diff --git a/.config/lychee.toml b/.config/lychee.toml
index b7b5b83f35bc57a835034d15334fa7a3ed933d51..1de9fcd559dd9ea14fb603b7740efebcb893ed93 100644
--- a/.config/lychee.toml
+++ b/.config/lychee.toml
@@ -51,5 +51,6 @@ exclude = [
 	"https://www.reddit.com/r/rust/comments/3spfh1/does_collect_allocate_more_than_once_while/",
 	# 403 rate limited:
 	"https://etherscan.io/block/11090290",
+	"https://subscan.io/",
 	"https://substrate.stackexchange.com/.*",
 ]
diff --git a/.config/zepter.yaml b/.config/zepter.yaml
index f701392d16b15aab8351b730efa13f3abffe2406..9b3bd9d618c14e41f1dbf420aff3fee1677e2830 100644
--- a/.config/zepter.yaml
+++ b/.config/zepter.yaml
@@ -25,9 +25,13 @@ workflows:
         '--show-path',
         '--quiet',
       ]
-  # Same as `check`, but with the `--fix` flag.
+  # The umbrella crate uses more features, so we to check those too:
+  check_umbrella:
+    - [ $check.0, '--features=serde,experimental,with-tracing,tuples-96,with-tracing', '-p=polkadot-sdk' ]
+  # Same as `check_*`, but with the `--fix` flag.
   default:
     - [ $check.0, '--fix' ]
+    - [ $check_umbrella.0, '--fix' ]
 
 # Will be displayed when any workflow fails:
 help:
diff --git a/.forklift/config-gitlab.toml b/.forklift/config-gitlab.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ab3b2729a46d4e54dc77df1175d4ebe79eda46d0
--- /dev/null
+++ b/.forklift/config-gitlab.toml
@@ -0,0 +1,33 @@
+[compression]
+type = "zstd"
+
+[compression.zstd]
+compressionLevel = 3
+
+[general]
+jobNameVariable = "CI_JOB_NAME"
+jobsBlackList = []
+logLevel = "warn"
+threadsCount = 6
+
+[cache]
+extraEnv = ["RUNTIME_METADATA_HASH"]
+
+[metrics]
+enabled = true
+pushEndpoint = "placeholder"
+
+[metrics.extraLabels]
+environment = "production"
+job_name = "$CI_JOB_NAME"
+project_name = "$CI_PROJECT_PATH"
+
+[storage]
+type = "s3"
+
+[storage.s3]
+accessKeyId = "placeholder"
+bucketName = "placeholder"
+concurrency = 10
+endpointUrl = "placeholder"
+secretAccessKey = "placeholder"
diff --git a/.forklift/config.toml b/.forklift/config.toml
index ab3b2729a46d4e54dc77df1175d4ebe79eda46d0..6f8eed8882ea36f39d1f0a519180f92eb905f7be 100644
--- a/.forklift/config.toml
+++ b/.forklift/config.toml
@@ -23,11 +23,7 @@ job_name = "$CI_JOB_NAME"
 project_name = "$CI_PROJECT_PATH"
 
 [storage]
-type = "s3"
+type = "gcs"
 
-[storage.s3]
-accessKeyId = "placeholder"
-bucketName = "placeholder"
-concurrency = 10
-endpointUrl = "placeholder"
-secretAccessKey = "placeholder"
+[storage.gcs]
+bucketName = "parity-ci-forklift"
diff --git a/.github/actions/set-up-gh/action.yml b/.github/actions/set-up-gh/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..fc16ce0b26334283b83266e381c1811738be87c9
--- /dev/null
+++ b/.github/actions/set-up-gh/action.yml
@@ -0,0 +1,36 @@
+name: 'install gh'
+description: 'Install the gh cli in a debian based distro and switches to the PR branch.'
+inputs:
+  pr-number:
+    description: "Number of the PR"
+    required: true
+  GH_TOKEN:
+    description: "GitHub token"
+    required: true
+outputs:
+  branch:
+    description: 'Branch name for the PR'
+    value: ${{ steps.branch.outputs.branch }}
+runs:
+  using: "composite"
+  steps:
+      - name: Instal gh cli
+        shell: bash
+        # Here it would get the script from previous step
+        run: |
+          (type -p wget >/dev/null || (apt update && apt-get install wget -y))
+          mkdir -p -m 755 /etc/apt/keyrings
+          wget -qO- https://cli.github.com/packages/githubcli-archive-keyring.gpg | tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null 
+          chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg
+          echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+          apt update
+          apt install gh -y
+          git config --global --add safe.directory '*'
+      - run: gh pr checkout ${{ inputs.pr-number }}
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ inputs.GH_TOKEN }}
+      - name: Export branch name
+        shell: bash
+        run: echo "branch=$(git rev-parse --abbrev-ref HEAD)" >> "$GITHUB_OUTPUT"
+        id: branch
diff --git a/.github/command-screnshot.png b/.github/command-screnshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..1451fabca8b975534778e8321facd261e3b803fb
Binary files /dev/null and b/.github/command-screnshot.png differ
diff --git a/.github/commands-readme.md b/.github/commands-readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..bf0e9e5ed20bb3085e6bbe3e59079372121167b1
--- /dev/null
+++ b/.github/commands-readme.md
@@ -0,0 +1,199 @@
+# Running commands
+
+Command bot has been migrated, it is no longer a comment parser and now it is a GitHub action that works as a [`workflow_dispatch`](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflow_dispatch) event.
+
+## How to run an action
+
+To run an action, you need to go to the [_actions tab_](https://github.com/paritytech/polkadot-sdk/actions) and pick the one you desire to run.
+
+The current available command actions are:
+
+- [Command FMT](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-fmt.yml)
+- [Command Update UI](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-update-ui.yml)
+- [Command Bench](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-bench.yml)
+- [Command Bench All](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-bench-all.yml)
+- [Command Bench Overhead](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-bench-overhead.yml)
+
+You need to select the action, and click on the dropdown that says: `Run workflow`. It is located in the upper right.
+
+If this dropdown is not visible, you may not have permission to run the action. Contact IT for help.
+
+![command screenshot](command-screnshot.png)
+
+Each command will have the same two required values, but it could have more.
+
+GitHub's official documentation: [Manually running a workflow](https://docs.github.com/en/actions/using-workflows/manually-running-a-workflow)
+
+### Number of the Pull Request
+
+The number of the pull request. Required so the action can fetch the correct branch and comment if it fails.
+
+## Action configurations
+
+### Bench
+
+Runs `benchmark pallet` or `benchmark overhead` against your PR and commits back updated weights.
+
+Posible combinations based on the `benchmark` dropdown.
+
+- `substrate-pallet`: Pallet Benchmark for Substrate for specific pallet
+  - Requires `Subcommand` to be `pallet`
+  - Requires `Runtime` to be `dev`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Target Directory` to be `substrate`
+- `polkadot-pallet`: Pallet Benchmark for Polkadot for specific pallet
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one of the following:
+    - `rococo`
+    - `westend`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Target Directory` to be `polkadot`
+- `cumulus-assets`: Pallet Benchmark for Cumulus assets
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one of the following:
+    - `asset-hub-westend`
+    - `asset-hub-rococo`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `assets`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-collectives`: Pallet Benchmark for Cumulus collectives
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be `collectives-westend`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `collectives`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-coretime`: Pallet Benchmark for Cumulus coretime
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one of the following:
+    - `coretime-rococo`
+    - `coretime-westend`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `coretime`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-bridge-hubs`: Pallet Benchmark for Cumulus bridge-hubs
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one of the following:
+    - `bridge-hub-rococo`
+    - `bridge-hub-westend`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `bridge-hub`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-contracts`: Pallet Benchmark for Cumulus contracts
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one `contracts-rococo`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `contracts`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-glutton`: Pallet Benchmark for Cumulus glutton
+  - Requires `Subcommand` to be `pallet`
+  - Requires `Runtime` to be one of the following:
+    - `glutton-westend`
+    - `glutton-westend-dev-1300`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `glutton`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-starters`: Pallet Benchmark for Cumulus starters
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one of the following:
+    - `seedling`
+    - `shell`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `starters`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-people`: Pallet Benchmark for Cumulus people
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one of the following:
+    - `people-westend`
+    - `people-rococo`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `people`
+  - Requires `Target Directory` to be `cumulus`
+- `cumulus-testing`: Pallet Benchmark for Cumulus testing
+  - Requires `Subcommand` to be one of the following:
+    - `pallet`
+    - `xcm`
+  - Requires `Runtime` to be one of the following:
+    - `penpal`
+    - `rococo-parachain`
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+  - Requires `Runtime Dir` to be `testing`
+  - Requires `Target Directory` to be `cumulus`
+
+### Bench-all
+
+This is a wrapper to run `bench` for all pallets.
+
+Posible combinations based on the `benchmark` dropdown.
+
+- `pallet`: Benchmark for Substrate/Polkadot/Cumulus/Trappist for specific pallet
+  - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
+- `substrate`: Pallet + Overhead + Machine Benchmark for Substrate for all pallets
+  - Requires `Target Directory` to be `substrate`
+- `polkadot`: Pallet + Overhead Benchmark for Polkadot
+  - Requires `Runtime` to be one of the following:
+    - `rococo`
+    - `westend`
+  - Requires `Target Directory` to be `polkadot`
+- `cumulus`: Pallet Benchmark for Cumulus
+  - Requires `Runtime` to be one of the following:
+    - `rococo`
+    - `westend`
+    - `asset-hub-kusama`
+    - `asset-hub-polkadot`
+    - `asset-hub-rococo`
+    - `asset-hub-westend`
+    - `bridge-hub-kusama`
+    - `bridge-hub-polkadot`
+    - `bridge-hub-rococo`
+    - `bridge-hub-westend`
+    - `collectives-polkadot`
+    - `collectives-westend`
+    - `coretime-rococo`
+    - `coretime-westend`
+    - `contracts-rococo`
+    - `glutton-kusama`
+    - `glutton-westend`
+    - `people-rococo`
+    - `people-westend`
+  - Requires `Target Directory` to be `cumulus`
+
+### Bench-overhead
+
+Run benchmarks overhead and commit back results to PR.
+
+Posible combinations based on the `benchmark` dropdown.
+
+- `default`: Runs `benchmark overhead` and commits back to PR the updated `extrinsic_weights.rs` files
+  - Requires `Runtime` to be one of the following:
+    - `rococo`
+    - `westend`
+  - Requires `Target directory` to be `polkadot`
+- `substrate`: Runs `benchmark overhead` and commits back to PR the updated `extrinsic_weights.rs` files
+  - Requires `Target directory` to be `substrate`
+- `cumulus`: Runs `benchmark overhead` and commits back to PR the updated `extrinsic_weights.rs` files
+  - Requires `Runtime` to be one of the following:
+    - `asset-hub-rococo`
+    - `asset-hub-westend`
+  - Requires `Target directory` to be `cumulus`
+
+## How to modify an action
+
+If you want to modify an action and test it, you can do by simply pushing your changes and then selecting your branch in the `Use worflow from` option.
+
+This will use a file from a specified branch.
diff --git a/.github/review-bot.yml b/.github/review-bot.yml
index ed719cefec8bc97c921e11a1751889433f0991ea..adbc480c6ba1a69e8cdd112af4be378849d26315 100644
--- a/.github/review-bot.yml
+++ b/.github/review-bot.yml
@@ -9,6 +9,7 @@ rules:
         - ^\.gitlab/.*
         - ^\.config/nextest.toml
         - ^\.cargo/.*
+        - ^\.forklift/.*
       exclude:
         - ^\.gitlab/pipeline/zombienet.*
     type: "or"
@@ -33,6 +34,7 @@ rules:
         - ^docker/.*
         - ^\.github/.*
         - ^\.gitlab/.*
+        - ^\.forklift/.*
         - ^\.config/nextest.toml
         - ^\.cargo/.*
     minApprovals: 2
diff --git a/.github/scripts/deny-git-deps.py b/.github/scripts/deny-git-deps.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b831c9347f75bdc3c74c80d3af652c37e7ae459
--- /dev/null
+++ b/.github/scripts/deny-git-deps.py
@@ -0,0 +1,40 @@
+"""
+Script to deny Git dependencies in the Cargo workspace. Can be passed one optional argument for the
+root folder. If not provided, it will use the cwd.
+
+## Usage
+	python3 .github/scripts/deny-git-deps.py polkadot-sdk
+"""
+
+import os
+import sys
+
+from cargo_workspace import Workspace, DependencyLocation
+
+KNOWN_BAD_GIT_DEPS = {
+	'simple-mermaid': ['xcm-docs'],
+	# Fix in <https://github.com/paritytech/polkadot-sdk/issues/2922>
+	'bandersnatch_vrfs': ['sp-core'],
+}
+
+root = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
+workspace = Workspace.from_path(root)
+
+def check_dep(dep, used_by):
+	if dep.location != DependencyLocation.GIT:
+		return
+	
+	if used_by in KNOWN_BAD_GIT_DEPS.get(dep.name, []):
+		print(f'🤨 Ignoring git dependency {dep.name} in {used_by}')
+	else:
+		print(f'🚫 Found git dependency {dep.name} in {used_by}')
+		sys.exit(1)	
+
+# Check the workspace dependencies that can be inherited:
+for dep in workspace.dependencies:
+	check_dep(dep, "workspace")
+
+# And the dependencies of each crate:
+for crate in workspace.crates:
+	for dep in crate.dependencies:
+		check_dep(dep, crate.name)
diff --git a/.github/workflows/check-changed-files.yml b/.github/workflows/check-changed-files.yml
new file mode 100644
index 0000000000000000000000000000000000000000..657c05cd047db40af642886eb2710e7324dd40ce
--- /dev/null
+++ b/.github/workflows/check-changed-files.yml
@@ -0,0 +1,57 @@
+# Reusable workflow to perform checks and generate conditions for other workflows. 
+# Currently it checks if any Rust (build-related) file is changed
+# and if the current (caller) workflow file is changed.
+# Example:
+#
+# jobs:
+#   changes:
+#     permissions:
+#       pull-requests: read
+#     uses: ./.github/workflows/check-changed-files.yml
+#   some-job:
+#     needs: changes
+#     if: ${{ needs.changes.outputs.rust }}
+#  ....... 
+
+name: Check changes files
+
+on:
+  workflow_call:
+    # Map the workflow outputs to job outputs
+    outputs:
+      rust: 
+        value: ${{ jobs.changes.outputs.rust }}
+        description: 'true if any of the build-related OR current (caller) workflow files have changed'
+      current-workflow: 
+        value: ${{ jobs.changes.outputs.current-workflow }}
+        description: 'true if current (caller) workflow file has changed'      
+
+jobs:
+  changes:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    outputs:
+      # true if current workflow (caller) file is changed
+      rust: ${{ steps.filter.outputs.rust == 'true' || steps.filter.outputs.current-workflow == 'true' }}
+      current-workflow: ${{ steps.filter.outputs.current-workflow }}
+    steps:
+    - id: current-file
+      run: echo "current-workflow-file=$(echo ${{ github.workflow_ref }} | sed -nE "s/.*(\.github\/workflows\/[a-zA-Z0-9_-]*\.y[a]?ml)@refs.*/\1/p")" >> $GITHUB_OUTPUT
+    - run: echo "${{ steps.current-file.outputs.current-workflow-file }}"
+      # For pull requests it's not necessary to checkout the code
+    - id: filter
+      uses: dorny/paths-filter@v3
+      with:
+        predicate-quantifier: 'every'
+        # current-workflow - check if the current (caller) workflow file is changed
+        # rust - check if any Rust (build-related) file is changed
+        filters: |
+          current-workflow:
+            - '${{ steps.current-file.outputs.current-workflow-file }}'
+          rust:
+            - '**/*'
+            - '!.github/**/*'
+            - '!prdoc/**/*'
+            - '!docs/**/*'
+    #
\ No newline at end of file
diff --git a/.github/workflows/check-features.yml b/.github/workflows/check-features.yml
index 53d6ac6b4dbfd7e3ccf1ca09ad9e1e70a49a9ff9..d34b3d52c5332b61d9a90dc03de938f154de5c7e 100644
--- a/.github/workflows/check-features.yml
+++ b/.github/workflows/check-features.yml
@@ -13,7 +13,7 @@ jobs:
       - name: Check
         uses: hack-ink/cargo-featalign-action@bea88a864d6ca7d0c53c26f1391ce1d431dc7f34 # v0.1.1
         with:
-          crate: substrate/bin/node/runtime
+          crate: templates/parachain/runtime/
           features: std,runtime-benchmarks,try-runtime
           ignore: sc-executor
           default-std: true
diff --git a/.github/workflows/check-runtime-migration.yml b/.github/workflows/check-runtime-migration.yml
index 984e264d0d1d1d9c8ac1730c51950194cce56276..33da5a8ecd591535eb0d4fe8b63cd8801699e988 100644
--- a/.github/workflows/check-runtime-migration.yml
+++ b/.github/workflows/check-runtime-migration.yml
@@ -11,13 +11,6 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
-env:
-  FORKLIFT_storage_s3_bucketName: ${{ secrets.FORKLIFT_storage_s3_bucketName }}
-  FORKLIFT_storage_s3_accessKeyId: ${{ secrets.FORKLIFT_storage_s3_accessKeyId }}
-  FORKLIFT_storage_s3_secretAccessKey: ${{ secrets.FORKLIFT_storage_s3_secretAccessKey }}
-  FORKLIFT_storage_s3_endpointUrl: ${{ secrets.FORKLIFT_storage_s3_endpointUrl }}
-  FORKLIFT_metrics_pushEndpoint: ${{ secrets.FORKLIFT_metrics_pushEndpoint }}
-
 jobs:
   set-image:
     # GitHub Actions allows using 'env' in a container context.
@@ -34,7 +27,7 @@ jobs:
   # rococo and westend are disabled for now (no access to parity-chains.parity.io)
   check-runtime-migration:
     runs-on: arc-runners-polkadot-sdk-beefy
-    timeout-minutes: 30
+    timeout-minutes: 40
     needs: [set-image]
     container:
       image: ${{ needs.set-image.outputs.IMAGE }}
diff --git a/.github/workflows/check-semver.yml b/.github/workflows/check-semver.yml
index f0e076e8a1683a0cb5a46aa9010ec9bd3d1bc898..04c63f4192b29ca1773d1018698b2abe6a666e1c 100644
--- a/.github/workflows/check-semver.yml
+++ b/.github/workflows/check-semver.yml
@@ -38,6 +38,7 @@ jobs:
         run: |
           export CARGO_TARGET_DIR=target
           export RUSTFLAGS='-A warnings -A missing_docs'
+          export SKIP_WASM_BUILD=1
           if ! parity-publish --color always prdoc --since old --validate prdoc/pr_$PR.prdoc --toolchain nightly-2024-03-01 -v; then
             cat <<EOF
           👋 Hello developer! The SemVer information that you declared in the prdoc file did not match what the CI detected.
diff --git a/.github/workflows/checks-quick.yml b/.github/workflows/checks-quick.yml
index 217adf40a391966c9482a691b94ffc719d2c65ab..e7d9ce1ef786591180d134cc694e59b95b874a7e 100644
--- a/.github/workflows/checks-quick.yml
+++ b/.github/workflows/checks-quick.yml
@@ -87,13 +87,15 @@ jobs:
       - name: install python deps
         run: |
           sudo apt-get update && sudo apt-get install -y python3-pip python3
-          pip3 install toml
+          pip3 install toml "cargo-workspace>=1.2.6"
       - name: check integrity
         run: >
           python3 .github/scripts/check-workspace.py .
           --exclude
           "substrate/frame/contracts/fixtures/build"
           "substrate/frame/contracts/fixtures/contracts/common"
+      - name: deny git deps
+        run: python3 .github/scripts/deny-git-deps.py .
   check-markdown:
     runs-on: ubuntu-latest
     timeout-minutes: 10
@@ -115,4 +117,34 @@ jobs:
           CONFIG: .github/.markdownlint.yaml
         run: |
           echo "Checking markdown formatting. More info: docs/contributor/markdown_linting.md"
+          echo "To fix potential erros, you can run 'markdownlint --config .github/.markdownlint.yaml -f --ignore target .' locally."
           markdownlint --config "$CONFIG" --ignore target .
+  check-umbrella:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    needs: [set-image]
+    container:
+      image: ${{ needs.set-image.outputs.IMAGE }}
+    steps:
+      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.0 (22. Sep 2023)
+      - name: install python deps
+        run: pip3 install "cargo-workspace>=1.2.4" toml
+      - name: check umbrella correctness
+        run: |
+          # Fixes "detected dubious ownership" error in the ci
+          git config --global --add safe.directory '*'
+          python3 scripts/generate-umbrella.py --sdk . --version 0.1.0
+          cargo +nightly fmt --all
+
+          if [ -n "$(git status --porcelain)" ]; then
+            cat <<EOF
+          👋 Hello developer! Apparently you added a new crate that is not part of the umbrella crate?
+
+          You can just apply the patch (git apply PATCH_NAME) that was printed to make this CI check succeed.
+
+          Otherwise feel free to ask in the Merge Request or in Matrix chat.
+          EOF
+
+            git diff
+            exit 1
+          fi
diff --git a/.github/workflows/command-bench-all.yml b/.github/workflows/command-bench-all.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b3fa0868c48797775c0ef8eff67e3acbd7f6facd
--- /dev/null
+++ b/.github/workflows/command-bench-all.yml
@@ -0,0 +1,97 @@
+name: Command Bench All
+
+on: 
+  workflow_dispatch: 
+    inputs:
+      pr:
+        description: Number of the Pull Request
+        required: true
+      benchmark:
+        description: Pallet benchmark
+        type: choice
+        required: true
+        options:
+          - pallet
+          - substrate
+          - polkadot
+          - cumulus
+      pallet:
+        description: Pallet
+        required: false
+        type: string
+        default: pallet_name
+      target_dir:
+        description: Target directory
+        type: choice
+        options:
+          - substrate
+          - polkadot
+          - cumulus
+      runtime:
+        description: Runtime
+        type: choice
+        options:
+          - rococo
+          - westend
+          - asset-hub-kusama
+          - asset-hub-polkadot
+          - asset-hub-rococo
+          - asset-hub-westend
+          - bridge-hub-kusama
+          - bridge-hub-polkadot
+          - bridge-hub-rococo
+          - bridge-hub-westend
+          - collectives-polkadot
+          - collectives-westend
+          - coretime-rococo
+          - coretime-westend
+          - contracts-rococo
+          - glutton-kusama
+          - glutton-westend
+          - people-rococo
+          - people-westend
+
+
+jobs:
+  set-image:     
+    runs-on: ubuntu-latest
+    outputs:
+      IMAGE: ${{ steps.set_image.outputs.IMAGE }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - id: set_image
+        run: cat .github/env >> $GITHUB_OUTPUT
+  cmd-bench-all:
+    needs: [set-image]
+    runs-on: arc-runners-polkadot-sdk-benchmark
+    container:
+      image: ${{ needs.set-image.outputs.IMAGE }}
+    steps:
+      - name: Download repo
+        uses: actions/checkout@v4
+      - name: Install gh cli
+        id: gh
+        uses: ./.github/actions/set-up-gh
+        with:
+          pr-number: ${{ inputs.pr }}
+          GH_TOKEN: ${{ github.token }}
+      - name: Run bench all
+        run: |
+          "./scripts/bench-all.sh" "${{ inputs.benchmark }}" --runtime "${{ inputs.runtime }}" --pallet "${{ inputs.pallet }}" --target_dir "${{ inputs.target_dir }}"
+      - name: Report failure
+        if: ${{ failure() }}
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Command failed ❌</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> failed. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
+      - run: git pull --rebase
+      - uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: cmd-action - ${{ github.workflow }}
+          branch: ${{ steps.gh.outputs.branch }}
+      - name: Report succeed
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Action completed 🎉🎉</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> completed 🎉. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-bench-overhead.yml b/.github/workflows/command-bench-overhead.yml
new file mode 100644
index 0000000000000000000000000000000000000000..735b401021061c3dde3dd065a12d9f6f538b8c93
--- /dev/null
+++ b/.github/workflows/command-bench-overhead.yml
@@ -0,0 +1,75 @@
+name: Command Bench Overhead
+
+on: 
+  workflow_dispatch: 
+    inputs:
+      pr:
+        description: Number of the Pull Request
+        required: true
+      benchmark:
+        description: Pallet benchmark
+        type: choice
+        required: true
+        options:
+          - default
+          - substrate
+          - cumulus
+      runtime:
+        description: Runtime
+        type: choice
+        options:
+          - rococo
+          - westend
+          - asset-hub-rococo
+          - asset-hub-westend
+      target_dir:
+        description: Target directory
+        type: choice
+        options:
+          - polkadot
+          - substrate
+          - cumulus
+
+jobs:
+  set-image:     
+    runs-on: ubuntu-latest
+    outputs:
+      IMAGE: ${{ steps.set_image.outputs.IMAGE }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - id: set_image
+        run: cat .github/env >> $GITHUB_OUTPUT
+  cmd-bench-overhead:
+    needs: [set-image]
+    runs-on: arc-runners-polkadot-sdk-benchmark
+    container:
+      image: ${{ needs.set-image.outputs.IMAGE }}
+    steps:
+      - name: Download repo
+        uses: actions/checkout@v4
+      - name: Install gh cli
+        id: gh
+        uses: ./.github/actions/set-up-gh
+        with:
+          pr-number: ${{ inputs.pr }}
+          GH_TOKEN: ${{ github.token }}
+      - name: Run bench overhead
+        run: |
+          "./scripts/bench.sh" "${{ inputs.benchmark }}" --subcommand "overhead" --runtime "${{ inputs.runtime }}" --target_dir "${{ inputs.target_dir }}"
+      - name: Report failure
+        if: ${{ failure() }}
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Command failed ❌</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> failed. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
+      - run: git pull --rebase
+      - uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: cmd-action - ${{ github.workflow }}
+          branch: ${{ steps.gh.outputs.branch }}
+      - name: Report succeed
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Action completed 🎉🎉</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> completed 🎉. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-bench.yml b/.github/workflows/command-bench.yml
new file mode 100644
index 0000000000000000000000000000000000000000..0ff166be48c193aa00e858b3bf7138b856487e24
--- /dev/null
+++ b/.github/workflows/command-bench.yml
@@ -0,0 +1,122 @@
+name: Command Bench
+
+on: 
+  workflow_dispatch: 
+    inputs:
+      pr:
+        description: Number of the Pull Request
+        required: true
+      benchmark:
+        description: Pallet benchmark
+        type: choice
+        required: true
+        options:
+          - substrate-pallet
+          - polkadot-pallet
+          - cumulus-assets
+          - cumulus-collectives
+          - cumulus-coretime
+          - cumulus-bridge-hubs
+          - cumulus-contracts
+          - cumulus-glutton
+          - cumulus-starters
+          - cumulus-people
+          - cumulus-testing
+      subcommand:
+        description: Subcommand
+        type: choice
+        required: true
+        options:
+          - pallet
+          - xcm
+      runtime:
+        description: Runtime
+        type: choice
+        options:
+          - dev
+          - rococo
+          - westend
+          - asset-hub-westend
+          - asset-hub-rococo
+          - collectives-westend
+          - coretime-rococo
+          - coretime-westend
+          - bridge-hub-rococo
+          - bridge-hub-westend
+          - contracts-rococo
+          - glutton-westend
+          - glutton-westend-dev-1300
+          - seedling
+          - shell
+          - people-westend
+          - people-rococo
+          - penpal
+          - rococo-parachain
+      pallet:
+        description: Pallet
+        type: string
+        default: pallet_name
+      target_dir:
+        description: Target directory
+        type: choice
+        options:
+          - substrate
+          - polkadot
+          - cumulus
+      runtime_dir:
+        description: Runtime directory
+        type: choice
+        options:
+          - people
+          - collectives
+          - coretime
+          - bridge-hubs
+          - contracts
+          - glutton
+          - starters
+          - testing
+
+
+jobs:
+  set-image:     
+    runs-on: ubuntu-latest
+    outputs:
+      IMAGE: ${{ steps.set_image.outputs.IMAGE }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - id: set_image
+        run: cat .github/env >> $GITHUB_OUTPUT
+  cmd-bench:
+    needs: [set-image]
+    runs-on: arc-runners-polkadot-sdk-benchmark
+    container:
+      image: ${{ needs.set-image.outputs.IMAGE }}
+    steps:
+      - name: Download repo
+        uses: actions/checkout@v4
+      - name: Install gh cli
+        id: gh
+        uses: ./.github/actions/set-up-gh
+        with:
+          pr-number: ${{ inputs.pr }}
+          GH_TOKEN: ${{ github.token }}
+      - name: Run bench
+        run: |
+          "./scripts/bench.sh" "${{ inputs.benchmark }}" --runtime "${{ inputs.runtime }}" --pallet "${{ inputs.pallet }}" --target_dir "${{ inputs.target_dir }}" --subcommand "${{ inputs.subcommand }}" --runtime_dir "${{ inputs.runtime_dir }}"
+      - name: Report failure
+        if: ${{ failure() }}
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Command failed ❌</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> failed. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
+      - run: git pull --rebase
+      - uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: cmd-action - ${{ github.workflow }}
+          branch: ${{ steps.gh.outputs.branch }}
+      - name: Report succeed
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Action completed 🎉🎉</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> completed 🎉. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-fmt.yml b/.github/workflows/command-fmt.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d415007d938390ded98a95f5f5c8ecc61fb0dc84
--- /dev/null
+++ b/.github/workflows/command-fmt.yml
@@ -0,0 +1,54 @@
+name: Command FMT
+
+on: 
+  workflow_dispatch: 
+    inputs:
+      pr:
+        description: Number of the Pull Request
+        required: true
+
+jobs:
+  set-image:     
+    runs-on: ubuntu-latest
+    outputs:
+      IMAGE: ${{ steps.set_image.outputs.IMAGE }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - id: set_image
+        run: cat .github/env >> $GITHUB_OUTPUT
+  cmd-fmt:
+    needs: [set-image]
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ needs.set-image.outputs.IMAGE }}
+    steps:
+      - name: Download repo
+        uses: actions/checkout@v4
+      - name: Install gh cli
+        id: gh
+        uses: ./.github/actions/set-up-gh
+        with:
+          pr-number: ${{ inputs.pr }}
+          GH_TOKEN: ${{ github.token }}
+      - name: Run FMT
+        run: |
+          # format toml.
+          # since paritytech/ci-unified:bullseye-1.73.0-2023-11-01-v20231204 includes taplo-cli
+          taplo format --config .config/taplo.toml
+      - name: Report failure
+        if: ${{ failure() }}
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Command failed ❌</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> failed. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
+      - run: git pull --rebase
+      - uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: cmd-action - ${{ github.workflow }}
+          branch: ${{ steps.gh.outputs.branch }}
+      - name: Report succeed
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Action completed 🎉🎉</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> completed 🎉. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-inform.yml b/.github/workflows/command-inform.yml
new file mode 100644
index 0000000000000000000000000000000000000000..1c7323c998dfee3ba822f4bcb655c57a958fd80f
--- /dev/null
+++ b/.github/workflows/command-inform.yml
@@ -0,0 +1,15 @@
+name: Inform of new command action
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Inform that the new command exist
+      if: ${{ github.event.issue.pull_request && startsWith(github.event.comment.body, 'bot ') }}
+      run: gh pr comment ${{ github.event.issue.number }} --body 'We are migrating this bot to be a GitHub Action<br/><br/>Please, see the <a href="https://github.com/paritytech/polkadot-sdk/blob/master/.github/commands-readme.md">documentation on how to use it</a>'
+      env:
+        GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-update-ui.yml b/.github/workflows/command-update-ui.yml
new file mode 100644
index 0000000000000000000000000000000000000000..9b9c45c5c0b9d78f0287b8d00314e0c58fff0c69
--- /dev/null
+++ b/.github/workflows/command-update-ui.yml
@@ -0,0 +1,55 @@
+name: Command Update UI
+
+on: 
+  workflow_dispatch: 
+    inputs:
+      pr:
+        description: Number of the Pull Request
+        required: true
+      rust-version:
+        description: Version of rust. Example 1.70
+        required: false
+
+jobs:
+  set-image:     
+    runs-on: ubuntu-latest
+    outputs:
+      IMAGE: ${{ steps.set_image.outputs.IMAGE }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - id: set_image
+        run: cat .github/env >> $GITHUB_OUTPUT
+  cmd-update-ui:
+    needs: [set-image]
+    runs-on: arc-runners-polkadot-sdk-beefy
+    container:
+      image: ${{ needs.set-image.outputs.IMAGE }}
+    steps:
+      - name: Download repo
+        uses: actions/checkout@v4
+      - name: Install gh cli
+        id: gh
+        uses: ./.github/actions/set-up-gh
+        with:
+          pr-number: ${{ inputs.pr }}
+          GH_TOKEN: ${{ github.token }}
+      - name: Run update-ui
+        run: |
+          "./scripts/update-ui-tests.sh" "${{ inputs.rust-version }}"
+      - name: Report failure
+        if: ${{ failure() }}
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Command failed ❌</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> failed. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
+      - run: git pull --rebase
+      - uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: cmd-action - ${{ github.workflow }}
+          branch: ${{ steps.gh.outputs.branch }}
+      - name: Report succeed
+        run: gh pr comment ${{ inputs.pr }} --body "<h2>Action completed 🎉🎉</h2> Run by @${{ github.actor }} for <code>${{ github.workflow }}</code> completed 🎉. See logs <a href=\"$RUN\">here</a>."
+        env:
+          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/misc-sync-templates.yml b/.github/workflows/misc-sync-templates.yml
index 3617d6c34a3e342e1abd52acaffbf3a8c61ec43b..d8027014863936ffd6c6a217f282dfa45bc2edd7 100644
--- a/.github/workflows/misc-sync-templates.yml
+++ b/.github/workflows/misc-sync-templates.yml
@@ -104,10 +104,6 @@ jobs:
 
           toml set templates/${{ matrix.template }}/Cargo.toml 'workspace.package.edition' "$(toml get --raw Cargo.toml 'workspace.package.edition')" > Cargo.temp
           mv Cargo.temp ./templates/${{ matrix.template }}/Cargo.toml
-
-          toml get Cargo.toml 'workspace.lints' --output-toml >> ./templates/${{ matrix.template }}/Cargo.toml
-
-          toml get Cargo.toml 'workspace.dependencies' --output-toml >> ./templates/${{ matrix.template }}/Cargo.toml
         working-directory: polkadot-sdk
       - name: Print the result Cargo.tomls for debugging
         if: runner.debug == '1'
@@ -120,6 +116,18 @@ jobs:
       - name: Copy over the new changes
         run: |
           cp -r polkadot-sdk/templates/${{ matrix.template }}/* "${{ env.template-path }}/"
+      - name: Copy over required workspace dependencies
+        run: |
+          echo -e "\n[workspace.dependencies]" >> Cargo.toml
+          set +e
+          # If a workspace dependency is required..
+          while cargo tree --depth 1 --prefix none --no-dedupe 2>&1 | grep 'was not found in `workspace.dependencies`'; do
+            # Get its name..
+            missing_dep=$(cargo tree --depth 1 --prefix none --no-dedupe 2>&1 | grep 'was not found in `workspace.dependencies`' | sed -E 's/(.*)`dependency.(.*)` was not found in `workspace.dependencies`/\2/')
+            # And copy the dependency from the monorepo.
+            toml get ../polkadot-sdk/Cargo.toml 'workspace.dependencies' --output-toml | grep "^${missing_dep} = " >> Cargo.toml
+          done;
+        working-directory: "${{ env.template-path }}"
 
       # 3. Verify the build. Push the changes or create a PR.
 
@@ -148,12 +156,12 @@ jobs:
           token: ${{ steps.app_token.outputs.token }}
           add-paths: |
             ./*
-          title: "[Don't merge] Update the ${{ matrix.template }} template"
+          title: "[Don't merge] Update the ${{ matrix.template }} template to ${{ github.event.inputs.crate_release_version }}"
           body: "The template has NOT been successfully built and needs to be inspected."
-          branch: "update-template/${{ github.event_name }}"
+          branch: "update-template/${{ github.event.inputs.crate_release_version }}"
       - name: Push changes
         run: |
           git add -A .
-          git commit --allow-empty -m "Update template triggered by ${{ github.event_name }}"
+          git commit --allow-empty -m "Update to ${{ github.event.inputs.crate_release_version }} triggered by ${{ github.event_name }}"
           git push
         working-directory: "${{ env.template-path }}"
diff --git a/.github/workflows/release-30_publish_release_draft.yml b/.github/workflows/release-30_publish_release_draft.yml
index a9e521051d04079a49af76c78681af8ae52ae5da..20492f2d3a9104fd08af663d19aed9a301918e6c 100644
--- a/.github/workflows/release-30_publish_release_draft.yml
+++ b/.github/workflows/release-30_publish_release_draft.yml
@@ -23,13 +23,40 @@ jobs:
           echo "stable=$RUST_STABLE_VERSION" >> $GITHUB_OUTPUT
 
   build-runtimes:
-    uses: "./.github/workflows/srtool.yml"
+    uses: "./.github/workflows/release-srtool.yml"
     with:
        excluded_runtimes: "substrate-test bp cumulus-test kitchensink minimal-template parachain-template penpal polkadot-test seedling shell frame-try sp solochain-template"
 
+  build-binaries:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        # Tuples of [package, binary-name]
+        binary: [ [frame-omni-bencher, frame-omni-bencher], [staging-chain-spec-builder, chain-spec-builder] ]
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
+
+      - name: Install protobuf-compiler
+        run: |
+          sudo apt update
+          sudo apt install -y protobuf-compiler
+
+      - name: Build ${{ matrix.binary[1] }} binary
+        run: |
+          cargo build --locked --profile=production -p ${{ matrix.binary[0] }} --bin ${{ matrix.binary[1] }}
+          target/production/${{ matrix.binary[1] }} --version
+
+      - name: Upload ${{ matrix.binary[1] }} binary
+        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
+        with:
+          name: ${{ matrix.binary[1] }}
+          path: target/production/${{ matrix.binary[1] }}
+
+
   publish-release-draft:
     runs-on: ubuntu-latest
-    needs: [get-rust-versions, build-runtimes]
+    needs: [ get-rust-versions, build-runtimes ]
     outputs:
       release_url: ${{ steps.create-release.outputs.html_url }}
       asset_upload_url: ${{ steps.create-release.outputs.upload_url }}
@@ -37,15 +64,15 @@ jobs:
       - name: Checkout
         uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
 
+      - name: Download artifacts
+        uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4
+
       - name: Prepare tooling
         run: |
           URL=https://github.com/chevdor/tera-cli/releases/download/v0.2.4/tera-cli_linux_amd64.deb
           wget $URL -O tera.deb
           sudo dpkg -i tera.deb
 
-      - name: Download artifacts
-        uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4
-
       - name: Prepare draft
         id: draft
         env:
@@ -129,6 +156,30 @@ jobs:
           asset_name: ${{ matrix.chain }}_runtime-v${{ env.SPEC }}.compact.compressed.wasm
           asset_content_type: application/wasm
 
+  publish-binaries:
+    needs: [ publish-release-draft, build-binaries ]
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        binary: [frame-omni-bencher, chain-spec-builder]
+
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4
+        with:
+          name: ${{ matrix.binary }}
+
+      - name: Upload ${{ matrix.binary }} binary
+        uses: actions/upload-release-asset@e8f9f06c4b078e705bd2ea027f0926603fc9b4d5 #v1.0.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.publish-release-draft.outputs.asset_upload_url }}
+          asset_path:  ${{ github.workspace}}/${{ matrix.binary }}
+          asset_name:  ${{ matrix.binary }}
+          asset_content_type: application/octet-stream
+
   post_to_matrix:
     runs-on: ubuntu-latest
     needs: publish-release-draft
diff --git a/.github/workflows/release-50_publish-docker.yml b/.github/workflows/release-50_publish-docker.yml
index 67e93ee96574de1f1e3e29f1bf6d90085865100d..4679f58578f7906b75e4a3d6d623ebc1d55df40d 100644
--- a/.github/workflows/release-50_publish-docker.yml
+++ b/.github/workflows/release-50_publish-docker.yml
@@ -27,6 +27,7 @@ on:
         options:
           - polkadot
           - polkadot-parachain
+          - chain-spec-builder
 
       release_id:
         description: |
@@ -74,7 +75,7 @@ env:
 
 jobs:
   fetch-artifacts: # this job will be triggered for the polkadot-parachain rc and release or polkadot rc image build
-    if: ${{ inputs.binary == 'polkadot-parachain' || inputs.image_type == 'rc' }}
+    if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'chain-spec-builder' || inputs.image_type == 'rc' }}
     runs-on: ubuntu-latest
 
     steps:
@@ -97,7 +98,7 @@ jobs:
 
       - name: Fetch rc artifacts or release artifacts from s3 based on version
         #this step runs only if the workflow is triggered manually
-        if: ${{ env.EVENT_NAME  == 'workflow_dispatch' }}
+        if: ${{ env.EVENT_NAME  == 'workflow_dispatch' && inputs.binary != 'chain-spec-builder'}}
         run: |
           . ./.github/scripts/common/lib.sh
 
@@ -106,15 +107,22 @@ jobs:
 
           fetch_release_artifacts_from_s3
 
-      - name: Cache the artifacts
-        uses: actions/cache@e12d46a63a90f2fae62d114769bbf2a179198b5c # v3.3.3
+      - name: Fetch chain-spec-builder rc artifacts or release artifacts based on release id
+        #this step runs only if the workflow is triggered manually and only for chain-spec-builder
+        if: ${{ env.EVENT_NAME  == 'workflow_dispatch' && inputs.binary == 'chain-spec-builder' }}
+        run: |
+          . ./.github/scripts/common/lib.sh
+          RELEASE_ID=$(check_release_id "${{ inputs.release_id }}")
+          fetch_release_artifacts
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1
         with:
-          key: artifacts-${{ env.BINARY }}-${{ github.sha }}
-          path: |
-            ./release-artifacts/${{ env.BINARY }}/**/*
+          name: release-artifacts
+          path: release-artifacts/${{ env.BINARY }}/**/*
 
   build-container: # this job will be triggered for the polkadot-parachain rc and release or polkadot rc image build
-    if: ${{ inputs.binary == 'polkadot-parachain' || inputs.image_type == 'rc' }}
+    if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'chain-spec-builder' || inputs.image_type == 'rc' }}
     runs-on: ubuntu-latest
     needs: fetch-artifacts
     environment: release
@@ -123,26 +131,23 @@ jobs:
       - name: Checkout sources
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
 
-      - name: Get artifacts from cache
-        uses: actions/cache@e12d46a63a90f2fae62d114769bbf2a179198b5c # v3.3.3
-        with:
-          key: artifacts-${{ env.BINARY }}-${{ github.sha }}
-          fail-on-cache-miss: true
-          path: |
-            ./release-artifacts/${{ env.BINARY }}/**/*
+      - name: Download artifacts
+        uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4
 
       - name: Check sha256 ${{ env.BINARY }}
-        working-directory: ./release-artifacts/${{ env.BINARY }}
+        if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'polkadot' }}
+        working-directory: release-artifacts
         run: |
-          . ../../.github/scripts/common/lib.sh
+          . ../.github/scripts/common/lib.sh
 
           echo "Checking binary $BINARY"
           check_sha256 $BINARY && echo "OK" || echo "ERR"
 
       - name: Check GPG ${{ env.BINARY }}
-        working-directory: ./release-artifacts/${{ env.BINARY }}
+        if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'polkadot' }}
+        working-directory: release-artifacts
         run: |
-          . ../../.github/scripts/common/lib.sh
+          . ../.github/scripts/common/lib.sh
           import_gpg_keys
           check_gpg $BINARY
 
@@ -164,20 +169,21 @@ jobs:
           echo "No tag, doing without"
 
       - name: Fetch release tags
-        working-directory: ./release-artifacts/${{ env.BINARY }}
+        working-directory: release-artifacts
         if: ${{ env.IMAGE_TYPE == 'release'}}
         id: fetch_release_refs
         run: |
           chmod a+rx $BINARY
-          VERSION=$(./$BINARY --version | awk '{ print $2 }' )
+          [[ $BINARY != 'chain-spec-builder' ]] && VERSION=$(./$BINARY --version | awk '{ print $2 }' )
+
           release=$( echo $VERSION | cut -f1 -d- )
           echo "tag=latest" >> $GITHUB_OUTPUT
           echo "release=${release}" >> $GITHUB_OUTPUT
 
-      - name: Build Injected Container image for polkadot rc
-        if: ${{ env.BINARY == 'polkadot' }}
+      - name: Build Injected Container image for polkadot rc or chain-spec-builder
+        if: ${{ env.BINARY == 'polkadot' || env.BINARY == 'chain-spec-builder' }}
         env:
-          ARTIFACTS_FOLDER: ./release-artifacts
+          ARTIFACTS_FOLDER: release-artifacts
           IMAGE_NAME: ${{ env.BINARY }}
           OWNER: ${{ env.DOCKER_OWNER }}
           TAGS: ${{ join(steps.fetch_rc_refs.outputs.*, ',') || join(steps.fetch_release_refs.outputs.*, ',') }}
@@ -189,7 +195,7 @@ jobs:
       - name: Build Injected Container image for polkadot-parachain
         if: ${{ env.BINARY == 'polkadot-parachain' }}
         env:
-          ARTIFACTS_FOLDER: ./release-artifacts
+          ARTIFACTS_FOLDER: release-artifacts
           IMAGE_NAME: ${{ env.BINARY }}
           OWNER: ${{ env.DOCKER_OWNER }}
           DOCKERFILE: docker/dockerfiles/polkadot-parachain/polkadot-parachain_injected.Dockerfile
@@ -219,7 +225,11 @@ jobs:
           RELEASE_TAG: ${{ steps.fetch_rc_refs.outputs.release || steps.fetch_release_refs.outputs.release  }}
         run: |
           echo "Checking tag ${RELEASE_TAG} for image ${REGISTRY}/${DOCKER_OWNER}/${BINARY}"
-          $ENGINE run -i ${REGISTRY}/${DOCKER_OWNER}/${BINARY}:${RELEASE_TAG} --version
+          if [[ ${BINARY} == 'chain-spec-builder' ]]; then
+            $ENGINE run -i ${REGISTRY}/${DOCKER_OWNER}/${BINARY}:${RELEASE_TAG}
+          else
+            $ENGINE run -i ${REGISTRY}/${DOCKER_OWNER}/${BINARY}:${RELEASE_TAG} --version
+          fi
 
   fetch-latest-debian-package-version: # this job will be triggered for polkadot release build
     if: ${{ inputs.binary == 'polkadot' && inputs.image_type == 'release' }}
diff --git a/.github/workflows/release-build-and-attach-runtimes.yml b/.github/workflows/release-build-and-attach-runtimes.yml
deleted file mode 100644
index 680a9ecffd312dba61c2eaee3a3e2e6a9d5b136c..0000000000000000000000000000000000000000
--- a/.github/workflows/release-build-and-attach-runtimes.yml
+++ /dev/null
@@ -1,65 +0,0 @@
-name: Build and Attach Runtimes to Releases/RC
-
-on:
-  release:
-    types:
-      - published
-
-env:
-  PROFILE: production
-
-jobs:
-  build_and_upload:
-    strategy:
-      matrix:
-        runtime:
-          - { name: westend, package: westend-runtime, path: polkadot/runtime/westend }
-          - { name: rococo, package: rococo-runtime, path: polkadot/runtime/rococo }
-          - { name: asset-hub-rococo, package: asset-hub-rococo-runtime, path: cumulus/parachains/runtimes/assets/asset-hub-rococo }
-          - { name: asset-hub-westend, package: asset-hub-westend-runtime, path: cumulus/parachains/runtimes/assets/asset-hub-westend }
-          - { name: bridge-hub-rococo, package: bridge-hub-rococo-runtime, path: cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo }
-          - { name: contracts-rococo, package: contracts-rococo-runtime, path: cumulus/parachains/runtimes/contracts/contracts-rococo }
-          - { name: collectives-westend, package: collectives-westend-runtime, path: cumulus/parachains/runtimes/collectives/collectives-westend }
-          - { name: glutton-westend, package: glutton-westend-runtime, path: cumulus/parachains/runtimes/glutton/glutton-westend }
-        build_config:
-          # Release build has logging disabled and no dev features
-          - { type: on-chain-release, opts: --features on-chain-release-build }
-          # Debug build has logging enabled and developer features
-          - { type: dev-debug-build, opts: --features try-runtime }
-
-    runs-on: ubuntu-22.04
-
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-    - name: Build ${{ matrix.runtime.name }} ${{ matrix.build_config.type }}
-      id: srtool_build
-      uses: chevdor/srtool-actions@v0.9.2
-      env:
-        BUILD_OPTS: ${{ matrix.build_config.opts }}
-      with:
-        chain: ${{ matrix.runtime.name }}
-        package: ${{ matrix.runtime.package }}
-        runtime_dir: ${{ matrix.runtime.path }}
-        profile: ${{ env.PROFILE }}
-
-    - name: Set up paths and runtime names
-      id: setup
-      run: |
-        RUNTIME_BLOB_NAME=$(echo ${{ matrix.runtime.package }} | sed 's/-/_/g').compact.compressed.wasm
-        PREFIX=${{ matrix.build_config.type == 'dev-debug-build' && 'DEV_DEBUG_BUILD__' || '' }}
-
-        echo "RUNTIME_BLOB_NAME=$RUNTIME_BLOB_NAME" >> $GITHUB_ENV
-        echo "ASSET_PATH=./${{ matrix.runtime.path }}/target/srtool/${{ env.PROFILE }}/wbuild/${{ matrix.runtime.package }}/$RUNTIME_BLOB_NAME" >> $GITHUB_ENV
-        echo "ASSET_NAME=$PREFIX$RUNTIME_BLOB_NAME" >> $GITHUB_ENV
-
-    - name: Upload Runtime to Release
-      uses: actions/upload-release-asset@v1
-      with:
-        upload_url: ${{ github.event.release.upload_url }}
-        asset_path: ${{ env.ASSET_PATH }}
-        asset_name: ${{ env.ASSET_NAME }}
-        asset_content_type: application/octet-stream
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/release-clobber-stable.yml b/.github/workflows/release-clobber-stable.yml
new file mode 100644
index 0000000000000000000000000000000000000000..643c14daa15b1aa7501e27f272524e0ee010e781
--- /dev/null
+++ b/.github/workflows/release-clobber-stable.yml
@@ -0,0 +1,70 @@
+name: Clobber Stable
+
+# This action implements the
+# [Clobbering](https://github.com/paritytech/polkadot-sdk/blob/master/docs/RELEASE.md#clobbering)
+# process from the release process. It pushes a new commit to the `stable` branch with all the
+# current content of the `audited` tag. It does not use a merge commit, but rather 'clobbers' the
+# branch with a single commit that contains all the changes. It has a naming scheme of `Clobber with
+# audited ($COMMIT)`.  
+# Currently, the script is only triggered manually, but can be easily changed to a schedule.
+
+on:
+  workflow_dispatch:
+
+permissions:
+    contents: write
+
+jobs:
+  clobber-stable:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    env:
+        STABLE: stable
+        UNSTABLE: master
+        AUDITED: audited
+    steps:
+    - name: Checkout
+      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+    
+    - name: Prechecks
+      run: |
+        # Properly fetch
+        git fetch --prune --unshallow origin tag $AUDITED
+        git fetch origin $STABLE
+
+        # Sanity checks
+        git checkout -q tags/$AUDITED || (echo "Could not find the '$AUDITED' tag." && exit 1)
+        COMMIT=$(git rev-parse tags/$AUDITED)
+        #$(git branch --contains $COMMIT | grep -q $UNSTABLE) || (echo "The '$AUDITED' tag is not on the '$UNSTABLE' branch." && exit 1)
+
+        git config --global user.email "admin@parity.io"
+        git config --global user.name "Parity Release Team"
+
+    - name: Prepare commit
+      run: |
+        git checkout --quiet origin/$STABLE
+
+        # Delete all tracked files in the working directory
+        git ls-files -z | xargs -0 rm -f
+
+        # Find and delete any empty directories
+        find . -type d -empty -delete
+
+        git add . 1>/dev/null 2>/dev/null
+        git commit -qm "Delete all files"
+
+        # Grab the files from the commit
+        git checkout --quiet tags/$AUDITED -- .
+
+        # Stage, commit, and push the working directory which now matches 'audited' 1:1
+        git status
+        COMMIT=$(git rev-parse --short=10 tags/$AUDITED)
+        git add . 1>/dev/null 2>/dev/null
+        git commit --allow-empty --amend -qm "Clobber with $AUDITED ($COMMIT)"
+        
+    - name: Push stable branch
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: |
+        git log -3
+        git push --verbose origin HEAD:$STABLE
diff --git a/.github/workflows/release-srtool.yml b/.github/workflows/release-srtool.yml
index 95b1846b98e0c47cc6de2c92cadc16adc0cab487..69a4bdbdda9ae87a188a23bceb9185d813424a98 100644
--- a/.github/workflows/release-srtool.yml
+++ b/.github/workflows/release-srtool.yml
@@ -6,8 +6,6 @@ env:
 
 on:
   push:
-    tags:
-      - "*"
     branches:
       - release-v[0-9]+.[0-9]+.[0-9]+*
       - release-cumulus-v[0-9]+*
diff --git a/.github/workflows/tests-linux-stable.yml b/.github/workflows/tests-linux-stable.yml
index 8822ba6d250ac5c858e22cdd98027d6a89e0634d..6f2ac87c3efbea16efc9a5564fa770cd0f9ffbdf 100644
--- a/.github/workflows/tests-linux-stable.yml
+++ b/.github/workflows/tests-linux-stable.yml
@@ -12,18 +12,18 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
-env:
-  FORKLIFT_storage_s3_bucketName: ${{ secrets.FORKLIFT_storage_s3_bucketName }}
-  FORKLIFT_storage_s3_accessKeyId: ${{ secrets.FORKLIFT_storage_s3_accessKeyId }}
-  FORKLIFT_storage_s3_secretAccessKey: ${{ secrets.FORKLIFT_storage_s3_secretAccessKey }}
-  FORKLIFT_storage_s3_endpointUrl: ${{ secrets.FORKLIFT_storage_s3_endpointUrl }}
-  FORKLIFT_metrics_pushEndpoint: ${{ secrets.FORKLIFT_metrics_pushEndpoint }}
-
 jobs:
+  changes:
+    permissions:
+      pull-requests: read
+    uses: ./.github/workflows/check-changed-files.yml
+
   set-image:
     # GitHub Actions allows using 'env' in a container context.
     # However, env variables don't work for forks: https://github.com/orgs/community/discussions/44322
     # This workaround sets the container image for each job using 'set-image' job output.
+    needs: changes
+    if: ${{ needs.changes.outputs.rust }}
     runs-on: ubuntu-latest
     outputs:
       IMAGE: ${{ steps.set_image.outputs.IMAGE }}
@@ -32,10 +32,12 @@ jobs:
         uses: actions/checkout@v4
       - id: set_image
         run: cat .github/env >> $GITHUB_OUTPUT
+
   test-linux-stable-int:
+    needs: [set-image, changes]
+    if: ${{ needs.changes.outputs.rust }}
     runs-on: arc-runners-polkadot-sdk-beefy
     timeout-minutes: 30
-    needs: [set-image]
     container:
       image: ${{ needs.set-image.outputs.IMAGE }}
     env:
@@ -50,11 +52,13 @@ jobs:
         uses: actions/checkout@v4
       - name: script
         run: WASM_BUILD_NO_COLOR=1 time forklift cargo test -p staging-node-cli --release --locked -- --ignored
+
   # https://github.com/paritytech/ci_cd/issues/864
   test-linux-stable-runtime-benchmarks:
+    needs: [set-image, changes]
+    if: ${{ needs.changes.outputs.rust }}
     runs-on: arc-runners-polkadot-sdk-beefy
     timeout-minutes: 30
-    needs: [set-image]
     container:
       image: ${{ needs.set-image.outputs.IMAGE }}
     env:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 76bccba86b21c136cbb2bf15f44e701cc69af4ab..0c1447cba33a372cbbf4cb057b9f63dd49565468 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -11,14 +11,12 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
-env:
-  FORKLIFT_storage_s3_bucketName: ${{ secrets.FORKLIFT_storage_s3_bucketName }}
-  FORKLIFT_storage_s3_accessKeyId: ${{ secrets.FORKLIFT_storage_s3_accessKeyId }}
-  FORKLIFT_storage_s3_secretAccessKey: ${{ secrets.FORKLIFT_storage_s3_secretAccessKey }}
-  FORKLIFT_storage_s3_endpointUrl: ${{ secrets.FORKLIFT_storage_s3_endpointUrl }}
-  FORKLIFT_metrics_pushEndpoint: ${{ secrets.FORKLIFT_metrics_pushEndpoint }}
-
 jobs:
+  changes:
+    permissions:
+      pull-requests: read
+    uses: ./.github/workflows/check-changed-files.yml
+
   set-image:
     # GitHub Actions allows using 'env' in a container context.
     # However, env variables don't work for forks: https://github.com/orgs/community/discussions/44322
@@ -31,10 +29,12 @@ jobs:
         uses: actions/checkout@v4
       - id: set_image
         run: cat .github/env >> $GITHUB_OUTPUT
+
   quick-benchmarks:
+    needs: [set-image, changes]
+    if: ${{ needs.changes.outputs.rust }}
     runs-on: arc-runners-polkadot-sdk-beefy
     timeout-minutes: 30
-    needs: [set-image]
     container:
       image: ${{ needs.set-image.outputs.IMAGE }}
     env:
@@ -47,11 +47,13 @@ jobs:
         uses: actions/checkout@v4
       - name: script
         run: time forklift cargo run --locked --release -p staging-node-cli --bin substrate-node --features runtime-benchmarks -- benchmark pallet --chain dev --pallet "*" --extrinsic "*" --steps 2 --repeat 1 --quiet
+
   # cf https://github.com/paritytech/polkadot-sdk/issues/1652
   test-syscalls:
+    needs: [set-image, changes]
+    if: ${{ needs.changes.outputs.rust }}
     runs-on: arc-runners-polkadot-sdk-beefy
     timeout-minutes: 30
-    needs: [set-image]
     container:
       image: ${{ needs.set-image.outputs.IMAGE }}
     continue-on-error: true # this rarely triggers in practice
@@ -71,10 +73,12 @@ jobs:
     # - if [[ "$CI_JOB_STATUS" == "failed" ]]; then
     #   printf "The x86_64 syscalls used by the worker binaries have changed. Please review if this is expected and update polkadot/scripts/list-syscalls/*-worker-syscalls as needed.\n";
     #   fi
+
   cargo-check-all-benches:
+    needs: [set-image, changes]
+    if: ${{ needs.changes.outputs.rust }}
     runs-on: arc-runners-polkadot-sdk-beefy
     timeout-minutes: 30
-    needs: [set-image]
     container:
       image: ${{ needs.set-image.outputs.IMAGE }}
     env:
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 73a8c52c448f72d12e510d65b2f7ff38469856f0..7f2babc6bd47237032b941a6bf9de4a91b031932 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -120,7 +120,8 @@ default:
 .forklift-cache:
   before_script:
     - mkdir ~/.forklift
-    - cp .forklift/config.toml ~/.forklift/config.toml
+    - cp .forklift/config-gitlab.toml ~/.forklift/config.toml
+    - cat .forklift/config-gitlab.toml > .forklift/config.toml
     - >
       if [ "$FORKLIFT_BYPASS" != "true" ]; then
         echo "FORKLIFT_BYPASS not set"; 
diff --git a/.gitlab/pipeline/check.yml b/.gitlab/pipeline/check.yml
index 5c1a667a313ce391f0c790881d87f48ebd79d073..2b8b90ef19a47874b3a9de065038faee376a01ae 100644
--- a/.gitlab/pipeline/check.yml
+++ b/.gitlab/pipeline/check.yml
@@ -24,30 +24,6 @@ check-try-runtime:
     # experimental code may rely on try-runtime and vice-versa
     - time cargo check --locked --all --features try-runtime,experimental
 
-# FIXME
-.cargo-deny-licenses:
-  stage: check
-  extends:
-    - .docker-env
-    - .test-pr-refs
-  variables:
-    CARGO_DENY_CMD: "cargo deny --all-features check licenses -c ./substrate/scripts/ci/deny.toml"
-  script:
-    - $CARGO_DENY_CMD --hide-inclusion-graph
-  after_script:
-    - echo "___The complete log is in the artifacts___"
-    - $CARGO_DENY_CMD 2> deny.log
-    - if [ $CI_JOB_STATUS != 'success' ]; then
-      echo 'Please check license of your crate or add an exception to scripts/ci/deny.toml';
-      fi
-  allow_failure: true
-  artifacts:
-    name: $CI_COMMIT_SHORT_SHA
-    expire_in: 3 days
-    when: always
-    paths:
-      - deny.log
-
 # from substrate
 # not sure if it's needed in monorepo
 check-dependency-rules:
diff --git a/.gitlab/pipeline/publish.yml b/.gitlab/pipeline/publish.yml
index 8b27c7247487f0620c5214e75532025a96ec3ea4..44cd1933a9cfa0b3cbff384ff4184a36bf864021 100644
--- a/.gitlab/pipeline/publish.yml
+++ b/.gitlab/pipeline/publish.yml
@@ -76,6 +76,8 @@ publish-subsystem-benchmarks:
       artifacts: true
     - job: subsystem-benchmark-approval-voting
       artifacts: true
+    - job: subsystem-benchmark-statement-distribution
+      artifacts: true
     - job: publish-rustdoc
       artifacts: false
   script:
@@ -119,6 +121,8 @@ trigger_workflow:
       artifacts: true
     - job: subsystem-benchmark-approval-voting
       artifacts: true
+    - job: subsystem-benchmark-statement-distribution
+      artifacts: true
   script:
     - echo "Triggering workflow"
     - >
diff --git a/.gitlab/pipeline/test.yml b/.gitlab/pipeline/test.yml
index eea561ff8baa8793e8f70974ec01c428d150ea73..d171a8a19426c959f776aa0780f4373c4b23b4e6 100644
--- a/.gitlab/pipeline/test.yml
+++ b/.gitlab/pipeline/test.yml
@@ -491,6 +491,17 @@ check-tracing:
     - time cargo test --locked --manifest-path ./substrate/primitives/tracing/Cargo.toml --no-default-features
     - time cargo test --locked --manifest-path ./substrate/primitives/tracing/Cargo.toml --no-default-features --features=with-tracing
 
+# Check that `westend-runtime` compiles with the `metadata-hash` feature enabled.
+check-metadata-hash:
+  stage: test
+  extends:
+    - .docker-env
+    - .common-refs
+    - .run-immediately
+    - .pipeline-stopper-artifacts
+  script:
+    - time cargo build --locked -p westend-runtime --features metadata-hash
+
 # more information about this job can be found here:
 # https://github.com/paritytech/substrate/pull/3778
 test-full-crypto-feature:
@@ -619,3 +630,10 @@ subsystem-benchmark-approval-voting:
   script:
     - cargo bench -p polkadot-node-core-approval-voting --bench approval-voting-regression-bench --features subsystem-benchmarks
   allow_failure: true
+
+subsystem-benchmark-statement-distribution:
+  extends:
+    - .subsystem-benchmark-template
+  script:
+    - cargo bench -p polkadot-statement-distribution --bench statement-distribution-regression-bench --features subsystem-benchmarks
+  allow_failure: true
diff --git a/.gitlab/pipeline/zombienet.yml b/.gitlab/pipeline/zombienet.yml
index 7be4ba1663e620ea34724926cf2ac52458df07d8..7897e55e291bd3cae1f3df42d1fcf5c811ff52f2 100644
--- a/.gitlab/pipeline/zombienet.yml
+++ b/.gitlab/pipeline/zombienet.yml
@@ -1,7 +1,7 @@
 .zombienet-refs:
   extends: .build-refs
   variables:
-    ZOMBIENET_IMAGE: "docker.io/paritytech/zombienet:v1.3.103"
+    ZOMBIENET_IMAGE: "docker.io/paritytech/zombienet:v1.3.105"
     PUSHGATEWAY_URL: "http://zombienet-prometheus-pushgateway.managed-monitoring:9091/metrics/job/zombie-metrics"
     DEBUG: "zombie,zombie::network-node,zombie::kube::client::logs"
 
diff --git a/.gitlab/pipeline/zombienet/polkadot.yml b/.gitlab/pipeline/zombienet/polkadot.yml
index a9f0eb9303371499642e244c3b8408e42e4c78e8..90251082077ce07f739a5b122deaf6023dcfeaa6 100644
--- a/.gitlab/pipeline/zombienet/polkadot.yml
+++ b/.gitlab/pipeline/zombienet/polkadot.yml
@@ -162,6 +162,9 @@ zombienet-polkadot-elastic-scaling-0001-basic-3cores-6s-blocks:
     - .zombienet-polkadot-common
   variables:
     FORCED_INFRA_INSTANCE: "spot-iops"
+  before_script:
+    - !reference [.zombienet-polkadot-common, before_script]
+    - cp --remove-destination ${LOCAL_DIR}/assign-core.js ${LOCAL_DIR}/elastic_scaling
   script:
     - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh
       --local-dir="${LOCAL_DIR}/elastic_scaling"
@@ -170,6 +173,9 @@ zombienet-polkadot-elastic-scaling-0001-basic-3cores-6s-blocks:
 zombienet-polkadot-elastic-scaling-0002-elastic-scaling-doesnt-break-parachains:
   extends:
     - .zombienet-polkadot-common
+  before_script:
+    - !reference [.zombienet-polkadot-common, before_script]
+    - cp --remove-destination ${LOCAL_DIR}/assign-core.js ${LOCAL_DIR}/elastic_scaling
   script:
     - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh
       --local-dir="${LOCAL_DIR}/elastic_scaling"
@@ -183,6 +189,33 @@ zombienet-polkadot-functional-0012-spam-statement-distribution-requests:
       --local-dir="${LOCAL_DIR}/functional"
       --test="0012-spam-statement-distribution-requests.zndsl"
 
+zombienet-polkadot-functional-0013-systematic-chunk-recovery:
+  extends:
+    - .zombienet-polkadot-common
+  script:
+    - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh
+      --local-dir="${LOCAL_DIR}/functional"
+      --test="0013-systematic-chunk-recovery.zndsl"
+
+zombienet-polkadot-functional-0014-chunk-fetching-network-compatibility:
+  extends:
+    - .zombienet-polkadot-common
+  script:
+    - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh
+      --local-dir="${LOCAL_DIR}/functional"
+      --test="0014-chunk-fetching-network-compatibility.zndsl"
+
+zombienet-polkadot-functional-0015-coretime-shared-core:
+  extends:
+    - .zombienet-polkadot-common
+  before_script:
+    - !reference [.zombienet-polkadot-common, before_script]
+    - cp --remove-destination ${LOCAL_DIR}/assign-core.js ${LOCAL_DIR}/functional
+  script:
+    - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh
+      --local-dir="${LOCAL_DIR}/functional"
+      --test="0015-coretime-shared-core.zndsl"
+
 zombienet-polkadot-smoke-0001-parachains-smoke-test:
   extends:
     - .zombienet-polkadot-common
diff --git a/Cargo.lock b/Cargo.lock
index 2a4b9b138bf85a5099d17b0f47d07ed9260ce686..f86907030f84f79802db0172a7484126662fff8d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -90,9 +90,9 @@ dependencies = [
 
 [[package]]
 name = "ahash"
-version = "0.8.8"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42cd52102d3df161c77a887b608d7a4897d7cc112886a9537b738a887a03aaff"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if",
  "getrandom 0.2.10",
@@ -294,6 +294,9 @@ name = "arbitrary"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+dependencies = [
+ "derive_arbitrary",
+]
 
 [[package]]
 name = "ark-bls12-377"
@@ -808,6 +811,7 @@ dependencies = [
  "cumulus-primitives-utility",
  "frame-benchmarking",
  "frame-executive",
+ "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "frame-system-benchmarking",
@@ -819,6 +823,7 @@ dependencies = [
  "pallet-asset-conversion-ops",
  "pallet-asset-conversion-tx-payment",
  "pallet-assets",
+ "pallet-assets-freezer",
  "pallet-aura",
  "pallet-authorship",
  "pallet-balances",
@@ -894,6 +899,7 @@ dependencies = [
  "cumulus-pallet-parachain-system",
  "cumulus-pallet-xcmp-queue",
  "emulated-integration-tests-common",
+ "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "pallet-asset-conversion",
@@ -939,6 +945,7 @@ dependencies = [
  "cumulus-primitives-utility",
  "frame-benchmarking",
  "frame-executive",
+ "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "frame-system-benchmarking",
@@ -950,6 +957,7 @@ dependencies = [
  "pallet-asset-conversion-ops",
  "pallet-asset-conversion-tx-payment",
  "pallet-assets",
+ "pallet-assets-freezer",
  "pallet-aura",
  "pallet-authorship",
  "pallet-balances",
@@ -1896,7 +1904,7 @@ dependencies = [
  "bp-parachains",
  "bp-polkadot-core",
  "bp-runtime",
- "ed25519-dalek 2.1.0",
+ "ed25519-dalek 2.1.1",
  "finality-grandpa",
  "parity-scale-codec",
  "sp-application-crypto",
@@ -2095,7 +2103,7 @@ dependencies = [
  "static_assertions",
  "substrate-wasm-builder",
  "testnet-parachains-constants",
- "tuplex",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -2254,8 +2262,8 @@ dependencies = [
  "static_assertions",
  "substrate-wasm-builder",
  "testnet-parachains-constants",
- "tuplex",
  "westend-runtime-constants",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -2363,9 +2371,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "bytes"
-version = "1.4.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
 
 [[package]]
 name = "bzip2-sys"
@@ -2506,6 +2514,32 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "chain-spec-guide-runtime"
+version = "0.0.0"
+dependencies = [
+ "docify",
+ "pallet-balances",
+ "pallet-sudo",
+ "pallet-timestamp",
+ "pallet-transaction-payment",
+ "pallet-transaction-payment-rpc-runtime-api",
+ "parity-scale-codec",
+ "polkadot-sdk-frame",
+ "sc-chain-spec",
+ "scale-info",
+ "serde",
+ "serde_json",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-genesis-builder",
+ "sp-keyring",
+ "sp-runtime",
+ "sp-std 14.0.0",
+ "staging-chain-spec-builder",
+ "substrate-wasm-builder",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.31"
@@ -2602,15 +2636,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "ckb-merkle-mountain-range"
-version = "0.6.0"
-source = "git+https://github.com/paritytech/merkle-mountain-range.git?branch=master#537f0e3f67c5adf7afff0800bbb81f02f17570a1"
-dependencies = [
- "cfg-if",
- "itertools 0.10.5",
-]
-
 [[package]]
 name = "clang-sys"
 version = "1.6.1"
@@ -2874,6 +2899,7 @@ dependencies = [
  "substrate-wasm-builder",
  "testnet-parachains-constants",
  "westend-runtime-constants",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -3129,6 +3155,7 @@ dependencies = [
  "staging-xcm-executor",
  "substrate-wasm-builder",
  "testnet-parachains-constants",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -3225,6 +3252,7 @@ dependencies = [
  "staging-xcm-executor",
  "substrate-wasm-builder",
  "testnet-parachains-constants",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -3289,6 +3317,7 @@ dependencies = [
  "substrate-wasm-builder",
  "testnet-parachains-constants",
  "westend-runtime-constants",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -3704,6 +3733,7 @@ dependencies = [
  "sp-timestamp",
  "sp-tracing 16.0.0",
  "sp-trie",
+ "sp-version",
  "substrate-prometheus-endpoint",
  "tracing",
 ]
@@ -3758,12 +3788,15 @@ dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.1",
  "polkadot-node-primitives",
+ "polkadot-node-subsystem",
  "polkadot-parachain-primitives",
  "polkadot-primitives",
  "polkadot-test-client",
  "portpicker",
+ "rstest",
  "sc-cli",
  "sc-client-api",
+ "sp-api",
  "sp-blockchain",
  "sp-consensus",
  "sp-core",
@@ -3771,6 +3804,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "sp-state-machine",
+ "sp-version",
  "substrate-test-utils",
  "tokio",
  "tracing",
@@ -3804,9 +3838,11 @@ dependencies = [
 name = "cumulus-client-pov-recovery"
 version = "0.7.0"
 dependencies = [
+ "assert_matches",
  "async-trait",
  "cumulus-primitives-core",
  "cumulus-relay-chain-interface",
+ "cumulus-test-client",
  "cumulus-test-service",
  "futures",
  "futures-timer",
@@ -3817,12 +3853,18 @@ dependencies = [
  "polkadot-primitives",
  "portpicker",
  "rand 0.8.5",
+ "rstest",
  "sc-cli",
  "sc-client-api",
  "sc-consensus",
+ "sc-utils",
+ "sp-api",
+ "sp-blockchain",
  "sp-consensus",
  "sp-maybe-compressed-blob",
  "sp-runtime",
+ "sp-tracing 16.0.0",
+ "sp-version",
  "substrate-test-utils",
  "tokio",
  "tracing",
@@ -4193,6 +4235,7 @@ dependencies = [
  "sp-api",
  "sp-blockchain",
  "sp-state-machine",
+ "sp-version",
  "thiserror",
 ]
 
@@ -4363,6 +4406,7 @@ dependencies = [
  "sp-std 14.0.0",
  "sp-transaction-pool",
  "sp-version",
+ "staging-parachain-info",
  "substrate-wasm-builder",
 ]
 
@@ -4494,16 +4538,15 @@ dependencies = [
 
 [[package]]
 name = "curve25519-dalek"
-version = "4.1.2"
+version = "4.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
 dependencies = [
  "cfg-if",
  "cpufeatures",
  "curve25519-dalek-derive",
  "digest 0.10.7",
  "fiat-crypto",
- "platforms",
  "rustc_version 0.4.0",
  "subtle 2.5.0",
  "zeroize",
@@ -4651,9 +4694,12 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.3.8"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+]
 
 [[package]]
 name = "derivative"
@@ -4688,6 +4734,17 @@ dependencies = [
  "syn 2.0.61",
 ]
 
+[[package]]
+name = "derive_arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+dependencies = [
+ "proc-macro2 1.0.82",
+ "quote 1.0.35",
+ "syn 2.0.61",
+]
+
 [[package]]
 name = "derive_more"
 version = "0.99.17"
@@ -4961,11 +5018,11 @@ dependencies = [
 
 [[package]]
 name = "ed25519-dalek"
-version = "2.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f628eaec48bfd21b865dc2950cfa014450c01d2fa2b69a86c2fd5844ec523c0"
+checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
 dependencies = [
- "curve25519-dalek 4.1.2",
+ "curve25519-dalek 4.1.3",
  "ed25519 2.2.2",
  "rand_core 0.6.4",
  "serde",
@@ -4980,7 +5037,7 @@ version = "4.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d9ce6874da5d4415896cd45ffbc4d1cfc0c4f9c079427bd870742c30f2f65a9"
 dependencies = [
- "curve25519-dalek 4.1.2",
+ "curve25519-dalek 4.1.3",
  "ed25519 2.2.2",
  "hashbrown 0.14.3",
  "hex",
@@ -5345,9 +5402,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.0.0"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6999dc1837253364c2ebb0704ba97994bd874e8f195d665c50b7548f6ea92764"
+checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
 
 [[package]]
 name = "fastrlp"
@@ -5782,6 +5839,27 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "frame-metadata-hash-extension"
+version = "0.1.0"
+dependencies = [
+ "array-bytes",
+ "docify",
+ "frame-metadata",
+ "frame-support",
+ "frame-system",
+ "log",
+ "merkleized-metadata",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-runtime",
+ "sp-tracing 16.0.0",
+ "sp-transaction-pool",
+ "substrate-test-runtime-client",
+ "substrate-wasm-builder",
+]
+
 [[package]]
 name = "frame-omni-bencher"
 version = "0.1.0"
@@ -6007,6 +6085,7 @@ dependencies = [
 name = "frame-system-rpc-runtime-api"
 version = "26.0.0"
 dependencies = [
+ "docify",
  "parity-scale-codec",
  "sp-api",
 ]
@@ -6160,9 +6239,9 @@ checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
 
 [[package]]
 name = "futures-timer"
-version = "3.0.2"
+version = "3.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
 
 [[package]]
 name = "futures-util"
@@ -6459,7 +6538,7 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
 dependencies = [
- "ahash 0.8.8",
+ "ahash 0.8.11",
 ]
 
 [[package]]
@@ -6468,7 +6547,7 @@ version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 dependencies = [
- "ahash 0.8.8",
+ "ahash 0.8.11",
  "allocator-api2",
  "serde",
 ]
@@ -7234,123 +7313,15 @@ checksum = "c33070833c9ee02266356de0c43f723152bd38bd96ddf52c82b3af10c9138b28"
 name = "kitchensink-runtime"
 version = "3.0.0-dev"
 dependencies = [
- "frame-benchmarking",
- "frame-benchmarking-pallet-pov",
- "frame-election-provider-support",
- "frame-executive",
- "frame-support",
- "frame-system",
- "frame-system-benchmarking",
- "frame-system-rpc-runtime-api",
- "frame-try-runtime",
  "log",
  "node-primitives",
- "pallet-alliance",
- "pallet-asset-conversion",
- "pallet-asset-conversion-ops",
- "pallet-asset-conversion-tx-payment",
- "pallet-asset-rate",
- "pallet-asset-tx-payment",
- "pallet-assets",
- "pallet-authority-discovery",
- "pallet-authorship",
- "pallet-babe",
- "pallet-bags-list",
- "pallet-balances",
- "pallet-beefy",
- "pallet-beefy-mmr",
- "pallet-bounties",
- "pallet-broker",
- "pallet-child-bounties",
- "pallet-collective",
- "pallet-contracts",
- "pallet-conviction-voting",
- "pallet-core-fellowship",
- "pallet-democracy",
- "pallet-election-provider-multi-phase",
- "pallet-election-provider-support-benchmarking",
- "pallet-elections-phragmen",
  "pallet-example-mbm",
  "pallet-example-tasks",
- "pallet-fast-unstake",
- "pallet-glutton",
- "pallet-grandpa",
- "pallet-identity",
- "pallet-im-online",
- "pallet-indices",
- "pallet-insecure-randomness-collective-flip",
- "pallet-lottery",
- "pallet-membership",
- "pallet-message-queue",
- "pallet-migrations",
- "pallet-mixnet",
- "pallet-mmr",
- "pallet-multisig",
- "pallet-nft-fractionalization",
- "pallet-nfts",
- "pallet-nfts-runtime-api",
- "pallet-nis",
- "pallet-nomination-pools",
- "pallet-nomination-pools-benchmarking",
- "pallet-nomination-pools-runtime-api",
- "pallet-offences",
- "pallet-offences-benchmarking",
- "pallet-parameters",
- "pallet-preimage",
- "pallet-proxy",
- "pallet-ranked-collective",
- "pallet-recovery",
- "pallet-referenda",
- "pallet-remark",
- "pallet-root-testing",
- "pallet-safe-mode",
- "pallet-salary",
- "pallet-scheduler",
- "pallet-session",
- "pallet-session-benchmarking",
- "pallet-skip-feeless-payment",
- "pallet-society",
- "pallet-staking",
- "pallet-staking-reward-curve",
- "pallet-staking-runtime-api",
- "pallet-state-trie-migration",
- "pallet-statement",
- "pallet-sudo",
- "pallet-timestamp",
- "pallet-tips",
- "pallet-transaction-payment",
- "pallet-transaction-payment-rpc-runtime-api",
- "pallet-transaction-storage",
- "pallet-treasury",
- "pallet-tx-pause",
- "pallet-uniques",
- "pallet-utility",
- "pallet-vesting",
- "pallet-whitelist",
  "parity-scale-codec",
+ "polkadot-sdk",
  "primitive-types",
  "scale-info",
  "serde_json",
- "sp-api",
- "sp-authority-discovery",
- "sp-block-builder",
- "sp-consensus-babe",
- "sp-consensus-beefy",
- "sp-consensus-grandpa",
- "sp-core",
- "sp-genesis-builder",
- "sp-inherents",
- "sp-io",
- "sp-mixnet",
- "sp-offchain",
- "sp-runtime",
- "sp-session",
- "sp-staking",
- "sp-statement-store",
- "sp-std 14.0.0",
- "sp-storage 19.0.0",
- "sp-transaction-pool",
- "sp-version",
  "static_assertions",
  "substrate-wasm-builder",
 ]
@@ -7484,9 +7455,9 @@ dependencies = [
 
 [[package]]
 name = "libm"
-version = "0.2.7"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
 
 [[package]]
 name = "libnghttp2-sys"
@@ -7626,7 +7597,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "276bb57e7af15d8f100d3c11cbdd32c6752b7eef4ba7a18ecf464972c07abcce"
 dependencies = [
  "bs58 0.4.0",
- "ed25519-dalek 2.1.0",
+ "ed25519-dalek 2.1.1",
  "log",
  "multiaddr",
  "multihash 0.17.0",
@@ -8049,8 +8020,9 @@ dependencies = [
 
 [[package]]
 name = "litep2p"
-version = "0.3.0"
-source = "git+https://github.com/paritytech/litep2p?rev=e03a6023882db111beeb24d8c0ceaac0721d3f0f#e03a6023882db111beeb24d8c0ceaac0721d3f0f"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f02542ae3a94b4c4ffa37dc56388c923e286afa3bf65452e3984b50b2a2f316"
 dependencies = [
  "async-trait",
  "bs58 0.4.0",
@@ -8062,7 +8034,7 @@ dependencies = [
  "hex-literal",
  "indexmap 2.2.3",
  "libc",
- "mockall",
+ "mockall 0.12.1",
  "multiaddr",
  "multihash 0.17.0",
  "network-interface",
@@ -8346,6 +8318,20 @@ dependencies = [
  "hash-db",
 ]
 
+[[package]]
+name = "merkleized-metadata"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f313fcff1d2a4bcaa2deeaa00bf7530d77d5f7bd0467a117dde2e29a75a7a17a"
+dependencies = [
+ "array-bytes",
+ "blake3",
+ "frame-metadata",
+ "parity-scale-codec",
+ "scale-decode",
+ "scale-info",
+]
+
 [[package]]
 name = "merlin"
 version = "3.0.0"
@@ -8417,6 +8403,7 @@ name = "minimal-template-node"
 version = "0.0.0"
 dependencies = [
  "clap 4.5.3",
+ "docify",
  "futures",
  "futures-timer",
  "jsonrpsee",
@@ -8496,7 +8483,7 @@ dependencies = [
  "bitflags 1.3.2",
  "blake2 0.10.6",
  "c2-chacha",
- "curve25519-dalek 4.1.2",
+ "curve25519-dalek 4.1.3",
  "either",
  "hashlink",
  "lioness",
@@ -8558,11 +8545,26 @@ dependencies = [
  "downcast",
  "fragile",
  "lazy_static",
- "mockall_derive",
+ "mockall_derive 0.11.4",
  "predicates 2.1.5",
  "predicates-tree",
 ]
 
+[[package]]
+name = "mockall"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43766c2b5203b10de348ffe19f7e54564b64f3d6018ff7648d1e2d6d3a0f0a48"
+dependencies = [
+ "cfg-if",
+ "downcast",
+ "fragile",
+ "lazy_static",
+ "mockall_derive 0.12.1",
+ "predicates 3.0.3",
+ "predicates-tree",
+]
+
 [[package]]
 name = "mockall_derive"
 version = "0.11.4"
@@ -8575,6 +8577,24 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "mockall_derive"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af7cbce79ec385a1d4f54baa90a76401eb15d9cab93685f62e7e9f942aa00ae2"
+dependencies = [
+ "cfg-if",
+ "proc-macro2 1.0.82",
+ "quote 1.0.35",
+ "syn 2.0.61",
+]
+
+[[package]]
+name = "multi-stash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685a9ac4b61f4e728e1d2c6a7844609c16527aeb5e6c865915c08e619c16410f"
+
 [[package]]
 name = "multiaddr"
 version = "0.17.1"
@@ -8963,10 +8983,12 @@ dependencies = [
  "sc-sync-state-rpc",
  "sc-transaction-pool-api",
  "sp-api",
+ "sp-application-crypto",
  "sp-block-builder",
  "sp-blockchain",
  "sp-consensus",
  "sp-consensus-babe",
+ "sp-consensus-beefy",
  "sp-keystore",
  "sp-runtime",
  "sp-statement-store",
@@ -9001,6 +9023,7 @@ dependencies = [
 name = "node-testing"
 version = "3.0.0-dev"
 dependencies = [
+ "frame-metadata-hash-extension",
  "frame-system",
  "fs_extra",
  "futures",
@@ -9128,6 +9151,23 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2 1.0.82",
+ "quote 1.0.35",
+ "syn 2.0.61",
+]
+
 [[package]]
 name = "num-format"
 version = "0.4.4"
@@ -9517,6 +9557,23 @@ dependencies = [
  "sp-std 14.0.0",
 ]
 
+[[package]]
+name = "pallet-assets-freezer"
+version = "0.1.0"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-assets",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "pallet-atomic-swap"
 version = "28.0.0"
@@ -9756,7 +9813,7 @@ dependencies = [
  "bp-beefy",
  "bp-runtime",
  "bp-test-utils",
- "ckb-merkle-mountain-range 0.5.2",
+ "ckb-merkle-mountain-range",
  "frame-support",
  "frame-system",
  "log",
@@ -9877,6 +9934,7 @@ dependencies = [
  "sp-io",
  "sp-runtime",
  "sp-std 14.0.0",
+ "sp-tracing 16.0.0",
 ]
 
 [[package]]
@@ -9996,7 +10054,7 @@ dependencies = [
  "staging-xcm",
  "staging-xcm-builder",
  "wasm-instrument",
- "wasmi",
+ "wasmi 0.32.3",
  "wat",
 ]
 
@@ -10131,6 +10189,7 @@ dependencies = [
  "frame-support",
  "frame-system",
  "pallet-balances",
+ "pallet-nomination-pools",
  "pallet-staking",
  "pallet-staking-reward-curve",
  "pallet-timestamp",
@@ -10445,6 +10504,7 @@ dependencies = [
  "parity-scale-codec",
  "scale-info",
  "sp-core",
+ "sp-inherents",
  "sp-io",
  "sp-runtime",
  "sp-std 14.0.0",
@@ -10482,7 +10542,7 @@ dependencies = [
 
 [[package]]
 name = "pallet-identity"
-version = "28.0.0"
+version = "29.0.0"
 dependencies = [
  "enumflags2",
  "frame-benchmarking",
@@ -10804,6 +10864,7 @@ dependencies = [
  "frame-system",
  "pallet-bags-list",
  "pallet-balances",
+ "pallet-delegated-staking",
  "pallet-nomination-pools",
  "pallet-staking",
  "pallet-staking-reward-curve",
@@ -10844,7 +10905,32 @@ dependencies = [
 ]
 
 [[package]]
-name = "pallet-nomination-pools-test-staking"
+name = "pallet-nomination-pools-test-delegate-stake"
+version = "1.0.0"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-bags-list",
+ "pallet-balances",
+ "pallet-delegated-staking",
+ "pallet-nomination-pools",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std 14.0.0",
+ "sp-tracing 16.0.0",
+]
+
+[[package]]
+name = "pallet-nomination-pools-test-transfer-stake"
 version = "1.0.0"
 dependencies = [
  "frame-election-provider-support",
@@ -11798,6 +11884,7 @@ dependencies = [
  "docify",
  "frame-benchmarking",
  "frame-executive",
+ "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "frame-system-benchmarking",
@@ -12300,6 +12387,7 @@ dependencies = [
  "staging-xcm-executor",
  "substrate-wasm-builder",
  "testnet-parachains-constants",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -12400,6 +12488,7 @@ dependencies = [
  "substrate-wasm-builder",
  "testnet-parachains-constants",
  "westend-runtime-constants",
+ "xcm-fee-payment-runtime-api",
 ]
 
 [[package]]
@@ -12647,6 +12736,7 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "polkadot-subsystem-bench",
  "rand 0.8.5",
+ "rstest",
  "sc-network",
  "schnellru",
  "sp-core",
@@ -12663,7 +12753,6 @@ version = "7.0.0"
 dependencies = [
  "assert_matches",
  "async-trait",
- "env_logger 0.11.3",
  "fatality",
  "futures",
  "futures-timer",
@@ -12679,16 +12768,28 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "polkadot-subsystem-bench",
  "rand 0.8.5",
+ "rstest",
  "sc-network",
  "schnellru",
  "sp-application-crypto",
  "sp-core",
  "sp-keyring",
+ "sp-tracing 16.0.0",
  "thiserror",
  "tokio",
  "tracing-gum",
 ]
 
+[[package]]
+name = "polkadot-ckb-merkle-mountain-range"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4b44320e5f7ce2c18227537a3032ae5b2c476a7e8eddba45333e1011fc31b92"
+dependencies = [
+ "cfg-if",
+ "itertools 0.10.5",
+]
+
 [[package]]
 name = "polkadot-cli"
 version = "7.0.0"
@@ -12801,6 +12902,7 @@ dependencies = [
  "parity-scale-codec",
  "polkadot-node-primitives",
  "polkadot-primitives",
+ "quickcheck",
  "reed-solomon-novelpoly",
  "sp-core",
  "sp-trie",
@@ -13134,6 +13236,7 @@ dependencies = [
  "polkadot-node-subsystem-util",
  "polkadot-primitives",
  "polkadot-primitives-test-helpers",
+ "rstest",
  "sc-keystore",
  "sp-application-crypto",
  "sp-core",
@@ -13447,6 +13550,7 @@ dependencies = [
  "async-trait",
  "bitvec",
  "derive_more",
+ "fatality",
  "futures",
  "orchestra",
  "polkadot-node-jaeger",
@@ -13489,6 +13593,7 @@ dependencies = [
  "parity-scale-codec",
  "parking_lot 0.12.1",
  "pin-project",
+ "polkadot-erasure-coding",
  "polkadot-node-jaeger",
  "polkadot-node-metrics",
  "polkadot-node-network-protocol",
@@ -13710,10 +13815,12 @@ dependencies = [
  "sc-sync-state-rpc",
  "sc-transaction-pool-api",
  "sp-api",
+ "sp-application-crypto",
  "sp-block-builder",
  "sp-blockchain",
  "sp-consensus",
  "sp-consensus-babe",
+ "sp-consensus-beefy",
  "sp-keystore",
  "sp-runtime",
  "substrate-frame-rpc-system",
@@ -13844,14 +13951,402 @@ dependencies = [
  "sp-tracing 16.0.0",
  "staging-xcm",
  "staging-xcm-executor",
- "static_assertions",
- "thousands",
+ "static_assertions",
+ "thousands",
+]
+
+[[package]]
+name = "polkadot-sdk"
+version = "0.1.0"
+dependencies = [
+ "asset-test-utils",
+ "assets-common",
+ "binary-merkle-tree",
+ "bp-asset-hub-rococo",
+ "bp-asset-hub-westend",
+ "bp-bridge-hub-cumulus",
+ "bp-bridge-hub-kusama",
+ "bp-bridge-hub-polkadot",
+ "bp-bridge-hub-rococo",
+ "bp-bridge-hub-westend",
+ "bp-header-chain",
+ "bp-kusama",
+ "bp-messages",
+ "bp-parachains",
+ "bp-polkadot",
+ "bp-polkadot-bulletin",
+ "bp-polkadot-core",
+ "bp-relayers",
+ "bp-rococo",
+ "bp-runtime",
+ "bp-test-utils",
+ "bp-westend",
+ "bp-xcm-bridge-hub",
+ "bp-xcm-bridge-hub-router",
+ "bridge-hub-common",
+ "bridge-hub-test-utils",
+ "bridge-runtime-common",
+ "cumulus-client-cli",
+ "cumulus-client-collator",
+ "cumulus-client-consensus-aura",
+ "cumulus-client-consensus-common",
+ "cumulus-client-consensus-proposer",
+ "cumulus-client-consensus-relay-chain",
+ "cumulus-client-network",
+ "cumulus-client-parachain-inherent",
+ "cumulus-client-pov-recovery",
+ "cumulus-client-service",
+ "cumulus-pallet-aura-ext",
+ "cumulus-pallet-dmp-queue",
+ "cumulus-pallet-parachain-system",
+ "cumulus-pallet-parachain-system-proc-macro",
+ "cumulus-pallet-session-benchmarking",
+ "cumulus-pallet-solo-to-para",
+ "cumulus-pallet-xcm",
+ "cumulus-pallet-xcmp-queue",
+ "cumulus-ping",
+ "cumulus-primitives-aura",
+ "cumulus-primitives-core",
+ "cumulus-primitives-parachain-inherent",
+ "cumulus-primitives-proof-size-hostfunction",
+ "cumulus-primitives-storage-weight-reclaim",
+ "cumulus-primitives-timestamp",
+ "cumulus-primitives-utility",
+ "cumulus-relay-chain-inprocess-interface",
+ "cumulus-relay-chain-interface",
+ "cumulus-relay-chain-minimal-node",
+ "cumulus-relay-chain-rpc-interface",
+ "cumulus-test-relay-sproof-builder",
+ "emulated-integration-tests-common",
+ "fork-tree",
+ "frame-benchmarking",
+ "frame-benchmarking-cli",
+ "frame-benchmarking-pallet-pov",
+ "frame-election-provider-solution-type",
+ "frame-election-provider-support",
+ "frame-executive",
+ "frame-metadata-hash-extension",
+ "frame-remote-externalities",
+ "frame-support",
+ "frame-support-procedural",
+ "frame-support-procedural-tools",
+ "frame-support-procedural-tools-derive",
+ "frame-system",
+ "frame-system-benchmarking",
+ "frame-system-rpc-runtime-api",
+ "frame-try-runtime",
+ "generate-bags",
+ "mmr-gadget",
+ "mmr-rpc",
+ "pallet-alliance",
+ "pallet-asset-conversion",
+ "pallet-asset-conversion-ops",
+ "pallet-asset-conversion-tx-payment",
+ "pallet-asset-rate",
+ "pallet-asset-tx-payment",
+ "pallet-assets",
+ "pallet-assets-freezer",
+ "pallet-atomic-swap",
+ "pallet-aura",
+ "pallet-authority-discovery",
+ "pallet-authorship",
+ "pallet-babe",
+ "pallet-bags-list",
+ "pallet-balances",
+ "pallet-beefy",
+ "pallet-beefy-mmr",
+ "pallet-bounties",
+ "pallet-bridge-grandpa",
+ "pallet-bridge-messages",
+ "pallet-bridge-parachains",
+ "pallet-bridge-relayers",
+ "pallet-broker",
+ "pallet-child-bounties",
+ "pallet-collator-selection",
+ "pallet-collective",
+ "pallet-collective-content",
+ "pallet-contracts",
+ "pallet-contracts-mock-network",
+ "pallet-contracts-proc-macro",
+ "pallet-contracts-uapi",
+ "pallet-conviction-voting",
+ "pallet-core-fellowship",
+ "pallet-delegated-staking",
+ "pallet-democracy",
+ "pallet-dev-mode",
+ "pallet-election-provider-multi-phase",
+ "pallet-election-provider-support-benchmarking",
+ "pallet-elections-phragmen",
+ "pallet-fast-unstake",
+ "pallet-glutton",
+ "pallet-grandpa",
+ "pallet-identity",
+ "pallet-im-online",
+ "pallet-indices",
+ "pallet-insecure-randomness-collective-flip",
+ "pallet-lottery",
+ "pallet-membership",
+ "pallet-message-queue",
+ "pallet-migrations",
+ "pallet-mixnet",
+ "pallet-mmr",
+ "pallet-multisig",
+ "pallet-nft-fractionalization",
+ "pallet-nfts",
+ "pallet-nfts-runtime-api",
+ "pallet-nis",
+ "pallet-node-authorization",
+ "pallet-nomination-pools",
+ "pallet-nomination-pools-benchmarking",
+ "pallet-nomination-pools-runtime-api",
+ "pallet-offences",
+ "pallet-offences-benchmarking",
+ "pallet-paged-list",
+ "pallet-parameters",
+ "pallet-preimage",
+ "pallet-proxy",
+ "pallet-ranked-collective",
+ "pallet-recovery",
+ "pallet-referenda",
+ "pallet-remark",
+ "pallet-root-offences",
+ "pallet-root-testing",
+ "pallet-safe-mode",
+ "pallet-salary",
+ "pallet-scheduler",
+ "pallet-scored-pool",
+ "pallet-session",
+ "pallet-session-benchmarking",
+ "pallet-skip-feeless-payment",
+ "pallet-society",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-staking-reward-fn",
+ "pallet-staking-runtime-api",
+ "pallet-state-trie-migration",
+ "pallet-statement",
+ "pallet-sudo",
+ "pallet-timestamp",
+ "pallet-tips",
+ "pallet-transaction-payment",
+ "pallet-transaction-payment-rpc",
+ "pallet-transaction-payment-rpc-runtime-api",
+ "pallet-transaction-storage",
+ "pallet-treasury",
+ "pallet-tx-pause",
+ "pallet-uniques",
+ "pallet-utility",
+ "pallet-vesting",
+ "pallet-whitelist",
+ "pallet-xcm",
+ "pallet-xcm-benchmarks",
+ "pallet-xcm-bridge-hub",
+ "pallet-xcm-bridge-hub-router",
+ "parachains-common",
+ "parachains-runtimes-test-utils",
+ "polkadot-approval-distribution",
+ "polkadot-availability-bitfield-distribution",
+ "polkadot-availability-distribution",
+ "polkadot-availability-recovery",
+ "polkadot-cli",
+ "polkadot-collator-protocol",
+ "polkadot-core-primitives",
+ "polkadot-dispute-distribution",
+ "polkadot-erasure-coding",
+ "polkadot-gossip-support",
+ "polkadot-network-bridge",
+ "polkadot-node-collation-generation",
+ "polkadot-node-core-approval-voting",
+ "polkadot-node-core-av-store",
+ "polkadot-node-core-backing",
+ "polkadot-node-core-bitfield-signing",
+ "polkadot-node-core-candidate-validation",
+ "polkadot-node-core-chain-api",
+ "polkadot-node-core-chain-selection",
+ "polkadot-node-core-dispute-coordinator",
+ "polkadot-node-core-parachains-inherent",
+ "polkadot-node-core-prospective-parachains",
+ "polkadot-node-core-provisioner",
+ "polkadot-node-core-pvf",
+ "polkadot-node-core-pvf-checker",
+ "polkadot-node-core-pvf-common",
+ "polkadot-node-core-pvf-execute-worker",
+ "polkadot-node-core-pvf-prepare-worker",
+ "polkadot-node-core-runtime-api",
+ "polkadot-node-jaeger",
+ "polkadot-node-metrics",
+ "polkadot-node-network-protocol",
+ "polkadot-node-primitives",
+ "polkadot-node-subsystem",
+ "polkadot-node-subsystem-types",
+ "polkadot-node-subsystem-util",
+ "polkadot-overseer",
+ "polkadot-parachain-primitives",
+ "polkadot-primitives",
+ "polkadot-rpc",
+ "polkadot-runtime-common",
+ "polkadot-runtime-metrics",
+ "polkadot-runtime-parachains",
+ "polkadot-sdk-frame",
+ "polkadot-service",
+ "polkadot-statement-distribution",
+ "polkadot-statement-table",
+ "rococo-runtime-constants",
+ "sc-allocator",
+ "sc-authority-discovery",
+ "sc-basic-authorship",
+ "sc-block-builder",
+ "sc-chain-spec",
+ "sc-chain-spec-derive",
+ "sc-cli",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-consensus",
+ "sc-consensus-aura",
+ "sc-consensus-babe",
+ "sc-consensus-babe-rpc",
+ "sc-consensus-beefy",
+ "sc-consensus-beefy-rpc",
+ "sc-consensus-epochs",
+ "sc-consensus-grandpa",
+ "sc-consensus-grandpa-rpc",
+ "sc-consensus-manual-seal",
+ "sc-consensus-pow",
+ "sc-consensus-slots",
+ "sc-executor",
+ "sc-executor-common",
+ "sc-executor-polkavm",
+ "sc-executor-wasmtime",
+ "sc-informant",
+ "sc-keystore",
+ "sc-mixnet",
+ "sc-network",
+ "sc-network-common",
+ "sc-network-gossip",
+ "sc-network-light",
+ "sc-network-statement",
+ "sc-network-sync",
+ "sc-network-transactions",
+ "sc-network-types",
+ "sc-offchain",
+ "sc-proposer-metrics",
+ "sc-rpc",
+ "sc-rpc-api",
+ "sc-rpc-server",
+ "sc-rpc-spec-v2",
+ "sc-service",
+ "sc-state-db",
+ "sc-statement-store",
+ "sc-storage-monitor",
+ "sc-sync-state-rpc",
+ "sc-sysinfo",
+ "sc-telemetry",
+ "sc-tracing",
+ "sc-tracing-proc-macro",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "slot-range-helper",
+ "snowbridge-beacon-primitives",
+ "snowbridge-core",
+ "snowbridge-ethereum",
+ "snowbridge-outbound-queue-merkle-tree",
+ "snowbridge-outbound-queue-runtime-api",
+ "snowbridge-pallet-ethereum-client",
+ "snowbridge-pallet-ethereum-client-fixtures",
+ "snowbridge-pallet-inbound-queue",
+ "snowbridge-pallet-inbound-queue-fixtures",
+ "snowbridge-pallet-outbound-queue",
+ "snowbridge-pallet-system",
+ "snowbridge-router-primitives",
+ "snowbridge-runtime-common",
+ "snowbridge-runtime-test-common",
+ "snowbridge-system-runtime-api",
+ "sp-api",
+ "sp-api-proc-macro",
+ "sp-application-crypto",
+ "sp-arithmetic",
+ "sp-authority-discovery",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-aura",
+ "sp-consensus-babe",
+ "sp-consensus-beefy",
+ "sp-consensus-grandpa",
+ "sp-consensus-pow",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-core-hashing",
+ "sp-core-hashing-proc-macro",
+ "sp-crypto-ec-utils 0.10.0",
+ "sp-crypto-hashing",
+ "sp-crypto-hashing-proc-macro",
+ "sp-database",
+ "sp-debug-derive 14.0.0",
+ "sp-externalities 0.25.0",
+ "sp-genesis-builder",
+ "sp-inherents",
+ "sp-io",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-maybe-compressed-blob",
+ "sp-metadata-ir",
+ "sp-mixnet",
+ "sp-mmr-primitives",
+ "sp-npos-elections",
+ "sp-offchain",
+ "sp-panic-handler",
+ "sp-rpc",
+ "sp-runtime",
+ "sp-runtime-interface 24.0.0",
+ "sp-runtime-interface-proc-macro 17.0.0",
+ "sp-session",
+ "sp-staking",
+ "sp-state-machine",
+ "sp-statement-store",
+ "sp-std 14.0.0",
+ "sp-storage 19.0.0",
+ "sp-timestamp",
+ "sp-tracing 16.0.0",
+ "sp-transaction-pool",
+ "sp-transaction-storage-proof",
+ "sp-trie",
+ "sp-version",
+ "sp-version-proc-macro",
+ "sp-wasm-interface 20.0.0",
+ "sp-weights",
+ "staging-chain-spec-builder",
+ "staging-node-inspect",
+ "staging-parachain-info",
+ "staging-tracking-allocator",
+ "staging-xcm",
+ "staging-xcm-builder",
+ "staging-xcm-executor",
+ "subkey",
+ "substrate-bip39",
+ "substrate-build-script-utils",
+ "substrate-frame-rpc-support",
+ "substrate-frame-rpc-system",
+ "substrate-prometheus-endpoint",
+ "substrate-rpc-client",
+ "substrate-state-trie-migration-rpc",
+ "substrate-wasm-builder",
+ "testnet-parachains-constants",
+ "tracing-gum",
+ "tracing-gum-proc-macro",
+ "westend-runtime-constants",
+ "xcm-emulator",
+ "xcm-fee-payment-runtime-api",
+ "xcm-procedural",
+ "xcm-simulator",
 ]
 
 [[package]]
 name = "polkadot-sdk-docs"
 version = "0.0.1"
 dependencies = [
+ "chain-spec-guide-runtime",
  "cumulus-client-service",
  "cumulus-pallet-aura-ext",
  "cumulus-pallet-parachain-system",
@@ -13859,9 +14354,11 @@ dependencies = [
  "cumulus-primitives-storage-weight-reclaim",
  "docify",
  "frame-executive",
+ "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "kitchensink-runtime",
+ "minimal-template-runtime",
  "pallet-assets",
  "pallet-aura",
  "pallet-authorship",
@@ -13884,8 +14381,11 @@ dependencies = [
  "pallet-transaction-payment",
  "pallet-uniques",
  "pallet-utility",
+ "parachain-template-runtime",
  "parity-scale-codec",
+ "polkadot-sdk",
  "polkadot-sdk-frame",
+ "sc-chain-spec",
  "sc-cli",
  "sc-client-db",
  "sc-consensus-aura",
@@ -13901,13 +14401,18 @@ dependencies = [
  "sc-service",
  "scale-info",
  "simple-mermaid 0.1.1",
+ "solochain-template-runtime",
  "sp-api",
  "sp-arithmetic",
  "sp-core",
+ "sp-genesis-builder",
  "sp-io",
  "sp-keyring",
  "sp-offchain",
  "sp-runtime",
+ "sp-runtime-interface 24.0.0",
+ "sp-std 14.0.0",
+ "sp-tracing 16.0.0",
  "sp-version",
  "staging-chain-spec-builder",
  "staging-node-cli",
@@ -13915,6 +14420,7 @@ dependencies = [
  "staging-xcm",
  "subkey",
  "substrate-wasm-builder",
+ "xcm-docs",
 ]
 
 [[package]]
@@ -13960,6 +14466,7 @@ dependencies = [
  "env_logger 0.11.3",
  "frame-benchmarking",
  "frame-benchmarking-cli",
+ "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "frame-system-rpc-runtime-api",
@@ -14097,6 +14604,7 @@ dependencies = [
  "polkadot-node-subsystem-util",
  "polkadot-primitives",
  "polkadot-primitives-test-helpers",
+ "polkadot-subsystem-bench",
  "rand_chacha 0.3.1",
  "sc-keystore",
  "sc-network",
@@ -14161,6 +14669,7 @@ dependencies = [
  "polkadot-overseer",
  "polkadot-primitives",
  "polkadot-primitives-test-helpers",
+ "polkadot-statement-distribution",
  "prometheus",
  "pyroscope",
  "pyroscope_pprofrs",
@@ -14185,6 +14694,7 @@ dependencies = [
  "sp-keystore",
  "sp-runtime",
  "sp-timestamp",
+ "strum 0.24.1",
  "substrate-prometheus-endpoint",
  "tokio",
  "tracing-gum",
@@ -14511,6 +15021,12 @@ dependencies = [
  "rand 0.8.5",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "pprof"
 version = "0.12.1"
@@ -15003,6 +15519,17 @@ dependencies = [
  "unsigned-varint",
 ]
 
+[[package]]
+name = "quick_cache"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5253a3a0d56548d5b0be25414171dc780cc6870727746d05bd2bde352eee96c5"
+dependencies = [
+ "ahash 0.8.11",
+ "hashbrown 0.13.2",
+ "parking_lot 0.12.1",
+]
+
 [[package]]
 name = "quickcheck"
 version = "1.0.3"
@@ -15438,6 +15965,7 @@ dependencies = [
  "pallet-transaction-payment-rpc-runtime-api",
  "pallet-utility",
  "parity-scale-codec",
+ "quick_cache",
  "rand 0.8.5",
  "relay-utils",
  "sc-chain-spec",
@@ -15712,6 +16240,7 @@ dependencies = [
  "bitvec",
  "frame-benchmarking",
  "frame-executive",
+ "frame-metadata-hash-extension",
  "frame-remote-externalities",
  "frame-support",
  "frame-system",
@@ -16318,10 +16847,12 @@ name = "sc-chain-spec"
 version = "28.0.0"
 dependencies = [
  "array-bytes",
+ "clap 4.5.3",
  "docify",
  "log",
  "memmap2 0.9.3",
  "parity-scale-codec",
+ "regex",
  "sc-chain-spec-derive",
  "sc-client-api",
  "sc-executor",
@@ -16466,7 +16997,7 @@ dependencies = [
  "futures",
  "futures-timer",
  "log",
- "mockall",
+ "mockall 0.11.4",
  "parking_lot 0.12.1",
  "sc-client-api",
  "sc-network-types",
@@ -16648,6 +17179,7 @@ dependencies = [
  "sc-rpc",
  "serde",
  "serde_json",
+ "sp-application-crypto",
  "sp-consensus-beefy",
  "sp-core",
  "sp-runtime",
@@ -16672,7 +17204,7 @@ dependencies = [
 name = "sc-consensus-grandpa"
 version = "0.19.0"
 dependencies = [
- "ahash 0.8.8",
+ "ahash 0.8.11",
  "array-bytes",
  "assert_matches",
  "async-trait",
@@ -16991,7 +17523,7 @@ dependencies = [
  "linked_hash_set",
  "litep2p",
  "log",
- "mockall",
+ "mockall 0.11.4",
  "multistream-select",
  "once_cell",
  "parity-scale-codec",
@@ -17057,7 +17589,7 @@ dependencies = [
 name = "sc-network-gossip"
 version = "0.34.0"
 dependencies = [
- "ahash 0.8.8",
+ "ahash 0.8.11",
  "async-trait",
  "futures",
  "futures-timer",
@@ -17129,7 +17661,7 @@ dependencies = [
  "futures-timer",
  "libp2p",
  "log",
- "mockall",
+ "mockall 0.11.4",
  "parity-scale-codec",
  "prost 0.12.4",
  "prost-build 0.12.4",
@@ -17213,12 +17745,15 @@ name = "sc-network-types"
 version = "0.10.0"
 dependencies = [
  "bs58 0.5.0",
+ "ed25519-dalek 2.1.1",
  "libp2p-identity",
  "litep2p",
  "multiaddr",
  "multihash 0.17.0",
+ "quickcheck",
  "rand 0.8.5",
  "thiserror",
+ "zeroize",
 ]
 
 [[package]]
@@ -17345,6 +17880,7 @@ dependencies = [
  "ip_network",
  "jsonrpsee",
  "log",
+ "serde",
  "serde_json",
  "substrate-prometheus-endpoint",
  "tokio",
@@ -17713,6 +18249,29 @@ dependencies = [
  "tokio-test",
 ]
 
+[[package]]
+name = "scale-bits"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57b1e7f6b65ed1f04e79a85a57d755ad56d76fdf1e9bddcc9ae14f71fcdcf54"
+dependencies = [
+ "parity-scale-codec",
+ "scale-type-resolver",
+]
+
+[[package]]
+name = "scale-decode"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b12ebca36cec2a3f983c46295b282b35e5f8496346fb859a8776dad5389e5389"
+dependencies = [
+ "derive_more",
+ "parity-scale-codec",
+ "scale-bits",
+ "scale-type-resolver",
+ "smallvec",
+]
+
 [[package]]
 name = "scale-info"
 version = "2.11.3"
@@ -17739,6 +18298,12 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "scale-type-resolver"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0cded6518aa0bd6c1be2b88ac81bf7044992f0f154bfbabd5ad34f43512abcb"
+
 [[package]]
 name = "schannel"
 version = "0.1.22"
@@ -17778,7 +18343,7 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "772575a524feeb803e5b0fcbc6dd9f367e579488197c94c6e4023aad2305774d"
 dependencies = [
- "ahash 0.8.8",
+ "ahash 0.8.11",
  "cfg-if",
  "hashbrown 0.13.2",
 ]
@@ -17808,7 +18373,7 @@ dependencies = [
  "aead",
  "arrayref",
  "arrayvec 0.7.4",
- "curve25519-dalek 4.1.2",
+ "curve25519-dalek 4.1.3",
  "getrandom_or_panic",
  "merlin",
  "rand_core 0.6.4",
@@ -17848,9 +18413,9 @@ dependencies = [
 
 [[package]]
 name = "sctp-proto"
-version = "0.1.7"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f64cef148d3295c730c3cb340b0b252a4d570b1c7d4bf0808f88540b0a888bc"
+checksum = "b6220f78bb44c15f326b0596113305f6101097a18755d53727a575c97e09fb24"
 dependencies = [
  "bytes",
  "crc",
@@ -17887,18 +18452,18 @@ dependencies = [
 
 [[package]]
 name = "secp256k1"
-version = "0.28.0"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acea373acb8c21ecb5a23741452acd2593ed44ee3d343e72baaa143bc89d0d5"
+checksum = "d24b59d129cdadea20aea4fb2352fa053712e5d713eee47d700cd4b2bc002f10"
 dependencies = [
  "secp256k1-sys",
 ]
 
 [[package]]
 name = "secp256k1-sys"
-version = "0.9.0"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09e67c467c38fd24bd5499dc9a18183b31575c12ee549197e3e20d57aa4fe3b7"
+checksum = "e5d1746aae42c19d583c3c1a8c646bfad910498e2051c551a7f2e3c0c9fbb7eb"
 dependencies = [
  "cc",
 ]
@@ -18419,9 +18984,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.11.2"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "smol"
@@ -18498,7 +19063,7 @@ dependencies = [
  "smallvec",
  "soketto",
  "twox-hash",
- "wasmi",
+ "wasmi 0.31.2",
  "x25519-dalek 2.0.0",
  "zeroize",
 ]
@@ -18554,7 +19119,7 @@ dependencies = [
  "aes-gcm",
  "blake2 0.10.6",
  "chacha20poly1305",
- "curve25519-dalek 4.1.2",
+ "curve25519-dalek 4.1.3",
  "rand_core 0.6.4",
  "ring 0.17.7",
  "rustc_version 0.4.0",
@@ -19004,6 +19569,7 @@ dependencies = [
 name = "sp-api"
 version = "26.0.0"
 dependencies = [
+ "docify",
  "hash-db",
  "log",
  "parity-scale-codec",
@@ -19497,7 +20063,8 @@ name = "sp-io"
 version = "30.0.0"
 dependencies = [
  "bytes",
- "ed25519-dalek 2.1.0",
+ "docify",
+ "ed25519-dalek 2.1.1",
  "libsecp256k1",
  "log",
  "parity-scale-codec",
@@ -19570,9 +20137,9 @@ name = "sp-mmr-primitives"
 version = "26.0.0"
 dependencies = [
  "array-bytes",
- "ckb-merkle-mountain-range 0.6.0",
  "log",
  "parity-scale-codec",
+ "polkadot-ckb-merkle-mountain-range",
  "scale-info",
  "serde",
  "sp-api",
@@ -19798,6 +20365,7 @@ dependencies = [
 name = "sp-state-machine"
 version = "0.35.0"
 dependencies = [
+ "arbitrary",
  "array-bytes",
  "assert_matches",
  "hash-db",
@@ -19822,8 +20390,8 @@ name = "sp-statement-store"
 version = "10.0.0"
 dependencies = [
  "aes-gcm",
- "curve25519-dalek 4.1.2",
- "ed25519-dalek 2.1.0",
+ "curve25519-dalek 4.1.3",
+ "ed25519-dalek 2.1.1",
  "hkdf",
  "parity-scale-codec",
  "rand 0.8.5",
@@ -19943,7 +20511,7 @@ dependencies = [
 name = "sp-trie"
 version = "29.0.0"
 dependencies = [
- "ahash 0.8.8",
+ "ahash 0.8.11",
  "array-bytes",
  "criterion",
  "hash-db",
@@ -20110,7 +20678,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "staging-chain-spec-builder"
-version = "3.0.0"
+version = "1.6.1"
 dependencies = [
  "clap 4.5.3",
  "log",
@@ -20128,101 +20696,26 @@ dependencies = [
  "clap 4.5.3",
  "clap_complete",
  "criterion",
- "frame-benchmarking",
- "frame-benchmarking-cli",
- "frame-support",
- "frame-system",
- "frame-system-rpc-runtime-api",
  "futures",
  "jsonrpsee",
  "kitchensink-runtime",
  "log",
- "mmr-gadget",
  "nix 0.28.0",
  "node-primitives",
  "node-rpc",
  "node-testing",
- "pallet-asset-conversion-tx-payment",
- "pallet-asset-tx-payment",
- "pallet-assets",
- "pallet-balances",
- "pallet-contracts",
- "pallet-glutton",
- "pallet-im-online",
- "pallet-root-testing",
- "pallet-skip-feeless-payment",
- "pallet-sudo",
- "pallet-timestamp",
- "pallet-transaction-payment",
- "pallet-treasury",
  "parity-scale-codec",
  "platforms",
+ "polkadot-sdk",
  "rand 0.8.5",
  "regex",
- "sc-authority-discovery",
- "sc-basic-authorship",
- "sc-block-builder",
- "sc-chain-spec",
- "sc-cli",
- "sc-client-api",
- "sc-client-db",
- "sc-consensus",
- "sc-consensus-babe",
- "sc-consensus-beefy",
- "sc-consensus-epochs",
- "sc-consensus-grandpa",
- "sc-consensus-slots",
- "sc-executor",
- "sc-keystore",
- "sc-mixnet",
- "sc-network",
- "sc-network-common",
- "sc-network-statement",
- "sc-network-sync",
- "sc-offchain",
- "sc-rpc",
- "sc-service",
  "sc-service-test",
- "sc-statement-store",
- "sc-storage-monitor",
- "sc-sync-state-rpc",
- "sc-sysinfo",
- "sc-telemetry",
- "sc-transaction-pool",
- "sc-transaction-pool-api",
  "scale-info",
  "serde",
  "serde_json",
  "soketto",
- "sp-api",
- "sp-application-crypto",
- "sp-authority-discovery",
- "sp-blockchain",
- "sp-consensus",
- "sp-consensus-babe",
- "sp-consensus-beefy",
- "sp-consensus-grandpa",
- "sp-core",
- "sp-crypto-hashing",
- "sp-externalities 0.25.0",
- "sp-genesis-builder",
- "sp-inherents",
- "sp-io",
- "sp-keyring",
- "sp-keystore",
- "sp-mixnet",
- "sp-mmr-primitives",
- "sp-runtime",
- "sp-state-machine",
- "sp-statement-store",
- "sp-timestamp",
- "sp-tracing 16.0.0",
- "sp-transaction-storage-proof",
- "sp-trie",
  "staging-node-inspect",
- "substrate-build-script-utils",
  "substrate-cli-test-utils",
- "substrate-rpc-client",
  "tempfile",
  "tokio",
  "tokio-util",
@@ -20371,17 +20864,17 @@ dependencies = [
 
 [[package]]
 name = "str0m"
-version = "0.4.1"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3f10d3f68e60168d81110410428a435dbde28cc5525f5f7c6fdec92dbdc2800"
+checksum = "6706347e49b13373f7ddfafad47df7583ed52083d6fc8a594eb2c80497ef959d"
 dependencies = [
  "combine",
  "crc",
+ "fastrand 2.1.0",
  "hmac 0.12.1",
  "once_cell",
  "openssl",
  "openssl-sys",
- "rand 0.8.5",
  "sctp-proto",
  "serde",
  "sha-1 0.10.1",
@@ -20389,6 +20882,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "string-interner"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c6a0d765f5807e98a091107bae0a56ea3799f66a5de47b2c84c94a39c09974e"
+dependencies = [
+ "cfg-if",
+ "hashbrown 0.14.3",
+ "serde",
+]
+
 [[package]]
 name = "strobe-rs"
 version = "0.8.1"
@@ -20571,6 +21075,7 @@ name = "substrate-frame-rpc-system"
 version = "28.0.0"
 dependencies = [
  "assert_matches",
+ "docify",
  "frame-system-rpc-runtime-api",
  "futures",
  "jsonrpsee",
@@ -20706,6 +21211,7 @@ version = "2.0.0"
 dependencies = [
  "array-bytes",
  "frame-executive",
+ "frame-metadata-hash-extension",
  "frame-support",
  "frame-system",
  "frame-system-rpc-runtime-api",
@@ -20797,13 +21303,22 @@ dependencies = [
 name = "substrate-wasm-builder"
 version = "17.0.0"
 dependencies = [
+ "array-bytes",
  "build-helper",
  "cargo_metadata",
  "console",
  "filetime",
+ "frame-metadata",
+ "merkleized-metadata",
+ "parity-scale-codec",
  "parity-wasm",
  "polkavm-linker",
+ "sc-executor",
+ "sp-core",
+ "sp-io",
  "sp-maybe-compressed-blob",
+ "sp-tracing 16.0.0",
+ "sp-version",
  "strum 0.26.2",
  "tempfile",
  "toml 0.8.8",
@@ -21043,7 +21558,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ef1adac450ad7f4b3c28589471ade84f25f731a7a0fe30d71dfa9f60fd808e5"
 dependencies = [
  "cfg-if",
- "fastrand 2.0.0",
+ "fastrand 2.1.0",
  "redox_syscall 0.4.1",
  "rustix 0.38.21",
  "windows-sys 0.48.0",
@@ -21235,9 +21750,9 @@ checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
 
 [[package]]
 name = "thiserror"
-version = "1.0.50"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
  "thiserror-impl",
 ]
@@ -21264,9 +21779,9 @@ dependencies = [
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.50"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
  "proc-macro2 1.0.82",
  "quote 1.0.35",
@@ -21344,14 +21859,16 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.27"
+version = "0.3.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bb39ee79a6d8de55f48f2293a830e040392f1c5f16e336bdd1788cd0aadce07"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
 dependencies = [
  "deranged",
  "itoa",
  "libc",
+ "num-conv",
  "num_threads",
+ "powerfmt",
  "serde",
  "time-core",
  "time-macros",
@@ -21359,16 +21876,17 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
-version = "0.2.13"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "733d258752e9303d392b94b75230d07b0b9c489350c69b851fc6c065fde3e8f9"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
 dependencies = [
+ "num-conv",
  "time-core",
 ]
 
@@ -21510,9 +22028,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.8"
+version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d"
+checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
 dependencies = [
  "bytes",
  "futures-core",
@@ -21520,7 +22038,6 @@ dependencies = [
  "futures-sink",
  "pin-project-lite 0.2.12",
  "tokio",
- "tracing",
 ]
 
 [[package]]
@@ -22421,7 +22938,24 @@ dependencies = [
  "smallvec",
  "spin 0.9.8",
  "wasmi_arena",
- "wasmi_core",
+ "wasmi_core 0.13.0",
+ "wasmparser-nostd",
+]
+
+[[package]]
+name = "wasmi"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50386c99b9c32bd2ed71a55b6dd4040af2580530fae8bdb9a6576571a80d0cca"
+dependencies = [
+ "arrayvec 0.7.4",
+ "multi-stash",
+ "num-derive",
+ "num-traits",
+ "smallvec",
+ "spin 0.9.8",
+ "wasmi_collections",
+ "wasmi_core 0.32.3",
  "wasmparser-nostd",
 ]
 
@@ -22431,6 +22965,17 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "104a7f73be44570cac297b3035d76b169d6599637631cf37a1703326a0727073"
 
+[[package]]
+name = "wasmi_collections"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c128c039340ffd50d4195c3f8ce31aac357f06804cfc494c8b9508d4b30dca4"
+dependencies = [
+ "ahash 0.8.11",
+ "hashbrown 0.14.3",
+ "string-interner",
+]
+
 [[package]]
 name = "wasmi_core"
 version = "0.13.0"
@@ -22443,6 +22988,18 @@ dependencies = [
  "paste",
 ]
 
+[[package]]
+name = "wasmi_core"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a23b3a7f6c8c3ceeec6b83531ee61f0013c56e51cbf2b14b0f213548b23a4b41"
+dependencies = [
+ "downcast-rs",
+ "libm",
+ "num-traits",
+ "paste",
+]
+
 [[package]]
 name = "wasmparser"
 version = "0.102.0"
@@ -22455,9 +23012,9 @@ dependencies = [
 
 [[package]]
 name = "wasmparser-nostd"
-version = "0.100.1"
+version = "0.100.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9157cab83003221bfd385833ab587a039f5d6fa7304854042ba358a3b09e0724"
+checksum = "d5a015fe95f3504a94bb1462c717aae75253e39b9dd6c3fb1062c934535c64aa"
 dependencies = [
  "indexmap-nostd",
 ]
@@ -22742,6 +23299,7 @@ dependencies = [
  "frame-benchmarking",
  "frame-election-provider-support",
  "frame-executive",
+ "frame-metadata-hash-extension",
  "frame-remote-externalities",
  "frame-support",
  "frame-system",
@@ -22760,6 +23318,7 @@ dependencies = [
  "pallet-beefy-mmr",
  "pallet-collective",
  "pallet-conviction-voting",
+ "pallet-delegated-staking",
  "pallet-democracy",
  "pallet-election-provider-multi-phase",
  "pallet-election-provider-support-benchmarking",
@@ -23259,7 +23818,7 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb66477291e7e8d2b0ff1bcb900bf29489a9692816d79874bea351e7a8b6de96"
 dependencies = [
- "curve25519-dalek 4.1.2",
+ "curve25519-dalek 4.1.3",
  "rand_core 0.6.4",
  "serde",
  "zeroize",
diff --git a/Cargo.toml b/Cargo.toml
index 1d02b701d2316ae09e84e3813304e43fee034ec5..ba52b0179ff81000e6fc77498f2d993bdc12fb72 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -144,6 +144,7 @@ members = [
 	"cumulus/test/service",
 	"cumulus/xcm/xcm-emulator",
 	"docs/sdk",
+	"docs/sdk/src/reference_docs/chain_spec_runtime",
 	"polkadot",
 	"polkadot/cli",
 	"polkadot/core-primitives",
@@ -305,6 +306,7 @@ members = [
 	"substrate/frame/asset-conversion/ops",
 	"substrate/frame/asset-rate",
 	"substrate/frame/assets",
+	"substrate/frame/assets-freezer",
 	"substrate/frame/atomic-swap",
 	"substrate/frame/aura",
 	"substrate/frame/authority-discovery",
@@ -361,6 +363,7 @@ members = [
 	"substrate/frame/membership",
 	"substrate/frame/merkle-mountain-range",
 	"substrate/frame/message-queue",
+	"substrate/frame/metadata-hash-extension",
 	"substrate/frame/migrations",
 	"substrate/frame/mixnet",
 	"substrate/frame/multisig",
@@ -373,7 +376,8 @@ members = [
 	"substrate/frame/nomination-pools/benchmarking",
 	"substrate/frame/nomination-pools/fuzzer",
 	"substrate/frame/nomination-pools/runtime-api",
-	"substrate/frame/nomination-pools/test-staking",
+	"substrate/frame/nomination-pools/test-delegate-stake",
+	"substrate/frame/nomination-pools/test-transfer-stake",
 	"substrate/frame/offences",
 	"substrate/frame/offences/benchmarking",
 	"substrate/frame/paged-list",
@@ -513,21 +517,23 @@ members = [
 	"substrate/utils/prometheus",
 	"substrate/utils/substrate-bip39",
 	"substrate/utils/wasm-builder",
-
 	"templates/minimal",
 	"templates/minimal/node",
 	"templates/minimal/pallets/template",
 	"templates/minimal/runtime",
-
+	"templates/parachain/node",
+	"templates/parachain/pallets/template",
+	"templates/parachain/runtime",
 	"templates/solochain/node",
 	"templates/solochain/pallets/template",
 	"templates/solochain/runtime",
+	"umbrella",
+]
 
-	"templates/parachain/node",
-	"templates/parachain/pallets/template",
-	"templates/parachain/runtime",
+default-members = [
+	"polkadot",
+	"substrate/bin/node/cli",
 ]
-default-members = ["polkadot", "substrate/bin/node/cli"]
 
 [workspace.lints.rust]
 suspicious_double_ref_op = { level = "allow", priority = 2 }
diff --git a/README.md b/README.md
index 63743a456f4c8f8561bbeee8c59d63b88d352285..92901d070db0854dd4b1daef8c3ed7a3fd3893f2 100644
--- a/README.md
+++ b/README.md
@@ -1,81 +1,96 @@
-> NOTE: We have recently made significant changes to our repository structure. In order to streamline our development
-process and foster better contributions, we have merged three separate repositories Cumulus, Substrate and Polkadot into
-this repository. Read more about the changes [
-here](https://polkadot-public.notion.site/Polkadot-SDK-FAQ-fbc4cecc2c46443fb37b9eeec2f0d85f).
+
+<div align="center">
+
+![SDK Logo](./docs/images/Polkadot_Logo_Horizontal_Pink_White.png#gh-dark-mode-only)
+![SDK Logo](./docs/images/Polkadot_Logo_Horizontal_Pink_Black.png#gh-light-mode-only)
 
 # Polkadot SDK
 
-![](https://cms.polkadot.network/content/images/2021/06/1-xPcVR_fkITd0ssKBvJ3GMw.png)
+![GitHub stars](https://img.shields.io/github/stars/paritytech/polkadot-sdk)&nbsp;&nbsp;![GitHub
+forks](https://img.shields.io/github/forks/paritytech/polkadot-sdk)
+
+<!-- markdownlint-disable-next-line MD013 -->
+[![StackExchange](https://img.shields.io/badge/StackExchange-Community%20&%20Support-222222?logo=stackexchange)](https://substrate.stackexchange.com/)&nbsp;&nbsp;![GitHub contributors](https://img.shields.io/github/contributors/paritytech/polkadot-sdk)&nbsp;&nbsp;![GitHub commit activity](https://img.shields.io/github/commit-activity/m/paritytech/polkadot-sdk)
+
+![GitHub lines of code](https://tokei.rs/b1/github/paritytech/polkadot-sdk)&nbsp;&nbsp;
+![GitHub last commit](https://img.shields.io/github/last-commit/paritytech/polkadot-sdk)
 
-[![StackExchange](https://img.shields.io/badge/StackExchange-Community%20&%20Support-222222?logo=stackexchange)](https://substrate.stackexchange.com/)
+> The Polkadot SDK repository provides all the components needed to start building on the
+> [Polkadot](https://polkadot.network) network, a multi-chain blockchain platform that enables
+> different blockchains to interoperate and share information in a secure and scalable way.
 
-The Polkadot SDK repository provides all the resources needed to start building on the Polkadot network, a multi-chain
-blockchain platform that enables different blockchains to interoperate and share information in a secure and scalable
-way. The Polkadot SDK comprises three main pieces of software:
+</div>
 
-## [Polkadot](./polkadot/)
-[![PolkadotForum](https://img.shields.io/badge/Polkadot_Forum-e6007a?logo=polkadot)](https://forum.polkadot.network/)
-[![Polkadot-license](https://img.shields.io/badge/License-GPL3-blue)](./polkadot/LICENSE)
+## 📚 Documentation
 
-Implementation of a node for the https://polkadot.network in Rust, using the Substrate framework. This directory
-currently contains runtimes for the Westend and Rococo test networks. Polkadot, Kusama and their system chain runtimes
-are located in the [`runtimes`](https://github.com/polkadot-fellows/runtimes/) repository maintained by
-[the Polkadot Technical Fellowship](https://polkadot-fellows.github.io/dashboard/#/overview).
+* [🦀 rust-docs](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/index.html)
+  * [Introduction](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/index.html)
+	to each component of the Polkadot SDK: Substrate, FRAME, Cumulus, and XCM
+  * [Guides](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/index.html),
+	namely how to build your first FRAME pallet.
+  * [Templates](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/templates/index.html)
+    for starting a new project.
+* Other Resources:
+  * [Polkadot Wiki -> Build](https://wiki.polkadot.network/docs/build-guide)
 
-## [Substrate](./substrate/)
- [![SubstrateRustDocs](https://img.shields.io/badge/Rust_Docs-Substrate-24CC85?logo=rust)](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/substrate/index.html)
- [![Substrate-license](https://img.shields.io/badge/License-GPL3%2FApache2.0-blue)](./substrate/README.md#LICENSE)
+## 🚀 Releases
 
-Substrate is the primary blockchain SDK used by developers to create the parachains that make up the Polkadot network.
-Additionally, it allows for the development of self-sovereign blockchains that operate completely independently of
-Polkadot.
+> [!NOTE]
+> Our release process is still Work-In-Progress and may not yet reflect the aspired outline
+> here.
 
-## [Cumulus](./cumulus/)
-[![CumulusRustDocs](https://img.shields.io/badge/Rust_Docs-Cumulus-222222?logo=rust)](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/cumulus/index.html)
-[![Cumulus-license](https://img.shields.io/badge/License-GPL3-blue)](./cumulus/LICENSE)
+The Polkadot-SDK has two release channels: `stable` and `nightly`. Production software is advised to
+only use `stable`. `nightly` is meant for tinkerers to try out the latest features. The detailed
+release process is described in [RELEASE.md](docs/RELEASE.md).
 
-Cumulus is a set of tools for writing Substrate-based Polkadot parachains.
+You can use [`psvm`](https://github.com/paritytech/psvm) to manage your Polkadot-SDK dependency
+versions in downstream projects.
 
-## Releases
+### 😌 Stable
 
-> [!NOTE]  
-> Our release process is still Work-In-Progress and may not yet reflect the aspired outline here.
+`stable` releases have a support duration of **three months**. In this period, the release will not
+have any breaking changes. It will receive bug fixes, security fixes, performance fixes and new
+non-breaking features on a **two week** cadence.
 
-The Polkadot-SDK has two release channels: `stable` and `nightly`. Production software is advised to only use `stable`.
-`nightly` is meant for tinkerers to try out the latest features. The detailed release process is described in
-[RELEASE.md](docs/RELEASE.md).
+### 🤠 Nightly
 
-### Stable
+`nightly` releases are released every night from the `master` branch, potentially with breaking
+changes. They have pre-release version numbers in the format `major.0.0-nightlyYYMMDD`.
 
-`stable` releases have a support duration of **three months**. In this period, the release will not have any breaking
-changes. It will receive bug fixes, security fixes, performance fixes and new non-breaking features on a **two week**
-cadence.
+## 🛠️ Tooling
 
-### Nightly
+[Polkadot SDK Version Manager](https://github.com/paritytech/psvm):
+A simple tool to manage and update the Polkadot SDK dependencies in any Cargo.toml file.
+It will automatically update the Polkadot SDK dependencies to their correct crates.io version.
 
-`nightly` releases are released every night from the `master` branch, potentially with breaking changes. They have
-pre-release version numbers in the format `major.0.0-nightlyYYMMDD`.
+## 🔐 Security
 
-## Upstream Dependencies
+The security policy and procedures can be found in
+[docs/contributor/SECURITY.md](./docs/contributor/SECURITY.md).
 
-Below are the primary upstream dependencies utilized in this project:
+## 🤍 Contributing & Code of Conduct
 
-- [`parity-scale-codec`](https://crates.io/crates/parity-scale-codec)
-- [`parity-db`](https://crates.io/crates/parity-db)
-- [`parity-common`](https://github.com/paritytech/parity-common)
-- [`trie`](https://github.com/paritytech/trie)
+Ensure you follow our [contribution guidelines](./docs/contributor/CONTRIBUTING.md). In every
+interaction and contribution, this project adheres to the [Contributor Covenant Code of
+Conduct](./docs/contributor/CODE_OF_CONDUCT.md).
 
-## Security
+### 👾 Ready to Contribute?
 
-The security policy and procedures can be found in [docs/contributor/SECURITY.md](./docs/contributor/SECURITY.md).
+Take a look at the issues labeled with [`mentor`](https://github.com/paritytech/polkadot-sdk/labels/C1-mentor)
+(or alternatively [this](https://mentor.tasty.limo/) page, created by one of the maintainers) label to get started!
+We always recognize valuable contributions by proposing an on-chain tip to the Polkadot network as a token of our
+appreciation.
 
-## Contributing & Code of Conduct
+## Polkadot Fellowship
 
-Ensure you follow our [contribution guidelines](./docs/contributor/CONTRIBUTING.md). In every interaction and
-contribution, this project adheres to the [Contributor Covenant Code of Conduct](./docs/contributor/CODE_OF_CONDUCT.md).
+Development in this repo usually goes hand in hand with the `fellowship` organization. In short,
+this repository provides all the SDK pieces needed to build both Polkadot and its parachains. But,
+the actual Polkadot runtime lives in the `fellowship/runtimes` repository. Read more about the
+fellowship, this separation, the RFC process
+[here](https://polkadot-fellows.github.io/dashboard/).
 
-## Additional Resources
+## History
 
-- For monitoring upcoming changes and current proposals related to the technical implementation of the Polkadot network,
-  visit the [`Requests for Comment (RFC)`](https://github.com/polkadot-fellows/RFCs) repository. While it's maintained
-  by the Polkadot Fellowship, the RFC process welcomes contributions from everyone.
+This repository is the amalgamation of 3 separate repositories that used to make up Polkadot SDK,
+namely Substrate, Polkadot and Cumulus. Read more about the merge and its history
+[here](https://polkadot-public.notion.site/Polkadot-SDK-FAQ-fbc4cecc2c46443fb37b9eeec2f0d85f).
diff --git a/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs b/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs
index 2c152aef68226aee36e791a882b5859427a9a33d..df75092af6e8b89fb76003cf0bfff508214ea825 100644
--- a/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs
+++ b/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs
@@ -36,6 +36,12 @@ use sp_runtime::{
 	transaction_validity::{TransactionPriority, TransactionValidity, ValidTransactionBuilder},
 };
 
+// Re-export to avoid include tuplex dependency everywhere.
+#[doc(hidden)]
+pub mod __private {
+	pub use tuplex;
+}
+
 /// A duplication of the `FilterCall` trait.
 ///
 /// We need this trait in order to be able to implement it for the messages pallet,
@@ -313,7 +319,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
 				info: &sp_runtime::traits::DispatchInfoOf<Self::Call>,
 				len: usize,
 			) -> Result<Self::Pre, sp_runtime::transaction_validity::TransactionValidityError> {
-				use tuplex::PushBack;
+				use $crate::extensions::check_obsolete_extension::__private::tuplex::PushBack;
 				let to_post_dispatch = ();
 				$(
 					let (from_validate, call_filter_validity) = <
@@ -336,7 +342,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
 				len: usize,
 				result: &sp_runtime::DispatchResult,
 			) -> Result<(), sp_runtime::transaction_validity::TransactionValidityError> {
-				use tuplex::PopFront;
+				use $crate::extensions::check_obsolete_extension::__private::tuplex::PopFront;
 				let Some((relayer, to_post_dispatch)) = to_post_dispatch else { return Ok(()) };
 				let has_failed = result.is_err();
 				$(
diff --git a/bridges/bin/runtime-common/src/messages_benchmarking.rs b/bridges/bin/runtime-common/src/messages_benchmarking.rs
index 0c7a9ad1a83d6a83e0c9fe1f5e77ba2c4cefc17d..74494f7908045fac601b4c3f64a456ad12dacd6f 100644
--- a/bridges/bin/runtime-common/src/messages_benchmarking.rs
+++ b/bridges/bin/runtime-common/src/messages_benchmarking.rs
@@ -271,7 +271,7 @@ pub fn generate_xcm_builder_bridge_message_sample(
 	move |expected_message_size| -> MessagePayload {
 		// For XCM bridge hubs, it is the message that
 		// will be pushed further to some XCM queue (XCMP/UMP)
-		let location = xcm::VersionedInteriorLocation::V4(destination.clone());
+		let location = xcm::VersionedInteriorLocation::from(destination.clone());
 		let location_encoded_size = location.encoded_size();
 
 		// we don't need to be super-precise with `expected_size` here
@@ -294,16 +294,13 @@ pub fn generate_xcm_builder_bridge_message_sample(
 			expected_message_size, location_encoded_size, xcm_size, xcm_data_size,
 		);
 
-		let xcm = xcm::VersionedXcm::<()>::V4(
-			vec![Instruction::<()>::ExpectPallet {
-				index: 0,
-				name: vec![42; xcm_data_size],
-				module_name: vec![],
-				crate_major: 0,
-				min_crate_minor: 0,
-			}]
-			.into(),
-		);
+		let xcm = xcm::VersionedXcm::<()>::from(Xcm(vec![Instruction::<()>::ExpectPallet {
+			index: 0,
+			name: vec![42; xcm_data_size],
+			module_name: vec![],
+			crate_major: 0,
+			min_crate_minor: 0,
+		}]));
 
 		// this is the `BridgeMessage` from polkadot xcm builder, but it has no constructor
 		// or public fields, so just tuple
diff --git a/bridges/bin/runtime-common/src/mock.rs b/bridges/bin/runtime-common/src/mock.rs
index e323f1edfc71da8c84fe8cabb977da85ce4d303e..f49474667896049cfd6aff4bf4a4b0d9d6e73c95 100644
--- a/bridges/bin/runtime-common/src/mock.rs
+++ b/bridges/bin/runtime-common/src/mock.rs
@@ -148,7 +148,6 @@ impl frame_system::Config for TestRuntime {
 	type AccountId = ThisChainAccountId;
 	type Block = ThisChainBlock;
 	type AccountData = pallet_balances::AccountData<ThisChainBalance>;
-	type BlockHashCount = ConstU32<250>;
 }
 
 impl pallet_utility::Config for TestRuntime {
diff --git a/bridges/docs/running-relayer.md b/bridges/docs/running-relayer.md
index 710810a476e4df5e4b80fde31f9576be5ad26391..594cbc35a106b1ebd8cc1e9e9c0542c759489197 100644
--- a/bridges/docs/running-relayer.md
+++ b/bridges/docs/running-relayer.md
@@ -139,7 +139,7 @@ your transactions that are **validated** on top of block, where it is active get
 becomes expired when the block with the number you have specified during registration is "mined". It is the
 `validTill` parameter of the `register` call (see below). After that `validTill` block, you may unregister and get
 your reserved funds back. There's also an intermediate point between those blocks - it is the `validTill - LEASE`,
-where `LEASE` is the the chain constant, controlled by the governance. Initially it is set to `300` blocks.
+where `LEASE` is the chain constant, controlled by the governance. Initially it is set to `300` blocks.
 All your transactions, **validated** between the `validTill - LEASE` and `validTill` blocks do not get the
 priority boost. Also, it is forbidden to specify `validTill` such that the `validTill - currentBlock` is less
 than the `LEASE`.
@@ -156,7 +156,7 @@ than the `LEASE`.
 | 700               | Inactive           | Your message delivery transactions are not boosted     |
 | 701               | Inactive           | Your message delivery transactions are not boosted     |
 | ...               | Inactive           | Your message delivery transactions are not boosted     |
-| 1000              | Expired            | Your may submit a tx with the `deregister` call        |
+| 1000              | Expired            | You may submit a tx with the `deregister` call         |
 
 </details>
 
@@ -230,7 +230,7 @@ your relayer account. Then:
 
 - set the `bridgedChainId` to `bhpd`;
 
-- check the both variants of the `owner` field: `ThisChain` is used to pay for message delivery transactions
+- check both variants of the `owner` field: `ThisChain` is used to pay for message delivery transactions
   and `BridgedChain` is used to pay for message confirmation transactions.
 
 If check shows that you have some rewards, you can craft the claim transaction, with similar parameters.
diff --git a/bridges/modules/beefy/src/lib.rs b/bridges/modules/beefy/src/lib.rs
index 27c83921021bb4299b18cbf2d3216427f8c89ccc..ccddcde920f694a87ab22042f44d84707982eefe 100644
--- a/bridges/modules/beefy/src/lib.rs
+++ b/bridges/modules/beefy/src/lib.rs
@@ -316,7 +316,7 @@ pub mod pallet {
 	/// Pallet owner has the right to halt all pallet operations and then resume it. If it is
 	/// `None`, then there are no direct ways to halt/resume pallet operations, but other
 	/// runtime methods may still be used to do that (i.e. `democracy::referendum` to update halt
-	/// flag directly or calling `halt_operations`).
+	/// flag directly or calling `set_operating_mode`).
 	#[pallet::storage]
 	pub type PalletOwner<T: Config<I>, I: 'static = ()> =
 		StorageValue<_, T::AccountId, OptionQuery>;
diff --git a/bridges/modules/beefy/src/mock.rs b/bridges/modules/beefy/src/mock.rs
index c99566b6b06d1855319d614f4f4ddfbf2fb1918b..53efd57c29a0dfc870e43be4fec7bcdf817a3282 100644
--- a/bridges/modules/beefy/src/mock.rs
+++ b/bridges/modules/beefy/src/mock.rs
@@ -66,7 +66,7 @@ construct_runtime! {
 	}
 }
 
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for TestRuntime {
 	type Block = Block;
 }
diff --git a/bridges/modules/grandpa/README.md b/bridges/modules/grandpa/README.md
index 4a3099b8afc654bfced296aaa0ead4a5d113eb7f..df63f4aa639f21186932bde6b2a475b3873a6bf7 100644
--- a/bridges/modules/grandpa/README.md
+++ b/bridges/modules/grandpa/README.md
@@ -87,7 +87,7 @@ It'd be better for anyone (for chain and for submitters) to reject all transacti
 already known headers to the pallet. This way, we leave block space to other useful transactions and
 we don't charge concurrent submitters for their honest actions.
 
-To deal with that, we have a [signed extension](./src/call_ext) that may be added to the runtime.
+To deal with that, we have a [signed extension](./src/call_ext.rs) that may be added to the runtime.
 It does exactly what is required - rejects all transactions with already known headers. The submitter
 pays nothing for such transactions - they're simply removed from the transaction pool, when the block
 is built.
diff --git a/bridges/modules/grandpa/src/benchmarking.rs b/bridges/modules/grandpa/src/benchmarking.rs
index 11033373ce478fa9fefb613a1377449bb77daf1d..fb7354e05c06eeeab17363d5671cd8d636ec48f3 100644
--- a/bridges/modules/grandpa/src/benchmarking.rs
+++ b/bridges/modules/grandpa/src/benchmarking.rs
@@ -70,11 +70,12 @@ const MAX_VOTE_ANCESTRIES_RANGE_END: u32 =
 // the same with validators - if there are too much validators, let's run benchmarks on subrange
 fn precommits_range_end<T: Config<I>, I: 'static>() -> u32 {
 	let max_bridged_authorities = T::BridgedChain::MAX_AUTHORITIES_COUNT;
-	if max_bridged_authorities > 128 {
+	let max_bridged_authorities = if max_bridged_authorities > 128 {
 		sp_std::cmp::max(128, max_bridged_authorities / 5)
 	} else {
 		max_bridged_authorities
 	};
+
 	required_justification_precommits(max_bridged_authorities)
 }
 
@@ -138,5 +139,19 @@ benchmarks_instance_pallet! {
 		assert!(!<ImportedHeaders<T, I>>::contains_key(genesis_header.hash()));
 	}
 
+	force_set_pallet_state {
+		let set_id = 100;
+		let authorities = accounts(T::BridgedChain::MAX_AUTHORITIES_COUNT as u16)
+			.iter()
+			.map(|id| (AuthorityId::from(*id), 1))
+			.collect::<Vec<_>>();
+		let (header, _) = prepare_benchmark_data::<T, I>(1, 1);
+		let expected_hash = header.hash();
+	}: force_set_pallet_state(RawOrigin::Root, set_id, authorities, Box::new(header))
+	verify {
+		assert_eq!(<BestFinalized<T, I>>::get().unwrap().1, expected_hash);
+		assert_eq!(<CurrentAuthoritySet<T, I>>::get().set_id, set_id);
+	}
+
 	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime)
 }
diff --git a/bridges/modules/grandpa/src/call_ext.rs b/bridges/modules/grandpa/src/call_ext.rs
index 98fbeaa30bbac4c6bade6dc4b7d2f97d53940c6b..f08eb4c5d1ab5ae231afc388dacb0699d58fbc46 100644
--- a/bridges/modules/grandpa/src/call_ext.rs
+++ b/bridges/modules/grandpa/src/call_ext.rs
@@ -18,12 +18,8 @@ use crate::{
 	weights::WeightInfo, BestFinalized, BridgedBlockNumber, BridgedHeader, Config,
 	CurrentAuthoritySet, Error, FreeHeadersRemaining, Pallet,
 };
-use bp_header_chain::{
-	justification::GrandpaJustification, max_expected_submit_finality_proof_arguments_size,
-	ChainWithGrandpa, GrandpaConsensusLogReader,
-};
+use bp_header_chain::{justification::GrandpaJustification, submit_finality_proof_limits_extras};
 use bp_runtime::{BlockNumberOf, Chain, OwnedBridgeModule};
-use codec::Encode;
 use frame_support::{
 	dispatch::CallableCallFor,
 	traits::{Get, IsSubType},
@@ -303,53 +299,31 @@ pub(crate) fn submit_finality_proof_info_from_args<T: Config<I>, I: 'static>(
 	current_set_id: Option<SetId>,
 	is_free_execution_expected: bool,
 ) -> SubmitFinalityProofInfo<BridgedBlockNumber<T, I>> {
-	let block_number = *finality_target.number();
-
-	// the `submit_finality_proof` call will reject justifications with invalid, duplicate,
-	// unknown and extra signatures. It'll also reject justifications with less than necessary
-	// signatures. So we do not care about extra weight because of additional signatures here.
-	let precommits_len = justification.commit.precommits.len().saturated_into();
-	let required_precommits = precommits_len;
+	// check if call exceeds limits. In other words - whether some size or weight is included
+	// in the call
+	let extras =
+		submit_finality_proof_limits_extras::<T::BridgedChain>(finality_target, justification);
 
 	// We do care about extra weight because of more-than-expected headers in the votes
 	// ancestries. But we have problems computing extra weight for additional headers (weight of
 	// additional header is too small, so that our benchmarks aren't detecting that). So if there
 	// are more than expected headers in votes ancestries, we will treat the whole call weight
 	// as an extra weight.
-	let votes_ancestries_len = justification.votes_ancestries.len().saturated_into();
-	let extra_weight =
-		if votes_ancestries_len > T::BridgedChain::REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY {
-			T::WeightInfo::submit_finality_proof(precommits_len, votes_ancestries_len)
-		} else {
-			Weight::zero()
-		};
-
-	// check if the `finality_target` is a mandatory header. If so, we are ready to refund larger
-	// size
-	let is_mandatory_finality_target =
-		GrandpaConsensusLogReader::<BridgedBlockNumber<T, I>>::find_scheduled_change(
-			finality_target.digest(),
-		)
-		.is_some();
-
-	// we can estimate extra call size easily, without any additional significant overhead
-	let actual_call_size: u32 = finality_target
-		.encoded_size()
-		.saturating_add(justification.encoded_size())
-		.saturated_into();
-	let max_expected_call_size = max_expected_submit_finality_proof_arguments_size::<T::BridgedChain>(
-		is_mandatory_finality_target,
-		required_precommits,
-	);
-	let extra_size = actual_call_size.saturating_sub(max_expected_call_size);
+	let extra_weight = if extras.is_weight_limit_exceeded {
+		let precommits_len = justification.commit.precommits.len().saturated_into();
+		let votes_ancestries_len = justification.votes_ancestries.len().saturated_into();
+		T::WeightInfo::submit_finality_proof(precommits_len, votes_ancestries_len)
+	} else {
+		Weight::zero()
+	};
 
 	SubmitFinalityProofInfo {
-		block_number,
+		block_number: *finality_target.number(),
 		current_set_id,
-		is_mandatory: is_mandatory_finality_target,
+		is_mandatory: extras.is_mandatory_finality_target,
 		is_free_execution_expected,
 		extra_weight,
-		extra_size,
+		extra_size: extras.extra_size,
 	}
 }
 
diff --git a/bridges/modules/grandpa/src/lib.rs b/bridges/modules/grandpa/src/lib.rs
index a927882aaaa27210c4777fa2e99a109b4d8b500b..3b77f676870e1a28b8367f1b14d24c9ca83ece4a 100644
--- a/bridges/modules/grandpa/src/lib.rs
+++ b/bridges/modules/grandpa/src/lib.rs
@@ -44,7 +44,7 @@ use bp_header_chain::{
 };
 use bp_runtime::{BlockNumberOf, HashOf, HasherOf, HeaderId, HeaderOf, OwnedBridgeModule};
 use frame_support::{dispatch::PostDispatchInfo, ensure, DefaultNoBound};
-use sp_consensus_grandpa::SetId;
+use sp_consensus_grandpa::{AuthorityList, SetId};
 use sp_runtime::{
 	traits::{Header as HeaderT, Zero},
 	SaturatedConversion,
@@ -360,6 +360,42 @@ pub mod pallet {
 
 			Ok(PostDispatchInfo { actual_weight: Some(actual_weight), pays_fee })
 		}
+
+		/// Set current authorities set and best finalized bridged header to given values
+		/// (almost) without any checks. This call can fail only if:
+		///
+		/// - the call origin is not a root or a pallet owner;
+		///
+		/// - there are too many authorities in the new set.
+		///
+		/// No other checks are made. Previously imported headers stay in the storage and
+		/// are still accessible after the call.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::force_set_pallet_state())]
+		pub fn force_set_pallet_state(
+			origin: OriginFor<T>,
+			new_current_set_id: SetId,
+			new_authorities: AuthorityList,
+			new_best_header: Box<BridgedHeader<T, I>>,
+		) -> DispatchResult {
+			Self::ensure_owner_or_root(origin)?;
+
+			// save new authorities set. It only fails if there are too many authorities
+			// in the new set
+			save_authorities_set::<T, I>(
+				CurrentAuthoritySet::<T, I>::get().set_id,
+				new_current_set_id,
+				new_authorities,
+			)?;
+
+			// save new best header. It may be older than the best header that is already
+			// known to the pallet - it changes nothing (except for the fact that previously
+			// imported headers may still be used to prove something)
+			let new_best_header_hash = new_best_header.hash();
+			insert_header::<T, I>(*new_best_header, new_best_header_hash);
+
+			Ok(())
+		}
 	}
 
 	/// Number of free header submissions that we may yet accept in the current block.
@@ -423,7 +459,7 @@ pub mod pallet {
 	/// Pallet owner has a right to halt all pallet operations and then resume it. If it is
 	/// `None`, then there are no direct ways to halt/resume pallet operations, but other
 	/// runtime methods may still be used to do that (i.e. democracy::referendum to update halt
-	/// flag directly or call the `halt_operations`).
+	/// flag directly or call the `set_operating_mode`).
 	#[pallet::storage]
 	pub type PalletOwner<T: Config<I>, I: 'static = ()> =
 		StorageValue<_, T::AccountId, OptionQuery>;
@@ -592,33 +628,45 @@ pub mod pallet {
 			// GRANDPA only includes a `delay` for forced changes, so this isn't valid.
 			ensure!(change.delay == Zero::zero(), <Error<T, I>>::UnsupportedScheduledChange);
 
-			// TODO [#788]: Stop manually increasing the `set_id` here.
-			let next_authorities = StoredAuthoritySet::<T, I> {
-				authorities: change
-					.next_authorities
-					.try_into()
-					.map_err(|_| Error::<T, I>::TooManyAuthoritiesInSet)?,
-				set_id: current_set_id + 1,
-			};
-
 			// Since our header schedules a change and we know the delay is 0, it must also enact
 			// the change.
-			<CurrentAuthoritySet<T, I>>::put(&next_authorities);
-
-			log::info!(
-				target: LOG_TARGET,
-				"Transitioned from authority set {} to {}! New authorities are: {:?}",
+			// TODO [#788]: Stop manually increasing the `set_id` here.
+			return save_authorities_set::<T, I>(
 				current_set_id,
 				current_set_id + 1,
-				next_authorities,
+				change.next_authorities,
 			);
-
-			return Ok(Some(next_authorities.into()))
 		};
 
 		Ok(None)
 	}
 
+	/// Save new authorities set.
+	pub(crate) fn save_authorities_set<T: Config<I>, I: 'static>(
+		old_current_set_id: SetId,
+		new_current_set_id: SetId,
+		new_authorities: AuthorityList,
+	) -> Result<Option<AuthoritySet>, DispatchError> {
+		let next_authorities = StoredAuthoritySet::<T, I> {
+			authorities: new_authorities
+				.try_into()
+				.map_err(|_| Error::<T, I>::TooManyAuthoritiesInSet)?,
+			set_id: new_current_set_id,
+		};
+
+		<CurrentAuthoritySet<T, I>>::put(&next_authorities);
+
+		log::info!(
+			target: LOG_TARGET,
+			"Transitioned from authority set {} to {}! New authorities are: {:?}",
+			old_current_set_id,
+			new_current_set_id,
+			next_authorities,
+		);
+
+		Ok(Some(next_authorities.into()))
+	}
+
 	/// Verify a GRANDPA justification (finality proof) for a given header.
 	///
 	/// Will use the GRANDPA current authorities known to the pallet.
@@ -1700,4 +1748,98 @@ mod tests {
 			assert_eq!(FreeHeadersRemaining::<TestRuntime, ()>::get(), Some(0));
 		})
 	}
+
+	#[test]
+	fn force_set_pallet_state_works() {
+		run_test(|| {
+			let header25 = test_header(25);
+			let header50 = test_header(50);
+			let ok_new_set_id = 100;
+			let ok_new_authorities = authority_list();
+			let bad_new_set_id = 100;
+			let bad_new_authorities: Vec<_> = std::iter::repeat((ALICE.into(), 1))
+				.take(MAX_BRIDGED_AUTHORITIES as usize + 1)
+				.collect();
+
+			// initialize and import several headers
+			initialize_substrate_bridge();
+			assert_ok!(submit_finality_proof(30));
+
+			// wrong origin => error
+			assert_noop!(
+				Pallet::<TestRuntime>::force_set_pallet_state(
+					RuntimeOrigin::signed(1),
+					ok_new_set_id,
+					ok_new_authorities.clone(),
+					Box::new(header50.clone()),
+				),
+				DispatchError::BadOrigin,
+			);
+
+			// too many authorities in the set => error
+			assert_noop!(
+				Pallet::<TestRuntime>::force_set_pallet_state(
+					RuntimeOrigin::root(),
+					bad_new_set_id,
+					bad_new_authorities.clone(),
+					Box::new(header50.clone()),
+				),
+				Error::<TestRuntime>::TooManyAuthoritiesInSet,
+			);
+
+			// force import header 50 => ok
+			assert_ok!(Pallet::<TestRuntime>::force_set_pallet_state(
+				RuntimeOrigin::root(),
+				ok_new_set_id,
+				ok_new_authorities.clone(),
+				Box::new(header50.clone()),
+			),);
+
+			// force import header 25 after 50 => ok
+			assert_ok!(Pallet::<TestRuntime>::force_set_pallet_state(
+				RuntimeOrigin::root(),
+				ok_new_set_id,
+				ok_new_authorities.clone(),
+				Box::new(header25.clone()),
+			),);
+
+			// we may import better headers
+			assert_noop!(submit_finality_proof(20), Error::<TestRuntime>::OldHeader);
+			assert_ok!(submit_finality_proof_with_set_id(26, ok_new_set_id));
+
+			// we can even reimport header #50. It **will cause** some issues during pruning
+			// (see below)
+			assert_ok!(submit_finality_proof_with_set_id(50, ok_new_set_id));
+
+			// and all headers are available. Even though there are 4 headers, the ring
+			// buffer thinks that there are 5, because we've imported header $50 twice
+			assert!(GrandpaChainHeaders::<TestRuntime, ()>::finalized_header_state_root(
+				test_header(30).hash()
+			)
+			.is_some());
+			assert!(GrandpaChainHeaders::<TestRuntime, ()>::finalized_header_state_root(
+				test_header(50).hash()
+			)
+			.is_some());
+			assert!(GrandpaChainHeaders::<TestRuntime, ()>::finalized_header_state_root(
+				test_header(25).hash()
+			)
+			.is_some());
+			assert!(GrandpaChainHeaders::<TestRuntime, ()>::finalized_header_state_root(
+				test_header(26).hash()
+			)
+			.is_some());
+
+			// next header import will prune header 30
+			assert_ok!(submit_finality_proof_with_set_id(70, ok_new_set_id));
+			// next header import will prune header 50
+			assert_ok!(submit_finality_proof_with_set_id(80, ok_new_set_id));
+			// next header import will prune header 25
+			assert_ok!(submit_finality_proof_with_set_id(90, ok_new_set_id));
+			// next header import will prune header 26
+			assert_ok!(submit_finality_proof_with_set_id(100, ok_new_set_id));
+			// next header import will prune header 50 again. But it is fine
+			assert_ok!(submit_finality_proof_with_set_id(110, ok_new_set_id));
+		});
+	}
 }
diff --git a/bridges/modules/grandpa/src/weights.rs b/bridges/modules/grandpa/src/weights.rs
index a75e7b5a8e4ada8ce880a040492c904d8035642c..9719bc9c022e2f082307ddf49fc02eb70f4c3497 100644
--- a/bridges/modules/grandpa/src/weights.rs
+++ b/bridges/modules/grandpa/src/weights.rs
@@ -51,6 +51,7 @@ use sp_std::marker::PhantomData;
 /// Weight functions needed for pallet_bridge_grandpa.
 pub trait WeightInfo {
 	fn submit_finality_proof(p: u32, v: u32) -> Weight;
+	fn force_set_pallet_state() -> Weight;
 }
 
 /// Weights for `pallet_bridge_grandpa` that are generated using one of the Bridge testnets.
@@ -109,6 +110,30 @@ impl<T: frame_system::Config> WeightInfo for BridgeWeight<T> {
 			.saturating_add(T::DbWeight::get().reads(6_u64))
 			.saturating_add(T::DbWeight::get().writes(6_u64))
 	}
+
+	/// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:1)
+	/// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`:
+	/// Some(50250), added: 50745, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1)
+	/// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`:
+	/// Some(4), added: 499, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHashes`
+	/// (r:1 w:1) Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024),
+	/// `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::BestFinalized` (r:0 w:1)
+	/// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36),
+	/// added: 531, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0
+	/// w:2) Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`:
+	/// Some(68), added: 1553, mode: `MaxEncodedLen`)
+	fn force_set_pallet_state() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `452`
+		//  Estimated: `51735`
+		// Minimum execution time: 62_232_000 picoseconds.
+		Weight::from_parts(78_755_000, 0)
+			.saturating_add(Weight::from_parts(0, 51735))
+			.saturating_add(RocksDbWeight::get().reads(3))
+			.saturating_add(RocksDbWeight::get().writes(6))
+	}
 }
 
 // For backwards compatibility and tests
@@ -164,4 +189,28 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(6_u64))
 			.saturating_add(RocksDbWeight::get().writes(6_u64))
 	}
+
+	/// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:1)
+	/// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`:
+	/// Some(50250), added: 50745, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1)
+	/// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`:
+	/// Some(4), added: 499, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHashes`
+	/// (r:1 w:1) Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024),
+	/// `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::BestFinalized` (r:0 w:1)
+	/// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36),
+	/// added: 531, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0
+	/// w:2) Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`:
+	/// Some(68), added: 1553, mode: `MaxEncodedLen`)
+	fn force_set_pallet_state() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `452`
+		//  Estimated: `51735`
+		// Minimum execution time: 62_232_000 picoseconds.
+		Weight::from_parts(78_755_000, 0)
+			.saturating_add(Weight::from_parts(0, 51735))
+			.saturating_add(RocksDbWeight::get().reads(3))
+			.saturating_add(RocksDbWeight::get().writes(6))
+	}
 }
diff --git a/bridges/modules/messages/README.md b/bridges/modules/messages/README.md
index fe62305748cd1d6030a7a8085bff29f24ee4dbc5..c06b96b857dea1cdf7fdaed81e70d66aff116064 100644
--- a/bridges/modules/messages/README.md
+++ b/bridges/modules/messages/README.md
@@ -187,11 +187,13 @@ There may be a special account in every runtime where the messages module is dep
 owner', is like a module-level sudo account - he's able to halt and resume all module operations without requiring
 runtime upgrade. Calls that are related to this account are:
 - `fn set_owner()`: current module owner may call it to transfer "ownership" to another account;
-- `fn halt_operations()`: the module owner (or sudo account) may call this function to stop all module operations. After
-  this call, all message-related transactions will be rejected until further `resume_operations` call'. This call may be
-  used when something extraordinary happens with the bridge;
-- `fn resume_operations()`: module owner may call this function to resume bridge operations. The module will resume its
-  regular operations after this call.
+- `fn set_operating_mode()`: the module owner (or sudo account) may call this function to pause/resume
+  pallet operations. Owner may halt the pallet by calling this method with
+  `MessagesOperatingMode::Basic(BasicOperatingMode::Halted)` argument - all message-related
+  transactions will be rejected. Owner may then resume pallet operations by passing the
+  `MessagesOperatingMode::Basic(BasicOperatingMode::Normal)` argument. There's also
+  `MessagesOperatingMode::RejectingOutboundMessages` pallet mode, where it still accepts all incoming
+  messages, but all outbound messages are rejected.
 
 If pallet owner is not defined, the governance may be used to make those calls.
 
diff --git a/bridges/modules/messages/src/lib.rs b/bridges/modules/messages/src/lib.rs
index bc00db9eba5ba12dbdaa0de7008f293a727a7ef5..e31a4542056cb30466f236d0dc9957c053a03f66 100644
--- a/bridges/modules/messages/src/lib.rs
+++ b/bridges/modules/messages/src/lib.rs
@@ -573,7 +573,7 @@ pub mod pallet {
 	/// Pallet owner has a right to halt all pallet operations and then resume it. If it is
 	/// `None`, then there are no direct ways to halt/resume pallet operations, but other
 	/// runtime methods may still be used to do that (i.e. democracy::referendum to update halt
-	/// flag directly or call the `halt_operations`).
+	/// flag directly or call the `set_operating_mode`).
 	#[pallet::storage]
 	#[pallet::getter(fn module_owner)]
 	pub type PalletOwner<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
diff --git a/bridges/modules/messages/src/mock.rs b/bridges/modules/messages/src/mock.rs
index ec63f15b94b5205d744b1379bd6697a4ae43534a..3a1e0063d5337769b75b35035116aaff6e2b2e08 100644
--- a/bridges/modules/messages/src/mock.rs
+++ b/bridges/modules/messages/src/mock.rs
@@ -86,7 +86,6 @@ impl frame_system::Config for TestRuntime {
 
 #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for TestRuntime {
-	type ReserveIdentifier = [u8; 8];
 	type AccountStore = System;
 }
 
diff --git a/bridges/modules/parachains/src/lib.rs b/bridges/modules/parachains/src/lib.rs
index 61e04aed3770dcaa9cb611dc754aad21325e1b39..d323aef3b22070d1db1e4709fe0dad8bf0360caf 100644
--- a/bridges/modules/parachains/src/lib.rs
+++ b/bridges/modules/parachains/src/lib.rs
@@ -260,7 +260,7 @@ pub mod pallet {
 	/// Pallet owner has a right to halt all pallet operations and then resume them. If it is
 	/// `None`, then there are no direct ways to halt/resume pallet operations, but other
 	/// runtime methods may still be used to do that (i.e. democracy::referendum to update halt
-	/// flag directly or call the `halt_operations`).
+	/// flag directly or call the `set_operating_mode`).
 	#[pallet::storage]
 	pub type PalletOwner<T: Config<I>, I: 'static = ()> =
 		StorageValue<_, T::AccountId, OptionQuery>;
diff --git a/bridges/modules/relayers/src/lib.rs b/bridges/modules/relayers/src/lib.rs
index 7a3a0f9ea94cbe5768bf6ee8c850355193ea44f0..2c86ec01f5b915bc3b3b1e65c15adae7c45e1819 100644
--- a/bridges/modules/relayers/src/lib.rs
+++ b/bridges/modules/relayers/src/lib.rs
@@ -63,7 +63,7 @@ pub mod pallet {
 		/// The overarching event type.
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 		/// Type of relayer reward.
-		type Reward: AtLeast32BitUnsigned + Copy + Parameter + MaxEncodedLen;
+		type Reward: AtLeast32BitUnsigned + Copy + Member + Parameter + MaxEncodedLen;
 		/// Pay rewards scheme.
 		type PaymentProcedure: PaymentProcedure<Self::AccountId, Self::Reward>;
 		/// Stake and slash scheme.
diff --git a/bridges/primitives/header-chain/src/lib.rs b/bridges/primitives/header-chain/src/lib.rs
index ad496012c6a3f95d636a2c1ae52fcb5f4ec5434d..af2afb65a26a7f206fdbfcf22e20cb5100a8c95f 100644
--- a/bridges/primitives/header-chain/src/lib.rs
+++ b/bridges/primitives/header-chain/src/lib.rs
@@ -24,8 +24,8 @@ use crate::justification::{
 	GrandpaJustification, JustificationVerificationContext, JustificationVerificationError,
 };
 use bp_runtime::{
-	BasicOperatingMode, Chain, HashOf, HasherOf, HeaderOf, RawStorageProof, StorageProofChecker,
-	StorageProofError, UnderlyingChainProvider,
+	BasicOperatingMode, BlockNumberOf, Chain, HashOf, HasherOf, HeaderOf, RawStorageProof,
+	StorageProofChecker, StorageProofError, UnderlyingChainProvider,
 };
 use codec::{Codec, Decode, Encode, EncodeLike, MaxEncodedLen};
 use core::{clone::Clone, cmp::Eq, default::Default, fmt::Debug};
@@ -35,7 +35,7 @@ use serde::{Deserialize, Serialize};
 use sp_consensus_grandpa::{
 	AuthorityList, ConsensusLog, ScheduledChange, SetId, GRANDPA_ENGINE_ID,
 };
-use sp_runtime::{traits::Header as HeaderT, Digest, RuntimeDebug};
+use sp_runtime::{traits::Header as HeaderT, Digest, RuntimeDebug, SaturatedConversion};
 use sp_std::{boxed::Box, vec::Vec};
 
 pub mod justification;
@@ -325,6 +325,68 @@ where
 	const AVERAGE_HEADER_SIZE: u32 = <T::Chain as ChainWithGrandpa>::AVERAGE_HEADER_SIZE;
 }
 
+/// Result of checking maximal expected submit finality proof call weight and size.
+#[derive(Debug)]
+pub struct SubmitFinalityProofCallExtras {
+	/// If true, the call weight is larger than what we have assumed.
+	///
+	/// We have some assumptions about headers and justifications of the bridged chain.
+	/// We know that if our assumptions are correct, then the call must not have the
+	/// weight above some limit. The fee paid for weight above that limit, is never refunded.
+	pub is_weight_limit_exceeded: bool,
+	/// Extra size (in bytes) that we assume are included in the call.
+	///
+	/// We have some assumptions about headers and justifications of the bridged chain.
+	/// We know that if our assumptions are correct, then the call must not have the
+	/// weight above some limit. The fee paid for bytes above that limit, is never refunded.
+	pub extra_size: u32,
+	/// A flag that is true if the header is the mandatory header that enacts new
+	/// authorities set.
+	pub is_mandatory_finality_target: bool,
+}
+
+/// Checks whether the given `header` and its finality `proof` fit the maximal expected
+/// call limits (size and weight). The submission may be refunded sometimes (see pallet
+/// configuration for details), but it should fit some limits. If the call has some extra
+/// weight and/or size included, though, we won't refund it or refund will be partial.
+pub fn submit_finality_proof_limits_extras<C: ChainWithGrandpa>(
+	header: &C::Header,
+	proof: &justification::GrandpaJustification<C::Header>,
+) -> SubmitFinalityProofCallExtras {
+	// the `submit_finality_proof` call will reject justifications with invalid, duplicate,
+	// unknown and extra signatures. It'll also reject justifications with less than necessary
+	// signatures. So we do not care about extra weight because of additional signatures here.
+	let precommits_len = proof.commit.precommits.len().saturated_into();
+	let required_precommits = precommits_len;
+
+	// the weight check is simple - we assume that there are no more than the `limit`
+	// headers in the ancestry proof
+	let votes_ancestries_len: u32 = proof.votes_ancestries.len().saturated_into();
+	let is_weight_limit_exceeded =
+		votes_ancestries_len > C::REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY;
+
+	// check if the `finality_target` is a mandatory header. If so, we are ready to refund larger
+	// size
+	let is_mandatory_finality_target =
+		GrandpaConsensusLogReader::<BlockNumberOf<C>>::find_scheduled_change(header.digest())
+			.is_some();
+
+	// we can estimate extra call size easily, without any additional significant overhead
+	let actual_call_size: u32 =
+		header.encoded_size().saturating_add(proof.encoded_size()).saturated_into();
+	let max_expected_call_size = max_expected_submit_finality_proof_arguments_size::<C>(
+		is_mandatory_finality_target,
+		required_precommits,
+	);
+	let extra_size = actual_call_size.saturating_sub(max_expected_call_size);
+
+	SubmitFinalityProofCallExtras {
+		is_weight_limit_exceeded,
+		extra_size,
+		is_mandatory_finality_target,
+	}
+}
+
 /// Returns maximal expected size of `submit_finality_proof` call arguments.
 pub fn max_expected_submit_finality_proof_arguments_size<C: ChainWithGrandpa>(
 	is_mandatory_finality_target: bool,
diff --git a/bridges/primitives/relayers/src/lib.rs b/bridges/primitives/relayers/src/lib.rs
index 2a9ef6a8e1e9aba999ea90045447f7a87fb3813b..436f33db4008013572592939b63c0e02e92b8e99 100644
--- a/bridges/primitives/relayers/src/lib.rs
+++ b/bridges/primitives/relayers/src/lib.rs
@@ -140,8 +140,8 @@ pub struct RelayerRewardsKeyProvider<AccountId, Reward>(PhantomData<(AccountId,
 
 impl<AccountId, Reward> StorageDoubleMapKeyProvider for RelayerRewardsKeyProvider<AccountId, Reward>
 where
-	AccountId: Codec + EncodeLike,
-	Reward: Codec + EncodeLike,
+	AccountId: 'static + Codec + EncodeLike + Send + Sync,
+	Reward: 'static + Codec + EncodeLike + Send + Sync,
 {
 	const MAP_NAME: &'static str = "RelayerRewards";
 
diff --git a/bridges/primitives/runtime/src/lib.rs b/bridges/primitives/runtime/src/lib.rs
index 5daba0351ad48f0ae39b870990b6f5ccea1bec1e..d13c9b40efa0b4ddf1433fdc87ce59eb13c7d9a3 100644
--- a/bridges/primitives/runtime/src/lib.rs
+++ b/bridges/primitives/runtime/src/lib.rs
@@ -255,9 +255,9 @@ pub trait StorageMapKeyProvider {
 	/// The same as `StorageMap::Hasher1`.
 	type Hasher: StorageHasher;
 	/// The same as `StorageMap::Key1`.
-	type Key: FullCodec;
+	type Key: FullCodec + Send + Sync;
 	/// The same as `StorageMap::Value`.
-	type Value: FullCodec;
+	type Value: 'static + FullCodec;
 
 	/// This is a copy of the
 	/// `frame_support::storage::generator::StorageMap::storage_map_final_key`.
@@ -277,13 +277,13 @@ pub trait StorageDoubleMapKeyProvider {
 	/// The same as `StorageDoubleMap::Hasher1`.
 	type Hasher1: StorageHasher;
 	/// The same as `StorageDoubleMap::Key1`.
-	type Key1: FullCodec;
+	type Key1: FullCodec + Send + Sync;
 	/// The same as `StorageDoubleMap::Hasher2`.
 	type Hasher2: StorageHasher;
 	/// The same as `StorageDoubleMap::Key2`.
-	type Key2: FullCodec;
+	type Key2: FullCodec + Send + Sync;
 	/// The same as `StorageDoubleMap::Value`.
-	type Value: FullCodec;
+	type Value: 'static + FullCodec;
 
 	/// This is a copy of the
 	/// `frame_support::storage::generator::StorageDoubleMap::storage_double_map_final_key`.
diff --git a/bridges/relays/client-substrate/Cargo.toml b/bridges/relays/client-substrate/Cargo.toml
index cb7eae4f340c7375ad69b111f6b561c84bc57144..ea267ea5e302a6aaaf5c8a3b825d3f17412b22ff 100644
--- a/bridges/relays/client-substrate/Cargo.toml
+++ b/bridges/relays/client-substrate/Cargo.toml
@@ -22,6 +22,7 @@ rand = "0.8.5"
 scale-info = { version = "2.11.1", features = ["derive"] }
 tokio = { version = "1.37", features = ["rt-multi-thread"] }
 thiserror = { workspace = true }
+quick_cache = "0.3"
 
 # Bridge dependencies
 
diff --git a/bridges/relays/client-substrate/src/chain.rs b/bridges/relays/client-substrate/src/chain.rs
index 40269fe64c879249e9f0ed5ffe070d9fc606bdb6..227e9c31c5bfc6a93df88bb117f29bdb1b7c61d3 100644
--- a/bridges/relays/client-substrate/src/chain.rs
+++ b/bridges/relays/client-substrate/src/chain.rs
@@ -36,6 +36,9 @@ use sp_runtime::{
 };
 use std::{fmt::Debug, time::Duration};
 
+/// Signed block type of given chain.
+pub type SignedBlockOf<C> = <C as Chain>::SignedBlock;
+
 /// Substrate-based chain from minimal relay-client point of view.
 pub trait Chain: ChainBase + Clone {
 	/// Chain name.
diff --git a/bridges/relays/client-substrate/src/client.rs b/bridges/relays/client-substrate/src/client.rs
deleted file mode 100644
index 2e7cb7455f76cceee1c63aae4efb4a5cfe9f2a69..0000000000000000000000000000000000000000
--- a/bridges/relays/client-substrate/src/client.rs
+++ /dev/null
@@ -1,1032 +0,0 @@
-// Copyright 2019-2021 Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
-
-//! Substrate node client.
-
-use crate::{
-	chain::{Chain, ChainWithTransactions},
-	guard::Environment,
-	rpc::{
-		SubstrateAuthorClient, SubstrateChainClient, SubstrateFinalityClient,
-		SubstrateFrameSystemClient, SubstrateStateClient, SubstrateSystemClient,
-	},
-	transaction_stall_timeout, AccountKeyPairOf, ChainWithGrandpa, ConnectionParams, Error, HashOf,
-	HeaderIdOf, Result, SignParam, TransactionTracker, UnsignedTransaction,
-};
-
-use async_std::sync::{Arc, Mutex, RwLock};
-use async_trait::async_trait;
-use bp_runtime::{HeaderIdProvider, StorageDoubleMapKeyProvider, StorageMapKeyProvider};
-use codec::{Decode, Encode};
-use frame_support::weights::Weight;
-use futures::{SinkExt, StreamExt};
-use jsonrpsee::{
-	core::DeserializeOwned,
-	ws_client::{WsClient as RpcClient, WsClientBuilder as RpcClientBuilder},
-};
-use num_traits::{Saturating, Zero};
-use pallet_transaction_payment::RuntimeDispatchInfo;
-use relay_utils::{relay_loop::RECONNECT_DELAY, STALL_TIMEOUT};
-use sp_core::{
-	storage::{StorageData, StorageKey},
-	Bytes, Hasher, Pair,
-};
-use sp_runtime::{
-	traits::Header as HeaderT,
-	transaction_validity::{TransactionSource, TransactionValidity},
-};
-use sp_trie::StorageProof;
-use sp_version::RuntimeVersion;
-use std::{cmp::Ordering, future::Future};
-
-const SUB_API_GRANDPA_AUTHORITIES: &str = "GrandpaApi_grandpa_authorities";
-const SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF: &str =
-	"GrandpaApi_generate_key_ownership_proof";
-const SUB_API_TXPOOL_VALIDATE_TRANSACTION: &str = "TaggedTransactionQueue_validate_transaction";
-const SUB_API_TX_PAYMENT_QUERY_INFO: &str = "TransactionPaymentApi_query_info";
-const MAX_SUBSCRIPTION_CAPACITY: usize = 4096;
-
-/// The difference between best block number and number of its ancestor, that is enough
-/// for us to consider that ancestor an "ancient" block with dropped state.
-///
-/// The relay does not assume that it is connected to the archive node, so it always tries
-/// to use the best available chain state. But sometimes it still may use state of some
-/// old block. If the state of that block is already dropped, relay will see errors when
-/// e.g. it tries to prove something.
-///
-/// By default Substrate-based nodes are storing state for last 256 blocks. We'll use
-/// half of this value.
-pub const ANCIENT_BLOCK_THRESHOLD: u32 = 128;
-
-/// Returns `true` if we think that the state is already discarded for given block.
-pub fn is_ancient_block<N: From<u32> + PartialOrd + Saturating>(block: N, best: N) -> bool {
-	best.saturating_sub(block) >= N::from(ANCIENT_BLOCK_THRESHOLD)
-}
-
-/// Opaque justifications subscription type.
-pub struct Subscription<T>(
-	pub(crate) Mutex<futures::channel::mpsc::Receiver<Option<T>>>,
-	// The following field is not explicitly used by the code. But when it is dropped,
-	// the bakground task receives a shutdown signal.
-	#[allow(dead_code)] pub(crate) futures::channel::oneshot::Sender<()>,
-);
-
-/// Opaque GRANDPA authorities set.
-pub type OpaqueGrandpaAuthoritiesSet = Vec<u8>;
-
-/// A simple runtime version. It only includes the `spec_version` and `transaction_version`.
-#[derive(Copy, Clone, Debug)]
-pub struct SimpleRuntimeVersion {
-	/// Version of the runtime specification.
-	pub spec_version: u32,
-	/// All existing dispatches are fully compatible when this number doesn't change.
-	pub transaction_version: u32,
-}
-
-impl SimpleRuntimeVersion {
-	/// Create a new instance of `SimpleRuntimeVersion` from a `RuntimeVersion`.
-	pub const fn from_runtime_version(runtime_version: &RuntimeVersion) -> Self {
-		Self {
-			spec_version: runtime_version.spec_version,
-			transaction_version: runtime_version.transaction_version,
-		}
-	}
-}
-
-/// Chain runtime version in client
-#[derive(Copy, Clone, Debug)]
-pub enum ChainRuntimeVersion {
-	/// Auto query from chain.
-	Auto,
-	/// Custom runtime version, defined by user.
-	Custom(SimpleRuntimeVersion),
-}
-
-/// Substrate client type.
-///
-/// Cloning `Client` is a cheap operation that only clones internal references. Different
-/// clones of the same client are guaranteed to use the same references.
-pub struct Client<C: Chain> {
-	// Lock order: `submit_signed_extrinsic_lock`, `data`
-	/// Client connection params.
-	params: Arc<ConnectionParams>,
-	/// Saved chain runtime version.
-	chain_runtime_version: ChainRuntimeVersion,
-	/// If several tasks are submitting their transactions simultaneously using
-	/// `submit_signed_extrinsic` method, they may get the same transaction nonce. So one of
-	/// transactions will be rejected from the pool. This lock is here to prevent situations like
-	/// that.
-	submit_signed_extrinsic_lock: Arc<Mutex<()>>,
-	/// Genesis block hash.
-	genesis_hash: HashOf<C>,
-	/// Shared dynamic data.
-	data: Arc<RwLock<ClientData>>,
-}
-
-/// Client data, shared by all `Client` clones.
-struct ClientData {
-	/// Tokio runtime handle.
-	tokio: Arc<tokio::runtime::Runtime>,
-	/// Substrate RPC client.
-	client: Arc<RpcClient>,
-}
-
-/// Already encoded value.
-struct PreEncoded(Vec<u8>);
-
-impl Encode for PreEncoded {
-	fn encode(&self) -> Vec<u8> {
-		self.0.clone()
-	}
-}
-
-#[async_trait]
-impl<C: Chain> relay_utils::relay_loop::Client for Client<C> {
-	type Error = Error;
-
-	async fn reconnect(&mut self) -> Result<()> {
-		let mut data = self.data.write().await;
-		let (tokio, client) = Self::build_client(&self.params).await?;
-		data.tokio = tokio;
-		data.client = client;
-		Ok(())
-	}
-}
-
-impl<C: Chain> Clone for Client<C> {
-	fn clone(&self) -> Self {
-		Client {
-			params: self.params.clone(),
-			chain_runtime_version: self.chain_runtime_version,
-			submit_signed_extrinsic_lock: self.submit_signed_extrinsic_lock.clone(),
-			genesis_hash: self.genesis_hash,
-			data: self.data.clone(),
-		}
-	}
-}
-
-impl<C: Chain> std::fmt::Debug for Client<C> {
-	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-		fmt.debug_struct("Client").field("genesis_hash", &self.genesis_hash).finish()
-	}
-}
-
-impl<C: Chain> Client<C> {
-	/// Returns client that is able to call RPCs on Substrate node over websocket connection.
-	///
-	/// This function will keep connecting to given Substrate node until connection is established
-	/// and is functional. If attempt fail, it will wait for `RECONNECT_DELAY` and retry again.
-	pub async fn new(params: ConnectionParams) -> Self {
-		let params = Arc::new(params);
-		loop {
-			match Self::try_connect(params.clone()).await {
-				Ok(client) => return client,
-				Err(error) => log::error!(
-					target: "bridge",
-					"Failed to connect to {} node: {:?}. Going to retry in {}s",
-					C::NAME,
-					error,
-					RECONNECT_DELAY.as_secs(),
-				),
-			}
-
-			async_std::task::sleep(RECONNECT_DELAY).await;
-		}
-	}
-
-	/// Try to connect to Substrate node over websocket. Returns Substrate RPC client if connection
-	/// has been established or error otherwise.
-	pub async fn try_connect(params: Arc<ConnectionParams>) -> Result<Self> {
-		let (tokio, client) = Self::build_client(&params).await?;
-
-		let number: C::BlockNumber = Zero::zero();
-		let genesis_hash_client = client.clone();
-		let genesis_hash = tokio
-			.spawn(async move {
-				SubstrateChainClient::<C>::block_hash(&*genesis_hash_client, Some(number)).await
-			})
-			.await??;
-
-		let chain_runtime_version = params.chain_runtime_version;
-		let mut client = Self {
-			params,
-			chain_runtime_version,
-			submit_signed_extrinsic_lock: Arc::new(Mutex::new(())),
-			genesis_hash,
-			data: Arc::new(RwLock::new(ClientData { tokio, client })),
-		};
-		Self::ensure_correct_runtime_version(&mut client, chain_runtime_version).await?;
-		Ok(client)
-	}
-
-	// Check runtime version to understand if we need are connected to expected version, or we
-	// need to wait for upgrade, we need to abort immediately.
-	async fn ensure_correct_runtime_version<E: Environment<C, Error = Error>>(
-		env: &mut E,
-		expected: ChainRuntimeVersion,
-	) -> Result<()> {
-		// we are only interested if version mode is bundled or passed using CLI
-		let expected = match expected {
-			ChainRuntimeVersion::Auto => return Ok(()),
-			ChainRuntimeVersion::Custom(expected) => expected,
-		};
-
-		// we need to wait if actual version is < than expected, we are OK of versions are the
-		// same and we need to abort if actual version is > than expected
-		let actual = SimpleRuntimeVersion::from_runtime_version(&env.runtime_version().await?);
-		match actual.spec_version.cmp(&expected.spec_version) {
-			Ordering::Less =>
-				Err(Error::WaitingForRuntimeUpgrade { chain: C::NAME.into(), expected, actual }),
-			Ordering::Equal => Ok(()),
-			Ordering::Greater => {
-				log::error!(
-					target: "bridge",
-					"The {} client is configured to use runtime version {expected:?} and actual \
-					version is {actual:?}. Aborting",
-					C::NAME,
-				);
-				env.abort().await;
-				Err(Error::Custom("Aborted".into()))
-			},
-		}
-	}
-
-	/// Build client to use in connection.
-	async fn build_client(
-		params: &ConnectionParams,
-	) -> Result<(Arc<tokio::runtime::Runtime>, Arc<RpcClient>)> {
-		let tokio = tokio::runtime::Runtime::new()?;
-
-		let uri = match params.uri {
-			Some(ref uri) => uri.clone(),
-			None => {
-				format!(
-					"{}://{}:{}{}",
-					if params.secure { "wss" } else { "ws" },
-					params.host,
-					params.port,
-					match params.path {
-						Some(ref path) => format!("/{}", path),
-						None => String::new(),
-					},
-				)
-			},
-		};
-		log::info!(target: "bridge", "Connecting to {} node at {}", C::NAME, uri);
-
-		let client = tokio
-			.spawn(async move {
-				RpcClientBuilder::default()
-					.max_buffer_capacity_per_subscription(MAX_SUBSCRIPTION_CAPACITY)
-					.build(&uri)
-					.await
-			})
-			.await??;
-
-		Ok((Arc::new(tokio), Arc::new(client)))
-	}
-}
-
-impl<C: Chain> Client<C> {
-	/// Return simple runtime version, only include `spec_version` and `transaction_version`.
-	pub async fn simple_runtime_version(&self) -> Result<SimpleRuntimeVersion> {
-		Ok(match &self.chain_runtime_version {
-			ChainRuntimeVersion::Auto => {
-				let runtime_version = self.runtime_version().await?;
-				SimpleRuntimeVersion::from_runtime_version(&runtime_version)
-			},
-			ChainRuntimeVersion::Custom(version) => *version,
-		})
-	}
-
-	/// Returns true if client is connected to at least one peer and is in synced state.
-	pub async fn ensure_synced(&self) -> Result<()> {
-		self.jsonrpsee_execute(|client| async move {
-			let health = SubstrateSystemClient::<C>::health(&*client).await?;
-			let is_synced = !health.is_syncing && (!health.should_have_peers || health.peers > 0);
-			if is_synced {
-				Ok(())
-			} else {
-				Err(Error::ClientNotSynced(health))
-			}
-		})
-		.await
-	}
-
-	/// Return hash of the genesis block.
-	pub fn genesis_hash(&self) -> &C::Hash {
-		&self.genesis_hash
-	}
-
-	/// Return hash of the best finalized block.
-	pub async fn best_finalized_header_hash(&self) -> Result<C::Hash> {
-		self.jsonrpsee_execute(|client| async move {
-			Ok(SubstrateChainClient::<C>::finalized_head(&*client).await?)
-		})
-		.await
-		.map_err(|e| Error::FailedToReadBestFinalizedHeaderHash {
-			chain: C::NAME.into(),
-			error: e.boxed(),
-		})
-	}
-
-	/// Return number of the best finalized block.
-	pub async fn best_finalized_header_number(&self) -> Result<C::BlockNumber> {
-		Ok(*self.best_finalized_header().await?.number())
-	}
-
-	/// Return header of the best finalized block.
-	pub async fn best_finalized_header(&self) -> Result<C::Header> {
-		self.header_by_hash(self.best_finalized_header_hash().await?).await
-	}
-
-	/// Returns the best Substrate header.
-	pub async fn best_header(&self) -> Result<C::Header>
-	where
-		C::Header: DeserializeOwned,
-	{
-		self.jsonrpsee_execute(|client| async move {
-			Ok(SubstrateChainClient::<C>::header(&*client, None).await?)
-		})
-		.await
-		.map_err(|e| Error::FailedToReadBestHeader { chain: C::NAME.into(), error: e.boxed() })
-	}
-
-	/// Get a Substrate block from its hash.
-	pub async fn get_block(&self, block_hash: Option<C::Hash>) -> Result<C::SignedBlock> {
-		self.jsonrpsee_execute(move |client| async move {
-			Ok(SubstrateChainClient::<C>::block(&*client, block_hash).await?)
-		})
-		.await
-	}
-
-	/// Get a Substrate header by its hash.
-	pub async fn header_by_hash(&self, block_hash: C::Hash) -> Result<C::Header>
-	where
-		C::Header: DeserializeOwned,
-	{
-		self.jsonrpsee_execute(move |client| async move {
-			Ok(SubstrateChainClient::<C>::header(&*client, Some(block_hash)).await?)
-		})
-		.await
-		.map_err(|e| Error::FailedToReadHeaderByHash {
-			chain: C::NAME.into(),
-			hash: format!("{block_hash}"),
-			error: e.boxed(),
-		})
-	}
-
-	/// Get a Substrate block hash by its number.
-	pub async fn block_hash_by_number(&self, number: C::BlockNumber) -> Result<C::Hash> {
-		self.jsonrpsee_execute(move |client| async move {
-			Ok(SubstrateChainClient::<C>::block_hash(&*client, Some(number)).await?)
-		})
-		.await
-	}
-
-	/// Get a Substrate header by its number.
-	pub async fn header_by_number(&self, block_number: C::BlockNumber) -> Result<C::Header>
-	where
-		C::Header: DeserializeOwned,
-	{
-		let block_hash = Self::block_hash_by_number(self, block_number).await?;
-		let header_by_hash = Self::header_by_hash(self, block_hash).await?;
-		Ok(header_by_hash)
-	}
-
-	/// Return runtime version.
-	pub async fn runtime_version(&self) -> Result<RuntimeVersion> {
-		self.jsonrpsee_execute(move |client| async move {
-			Ok(SubstrateStateClient::<C>::runtime_version(&*client).await?)
-		})
-		.await
-	}
-
-	/// Read value from runtime storage.
-	pub async fn storage_value<T: Send + Decode + 'static>(
-		&self,
-		storage_key: StorageKey,
-		block_hash: Option<C::Hash>,
-	) -> Result<Option<T>> {
-		self.raw_storage_value(storage_key, block_hash)
-			.await?
-			.map(|encoded_value| {
-				T::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed)
-			})
-			.transpose()
-	}
-
-	/// Read `MapStorage` value from runtime storage.
-	pub async fn storage_map_value<T: StorageMapKeyProvider>(
-		&self,
-		pallet_prefix: &str,
-		key: &T::Key,
-		block_hash: Option<C::Hash>,
-	) -> Result<Option<T::Value>> {
-		let storage_key = T::final_key(pallet_prefix, key);
-
-		self.raw_storage_value(storage_key, block_hash)
-			.await?
-			.map(|encoded_value| {
-				T::Value::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed)
-			})
-			.transpose()
-	}
-
-	/// Read `DoubleMapStorage` value from runtime storage.
-	pub async fn storage_double_map_value<T: StorageDoubleMapKeyProvider>(
-		&self,
-		pallet_prefix: &str,
-		key1: &T::Key1,
-		key2: &T::Key2,
-		block_hash: Option<C::Hash>,
-	) -> Result<Option<T::Value>> {
-		let storage_key = T::final_key(pallet_prefix, key1, key2);
-
-		self.raw_storage_value(storage_key, block_hash)
-			.await?
-			.map(|encoded_value| {
-				T::Value::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed)
-			})
-			.transpose()
-	}
-
-	/// Read raw value from runtime storage.
-	pub async fn raw_storage_value(
-		&self,
-		storage_key: StorageKey,
-		block_hash: Option<C::Hash>,
-	) -> Result<Option<StorageData>> {
-		let cloned_storage_key = storage_key.clone();
-		self.jsonrpsee_execute(move |client| async move {
-			Ok(SubstrateStateClient::<C>::storage(&*client, storage_key.clone(), block_hash)
-				.await?)
-		})
-		.await
-		.map_err(|e| Error::FailedToReadRuntimeStorageValue {
-			chain: C::NAME.into(),
-			key: cloned_storage_key,
-			error: e.boxed(),
-		})
-	}
-
-	/// Get the nonce of the given Substrate account.
-	///
-	/// Note: It's the caller's responsibility to make sure `account` is a valid SS58 address.
-	pub async fn next_account_index(&self, account: C::AccountId) -> Result<C::Nonce> {
-		self.jsonrpsee_execute(move |client| async move {
-			Ok(SubstrateFrameSystemClient::<C>::account_next_index(&*client, account).await?)
-		})
-		.await
-	}
-
-	/// Submit unsigned extrinsic for inclusion in a block.
-	///
-	/// Note: The given transaction needs to be SCALE encoded beforehand.
-	pub async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result<C::Hash> {
-		// one last check that the transaction is valid. Most of checks happen in the relay loop and
-		// it is the "final" check before submission.
-		let best_header_hash = self.best_header().await?.hash();
-		self.validate_transaction(best_header_hash, PreEncoded(transaction.0.clone()))
-			.await
-			.map_err(|e| {
-				log::error!(target: "bridge", "Pre-submit {} transaction validation failed: {:?}", C::NAME, e);
-				e
-			})??;
-
-		self.jsonrpsee_execute(move |client| async move {
-			let tx_hash = SubstrateAuthorClient::<C>::submit_extrinsic(&*client, transaction)
-				.await
-				.map_err(|e| {
-					log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e);
-					e
-				})?;
-			log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash);
-			Ok(tx_hash)
-		})
-		.await
-	}
-
-	async fn build_sign_params(&self, signer: AccountKeyPairOf<C>) -> Result<SignParam<C>>
-	where
-		C: ChainWithTransactions,
-	{
-		let runtime_version = self.simple_runtime_version().await?;
-		Ok(SignParam::<C> {
-			spec_version: runtime_version.spec_version,
-			transaction_version: runtime_version.transaction_version,
-			genesis_hash: self.genesis_hash,
-			signer,
-		})
-	}
-
-	/// Submit an extrinsic signed by given account.
-	///
-	/// All calls of this method are synchronized, so there can't be more than one active
-	/// `submit_signed_extrinsic()` call. This guarantees that no nonces collision may happen
-	/// if all client instances are clones of the same initial `Client`.
-	///
-	/// Note: The given transaction needs to be SCALE encoded beforehand.
-	pub async fn submit_signed_extrinsic(
-		&self,
-		signer: &AccountKeyPairOf<C>,
-		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, C::Nonce) -> Result<UnsignedTransaction<C>>
-			+ Send
-			+ 'static,
-	) -> Result<C::Hash>
-	where
-		C: ChainWithTransactions,
-		C::AccountId: From<<C::AccountKeyPair as Pair>::Public>,
-	{
-		let _guard = self.submit_signed_extrinsic_lock.lock().await;
-		let transaction_nonce = self.next_account_index(signer.public().into()).await?;
-		let best_header = self.best_header().await?;
-		let signing_data = self.build_sign_params(signer.clone()).await?;
-
-		// By using parent of best block here, we are protecing again best-block reorganizations.
-		// E.g. transaction may have been submitted when the best block was `A[num=100]`. Then it
-		// has been changed to `B[num=100]`. Hash of `A` has been included into transaction
-		// signature payload. So when signature will be checked, the check will fail and transaction
-		// will be dropped from the pool.
-		let best_header_id = best_header.parent_id().unwrap_or_else(|| best_header.id());
-
-		let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?;
-		let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode();
-
-		// one last check that the transaction is valid. Most of checks happen in the relay loop and
-		// it is the "final" check before submission.
-		self.validate_transaction(best_header_id.1, PreEncoded(signed_extrinsic.clone()))
-			.await
-			.map_err(|e| {
-				log::error!(target: "bridge", "Pre-submit {} transaction validation failed: {:?}", C::NAME, e);
-				e
-			})??;
-
-		self.jsonrpsee_execute(move |client| async move {
-			let tx_hash =
-				SubstrateAuthorClient::<C>::submit_extrinsic(&*client, Bytes(signed_extrinsic))
-					.await
-					.map_err(|e| {
-						log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e);
-						e
-					})?;
-			log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash);
-			Ok(tx_hash)
-		})
-		.await
-	}
-
-	/// Does exactly the same as `submit_signed_extrinsic`, but keeps watching for extrinsic status
-	/// after submission.
-	pub async fn submit_and_watch_signed_extrinsic(
-		&self,
-		signer: &AccountKeyPairOf<C>,
-		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, C::Nonce) -> Result<UnsignedTransaction<C>>
-			+ Send
-			+ 'static,
-	) -> Result<TransactionTracker<C, Self>>
-	where
-		C: ChainWithTransactions,
-		C::AccountId: From<<C::AccountKeyPair as Pair>::Public>,
-	{
-		let self_clone = self.clone();
-		let signing_data = self.build_sign_params(signer.clone()).await?;
-		let _guard = self.submit_signed_extrinsic_lock.lock().await;
-		let transaction_nonce = self.next_account_index(signer.public().into()).await?;
-		let best_header = self.best_header().await?;
-		let best_header_id = best_header.id();
-
-		let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?;
-		let stall_timeout = transaction_stall_timeout(
-			extrinsic.era.mortality_period(),
-			C::AVERAGE_BLOCK_INTERVAL,
-			STALL_TIMEOUT,
-		);
-		let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode();
-
-		// one last check that the transaction is valid. Most of checks happen in the relay loop and
-		// it is the "final" check before submission.
-		self.validate_transaction(best_header_id.1, PreEncoded(signed_extrinsic.clone()))
-			.await
-			.map_err(|e| {
-				log::error!(target: "bridge", "Pre-submit {} transaction validation failed: {:?}", C::NAME, e);
-				e
-			})??;
-
-		let (cancel_sender, cancel_receiver) = futures::channel::oneshot::channel();
-		let (sender, receiver) = futures::channel::mpsc::channel(MAX_SUBSCRIPTION_CAPACITY);
-		let (tracker, subscription) = self
-			.jsonrpsee_execute(move |client| async move {
-				let tx_hash = C::Hasher::hash(&signed_extrinsic);
-				let subscription = SubstrateAuthorClient::<C>::submit_and_watch_extrinsic(
-					&*client,
-					Bytes(signed_extrinsic),
-				)
-				.await
-				.map_err(|e| {
-					log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e);
-					e
-				})?;
-				log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash);
-				let tracker = TransactionTracker::new(
-					self_clone,
-					stall_timeout,
-					tx_hash,
-					Subscription(Mutex::new(receiver), cancel_sender),
-				);
-				Ok((tracker, subscription))
-			})
-			.await?;
-		self.data.read().await.tokio.spawn(Subscription::background_worker(
-			C::NAME.into(),
-			"extrinsic".into(),
-			subscription,
-			sender,
-			cancel_receiver,
-		));
-		Ok(tracker)
-	}
-
-	/// Returns pending extrinsics from transaction pool.
-	pub async fn pending_extrinsics(&self) -> Result<Vec<Bytes>> {
-		self.jsonrpsee_execute(move |client| async move {
-			Ok(SubstrateAuthorClient::<C>::pending_extrinsics(&*client).await?)
-		})
-		.await
-	}
-
-	/// Validate transaction at given block state.
-	pub async fn validate_transaction<SignedTransaction: Encode + Send + 'static>(
-		&self,
-		at_block: C::Hash,
-		transaction: SignedTransaction,
-	) -> Result<TransactionValidity> {
-		self.jsonrpsee_execute(move |client| async move {
-			let call = SUB_API_TXPOOL_VALIDATE_TRANSACTION.to_string();
-			let data = Bytes((TransactionSource::External, transaction, at_block).encode());
-
-			let encoded_response =
-				SubstrateStateClient::<C>::call(&*client, call, data, Some(at_block)).await?;
-			let validity = TransactionValidity::decode(&mut &encoded_response.0[..])
-				.map_err(Error::ResponseParseFailed)?;
-
-			Ok(validity)
-		})
-		.await
-	}
-
-	/// Returns weight of the given transaction.
-	pub async fn extimate_extrinsic_weight<SignedTransaction: Encode + Send + 'static>(
-		&self,
-		transaction: SignedTransaction,
-	) -> Result<Weight> {
-		self.jsonrpsee_execute(move |client| async move {
-			let transaction_len = transaction.encoded_size() as u32;
-
-			let call = SUB_API_TX_PAYMENT_QUERY_INFO.to_string();
-			let data = Bytes((transaction, transaction_len).encode());
-
-			let encoded_response =
-				SubstrateStateClient::<C>::call(&*client, call, data, None).await?;
-			let dispatch_info =
-				RuntimeDispatchInfo::<C::Balance>::decode(&mut &encoded_response.0[..])
-					.map_err(Error::ResponseParseFailed)?;
-
-			Ok(dispatch_info.weight)
-		})
-		.await
-	}
-
-	/// Get the GRANDPA authority set at given block.
-	pub async fn grandpa_authorities_set(
-		&self,
-		block: C::Hash,
-	) -> Result<OpaqueGrandpaAuthoritiesSet> {
-		self.jsonrpsee_execute(move |client| async move {
-			let call = SUB_API_GRANDPA_AUTHORITIES.to_string();
-			let data = Bytes(Vec::new());
-
-			let encoded_response =
-				SubstrateStateClient::<C>::call(&*client, call, data, Some(block)).await?;
-			let authority_list = encoded_response.0;
-
-			Ok(authority_list)
-		})
-		.await
-	}
-
-	/// Execute runtime call at given block, provided the input and output types.
-	/// It also performs the input encode and output decode.
-	pub async fn typed_state_call<Input: codec::Encode, Output: codec::Decode>(
-		&self,
-		method_name: String,
-		input: Input,
-		at_block: Option<C::Hash>,
-	) -> Result<Output> {
-		let encoded_output = self
-			.state_call(method_name.clone(), Bytes(input.encode()), at_block)
-			.await
-			.map_err(|e| Error::ErrorExecutingRuntimeCall {
-				chain: C::NAME.into(),
-				method: method_name,
-				error: e.boxed(),
-			})?;
-		Output::decode(&mut &encoded_output.0[..]).map_err(Error::ResponseParseFailed)
-	}
-
-	/// Execute runtime call at given block.
-	pub async fn state_call(
-		&self,
-		method: String,
-		data: Bytes,
-		at_block: Option<C::Hash>,
-	) -> Result<Bytes> {
-		self.jsonrpsee_execute(move |client| async move {
-			SubstrateStateClient::<C>::call(&*client, method, data, at_block)
-				.await
-				.map_err(Into::into)
-		})
-		.await
-	}
-
-	/// Returns storage proof of given storage keys.
-	pub async fn prove_storage(
-		&self,
-		keys: Vec<StorageKey>,
-		at_block: C::Hash,
-	) -> Result<StorageProof> {
-		self.jsonrpsee_execute(move |client| async move {
-			SubstrateStateClient::<C>::prove_storage(&*client, keys, Some(at_block))
-				.await
-				.map(|proof| {
-					StorageProof::new(proof.proof.into_iter().map(|b| b.0).collect::<Vec<_>>())
-				})
-				.map_err(Into::into)
-		})
-		.await
-	}
-
-	/// Return `tokenDecimals` property from the set of chain properties.
-	pub async fn token_decimals(&self) -> Result<Option<u64>> {
-		self.jsonrpsee_execute(move |client| async move {
-			let system_properties = SubstrateSystemClient::<C>::properties(&*client).await?;
-			Ok(system_properties.get("tokenDecimals").and_then(|v| v.as_u64()))
-		})
-		.await
-	}
-
-	/// Return new finality justifications stream.
-	pub async fn subscribe_finality_justifications<FC: SubstrateFinalityClient<C>>(
-		&self,
-	) -> Result<Subscription<Bytes>> {
-		let subscription = self
-			.jsonrpsee_execute(move |client| async move {
-				Ok(FC::subscribe_justifications(&client).await?)
-			})
-			.await?;
-		let (cancel_sender, cancel_receiver) = futures::channel::oneshot::channel();
-		let (sender, receiver) = futures::channel::mpsc::channel(MAX_SUBSCRIPTION_CAPACITY);
-		self.data.read().await.tokio.spawn(Subscription::background_worker(
-			C::NAME.into(),
-			"justification".into(),
-			subscription,
-			sender,
-			cancel_receiver,
-		));
-		Ok(Subscription(Mutex::new(receiver), cancel_sender))
-	}
-
-	/// Generates a proof of key ownership for the given authority in the given set.
-	pub async fn generate_grandpa_key_ownership_proof(
-		&self,
-		at: HashOf<C>,
-		set_id: sp_consensus_grandpa::SetId,
-		authority_id: sp_consensus_grandpa::AuthorityId,
-	) -> Result<Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof>>
-	where
-		C: ChainWithGrandpa,
-	{
-		self.typed_state_call(
-			SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF.into(),
-			(set_id, authority_id),
-			Some(at),
-		)
-		.await
-	}
-
-	/// Execute jsonrpsee future in tokio context.
-	async fn jsonrpsee_execute<MF, F, T>(&self, make_jsonrpsee_future: MF) -> Result<T>
-	where
-		MF: FnOnce(Arc<RpcClient>) -> F + Send + 'static,
-		F: Future<Output = Result<T>> + Send + 'static,
-		T: Send + 'static,
-	{
-		let data = self.data.read().await;
-		let client = data.client.clone();
-		data.tokio.spawn(make_jsonrpsee_future(client)).await?
-	}
-
-	/// Returns `true` if version guard can be started.
-	///
-	/// There's no reason to run version guard when version mode is set to `Auto`. It can
-	/// lead to relay shutdown when chain is upgraded, even though we have explicitly
-	/// said that we don't want to shutdown.
-	pub fn can_start_version_guard(&self) -> bool {
-		!matches!(self.chain_runtime_version, ChainRuntimeVersion::Auto)
-	}
-}
-
-impl<T: DeserializeOwned> Subscription<T> {
-	/// Consumes subscription and returns future statuses stream.
-	pub fn into_stream(self) -> impl futures::Stream<Item = T> {
-		futures::stream::unfold(Some(self), |mut this| async move {
-			let Some(this) = this.take() else { return None };
-			let item = this.0.lock().await.next().await.unwrap_or(None);
-			match item {
-				Some(item) => Some((item, Some(this))),
-				None => {
-					// let's make it explicit here
-					let _ = this.1.send(());
-					None
-				},
-			}
-		})
-	}
-
-	/// Return next item from the subscription.
-	pub async fn next(&self) -> Result<Option<T>> {
-		let mut receiver = self.0.lock().await;
-		let item = receiver.next().await;
-		Ok(item.unwrap_or(None))
-	}
-
-	/// Background worker that is executed in tokio context as `jsonrpsee` requires.
-	async fn background_worker(
-		chain_name: String,
-		item_type: String,
-		subscription: jsonrpsee::core::client::Subscription<T>,
-		mut sender: futures::channel::mpsc::Sender<Option<T>>,
-		cancel_receiver: futures::channel::oneshot::Receiver<()>,
-	) {
-		log::trace!(
-			target: "bridge",
-			"Starting background worker for {} {} subscription stream.",
-			chain_name,
-			item_type,
-		);
-
-		futures::pin_mut!(subscription, cancel_receiver);
-		loop {
-			match futures::future::select(subscription.next(), &mut cancel_receiver).await {
-				futures::future::Either::Left((Some(Ok(item)), _)) =>
-					if sender.send(Some(item)).await.is_err() {
-						log::trace!(
-							target: "bridge",
-							"{} {} subscription stream: no listener. Stopping background worker.",
-							chain_name,
-							item_type,
-						);
-
-						break
-					},
-				futures::future::Either::Left((Some(Err(e)), _)) => {
-					log::trace!(
-						target: "bridge",
-						"{} {} subscription stream has returned '{:?}'. Stream needs to be restarted. Stopping background worker.",
-						chain_name,
-						item_type,
-						e,
-					);
-					let _ = sender.send(None).await;
-					break
-				},
-				futures::future::Either::Left((None, _)) => {
-					log::trace!(
-						target: "bridge",
-						"{} {} subscription stream has returned None. Stream needs to be restarted. Stopping background worker.",
-						chain_name,
-						item_type,
-					);
-					let _ = sender.send(None).await;
-					break
-				},
-				futures::future::Either::Right((_, _)) => {
-					log::trace!(
-						target: "bridge",
-						"{} {} subscription stream: listener has been dropped. Stopping background worker.",
-						chain_name,
-						item_type,
-					);
-					break;
-				},
-			}
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use crate::{guard::tests::TestEnvironment, test_chain::TestChain};
-	use futures::{channel::mpsc::unbounded, FutureExt};
-
-	async fn run_ensure_correct_runtime_version(
-		expected: ChainRuntimeVersion,
-		actual: RuntimeVersion,
-	) -> Result<()> {
-		let (
-			(mut runtime_version_tx, runtime_version_rx),
-			(slept_tx, _slept_rx),
-			(aborted_tx, mut aborted_rx),
-		) = (unbounded(), unbounded(), unbounded());
-		runtime_version_tx.send(actual).await.unwrap();
-		let mut env = TestEnvironment { runtime_version_rx, slept_tx, aborted_tx };
-
-		let ensure_correct_runtime_version =
-			Client::<TestChain>::ensure_correct_runtime_version(&mut env, expected).boxed();
-		let aborted = aborted_rx.next().map(|_| Err(Error::Custom("".into()))).boxed();
-		futures::pin_mut!(ensure_correct_runtime_version, aborted);
-		futures::future::select(ensure_correct_runtime_version, aborted)
-			.await
-			.into_inner()
-			.0
-	}
-
-	#[async_std::test]
-	async fn ensure_correct_runtime_version_works() {
-		// when we are configured to use auto version
-		assert!(matches!(
-			run_ensure_correct_runtime_version(
-				ChainRuntimeVersion::Auto,
-				RuntimeVersion {
-					spec_version: 100,
-					transaction_version: 100,
-					..Default::default()
-				},
-			)
-			.await,
-			Ok(()),
-		));
-		// when actual == expected
-		assert!(matches!(
-			run_ensure_correct_runtime_version(
-				ChainRuntimeVersion::Custom(SimpleRuntimeVersion {
-					spec_version: 100,
-					transaction_version: 100
-				}),
-				RuntimeVersion {
-					spec_version: 100,
-					transaction_version: 100,
-					..Default::default()
-				},
-			)
-			.await,
-			Ok(()),
-		));
-		// when actual spec version < expected spec version
-		assert!(matches!(
-			run_ensure_correct_runtime_version(
-				ChainRuntimeVersion::Custom(SimpleRuntimeVersion {
-					spec_version: 100,
-					transaction_version: 100
-				}),
-				RuntimeVersion { spec_version: 99, transaction_version: 100, ..Default::default() },
-			)
-			.await,
-			Err(Error::WaitingForRuntimeUpgrade {
-				expected: SimpleRuntimeVersion { spec_version: 100, transaction_version: 100 },
-				actual: SimpleRuntimeVersion { spec_version: 99, transaction_version: 100 },
-				..
-			}),
-		));
-		// when actual spec version > expected spec version
-		assert!(matches!(
-			run_ensure_correct_runtime_version(
-				ChainRuntimeVersion::Custom(SimpleRuntimeVersion {
-					spec_version: 100,
-					transaction_version: 100
-				}),
-				RuntimeVersion {
-					spec_version: 101,
-					transaction_version: 100,
-					..Default::default()
-				},
-			)
-			.await,
-			Err(Error::Custom(_)),
-		));
-	}
-}
diff --git a/bridges/relays/client-substrate/src/client/caching.rs b/bridges/relays/client-substrate/src/client/caching.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cb898cf517267a173b0ef4daf374c5b16b0757ba
--- /dev/null
+++ b/bridges/relays/client-substrate/src/client/caching.rs
@@ -0,0 +1,468 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Client implementation that is caching (whenever possible) results of its backend
+//! method calls.
+
+use crate::{
+	client::{Client, SubscriptionBroadcaster},
+	error::{Error, Result},
+	AccountIdOf, AccountKeyPairOf, BlockNumberOf, Chain, ChainWithGrandpa, ChainWithTransactions,
+	HashOf, HeaderIdOf, HeaderOf, NonceOf, SignedBlockOf, SimpleRuntimeVersion, Subscription,
+	TransactionTracker, UnsignedTransaction, ANCIENT_BLOCK_THRESHOLD,
+};
+use std::{cmp::Ordering, future::Future, task::Poll};
+
+use async_std::{
+	sync::{Arc, Mutex, RwLock},
+	task::JoinHandle,
+};
+use async_trait::async_trait;
+use codec::Encode;
+use frame_support::weights::Weight;
+use futures::{FutureExt, StreamExt};
+use quick_cache::unsync::Cache;
+use sp_consensus_grandpa::{AuthorityId, OpaqueKeyOwnershipProof, SetId};
+use sp_core::{
+	storage::{StorageData, StorageKey},
+	Bytes, Pair,
+};
+use sp_runtime::{traits::Header as _, transaction_validity::TransactionValidity};
+use sp_trie::StorageProof;
+use sp_version::RuntimeVersion;
+
+/// `quick_cache::unsync::Cache` wrapped in async-aware synchronization primitives.
+type SyncCache<K, V> = Arc<RwLock<Cache<K, V>>>;
+
+/// Client implementation that is caching (whenever possible) results of its backend
+/// method calls. Apart from caching call results, it also supports some (at the
+/// moment: justifications) subscription sharing, meaning that the single server
+/// subscription may be shared by multiple subscribers at the client side.
+#[derive(Clone)]
+pub struct CachingClient<C: Chain, B: Client<C>> {
+	backend: B,
+	data: Arc<ClientData<C>>,
+}
+
+/// Client data, shared by all `CachingClient` clones.
+struct ClientData<C: Chain> {
+	grandpa_justifications: Arc<Mutex<Option<SubscriptionBroadcaster<Bytes>>>>,
+	beefy_justifications: Arc<Mutex<Option<SubscriptionBroadcaster<Bytes>>>>,
+	background_task_handle: Arc<Mutex<JoinHandle<Result<()>>>>,
+	best_header: Arc<RwLock<Option<HeaderOf<C>>>>,
+	best_finalized_header: Arc<RwLock<Option<HeaderOf<C>>>>,
+	// `quick_cache::sync::Cache` has the `get_or_insert_async` method, which fits our needs,
+	// but it uses synchronization primitives that are not aware of async execution. They
+	// can block the executor threads and cause deadlocks => let's use primitives from
+	// `async_std` crate around `quick_cache::unsync::Cache`
+	header_hash_by_number_cache: SyncCache<BlockNumberOf<C>, HashOf<C>>,
+	header_by_hash_cache: SyncCache<HashOf<C>, HeaderOf<C>>,
+	block_by_hash_cache: SyncCache<HashOf<C>, SignedBlockOf<C>>,
+	raw_storage_value_cache: SyncCache<(HashOf<C>, StorageKey), Option<StorageData>>,
+	state_call_cache: SyncCache<(HashOf<C>, String, Bytes), Bytes>,
+}
+
+impl<C: Chain, B: Client<C>> CachingClient<C, B> {
+	/// Creates new `CachingClient` on top of given `backend`.
+	pub async fn new(backend: B) -> Self {
+		// most of relayer operations will never touch more than `ANCIENT_BLOCK_THRESHOLD`
+		// headers, so we'll use this as a cache capacity for all chain-related caches
+		let chain_state_capacity = ANCIENT_BLOCK_THRESHOLD as usize;
+		let best_header = Arc::new(RwLock::new(None));
+		let best_finalized_header = Arc::new(RwLock::new(None));
+		let header_by_hash_cache = Arc::new(RwLock::new(Cache::new(chain_state_capacity)));
+		let background_task_handle = Self::start_background_task(
+			backend.clone(),
+			best_header.clone(),
+			best_finalized_header.clone(),
+			header_by_hash_cache.clone(),
+		)
+		.await;
+		CachingClient {
+			backend,
+			data: Arc::new(ClientData {
+				grandpa_justifications: Arc::new(Mutex::new(None)),
+				beefy_justifications: Arc::new(Mutex::new(None)),
+				background_task_handle: Arc::new(Mutex::new(background_task_handle)),
+				best_header,
+				best_finalized_header,
+				header_hash_by_number_cache: Arc::new(RwLock::new(Cache::new(
+					chain_state_capacity,
+				))),
+				header_by_hash_cache,
+				block_by_hash_cache: Arc::new(RwLock::new(Cache::new(chain_state_capacity))),
+				raw_storage_value_cache: Arc::new(RwLock::new(Cache::new(1_024))),
+				state_call_cache: Arc::new(RwLock::new(Cache::new(1_024))),
+			}),
+		}
+	}
+
+	/// Try to get value from the cache, or compute and insert it using given future.
+	async fn get_or_insert_async<K: Clone + std::fmt::Debug + Eq + std::hash::Hash, V: Clone>(
+		&self,
+		cache: &Arc<RwLock<Cache<K, V>>>,
+		key: &K,
+		with: impl std::future::Future<Output = Result<V>>,
+	) -> Result<V> {
+		// try to get cached value first using read lock
+		{
+			let cache = cache.read().await;
+			if let Some(value) = cache.get(key) {
+				return Ok(value.clone())
+			}
+		}
+
+		// let's compute the value without holding any locks - it may cause additional misses and
+		// double insertions, but that's better than holding a lock for a while
+		let value = with.await?;
+
+		// insert/update the value in the cache
+		cache.write().await.insert(key.clone(), value.clone());
+		Ok(value)
+	}
+
+	/// Subscribe to finality justifications, trying to reuse existing subscription.
+	async fn subscribe_finality_justifications<'a>(
+		&'a self,
+		maybe_broadcaster: &Mutex<Option<SubscriptionBroadcaster<Bytes>>>,
+		do_subscribe: impl Future<Output = Result<Subscription<Bytes>>> + 'a,
+	) -> Result<Subscription<Bytes>> {
+		let mut maybe_broadcaster = maybe_broadcaster.lock().await;
+		let broadcaster = match maybe_broadcaster.as_ref() {
+			Some(justifications) => justifications,
+			None => {
+				let broadcaster = match SubscriptionBroadcaster::new(do_subscribe.await?) {
+					Ok(broadcaster) => broadcaster,
+					Err(subscription) => return Ok(subscription),
+				};
+				maybe_broadcaster.get_or_insert(broadcaster)
+			},
+		};
+
+		broadcaster.subscribe().await
+	}
+
+	/// Start background task that reads best (and best finalized) headers from subscriptions.
+	async fn start_background_task(
+		backend: B,
+		best_header: Arc<RwLock<Option<HeaderOf<C>>>>,
+		best_finalized_header: Arc<RwLock<Option<HeaderOf<C>>>>,
+		header_by_hash_cache: SyncCache<HashOf<C>, HeaderOf<C>>,
+	) -> JoinHandle<Result<()>> {
+		async_std::task::spawn(async move {
+			// initialize by reading headers directly from backend to avoid doing that in the
+			// high-level code
+			let mut last_finalized_header =
+				backend.header_by_hash(backend.best_finalized_header_hash().await?).await?;
+			*best_header.write().await = Some(backend.best_header().await?);
+			*best_finalized_header.write().await = Some(last_finalized_header.clone());
+
+			// ...and then continue with subscriptions
+			let mut best_headers = backend.subscribe_best_headers().await?;
+			let mut finalized_headers = backend.subscribe_finalized_headers().await?;
+			loop {
+				futures::select! {
+					new_best_header = best_headers.next().fuse() => {
+						// we assume that the best header is always the actual best header, even if its
+						// number is lower than the number of previous-best-header (chain may use its own
+						// best header selection algorithms)
+						let new_best_header = new_best_header
+							.ok_or_else(|| Error::ChannelError(format!("Mandatory best headers subscription for {} has finished", C::NAME)))?;
+						let new_best_header_hash = new_best_header.hash();
+						header_by_hash_cache.write().await.insert(new_best_header_hash, new_best_header.clone());
+						*best_header.write().await = Some(new_best_header);
+					},
+					new_finalized_header = finalized_headers.next().fuse() => {
+						// in theory we'll always get finalized headers in order, but let's double check
+						let new_finalized_header = new_finalized_header.
+							ok_or_else(|| Error::ChannelError(format!("Finalized headers subscription for {} has finished", C::NAME)))?;
+						let new_finalized_header_number = *new_finalized_header.number();
+						let last_finalized_header_number = *last_finalized_header.number();
+						match new_finalized_header_number.cmp(&last_finalized_header_number) {
+							Ordering::Greater => {
+								let new_finalized_header_hash = new_finalized_header.hash();
+								header_by_hash_cache.write().await.insert(new_finalized_header_hash, new_finalized_header.clone());
+								*best_finalized_header.write().await = Some(new_finalized_header.clone());
+								last_finalized_header = new_finalized_header;
+							},
+							Ordering::Less => {
+								return Err(Error::unordered_finalized_headers::<C>(
+									new_finalized_header_number,
+									last_finalized_header_number,
+								));
+							},
+							_ => (),
+						}
+					},
+				}
+			}
+		})
+	}
+
+	/// Ensure that the background task is active.
+	async fn ensure_background_task_active(&self) -> Result<()> {
+		let mut background_task_handle = self.data.background_task_handle.lock().await;
+		if let Poll::Ready(result) = futures::poll!(&mut *background_task_handle) {
+			return Err(Error::ChannelError(format!(
+				"Background task of {} client has exited with result: {:?}",
+				C::NAME,
+				result
+			)))
+		}
+
+		Ok(())
+	}
+
+	/// Try to get header, read elsewhere by background task through subscription.
+	async fn read_header_from_background<'a>(
+		&'a self,
+		header: &Arc<RwLock<Option<HeaderOf<C>>>>,
+		read_header_from_backend: impl Future<Output = Result<HeaderOf<C>>> + 'a,
+	) -> Result<HeaderOf<C>> {
+		// ensure that the background task is active
+		self.ensure_background_task_active().await?;
+
+		// now we know that the background task is active, so we could trust that the
+		// `header` has the most recent updates from it
+		match header.read().await.clone() {
+			Some(header) => Ok(header),
+			None => {
+				// header has not yet been read from the subscription, which means that
+				// we are just starting - let's read header directly from backend this time
+				read_header_from_backend.await
+			},
+		}
+	}
+}
+
+impl<C: Chain, B: Client<C>> std::fmt::Debug for CachingClient<C, B> {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.write_fmt(format_args!("CachingClient<{:?}>", self.backend))
+	}
+}
+
+#[async_trait]
+impl<C: Chain, B: Client<C>> Client<C> for CachingClient<C, B> {
+	async fn ensure_synced(&self) -> Result<()> {
+		self.backend.ensure_synced().await
+	}
+
+	async fn reconnect(&self) -> Result<()> {
+		self.backend.reconnect().await?;
+		// since we have new underlying client, we need to restart subscriptions too
+		*self.data.grandpa_justifications.lock().await = None;
+		*self.data.beefy_justifications.lock().await = None;
+		// also restart background task too
+		*self.data.best_header.write().await = None;
+		*self.data.best_finalized_header.write().await = None;
+		*self.data.background_task_handle.lock().await = Self::start_background_task(
+			self.backend.clone(),
+			self.data.best_header.clone(),
+			self.data.best_finalized_header.clone(),
+			self.data.header_by_hash_cache.clone(),
+		)
+		.await;
+		Ok(())
+	}
+
+	fn genesis_hash(&self) -> HashOf<C> {
+		self.backend.genesis_hash()
+	}
+
+	async fn header_hash_by_number(&self, number: BlockNumberOf<C>) -> Result<HashOf<C>> {
+		self.get_or_insert_async(
+			&self.data.header_hash_by_number_cache,
+			&number,
+			self.backend.header_hash_by_number(number),
+		)
+		.await
+	}
+
+	async fn header_by_hash(&self, hash: HashOf<C>) -> Result<HeaderOf<C>> {
+		self.get_or_insert_async(
+			&self.data.header_by_hash_cache,
+			&hash,
+			self.backend.header_by_hash(hash),
+		)
+		.await
+	}
+
+	async fn block_by_hash(&self, hash: HashOf<C>) -> Result<SignedBlockOf<C>> {
+		self.get_or_insert_async(
+			&self.data.block_by_hash_cache,
+			&hash,
+			self.backend.block_by_hash(hash),
+		)
+		.await
+	}
+
+	async fn best_finalized_header_hash(&self) -> Result<HashOf<C>> {
+		self.read_header_from_background(
+			&self.data.best_finalized_header,
+			self.backend.best_finalized_header(),
+		)
+		.await
+		.map(|h| h.hash())
+	}
+
+	async fn best_header(&self) -> Result<HeaderOf<C>> {
+		self.read_header_from_background(&self.data.best_header, self.backend.best_header())
+			.await
+	}
+
+	async fn subscribe_best_headers(&self) -> Result<Subscription<HeaderOf<C>>> {
+		// we may share the sunbscription here, but atm there's no callers of this method
+		self.backend.subscribe_best_headers().await
+	}
+
+	async fn subscribe_finalized_headers(&self) -> Result<Subscription<HeaderOf<C>>> {
+		// we may share the sunbscription here, but atm there's no callers of this method
+		self.backend.subscribe_finalized_headers().await
+	}
+
+	async fn subscribe_grandpa_finality_justifications(&self) -> Result<Subscription<Bytes>>
+	where
+		C: ChainWithGrandpa,
+	{
+		self.subscribe_finality_justifications(
+			&self.data.grandpa_justifications,
+			self.backend.subscribe_grandpa_finality_justifications(),
+		)
+		.await
+	}
+
+	async fn generate_grandpa_key_ownership_proof(
+		&self,
+		at: HashOf<C>,
+		set_id: SetId,
+		authority_id: AuthorityId,
+	) -> Result<Option<OpaqueKeyOwnershipProof>> {
+		self.backend
+			.generate_grandpa_key_ownership_proof(at, set_id, authority_id)
+			.await
+	}
+
+	async fn subscribe_beefy_finality_justifications(&self) -> Result<Subscription<Bytes>> {
+		self.subscribe_finality_justifications(
+			&self.data.beefy_justifications,
+			self.backend.subscribe_beefy_finality_justifications(),
+		)
+		.await
+	}
+
+	async fn token_decimals(&self) -> Result<Option<u64>> {
+		self.backend.token_decimals().await
+	}
+
+	async fn runtime_version(&self) -> Result<RuntimeVersion> {
+		self.backend.runtime_version().await
+	}
+
+	async fn simple_runtime_version(&self) -> Result<SimpleRuntimeVersion> {
+		self.backend.simple_runtime_version().await
+	}
+
+	fn can_start_version_guard(&self) -> bool {
+		self.backend.can_start_version_guard()
+	}
+
+	async fn raw_storage_value(
+		&self,
+		at: HashOf<C>,
+		storage_key: StorageKey,
+	) -> Result<Option<StorageData>> {
+		self.get_or_insert_async(
+			&self.data.raw_storage_value_cache,
+			&(at, storage_key.clone()),
+			self.backend.raw_storage_value(at, storage_key),
+		)
+		.await
+	}
+
+	async fn pending_extrinsics(&self) -> Result<Vec<Bytes>> {
+		self.backend.pending_extrinsics().await
+	}
+
+	async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result<HashOf<C>> {
+		self.backend.submit_unsigned_extrinsic(transaction).await
+	}
+
+	async fn submit_signed_extrinsic(
+		&self,
+		signer: &AccountKeyPairOf<C>,
+		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, NonceOf<C>) -> Result<UnsignedTransaction<C>>
+			+ Send
+			+ 'static,
+	) -> Result<HashOf<C>>
+	where
+		C: ChainWithTransactions,
+		AccountIdOf<C>: From<<AccountKeyPairOf<C> as Pair>::Public>,
+	{
+		self.backend.submit_signed_extrinsic(signer, prepare_extrinsic).await
+	}
+
+	async fn submit_and_watch_signed_extrinsic(
+		&self,
+		signer: &AccountKeyPairOf<C>,
+		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, NonceOf<C>) -> Result<UnsignedTransaction<C>>
+			+ Send
+			+ 'static,
+	) -> Result<TransactionTracker<C, Self>>
+	where
+		C: ChainWithTransactions,
+		AccountIdOf<C>: From<<AccountKeyPairOf<C> as Pair>::Public>,
+	{
+		self.backend
+			.submit_and_watch_signed_extrinsic(signer, prepare_extrinsic)
+			.await
+			.map(|t| t.switch_environment(self.clone()))
+	}
+
+	async fn validate_transaction<SignedTransaction: Encode + Send + 'static>(
+		&self,
+		at: HashOf<C>,
+		transaction: SignedTransaction,
+	) -> Result<TransactionValidity> {
+		self.backend.validate_transaction(at, transaction).await
+	}
+
+	async fn estimate_extrinsic_weight<SignedTransaction: Encode + Send + 'static>(
+		&self,
+		at: HashOf<C>,
+		transaction: SignedTransaction,
+	) -> Result<Weight> {
+		self.backend.estimate_extrinsic_weight(at, transaction).await
+	}
+
+	async fn raw_state_call<Args: Encode + Send>(
+		&self,
+		at: HashOf<C>,
+		method: String,
+		arguments: Args,
+	) -> Result<Bytes> {
+		let encoded_arguments = Bytes(arguments.encode());
+		self.get_or_insert_async(
+			&self.data.state_call_cache,
+			&(at, method.clone(), encoded_arguments),
+			self.backend.raw_state_call(at, method, arguments),
+		)
+		.await
+	}
+
+	async fn prove_storage(&self, at: HashOf<C>, keys: Vec<StorageKey>) -> Result<StorageProof> {
+		self.backend.prove_storage(at, keys).await
+	}
+}
diff --git a/bridges/relays/client-substrate/src/client/mod.rs b/bridges/relays/client-substrate/src/client/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..62a1119d718ff79fa45800166c01762e2044f781
--- /dev/null
+++ b/bridges/relays/client-substrate/src/client/mod.rs
@@ -0,0 +1,91 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Layered Substrate client implementation.
+
+use crate::{Chain, ConnectionParams};
+
+use caching::CachingClient;
+use num_traits::Saturating;
+use rpc::RpcClient;
+use sp_version::RuntimeVersion;
+
+pub mod caching;
+pub mod rpc;
+
+mod rpc_api;
+mod subscription;
+mod traits;
+
+pub use subscription::{StreamDescription, Subscription, SubscriptionBroadcaster};
+pub use traits::Client;
+
+/// Type of RPC client with caching support.
+pub type RpcWithCachingClient<C> = CachingClient<C, RpcClient<C>>;
+
+/// Creates new RPC client with caching support.
+pub async fn rpc_with_caching<C: Chain>(params: ConnectionParams) -> RpcWithCachingClient<C> {
+	let rpc = rpc::RpcClient::<C>::new(params).await;
+	caching::CachingClient::new(rpc).await
+}
+
+/// The difference between best block number and number of its ancestor, that is enough
+/// for us to consider that ancestor an "ancient" block with dropped state.
+///
+/// The relay does not assume that it is connected to the archive node, so it always tries
+/// to use the best available chain state. But sometimes it still may use state of some
+/// old block. If the state of that block is already dropped, relay will see errors when
+/// e.g. it tries to prove something.
+///
+/// By default Substrate-based nodes are storing state for last 256 blocks. We'll use
+/// half of this value.
+pub const ANCIENT_BLOCK_THRESHOLD: u32 = 128;
+
+/// Returns `true` if we think that the state is already discarded for given block.
+pub fn is_ancient_block<N: From<u32> + PartialOrd + Saturating>(block: N, best: N) -> bool {
+	best.saturating_sub(block) >= N::from(ANCIENT_BLOCK_THRESHOLD)
+}
+
+/// Opaque GRANDPA authorities set.
+pub type OpaqueGrandpaAuthoritiesSet = Vec<u8>;
+
+/// A simple runtime version. It only includes the `spec_version` and `transaction_version`.
+#[derive(Copy, Clone, Debug)]
+pub struct SimpleRuntimeVersion {
+	/// Version of the runtime specification.
+	pub spec_version: u32,
+	/// All existing dispatches are fully compatible when this number doesn't change.
+	pub transaction_version: u32,
+}
+
+impl SimpleRuntimeVersion {
+	/// Create a new instance of `SimpleRuntimeVersion` from a `RuntimeVersion`.
+	pub const fn from_runtime_version(runtime_version: &RuntimeVersion) -> Self {
+		Self {
+			spec_version: runtime_version.spec_version,
+			transaction_version: runtime_version.transaction_version,
+		}
+	}
+}
+
+/// Chain runtime version in client
+#[derive(Copy, Clone, Debug)]
+pub enum ChainRuntimeVersion {
+	/// Auto query from chain.
+	Auto,
+	/// Custom runtime version, defined by user.
+	Custom(SimpleRuntimeVersion),
+}
diff --git a/bridges/relays/client-substrate/src/client/rpc.rs b/bridges/relays/client-substrate/src/client/rpc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bf7442a95141ff168229bffbc149f686d6b2771a
--- /dev/null
+++ b/bridges/relays/client-substrate/src/client/rpc.rs
@@ -0,0 +1,743 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Client implementation that connects to the Substrate node over `ws`/`wss` connection
+//! and is using RPC methods to get required data and submit transactions.
+
+use crate::{
+	client::{
+		rpc_api::{
+			SubstrateAuthorClient, SubstrateBeefyClient, SubstrateChainClient,
+			SubstrateFrameSystemClient, SubstrateGrandpaClient, SubstrateStateClient,
+			SubstrateSystemClient,
+		},
+		subscription::{StreamDescription, Subscription},
+		Client,
+	},
+	error::{Error, Result},
+	guard::Environment,
+	transaction_stall_timeout, AccountIdOf, AccountKeyPairOf, BalanceOf, BlockNumberOf, Chain,
+	ChainRuntimeVersion, ChainWithGrandpa, ChainWithTransactions, ConnectionParams, HashOf,
+	HeaderIdOf, HeaderOf, NonceOf, SignParam, SignedBlockOf, SimpleRuntimeVersion,
+	TransactionTracker, UnsignedTransaction,
+};
+
+use async_std::sync::{Arc, Mutex, RwLock};
+use async_trait::async_trait;
+use bp_runtime::HeaderIdProvider;
+use codec::Encode;
+use frame_support::weights::Weight;
+use futures::TryFutureExt;
+use jsonrpsee::{
+	core::{client::Subscription as RpcSubscription, ClientError},
+	ws_client::{WsClient, WsClientBuilder},
+};
+use num_traits::Zero;
+use pallet_transaction_payment::RuntimeDispatchInfo;
+use relay_utils::{relay_loop::RECONNECT_DELAY, STALL_TIMEOUT};
+use sp_core::{
+	storage::{StorageData, StorageKey},
+	Bytes, Hasher, Pair,
+};
+use sp_runtime::transaction_validity::{TransactionSource, TransactionValidity};
+use sp_trie::StorageProof;
+use sp_version::RuntimeVersion;
+use std::{cmp::Ordering, future::Future, marker::PhantomData};
+
+const MAX_SUBSCRIPTION_CAPACITY: usize = 4096;
+
+const SUB_API_TXPOOL_VALIDATE_TRANSACTION: &str = "TaggedTransactionQueue_validate_transaction";
+const SUB_API_TX_PAYMENT_QUERY_INFO: &str = "TransactionPaymentApi_query_info";
+const SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF: &str =
+	"GrandpaApi_generate_key_ownership_proof";
+
+/// Client implementation that connects to the Substrate node over `ws`/`wss` connection
+/// and is using RPC methods to get required data and submit transactions.
+pub struct RpcClient<C: Chain> {
+	// Lock order: `submit_signed_extrinsic_lock`, `data`
+	/// Client connection params.
+	params: Arc<ConnectionParams>,
+	/// If several tasks are submitting their transactions simultaneously using
+	/// `submit_signed_extrinsic` method, they may get the same transaction nonce. So one of
+	/// transactions will be rejected from the pool. This lock is here to prevent situations like
+	/// that.
+	submit_signed_extrinsic_lock: Arc<Mutex<()>>,
+	/// Genesis block hash.
+	genesis_hash: HashOf<C>,
+	/// Shared dynamic data.
+	data: Arc<RwLock<ClientData>>,
+	/// Generic arguments dump.
+	_phantom: PhantomData<C>,
+}
+
+/// Client data, shared by all `RpcClient` clones.
+struct ClientData {
+	/// Tokio runtime handle.
+	tokio: Arc<tokio::runtime::Runtime>,
+	/// Substrate RPC client.
+	client: Arc<WsClient>,
+}
+
+/// Already encoded value.
+struct PreEncoded(Vec<u8>);
+
+impl Encode for PreEncoded {
+	fn encode(&self) -> Vec<u8> {
+		self.0.clone()
+	}
+}
+
+impl<C: Chain> std::fmt::Debug for RpcClient<C> {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.write_fmt(format_args!("RpcClient<{}>", C::NAME))
+	}
+}
+
+impl<C: Chain> RpcClient<C> {
+	/// Returns client that is able to call RPCs on Substrate node over websocket connection.
+	///
+	/// This function will keep connecting to given Substrate node until connection is established
+	/// and is functional. If attempt fail, it will wait for `RECONNECT_DELAY` and retry again.
+	pub async fn new(params: ConnectionParams) -> Self {
+		let params = Arc::new(params);
+		loop {
+			match Self::try_connect(params.clone()).await {
+				Ok(client) => return client,
+				Err(error) => log::error!(
+					target: "bridge",
+					"Failed to connect to {} node: {:?}. Going to retry in {}s",
+					C::NAME,
+					error,
+					RECONNECT_DELAY.as_secs(),
+				),
+			}
+
+			async_std::task::sleep(RECONNECT_DELAY).await;
+		}
+	}
+
+	/// Try to connect to Substrate node over websocket. Returns Substrate RPC client if connection
+	/// has been established or error otherwise.
+	async fn try_connect(params: Arc<ConnectionParams>) -> Result<Self> {
+		let (tokio, client) = Self::build_client(&params).await?;
+
+		let genesis_hash_client = client.clone();
+		let genesis_hash = tokio
+			.spawn(async move {
+				SubstrateChainClient::<C>::block_hash(&*genesis_hash_client, Some(Zero::zero()))
+					.await
+			})
+			.await??;
+
+		let chain_runtime_version = params.chain_runtime_version;
+		let mut client = Self {
+			params,
+			submit_signed_extrinsic_lock: Arc::new(Mutex::new(())),
+			genesis_hash,
+			data: Arc::new(RwLock::new(ClientData { tokio, client })),
+			_phantom: PhantomData,
+		};
+		Self::ensure_correct_runtime_version(&mut client, chain_runtime_version).await?;
+		Ok(client)
+	}
+
+	// Check runtime version to understand if we need are connected to expected version, or we
+	// need to wait for upgrade, we need to abort immediately.
+	async fn ensure_correct_runtime_version<E: Environment<C, Error = Error>>(
+		env: &mut E,
+		expected: ChainRuntimeVersion,
+	) -> Result<()> {
+		// we are only interested if version mode is bundled or passed using CLI
+		let expected = match expected {
+			ChainRuntimeVersion::Auto => return Ok(()),
+			ChainRuntimeVersion::Custom(expected) => expected,
+		};
+
+		// we need to wait if actual version is < than expected, we are OK of versions are the
+		// same and we need to abort if actual version is > than expected
+		let actual = SimpleRuntimeVersion::from_runtime_version(&env.runtime_version().await?);
+		match actual.spec_version.cmp(&expected.spec_version) {
+			Ordering::Less =>
+				Err(Error::WaitingForRuntimeUpgrade { chain: C::NAME.into(), expected, actual }),
+			Ordering::Equal => Ok(()),
+			Ordering::Greater => {
+				log::error!(
+					target: "bridge",
+					"The {} client is configured to use runtime version {expected:?} and actual \
+					version is {actual:?}. Aborting",
+					C::NAME,
+				);
+				env.abort().await;
+				Err(Error::Custom("Aborted".into()))
+			},
+		}
+	}
+
+	/// Build client to use in connection.
+	async fn build_client(
+		params: &ConnectionParams,
+	) -> Result<(Arc<tokio::runtime::Runtime>, Arc<WsClient>)> {
+		let tokio = tokio::runtime::Runtime::new()?;
+		let uri = match params.uri {
+			Some(ref uri) => uri.clone(),
+			None => {
+				format!(
+					"{}://{}:{}{}",
+					if params.secure { "wss" } else { "ws" },
+					params.host,
+					params.port,
+					match params.path {
+						Some(ref path) => format!("/{}", path),
+						None => String::new(),
+					},
+				)
+			},
+		};
+		log::info!(target: "bridge", "Connecting to {} node at {}", C::NAME, uri);
+
+		let client = tokio
+			.spawn(async move {
+				WsClientBuilder::default()
+					.max_buffer_capacity_per_subscription(MAX_SUBSCRIPTION_CAPACITY)
+					.build(&uri)
+					.await
+			})
+			.await??;
+
+		Ok((Arc::new(tokio), Arc::new(client)))
+	}
+
+	/// Execute jsonrpsee future in tokio context.
+	async fn jsonrpsee_execute<MF, F, T>(&self, make_jsonrpsee_future: MF) -> Result<T>
+	where
+		MF: FnOnce(Arc<WsClient>) -> F + Send + 'static,
+		F: Future<Output = Result<T>> + Send + 'static,
+		T: Send + 'static,
+	{
+		let data = self.data.read().await;
+		let client = data.client.clone();
+		data.tokio.spawn(make_jsonrpsee_future(client)).await?
+	}
+
+	/// Prepare parameters used to sign chain transactions.
+	async fn build_sign_params(&self, signer: AccountKeyPairOf<C>) -> Result<SignParam<C>>
+	where
+		C: ChainWithTransactions,
+	{
+		let runtime_version = self.simple_runtime_version().await?;
+		Ok(SignParam::<C> {
+			spec_version: runtime_version.spec_version,
+			transaction_version: runtime_version.transaction_version,
+			genesis_hash: self.genesis_hash,
+			signer,
+		})
+	}
+
+	/// Get the nonce of the given Substrate account.
+	pub async fn next_account_index(&self, account: AccountIdOf<C>) -> Result<NonceOf<C>> {
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(SubstrateFrameSystemClient::<C>::account_next_index(&*client, account).await?)
+		})
+		.await
+	}
+
+	/// Subscribe to finality justifications.
+	async fn subscribe_finality_justifications<Fut>(
+		&self,
+		gadget_name: &str,
+		do_subscribe: impl FnOnce(Arc<WsClient>) -> Fut + Send + 'static,
+	) -> Result<Subscription<Bytes>>
+	where
+		Fut: Future<Output = std::result::Result<RpcSubscription<Bytes>, ClientError>> + Send,
+	{
+		let subscription = self
+			.jsonrpsee_execute(move |client| async move { Ok(do_subscribe(client).await?) })
+			.map_err(|e| Error::failed_to_subscribe_justification::<C>(e))
+			.await?;
+
+		Ok(Subscription::new_forwarded(
+			StreamDescription::new(format!("{} justifications", gadget_name), C::NAME.into()),
+			subscription,
+		))
+	}
+
+	/// Subscribe to headers stream.
+	async fn subscribe_headers<Fut>(
+		&self,
+		stream_name: &str,
+		do_subscribe: impl FnOnce(Arc<WsClient>) -> Fut + Send + 'static,
+		map_err: impl FnOnce(Error) -> Error,
+	) -> Result<Subscription<HeaderOf<C>>>
+	where
+		Fut: Future<Output = std::result::Result<RpcSubscription<HeaderOf<C>>, ClientError>> + Send,
+	{
+		let subscription = self
+			.jsonrpsee_execute(move |client| async move { Ok(do_subscribe(client).await?) })
+			.map_err(map_err)
+			.await?;
+
+		Ok(Subscription::new_forwarded(
+			StreamDescription::new(format!("{} headers", stream_name), C::NAME.into()),
+			subscription,
+		))
+	}
+}
+
+impl<C: Chain> Clone for RpcClient<C> {
+	fn clone(&self) -> Self {
+		RpcClient {
+			params: self.params.clone(),
+			submit_signed_extrinsic_lock: self.submit_signed_extrinsic_lock.clone(),
+			genesis_hash: self.genesis_hash,
+			data: self.data.clone(),
+			_phantom: PhantomData,
+		}
+	}
+}
+
+#[async_trait]
+impl<C: Chain> Client<C> for RpcClient<C> {
+	async fn ensure_synced(&self) -> Result<()> {
+		let health = self
+			.jsonrpsee_execute(|client| async move {
+				Ok(SubstrateSystemClient::<C>::health(&*client).await?)
+			})
+			.await
+			.map_err(|e| Error::failed_to_get_system_health::<C>(e))?;
+
+		let is_synced = !health.is_syncing && (!health.should_have_peers || health.peers > 0);
+		if is_synced {
+			Ok(())
+		} else {
+			Err(Error::ClientNotSynced(health))
+		}
+	}
+
+	async fn reconnect(&self) -> Result<()> {
+		let mut data = self.data.write().await;
+		let (tokio, client) = Self::build_client(&self.params).await?;
+		data.tokio = tokio;
+		data.client = client;
+		Ok(())
+	}
+
+	fn genesis_hash(&self) -> HashOf<C> {
+		self.genesis_hash
+	}
+
+	async fn header_hash_by_number(&self, number: BlockNumberOf<C>) -> Result<HashOf<C>> {
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(SubstrateChainClient::<C>::block_hash(&*client, Some(number)).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_read_header_hash_by_number::<C>(number, e))
+	}
+
+	async fn header_by_hash(&self, hash: HashOf<C>) -> Result<HeaderOf<C>> {
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(SubstrateChainClient::<C>::header(&*client, Some(hash)).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_read_header_by_hash::<C>(hash, e))
+	}
+
+	async fn block_by_hash(&self, hash: HashOf<C>) -> Result<SignedBlockOf<C>> {
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(SubstrateChainClient::<C>::block(&*client, Some(hash)).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_read_block_by_hash::<C>(hash, e))
+	}
+
+	async fn best_finalized_header_hash(&self) -> Result<HashOf<C>> {
+		self.jsonrpsee_execute(|client| async move {
+			Ok(SubstrateChainClient::<C>::finalized_head(&*client).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_read_best_finalized_header_hash::<C>(e))
+	}
+
+	async fn best_header(&self) -> Result<HeaderOf<C>> {
+		self.jsonrpsee_execute(|client| async move {
+			Ok(SubstrateChainClient::<C>::header(&*client, None).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_read_best_header::<C>(e))
+	}
+
+	async fn subscribe_best_headers(&self) -> Result<Subscription<HeaderOf<C>>> {
+		self.subscribe_headers(
+			"best headers",
+			move |client| async move { SubstrateChainClient::<C>::subscribe_new_heads(&*client).await },
+			|e| Error::failed_to_subscribe_best_headers::<C>(e),
+		)
+		.await
+	}
+
+	async fn subscribe_finalized_headers(&self) -> Result<Subscription<HeaderOf<C>>> {
+		self.subscribe_headers(
+			"best finalized headers",
+			move |client| async move {
+				SubstrateChainClient::<C>::subscribe_finalized_heads(&*client).await
+			},
+			|e| Error::failed_to_subscribe_finalized_headers::<C>(e),
+		)
+		.await
+	}
+
+	async fn subscribe_grandpa_finality_justifications(&self) -> Result<Subscription<Bytes>>
+	where
+		C: ChainWithGrandpa,
+	{
+		self.subscribe_finality_justifications("GRANDPA", move |client| async move {
+			SubstrateGrandpaClient::<C>::subscribe_justifications(&*client).await
+		})
+		.await
+	}
+
+	async fn generate_grandpa_key_ownership_proof(
+		&self,
+		at: HashOf<C>,
+		set_id: sp_consensus_grandpa::SetId,
+		authority_id: sp_consensus_grandpa::AuthorityId,
+	) -> Result<Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof>> {
+		self.state_call(
+			at,
+			SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF.into(),
+			(set_id, authority_id),
+		)
+		.await
+	}
+
+	async fn subscribe_beefy_finality_justifications(&self) -> Result<Subscription<Bytes>> {
+		self.subscribe_finality_justifications("BEEFY", move |client| async move {
+			SubstrateBeefyClient::<C>::subscribe_justifications(&*client).await
+		})
+		.await
+	}
+
+	async fn token_decimals(&self) -> Result<Option<u64>> {
+		self.jsonrpsee_execute(move |client| async move {
+			let system_properties = SubstrateSystemClient::<C>::properties(&*client).await?;
+			Ok(system_properties.get("tokenDecimals").and_then(|v| v.as_u64()))
+		})
+		.await
+	}
+
+	async fn runtime_version(&self) -> Result<RuntimeVersion> {
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(SubstrateStateClient::<C>::runtime_version(&*client).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_read_runtime_version::<C>(e))
+	}
+
+	async fn simple_runtime_version(&self) -> Result<SimpleRuntimeVersion> {
+		Ok(match self.params.chain_runtime_version {
+			ChainRuntimeVersion::Auto => {
+				let runtime_version = self.runtime_version().await?;
+				SimpleRuntimeVersion::from_runtime_version(&runtime_version)
+			},
+			ChainRuntimeVersion::Custom(ref version) => *version,
+		})
+	}
+
+	fn can_start_version_guard(&self) -> bool {
+		!matches!(self.params.chain_runtime_version, ChainRuntimeVersion::Auto)
+	}
+
+	async fn raw_storage_value(
+		&self,
+		at: HashOf<C>,
+		storage_key: StorageKey,
+	) -> Result<Option<StorageData>> {
+		let cloned_storage_key = storage_key.clone();
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(SubstrateStateClient::<C>::storage(&*client, cloned_storage_key, Some(at)).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_read_storage_value::<C>(at, storage_key, e))
+	}
+
+	async fn pending_extrinsics(&self) -> Result<Vec<Bytes>> {
+		self.jsonrpsee_execute(move |client| async move {
+			Ok(SubstrateAuthorClient::<C>::pending_extrinsics(&*client).await?)
+		})
+		.await
+		.map_err(|e| Error::failed_to_get_pending_extrinsics::<C>(e))
+	}
+
+	async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result<HashOf<C>> {
+		// one last check that the transaction is valid. Most of checks happen in the relay loop and
+		// it is the "final" check before submission.
+		let best_header_hash = self.best_header_hash().await?;
+		self.validate_transaction(best_header_hash, PreEncoded(transaction.0.clone()))
+			.await
+			.map_err(|e| Error::failed_to_submit_transaction::<C>(e))?
+			.map_err(|e| Error::failed_to_submit_transaction::<C>(Error::TransactionInvalid(e)))?;
+
+		self.jsonrpsee_execute(move |client| async move {
+			let tx_hash = SubstrateAuthorClient::<C>::submit_extrinsic(&*client, transaction)
+				.await
+				.map_err(|e| {
+					log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e);
+					e
+				})?;
+			log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash);
+			Ok(tx_hash)
+		})
+		.await
+		.map_err(|e| Error::failed_to_submit_transaction::<C>(e))
+	}
+
+	async fn submit_signed_extrinsic(
+		&self,
+		signer: &AccountKeyPairOf<C>,
+		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, NonceOf<C>) -> Result<UnsignedTransaction<C>>
+			+ Send
+			+ 'static,
+	) -> Result<HashOf<C>>
+	where
+		C: ChainWithTransactions,
+		AccountIdOf<C>: From<<AccountKeyPairOf<C> as Pair>::Public>,
+	{
+		let _guard = self.submit_signed_extrinsic_lock.lock().await;
+		let transaction_nonce = self.next_account_index(signer.public().into()).await?;
+		let best_header = self.best_header().await?;
+		let signing_data = self.build_sign_params(signer.clone()).await?;
+
+		// By using parent of best block here, we are protecting again best-block reorganizations.
+		// E.g. transaction may have been submitted when the best block was `A[num=100]`. Then it
+		// has been changed to `B[num=100]`. Hash of `A` has been included into transaction
+		// signature payload. So when signature will be checked, the check will fail and transaction
+		// will be dropped from the pool.
+		let best_header_id = best_header.parent_id().unwrap_or_else(|| best_header.id());
+
+		let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?;
+		let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode();
+		self.submit_unsigned_extrinsic(Bytes(signed_extrinsic)).await
+	}
+
+	async fn submit_and_watch_signed_extrinsic(
+		&self,
+		signer: &AccountKeyPairOf<C>,
+		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, NonceOf<C>) -> Result<UnsignedTransaction<C>>
+			+ Send
+			+ 'static,
+	) -> Result<TransactionTracker<C, Self>>
+	where
+		C: ChainWithTransactions,
+		AccountIdOf<C>: From<<AccountKeyPairOf<C> as Pair>::Public>,
+	{
+		let self_clone = self.clone();
+		let signing_data = self.build_sign_params(signer.clone()).await?;
+		let _guard = self.submit_signed_extrinsic_lock.lock().await;
+		let transaction_nonce = self.next_account_index(signer.public().into()).await?;
+		let best_header = self.best_header().await?;
+		let best_header_id = best_header.id();
+
+		let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?;
+		let stall_timeout = transaction_stall_timeout(
+			extrinsic.era.mortality_period(),
+			C::AVERAGE_BLOCK_INTERVAL,
+			STALL_TIMEOUT,
+		);
+		let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode();
+
+		// one last check that the transaction is valid. Most of checks happen in the relay loop and
+		// it is the "final" check before submission.
+		self.validate_transaction(best_header_id.hash(), PreEncoded(signed_extrinsic.clone()))
+			.await
+			.map_err(|e| Error::failed_to_submit_transaction::<C>(e))?
+			.map_err(|e| Error::failed_to_submit_transaction::<C>(Error::TransactionInvalid(e)))?;
+
+		self.jsonrpsee_execute(move |client| async move {
+			let tx_hash = C::Hasher::hash(&signed_extrinsic);
+			let subscription: jsonrpsee::core::client::Subscription<_> =
+				SubstrateAuthorClient::<C>::submit_and_watch_extrinsic(
+					&*client,
+					Bytes(signed_extrinsic),
+				)
+				.await
+				.map_err(|e| {
+					log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e);
+					e
+				})?;
+			log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash);
+			Ok(TransactionTracker::new(
+				self_clone,
+				stall_timeout,
+				tx_hash,
+				Subscription::new_forwarded(
+					StreamDescription::new("transaction events".into(), C::NAME.into()),
+					subscription,
+				),
+			))
+		})
+		.await
+		.map_err(|e| Error::failed_to_submit_transaction::<C>(e))
+	}
+
+	async fn validate_transaction<SignedTransaction: Encode + Send + 'static>(
+		&self,
+		at: HashOf<C>,
+		transaction: SignedTransaction,
+	) -> Result<TransactionValidity> {
+		self.state_call(
+			at,
+			SUB_API_TXPOOL_VALIDATE_TRANSACTION.into(),
+			(TransactionSource::External, transaction, at),
+		)
+		.await
+	}
+
+	async fn estimate_extrinsic_weight<SignedTransaction: Encode + Send + 'static>(
+		&self,
+		at: HashOf<C>,
+		transaction: SignedTransaction,
+	) -> Result<Weight> {
+		let transaction_len = transaction.encoded_size() as u32;
+		let dispatch_info: RuntimeDispatchInfo<BalanceOf<C>> = self
+			.state_call(at, SUB_API_TX_PAYMENT_QUERY_INFO.into(), (transaction, transaction_len))
+			.await?;
+
+		Ok(dispatch_info.weight)
+	}
+
+	async fn raw_state_call<Args: Encode + Send>(
+		&self,
+		at: HashOf<C>,
+		method: String,
+		arguments: Args,
+	) -> Result<Bytes> {
+		let arguments = Bytes(arguments.encode());
+		let arguments_clone = arguments.clone();
+		let method_clone = method.clone();
+		self.jsonrpsee_execute(move |client| async move {
+			SubstrateStateClient::<C>::call(&*client, method, arguments, Some(at))
+				.await
+				.map_err(Into::into)
+		})
+		.await
+		.map_err(|e| Error::failed_state_call::<C>(at, method_clone, arguments_clone, e))
+	}
+
+	async fn prove_storage(&self, at: HashOf<C>, keys: Vec<StorageKey>) -> Result<StorageProof> {
+		let keys_clone = keys.clone();
+		self.jsonrpsee_execute(move |client| async move {
+			SubstrateStateClient::<C>::prove_storage(&*client, keys, Some(at))
+				.await
+				.map(|proof| StorageProof::new(proof.proof.into_iter().map(|b| b.0)))
+				.map_err(Into::into)
+		})
+		.await
+		.map_err(|e| Error::failed_to_prove_storage::<C>(at, keys_clone, e))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{guard::tests::TestEnvironment, test_chain::TestChain};
+	use futures::{channel::mpsc::unbounded, FutureExt, SinkExt, StreamExt};
+
+	async fn run_ensure_correct_runtime_version(
+		expected: ChainRuntimeVersion,
+		actual: RuntimeVersion,
+	) -> Result<()> {
+		let (
+			(mut runtime_version_tx, runtime_version_rx),
+			(slept_tx, _slept_rx),
+			(aborted_tx, mut aborted_rx),
+		) = (unbounded(), unbounded(), unbounded());
+		runtime_version_tx.send(actual).await.unwrap();
+		let mut env = TestEnvironment { runtime_version_rx, slept_tx, aborted_tx };
+
+		let ensure_correct_runtime_version =
+			RpcClient::<TestChain>::ensure_correct_runtime_version(&mut env, expected).boxed();
+		let aborted = aborted_rx.next().map(|_| Err(Error::Custom("".into()))).boxed();
+		futures::pin_mut!(ensure_correct_runtime_version, aborted);
+		futures::future::select(ensure_correct_runtime_version, aborted)
+			.await
+			.into_inner()
+			.0
+	}
+
+	#[async_std::test]
+	async fn ensure_correct_runtime_version_works() {
+		// when we are configured to use auto version
+		assert!(matches!(
+			run_ensure_correct_runtime_version(
+				ChainRuntimeVersion::Auto,
+				RuntimeVersion {
+					spec_version: 100,
+					transaction_version: 100,
+					..Default::default()
+				},
+			)
+			.await,
+			Ok(()),
+		));
+		// when actual == expected
+		assert!(matches!(
+			run_ensure_correct_runtime_version(
+				ChainRuntimeVersion::Custom(SimpleRuntimeVersion {
+					spec_version: 100,
+					transaction_version: 100
+				}),
+				RuntimeVersion {
+					spec_version: 100,
+					transaction_version: 100,
+					..Default::default()
+				},
+			)
+			.await,
+			Ok(()),
+		));
+		// when actual spec version < expected spec version
+		assert!(matches!(
+			run_ensure_correct_runtime_version(
+				ChainRuntimeVersion::Custom(SimpleRuntimeVersion {
+					spec_version: 100,
+					transaction_version: 100
+				}),
+				RuntimeVersion { spec_version: 99, transaction_version: 100, ..Default::default() },
+			)
+			.await,
+			Err(Error::WaitingForRuntimeUpgrade {
+				expected: SimpleRuntimeVersion { spec_version: 100, transaction_version: 100 },
+				actual: SimpleRuntimeVersion { spec_version: 99, transaction_version: 100 },
+				..
+			}),
+		));
+		// when actual spec version > expected spec version
+		assert!(matches!(
+			run_ensure_correct_runtime_version(
+				ChainRuntimeVersion::Custom(SimpleRuntimeVersion {
+					spec_version: 100,
+					transaction_version: 100
+				}),
+				RuntimeVersion {
+					spec_version: 101,
+					transaction_version: 100,
+					..Default::default()
+				},
+			)
+			.await,
+			Err(Error::Custom(_)),
+		));
+	}
+}
diff --git a/bridges/relays/client-substrate/src/rpc.rs b/bridges/relays/client-substrate/src/client/rpc_api.rs
similarity index 80%
rename from bridges/relays/client-substrate/src/rpc.rs
rename to bridges/relays/client-substrate/src/client/rpc_api.rs
index 60c29cdeb5c7707619b65d23800dcd7dfdfd840a..9cac69f7a13d06bf772fb9493520113d8e066681 100644
--- a/bridges/relays/client-substrate/src/rpc.rs
+++ b/bridges/relays/client-substrate/src/client/rpc_api.rs
@@ -16,15 +16,9 @@
 
 //! The most generic Substrate node RPC interface.
 
-use async_trait::async_trait;
-
 use crate::{Chain, ChainWithGrandpa, TransactionStatusOf};
 
-use jsonrpsee::{
-	core::{client::Subscription, ClientError},
-	proc_macros::rpc,
-	ws_client::WsClient,
-};
+use jsonrpsee::proc_macros::rpc;
 use pallet_transaction_payment_rpc_runtime_api::FeeDetails;
 use sc_rpc_api::{state::ReadProof, system::Health};
 use sp_core::{
@@ -60,6 +54,20 @@ pub(crate) trait SubstrateChain<C> {
 	/// Return signed block (with justifications) by its hash.
 	#[method(name = "getBlock")]
 	async fn block(&self, block_hash: Option<C::Hash>) -> RpcResult<C::SignedBlock>;
+	/// Subscribe to best headers.
+	#[subscription(
+		name = "subscribeNewHeads" => "newHead",
+		unsubscribe = "unsubscribeNewHeads",
+		item = C::Header
+	)]
+	async fn subscribe_new_heads(&self);
+	/// Subscribe to finalized headers.
+	#[subscription(
+		name = "subscribeFinalizedHeads" => "finalizedHead",
+		unsubscribe = "unsubscribeFinalizedHeads",
+		item = C::Header
+	)]
+	async fn subscribe_finalized_heads(&self);
 }
 
 /// RPC methods of Substrate `author` namespace, that we are using.
@@ -106,15 +114,6 @@ pub(crate) trait SubstrateState<C> {
 	) -> RpcResult<ReadProof<C::Hash>>;
 }
 
-/// RPC methods that we are using for a certain finality gadget.
-#[async_trait]
-pub trait SubstrateFinalityClient<C: Chain> {
-	/// Subscribe to finality justifications.
-	async fn subscribe_justifications(
-		client: &WsClient,
-	) -> Result<Subscription<Bytes>, ClientError>;
-}
-
 /// RPC methods of Substrate `grandpa` namespace, that we are using.
 #[rpc(client, client_bounds(C: ChainWithGrandpa), namespace = "grandpa")]
 pub(crate) trait SubstrateGrandpa<C> {
@@ -123,17 +122,6 @@ pub(crate) trait SubstrateGrandpa<C> {
 	async fn subscribe_justifications(&self);
 }
 
-/// RPC finality methods of Substrate `grandpa` namespace, that we are using.
-pub struct SubstrateGrandpaFinalityClient;
-#[async_trait]
-impl<C: ChainWithGrandpa> SubstrateFinalityClient<C> for SubstrateGrandpaFinalityClient {
-	async fn subscribe_justifications(
-		client: &WsClient,
-	) -> Result<Subscription<Bytes>, ClientError> {
-		SubstrateGrandpaClient::<C>::subscribe_justifications(client).await
-	}
-}
-
 // TODO: Use `ChainWithBeefy` instead of `Chain` after #1606 is merged
 /// RPC methods of Substrate `beefy` namespace, that we are using.
 #[rpc(client, client_bounds(C: Chain), namespace = "beefy")]
@@ -143,18 +131,6 @@ pub(crate) trait SubstrateBeefy<C> {
 	async fn subscribe_justifications(&self);
 }
 
-/// RPC finality methods of Substrate `beefy` namespace, that we are using.
-pub struct SubstrateBeefyFinalityClient;
-// TODO: Use `ChainWithBeefy` instead of `Chain` after #1606 is merged
-#[async_trait]
-impl<C: Chain> SubstrateFinalityClient<C> for SubstrateBeefyFinalityClient {
-	async fn subscribe_justifications(
-		client: &WsClient,
-	) -> Result<Subscription<Bytes>, ClientError> {
-		SubstrateBeefyClient::<C>::subscribe_justifications(client).await
-	}
-}
-
 /// RPC methods of Substrate `system` frame pallet, that we are using.
 #[rpc(client, client_bounds(C: Chain), namespace = "system")]
 pub(crate) trait SubstrateFrameSystem<C> {
diff --git a/bridges/relays/client-substrate/src/client/subscription.rs b/bridges/relays/client-substrate/src/client/subscription.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43a46573f987b9d58f7b98050359614767bcee3e
--- /dev/null
+++ b/bridges/relays/client-substrate/src/client/subscription.rs
@@ -0,0 +1,239 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::error::Result as ClientResult;
+
+use async_std::{
+	channel::{bounded, Receiver, Sender},
+	stream::StreamExt,
+};
+use futures::{FutureExt, Stream};
+use jsonrpsee::core::ClientError;
+use sp_runtime::DeserializeOwned;
+use std::{
+	fmt::Debug,
+	pin::Pin,
+	result::Result as StdResult,
+	task::{Context, Poll},
+};
+
+/// Once channel reaches this capacity, the subscription breaks.
+const CHANNEL_CAPACITY: usize = 128;
+
+/// Structure describing a stream.
+#[derive(Clone)]
+pub struct StreamDescription {
+	stream_name: String,
+	chain_name: String,
+}
+
+impl StreamDescription {
+	/// Create a new instance of `StreamDescription`.
+	pub fn new(stream_name: String, chain_name: String) -> Self {
+		Self { stream_name, chain_name }
+	}
+
+	/// Get a stream description.
+	fn get(&self) -> String {
+		format!("{} stream of {}", self.stream_name, self.chain_name)
+	}
+}
+
+/// Chainable stream that transforms items of type `Result<T, E>` to items of type `T`.
+///
+/// If it encounters an item of type `Err`, it returns `Poll::Ready(None)`
+/// and terminates the underlying stream.
+struct Unwrap<S: Stream<Item = StdResult<T, E>>, T, E> {
+	desc: StreamDescription,
+	stream: Option<S>,
+}
+
+impl<S: Stream<Item = StdResult<T, E>>, T, E> Unwrap<S, T, E> {
+	/// Create a new instance of `Unwrap`.
+	pub fn new(desc: StreamDescription, stream: S) -> Self {
+		Self { desc, stream: Some(stream) }
+	}
+}
+
+impl<S: Stream<Item = StdResult<T, E>> + Unpin, T: DeserializeOwned, E: Debug> Stream
+	for Unwrap<S, T, E>
+{
+	type Item = T;
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+		Poll::Ready(match self.stream.as_mut() {
+			Some(subscription) => match futures::ready!(Pin::new(subscription).poll_next(cx)) {
+				Some(Ok(item)) => Some(item),
+				Some(Err(e)) => {
+					self.stream.take();
+					log::debug!(
+						target: "bridge",
+						"{} has returned error: {:?}. It may need to be restarted",
+						self.desc.get(),
+						e,
+					);
+					None
+				},
+				None => {
+					self.stream.take();
+					log::debug!(
+						target: "bridge",
+						"{} has returned `None`. It may need to be restarted",
+						self.desc.get()
+					);
+					None
+				},
+			},
+			None => None,
+		})
+	}
+}
+
+/// Subscription factory that produces subscriptions, sharing the same background thread.
+#[derive(Clone)]
+pub struct SubscriptionBroadcaster<T> {
+	desc: StreamDescription,
+	subscribers_sender: Sender<Sender<T>>,
+}
+
+impl<T: 'static + Clone + DeserializeOwned + Send> SubscriptionBroadcaster<T> {
+	/// Create new subscription factory.
+	pub fn new(subscription: Subscription<T>) -> StdResult<Self, Subscription<T>> {
+		// It doesn't make sense to further broadcast a broadcasted subscription.
+		if subscription.is_broadcasted {
+			return Err(subscription)
+		}
+
+		let desc = subscription.desc().clone();
+		let (subscribers_sender, subscribers_receiver) = bounded(CHANNEL_CAPACITY);
+		async_std::task::spawn(background_worker(subscription, subscribers_receiver));
+		Ok(Self { desc, subscribers_sender })
+	}
+
+	/// Produce new subscription.
+	pub async fn subscribe(&self) -> ClientResult<Subscription<T>> {
+		let (items_sender, items_receiver) = bounded(CHANNEL_CAPACITY);
+		self.subscribers_sender.try_send(items_sender)?;
+
+		Ok(Subscription::new_broadcasted(self.desc.clone(), items_receiver))
+	}
+}
+
+/// Subscription to some chain events.
+pub struct Subscription<T> {
+	desc: StreamDescription,
+	subscription: Box<dyn Stream<Item = T> + Unpin + Send>,
+	is_broadcasted: bool,
+}
+
+impl<T: 'static + Clone + DeserializeOwned + Send> Subscription<T> {
+	/// Create new forwarded subscription.
+	pub fn new_forwarded(
+		desc: StreamDescription,
+		subscription: impl Stream<Item = StdResult<T, ClientError>> + Unpin + Send + 'static,
+	) -> Self {
+		Self {
+			desc: desc.clone(),
+			subscription: Box::new(Unwrap::new(desc, subscription)),
+			is_broadcasted: false,
+		}
+	}
+
+	/// Create new broadcasted subscription.
+	pub fn new_broadcasted(
+		desc: StreamDescription,
+		subscription: impl Stream<Item = T> + Unpin + Send + 'static,
+	) -> Self {
+		Self { desc, subscription: Box::new(subscription), is_broadcasted: true }
+	}
+
+	/// Get the description of the underlying stream
+	pub fn desc(&self) -> &StreamDescription {
+		&self.desc
+	}
+}
+
+impl<T> Stream for Subscription<T> {
+	type Item = T;
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+		Poll::Ready(futures::ready!(Pin::new(&mut self.subscription).poll_next(cx)))
+	}
+}
+
+/// Background worker that is executed in tokio context as `jsonrpsee` requires.
+///
+/// This task may exit under some circumstances. It'll send the correspondent
+/// message (`Err` or `None`) to all known listeners. Also, when it stops, all
+/// subsequent reads and new subscribers will get the connection error (`ChannelError`).
+async fn background_worker<T: 'static + Clone + DeserializeOwned + Send>(
+	mut subscription: Subscription<T>,
+	mut subscribers_receiver: Receiver<Sender<T>>,
+) {
+	fn log_task_exit(desc: &StreamDescription, reason: &str) {
+		log::debug!(
+			target: "bridge",
+			"Background task of subscription broadcaster for {} has stopped: {}",
+			desc.get(),
+			reason,
+		);
+	}
+
+	// wait for first subscriber until actually starting subscription
+	let subscriber = match subscribers_receiver.next().await {
+		Some(subscriber) => subscriber,
+		None => {
+			// it means that the last subscriber/factory has been dropped, so we need to
+			// exit too
+			return log_task_exit(subscription.desc(), "client has stopped")
+		},
+	};
+
+	// actually subscribe
+	let mut subscribers = vec![subscriber];
+
+	// start listening for new items and receivers
+	loop {
+		futures::select! {
+			subscriber = subscribers_receiver.next().fuse() => {
+				match subscriber {
+					Some(subscriber) => subscribers.push(subscriber),
+					None => {
+						// it means that the last subscriber/factory has been dropped, so we need to
+						// exit too
+						return log_task_exit(subscription.desc(), "client has stopped")
+					},
+				}
+			},
+			maybe_item = subscription.subscription.next().fuse() => {
+				match maybe_item {
+					Some(item) => {
+						// notify subscribers
+						subscribers.retain(|subscriber| {
+							let send_result = subscriber.try_send(item.clone());
+							send_result.is_ok()
+						});
+					}
+					None => {
+						// The underlying client has dropped, so we can't do anything here
+						// and need to stop the task.
+						return log_task_exit(subscription.desc(), "stream has finished");
+					}
+				}
+			},
+		}
+	}
+}
diff --git a/bridges/relays/client-substrate/src/client/traits.rs b/bridges/relays/client-substrate/src/client/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..49f5c001c3f7d80fd51892c8de73f41960557cba
--- /dev/null
+++ b/bridges/relays/client-substrate/src/client/traits.rs
@@ -0,0 +1,230 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+	error::{Error, Result},
+	AccountIdOf, AccountKeyPairOf, BlockNumberOf, Chain, ChainWithGrandpa, ChainWithTransactions,
+	HashOf, HeaderIdOf, HeaderOf, NonceOf, SignedBlockOf, SimpleRuntimeVersion, Subscription,
+	TransactionTracker, UnsignedTransaction,
+};
+
+use async_trait::async_trait;
+use bp_runtime::{StorageDoubleMapKeyProvider, StorageMapKeyProvider};
+use codec::{Decode, Encode};
+use frame_support::weights::Weight;
+use sp_core::{
+	storage::{StorageData, StorageKey},
+	Bytes, Pair,
+};
+use sp_runtime::{traits::Header as _, transaction_validity::TransactionValidity};
+use sp_trie::StorageProof;
+use sp_version::RuntimeVersion;
+use std::fmt::Debug;
+
+/// Relay uses the `Client` to communicate with the node, connected to Substrate
+/// chain `C`.
+#[async_trait]
+pub trait Client<C: Chain>: 'static + Send + Sync + Clone + Debug {
+	/// Returns error if client has no connected peers or it believes it is far
+	/// behind the chain tip.
+	async fn ensure_synced(&self) -> Result<()>;
+	/// Reconnects the client.
+	async fn reconnect(&self) -> Result<()>;
+
+	/// Return hash of the genesis block.
+	fn genesis_hash(&self) -> HashOf<C>;
+	/// Get header hash by number.
+	async fn header_hash_by_number(&self, number: BlockNumberOf<C>) -> Result<HashOf<C>>;
+	/// Get header by hash.
+	async fn header_by_hash(&self, hash: HashOf<C>) -> Result<HeaderOf<C>>;
+	/// Get header by number.
+	async fn header_by_number(&self, number: BlockNumberOf<C>) -> Result<HeaderOf<C>> {
+		self.header_by_hash(self.header_hash_by_number(number).await?).await
+	}
+	/// Get block by hash.
+	async fn block_by_hash(&self, hash: HashOf<C>) -> Result<SignedBlockOf<C>>;
+
+	/// Get best finalized header hash.
+	async fn best_finalized_header_hash(&self) -> Result<HashOf<C>>;
+	/// Get best finalized header number.
+	async fn best_finalized_header_number(&self) -> Result<BlockNumberOf<C>> {
+		Ok(*self.best_finalized_header().await?.number())
+	}
+	/// Get best finalized header.
+	async fn best_finalized_header(&self) -> Result<HeaderOf<C>> {
+		self.header_by_hash(self.best_finalized_header_hash().await?).await
+	}
+
+	/// Get best header.
+	async fn best_header(&self) -> Result<HeaderOf<C>>;
+	/// Get best header hash.
+	async fn best_header_hash(&self) -> Result<HashOf<C>> {
+		Ok(self.best_header().await?.hash())
+	}
+
+	/// Subscribe to new best headers.
+	async fn subscribe_best_headers(&self) -> Result<Subscription<HeaderOf<C>>>;
+	/// Subscribe to new finalized headers.
+	async fn subscribe_finalized_headers(&self) -> Result<Subscription<HeaderOf<C>>>;
+
+	/// Subscribe to GRANDPA finality justifications.
+	async fn subscribe_grandpa_finality_justifications(&self) -> Result<Subscription<Bytes>>
+	where
+		C: ChainWithGrandpa;
+	/// Generates a proof of key ownership for the given authority in the given set.
+	async fn generate_grandpa_key_ownership_proof(
+		&self,
+		at: HashOf<C>,
+		set_id: sp_consensus_grandpa::SetId,
+		authority_id: sp_consensus_grandpa::AuthorityId,
+	) -> Result<Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof>>;
+
+	/// Subscribe to BEEFY finality justifications.
+	async fn subscribe_beefy_finality_justifications(&self) -> Result<Subscription<Bytes>>;
+
+	/// Return `tokenDecimals` property from the set of chain properties.
+	async fn token_decimals(&self) -> Result<Option<u64>>;
+	/// Get runtime version of the connected chain.
+	async fn runtime_version(&self) -> Result<RuntimeVersion>;
+	/// Get partial runtime version, to use when signing transactions.
+	async fn simple_runtime_version(&self) -> Result<SimpleRuntimeVersion>;
+	/// Returns `true` if version guard can be started.
+	///
+	/// There's no reason to run version guard when version mode is set to `Auto`. It can
+	/// lead to relay shutdown when chain is upgraded, even though we have explicitly
+	/// said that we don't want to shutdown.
+	fn can_start_version_guard(&self) -> bool;
+
+	/// Read raw value from runtime storage.
+	async fn raw_storage_value(
+		&self,
+		at: HashOf<C>,
+		storage_key: StorageKey,
+	) -> Result<Option<StorageData>>;
+	/// Read and decode value from runtime storage.
+	async fn storage_value<T: Decode + 'static>(
+		&self,
+		at: HashOf<C>,
+		storage_key: StorageKey,
+	) -> Result<Option<T>> {
+		self.raw_storage_value(at, storage_key.clone())
+			.await?
+			.map(|encoded_value| {
+				T::decode(&mut &encoded_value.0[..]).map_err(|e| {
+					Error::failed_to_read_storage_value::<C>(at, storage_key, e.into())
+				})
+			})
+			.transpose()
+	}
+	/// Read and decode value from runtime storage map.
+	///
+	/// `pallet_prefix` is the name of the pallet (used in `construct_runtime`), which
+	/// "contains" the storage map.
+	async fn storage_map_value<T: StorageMapKeyProvider>(
+		&self,
+		at: HashOf<C>,
+		pallet_prefix: &str,
+		storage_key: &T::Key,
+	) -> Result<Option<T::Value>> {
+		self.storage_value(at, T::final_key(pallet_prefix, storage_key)).await
+	}
+	/// Read and decode value from runtime storage double map.
+	///
+	/// `pallet_prefix` is the name of the pallet (used in `construct_runtime`), which
+	/// "contains" the storage double map.
+	async fn storage_double_map_value<T: StorageDoubleMapKeyProvider>(
+		&self,
+		at: HashOf<C>,
+		pallet_prefix: &str,
+		key1: &T::Key1,
+		key2: &T::Key2,
+	) -> Result<Option<T::Value>> {
+		self.storage_value(at, T::final_key(pallet_prefix, key1, key2)).await
+	}
+
+	/// Returns pending extrinsics from transaction pool.
+	async fn pending_extrinsics(&self) -> Result<Vec<Bytes>>;
+	/// Submit unsigned extrinsic for inclusion in a block.
+	///
+	/// Note: The given transaction needs to be SCALE encoded beforehand.
+	async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result<HashOf<C>>;
+	/// Submit an extrinsic signed by given account.
+	///
+	/// All calls of this method are synchronized, so there can't be more than one active
+	/// `submit_signed_extrinsic()` call. This guarantees that no nonces collision may happen
+	/// if all client instances are clones of the same initial `Client`.
+	///
+	/// Note: The given transaction needs to be SCALE encoded beforehand.
+	async fn submit_signed_extrinsic(
+		&self,
+		signer: &AccountKeyPairOf<C>,
+		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, NonceOf<C>) -> Result<UnsignedTransaction<C>>
+			+ Send
+			+ 'static,
+	) -> Result<HashOf<C>>
+	where
+		C: ChainWithTransactions,
+		AccountIdOf<C>: From<<AccountKeyPairOf<C> as Pair>::Public>;
+	/// Does exactly the same as `submit_signed_extrinsic`, but keeps watching for extrinsic status
+	/// after submission.
+	async fn submit_and_watch_signed_extrinsic(
+		&self,
+		signer: &AccountKeyPairOf<C>,
+		prepare_extrinsic: impl FnOnce(HeaderIdOf<C>, NonceOf<C>) -> Result<UnsignedTransaction<C>>
+			+ Send
+			+ 'static,
+	) -> Result<TransactionTracker<C, Self>>
+	where
+		C: ChainWithTransactions,
+		AccountIdOf<C>: From<<AccountKeyPairOf<C> as Pair>::Public>;
+	/// Validate transaction at given block.
+	async fn validate_transaction<SignedTransaction: Encode + Send + 'static>(
+		&self,
+		at: HashOf<C>,
+		transaction: SignedTransaction,
+	) -> Result<TransactionValidity>;
+	/// Returns weight of the given transaction.
+	async fn estimate_extrinsic_weight<SignedTransaction: Encode + Send + 'static>(
+		&self,
+		at: HashOf<C>,
+		transaction: SignedTransaction,
+	) -> Result<Weight>;
+
+	/// Execute runtime call at given block.
+	async fn raw_state_call<Args: Encode + Send>(
+		&self,
+		at: HashOf<C>,
+		method: String,
+		arguments: Args,
+	) -> Result<Bytes>;
+	/// Execute runtime call at given block, provided the input and output types.
+	/// It also performs the input encode and output decode.
+	async fn state_call<Args: Encode + Send, Ret: Decode>(
+		&self,
+		at: HashOf<C>,
+		method: String,
+		arguments: Args,
+	) -> Result<Ret> {
+		let encoded_arguments = arguments.encode();
+		let encoded_output = self.raw_state_call(at, method.clone(), arguments).await?;
+		Ret::decode(&mut &encoded_output.0[..]).map_err(|e| {
+			Error::failed_state_call::<C>(at, method, Bytes(encoded_arguments), e.into())
+		})
+	}
+
+	/// Returns storage proof of given storage keys.
+	async fn prove_storage(&self, at: HashOf<C>, keys: Vec<StorageKey>) -> Result<StorageProof>;
+}
diff --git a/bridges/relays/client-substrate/src/error.rs b/bridges/relays/client-substrate/src/error.rs
index 0b446681818879d662ba9a71679a799519cf491b..b09e2c7abdc666735d7481d3f39c9492d851f76a 100644
--- a/bridges/relays/client-substrate/src/error.rs
+++ b/bridges/relays/client-substrate/src/error.rs
@@ -16,12 +16,13 @@
 
 //! Substrate node RPC errors.
 
-use crate::SimpleRuntimeVersion;
+use crate::{BlockNumberOf, Chain, HashOf, SimpleRuntimeVersion};
+use bp_header_chain::SubmitFinalityProofCallExtras;
 use bp_polkadot_core::parachains::ParaId;
 use jsonrpsee::core::ClientError as RpcError;
 use relay_utils::MaybeConnectionError;
 use sc_rpc_api::system::Health;
-use sp_core::storage::StorageKey;
+use sp_core::{storage::StorageKey, Bytes};
 use sp_runtime::transaction_validity::TransactionValidityError;
 use thiserror::Error;
 
@@ -42,12 +43,10 @@ pub enum Error {
 	/// The response from the server could not be SCALE decoded.
 	#[error("Response parse failed: {0}")]
 	ResponseParseFailed(#[from] codec::Error),
-	/// Account does not exist on the chain.
-	#[error("Account does not exist on the chain.")]
-	AccountDoesNotExist,
-	/// Runtime storage is missing some mandatory value.
-	#[error("Mandatory storage value is missing from the runtime storage.")]
-	MissingMandatoryStorageValue,
+	/// Internal channel error - communication channel is either closed, or full.
+	/// It can be solved with reconnect.
+	#[error("Internal communication channel error: {0:?}.")]
+	ChannelError(String),
 	/// Required parachain head is not present at the relay chain.
 	#[error("Parachain {0:?} head {1} is missing from the relay chain storage.")]
 	MissingRequiredParachainHead(ParaId, u64),
@@ -57,6 +56,14 @@ pub enum Error {
 	/// The client we're connected to is not synced, so we can't rely on its state.
 	#[error("Substrate client is not synced {0}.")]
 	ClientNotSynced(Health),
+	/// Failed to get system health.
+	#[error("Failed to get system health of {chain} node: {error:?}.")]
+	FailedToGetSystemHealth {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
 	/// Failed to read best finalized header hash from given chain.
 	#[error("Failed to read best finalized header hash of {chain}: {error:?}.")]
 	FailedToReadBestFinalizedHeaderHash {
@@ -73,6 +80,16 @@ pub enum Error {
 		/// Underlying error.
 		error: Box<Error>,
 	},
+	/// Failed to read header hash by number from given chain.
+	#[error("Failed to read header hash by number {number} of {chain}: {error:?}.")]
+	FailedToReadHeaderHashByNumber {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Number of the header we've tried to read.
+		number: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
 	/// Failed to read header by hash from given chain.
 	#[error("Failed to read header {hash} of {chain}: {error:?}.")]
 	FailedToReadHeaderByHash {
@@ -83,35 +100,119 @@ pub enum Error {
 		/// Underlying error.
 		error: Box<Error>,
 	},
-	/// Failed to execute runtime call at given chain.
-	#[error("Failed to execute runtime call {method} at {chain}: {error:?}.")]
-	ErrorExecutingRuntimeCall {
+	/// Failed to read block by hash from given chain.
+	#[error("Failed to read block {hash} of {chain}: {error:?}.")]
+	FailedToReadBlockByHash {
 		/// Name of the chain where the error has happened.
 		chain: String,
-		/// Runtime method name.
-		method: String,
+		/// Hash of the header we've tried to read.
+		hash: String,
 		/// Underlying error.
 		error: Box<Error>,
 	},
 	/// Failed to read sotrage value at given chain.
 	#[error("Failed to read storage value {key:?} at {chain}: {error:?}.")]
-	FailedToReadRuntimeStorageValue {
+	FailedToReadStorageValue {
 		/// Name of the chain where the error has happened.
 		chain: String,
+		/// Hash of the block we've tried to read value from.
+		hash: String,
 		/// Runtime storage key
 		key: StorageKey,
 		/// Underlying error.
 		error: Box<Error>,
 	},
+	/// Failed to read runtime version of given chain.
+	#[error("Failed to read runtime version of {chain}: {error:?}.")]
+	FailedToReadRuntimeVersion {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Failed to get pending extrinsics.
+	#[error("Failed to get pending extrinsics of {chain}: {error:?}.")]
+	FailedToGetPendingExtrinsics {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Failed to submit transaction.
+	#[error("Failed to submit {chain} transaction: {error:?}.")]
+	FailedToSubmitTransaction {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Runtime call has failed.
+	#[error("Runtime call {method} with arguments {arguments:?} of chain {chain} at {hash} has failed: {error:?}.")]
+	FailedStateCall {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Hash of the block we've tried to call at.
+		hash: String,
+		/// Runtime API method.
+		method: String,
+		/// Encoded method arguments.
+		arguments: Bytes,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Failed to prove storage keys.
+	#[error("Failed to prove storage keys {storage_keys:?} of {chain} at {hash}: {error:?}.")]
+	FailedToProveStorage {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Hash of the block we've tried to prove keys at.
+		hash: String,
+		/// Storage keys we have tried to prove.
+		storage_keys: Vec<StorageKey>,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Failed to subscribe to GRANDPA justifications stream.
+	#[error("Failed to subscribe to {chain} best headers: {error:?}.")]
+	FailedToSubscribeBestHeaders {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Failed to subscribe to GRANDPA justifications stream.
+	#[error("Failed to subscribe to {chain} finalized headers: {error:?}.")]
+	FailedToSubscribeFinalizedHeaders {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Failed to subscribe to GRANDPA justifications stream.
+	#[error("Failed to subscribe to {chain} justifications: {error:?}.")]
+	FailedToSubscribeJustifications {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Underlying error.
+		error: Box<Error>,
+	},
+	/// Headers of the chain are finalized out of order. Maybe chain has been
+	/// restarted?
+	#[error("Finalized headers of {chain} are unordered: previously finalized {prev_number} vs new {next_number}")]
+	UnorderedFinalizedHeaders {
+		/// Name of the chain where the error has happened.
+		chain: String,
+		/// Previously finalized header number.
+		prev_number: String,
+		/// New finalized header number.
+		next_number: String,
+	},
 	/// The bridge pallet is halted and all transactions will be rejected.
 	#[error("Bridge pallet is halted.")]
 	BridgePalletIsHalted,
 	/// The bridge pallet is not yet initialized and all transactions will be rejected.
 	#[error("Bridge pallet is not initialized.")]
 	BridgePalletIsNotInitialized,
-	/// There's no best head of the parachain at the `pallet-bridge-parachains` at the target side.
-	#[error("No head of the ParaId({0}) at the bridge parachains pallet at {1}.")]
-	NoParachainHeadAtTarget(u32, String),
 	/// An error has happened when we have tried to parse storage proof.
 	#[error("Error when parsing storage proof: {0:?}.")]
 	StorageProofError(bp_runtime::StorageProofError),
@@ -129,6 +230,12 @@ pub enum Error {
 		/// Actual runtime version.
 		actual: SimpleRuntimeVersion,
 	},
+	/// Finality proof submission exceeds size and/or weight limits.
+	#[error("Finality proof submission exceeds limits: {extras:?}")]
+	FinalityProofWeightLimitExceeded {
+		/// Finality proof submission extras.
+		extras: SubmitFinalityProofCallExtras,
+	},
 	/// Custom logic error.
 	#[error("{0}")]
 	Custom(String),
@@ -136,7 +243,19 @@ pub enum Error {
 
 impl From<tokio::task::JoinError> for Error {
 	fn from(error: tokio::task::JoinError) -> Self {
-		Error::Custom(format!("Failed to wait tokio task: {error}"))
+		Error::ChannelError(format!("failed to wait tokio task: {error}"))
+	}
+}
+
+impl<T> From<async_std::channel::TrySendError<T>> for Error {
+	fn from(error: async_std::channel::TrySendError<T>) -> Self {
+		Error::ChannelError(format!("`try_send` has failed: {error:?}"))
+	}
+}
+
+impl From<async_std::channel::RecvError> for Error {
+	fn from(error: async_std::channel::RecvError) -> Self {
+		Error::ChannelError(format!("`recv` has failed: {error:?}"))
 	}
 }
 
@@ -145,21 +264,170 @@ impl Error {
 	pub fn boxed(self) -> Box<Self> {
 		Box::new(self)
 	}
+
+	/// Returns nested error reference.
+	pub fn nested(&self) -> Option<&Self> {
+		match *self {
+			Self::FailedToReadBestFinalizedHeaderHash { ref error, .. } => Some(&**error),
+			Self::FailedToReadBestHeader { ref error, .. } => Some(&**error),
+			Self::FailedToReadHeaderHashByNumber { ref error, .. } => Some(&**error),
+			Self::FailedToReadHeaderByHash { ref error, .. } => Some(&**error),
+			Self::FailedToReadBlockByHash { ref error, .. } => Some(&**error),
+			Self::FailedToReadStorageValue { ref error, .. } => Some(&**error),
+			Self::FailedToReadRuntimeVersion { ref error, .. } => Some(&**error),
+			Self::FailedToGetPendingExtrinsics { ref error, .. } => Some(&**error),
+			Self::FailedToSubmitTransaction { ref error, .. } => Some(&**error),
+			Self::FailedStateCall { ref error, .. } => Some(&**error),
+			Self::FailedToProveStorage { ref error, .. } => Some(&**error),
+			Self::FailedToGetSystemHealth { ref error, .. } => Some(&**error),
+			Self::FailedToSubscribeBestHeaders { ref error, .. } => Some(&**error),
+			Self::FailedToSubscribeFinalizedHeaders { ref error, .. } => Some(&**error),
+			Self::FailedToSubscribeJustifications { ref error, .. } => Some(&**error),
+			_ => None,
+		}
+	}
+
+	/// Constructs `FailedToReadHeaderHashByNumber` variant.
+	pub fn failed_to_read_header_hash_by_number<C: Chain>(
+		number: BlockNumberOf<C>,
+		e: Error,
+	) -> Self {
+		Error::FailedToReadHeaderHashByNumber {
+			chain: C::NAME.into(),
+			number: format!("{number}"),
+			error: e.boxed(),
+		}
+	}
+
+	/// Constructs `FailedToReadHeaderByHash` variant.
+	pub fn failed_to_read_header_by_hash<C: Chain>(hash: HashOf<C>, e: Error) -> Self {
+		Error::FailedToReadHeaderByHash {
+			chain: C::NAME.into(),
+			hash: format!("{hash}"),
+			error: e.boxed(),
+		}
+	}
+
+	/// Constructs `FailedToReadBlockByHash` variant.
+	pub fn failed_to_read_block_by_hash<C: Chain>(hash: HashOf<C>, e: Error) -> Self {
+		Error::FailedToReadHeaderByHash {
+			chain: C::NAME.into(),
+			hash: format!("{hash}"),
+			error: e.boxed(),
+		}
+	}
+
+	/// Constructs `FailedToReadBestFinalizedHeaderHash` variant.
+	pub fn failed_to_read_best_finalized_header_hash<C: Chain>(e: Error) -> Self {
+		Error::FailedToReadBestFinalizedHeaderHash { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedToReadBestHeader` variant.
+	pub fn failed_to_read_best_header<C: Chain>(e: Error) -> Self {
+		Error::FailedToReadBestHeader { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedToReadRuntimeVersion` variant.
+	pub fn failed_to_read_runtime_version<C: Chain>(e: Error) -> Self {
+		Error::FailedToReadRuntimeVersion { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedToReadStorageValue` variant.
+	pub fn failed_to_read_storage_value<C: Chain>(
+		at: HashOf<C>,
+		key: StorageKey,
+		e: Error,
+	) -> Self {
+		Error::FailedToReadStorageValue {
+			chain: C::NAME.into(),
+			hash: format!("{at}"),
+			key,
+			error: e.boxed(),
+		}
+	}
+
+	/// Constructs `FailedToGetPendingExtrinsics` variant.
+	pub fn failed_to_get_pending_extrinsics<C: Chain>(e: Error) -> Self {
+		Error::FailedToGetPendingExtrinsics { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedToSubmitTransaction` variant.
+	pub fn failed_to_submit_transaction<C: Chain>(e: Error) -> Self {
+		Error::FailedToSubmitTransaction { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedStateCall` variant.
+	pub fn failed_state_call<C: Chain>(
+		at: HashOf<C>,
+		method: String,
+		arguments: Bytes,
+		e: Error,
+	) -> Self {
+		Error::FailedStateCall {
+			chain: C::NAME.into(),
+			hash: format!("{at}"),
+			method,
+			arguments,
+			error: e.boxed(),
+		}
+	}
+
+	/// Constructs `FailedToProveStorage` variant.
+	pub fn failed_to_prove_storage<C: Chain>(
+		at: HashOf<C>,
+		storage_keys: Vec<StorageKey>,
+		e: Error,
+	) -> Self {
+		Error::FailedToProveStorage {
+			chain: C::NAME.into(),
+			hash: format!("{at}"),
+			storage_keys,
+			error: e.boxed(),
+		}
+	}
+
+	/// Constructs `FailedToGetSystemHealth` variant.
+	pub fn failed_to_get_system_health<C: Chain>(e: Error) -> Self {
+		Error::FailedToGetSystemHealth { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedToSubscribeBestHeaders` variant.
+	pub fn failed_to_subscribe_best_headers<C: Chain>(e: Error) -> Self {
+		Error::FailedToSubscribeBestHeaders { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedToSubscribeFinalizedHeaders` variant.
+	pub fn failed_to_subscribe_finalized_headers<C: Chain>(e: Error) -> Self {
+		Error::FailedToSubscribeFinalizedHeaders { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `FailedToSubscribeJustifications` variant.
+	pub fn failed_to_subscribe_justification<C: Chain>(e: Error) -> Self {
+		Error::FailedToSubscribeJustifications { chain: C::NAME.into(), error: e.boxed() }
+	}
+
+	/// Constructs `Un`
+	pub fn unordered_finalized_headers<C: Chain>(
+		prev_number: BlockNumberOf<C>,
+		next_number: BlockNumberOf<C>,
+	) -> Self {
+		Error::UnorderedFinalizedHeaders {
+			chain: C::NAME.into(),
+			prev_number: format!("{}", prev_number),
+			next_number: format!("{}", next_number),
+		}
+	}
 }
 
 impl MaybeConnectionError for Error {
 	fn is_connection_error(&self) -> bool {
 		match *self {
-			Error::RpcError(RpcError::Transport(_)) |
-			Error::RpcError(RpcError::RestartNeeded(_)) |
+			Error::ChannelError(_) => true,
+			Error::RpcError(ref e) =>
+				matches!(*e, RpcError::Transport(_) | RpcError::RestartNeeded(_),),
 			Error::ClientNotSynced(_) => true,
-			Error::FailedToReadBestFinalizedHeaderHash { ref error, .. } =>
-				error.is_connection_error(),
-			Error::FailedToReadBestHeader { ref error, .. } => error.is_connection_error(),
-			Error::FailedToReadHeaderByHash { ref error, .. } => error.is_connection_error(),
-			Error::ErrorExecutingRuntimeCall { ref error, .. } => error.is_connection_error(),
-			Error::FailedToReadRuntimeStorageValue { ref error, .. } => error.is_connection_error(),
-			_ => false,
+			Error::UnorderedFinalizedHeaders { .. } => true,
+			_ => self.nested().map(|e| e.is_connection_error()).unwrap_or(false),
 		}
 	}
 }
diff --git a/bridges/relays/client-substrate/src/guard.rs b/bridges/relays/client-substrate/src/guard.rs
index 47454892cd039f40e92a8f25db435698360bde9b..3dbf95bff8e10de452992a0f3d42befbe058dd74 100644
--- a/bridges/relays/client-substrate/src/guard.rs
+++ b/bridges/relays/client-substrate/src/guard.rs
@@ -98,7 +98,7 @@ fn conditions_check_delay<C: Chain>() -> Duration {
 }
 
 #[async_trait]
-impl<C: Chain> Environment<C> for Client<C> {
+impl<C: Chain, Clnt: Client<C>> Environment<C> for Clnt {
 	type Error = Error;
 
 	async fn runtime_version(&mut self) -> Result<RuntimeVersion, Self::Error> {
diff --git a/bridges/relays/client-substrate/src/lib.rs b/bridges/relays/client-substrate/src/lib.rs
index d5b8d4dcced2d8b2e1883b6779905c536eec49f1..12a1c48c09c7ad59d05c0e40a578bc71f7575b35 100644
--- a/bridges/relays/client-substrate/src/lib.rs
+++ b/bridges/relays/client-substrate/src/lib.rs
@@ -21,7 +21,6 @@
 mod chain;
 mod client;
 mod error;
-mod rpc;
 mod sync_header;
 mod transaction_tracker;
 
@@ -37,14 +36,15 @@ pub use crate::{
 		AccountKeyPairOf, BlockWithJustification, CallOf, Chain, ChainWithBalances,
 		ChainWithGrandpa, ChainWithMessages, ChainWithRuntimeVersion, ChainWithTransactions,
 		ChainWithUtilityPallet, FullRuntimeUtilityPallet, MockedRuntimeUtilityPallet, Parachain,
-		RelayChain, SignParam, TransactionStatusOf, UnsignedTransaction, UtilityPallet,
+		RelayChain, SignParam, SignedBlockOf, TransactionStatusOf, UnsignedTransaction,
+		UtilityPallet,
 	},
 	client::{
-		is_ancient_block, ChainRuntimeVersion, Client, OpaqueGrandpaAuthoritiesSet,
-		SimpleRuntimeVersion, Subscription, ANCIENT_BLOCK_THRESHOLD,
+		is_ancient_block, rpc_with_caching as new, ChainRuntimeVersion, Client,
+		OpaqueGrandpaAuthoritiesSet, RpcWithCachingClient, SimpleRuntimeVersion, StreamDescription,
+		Subscription, ANCIENT_BLOCK_THRESHOLD,
 	},
 	error::{Error, Result},
-	rpc::{SubstrateBeefyFinalityClient, SubstrateFinalityClient, SubstrateGrandpaFinalityClient},
 	sync_header::SyncHeader,
 	transaction_tracker::TransactionTracker,
 };
diff --git a/bridges/relays/client-substrate/src/metrics/float_storage_value.rs b/bridges/relays/client-substrate/src/metrics/float_storage_value.rs
index 7bb92693b38d27f42b623d323ba3e7ced8ebbda2..27c9d8cd7a8b68d4ad04ff4ab00f89f408f96a28 100644
--- a/bridges/relays/client-substrate/src/metrics/float_storage_value.rs
+++ b/bridges/relays/client-substrate/src/metrics/float_storage_value.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::{chain::Chain, client::Client, Error as SubstrateError};
+use crate::{Chain, Client, Error as SubstrateError};
 
 use async_std::sync::{Arc, RwLock};
 use async_trait::async_trait;
@@ -66,20 +66,20 @@ impl FloatStorageValue for FixedU128OrOne {
 
 /// Metric that represents fixed-point runtime storage value as float gauge.
 #[derive(Clone, Debug)]
-pub struct FloatStorageValueMetric<C: Chain, V: FloatStorageValue> {
+pub struct FloatStorageValueMetric<C, Clnt, V> {
 	value_converter: V,
-	client: Client<C>,
+	client: Clnt,
 	storage_key: StorageKey,
 	metric: Gauge<F64>,
 	shared_value_ref: F64SharedRef,
-	_phantom: PhantomData<V>,
+	_phantom: PhantomData<(C, V)>,
 }
 
-impl<C: Chain, V: FloatStorageValue> FloatStorageValueMetric<C, V> {
+impl<C, Clnt, V> FloatStorageValueMetric<C, Clnt, V> {
 	/// Create new metric.
 	pub fn new(
 		value_converter: V,
-		client: Client<C>,
+		client: Clnt,
 		storage_key: StorageKey,
 		name: String,
 		help: String,
@@ -101,32 +101,39 @@ impl<C: Chain, V: FloatStorageValue> FloatStorageValueMetric<C, V> {
 	}
 }
 
-impl<C: Chain, V: FloatStorageValue> Metric for FloatStorageValueMetric<C, V> {
+impl<C: Chain, Clnt: Client<C>, V: FloatStorageValue> Metric
+	for FloatStorageValueMetric<C, Clnt, V>
+{
 	fn register(&self, registry: &Registry) -> Result<(), PrometheusError> {
 		register(self.metric.clone(), registry).map(drop)
 	}
 }
 
 #[async_trait]
-impl<C: Chain, V: FloatStorageValue> StandaloneMetric for FloatStorageValueMetric<C, V> {
+impl<C: Chain, Clnt: Client<C>, V: FloatStorageValue> StandaloneMetric
+	for FloatStorageValueMetric<C, Clnt, V>
+{
 	fn update_interval(&self) -> Duration {
 		C::AVERAGE_BLOCK_INTERVAL * UPDATE_INTERVAL_IN_BLOCKS
 	}
 
 	async fn update(&self) {
-		let value = self
-			.client
-			.raw_storage_value(self.storage_key.clone(), None)
-			.await
-			.and_then(|maybe_storage_value| {
-				self.value_converter.decode(maybe_storage_value).map(|maybe_fixed_point_value| {
-					maybe_fixed_point_value.map(|fixed_point_value| {
-						fixed_point_value.into_inner().unique_saturated_into() as f64 /
-							V::Value::DIV.unique_saturated_into() as f64
-					})
+		let value = async move {
+			let best_header_hash = self.client.best_header_hash().await?;
+			let maybe_storage_value = self
+				.client
+				.raw_storage_value(best_header_hash, self.storage_key.clone())
+				.await?;
+			self.value_converter.decode(maybe_storage_value).map(|maybe_fixed_point_value| {
+				maybe_fixed_point_value.map(|fixed_point_value| {
+					fixed_point_value.into_inner().unique_saturated_into() as f64 /
+						V::Value::DIV.unique_saturated_into() as f64
 				})
 			})
-			.map_err(|e| e.to_string());
+		}
+		.await
+		.map_err(|e| e.to_string());
+
 		relay_utils::metrics::set_gauge_value(&self.metric, value.clone());
 		*self.shared_value_ref.write().await = value.ok().and_then(|x| x);
 	}
diff --git a/bridges/relays/client-substrate/src/transaction_tracker.rs b/bridges/relays/client-substrate/src/transaction_tracker.rs
index b181a945c2c15393daf821901b298e81214f85e3..b4801c89f51e1b1d9fd31373cdafb5b4770037cc 100644
--- a/bridges/relays/client-substrate/src/transaction_tracker.rs
+++ b/bridges/relays/client-substrate/src/transaction_tracker.rs
@@ -16,7 +16,7 @@
 
 //! Helper for tracking transaction invalidation events.
 
-use crate::{Chain, Client, Error, HashOf, HeaderIdOf, Subscription, TransactionStatusOf};
+use crate::{Chain, Error, HashOf, HeaderIdOf, Subscription, TransactionStatusOf};
 
 use async_trait::async_trait;
 use futures::{future::Either, Future, FutureExt, Stream, StreamExt};
@@ -31,8 +31,10 @@ pub trait Environment<C: Chain>: Send + Sync {
 	async fn header_id_by_hash(&self, hash: HashOf<C>) -> Result<HeaderIdOf<C>, Error>;
 }
 
+// TODO (https://github.com/paritytech/parity-bridges-common/issues/2133): remove `Environment` trait
+// after test client is implemented
 #[async_trait]
-impl<C: Chain> Environment<C> for Client<C> {
+impl<C: Chain, T: crate::client::Client<C>> Environment<C> for T {
 	async fn header_id_by_hash(&self, hash: HashOf<C>) -> Result<HeaderIdOf<C>, Error> {
 		self.header_by_hash(hash).await.map(|h| HeaderId(*h.number(), hash))
 	}
@@ -76,6 +78,21 @@ impl<C: Chain, E: Environment<C>> TransactionTracker<C, E> {
 		Self { environment, stall_timeout, transaction_hash, subscription }
 	}
 
+	// TODO (https://github.com/paritytech/parity-bridges-common/issues/2133): remove me after
+	// test client is implemented
+	/// Converts self into tracker with different environment.
+	pub fn switch_environment<NewE: Environment<C>>(
+		self,
+		environment: NewE,
+	) -> TransactionTracker<C, NewE> {
+		TransactionTracker {
+			environment,
+			stall_timeout: self.stall_timeout,
+			transaction_hash: self.transaction_hash,
+			subscription: self.subscription,
+		}
+	}
+
 	/// Wait for final transaction status and return it along with last known internal invalidation
 	/// status.
 	async fn do_wait(
@@ -88,7 +105,7 @@ impl<C: Chain, E: Environment<C>> TransactionTracker<C, E> {
 		let wait_for_invalidation = watch_transaction_status::<_, C, _>(
 			self.environment,
 			self.transaction_hash,
-			self.subscription.into_stream(),
+			self.subscription,
 		);
 		futures::pin_mut!(wait_for_stall_timeout, wait_for_invalidation);
 
@@ -284,7 +301,7 @@ async fn watch_transaction_status<
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use crate::test_chain::TestChain;
+	use crate::{test_chain::TestChain, StreamDescription};
 	use futures::{FutureExt, SinkExt};
 	use sc_transaction_pool_api::TransactionStatus;
 
@@ -306,22 +323,27 @@ mod tests {
 		TrackedTransactionStatus<HeaderIdOf<TestChain>>,
 		InvalidationStatus<HeaderIdOf<TestChain>>,
 	)> {
-		let (cancel_sender, _cancel_receiver) = futures::channel::oneshot::channel();
 		let (mut sender, receiver) = futures::channel::mpsc::channel(1);
 		let tx_tracker = TransactionTracker::<TestChain, TestEnvironment>::new(
 			TestEnvironment(Ok(HeaderId(0, Default::default()))),
 			Duration::from_secs(0),
 			Default::default(),
-			Subscription(async_std::sync::Mutex::new(receiver), cancel_sender),
+			Subscription::new_forwarded(
+				StreamDescription::new("test".into(), "test".into()),
+				receiver,
+			),
 		);
 
-		let wait_for_stall_timeout = futures::future::pending();
+		// we can't do `.now_or_never()` on `do_wait()` call, because `Subscription` has its own
+		// background thread, which may cause additional async task switches => let's leave some
+		// relatively small timeout here
+		let wait_for_stall_timeout = async_std::task::sleep(std::time::Duration::from_millis(100));
 		let wait_for_stall_timeout_rest = futures::future::ready(());
-		sender.send(Some(status)).await.unwrap();
-		tx_tracker
-			.do_wait(wait_for_stall_timeout, wait_for_stall_timeout_rest)
-			.now_or_never()
-			.map(|(ts, is)| (ts, is.unwrap()))
+		sender.send(Ok(status)).await.unwrap();
+
+		let (ts, is) =
+			tx_tracker.do_wait(wait_for_stall_timeout, wait_for_stall_timeout_rest).await;
+		is.map(|is| (ts, is))
 	}
 
 	#[async_std::test]
@@ -429,13 +451,15 @@ mod tests {
 
 	#[async_std::test]
 	async fn lost_on_timeout_when_waiting_for_invalidation_status() {
-		let (cancel_sender, _cancel_receiver) = futures::channel::oneshot::channel();
 		let (_sender, receiver) = futures::channel::mpsc::channel(1);
 		let tx_tracker = TransactionTracker::<TestChain, TestEnvironment>::new(
 			TestEnvironment(Ok(HeaderId(0, Default::default()))),
 			Duration::from_secs(0),
 			Default::default(),
-			Subscription(async_std::sync::Mutex::new(receiver), cancel_sender),
+			Subscription::new_forwarded(
+				StreamDescription::new("test".into(), "test".into()),
+				receiver,
+			),
 		);
 
 		let wait_for_stall_timeout = futures::future::ready(()).shared();
diff --git a/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs b/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs
index 6246bdbf015152fe0e82ac0a8287692df6a1ace9..d985d35c9e802e694e74264ed3f611f14e8bc0d2 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs
@@ -123,11 +123,11 @@ macro_rules! declare_chain_connection_params_cli_schema {
 				#[allow(dead_code)]
 				pub async fn into_client<Chain: ChainWithRuntimeVersion>(
 					self,
-				) -> anyhow::Result<relay_substrate_client::Client<Chain>> {
+				) -> anyhow::Result<$crate::cli::DefaultClient<Chain>> {
 					let chain_runtime_version = self
 						.[<$chain_prefix _runtime_version>]
 						.into_runtime_version(Chain::RUNTIME_VERSION)?;
-					Ok(relay_substrate_client::Client::new(relay_substrate_client::ConnectionParams {
+					Ok(relay_substrate_client::new(relay_substrate_client::ConnectionParams {
 						uri: self.[<$chain_prefix _uri>],
 						host: self.[<$chain_prefix _host>],
 						port: self.[<$chain_prefix _port>],
diff --git a/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs b/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs
index b98e41b2a43e4f88670ac8ed1d7129a0187fecfe..3921685d9e8ad70a9173a87ef19fb567c9263a63 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs
@@ -23,7 +23,7 @@ use crate::{
 };
 
 use async_trait::async_trait;
-use relay_substrate_client::ChainWithTransactions;
+use relay_substrate_client::{ChainWithTransactions, Client};
 use structopt::StructOpt;
 
 /// Start equivocation detection loop.
diff --git a/bridges/relays/lib-substrate-relay/src/cli/mod.rs b/bridges/relays/lib-substrate-relay/src/cli/mod.rs
index 270608bf6ed8e1500d10000173bd7945a31c8135..ddb3e416dc32628b5a85f27f322d0568cbee1c10 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/mod.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/mod.rs
@@ -35,6 +35,11 @@ pub mod relay_parachains;
 /// The target that will be used when publishing logs related to this pallet.
 pub const LOG_TARGET: &str = "bridge";
 
+/// Default Substrate client type that we are using. We'll use it all over the glue CLI code
+/// to avoid multiple level generic arguments and constraints. We still allow usage of other
+/// clients in the **core logic code**.
+pub type DefaultClient<C> = relay_substrate_client::RpcWithCachingClient<C>;
+
 /// Lane id.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct HexLaneId(pub [u8; 4]);
diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs
index 093f98ef21ed24b40a0c2d8f217d84b841137a69..ea92a0c9acce15a7f5000d0dd7e0253bbafc7844 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs
@@ -29,6 +29,7 @@ use crate::{
 	finality::SubstrateFinalitySyncPipeline,
 	HeadersToRelay,
 };
+use relay_substrate_client::Client;
 
 /// Chain headers relaying params.
 #[derive(StructOpt)]
diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs
index a796df6721b8c8afd7f401f92e2fca6afcb41b02..05a061c2ea606b79464908a6af46ed75af7d80ee 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs
@@ -37,7 +37,7 @@ use structopt::StructOpt;
 use futures::{FutureExt, TryFutureExt};
 
 use crate::{
-	cli::{bridge::MessagesCliBridge, HexLaneId, PrometheusParams},
+	cli::{bridge::MessagesCliBridge, DefaultClient, HexLaneId, PrometheusParams},
 	messages_lane::{MessagesRelayLimits, MessagesRelayParams},
 	on_demand::OnDemandRelay,
 	HeadersToRelay, TaggedAccount, TransactionParams,
@@ -46,7 +46,7 @@ use bp_messages::LaneId;
 use bp_runtime::BalanceOf;
 use relay_substrate_client::{
 	AccountIdOf, AccountKeyPairOf, Chain, ChainWithBalances, ChainWithMessages,
-	ChainWithRuntimeVersion, ChainWithTransactions, Client,
+	ChainWithRuntimeVersion, ChainWithTransactions,
 };
 use relay_utils::metrics::MetricsParams;
 use sp_core::Pair;
@@ -118,7 +118,7 @@ impl<
 /// Parameters that are associated with one side of the bridge.
 pub struct BridgeEndCommonParams<Chain: ChainWithTransactions + ChainWithRuntimeVersion> {
 	/// Chain client.
-	pub client: Client<Chain>,
+	pub client: DefaultClient<Chain>,
 	/// Params used for sending transactions to the chain.
 	pub tx_params: TransactionParams<AccountKeyPairOf<Chain>>,
 	/// Accounts, which balances are exposed as metrics by the relay process.
@@ -165,7 +165,7 @@ where
 		target_to_source_headers_relay: Arc<dyn OnDemandRelay<Target, Source>>,
 		lane_id: LaneId,
 		maybe_limits: Option<MessagesRelayLimits>,
-	) -> MessagesRelayParams<Bridge::MessagesLane> {
+	) -> MessagesRelayParams<Bridge::MessagesLane, DefaultClient<Source>, DefaultClient<Target>> {
 		MessagesRelayParams {
 			source_client: self.source.client.clone(),
 			source_transaction_params: self.source.tx_params.clone(),
@@ -317,28 +317,30 @@ where
 		// Need 2x capacity since we consider both directions for each lane
 		let mut message_relays = Vec::with_capacity(lanes.len() * 2);
 		for lane in lanes {
-			let left_to_right_messages = crate::messages_lane::run::<
-				<Self::L2R as MessagesCliBridge>::MessagesLane,
-			>(self.left_to_right().messages_relay_params(
-				left_to_right_on_demand_headers.clone(),
-				right_to_left_on_demand_headers.clone(),
-				lane,
-				Self::L2R::maybe_messages_limits(),
-			))
-			.map_err(|e| anyhow::format_err!("{}", e))
-			.boxed();
+			let left_to_right_messages =
+				crate::messages_lane::run::<<Self::L2R as MessagesCliBridge>::MessagesLane, _, _>(
+					self.left_to_right().messages_relay_params(
+						left_to_right_on_demand_headers.clone(),
+						right_to_left_on_demand_headers.clone(),
+						lane,
+						Self::L2R::maybe_messages_limits(),
+					),
+				)
+				.map_err(|e| anyhow::format_err!("{}", e))
+				.boxed();
 			message_relays.push(left_to_right_messages);
 
-			let right_to_left_messages = crate::messages_lane::run::<
-				<Self::R2L as MessagesCliBridge>::MessagesLane,
-			>(self.right_to_left().messages_relay_params(
-				right_to_left_on_demand_headers.clone(),
-				left_to_right_on_demand_headers.clone(),
-				lane,
-				Self::R2L::maybe_messages_limits(),
-			))
-			.map_err(|e| anyhow::format_err!("{}", e))
-			.boxed();
+			let right_to_left_messages =
+				crate::messages_lane::run::<<Self::R2L as MessagesCliBridge>::MessagesLane, _, _>(
+					self.right_to_left().messages_relay_params(
+						right_to_left_on_demand_headers.clone(),
+						left_to_right_on_demand_headers.clone(),
+						lane,
+						Self::R2L::maybe_messages_limits(),
+					),
+				)
+				.map_err(|e| anyhow::format_err!("{}", e))
+				.boxed();
 			message_relays.push(right_to_left_messages);
 		}
 
diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs
index 7f6f40777823679c97577f1244eb9a860948d267..8104be7af807a67bbc001e70e24565c81b6beb17 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs
@@ -23,6 +23,7 @@ use crate::{
 	cli::{
 		bridge::{CliBridgeBase, MessagesCliBridge, ParachainToRelayHeadersCliBridge},
 		relay_headers_and_messages::{Full2WayBridgeBase, Full2WayBridgeCommonParams},
+		DefaultClient,
 	},
 	finality::SubstrateFinalitySyncPipeline,
 	on_demand::{
@@ -52,9 +53,9 @@ pub struct ParachainToParachainBridge<
 	pub common:
 		Full2WayBridgeCommonParams<<R2L as CliBridgeBase>::Target, <L2R as CliBridgeBase>::Target>,
 	/// Client of the left relay chain.
-	pub left_relay: Client<<L2R as ParachainToRelayHeadersCliBridge>::SourceRelay>,
+	pub left_relay: DefaultClient<<L2R as ParachainToRelayHeadersCliBridge>::SourceRelay>,
 	/// Client of the right relay chain.
-	pub right_relay: Client<<R2L as ParachainToRelayHeadersCliBridge>::SourceRelay>,
+	pub right_relay: DefaultClient<<R2L as ParachainToRelayHeadersCliBridge>::SourceRelay>,
 }
 
 /// Create set of configuration objects specific to parachain-to-parachain relayer.
@@ -175,25 +176,33 @@ where
 		)
 		.await?;
 
-		let left_relay_to_right_on_demand_headers =
-			OnDemandHeadersRelay::<<L2R as ParachainToRelayHeadersCliBridge>::RelayFinality>::new(
-				self.left_relay.clone(),
-				self.common.right.client.clone(),
-				self.common.right.tx_params.clone(),
-				self.common.shared.headers_to_relay(),
-				Some(self.common.metrics_params.clone()),
-			);
-		let right_relay_to_left_on_demand_headers =
-			OnDemandHeadersRelay::<<R2L as ParachainToRelayHeadersCliBridge>::RelayFinality>::new(
-				self.right_relay.clone(),
-				self.common.left.client.clone(),
-				self.common.left.tx_params.clone(),
-				self.common.shared.headers_to_relay(),
-				Some(self.common.metrics_params.clone()),
-			);
+		let left_relay_to_right_on_demand_headers = OnDemandHeadersRelay::<
+			<L2R as ParachainToRelayHeadersCliBridge>::RelayFinality,
+			_,
+			_,
+		>::new(
+			self.left_relay.clone(),
+			self.common.right.client.clone(),
+			self.common.right.tx_params.clone(),
+			self.common.shared.headers_to_relay(),
+			Some(self.common.metrics_params.clone()),
+		);
+		let right_relay_to_left_on_demand_headers = OnDemandHeadersRelay::<
+			<R2L as ParachainToRelayHeadersCliBridge>::RelayFinality,
+			_,
+			_,
+		>::new(
+			self.right_relay.clone(),
+			self.common.left.client.clone(),
+			self.common.left.tx_params.clone(),
+			self.common.shared.headers_to_relay(),
+			Some(self.common.metrics_params.clone()),
+		);
 
 		let left_to_right_on_demand_parachains = OnDemandParachainsRelay::<
 			<L2R as ParachainToRelayHeadersCliBridge>::ParachainFinality,
+			_,
+			_,
 		>::new(
 			self.left_relay.clone(),
 			self.common.right.client.clone(),
@@ -202,6 +211,8 @@ where
 		);
 		let right_to_left_on_demand_parachains = OnDemandParachainsRelay::<
 			<R2L as ParachainToRelayHeadersCliBridge>::ParachainFinality,
+			_,
+			_,
 		>::new(
 			self.right_relay.clone(),
 			self.common.left.client.clone(),
diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs
index 5911fe49df4adfc955cbab4d142998fbc7ed4d22..6c078973fedc08a724e51808f2cb47f3a64ca1a1 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs
@@ -26,6 +26,7 @@ use crate::{
 			RelayToRelayHeadersCliBridge,
 		},
 		relay_headers_and_messages::{Full2WayBridgeBase, Full2WayBridgeCommonParams},
+		DefaultClient,
 	},
 	finality::SubstrateFinalitySyncPipeline,
 	on_demand::{
@@ -54,7 +55,7 @@ pub struct RelayToParachainBridge<
 	pub common:
 		Full2WayBridgeCommonParams<<R2L as CliBridgeBase>::Target, <L2R as CliBridgeBase>::Target>,
 	/// Client of the right relay chain.
-	pub right_relay: Client<<R2L as ParachainToRelayHeadersCliBridge>::SourceRelay>,
+	pub right_relay: DefaultClient<<R2L as ParachainToRelayHeadersCliBridge>::SourceRelay>,
 }
 
 /// Create set of configuration objects specific to relay-to-parachain relayer.
@@ -167,23 +168,28 @@ where
 		.await?;
 
 		let left_to_right_on_demand_headers =
-			OnDemandHeadersRelay::<<L2R as RelayToRelayHeadersCliBridge>::Finality>::new(
+			OnDemandHeadersRelay::<<L2R as RelayToRelayHeadersCliBridge>::Finality, _, _>::new(
 				self.common.left.client.clone(),
 				self.common.right.client.clone(),
 				self.common.right.tx_params.clone(),
 				self.common.shared.headers_to_relay(),
 				None,
 			);
-		let right_relay_to_left_on_demand_headers =
-			OnDemandHeadersRelay::<<R2L as ParachainToRelayHeadersCliBridge>::RelayFinality>::new(
-				self.right_relay.clone(),
-				self.common.left.client.clone(),
-				self.common.left.tx_params.clone(),
-				self.common.shared.headers_to_relay(),
-				Some(self.common.metrics_params.clone()),
-			);
+		let right_relay_to_left_on_demand_headers = OnDemandHeadersRelay::<
+			<R2L as ParachainToRelayHeadersCliBridge>::RelayFinality,
+			_,
+			_,
+		>::new(
+			self.right_relay.clone(),
+			self.common.left.client.clone(),
+			self.common.left.tx_params.clone(),
+			self.common.shared.headers_to_relay(),
+			Some(self.common.metrics_params.clone()),
+		);
 		let right_to_left_on_demand_parachains = OnDemandParachainsRelay::<
 			<R2L as ParachainToRelayHeadersCliBridge>::ParachainFinality,
+			_,
+			_,
 		>::new(
 			self.right_relay.clone(),
 			self.common.left.client.clone(),
diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs
index 832df4ae4003ced1715d7b9d495989d9163417d5..3f8c8bb40c99c7218cdc69a2524ec5dd113e621f 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs
@@ -32,7 +32,7 @@ use crate::{
 	on_demand::{headers::OnDemandHeadersRelay, OnDemandRelay},
 };
 use relay_substrate_client::{
-	AccountIdOf, AccountKeyPairOf, ChainWithRuntimeVersion, ChainWithTransactions,
+	AccountIdOf, AccountKeyPairOf, ChainWithRuntimeVersion, ChainWithTransactions, Client,
 };
 use sp_core::Pair;
 
@@ -148,7 +148,7 @@ where
 		.await?;
 
 		let left_to_right_on_demand_headers =
-			OnDemandHeadersRelay::<<L2R as RelayToRelayHeadersCliBridge>::Finality>::new(
+			OnDemandHeadersRelay::<<L2R as RelayToRelayHeadersCliBridge>::Finality, _, _>::new(
 				self.common.left.client.clone(),
 				self.common.right.client.clone(),
 				self.common.right.tx_params.clone(),
@@ -156,7 +156,7 @@ where
 				None,
 			);
 		let right_to_left_on_demand_headers =
-			OnDemandHeadersRelay::<<R2L as RelayToRelayHeadersCliBridge>::Finality>::new(
+			OnDemandHeadersRelay::<<R2L as RelayToRelayHeadersCliBridge>::Finality, _, _>::new(
 				self.common.right.client.clone(),
 				self.common.left.client.clone(),
 				self.common.left.tx_params.clone(),
diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs
index e5b07b241581e07d0a2b4c839f3dc6accf7bb523..a17ae7c0c01f9b828d8a534da8143a1d983892c2 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs
@@ -29,7 +29,8 @@ use structopt::StructOpt;
 use bp_messages::MessageNonce;
 use bp_runtime::HeaderIdProvider;
 use relay_substrate_client::{
-	AccountIdOf, AccountKeyPairOf, BalanceOf, Chain, ChainWithRuntimeVersion, ChainWithTransactions,
+	AccountIdOf, AccountKeyPairOf, BalanceOf, Chain, ChainWithRuntimeVersion,
+	ChainWithTransactions, Client,
 };
 use relay_utils::UniqueSaturatedInto;
 
@@ -80,6 +81,24 @@ pub struct RelayMessagesRangeParams {
 	target_sign: TargetSigningParams,
 }
 
+/// Messages delivery confirmation relaying params.
+#[derive(StructOpt)]
+pub struct RelayMessagesDeliveryConfirmationParams {
+	/// Number of the target chain header that we will use to prepare a messages
+	/// delivery proof. This header must be previously proved to the source chain.
+	#[structopt(long)]
+	at_target_block: u128,
+	/// Hex-encoded lane id that should be served by the relay. Defaults to `00000000`.
+	#[structopt(long, default_value = "00000000")]
+	lane: HexLaneId,
+	#[structopt(flatten)]
+	source: SourceConnectionParams,
+	#[structopt(flatten)]
+	source_sign: SourceSigningParams,
+	#[structopt(flatten)]
+	target: TargetConnectionParams,
+}
+
 /// Trait used for relaying messages between 2 chains.
 #[async_trait]
 pub trait MessagesRelayer: MessagesCliBridge
@@ -98,7 +117,7 @@ where
 		let target_sign = data.target_sign.to_keypair::<Self::Target>()?;
 		let target_transactions_mortality = data.target_sign.transactions_mortality()?;
 
-		crate::messages_lane::run::<Self::MessagesLane>(MessagesRelayParams {
+		crate::messages_lane::run::<Self::MessagesLane, _, _>(MessagesRelayParams {
 			source_client,
 			source_transaction_params: TransactionParams {
 				signer: source_sign,
@@ -154,4 +173,37 @@ where
 		)
 		.await
 	}
+
+	/// Relay a messages delivery confirmation.
+	async fn relay_messages_delivery_confirmation(
+		data: RelayMessagesDeliveryConfirmationParams,
+	) -> anyhow::Result<()> {
+		let source_client = data.source.into_client::<Self::Source>().await?;
+		let target_client = data.target.into_client::<Self::Target>().await?;
+		let source_sign = data.source_sign.to_keypair::<Self::Source>()?;
+		let source_transactions_mortality = data.source_sign.transactions_mortality()?;
+
+		let at_target_block = target_client
+			.header_by_number(data.at_target_block.unique_saturated_into())
+			.await
+			.map_err(|e| {
+				log::trace!(
+					target: "bridge",
+					"Failed to read {} header with number {}: {e:?}",
+					Self::Target::NAME,
+					data.at_target_block,
+				);
+				anyhow::format_err!("The command has failed")
+			})?
+			.id();
+
+		crate::messages_lane::relay_messages_delivery_confirmation::<Self::MessagesLane>(
+			source_client,
+			target_client,
+			TransactionParams { signer: source_sign, mortality: source_transactions_mortality },
+			at_target_block,
+			data.lane.into(),
+		)
+		.await
+	}
 }
diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs
index 00f8cf79ef1fb54577954cf198e7296819591a43..77cd395ff7225e9a0d088cc35cf0f86ab78caf46 100644
--- a/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs
+++ b/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs
@@ -21,7 +21,7 @@ use async_trait::async_trait;
 use bp_polkadot_core::BlockNumber as RelayBlockNumber;
 use bp_runtime::HeaderIdProvider;
 use parachains_relay::parachains_loop::{AvailableHeader, SourceClient, TargetClient};
-use relay_substrate_client::Parachain;
+use relay_substrate_client::{Client, Parachain};
 use relay_utils::metrics::{GlobalMetrics, StandaloneMetric};
 use std::sync::Arc;
 use structopt::StructOpt;
@@ -30,7 +30,7 @@ use crate::{
 	cli::{
 		bridge::{CliBridgeBase, ParachainToRelayHeadersCliBridge},
 		chain_schema::*,
-		PrometheusParams,
+		DefaultClient, PrometheusParams,
 	},
 	parachains::{source::ParachainsSource, target::ParachainsTarget, ParachainsPipelineAdapter},
 	TransactionParams,
@@ -72,16 +72,19 @@ pub struct RelayParachainHeadParams {
 #[async_trait]
 pub trait ParachainsRelayer: ParachainToRelayHeadersCliBridge
 where
-	ParachainsSource<Self::ParachainFinality>:
+	ParachainsSource<Self::ParachainFinality, DefaultClient<Self::SourceRelay>>:
 		SourceClient<ParachainsPipelineAdapter<Self::ParachainFinality>>,
-	ParachainsTarget<Self::ParachainFinality>:
-		TargetClient<ParachainsPipelineAdapter<Self::ParachainFinality>>,
+	ParachainsTarget<
+		Self::ParachainFinality,
+		DefaultClient<Self::SourceRelay>,
+		DefaultClient<Self::Target>,
+	>: TargetClient<ParachainsPipelineAdapter<Self::ParachainFinality>>,
 	<Self as CliBridgeBase>::Source: Parachain,
 {
 	/// Start relaying parachains finality.
 	async fn relay_parachains(data: RelayParachainsParams) -> anyhow::Result<()> {
 		let source_chain_client = data.source.into_client::<Self::SourceRelay>().await?;
-		let source_client = ParachainsSource::<Self::ParachainFinality>::new(
+		let source_client = ParachainsSource::<Self::ParachainFinality, _>::new(
 			source_chain_client.clone(),
 			Arc::new(Mutex::new(AvailableHeader::Missing)),
 		);
@@ -91,7 +94,7 @@ where
 			mortality: data.target_sign.target_transactions_mortality,
 		};
 		let target_chain_client = data.target.into_client::<Self::Target>().await?;
-		let target_client = ParachainsTarget::<Self::ParachainFinality>::new(
+		let target_client = ParachainsTarget::<Self::ParachainFinality, _, _>::new(
 			source_chain_client,
 			target_chain_client,
 			target_transaction_params,
@@ -121,7 +124,7 @@ where
 			.map_err(|e| anyhow::format_err!("{}", e))?
 			.id();
 
-		let source_client = ParachainsSource::<Self::ParachainFinality>::new(
+		let source_client = ParachainsSource::<Self::ParachainFinality, _>::new(
 			source_chain_client.clone(),
 			Arc::new(Mutex::new(AvailableHeader::Missing)),
 		);
@@ -131,7 +134,7 @@ where
 			mortality: data.target_sign.target_transactions_mortality,
 		};
 		let target_chain_client = data.target.into_client::<Self::Target>().await?;
-		let target_client = ParachainsTarget::<Self::ParachainFinality>::new(
+		let target_client = ParachainsTarget::<Self::ParachainFinality, _, _>::new(
 			source_chain_client,
 			target_chain_client,
 			target_transaction_params,
diff --git a/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs b/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs
index f6d58cbaa4ab4c4d7f489de5a80ab226b3b475b4..f8077923b82023cc640ddcf131f248ef141853a0 100644
--- a/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs
+++ b/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs
@@ -69,7 +69,7 @@ pub trait SubstrateEquivocationDetectionPipeline:
 
 	/// Add relay guards if required.
 	async fn start_relay_guards(
-		source_client: &Client<Self::SourceChain>,
+		source_client: &impl Client<Self::SourceChain>,
 		enable_version_guard: bool,
 	) -> relay_substrate_client::Result<()> {
 		if enable_version_guard {
@@ -199,8 +199,8 @@ macro_rules! generate_report_equivocation_call_builder {
 
 /// Run Substrate-to-Substrate equivocations detection loop.
 pub async fn run<P: SubstrateEquivocationDetectionPipeline>(
-	source_client: Client<P::SourceChain>,
-	target_client: Client<P::TargetChain>,
+	source_client: impl Client<P::SourceChain>,
+	target_client: impl Client<P::TargetChain>,
 	source_transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
 	metrics_params: MetricsParams,
 ) -> anyhow::Result<()> {
@@ -212,8 +212,8 @@ pub async fn run<P: SubstrateEquivocationDetectionPipeline>(
 	);
 
 	equivocation_detector::run(
-		SubstrateEquivocationSource::<P>::new(source_client, source_transaction_params),
-		SubstrateEquivocationTarget::<P>::new(target_client),
+		SubstrateEquivocationSource::<P, _>::new(source_client, source_transaction_params),
+		SubstrateEquivocationTarget::<P, _>::new(target_client),
 		P::TargetChain::AVERAGE_BLOCK_INTERVAL,
 		metrics_params,
 		futures::future::pending(),
diff --git a/bridges/relays/lib-substrate-relay/src/equivocation/source.rs b/bridges/relays/lib-substrate-relay/src/equivocation/source.rs
index a0c7dcf5cbc32c7e5a39de5acd53d92def24a22f..66d651600a1ec72943cb4d13c3e094c5be0a33e3 100644
--- a/bridges/relays/lib-substrate-relay/src/equivocation/source.rs
+++ b/bridges/relays/lib-substrate-relay/src/equivocation/source.rs
@@ -35,29 +35,35 @@ use relay_substrate_client::{
 use relay_utils::relay_loop::Client as RelayClient;
 
 /// Substrate node as equivocation source.
-pub struct SubstrateEquivocationSource<P: SubstrateEquivocationDetectionPipeline> {
-	client: Client<P::SourceChain>,
+pub struct SubstrateEquivocationSource<P: SubstrateEquivocationDetectionPipeline, SourceClnt> {
+	client: SourceClnt,
 	transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
 }
 
-impl<P: SubstrateEquivocationDetectionPipeline> SubstrateEquivocationSource<P> {
+impl<P: SubstrateEquivocationDetectionPipeline, SourceClnt: Client<P::SourceChain>>
+	SubstrateEquivocationSource<P, SourceClnt>
+{
 	/// Create new instance of `SubstrateEquivocationSource`.
 	pub fn new(
-		client: Client<P::SourceChain>,
+		client: SourceClnt,
 		transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
 	) -> Self {
 		Self { client, transaction_params }
 	}
 }
 
-impl<P: SubstrateEquivocationDetectionPipeline> Clone for SubstrateEquivocationSource<P> {
+impl<P: SubstrateEquivocationDetectionPipeline, SourceClnt: Client<P::SourceChain>> Clone
+	for SubstrateEquivocationSource<P, SourceClnt>
+{
 	fn clone(&self) -> Self {
 		Self { client: self.client.clone(), transaction_params: self.transaction_params.clone() }
 	}
 }
 
 #[async_trait]
-impl<P: SubstrateEquivocationDetectionPipeline> RelayClient for SubstrateEquivocationSource<P> {
+impl<P: SubstrateEquivocationDetectionPipeline, SourceClnt: Client<P::SourceChain>> RelayClient
+	for SubstrateEquivocationSource<P, SourceClnt>
+{
 	type Error = Error;
 
 	async fn reconnect(&mut self) -> Result<(), Error> {
@@ -66,8 +72,9 @@ impl<P: SubstrateEquivocationDetectionPipeline> RelayClient for SubstrateEquivoc
 }
 
 #[async_trait]
-impl<P: SubstrateEquivocationDetectionPipeline>
-	SourceClientBase<EquivocationDetectionPipelineAdapter<P>> for SubstrateEquivocationSource<P>
+impl<P: SubstrateEquivocationDetectionPipeline, SourceClnt: Client<P::SourceChain>>
+	SourceClientBase<EquivocationDetectionPipelineAdapter<P>>
+	for SubstrateEquivocationSource<P, SourceClnt>
 {
 	type FinalityProofsStream = SubstrateFinalityProofsStream<P>;
 
@@ -77,10 +84,11 @@ impl<P: SubstrateEquivocationDetectionPipeline>
 }
 
 #[async_trait]
-impl<P: SubstrateEquivocationDetectionPipeline>
-	SourceClient<EquivocationDetectionPipelineAdapter<P>> for SubstrateEquivocationSource<P>
+impl<P: SubstrateEquivocationDetectionPipeline, SourceClnt: Client<P::SourceChain>>
+	SourceClient<EquivocationDetectionPipelineAdapter<P>>
+	for SubstrateEquivocationSource<P, SourceClnt>
 {
-	type TransactionTracker = TransactionTracker<P::SourceChain, Client<P::SourceChain>>;
+	type TransactionTracker = TransactionTracker<P::SourceChain, SourceClnt>;
 
 	async fn report_equivocation(
 		&self,
diff --git a/bridges/relays/lib-substrate-relay/src/equivocation/target.rs b/bridges/relays/lib-substrate-relay/src/equivocation/target.rs
index 6eee2ab91d45b033a77e30b7d05ae28b246b9735..7d054e843d0db6c09b5baec551c46bb9fbe0fc34 100644
--- a/bridges/relays/lib-substrate-relay/src/equivocation/target.rs
+++ b/bridges/relays/lib-substrate-relay/src/equivocation/target.rs
@@ -34,27 +34,33 @@ use sp_runtime::traits::Header;
 use std::marker::PhantomData;
 
 /// Substrate node as equivocation source.
-pub struct SubstrateEquivocationTarget<P: SubstrateEquivocationDetectionPipeline> {
-	client: Client<P::TargetChain>,
+pub struct SubstrateEquivocationTarget<P: SubstrateEquivocationDetectionPipeline, TargetClnt> {
+	client: TargetClnt,
 
 	_phantom: PhantomData<P>,
 }
 
-impl<P: SubstrateEquivocationDetectionPipeline> SubstrateEquivocationTarget<P> {
+impl<P: SubstrateEquivocationDetectionPipeline, TargetClnt: Client<P::TargetChain>>
+	SubstrateEquivocationTarget<P, TargetClnt>
+{
 	/// Create new instance of `SubstrateEquivocationTarget`.
-	pub fn new(client: Client<P::TargetChain>) -> Self {
+	pub fn new(client: TargetClnt) -> Self {
 		Self { client, _phantom: Default::default() }
 	}
 }
 
-impl<P: SubstrateEquivocationDetectionPipeline> Clone for SubstrateEquivocationTarget<P> {
+impl<P: SubstrateEquivocationDetectionPipeline, TargetClnt: Client<P::TargetChain>> Clone
+	for SubstrateEquivocationTarget<P, TargetClnt>
+{
 	fn clone(&self) -> Self {
 		Self { client: self.client.clone(), _phantom: Default::default() }
 	}
 }
 
 #[async_trait]
-impl<P: SubstrateEquivocationDetectionPipeline> RelayClient for SubstrateEquivocationTarget<P> {
+impl<P: SubstrateEquivocationDetectionPipeline, TargetClnt: Client<P::TargetChain>> RelayClient
+	for SubstrateEquivocationTarget<P, TargetClnt>
+{
 	type Error = Error;
 
 	async fn reconnect(&mut self) -> Result<(), Error> {
@@ -63,8 +69,9 @@ impl<P: SubstrateEquivocationDetectionPipeline> RelayClient for SubstrateEquivoc
 }
 
 #[async_trait]
-impl<P: SubstrateEquivocationDetectionPipeline>
-	TargetClient<EquivocationDetectionPipelineAdapter<P>> for SubstrateEquivocationTarget<P>
+impl<P: SubstrateEquivocationDetectionPipeline, TargetClnt: Client<P::TargetChain>>
+	TargetClient<EquivocationDetectionPipelineAdapter<P>>
+	for SubstrateEquivocationTarget<P, TargetClnt>
 {
 	async fn best_finalized_header_number(
 		&self,
diff --git a/bridges/relays/lib-substrate-relay/src/finality/initialize.rs b/bridges/relays/lib-substrate-relay/src/finality/initialize.rs
index 5dde46c39dd674e7c01eebba4b014bc999611eb5..a972f743e117ce280fb2dd5a950581713766a3b6 100644
--- a/bridges/relays/lib-substrate-relay/src/finality/initialize.rs
+++ b/bridges/relays/lib-substrate-relay/src/finality/initialize.rs
@@ -39,8 +39,8 @@ pub async fn initialize<
 	TargetChain: ChainWithTransactions,
 	F,
 >(
-	source_client: Client<SourceChain>,
-	target_client: Client<TargetChain>,
+	source_client: impl Client<SourceChain>,
+	target_client: impl Client<TargetChain>,
 	target_signer: AccountKeyPairOf<TargetChain>,
 	prepare_initialize_transaction: F,
 	dry_run: bool,
@@ -101,8 +101,8 @@ async fn do_initialize<
 	TargetChain: ChainWithTransactions,
 	F,
 >(
-	source_client: Client<SourceChain>,
-	target_client: Client<TargetChain>,
+	source_client: impl Client<SourceChain>,
+	target_client: impl Client<TargetChain>,
 	target_signer: AccountKeyPairOf<TargetChain>,
 	prepare_initialize_transaction: F,
 	dry_run: bool,
diff --git a/bridges/relays/lib-substrate-relay/src/finality/mod.rs b/bridges/relays/lib-substrate-relay/src/finality/mod.rs
index 0293e1da224a6323fed59f7f727b5d5263391bb8..a2379eb4812e2ab7d904eff0ce9b082ac474d36e 100644
--- a/bridges/relays/lib-substrate-relay/src/finality/mod.rs
+++ b/bridges/relays/lib-substrate-relay/src/finality/mod.rs
@@ -77,7 +77,7 @@ pub trait SubstrateFinalitySyncPipeline: BaseSubstrateFinalitySyncPipeline {
 
 	/// Add relay guards if required.
 	async fn start_relay_guards(
-		target_client: &Client<Self::TargetChain>,
+		target_client: &impl Client<Self::TargetChain>,
 		enable_version_guard: bool,
 	) -> relay_substrate_client::Result<()> {
 		if enable_version_guard {
@@ -240,8 +240,8 @@ macro_rules! generate_submit_finality_proof_ex_call_builder {
 
 /// Run Substrate-to-Substrate finality sync loop.
 pub async fn run<P: SubstrateFinalitySyncPipeline>(
-	source_client: Client<P::SourceChain>,
-	target_client: Client<P::TargetChain>,
+	source_client: impl Client<P::SourceChain>,
+	target_client: impl Client<P::TargetChain>,
 	headers_to_relay: HeadersToRelay,
 	transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	metrics_params: MetricsParams,
@@ -255,8 +255,8 @@ pub async fn run<P: SubstrateFinalitySyncPipeline>(
 	);
 
 	finality_relay::run(
-		SubstrateFinalitySource::<P>::new(source_client, None),
-		SubstrateFinalityTarget::<P>::new(target_client, transaction_params.clone()),
+		SubstrateFinalitySource::<P, _>::new(source_client, None),
+		SubstrateFinalityTarget::<P, _>::new(target_client, transaction_params.clone()),
 		finality_relay::FinalitySyncParams {
 			tick: std::cmp::max(
 				P::SourceChain::AVERAGE_BLOCK_INTERVAL,
@@ -279,12 +279,12 @@ pub async fn run<P: SubstrateFinalitySyncPipeline>(
 
 /// Relay single header. No checks are made to ensure that transaction will succeed.
 pub async fn relay_single_header<P: SubstrateFinalitySyncPipeline>(
-	source_client: Client<P::SourceChain>,
-	target_client: Client<P::TargetChain>,
+	source_client: impl Client<P::SourceChain>,
+	target_client: impl Client<P::TargetChain>,
 	transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	header_number: BlockNumberOf<P::SourceChain>,
 ) -> anyhow::Result<()> {
-	let finality_source = SubstrateFinalitySource::<P>::new(source_client, None);
+	let finality_source = SubstrateFinalitySource::<P, _>::new(source_client, None);
 	let (header, proof) = finality_source.header_and_finality_proof(header_number).await?;
 	let Some(proof) = proof else {
 		return Err(anyhow::format_err!(
@@ -295,7 +295,7 @@ pub async fn relay_single_header<P: SubstrateFinalitySyncPipeline>(
 		));
 	};
 
-	let finality_target = SubstrateFinalityTarget::<P>::new(target_client, transaction_params);
+	let finality_target = SubstrateFinalityTarget::<P, _>::new(target_client, transaction_params);
 	let tx_tracker = finality_target.submit_finality_proof(header, proof, false).await?;
 	match tx_tracker.wait().await {
 		TrackedTransactionStatus::Finalized(_) => Ok(()),
diff --git a/bridges/relays/lib-substrate-relay/src/finality/source.rs b/bridges/relays/lib-substrate-relay/src/finality/source.rs
index c94af6108957a0d2d4b0b4079220be9c11a5a470..f6fa5c24add5066ab0c062a6966844b48be17ce8 100644
--- a/bridges/relays/lib-substrate-relay/src/finality/source.rs
+++ b/bridges/relays/lib-substrate-relay/src/finality/source.rs
@@ -40,22 +40,24 @@ use relay_utils::{relay_loop::Client as RelayClient, UniqueSaturatedInto};
 pub type RequiredHeaderNumberRef<C> = Arc<Mutex<<C as bp_runtime::Chain>::BlockNumber>>;
 
 /// Substrate node as finality source.
-pub struct SubstrateFinalitySource<P: SubstrateFinalitySyncPipeline> {
-	client: Client<P::SourceChain>,
+pub struct SubstrateFinalitySource<P: SubstrateFinalitySyncPipeline, SourceClnt> {
+	client: SourceClnt,
 	maximal_header_number: Option<RequiredHeaderNumberRef<P::SourceChain>>,
 }
 
-impl<P: SubstrateFinalitySyncPipeline> SubstrateFinalitySource<P> {
+impl<P: SubstrateFinalitySyncPipeline, SourceClnt: Client<P::SourceChain>>
+	SubstrateFinalitySource<P, SourceClnt>
+{
 	/// Create new headers source using given client.
 	pub fn new(
-		client: Client<P::SourceChain>,
+		client: SourceClnt,
 		maximal_header_number: Option<RequiredHeaderNumberRef<P::SourceChain>>,
 	) -> Self {
 		SubstrateFinalitySource { client, maximal_header_number }
 	}
 
 	/// Returns reference to the underlying RPC client.
-	pub fn client(&self) -> &Client<P::SourceChain> {
+	pub fn client(&self) -> &SourceClnt {
 		&self.client
 	}
 
@@ -174,7 +176,9 @@ impl<P: SubstrateFinalitySyncPipeline> SubstrateFinalitySource<P> {
 	}
 }
 
-impl<P: SubstrateFinalitySyncPipeline> Clone for SubstrateFinalitySource<P> {
+impl<P: SubstrateFinalitySyncPipeline, SourceClnt: Clone> Clone
+	for SubstrateFinalitySource<P, SourceClnt>
+{
 	fn clone(&self) -> Self {
 		SubstrateFinalitySource {
 			client: self.client.clone(),
@@ -184,7 +188,9 @@ impl<P: SubstrateFinalitySyncPipeline> Clone for SubstrateFinalitySource<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateFinalitySyncPipeline> RelayClient for SubstrateFinalitySource<P> {
+impl<P: SubstrateFinalitySyncPipeline, SourceClnt: Client<P::SourceChain>> RelayClient
+	for SubstrateFinalitySource<P, SourceClnt>
+{
 	type Error = Error;
 
 	async fn reconnect(&mut self) -> Result<(), Error> {
@@ -193,8 +199,8 @@ impl<P: SubstrateFinalitySyncPipeline> RelayClient for SubstrateFinalitySource<P
 }
 
 #[async_trait]
-impl<P: SubstrateFinalitySyncPipeline> SourceClientBase<FinalitySyncPipelineAdapter<P>>
-	for SubstrateFinalitySource<P>
+impl<P: SubstrateFinalitySyncPipeline, SourceClnt: Client<P::SourceChain>>
+	SourceClientBase<FinalitySyncPipelineAdapter<P>> for SubstrateFinalitySource<P, SourceClnt>
 {
 	type FinalityProofsStream = SubstrateFinalityProofsStream<P>;
 
@@ -204,8 +210,8 @@ impl<P: SubstrateFinalitySyncPipeline> SourceClientBase<FinalitySyncPipelineAdap
 }
 
 #[async_trait]
-impl<P: SubstrateFinalitySyncPipeline> SourceClient<FinalitySyncPipelineAdapter<P>>
-	for SubstrateFinalitySource<P>
+impl<P: SubstrateFinalitySyncPipeline, SourceClnt: Client<P::SourceChain>>
+	SourceClient<FinalitySyncPipelineAdapter<P>> for SubstrateFinalitySource<P, SourceClnt>
 {
 	async fn best_finalized_block_number(&self) -> Result<BlockNumberOf<P::SourceChain>, Error> {
 		let mut finalized_header_number = self.on_chain_best_finalized_block_number().await?;
@@ -235,7 +241,7 @@ impl<P: SubstrateFinalitySyncPipeline> SourceClient<FinalitySyncPipelineAdapter<
 }
 
 async fn header_and_finality_proof<P: SubstrateFinalitySyncPipeline>(
-	client: &Client<P::SourceChain>,
+	client: &impl Client<P::SourceChain>,
 	number: BlockNumberOf<P::SourceChain>,
 ) -> Result<
 	(
@@ -244,8 +250,8 @@ async fn header_and_finality_proof<P: SubstrateFinalitySyncPipeline>(
 	),
 	Error,
 > {
-	let header_hash = client.block_hash_by_number(number).await?;
-	let signed_block = client.get_block(Some(header_hash)).await?;
+	let header_hash = client.header_hash_by_number(number).await?;
+	let signed_block = client.block_by_hash(header_hash).await?;
 
 	let justification = signed_block
 		.justification(P::FinalityEngine::ID)
diff --git a/bridges/relays/lib-substrate-relay/src/finality/target.rs b/bridges/relays/lib-substrate-relay/src/finality/target.rs
index 0874fa53549c59f413a2f3f0c4f3dbc582fe0090..18b696685dd4e7122a7ff6a9f7d7cb2afd333f5f 100644
--- a/bridges/relays/lib-substrate-relay/src/finality/target.rs
+++ b/bridges/relays/lib-substrate-relay/src/finality/target.rs
@@ -28,22 +28,25 @@ use async_trait::async_trait;
 use bp_runtime::BlockNumberOf;
 use finality_relay::TargetClient;
 use relay_substrate_client::{
-	AccountKeyPairOf, Chain, Client, Error, HeaderIdOf, HeaderOf, SyncHeader, TransactionEra,
-	TransactionTracker, UnsignedTransaction,
+	AccountIdOf, AccountKeyPairOf, Chain, Client, Error, HeaderIdOf, HeaderOf, SyncHeader,
+	TransactionEra, TransactionTracker, UnsignedTransaction,
 };
 use relay_utils::relay_loop::Client as RelayClient;
+use sp_core::Pair;
 use sp_runtime::traits::Header;
 
 /// Substrate client as Substrate finality target.
-pub struct SubstrateFinalityTarget<P: SubstrateFinalitySyncPipeline> {
-	client: Client<P::TargetChain>,
+pub struct SubstrateFinalityTarget<P: SubstrateFinalitySyncPipeline, TargetClnt> {
+	client: TargetClnt,
 	transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 }
 
-impl<P: SubstrateFinalitySyncPipeline> SubstrateFinalityTarget<P> {
+impl<P: SubstrateFinalitySyncPipeline, TargetClnt: Client<P::TargetChain>>
+	SubstrateFinalityTarget<P, TargetClnt>
+{
 	/// Create new Substrate headers target.
 	pub fn new(
-		client: Client<P::TargetChain>,
+		client: TargetClnt,
 		transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	) -> Self {
 		SubstrateFinalityTarget { client, transaction_params }
@@ -65,7 +68,9 @@ impl<P: SubstrateFinalitySyncPipeline> SubstrateFinalityTarget<P> {
 	}
 }
 
-impl<P: SubstrateFinalitySyncPipeline> Clone for SubstrateFinalityTarget<P> {
+impl<P: SubstrateFinalitySyncPipeline, TargetClnt: Clone> Clone
+	for SubstrateFinalityTarget<P, TargetClnt>
+{
 	fn clone(&self) -> Self {
 		SubstrateFinalityTarget {
 			client: self.client.clone(),
@@ -75,7 +80,9 @@ impl<P: SubstrateFinalitySyncPipeline> Clone for SubstrateFinalityTarget<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateFinalitySyncPipeline> RelayClient for SubstrateFinalityTarget<P> {
+impl<P: SubstrateFinalitySyncPipeline, TargetClnt: Client<P::TargetChain>> RelayClient
+	for SubstrateFinalityTarget<P, TargetClnt>
+{
 	type Error = Error;
 
 	async fn reconnect(&mut self) -> Result<(), Error> {
@@ -84,10 +91,12 @@ impl<P: SubstrateFinalitySyncPipeline> RelayClient for SubstrateFinalityTarget<P
 }
 
 #[async_trait]
-impl<P: SubstrateFinalitySyncPipeline> TargetClient<FinalitySyncPipelineAdapter<P>>
-	for SubstrateFinalityTarget<P>
+impl<P: SubstrateFinalitySyncPipeline, TargetClnt: Client<P::TargetChain>>
+	TargetClient<FinalitySyncPipelineAdapter<P>> for SubstrateFinalityTarget<P, TargetClnt>
+where
+	AccountIdOf<P::TargetChain>: From<<AccountKeyPairOf<P::TargetChain> as Pair>::Public>,
 {
-	type TransactionTracker = TransactionTracker<P::TargetChain, Client<P::TargetChain>>;
+	type TransactionTracker = TransactionTracker<P::TargetChain, TargetClnt>;
 
 	async fn best_finalized_source_block_id(&self) -> Result<HeaderIdOf<P::SourceChain>, Error> {
 		// we can't continue to relay finality if target node is out of sync, because
@@ -109,10 +118,10 @@ impl<P: SubstrateFinalitySyncPipeline> TargetClient<FinalitySyncPipelineAdapter<
 	) -> Result<Option<BlockNumberOf<P::SourceChain>>, Self::Error> {
 		Ok(self
 			.client
-			.typed_state_call(
+			.state_call(
+				self.client.best_header().await?.hash(),
 				P::SourceChain::FREE_HEADERS_INTERVAL_METHOD.into(),
 				(),
-				Some(self.client.best_header().await?.hash()),
 			)
 			.await
 			.unwrap_or_else(|e| {
@@ -137,6 +146,16 @@ impl<P: SubstrateFinalitySyncPipeline> TargetClient<FinalitySyncPipelineAdapter<
 		let context =
 			P::FinalityEngine::verify_and_optimize_proof(&self.client, &header, &mut proof).await?;
 
+		// if free execution is expected, but the call size/weight exceeds hardcoded limits, the
+		// runtime may still accept the proof, but it may have some cost for relayer. Let's check
+		// it here to avoid losing relayer funds
+		if is_free_execution_expected {
+			let extras = P::FinalityEngine::check_max_expected_call_limits(&header, &proof);
+			if extras.is_weight_limit_exceeded || extras.extra_size != 0 {
+				return Err(Error::FinalityProofWeightLimitExceeded { extras })
+			}
+		}
+
 		// now we may submit optimized finality proof
 		let mortality = self.transaction_params.mortality;
 		let call = P::SubmitFinalityProofCallBuilder::build_submit_finality_proof_call(
diff --git a/bridges/relays/lib-substrate-relay/src/finality_base/engine.rs b/bridges/relays/lib-substrate-relay/src/finality_base/engine.rs
index e517b0fd9b9abd50d6445e7222ef24ed946554bf..4f15d68771940812d8a2f05c5656440100033dab 100644
--- a/bridges/relays/lib-substrate-relay/src/finality_base/engine.rs
+++ b/bridges/relays/lib-substrate-relay/src/finality_base/engine.rs
@@ -23,35 +23,22 @@ use bp_header_chain::{
 		verify_and_optimize_justification, GrandpaEquivocationsFinder, GrandpaJustification,
 		JustificationVerificationContext,
 	},
-	max_expected_submit_finality_proof_arguments_size, AuthoritySet, ConsensusLogReader,
-	FinalityProof, FindEquivocations, GrandpaConsensusLogReader, HeaderFinalityInfo,
-	HeaderGrandpaInfo, StoredHeaderGrandpaInfo,
+	AuthoritySet, ConsensusLogReader, FinalityProof, FindEquivocations, GrandpaConsensusLogReader,
+	HeaderFinalityInfo, HeaderGrandpaInfo, StoredHeaderGrandpaInfo, SubmitFinalityProofCallExtras,
 };
 use bp_runtime::{BasicOperatingMode, HeaderIdProvider, OperatingMode};
 use codec::{Decode, Encode};
+use futures::stream::StreamExt;
 use num_traits::{One, Zero};
 use relay_substrate_client::{
 	BlockNumberOf, Chain, ChainWithGrandpa, Client, Error as SubstrateError, HashOf, HeaderOf,
-	Subscription, SubstrateFinalityClient, SubstrateGrandpaFinalityClient,
+	Subscription,
 };
 use sp_consensus_grandpa::{AuthorityList as GrandpaAuthoritiesSet, GRANDPA_ENGINE_ID};
 use sp_core::{storage::StorageKey, Bytes};
-use sp_runtime::{scale_info::TypeInfo, traits::Header, ConsensusEngineId, SaturatedConversion};
+use sp_runtime::{scale_info::TypeInfo, traits::Header, ConsensusEngineId};
 use std::{fmt::Debug, marker::PhantomData};
 
-/// Result of checking maximal expected call size.
-pub enum MaxExpectedCallSizeCheck {
-	/// Size is ok and call will be refunded.
-	Ok,
-	/// The call size exceeds the maximal expected and relayer will only get partial refund.
-	Exceeds {
-		/// Actual call size.
-		call_size: u32,
-		/// Maximal expected call size.
-		max_call_size: u32,
-	},
-}
-
 /// Finality engine, used by the Substrate chain.
 #[async_trait]
 pub trait Engine<C: Chain>: Send {
@@ -59,8 +46,6 @@ pub trait Engine<C: Chain>: Send {
 	const ID: ConsensusEngineId;
 	/// A reader that can extract the consensus log from the header digest and interpret it.
 	type ConsensusLogReader: ConsensusLogReader;
-	/// Type of Finality RPC client used by this engine.
-	type FinalityClient: SubstrateFinalityClient<C>;
 	/// Type of finality proofs, used by consensus engine.
 	type FinalityProof: FinalityProof<HashOf<C>, BlockNumberOf<C>> + Decode + Encode;
 	/// The context needed for verifying finality proofs.
@@ -88,10 +73,10 @@ pub trait Engine<C: Chain>: Send {
 
 	/// Returns `Ok(true)` if finality pallet at the bridged chain has already been initialized.
 	async fn is_initialized<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 	) -> Result<bool, SubstrateError> {
 		Ok(target_client
-			.raw_storage_value(Self::is_initialized_key(), None)
+			.raw_storage_value(target_client.best_header_hash().await?, Self::is_initialized_key())
 			.await?
 			.is_some())
 	}
@@ -102,10 +87,13 @@ pub trait Engine<C: Chain>: Send {
 
 	/// Returns `Ok(true)` if finality pallet at the bridged chain is halted.
 	async fn is_halted<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 	) -> Result<bool, SubstrateError> {
 		Ok(target_client
-			.storage_value::<Self::OperatingMode>(Self::pallet_operating_mode_key(), None)
+			.storage_value::<Self::OperatingMode>(
+				target_client.best_header_hash().await?,
+				Self::pallet_operating_mode_key(),
+			)
 			.await?
 			.map(|operating_mode| operating_mode.is_halted())
 			.unwrap_or(false))
@@ -113,44 +101,41 @@ pub trait Engine<C: Chain>: Send {
 
 	/// A method to subscribe to encoded finality proofs, given source client.
 	async fn source_finality_proofs(
-		source_client: &Client<C>,
-	) -> Result<Subscription<Bytes>, SubstrateError> {
-		source_client.subscribe_finality_justifications::<Self::FinalityClient>().await
-	}
+		source_client: &impl Client<C>,
+	) -> Result<Subscription<Bytes>, SubstrateError>;
 
 	/// Verify and optimize finality proof before sending it to the target node.
 	///
 	/// Apart from optimization, we expect this method to perform all required checks
 	/// that the `header` and `proof` are valid at the current state of the target chain.
 	async fn verify_and_optimize_proof<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 		header: &C::Header,
 		proof: &mut Self::FinalityProof,
 	) -> Result<Self::FinalityVerificationContext, SubstrateError>;
 
 	/// Checks whether the given `header` and its finality `proof` fit the maximal expected
-	/// call size limit. If result is `MaxExpectedCallSizeCheck::Exceeds { .. }`, this
-	/// submission won't be fully refunded and relayer will spend its own funds on that.
-	fn check_max_expected_call_size(
+	/// call limits (size and weight).
+	fn check_max_expected_call_limits(
 		header: &C::Header,
 		proof: &Self::FinalityProof,
-	) -> MaxExpectedCallSizeCheck;
+	) -> SubmitFinalityProofCallExtras;
 
 	/// Prepare initialization data for the finality bridge pallet.
 	async fn prepare_initialization_data(
-		client: Client<C>,
+		client: impl Client<C>,
 	) -> Result<Self::InitializationData, Error<HashOf<C>, BlockNumberOf<C>>>;
 
 	/// Get the context needed for validating a finality proof.
 	async fn finality_verification_context<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 		at: HashOf<TargetChain>,
 	) -> Result<Self::FinalityVerificationContext, SubstrateError>;
 
 	/// Returns the finality info associated to the source headers synced with the target
 	/// at the provided block.
 	async fn synced_headers_finality_info<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 		at: TargetChain::Hash,
 	) -> Result<
 		Vec<HeaderFinalityInfo<Self::FinalityProof, Self::FinalityVerificationContext>>,
@@ -159,7 +144,7 @@ pub trait Engine<C: Chain>: Send {
 
 	/// Generate key ownership proof for the provided equivocation.
 	async fn generate_source_key_ownership_proof(
-		source_client: &Client<C>,
+		source_client: &impl Client<C>,
 		at: C::Hash,
 		equivocation: &Self::EquivocationProof,
 	) -> Result<Self::KeyOwnerProof, SubstrateError>;
@@ -171,7 +156,7 @@ pub struct Grandpa<C>(PhantomData<C>);
 impl<C: ChainWithGrandpa> Grandpa<C> {
 	/// Read header by hash from the source client.
 	async fn source_header(
-		source_client: &Client<C>,
+		source_client: &impl Client<C>,
 		header_hash: C::Hash,
 	) -> Result<C::Header, Error<HashOf<C>, BlockNumberOf<C>>> {
 		source_client
@@ -182,15 +167,15 @@ impl<C: ChainWithGrandpa> Grandpa<C> {
 
 	/// Read GRANDPA authorities set at given header.
 	async fn source_authorities_set(
-		source_client: &Client<C>,
+		source_client: &impl Client<C>,
 		header_hash: C::Hash,
 	) -> Result<GrandpaAuthoritiesSet, Error<HashOf<C>, BlockNumberOf<C>>> {
-		let raw_authorities_set = source_client
-			.grandpa_authorities_set(header_hash)
+		const SUB_API_GRANDPA_AUTHORITIES: &str = "GrandpaApi_grandpa_authorities";
+
+		source_client
+			.state_call(header_hash, SUB_API_GRANDPA_AUTHORITIES.to_string(), ())
 			.await
-			.map_err(|err| Error::RetrieveAuthorities(C::NAME, header_hash, err))?;
-		GrandpaAuthoritiesSet::decode(&mut &raw_authorities_set[..])
-			.map_err(|err| Error::DecodeAuthorities(C::NAME, header_hash, err))
+			.map_err(|err| Error::RetrieveAuthorities(C::NAME, header_hash, err))
 	}
 }
 
@@ -198,7 +183,6 @@ impl<C: ChainWithGrandpa> Grandpa<C> {
 impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 	const ID: ConsensusEngineId = GRANDPA_ENGINE_ID;
 	type ConsensusLogReader = GrandpaConsensusLogReader<<C::Header as Header>::Number>;
-	type FinalityClient = SubstrateGrandpaFinalityClient;
 	type FinalityProof = GrandpaJustification<HeaderOf<C>>;
 	type FinalityVerificationContext = JustificationVerificationContext;
 	type EquivocationProof = sp_consensus_grandpa::EquivocationProof<HashOf<C>, BlockNumberOf<C>>;
@@ -215,8 +199,14 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 		bp_header_chain::storage_keys::pallet_operating_mode_key(C::WITH_CHAIN_GRANDPA_PALLET_NAME)
 	}
 
+	async fn source_finality_proofs(
+		client: &impl Client<C>,
+	) -> Result<Subscription<Bytes>, SubstrateError> {
+		client.subscribe_grandpa_finality_justifications().await
+	}
+
 	async fn verify_and_optimize_proof<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 		header: &C::Header,
 		proof: &mut Self::FinalityProof,
 	) -> Result<Self::FinalityVerificationContext, SubstrateError> {
@@ -245,27 +235,16 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 		})
 	}
 
-	fn check_max_expected_call_size(
+	fn check_max_expected_call_limits(
 		header: &C::Header,
 		proof: &Self::FinalityProof,
-	) -> MaxExpectedCallSizeCheck {
-		let is_mandatory = Self::ConsensusLogReader::schedules_authorities_change(header.digest());
-		let call_size: u32 =
-			header.encoded_size().saturating_add(proof.encoded_size()).saturated_into();
-		let max_call_size = max_expected_submit_finality_proof_arguments_size::<C>(
-			is_mandatory,
-			proof.commit.precommits.len().saturated_into(),
-		);
-		if call_size > max_call_size {
-			MaxExpectedCallSizeCheck::Exceeds { call_size, max_call_size }
-		} else {
-			MaxExpectedCallSizeCheck::Ok
-		}
+	) -> SubmitFinalityProofCallExtras {
+		bp_header_chain::submit_finality_proof_limits_extras::<C>(header, proof)
 	}
 
 	/// Prepare initialization data for the GRANDPA verifier pallet.
 	async fn prepare_initialization_data(
-		source_client: Client<C>,
+		source_client: impl Client<C>,
 	) -> Result<Self::InitializationData, Error<HashOf<C>, BlockNumberOf<C>>> {
 		// In ideal world we just need to get best finalized header and then to read GRANDPA
 		// authorities set (`pallet_grandpa::CurrentSetId` + `GrandpaApi::grandpa_authorities()`) at
@@ -274,17 +253,14 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 		// But now there are problems with this approach - `CurrentSetId` may return invalid value.
 		// So here we're waiting for the next justification, read the authorities set and then try
 		// to figure out the set id with bruteforce.
-		let justifications = Self::source_finality_proofs(&source_client)
+		let mut justifications = Self::source_finality_proofs(&source_client)
 			.await
 			.map_err(|err| Error::Subscribe(C::NAME, err))?;
 		// Read next justification - the header that it finalizes will be used as initial header.
 		let justification = justifications
 			.next()
 			.await
-			.map_err(|e| Error::ReadJustification(C::NAME, e))
-			.and_then(|justification| {
-				justification.ok_or(Error::ReadJustificationStreamEnded(C::NAME))
-			})?;
+			.ok_or(Error::ReadJustificationStreamEnded(C::NAME))?;
 
 		// Read initial header.
 		let justification: GrandpaJustification<C::Header> =
@@ -385,14 +361,14 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 	}
 
 	async fn finality_verification_context<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 		at: HashOf<TargetChain>,
 	) -> Result<Self::FinalityVerificationContext, SubstrateError> {
 		let current_authority_set_key = bp_header_chain::storage_keys::current_authority_set_key(
 			C::WITH_CHAIN_GRANDPA_PALLET_NAME,
 		);
 		let authority_set: AuthoritySet = target_client
-			.storage_value(current_authority_set_key, Some(at))
+			.storage_value(at, current_authority_set_key)
 			.await?
 			.map(Ok)
 			.unwrap_or(Err(SubstrateError::Custom(format!(
@@ -411,11 +387,11 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 	}
 
 	async fn synced_headers_finality_info<TargetChain: Chain>(
-		target_client: &Client<TargetChain>,
+		target_client: &impl Client<TargetChain>,
 		at: TargetChain::Hash,
 	) -> Result<Vec<HeaderGrandpaInfo<HeaderOf<C>>>, SubstrateError> {
 		let stored_headers_grandpa_info: Vec<StoredHeaderGrandpaInfo<HeaderOf<C>>> = target_client
-			.typed_state_call(C::SYNCED_HEADERS_GRANDPA_INFO_METHOD.to_string(), (), Some(at))
+			.state_call(at, C::SYNCED_HEADERS_GRANDPA_INFO_METHOD.to_string(), ())
 			.await?;
 
 		let mut headers_grandpa_info = vec![];
@@ -433,7 +409,7 @@ impl<C: ChainWithGrandpa> Engine<C> for Grandpa<C> {
 	}
 
 	async fn generate_source_key_ownership_proof(
-		source_client: &Client<C>,
+		source_client: &impl Client<C>,
 		at: C::Hash,
 		equivocation: &Self::EquivocationProof,
 	) -> Result<Self::KeyOwnerProof, SubstrateError> {
diff --git a/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs b/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs
index 825960b1b3ef2cc4f73b7565d6a2c8fe3e30fdd9..71d15ca3868e04da680f83387ac792b3a02a5f24 100644
--- a/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs
+++ b/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs
@@ -50,11 +50,11 @@ pub type SubstrateFinalityProofsStream<P> =
 
 /// Subscribe to new finality proofs.
 pub async fn finality_proofs<P: SubstrateFinalityPipeline>(
-	client: &Client<P::SourceChain>,
+	client: &impl Client<P::SourceChain>,
 ) -> Result<SubstrateFinalityProofsStream<P>, Error> {
 	Ok(unfold(
 		P::FinalityEngine::source_finality_proofs(client).await?,
-		move |subscription| async move {
+		move |mut subscription| async move {
 			loop {
 				let log_error = |err| {
 					log::error!(
@@ -65,8 +65,7 @@ pub async fn finality_proofs<P: SubstrateFinalityPipeline>(
 					);
 				};
 
-				let next_justification =
-					subscription.next().await.map_err(|err| log_error(err.to_string())).ok()??;
+				let next_justification = subscription.next().await?;
 
 				let decoded_justification =
 					<P::FinalityEngine as Engine<P::SourceChain>>::FinalityProof::decode(
@@ -93,7 +92,7 @@ pub async fn finality_proofs<P: SubstrateFinalityPipeline>(
 ///
 /// The runtime API method should be `<TargetChain>FinalityApi::best_finalized()`.
 pub async fn best_synced_header_id<SourceChain, TargetChain>(
-	target_client: &Client<TargetChain>,
+	target_client: &impl Client<TargetChain>,
 	at: HashOf<TargetChain>,
 ) -> Result<Option<HeaderIdOf<SourceChain>>, Error>
 where
@@ -102,6 +101,6 @@ where
 {
 	// now let's read id of best finalized peer header at our best finalized block
 	target_client
-		.typed_state_call(SourceChain::BEST_FINALIZED_HEADER_ID_METHOD.into(), (), Some(at))
+		.state_call(at, SourceChain::BEST_FINALIZED_HEADER_ID_METHOD.into(), ())
 		.await
 }
diff --git a/bridges/relays/lib-substrate-relay/src/messages_lane.rs b/bridges/relays/lib-substrate-relay/src/messages_lane.rs
index a34b165289b2d67e1750b638ae1b997381280864..e3786dcdc5e31dad2cdf00ba2db073adb87f78b2 100644
--- a/bridges/relays/lib-substrate-relay/src/messages_lane.rs
+++ b/bridges/relays/lib-substrate-relay/src/messages_lane.rs
@@ -88,13 +88,13 @@ impl<P: SubstrateMessageLane> MessageLane for MessageLaneAdapter<P> {
 }
 
 /// Substrate <-> Substrate messages relay parameters.
-pub struct MessagesRelayParams<P: SubstrateMessageLane> {
+pub struct MessagesRelayParams<P: SubstrateMessageLane, SourceClnt, TargetClnt> {
 	/// Messages source client.
-	pub source_client: Client<P::SourceChain>,
+	pub source_client: SourceClnt,
 	/// Source transaction params.
 	pub source_transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
 	/// Messages target client.
-	pub target_client: Client<P::TargetChain>,
+	pub target_client: TargetClnt,
 	/// Target transaction params.
 	pub target_transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	/// Optional on-demand source to target headers relay.
@@ -179,8 +179,13 @@ impl<SC: Chain, TC: Chain, B: BatchCallBuilderConstructor<CallOf<SC>>>
 }
 
 /// Run Substrate-to-Substrate messages sync loop.
-pub async fn run<P: SubstrateMessageLane>(params: MessagesRelayParams<P>) -> anyhow::Result<()>
+pub async fn run<P, SourceClnt, TargetClnt>(
+	params: MessagesRelayParams<P, SourceClnt, TargetClnt>,
+) -> anyhow::Result<()>
 where
+	P: SubstrateMessageLane,
+	SourceClnt: Client<P::SourceChain>,
+	TargetClnt: Client<P::TargetChain>,
 	AccountIdOf<P::SourceChain>: From<<AccountKeyPairOf<P::SourceChain> as Pair>::Public>,
 	AccountIdOf<P::TargetChain>: From<<AccountKeyPairOf<P::TargetChain> as Pair>::Public>,
 	BalanceOf<P::SourceChain>: TryFrom<BalanceOf<P::TargetChain>>,
@@ -190,7 +195,7 @@ where
 	let limits = match params.limits {
 		Some(limits) => limits,
 		None =>
-			select_delivery_transaction_limits_rpc::<P>(
+			select_delivery_transaction_limits_rpc(
 				&params,
 				P::TargetChain::max_extrinsic_weight(),
 				P::SourceChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX,
@@ -250,19 +255,19 @@ where
 				max_messages_size_in_single_batch,
 			},
 		},
-		SubstrateMessagesSource::<P>::new(
+		SubstrateMessagesSource::<P, _, _>::new(
 			source_client.clone(),
 			target_client.clone(),
 			params.lane_id,
 			params.source_transaction_params,
 			params.target_to_source_headers_relay,
 		),
-		SubstrateMessagesTarget::<P>::new(
+		SubstrateMessagesTarget::<P, _, _>::new(
 			target_client,
 			source_client,
 			params.lane_id,
 			relayer_id_at_source,
-			params.target_transaction_params,
+			Some(params.target_transaction_params),
 			params.source_to_target_headers_relay,
 		),
 		{
@@ -278,8 +283,8 @@ where
 /// Deliver range of Substrate-to-Substrate messages. No checks are made to ensure that transaction
 /// will succeed.
 pub async fn relay_messages_range<P: SubstrateMessageLane>(
-	source_client: Client<P::SourceChain>,
-	target_client: Client<P::TargetChain>,
+	source_client: impl Client<P::SourceChain>,
+	target_client: impl Client<P::TargetChain>,
 	source_transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
 	target_transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	at_source_block: HeaderIdOf<P::SourceChain>,
@@ -295,19 +300,19 @@ where
 	let relayer_id_at_source: AccountIdOf<P::SourceChain> =
 		source_transaction_params.signer.public().into();
 	messages_relay::relay_messages_range(
-		SubstrateMessagesSource::<P>::new(
+		SubstrateMessagesSource::<P, _, _>::new(
 			source_client.clone(),
 			target_client.clone(),
 			lane_id,
 			source_transaction_params,
 			None,
 		),
-		SubstrateMessagesTarget::<P>::new(
+		SubstrateMessagesTarget::<P, _, _>::new(
 			target_client,
 			source_client,
 			lane_id,
 			relayer_id_at_source,
-			target_transaction_params,
+			Some(target_transaction_params),
 			None,
 		),
 		at_source_block,
@@ -318,6 +323,44 @@ where
 	.map_err(|_| anyhow::format_err!("The command has failed"))
 }
 
+/// Relay messages delivery confirmation of Substrate-to-Substrate messages.
+/// No checks are made to ensure that transaction will succeed.
+pub async fn relay_messages_delivery_confirmation<P: SubstrateMessageLane>(
+	source_client: impl Client<P::SourceChain>,
+	target_client: impl Client<P::TargetChain>,
+	source_transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
+	at_target_block: HeaderIdOf<P::TargetChain>,
+	lane_id: LaneId,
+) -> anyhow::Result<()>
+where
+	AccountIdOf<P::SourceChain>: From<<AccountKeyPairOf<P::SourceChain> as Pair>::Public>,
+	AccountIdOf<P::TargetChain>: From<<AccountKeyPairOf<P::TargetChain> as Pair>::Public>,
+	BalanceOf<P::SourceChain>: TryFrom<BalanceOf<P::TargetChain>>,
+{
+	let relayer_id_at_source: AccountIdOf<P::SourceChain> =
+		source_transaction_params.signer.public().into();
+	messages_relay::relay_messages_delivery_confirmation(
+		SubstrateMessagesSource::<P, _, _>::new(
+			source_client.clone(),
+			target_client.clone(),
+			lane_id,
+			source_transaction_params,
+			None,
+		),
+		SubstrateMessagesTarget::<P, _, _>::new(
+			target_client,
+			source_client,
+			lane_id,
+			relayer_id_at_source,
+			None,
+			None,
+		),
+		at_target_block,
+	)
+	.await
+	.map_err(|_| anyhow::format_err!("The command has failed"))
+}
+
 /// Different ways of building `receive_messages_proof` calls.
 pub trait ReceiveMessagesProofCallBuilder<P: SubstrateMessageLane> {
 	/// Given messages proof, build call of `receive_messages_proof` function of bridge
@@ -508,12 +551,15 @@ macro_rules! generate_receive_message_delivery_proof_call_builder {
 }
 
 /// Returns maximal number of messages and their maximal cumulative dispatch weight.
-async fn select_delivery_transaction_limits_rpc<P: SubstrateMessageLane>(
-	params: &MessagesRelayParams<P>,
+async fn select_delivery_transaction_limits_rpc<P, SourceClnt, TargetClnt>(
+	params: &MessagesRelayParams<P, SourceClnt, TargetClnt>,
 	max_extrinsic_weight: Weight,
 	max_unconfirmed_messages_at_inbound_lane: MessageNonce,
 ) -> anyhow::Result<MessagesRelayLimits>
 where
+	P: SubstrateMessageLane,
+	SourceClnt: Client<P::SourceChain>,
+	TargetClnt: Client<P::TargetChain>,
 	AccountIdOf<P::SourceChain>: From<<AccountKeyPairOf<P::SourceChain> as Pair>::Public>,
 {
 	// We may try to guess accurate value, based on maximal number of messages and per-message
@@ -529,20 +575,21 @@ where
 	let weight_for_messages_dispatch = max_extrinsic_weight - weight_for_delivery_tx;
 
 	// weight of empty message delivery with outbound lane state
-	let delivery_tx_with_zero_messages = dummy_messages_delivery_transaction::<P>(params, 0)?;
+	let best_target_block_hash = params.target_client.best_header_hash().await?;
+	let delivery_tx_with_zero_messages = dummy_messages_delivery_transaction::<P, _, _>(params, 0)?;
 	let delivery_tx_with_zero_messages_weight = params
 		.target_client
-		.extimate_extrinsic_weight(delivery_tx_with_zero_messages)
+		.estimate_extrinsic_weight(best_target_block_hash, delivery_tx_with_zero_messages)
 		.await
 		.map_err(|e| {
 			anyhow::format_err!("Failed to estimate delivery extrinsic weight: {:?}", e)
 		})?;
 
 	// weight of single message delivery with outbound lane state
-	let delivery_tx_with_one_message = dummy_messages_delivery_transaction::<P>(params, 1)?;
+	let delivery_tx_with_one_message = dummy_messages_delivery_transaction::<P, _, _>(params, 1)?;
 	let delivery_tx_with_one_message_weight = params
 		.target_client
-		.extimate_extrinsic_weight(delivery_tx_with_one_message)
+		.estimate_extrinsic_weight(best_target_block_hash, delivery_tx_with_one_message)
 		.await
 		.map_err(|e| {
 			anyhow::format_err!("Failed to estimate delivery extrinsic weight: {:?}", e)
@@ -577,8 +624,8 @@ where
 }
 
 /// Returns dummy message delivery transaction with zero messages and `1kb` proof.
-fn dummy_messages_delivery_transaction<P: SubstrateMessageLane>(
-	params: &MessagesRelayParams<P>,
+fn dummy_messages_delivery_transaction<P: SubstrateMessageLane, SourceClnt, TargetClnt>(
+	params: &MessagesRelayParams<P, SourceClnt, TargetClnt>,
 	messages: u32,
 ) -> anyhow::Result<<P::TargetChain as ChainWithTransactions>::SignedTransaction>
 where
diff --git a/bridges/relays/lib-substrate-relay/src/messages_metrics.rs b/bridges/relays/lib-substrate-relay/src/messages_metrics.rs
index b30e75bd8bacbbd25c056eb7d499cc18d040f991..8845f43dcb62aa778b50354141381290fc0b897d 100644
--- a/bridges/relays/lib-substrate-relay/src/messages_metrics.rs
+++ b/bridges/relays/lib-substrate-relay/src/messages_metrics.rs
@@ -36,7 +36,7 @@ use std::{fmt::Debug, marker::PhantomData};
 
 /// Add relay accounts balance metrics.
 pub async fn add_relay_balances_metrics<C: ChainWithBalances, BC: ChainWithMessages>(
-	client: Client<C>,
+	client: impl Client<C>,
 	metrics: &MetricsParams,
 	relay_accounts: &Vec<TaggedAccount<AccountIdOf<C>>>,
 	lanes: &[LaneId],
diff --git a/bridges/relays/lib-substrate-relay/src/messages_source.rs b/bridges/relays/lib-substrate-relay/src/messages_source.rs
index 49deff046f9ca0914846d19b18653f85b8cd8554..1f597e278da404a5c3d8d0dff0032030d96ed433 100644
--- a/bridges/relays/lib-substrate-relay/src/messages_source.rs
+++ b/bridges/relays/lib-substrate-relay/src/messages_source.rs
@@ -63,19 +63,21 @@ pub type SubstrateMessagesProof<C> = (Weight, FromBridgedChainMessagesProof<Hash
 type MessagesToRefine<'a> = Vec<(MessagePayload, &'a mut OutboundMessageDetails)>;
 
 /// Substrate client as Substrate messages source.
-pub struct SubstrateMessagesSource<P: SubstrateMessageLane> {
-	source_client: Client<P::SourceChain>,
-	target_client: Client<P::TargetChain>,
+pub struct SubstrateMessagesSource<P: SubstrateMessageLane, SourceClnt, TargetClnt> {
+	source_client: SourceClnt,
+	target_client: TargetClnt,
 	lane_id: LaneId,
 	transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
 	target_to_source_headers_relay: Option<Arc<dyn OnDemandRelay<P::TargetChain, P::SourceChain>>>,
 }
 
-impl<P: SubstrateMessageLane> SubstrateMessagesSource<P> {
+impl<P: SubstrateMessageLane, SourceClnt: Client<P::SourceChain>, TargetClnt>
+	SubstrateMessagesSource<P, SourceClnt, TargetClnt>
+{
 	/// Create new Substrate headers source.
 	pub fn new(
-		source_client: Client<P::SourceChain>,
-		target_client: Client<P::TargetChain>,
+		source_client: SourceClnt,
+		target_client: TargetClnt,
 		lane_id: LaneId,
 		transaction_params: TransactionParams<AccountKeyPairOf<P::SourceChain>>,
 		target_to_source_headers_relay: Option<
@@ -98,22 +100,25 @@ impl<P: SubstrateMessageLane> SubstrateMessagesSource<P> {
 	) -> Result<Option<OutboundLaneData>, SubstrateError> {
 		self.source_client
 			.storage_value(
+				id.hash(),
 				outbound_lane_data_key(
 					P::TargetChain::WITH_CHAIN_MESSAGES_PALLET_NAME,
 					&self.lane_id,
 				),
-				Some(id.1),
 			)
 			.await
 	}
 
 	/// Ensure that the messages pallet at source chain is active.
 	async fn ensure_pallet_active(&self) -> Result<(), SubstrateError> {
-		ensure_messages_pallet_active::<P::SourceChain, P::TargetChain>(&self.source_client).await
+		ensure_messages_pallet_active::<P::SourceChain, P::TargetChain, _>(&self.source_client)
+			.await
 	}
 }
 
-impl<P: SubstrateMessageLane> Clone for SubstrateMessagesSource<P> {
+impl<P: SubstrateMessageLane, SourceClnt: Clone, TargetClnt: Clone> Clone
+	for SubstrateMessagesSource<P, SourceClnt, TargetClnt>
+{
 	fn clone(&self) -> Self {
 		Self {
 			source_client: self.source_client.clone(),
@@ -126,7 +131,12 @@ impl<P: SubstrateMessageLane> Clone for SubstrateMessagesSource<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateMessageLane> RelayClient for SubstrateMessagesSource<P> {
+impl<
+		P: SubstrateMessageLane,
+		SourceClnt: Client<P::SourceChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> RelayClient for SubstrateMessagesSource<P, SourceClnt, TargetClnt>
+{
 	type Error = SubstrateError;
 
 	async fn reconnect(&mut self) -> Result<(), SubstrateError> {
@@ -150,13 +160,17 @@ impl<P: SubstrateMessageLane> RelayClient for SubstrateMessagesSource<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateMessageLane> SourceClient<MessageLaneAdapter<P>> for SubstrateMessagesSource<P>
+impl<
+		P: SubstrateMessageLane,
+		SourceClnt: Client<P::SourceChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> SourceClient<MessageLaneAdapter<P>> for SubstrateMessagesSource<P, SourceClnt, TargetClnt>
 where
 	AccountIdOf<P::SourceChain>: From<<AccountKeyPairOf<P::SourceChain> as Pair>::Public>,
 {
 	type BatchTransaction =
 		BatchProofTransaction<P::SourceChain, P::TargetChain, P::SourceBatchCallBuilder>;
-	type TransactionTracker = TransactionTracker<P::SourceChain, Client<P::SourceChain>>;
+	type TransactionTracker = TransactionTracker<P::SourceChain, SourceClnt>;
 
 	async fn state(&self) -> Result<SourceClientState<MessageLaneAdapter<P>>, SubstrateError> {
 		// we can't continue to deliver confirmations if source node is out of sync, because
@@ -169,7 +183,7 @@ where
 		// we can't relay confirmations if messages pallet at source chain is halted
 		self.ensure_pallet_active().await?;
 
-		read_client_state(&self.source_client, Some(&self.target_client)).await
+		read_client_state_from_both_chains(&self.source_client, &self.target_client).await
 	}
 
 	async fn latest_generated_nonce(
@@ -203,12 +217,12 @@ where
 		id: SourceHeaderIdOf<MessageLaneAdapter<P>>,
 		nonces: RangeInclusive<MessageNonce>,
 	) -> Result<MessageDetailsMap<BalanceOf<P::SourceChain>>, SubstrateError> {
-		let mut out_msgs_details = self
+		let mut out_msgs_details: Vec<_> = self
 			.source_client
-			.typed_state_call::<_, Vec<_>>(
+			.state_call::<_, Vec<_>>(
+				id.hash(),
 				P::TargetChain::TO_CHAIN_MESSAGE_DETAILS_METHOD.into(),
 				(self.lane_id, *nonces.start(), *nonces.end()),
-				Some(id.1),
 			)
 			.await?;
 		validate_out_msgs_details::<P::SourceChain>(&out_msgs_details, nonces)?;
@@ -226,7 +240,7 @@ where
 				out_msg_details.nonce,
 			);
 			let msg_payload: MessagePayload =
-				self.source_client.storage_value(msg_key, Some(id.1)).await?.ok_or_else(|| {
+				self.source_client.storage_value(id.hash(), msg_key).await?.ok_or_else(|| {
 					SubstrateError::Custom(format!(
 						"Message to {} {:?}/{} is missing from runtime the storage of {} at {:?}",
 						P::TargetChain::NAME,
@@ -240,15 +254,16 @@ where
 			msgs_to_refine.push((msg_payload, out_msg_details));
 		}
 
+		let best_target_header_hash = self.target_client.best_header_hash().await?;
 		for mut msgs_to_refine_batch in
 			split_msgs_to_refine::<P::SourceChain, P::TargetChain>(self.lane_id, msgs_to_refine)?
 		{
 			let in_msgs_details = self
 				.target_client
-				.typed_state_call::<_, Vec<InboundMessageDetails>>(
+				.state_call::<_, Vec<InboundMessageDetails>>(
+					best_target_header_hash,
 					P::SourceChain::FROM_CHAIN_MESSAGE_DETAILS_METHOD.into(),
 					(self.lane_id, &msgs_to_refine_batch),
-					None,
 				)
 				.await?;
 			if in_msgs_details.len() != msgs_to_refine_batch.len() {
@@ -326,7 +341,7 @@ where
 
 		let proof = self
 			.source_client
-			.prove_storage(storage_keys, id.1)
+			.prove_storage(id.1, storage_keys)
 			.await?
 			.into_iter_nodes()
 			.collect();
@@ -387,15 +402,19 @@ where
 }
 
 /// Ensure that the messages pallet at source chain is active.
-pub(crate) async fn ensure_messages_pallet_active<AtChain, WithChain>(
-	client: &Client<AtChain>,
+pub(crate) async fn ensure_messages_pallet_active<AtChain, WithChain, AtChainClient>(
+	client: &AtChainClient,
 ) -> Result<(), SubstrateError>
 where
 	AtChain: ChainWithMessages,
 	WithChain: ChainWithMessages,
+	AtChainClient: Client<AtChain>,
 {
 	let operating_mode = client
-		.storage_value(operating_mode_key(WithChain::WITH_CHAIN_MESSAGES_PALLET_NAME), None)
+		.storage_value(
+			client.best_header_hash().await?,
+			operating_mode_key(WithChain::WITH_CHAIN_MESSAGES_PALLET_NAME),
+		)
 		.await?;
 	let is_halted =
 		operating_mode == Some(MessagesOperatingMode::Basic(BasicOperatingMode::Halted));
@@ -412,11 +431,10 @@ where
 /// bridge GRANDPA pallet deployed and it provides `best_finalized_header_id_method_name`
 /// runtime API to read the best finalized Bridged chain header.
 ///
-/// If `peer_client` is `None`, the value of `actual_best_finalized_peer_at_best_self` will
-/// always match the `best_finalized_peer_at_best_self`.
+/// The value of `actual_best_finalized_peer_at_best_self` will always match
+/// the `best_finalized_peer_at_best_self`.
 pub async fn read_client_state<SelfChain, PeerChain>(
-	self_client: &Client<SelfChain>,
-	peer_client: Option<&Client<PeerChain>>,
+	self_client: &impl Client<SelfChain>,
 ) -> Result<ClientState<HeaderIdOf<SelfChain>, HeaderIdOf<PeerChain>>, SubstrateError>
 where
 	SelfChain: Chain,
@@ -431,30 +449,42 @@ where
 	let peer_on_self_best_finalized_id =
 		best_synced_header_id::<PeerChain, SelfChain>(self_client, self_best_id.hash()).await?;
 
-	// read actual header, matching the `peer_on_self_best_finalized_id` from the peer chain
-	let actual_peer_on_self_best_finalized_id =
-		match (peer_client, peer_on_self_best_finalized_id.as_ref()) {
-			(Some(peer_client), Some(peer_on_self_best_finalized_id)) => {
-				let actual_peer_on_self_best_finalized =
-					peer_client.header_by_number(peer_on_self_best_finalized_id.number()).await?;
-				Some(actual_peer_on_self_best_finalized.id())
-			},
-			_ => peer_on_self_best_finalized_id,
-		};
-
 	Ok(ClientState {
 		best_self: self_best_id,
 		best_finalized_self: self_best_finalized_id,
 		best_finalized_peer_at_best_self: peer_on_self_best_finalized_id,
-		actual_best_finalized_peer_at_best_self: actual_peer_on_self_best_finalized_id,
+		actual_best_finalized_peer_at_best_self: peer_on_self_best_finalized_id,
 	})
 }
 
+/// Does the same stuff as `read_client_state`, but properly fills the
+/// `actual_best_finalized_peer_at_best_self` field of the result.
+pub async fn read_client_state_from_both_chains<SelfChain, PeerChain>(
+	self_client: &impl Client<SelfChain>,
+	peer_client: &impl Client<PeerChain>,
+) -> Result<ClientState<HeaderIdOf<SelfChain>, HeaderIdOf<PeerChain>>, SubstrateError>
+where
+	SelfChain: Chain,
+	PeerChain: Chain,
+{
+	let mut client_state = read_client_state::<SelfChain, PeerChain>(self_client).await?;
+	client_state.actual_best_finalized_peer_at_best_self =
+		match client_state.best_finalized_peer_at_best_self.as_ref() {
+			Some(peer_on_self_best_finalized_id) => {
+				let actual_peer_on_self_best_finalized =
+					peer_client.header_by_number(peer_on_self_best_finalized_id.number()).await?;
+				Some(actual_peer_on_self_best_finalized.id())
+			},
+			_ => client_state.best_finalized_peer_at_best_self,
+		};
+	Ok(client_state)
+}
+
 /// Reads best `PeerChain` header known to the `SelfChain` using provided runtime API method.
 ///
 /// Method is supposed to be the `<PeerChain>FinalityApi::best_finalized()` method.
 pub async fn best_finalized_peer_header_at_self<SelfChain, PeerChain>(
-	self_client: &Client<SelfChain>,
+	self_client: &impl Client<SelfChain>,
 	at_self_hash: HashOf<SelfChain>,
 ) -> Result<Option<HeaderIdOf<PeerChain>>, SubstrateError>
 where
@@ -463,10 +493,10 @@ where
 {
 	// now let's read id of best finalized peer header at our best finalized block
 	self_client
-		.typed_state_call::<_, Option<_>>(
+		.state_call::<_, Option<_>>(
+			at_self_hash,
 			PeerChain::BEST_FINALIZED_HEADER_ID_METHOD.into(),
 			(),
-			Some(at_self_hash),
 		)
 		.await
 }
diff --git a/bridges/relays/lib-substrate-relay/src/messages_target.rs b/bridges/relays/lib-substrate-relay/src/messages_target.rs
index 633b11f0b8028636fdb8c9c6b4f1ec5fa42ccf33..e1c7645eac6834ed8768ef6f416ce415c37653cf 100644
--- a/bridges/relays/lib-substrate-relay/src/messages_target.rs
+++ b/bridges/relays/lib-substrate-relay/src/messages_target.rs
@@ -23,7 +23,9 @@ use crate::{
 		BatchProofTransaction, MessageLaneAdapter, ReceiveMessagesProofCallBuilder,
 		SubstrateMessageLane,
 	},
-	messages_source::{ensure_messages_pallet_active, read_client_state, SubstrateMessagesProof},
+	messages_source::{
+		ensure_messages_pallet_active, read_client_state_from_both_chains, SubstrateMessagesProof,
+	},
 	on_demand::OnDemandRelay,
 	TransactionParams,
 };
@@ -40,8 +42,8 @@ use messages_relay::{
 	message_lane_loop::{NoncesSubmitArtifacts, TargetClient, TargetClientState},
 };
 use relay_substrate_client::{
-	AccountIdOf, AccountKeyPairOf, BalanceOf, CallOf, Client, Error as SubstrateError, HashOf,
-	TransactionEra, TransactionTracker, UnsignedTransaction,
+	AccountIdOf, AccountKeyPairOf, BalanceOf, CallOf, Chain, Client, Error as SubstrateError,
+	HashOf, TransactionEra, TransactionTracker, UnsignedTransaction,
 };
 use relay_utils::relay_loop::Client as RelayClient;
 use sp_core::Pair;
@@ -52,23 +54,27 @@ pub type SubstrateMessagesDeliveryProof<C> =
 	(UnrewardedRelayersState, FromBridgedChainMessagesDeliveryProof<HashOf<C>>);
 
 /// Substrate client as Substrate messages target.
-pub struct SubstrateMessagesTarget<P: SubstrateMessageLane> {
-	target_client: Client<P::TargetChain>,
-	source_client: Client<P::SourceChain>,
+pub struct SubstrateMessagesTarget<P: SubstrateMessageLane, SourceClnt, TargetClnt> {
+	target_client: TargetClnt,
+	source_client: SourceClnt,
 	lane_id: LaneId,
 	relayer_id_at_source: AccountIdOf<P::SourceChain>,
-	transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
+	transaction_params: Option<TransactionParams<AccountKeyPairOf<P::TargetChain>>>,
 	source_to_target_headers_relay: Option<Arc<dyn OnDemandRelay<P::SourceChain, P::TargetChain>>>,
 }
 
-impl<P: SubstrateMessageLane> SubstrateMessagesTarget<P> {
+impl<P, SourceClnt, TargetClnt> SubstrateMessagesTarget<P, SourceClnt, TargetClnt>
+where
+	P: SubstrateMessageLane,
+	TargetClnt: Client<P::TargetChain>,
+{
 	/// Create new Substrate headers target.
 	pub fn new(
-		target_client: Client<P::TargetChain>,
-		source_client: Client<P::SourceChain>,
+		target_client: TargetClnt,
+		source_client: SourceClnt,
 		lane_id: LaneId,
 		relayer_id_at_source: AccountIdOf<P::SourceChain>,
-		transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
+		transaction_params: Option<TransactionParams<AccountKeyPairOf<P::TargetChain>>>,
 		source_to_target_headers_relay: Option<
 			Arc<dyn OnDemandRelay<P::SourceChain, P::TargetChain>>,
 		>,
@@ -90,22 +96,25 @@ impl<P: SubstrateMessageLane> SubstrateMessagesTarget<P> {
 	) -> Result<Option<InboundLaneData<AccountIdOf<P::SourceChain>>>, SubstrateError> {
 		self.target_client
 			.storage_value(
+				id.hash(),
 				inbound_lane_data_key(
 					P::SourceChain::WITH_CHAIN_MESSAGES_PALLET_NAME,
 					&self.lane_id,
 				),
-				Some(id.1),
 			)
 			.await
 	}
 
 	/// Ensure that the messages pallet at target chain is active.
 	async fn ensure_pallet_active(&self) -> Result<(), SubstrateError> {
-		ensure_messages_pallet_active::<P::TargetChain, P::SourceChain>(&self.target_client).await
+		ensure_messages_pallet_active::<P::TargetChain, P::SourceChain, _>(&self.target_client)
+			.await
 	}
 }
 
-impl<P: SubstrateMessageLane> Clone for SubstrateMessagesTarget<P> {
+impl<P: SubstrateMessageLane, SourceClnt: Clone, TargetClnt: Clone> Clone
+	for SubstrateMessagesTarget<P, SourceClnt, TargetClnt>
+{
 	fn clone(&self) -> Self {
 		Self {
 			target_client: self.target_client.clone(),
@@ -119,7 +128,12 @@ impl<P: SubstrateMessageLane> Clone for SubstrateMessagesTarget<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateMessageLane> RelayClient for SubstrateMessagesTarget<P> {
+impl<
+		P: SubstrateMessageLane,
+		SourceClnt: Client<P::SourceChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> RelayClient for SubstrateMessagesTarget<P, SourceClnt, TargetClnt>
+{
 	type Error = SubstrateError;
 
 	async fn reconnect(&mut self) -> Result<(), SubstrateError> {
@@ -143,14 +157,18 @@ impl<P: SubstrateMessageLane> RelayClient for SubstrateMessagesTarget<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateMessageLane> TargetClient<MessageLaneAdapter<P>> for SubstrateMessagesTarget<P>
+impl<
+		P: SubstrateMessageLane,
+		SourceClnt: Client<P::SourceChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> TargetClient<MessageLaneAdapter<P>> for SubstrateMessagesTarget<P, SourceClnt, TargetClnt>
 where
 	AccountIdOf<P::TargetChain>: From<<AccountKeyPairOf<P::TargetChain> as Pair>::Public>,
 	BalanceOf<P::SourceChain>: TryFrom<BalanceOf<P::TargetChain>>,
 {
 	type BatchTransaction =
 		BatchProofTransaction<P::TargetChain, P::SourceChain, P::TargetBatchCallBuilder>;
-	type TransactionTracker = TransactionTracker<P::TargetChain, Client<P::TargetChain>>;
+	type TransactionTracker = TransactionTracker<P::TargetChain, TargetClnt>;
 
 	async fn state(&self) -> Result<TargetClientState<MessageLaneAdapter<P>>, SubstrateError> {
 		// we can't continue to deliver confirmations if source node is out of sync, because
@@ -163,7 +181,7 @@ where
 		// we can't relay messages if messages pallet at target chain is halted
 		self.ensure_pallet_active().await?;
 
-		read_client_state(&self.target_client, Some(&self.source_client)).await
+		read_client_state_from_both_chains(&self.target_client, &self.source_client).await
 	}
 
 	async fn latest_received_nonce(
@@ -219,7 +237,7 @@ where
 		);
 		let proof = self
 			.target_client
-			.prove_storage(vec![inbound_data_key], id.1)
+			.prove_storage(id.hash(), vec![inbound_data_key])
 			.await?
 			.into_iter_nodes()
 			.collect();
@@ -249,11 +267,18 @@ where
 			None => messages_proof_call,
 		};
 
-		let transaction_params = self.transaction_params.clone();
+		let transaction_params = self.transaction_params.clone().map(Ok).unwrap_or_else(|| {
+			// this error shall never happen in practice, so it not deserves
+			// a separate error variant
+			Err(SubstrateError::Custom(format!(
+				"Cannot sign transaction of {} chain",
+				P::TargetChain::NAME,
+			)))
+		})?;
 		let tx_tracker = self
 			.target_client
 			.submit_and_watch_signed_extrinsic(
-				&self.transaction_params.signer,
+				&transaction_params.signer,
 				move |best_block_id, transaction_nonce| {
 					Ok(UnsignedTransaction::new(final_call.into(), transaction_nonce)
 						.era(TransactionEra::new(best_block_id, transaction_params.mortality)))
diff --git a/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs b/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs
index 74f3a70c5e81bbc1d27162a74fb8dadab46a6d09..d18c582dfac4340a72f1bebd2eea3cabd0563dbe 100644
--- a/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs
+++ b/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs
@@ -16,9 +16,7 @@
 
 //! On-demand Substrate -> Substrate header finality relay.
 
-use crate::{
-	finality::SubmitFinalityProofCallBuilder, finality_base::engine::MaxExpectedCallSizeCheck,
-};
+use crate::finality::SubmitFinalityProofCallBuilder;
 
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
@@ -55,25 +53,30 @@ use crate::{
 /// relay) needs it to continue its regular work. When enough headers are relayed, on-demand stops
 /// syncing headers.
 #[derive(Clone)]
-pub struct OnDemandHeadersRelay<P: SubstrateFinalitySyncPipeline> {
+pub struct OnDemandHeadersRelay<P: SubstrateFinalitySyncPipeline, SourceClnt, TargetClnt> {
 	/// Relay task name.
 	relay_task_name: String,
 	/// Shared reference to maximal required finalized header number.
 	required_header_number: RequiredHeaderNumberRef<P::SourceChain>,
 	/// Client of the source chain.
-	source_client: Client<P::SourceChain>,
+	source_client: SourceClnt,
 	/// Client of the target chain.
-	target_client: Client<P::TargetChain>,
+	target_client: TargetClnt,
 }
 
-impl<P: SubstrateFinalitySyncPipeline> OnDemandHeadersRelay<P> {
+impl<
+		P: SubstrateFinalitySyncPipeline,
+		SourceClnt: Client<P::SourceChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> OnDemandHeadersRelay<P, SourceClnt, TargetClnt>
+{
 	/// Create new on-demand headers relay.
 	///
 	/// If `metrics_params` is `Some(_)`, the metrics of the finality relay are registered.
 	/// Otherwise, all required metrics must be exposed outside of this method.
 	pub fn new(
-		source_client: Client<P::SourceChain>,
-		target_client: Client<P::TargetChain>,
+		source_client: SourceClnt,
+		target_client: TargetClnt,
 		target_transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 		headers_to_relay: HeadersToRelay,
 		metrics_params: Option<MetricsParams>,
@@ -106,8 +109,12 @@ impl<P: SubstrateFinalitySyncPipeline> OnDemandHeadersRelay<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateFinalitySyncPipeline> OnDemandRelay<P::SourceChain, P::TargetChain>
-	for OnDemandHeadersRelay<P>
+impl<
+		P: SubstrateFinalitySyncPipeline,
+		SourceClnt: Client<P::SourceChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> OnDemandRelay<P::SourceChain, P::TargetChain>
+	for OnDemandHeadersRelay<P, SourceClnt, TargetClnt>
 {
 	async fn reconnect(&self) -> Result<(), SubstrateError> {
 		// using clone is fine here (to avoid mut requirement), because clone on Client clones
@@ -141,7 +148,7 @@ impl<P: SubstrateFinalitySyncPipeline> OnDemandRelay<P::SourceChain, P::TargetCh
 		loop {
 			// first find proper header (either `current_required_header`) or its descendant
 			let finality_source =
-				SubstrateFinalitySource::<P>::new(self.source_client.clone(), None);
+				SubstrateFinalitySource::<P, _>::new(self.source_client.clone(), None);
 			let (header, mut proof) =
 				finality_source.prove_block_finality(current_required_header).await?;
 			let header_id = header.id();
@@ -156,22 +163,21 @@ impl<P: SubstrateFinalitySyncPipeline> OnDemandRelay<P::SourceChain, P::TargetCh
 
 			// now we have the header and its proof, but we want to minimize our losses, so let's
 			// check if we'll get the full refund for submitting this header
-			let check_result = P::FinalityEngine::check_max_expected_call_size(&header, &proof);
-			if let MaxExpectedCallSizeCheck::Exceeds { call_size, max_call_size } = check_result {
+			let check_result = P::FinalityEngine::check_max_expected_call_limits(&header, &proof);
+			if check_result.is_weight_limit_exceeded || check_result.extra_size != 0 {
 				iterations += 1;
 				current_required_header = header_id.number().saturating_add(One::one());
 				if iterations < MAX_ITERATIONS {
 					log::debug!(
 						target: "bridge",
-						"[{}] Requested to prove {} head {:?}. Selected to prove {} head {:?}. But it is too large: {} vs {}. \
+						"[{}] Requested to prove {} head {:?}. Selected to prove {} head {:?}. But it exceeds limits: {:?}. \
 						Going to select next header",
 						self.relay_task_name,
 						P::SourceChain::NAME,
 						required_header,
 						P::SourceChain::NAME,
 						header_id,
-						call_size,
-						max_call_size,
+						check_result,
 					);
 
 					continue;
@@ -201,8 +207,8 @@ impl<P: SubstrateFinalitySyncPipeline> OnDemandRelay<P::SourceChain, P::TargetCh
 
 /// Background task that is responsible for starting headers relay.
 async fn background_task<P: SubstrateFinalitySyncPipeline>(
-	source_client: Client<P::SourceChain>,
-	target_client: Client<P::TargetChain>,
+	source_client: impl Client<P::SourceChain>,
+	target_client: impl Client<P::TargetChain>,
 	target_transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	headers_to_relay: HeadersToRelay,
 	required_header_number: RequiredHeaderNumberRef<P::SourceChain>,
@@ -212,7 +218,7 @@ async fn background_task<P: SubstrateFinalitySyncPipeline>(
 {
 	let relay_task_name = on_demand_headers_relay_name::<P::SourceChain, P::TargetChain>();
 	let target_transactions_mortality = target_transaction_params.mortality;
-	let mut finality_source = SubstrateFinalitySource::<P>::new(
+	let mut finality_source = SubstrateFinalitySource::<P, _>::new(
 		source_client.clone(),
 		Some(required_header_number.clone()),
 	);
@@ -249,7 +255,8 @@ async fn background_task<P: SubstrateFinalitySyncPipeline>(
 
 		// read best finalized source header number from target
 		let best_finalized_source_header_at_target =
-			best_finalized_source_header_at_target::<P>(&finality_target, &relay_task_name).await;
+			best_finalized_source_header_at_target::<P, _>(&finality_target, &relay_task_name)
+				.await;
 		if matches!(best_finalized_source_header_at_target, Err(ref e) if e.is_connection_error()) {
 			relay_utils::relay_loop::reconnect_failed_client(
 				FailedClient::Target,
@@ -413,13 +420,17 @@ async fn mandatory_headers_scan_range<C: Chain>(
 /// it.
 ///
 /// Returns `true` if header was found and (asked to be) relayed and `false` otherwise.
-async fn relay_mandatory_header_from_range<P: SubstrateFinalitySyncPipeline>(
-	finality_source: &SubstrateFinalitySource<P>,
+async fn relay_mandatory_header_from_range<P, SourceClnt>(
+	finality_source: &SubstrateFinalitySource<P, SourceClnt>,
 	required_header_number: &RequiredHeaderNumberRef<P::SourceChain>,
 	best_finalized_source_header_at_target: String,
 	range: (BlockNumberOf<P::SourceChain>, BlockNumberOf<P::SourceChain>),
 	relay_task_name: &str,
-) -> Result<bool, relay_substrate_client::Error> {
+) -> Result<bool, relay_substrate_client::Error>
+where
+	P: SubstrateFinalitySyncPipeline,
+	SourceClnt: Client<P::SourceChain>,
+{
 	// search for mandatory header first
 	let mandatory_source_header_number =
 		find_mandatory_header_in_range(finality_source, range).await?;
@@ -454,10 +465,14 @@ async fn relay_mandatory_header_from_range<P: SubstrateFinalitySyncPipeline>(
 /// Read best finalized source block number from source client.
 ///
 /// Returns `None` if we have failed to read the number.
-async fn best_finalized_source_header_at_source<P: SubstrateFinalitySyncPipeline>(
-	finality_source: &SubstrateFinalitySource<P>,
+async fn best_finalized_source_header_at_source<P, SourceClnt>(
+	finality_source: &SubstrateFinalitySource<P, SourceClnt>,
 	relay_task_name: &str,
-) -> Result<BlockNumberOf<P::SourceChain>, relay_substrate_client::Error> {
+) -> Result<BlockNumberOf<P::SourceChain>, relay_substrate_client::Error>
+where
+	P: SubstrateFinalitySyncPipeline,
+	SourceClnt: Client<P::SourceChain>,
+{
 	finality_source.on_chain_best_finalized_block_number().await.map_err(|error| {
 		log::error!(
 			target: "bridge",
@@ -473,11 +488,16 @@ async fn best_finalized_source_header_at_source<P: SubstrateFinalitySyncPipeline
 /// Read best finalized source block number from target client.
 ///
 /// Returns `None` if we have failed to read the number.
-async fn best_finalized_source_header_at_target<P: SubstrateFinalitySyncPipeline>(
-	finality_target: &SubstrateFinalityTarget<P>,
+async fn best_finalized_source_header_at_target<P, TargetClnt>(
+	finality_target: &SubstrateFinalityTarget<P, TargetClnt>,
 	relay_task_name: &str,
-) -> Result<BlockNumberOf<P::SourceChain>, <SubstrateFinalityTarget<P> as RelayClient>::Error>
+) -> Result<
+	BlockNumberOf<P::SourceChain>,
+	<SubstrateFinalityTarget<P, TargetClnt> as RelayClient>::Error,
+>
 where
+	P: SubstrateFinalitySyncPipeline,
+	TargetClnt: Client<P::TargetChain>,
 	AccountIdOf<P::TargetChain>: From<<AccountKeyPairOf<P::TargetChain> as sp_core::Pair>::Public>,
 {
 	finality_target
@@ -499,10 +519,14 @@ where
 /// Read first mandatory header in given inclusive range.
 ///
 /// Returns `Ok(None)` if there were no mandatory headers in the range.
-async fn find_mandatory_header_in_range<P: SubstrateFinalitySyncPipeline>(
-	finality_source: &SubstrateFinalitySource<P>,
+async fn find_mandatory_header_in_range<P, SourceClnt>(
+	finality_source: &SubstrateFinalitySource<P, SourceClnt>,
 	range: (BlockNumberOf<P::SourceChain>, BlockNumberOf<P::SourceChain>),
-) -> Result<Option<BlockNumberOf<P::SourceChain>>, relay_substrate_client::Error> {
+) -> Result<Option<BlockNumberOf<P::SourceChain>>, relay_substrate_client::Error>
+where
+	P: SubstrateFinalitySyncPipeline,
+	SourceClnt: Client<P::SourceChain>,
+{
 	let mut current = range.0;
 	while current <= range.1 {
 		let header = finality_source.client().header_by_number(current).await?;
diff --git a/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs b/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs
index 966bdc3107203a61cf405adba2cf09124330954e..654cb6628d5f062d5790a2d14ffa1ae6fadb7475 100644
--- a/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs
+++ b/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs
@@ -53,29 +53,34 @@ use std::fmt::Debug;
 /// (e.g. messages relay) needs it to continue its regular work. When enough parachain headers
 /// are relayed, on-demand stops syncing headers.
 #[derive(Clone)]
-pub struct OnDemandParachainsRelay<P: SubstrateParachainsPipeline> {
+pub struct OnDemandParachainsRelay<P: SubstrateParachainsPipeline, SourceRelayClnt, TargetClnt> {
 	/// Relay task name.
 	relay_task_name: String,
 	/// Channel used to communicate with background task and ask for relay of parachain heads.
 	required_header_number_sender: Sender<BlockNumberOf<P::SourceParachain>>,
 	/// Source relay chain client.
-	source_relay_client: Client<P::SourceRelayChain>,
+	source_relay_client: SourceRelayClnt,
 	/// Target chain client.
-	target_client: Client<P::TargetChain>,
+	target_client: TargetClnt,
 	/// On-demand relay chain relay.
 	on_demand_source_relay_to_target_headers:
 		Arc<dyn OnDemandRelay<P::SourceRelayChain, P::TargetChain>>,
 }
 
-impl<P: SubstrateParachainsPipeline> OnDemandParachainsRelay<P> {
+impl<
+		P: SubstrateParachainsPipeline,
+		SourceRelayClnt: Client<P::SourceRelayChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> OnDemandParachainsRelay<P, SourceRelayClnt, TargetClnt>
+{
 	/// Create new on-demand parachains relay.
 	///
 	/// Note that the argument is the source relay chain client, not the parachain client.
 	/// That's because parachain finality is determined by the relay chain and we don't
 	/// need to connect to the parachain itself here.
 	pub fn new(
-		source_relay_client: Client<P::SourceRelayChain>,
-		target_client: Client<P::TargetChain>,
+		source_relay_client: SourceRelayClnt,
+		target_client: TargetClnt,
 		target_transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 		on_demand_source_relay_to_target_headers: Arc<
 			dyn OnDemandRelay<P::SourceRelayChain, P::TargetChain>,
@@ -114,10 +119,13 @@ impl<P: SubstrateParachainsPipeline> OnDemandParachainsRelay<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateParachainsPipeline> OnDemandRelay<P::SourceParachain, P::TargetChain>
-	for OnDemandParachainsRelay<P>
+impl<P: SubstrateParachainsPipeline, SourceRelayClnt, TargetClnt>
+	OnDemandRelay<P::SourceParachain, P::TargetChain>
+	for OnDemandParachainsRelay<P, SourceRelayClnt, TargetClnt>
 where
 	P::SourceParachain: Chain<Hash = ParaHash>,
+	SourceRelayClnt: Client<P::SourceRelayChain>,
+	TargetClnt: Client<P::TargetChain>,
 {
 	async fn reconnect(&self) -> Result<(), SubstrateError> {
 		// using clone is fine here (to avoid mut requirement), because clone on Client clones
@@ -147,7 +155,7 @@ where
 		required_parachain_header: BlockNumberOf<P::SourceParachain>,
 	) -> Result<(HeaderIdOf<P::SourceParachain>, Vec<CallOf<P::TargetChain>>), SubstrateError> {
 		// select headers to prove
-		let parachains_source = ParachainsSource::<P>::new(
+		let parachains_source = ParachainsSource::<P, _>::new(
 			self.source_relay_client.clone(),
 			Arc::new(Mutex::new(AvailableHeader::Missing)),
 		);
@@ -231,8 +239,8 @@ where
 
 /// Background task that is responsible for starting parachain headers relay.
 async fn background_task<P: SubstrateParachainsPipeline>(
-	source_relay_client: Client<P::SourceRelayChain>,
-	target_client: Client<P::TargetChain>,
+	source_relay_client: impl Client<P::SourceRelayChain>,
+	target_client: impl Client<P::TargetChain>,
 	target_transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	on_demand_source_relay_to_target_headers: Arc<
 		dyn OnDemandRelay<P::SourceRelayChain, P::TargetChain>,
@@ -255,9 +263,11 @@ async fn background_task<P: SubstrateParachainsPipeline>(
 	let parachains_relay_task = futures::future::Fuse::terminated();
 	futures::pin_mut!(parachains_relay_task);
 
-	let mut parachains_source =
-		ParachainsSource::<P>::new(source_relay_client.clone(), required_para_header_ref.clone());
-	let mut parachains_target = ParachainsTarget::<P>::new(
+	let mut parachains_source = ParachainsSource::<P, _>::new(
+		source_relay_client.clone(),
+		required_para_header_ref.clone(),
+	);
+	let mut parachains_target = ParachainsTarget::<P, _, _>::new(
 		source_relay_client.clone(),
 		target_client.clone(),
 		target_transaction_params.clone(),
@@ -446,9 +456,9 @@ struct RelayData<ParaHash, ParaNumber, RelayNumber> {
 }
 
 /// Read required data from source and target clients.
-async fn read_relay_data<P: SubstrateParachainsPipeline>(
-	source: &ParachainsSource<P>,
-	target: &ParachainsTarget<P>,
+async fn read_relay_data<P: SubstrateParachainsPipeline, SourceRelayClnt, TargetClnt>(
+	source: &ParachainsSource<P, SourceRelayClnt>,
+	target: &ParachainsTarget<P, SourceRelayClnt, TargetClnt>,
 	required_header_number: BlockNumberOf<P::SourceParachain>,
 ) -> Result<
 	RelayData<
@@ -459,7 +469,9 @@ async fn read_relay_data<P: SubstrateParachainsPipeline>(
 	FailedClient,
 >
 where
-	ParachainsTarget<P>:
+	SourceRelayClnt: Client<P::SourceRelayChain>,
+	TargetClnt: Client<P::TargetChain>,
+	ParachainsTarget<P, SourceRelayClnt, TargetClnt>:
 		TargetClient<ParachainsPipelineAdapter<P>> + RelayClient<Error = SubstrateError>,
 {
 	let map_target_err = |e| {
@@ -642,13 +654,19 @@ trait SelectHeadersToProveEnvironment<RBN, RBH, PBN, PBH> {
 }
 
 #[async_trait]
-impl<'a, P: SubstrateParachainsPipeline>
+impl<'a, P: SubstrateParachainsPipeline, SourceRelayClnt, TargetClnt>
 	SelectHeadersToProveEnvironment<
 		BlockNumberOf<P::SourceRelayChain>,
 		HashOf<P::SourceRelayChain>,
 		BlockNumberOf<P::SourceParachain>,
 		HashOf<P::SourceParachain>,
-	> for (&'a OnDemandParachainsRelay<P>, &'a ParachainsSource<P>)
+	>
+	for (
+		&'a OnDemandParachainsRelay<P, SourceRelayClnt, TargetClnt>,
+		&'a ParachainsSource<P, SourceRelayClnt>,
+	) where
+	SourceRelayClnt: Client<P::SourceRelayChain>,
+	TargetClnt: Client<P::TargetChain>,
 {
 	fn parachain_id(&self) -> ParaId {
 		ParaId(P::SourceParachain::PARACHAIN_ID)
@@ -665,7 +683,6 @@ impl<'a, P: SubstrateParachainsPipeline>
 	) -> Result<HeaderIdOf<P::SourceRelayChain>, SubstrateError> {
 		Ok(crate::messages_source::read_client_state::<P::TargetChain, P::SourceRelayChain>(
 			&self.0.target_client,
-			None,
 		)
 		.await?
 		.best_finalized_peer_at_best_self
diff --git a/bridges/relays/lib-substrate-relay/src/parachains/source.rs b/bridges/relays/lib-substrate-relay/src/parachains/source.rs
index 4cc512b9d9b45c7334ffb121c1a8613b7f118550..11b9d6dbf5bd3fe12a4249ac9c2f9864291392d7 100644
--- a/bridges/relays/lib-substrate-relay/src/parachains/source.rs
+++ b/bridges/relays/lib-substrate-relay/src/parachains/source.rs
@@ -37,22 +37,24 @@ pub type RequiredHeaderIdRef<C> = Arc<Mutex<AvailableHeader<HeaderIdOf<C>>>>;
 
 /// Substrate client as parachain heads source.
 #[derive(Clone)]
-pub struct ParachainsSource<P: SubstrateParachainsPipeline> {
-	client: Client<P::SourceRelayChain>,
+pub struct ParachainsSource<P: SubstrateParachainsPipeline, SourceRelayClnt> {
+	client: SourceRelayClnt,
 	max_head_id: RequiredHeaderIdRef<P::SourceParachain>,
 }
 
-impl<P: SubstrateParachainsPipeline> ParachainsSource<P> {
+impl<P: SubstrateParachainsPipeline, SourceRelayClnt: Client<P::SourceRelayChain>>
+	ParachainsSource<P, SourceRelayClnt>
+{
 	/// Creates new parachains source client.
 	pub fn new(
-		client: Client<P::SourceRelayChain>,
+		client: SourceRelayClnt,
 		max_head_id: RequiredHeaderIdRef<P::SourceParachain>,
 	) -> Self {
 		ParachainsSource { client, max_head_id }
 	}
 
 	/// Returns reference to the underlying RPC client.
-	pub fn client(&self) -> &Client<P::SourceRelayChain> {
+	pub fn client(&self) -> &SourceRelayClnt {
 		&self.client
 	}
 
@@ -64,8 +66,8 @@ impl<P: SubstrateParachainsPipeline> ParachainsSource<P> {
 		let para_id = ParaId(P::SourceParachain::PARACHAIN_ID);
 		let storage_key =
 			parachain_head_storage_key_at_source(P::SourceRelayChain::PARAS_PALLET_NAME, para_id);
-		let para_head = self.client.raw_storage_value(storage_key, Some(at_block.1)).await?;
-		let para_head = para_head.map(|h| ParaHead::decode(&mut &h.0[..])).transpose()?;
+		let para_head: Option<ParaHead> =
+			self.client.storage_value(at_block.hash(), storage_key).await?;
 		let para_head = match para_head {
 			Some(para_head) => para_head,
 			None => return Ok(None),
@@ -76,7 +78,9 @@ impl<P: SubstrateParachainsPipeline> ParachainsSource<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateParachainsPipeline> RelayClient for ParachainsSource<P> {
+impl<P: SubstrateParachainsPipeline, SourceRelayClnt: Client<P::SourceRelayChain>> RelayClient
+	for ParachainsSource<P, SourceRelayClnt>
+{
 	type Error = SubstrateError;
 
 	async fn reconnect(&mut self) -> Result<(), SubstrateError> {
@@ -85,8 +89,8 @@ impl<P: SubstrateParachainsPipeline> RelayClient for ParachainsSource<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateParachainsPipeline> SourceClient<ParachainsPipelineAdapter<P>>
-	for ParachainsSource<P>
+impl<P: SubstrateParachainsPipeline, SourceRelayClnt: Client<P::SourceRelayChain>>
+	SourceClient<ParachainsPipelineAdapter<P>> for ParachainsSource<P, SourceRelayClnt>
 where
 	P::SourceParachain: Chain<Hash = ParaHash>,
 {
@@ -151,7 +155,7 @@ where
 			parachain_head_storage_key_at_source(P::SourceRelayChain::PARAS_PALLET_NAME, parachain);
 		let parachain_heads_proof = self
 			.client
-			.prove_storage(vec![storage_key.clone()], at_block.1)
+			.prove_storage(at_block.hash(), vec![storage_key.clone()])
 			.await?
 			.into_iter_nodes()
 			.collect();
@@ -165,10 +169,8 @@ where
 		// rereading actual value here
 		let parachain_head = self
 			.client
-			.raw_storage_value(storage_key, Some(at_block.1))
+			.storage_value::<ParaHead>(at_block.hash(), storage_key)
 			.await?
-			.map(|h| ParaHead::decode(&mut &h.0[..]))
-			.transpose()?
 			.ok_or_else(|| {
 				SubstrateError::Custom(format!(
 					"Failed to read expected parachain {parachain:?} head at {at_block:?}"
diff --git a/bridges/relays/lib-substrate-relay/src/parachains/target.rs b/bridges/relays/lib-substrate-relay/src/parachains/target.rs
index 531d55b53223609c523d521f43a38336353c597f..f66b193340c1a5e243b3bca17a111ed20f422c37 100644
--- a/bridges/relays/lib-substrate-relay/src/parachains/target.rs
+++ b/bridges/relays/lib-substrate-relay/src/parachains/target.rs
@@ -42,31 +42,42 @@ use relay_substrate_client::{
 };
 use relay_utils::relay_loop::Client as RelayClient;
 use sp_core::Pair;
+use sp_runtime::traits::Header;
 
 /// Substrate client as parachain heads source.
-pub struct ParachainsTarget<P: SubstrateParachainsPipeline> {
-	source_client: Client<P::SourceRelayChain>,
-	target_client: Client<P::TargetChain>,
+pub struct ParachainsTarget<P: SubstrateParachainsPipeline, SourceClnt, TargetClnt> {
+	source_client: SourceClnt,
+	target_client: TargetClnt,
 	transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 }
 
-impl<P: SubstrateParachainsPipeline> ParachainsTarget<P> {
+impl<
+		P: SubstrateParachainsPipeline,
+		SourceClnt: Client<P::SourceRelayChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> ParachainsTarget<P, SourceClnt, TargetClnt>
+{
 	/// Creates new parachains target client.
 	pub fn new(
-		source_client: Client<P::SourceRelayChain>,
-		target_client: Client<P::TargetChain>,
+		source_client: SourceClnt,
+		target_client: TargetClnt,
 		transaction_params: TransactionParams<AccountKeyPairOf<P::TargetChain>>,
 	) -> Self {
 		ParachainsTarget { source_client, target_client, transaction_params }
 	}
 
 	/// Returns reference to the underlying RPC client.
-	pub fn target_client(&self) -> &Client<P::TargetChain> {
+	pub fn target_client(&self) -> &TargetClnt {
 		&self.target_client
 	}
 }
 
-impl<P: SubstrateParachainsPipeline> Clone for ParachainsTarget<P> {
+impl<
+		P: SubstrateParachainsPipeline,
+		SourceClnt: Client<P::SourceRelayChain>,
+		TargetClnt: Clone,
+	> Clone for ParachainsTarget<P, SourceClnt, TargetClnt>
+{
 	fn clone(&self) -> Self {
 		ParachainsTarget {
 			source_client: self.source_client.clone(),
@@ -77,7 +88,12 @@ impl<P: SubstrateParachainsPipeline> Clone for ParachainsTarget<P> {
 }
 
 #[async_trait]
-impl<P: SubstrateParachainsPipeline> RelayClient for ParachainsTarget<P> {
+impl<
+		P: SubstrateParachainsPipeline,
+		SourceClnt: Client<P::SourceRelayChain>,
+		TargetClnt: Client<P::TargetChain>,
+	> RelayClient for ParachainsTarget<P, SourceClnt, TargetClnt>
+{
 	type Error = SubstrateError;
 
 	async fn reconnect(&mut self) -> Result<(), SubstrateError> {
@@ -88,14 +104,17 @@ impl<P: SubstrateParachainsPipeline> RelayClient for ParachainsTarget<P> {
 }
 
 #[async_trait]
-impl<P> TargetClient<ParachainsPipelineAdapter<P>> for ParachainsTarget<P>
+impl<P, SourceClnt, TargetClnt> TargetClient<ParachainsPipelineAdapter<P>>
+	for ParachainsTarget<P, SourceClnt, TargetClnt>
 where
 	P: SubstrateParachainsPipeline,
+	SourceClnt: Client<P::SourceRelayChain>,
+	TargetClnt: Client<P::TargetChain>,
 	AccountIdOf<P::TargetChain>: From<<AccountKeyPairOf<P::TargetChain> as Pair>::Public>,
 	P::SourceParachain: ChainBase<Hash = ParaHash>,
 	P::SourceRelayChain: ChainBase<BlockNumber = RelayBlockNumber>,
 {
-	type TransactionTracker = TransactionTracker<P::TargetChain, Client<P::TargetChain>>;
+	type TransactionTracker = TransactionTracker<P::TargetChain, TargetClnt>;
 
 	async fn best_block(&self) -> Result<HeaderIdOf<P::TargetChain>, Self::Error> {
 		let best_header = self.target_client.best_header().await?;
@@ -109,10 +128,10 @@ where
 		at_block: &HeaderIdOf<P::TargetChain>,
 	) -> Result<HeaderIdOf<P::SourceRelayChain>, Self::Error> {
 		self.target_client
-			.typed_state_call::<_, Option<HeaderIdOf<P::SourceRelayChain>>>(
+			.state_call::<_, Option<HeaderIdOf<P::SourceRelayChain>>>(
+				at_block.hash(),
 				P::SourceRelayChain::BEST_FINALIZED_HEADER_ID_METHOD.into(),
 				(),
-				Some(at_block.1),
 			)
 			.await?
 			.map(Ok)
@@ -124,7 +143,11 @@ where
 	) -> Result<Option<BlockNumberOf<P::SourceRelayChain>>, Self::Error> {
 		Ok(self
 			.target_client
-			.typed_state_call(P::SourceRelayChain::FREE_HEADERS_INTERVAL_METHOD.into(), (), None)
+			.state_call(
+				self.target_client.best_header().await?.hash(),
+				P::SourceRelayChain::FREE_HEADERS_INTERVAL_METHOD.into(),
+				(),
+			)
 			.await
 			.unwrap_or_else(|e| {
 				log::info!(
@@ -151,7 +174,7 @@ where
 			&P::SourceParachain::PARACHAIN_ID.into(),
 		);
 		let storage_value: Option<ParaInfo> =
-			self.target_client.storage_value(storage_key, Some(at_block.hash())).await?;
+			self.target_client.storage_value(at_block.hash(), storage_key).await?;
 		let para_info = match storage_value {
 			Some(para_info) => para_info,
 			None => return Ok(None),
@@ -172,7 +195,7 @@ where
 			&para_info.best_head_hash.head_hash,
 		);
 		let storage_value: Option<ParaStoredHeaderData> =
-			self.target_client.storage_value(storage_key, Some(at_block.hash())).await?;
+			self.target_client.storage_value(at_block.hash(), storage_key).await?;
 		let para_head_number = match storage_value {
 			Some(para_head_data) =>
 				para_head_data.decode_parachain_head_data::<P::SourceParachain>()?.number,
diff --git a/bridges/relays/messages/src/lib.rs b/bridges/relays/messages/src/lib.rs
index 7c18b6b148f3427b6a3b9c545d2fb5dcbecc5cd3..78a3237ba4fe03851412b86e08867fcba07e8451 100644
--- a/bridges/relays/messages/src/lib.rs
+++ b/bridges/relays/messages/src/lib.rs
@@ -37,3 +37,4 @@ mod message_race_receiving;
 mod message_race_strategy;
 
 pub use message_race_delivery::relay_messages_range;
+pub use message_race_receiving::relay_messages_delivery_confirmation;
diff --git a/bridges/relays/messages/src/message_race_receiving.rs b/bridges/relays/messages/src/message_race_receiving.rs
index e6497a1b79eb70999f16cd0c1926ae9cf0ad5411..ac4149b22d7b124f9cf661e8a99de7dedc4a15fe 100644
--- a/bridges/relays/messages/src/message_race_receiving.rs
+++ b/bridges/relays/messages/src/message_race_receiving.rs
@@ -30,7 +30,7 @@ use crate::{
 use async_trait::async_trait;
 use bp_messages::MessageNonce;
 use futures::stream::FusedStream;
-use relay_utils::FailedClient;
+use relay_utils::{FailedClient, TrackedTransactionStatus, TransactionTracker};
 use std::{marker::PhantomData, ops::RangeInclusive};
 
 /// Message receiving confirmations delivery strategy.
@@ -69,6 +69,43 @@ pub async fn run<P: MessageLane>(
 	.await
 }
 
+/// Relay messages delivery confirmation.
+pub async fn relay_messages_delivery_confirmation<P: MessageLane>(
+	source_client: impl MessageLaneSourceClient<P>,
+	target_client: impl MessageLaneTargetClient<P>,
+	at: TargetHeaderIdOf<P>,
+) -> Result<(), ()> {
+	// prepare messages delivery proof
+	let (at, proof) = target_client.prove_messages_receiving(at.clone()).await.map_err(|e| {
+		log::error!(
+			target: "bridge",
+			"Failed to generate messages delivery proof at {:?}: {:?}",
+			at,
+			e,
+		);
+	})?;
+	// submit messages delivery proof to the source node
+	let tx_tracker =
+		source_client
+			.submit_messages_receiving_proof(None, at, proof)
+			.await
+			.map_err(|e| {
+				log::error!(
+					target: "bridge",
+					"Failed to submit messages delivery proof: {:?}",
+					e,
+				);
+			})?;
+
+	match tx_tracker.wait().await {
+		TrackedTransactionStatus::Finalized(_) => Ok(()),
+		TrackedTransactionStatus::Lost => {
+			log::error!("Transaction with messages delivery proof is considered lost");
+			Err(())
+		},
+	}
+}
+
 /// Messages receiving confirmations race.
 struct ReceivingConfirmationsRace<P>(std::marker::PhantomData<P>);
 
diff --git a/bridges/relays/utils/Cargo.toml b/bridges/relays/utils/Cargo.toml
index 1264f582983f93c0f0b739f9d6c456df417f00ac..4765730a0b4f9906fd163600a7937f8d6aad661f 100644
--- a/bridges/relays/utils/Cargo.toml
+++ b/bridges/relays/utils/Cargo.toml
@@ -36,4 +36,4 @@ bp-runtime = { path = "../../primitives/runtime" }
 # Substrate dependencies
 
 sp-runtime = { path = "../../../substrate/primitives/runtime" }
-substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" }
diff --git a/bridges/relays/utils/src/error.rs b/bridges/relays/utils/src/error.rs
index 26f1d0cacefd8eef5687e0102588f999859012a5..48c02bb9bd7a4510e46f4353f4bad448addbf1f4 100644
--- a/bridges/relays/utils/src/error.rs
+++ b/bridges/relays/utils/src/error.rs
@@ -42,5 +42,5 @@ pub enum Error {
 	ExposingMetricsInvalidHost(String, AddrParseError),
 	/// Prometheus error.
 	#[error("{0}")]
-	Prometheus(#[from] substrate_prometheus_endpoint::prometheus::Error),
+	Prometheus(#[from] prometheus_endpoint::prometheus::Error),
 }
diff --git a/bridges/relays/utils/src/metrics.rs b/bridges/relays/utils/src/metrics.rs
index 2e6c8236da454dd620ccdb5f1f03cdbf9eed9471..4c946651b058cc87eca3d2d88431cfc500a1126a 100644
--- a/bridges/relays/utils/src/metrics.rs
+++ b/bridges/relays/utils/src/metrics.rs
@@ -16,7 +16,7 @@
 
 pub use float_json_value::FloatJsonValueMetric;
 pub use global::GlobalMetrics;
-pub use substrate_prometheus_endpoint::{
+pub use prometheus_endpoint::{
 	prometheus::core::{Atomic, Collector},
 	register, Counter, CounterVec, Gauge, GaugeVec, Opts, PrometheusError, Registry, F64, I64, U64,
 };
diff --git a/bridges/relays/utils/src/relay_loop.rs b/bridges/relays/utils/src/relay_loop.rs
index 7105190a45831f57ecb728ac0d354157b020db8a..7f84fdc98f3cfbdfd61b4d413c7296d583ad6789 100644
--- a/bridges/relays/utils/src/relay_loop.rs
+++ b/bridges/relays/utils/src/relay_loop.rs
@@ -21,8 +21,8 @@ use crate::{
 };
 
 use async_trait::async_trait;
+use prometheus_endpoint::{init_prometheus, Registry};
 use std::{fmt::Debug, future::Future, net::SocketAddr, time::Duration};
-use substrate_prometheus_endpoint::{init_prometheus, Registry};
 
 /// Default pause between reconnect attempts.
 pub const RECONNECT_DELAY: Duration = Duration::from_secs(10);
diff --git a/bridges/snowbridge/pallets/ethereum-client/Cargo.toml b/bridges/snowbridge/pallets/ethereum-client/Cargo.toml
index e60934e34740600e78b9973d66ce648751a55138..cab2b06b0931e6d28df83434b3319c8384bd3679 100644
--- a/bridges/snowbridge/pallets/ethereum-client/Cargo.toml
+++ b/bridges/snowbridge/pallets/ethereum-client/Cargo.toml
@@ -33,7 +33,7 @@ sp-io = { path = "../../../../substrate/primitives/io", default-features = false
 snowbridge-core = { path = "../../primitives/core", default-features = false }
 snowbridge-ethereum = { path = "../../primitives/ethereum", default-features = false }
 snowbridge-pallet-ethereum-client-fixtures = { path = "fixtures", default-features = false, optional = true }
-primitives = { package = "snowbridge-beacon-primitives", path = "../../primitives/beacon", default-features = false }
+snowbridge-beacon-primitives = { path = "../../primitives/beacon", default-features = false }
 static_assertions = { version = "1.1.0", default-features = false }
 pallet-timestamp = { path = "../../../../substrate/frame/timestamp", default-features = false, optional = true }
 
@@ -62,9 +62,9 @@ std = [
 	"frame-system/std",
 	"log/std",
 	"pallet-timestamp/std",
-	"primitives/std",
 	"scale-info/std",
 	"serde",
+	"snowbridge-beacon-primitives/std",
 	"snowbridge-core/std",
 	"snowbridge-ethereum/std",
 	"snowbridge-pallet-ethereum-client-fixtures/std",
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs
index 4b8796b628d793951fec9ba905db1cd17f544eee..12aa3f4ca1fad4a0ac3c2adf8a0f54eaaf30b457 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs
@@ -9,7 +9,7 @@ use frame_system::RawOrigin;
 
 use snowbridge_pallet_ethereum_client_fixtures::*;
 
-use primitives::{
+use snowbridge_beacon_primitives::{
 	fast_aggregate_verify, prepare_aggregate_pubkey, prepare_aggregate_signature,
 	verify_merkle_branch,
 };
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs
index 7e5ded6e1f0d26cad99b5ee84f97eeb277605954..95e16d9fd434226db614cc29b9a8d995eb7ee930 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs
@@ -4,7 +4,7 @@ use crate::{
 	decompress_sync_committee_bits, Config, CurrentSyncCommittee, Pallet as EthereumBeaconClient,
 	Update, ValidatorsRoot, Vec,
 };
-use primitives::PublicKeyPrepared;
+use snowbridge_beacon_primitives::PublicKeyPrepared;
 use sp_core::H256;
 
 pub fn participant_pubkeys<T: Config>(
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs b/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs
index ba3ea47b94f9acf3dade1aec2bf39bd4d18b51ee..1ab1f67d6397f49d1f793d4250a3552c715db28d 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023 Snowfork <hello@snowfork.com>
-use primitives::merkle_proof::{generalized_index_length, subtree_index};
+use snowbridge_beacon_primitives::merkle_proof::{generalized_index_length, subtree_index};
 use static_assertions::const_assert;
 
 /// Generalized Indices
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/functions.rs b/bridges/snowbridge/pallets/ethereum-client/src/functions.rs
index 751e63c7f86afb6ae4161e9ec4b9ebe750d67436..781ae6c67638a60e5114b996fc73502795337c4d 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/functions.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/functions.rs
@@ -10,9 +10,10 @@ use crate::config::{
 pub fn decompress_sync_committee_bits(
 	input: [u8; SYNC_COMMITTEE_BITS_SIZE],
 ) -> [u8; SYNC_COMMITTEE_SIZE] {
-	primitives::decompress_sync_committee_bits::<SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_BITS_SIZE>(
-		input,
-	)
+	snowbridge_beacon_primitives::decompress_sync_committee_bits::<
+		SYNC_COMMITTEE_SIZE,
+		SYNC_COMMITTEE_BITS_SIZE,
+	>(input)
 }
 
 /// Compute the sync committee period in which a slot is contained.
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/impls.rs b/bridges/snowbridge/pallets/ethereum-client/src/impls.rs
index f600b1f67e29e7875bfccd6fab6926edda6498cc..2def6f58ba3034d2639a1bf8d25fddb1bbd1af31 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/impls.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/impls.rs
@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <hello@snowfork.com>
 use super::*;
 use frame_support::ensure;
-use primitives::ExecutionProof;
+use snowbridge_beacon_primitives::ExecutionProof;
 
 use snowbridge_core::inbound::{
 	VerificationError::{self, *},
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/lib.rs b/bridges/snowbridge/pallets/ethereum-client/src/lib.rs
index 6a5972ca7a142e4a5842d506fce5a87991e25f3a..6894977c21f4a2a78b1c7f67eb0b36a791936b92 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/lib.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/lib.rs
@@ -36,7 +36,7 @@ use frame_support::{
 	dispatch::DispatchResult, pallet_prelude::OptionQuery, traits::Get, transactional,
 };
 use frame_system::ensure_signed;
-use primitives::{
+use snowbridge_beacon_primitives::{
 	fast_aggregate_verify, verify_merkle_branch, verify_receipt_proof, BeaconHeader, BlsError,
 	CompactBeaconState, ForkData, ForkVersion, ForkVersions, PublicKeyPrepared, SigningData,
 };
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/mock.rs b/bridges/snowbridge/pallets/ethereum-client/src/mock.rs
index bd6144ebd8f9335ff02a82ad756d1b6dd06125e5..96298d4fa8962641d6ec8bab0ef67b751ab749cc 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/mock.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/mock.rs
@@ -4,7 +4,7 @@ use crate as ethereum_beacon_client;
 use crate::config;
 use frame_support::{derive_impl, dispatch::DispatchResult, parameter_types};
 use pallet_timestamp;
-use primitives::{Fork, ForkVersions};
+use snowbridge_beacon_primitives::{Fork, ForkVersions};
 use snowbridge_core::inbound::{Log, Proof};
 use sp_std::default::Default;
 use std::{fs::File, path::PathBuf};
@@ -21,32 +21,40 @@ where
 	serde_json::from_reader(File::open(filepath).unwrap())
 }
 
-pub fn load_execution_proof_fixture() -> primitives::ExecutionProof {
+pub fn load_execution_proof_fixture() -> snowbridge_beacon_primitives::ExecutionProof {
 	load_fixture("execution-proof.json".to_string()).unwrap()
 }
 
 pub fn load_checkpoint_update_fixture(
-) -> primitives::CheckpointUpdate<{ config::SYNC_COMMITTEE_SIZE }> {
+) -> snowbridge_beacon_primitives::CheckpointUpdate<{ config::SYNC_COMMITTEE_SIZE }> {
 	load_fixture("initial-checkpoint.json".to_string()).unwrap()
 }
 
-pub fn load_sync_committee_update_fixture(
-) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> {
+pub fn load_sync_committee_update_fixture() -> snowbridge_beacon_primitives::Update<
+	{ config::SYNC_COMMITTEE_SIZE },
+	{ config::SYNC_COMMITTEE_BITS_SIZE },
+> {
 	load_fixture("sync-committee-update.json".to_string()).unwrap()
 }
 
-pub fn load_finalized_header_update_fixture(
-) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> {
+pub fn load_finalized_header_update_fixture() -> snowbridge_beacon_primitives::Update<
+	{ config::SYNC_COMMITTEE_SIZE },
+	{ config::SYNC_COMMITTEE_BITS_SIZE },
+> {
 	load_fixture("finalized-header-update.json".to_string()).unwrap()
 }
 
-pub fn load_next_sync_committee_update_fixture(
-) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> {
+pub fn load_next_sync_committee_update_fixture() -> snowbridge_beacon_primitives::Update<
+	{ config::SYNC_COMMITTEE_SIZE },
+	{ config::SYNC_COMMITTEE_BITS_SIZE },
+> {
 	load_fixture("next-sync-committee-update.json".to_string()).unwrap()
 }
 
-pub fn load_next_finalized_header_update_fixture(
-) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> {
+pub fn load_next_finalized_header_update_fixture() -> snowbridge_beacon_primitives::Update<
+	{ config::SYNC_COMMITTEE_SIZE },
+	{ config::SYNC_COMMITTEE_BITS_SIZE },
+> {
 	load_fixture("next-finalized-header-update.json".to_string()).unwrap()
 }
 
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/tests.rs b/bridges/snowbridge/pallets/ethereum-client/src/tests.rs
index da762dc2fd8071969a1f68c707a0145aa0803852..c16743b75ea40b793947240773d159da908dab01 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/tests.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/tests.rs
@@ -17,7 +17,7 @@ pub use crate::mock::*;
 use crate::config::{EPOCHS_PER_SYNC_COMMITTEE_PERIOD, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT};
 use frame_support::{assert_err, assert_noop, assert_ok};
 use hex_literal::hex;
-use primitives::{
+use snowbridge_beacon_primitives::{
 	types::deneb, Fork, ForkVersions, NextSyncCommitteeUpdate, VersionedExecutionPayloadHeader,
 };
 use snowbridge_core::inbound::{VerificationError, Verifier};
@@ -171,7 +171,8 @@ pub fn sync_committee_participation_is_supermajority() {
 	let bits =
 		hex!("bffffffff7f1ffdfcfeffeffbfdffffbfffffdffffefefffdffff7f7ffff77fffdf7bff77ffdf7fffafffffff77fefffeff7effffffff5f7fedfffdfb6ddff7b"
 	);
-	let participation = primitives::decompress_sync_committee_bits::<512, 64>(bits);
+	let participation =
+		snowbridge_beacon_primitives::decompress_sync_committee_bits::<512, 64>(bits);
 	assert_ok!(EthereumBeaconClient::sync_committee_participation_is_supermajority(&participation));
 }
 
diff --git a/bridges/snowbridge/pallets/ethereum-client/src/types.rs b/bridges/snowbridge/pallets/ethereum-client/src/types.rs
index 92b9f77f739b062b89de2685db91e7f8355a2722..a670e691612ec132f8b11f1584b7de9dea504405 100644
--- a/bridges/snowbridge/pallets/ethereum-client/src/types.rs
+++ b/bridges/snowbridge/pallets/ethereum-client/src/types.rs
@@ -8,14 +8,14 @@ use frame_support::storage::types::OptionQuery;
 use snowbridge_core::RingBufferMapImpl;
 
 // Specialize types based on configured sync committee size
-pub type SyncCommittee = primitives::SyncCommittee<SC_SIZE>;
-pub type SyncCommitteePrepared = primitives::SyncCommitteePrepared<SC_SIZE>;
-pub type SyncAggregate = primitives::SyncAggregate<SC_SIZE, SC_BITS_SIZE>;
-pub type CheckpointUpdate = primitives::CheckpointUpdate<SC_SIZE>;
-pub type Update = primitives::Update<SC_SIZE, SC_BITS_SIZE>;
-pub type NextSyncCommitteeUpdate = primitives::NextSyncCommitteeUpdate<SC_SIZE>;
+pub type SyncCommittee = snowbridge_beacon_primitives::SyncCommittee<SC_SIZE>;
+pub type SyncCommitteePrepared = snowbridge_beacon_primitives::SyncCommitteePrepared<SC_SIZE>;
+pub type SyncAggregate = snowbridge_beacon_primitives::SyncAggregate<SC_SIZE, SC_BITS_SIZE>;
+pub type CheckpointUpdate = snowbridge_beacon_primitives::CheckpointUpdate<SC_SIZE>;
+pub type Update = snowbridge_beacon_primitives::Update<SC_SIZE, SC_BITS_SIZE>;
+pub type NextSyncCommitteeUpdate = snowbridge_beacon_primitives::NextSyncCommitteeUpdate<SC_SIZE>;
 
-pub use primitives::{AncestryProof, ExecutionProof};
+pub use snowbridge_beacon_primitives::{AncestryProof, ExecutionProof};
 
 /// FinalizedState ring buffer implementation
 pub type FinalizedBeaconStateBuffer<T> = RingBufferMapImpl<
diff --git a/bridges/snowbridge/pallets/inbound-queue/src/mock.rs b/bridges/snowbridge/pallets/inbound-queue/src/mock.rs
index c96c868bc26ef71984e70bc40863db73cf18b9c5..a031676c6076ad417a9d0fd1f060e9387bb99eea 100644
--- a/bridges/snowbridge/pallets/inbound-queue/src/mock.rs
+++ b/bridges/snowbridge/pallets/inbound-queue/src/mock.rs
@@ -2,11 +2,7 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <hello@snowfork.com>
 use super::*;
 
-use frame_support::{
-	derive_impl, parameter_types,
-	traits::{ConstU32, Everything},
-	weights::IdentityFee,
-};
+use frame_support::{derive_impl, parameter_types, traits::ConstU32, weights::IdentityFee};
 use hex_literal::hex;
 use snowbridge_beacon_primitives::{
 	types::deneb, BeaconHeader, ExecutionProof, Fork, ForkVersions, VersionedExecutionPayloadHeader,
@@ -19,7 +15,7 @@ use snowbridge_core::{
 use snowbridge_router_primitives::inbound::MessageToXcm;
 use sp_core::{H160, H256};
 use sp_runtime::{
-	traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify},
+	traits::{IdentifyAccount, IdentityLookup, Verify},
 	BuildStorage, FixedU128, MultiSignature,
 };
 use sp_std::{convert::From, default::Default};
@@ -43,27 +39,13 @@ frame_support::construct_runtime!(
 pub type Signature = MultiSignature;
 pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-}
-
 type Balance = u128;
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
-	type BaseCallFilter = Everything;
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
-	type RuntimeTask = RuntimeTask;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u128>;
-	type Nonce = u64;
 	type Block = Block;
 }
 
@@ -71,20 +53,11 @@ parameter_types! {
 	pub const ExistentialDeposit: u128 = 1;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 parameter_types! {
diff --git a/bridges/snowbridge/pallets/outbound-queue/src/mock.rs b/bridges/snowbridge/pallets/outbound-queue/src/mock.rs
index 5eeeeead140018e81a8aaaf302d678e3a4321e08..d65a96e2702dfbc69e52a913964de230bcdeadd0 100644
--- a/bridges/snowbridge/pallets/outbound-queue/src/mock.rs
+++ b/bridges/snowbridge/pallets/outbound-queue/src/mock.rs
@@ -33,10 +33,6 @@ frame_support::construct_runtime!(
 	}
 );
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-}
-
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
 	type BaseCallFilter = Everything;
@@ -48,7 +44,6 @@ impl frame_system::Config for Test {
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type PalletInfo = PalletInfo;
 	type Nonce = u64;
 	type Block = Block;
diff --git a/bridges/snowbridge/pallets/system/src/mock.rs b/bridges/snowbridge/pallets/system/src/mock.rs
index 687072a49e2e5ca9e27d7f1be94ea89564c2275f..98bd3da9ab27c974a1a85abbb208064e41f89991 100644
--- a/bridges/snowbridge/pallets/system/src/mock.rs
+++ b/bridges/snowbridge/pallets/system/src/mock.rs
@@ -3,7 +3,7 @@
 use crate as snowbridge_system;
 use frame_support::{
 	derive_impl, parameter_types,
-	traits::{tokens::fungible::Mutate, ConstU128, ConstU64, ConstU8},
+	traits::{tokens::fungible::Mutate, ConstU128, ConstU8},
 	weights::IdentityFee,
 	PalletId,
 };
@@ -106,27 +106,17 @@ impl frame_system::Config for Test {
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
 	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u128>;
 	type Nonce = u64;
 	type Block = Block;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ConstU128<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_xcm_origin::Config for Test {
diff --git a/bridges/snowbridge/primitives/router/Cargo.toml b/bridges/snowbridge/primitives/router/Cargo.toml
index 1d3fc43909df46a20f6e030985c2a7eea189fdc4..ec0888dd41b0cd197b49efda9f83e188916fb8fa 100644
--- a/bridges/snowbridge/primitives/router/Cargo.toml
+++ b/bridges/snowbridge/primitives/router/Cargo.toml
@@ -30,7 +30,7 @@ snowbridge-core = { path = "../core", default-features = false }
 hex-literal = { version = "0.4.1" }
 
 [dev-dependencies]
-hex = { package = "rustc-hex", version = "2.1.0" }
+rustc-hex = { version = "2.1.0" }
 
 [features]
 default = ["std"]
diff --git a/bridges/snowbridge/runtime/test-common/Cargo.toml b/bridges/snowbridge/runtime/test-common/Cargo.toml
index 20c3fc012d01183c09ca2ad206d38b1d382255cc..e19c682de4542994e19e20d0c194598fc8009db5 100644
--- a/bridges/snowbridge/runtime/test-common/Cargo.toml
+++ b/bridges/snowbridge/runtime/test-common/Cargo.toml
@@ -32,7 +32,7 @@ xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-feat
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../polkadot/xcm/xcm-executor", default-features = false }
 
 # Cumulus
-cumulus-pallet-parachain-system = { path = "../../../../cumulus/pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../cumulus/pallets/parachain-system", default-features = false }
 pallet-collator-selection = { path = "../../../../cumulus/pallets/collator-selection", default-features = false }
 parachain-info = { package = "staging-parachain-info", path = "../../../../cumulus/parachains/pallets/parachain-info", default-features = false }
 parachains-runtimes-test-utils = { path = "../../../../cumulus/parachains/runtimes/test-utils", default-features = false }
diff --git a/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json b/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json
index b2dddaa19ed1561b98422b3a28f6777308b3ba47..ca3abcc528cfaabc19cebf47426ef62f4ea5a8a6 100644
--- a/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json
+++ b/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json
@@ -736,9 +736,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "8.16.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.16.0.tgz",
-      "integrity": "sha512-HS0c//TP7Ina87TfiPUz1rQzMhHrl/SG2guqRcTOIUYD2q8uhUdNHZYJUaQ8aTGPzCh+c6oawMKW35nFl1dxyQ==",
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
       "engines": {
         "node": ">=10.0.0"
       },
diff --git a/cumulus/client/consensus/aura/Cargo.toml b/cumulus/client/consensus/aura/Cargo.toml
index 547137b7306460d91c10c3222c27d70f68d6e15d..fad30e59e869d3a4144b33cdd34c6b73990d7e9f 100644
--- a/cumulus/client/consensus/aura/Cargo.toml
+++ b/cumulus/client/consensus/aura/Cargo.toml
@@ -35,7 +35,7 @@ sp-keystore = { path = "../../../../substrate/primitives/keystore" }
 sp-runtime = { path = "../../../../substrate/primitives/runtime" }
 sp-timestamp = { path = "../../../../substrate/primitives/timestamp" }
 sp-state-machine = { path = "../../../../substrate/primitives/state-machine" }
-substrate-prometheus-endpoint = { path = "../../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../../substrate/utils/prometheus" }
 
 # Cumulus
 cumulus-client-consensus-common = { path = "../common" }
diff --git a/cumulus/client/consensus/aura/src/collators/lookahead.rs b/cumulus/client/consensus/aura/src/collators/lookahead.rs
index 09416233ea9b39dfd4bd4126149d51f922d7b6e4..b6f7b07f55d3e4f2f779b7d90f933b5f897a8079 100644
--- a/cumulus/client/consensus/aura/src/collators/lookahead.rs
+++ b/cumulus/client/consensus/aura/src/collators/lookahead.rs
@@ -363,13 +363,11 @@ where
 					Ok(x) => x,
 				};
 
-				let validation_code_hash = match params.code_hash_provider.code_hash_at(parent_hash)
-				{
-					None => {
-						tracing::error!(target: crate::LOG_TARGET, ?parent_hash, "Could not fetch validation code hash");
-						break
-					},
-					Some(v) => v,
+				let Some(validation_code_hash) =
+					params.code_hash_provider.code_hash_at(parent_hash)
+				else {
+					tracing::error!(target: crate::LOG_TARGET, ?parent_hash, "Could not fetch validation code hash");
+					break
 				};
 
 				super::check_validation_code_or_log(
diff --git a/cumulus/client/consensus/aura/src/collators/mod.rs b/cumulus/client/consensus/aura/src/collators/mod.rs
index 6e0067d0cedb602face8943737f99f3cb1a201a3..0abc034c1ed6baf051d04d1ff04680c3192acbf3 100644
--- a/cumulus/client/consensus/aura/src/collators/mod.rs
+++ b/cumulus/client/consensus/aura/src/collators/mod.rs
@@ -64,7 +64,7 @@ async fn check_validation_code_or_log(
 					?relay_parent,
 					?local_validation_code_hash,
 					relay_validation_code_hash = ?state,
-					"Parachain code doesn't match validation code stored in the relay chain state",
+					"Parachain code doesn't match validation code stored in the relay chain state.",
 				);
 			},
 		None => {
diff --git a/cumulus/client/consensus/aura/src/equivocation_import_queue.rs b/cumulus/client/consensus/aura/src/equivocation_import_queue.rs
index c3b601123b56996c597104567f7f39d29d64bf9c..be554bdcfc79b986f11da24404a47556031657b2 100644
--- a/cumulus/client/consensus/aura/src/equivocation_import_queue.rs
+++ b/cumulus/client/consensus/aura/src/equivocation_import_queue.rs
@@ -224,7 +224,7 @@ pub fn fully_verifying_import_queue<P, Client, Block: BlockT, I, CIDP>(
 	block_import: I,
 	create_inherent_data_providers: CIDP,
 	spawner: &impl sp_core::traits::SpawnEssentialNamed,
-	registry: Option<&substrate_prometheus_endpoint::Registry>,
+	registry: Option<&prometheus_endpoint::Registry>,
 	telemetry: Option<TelemetryHandle>,
 ) -> BasicQueue<Block>
 where
diff --git a/cumulus/client/consensus/aura/src/import_queue.rs b/cumulus/client/consensus/aura/src/import_queue.rs
index 2611eaf532f8ffadebc1c2932f429803e561924e..cbbfbe8d22230330e5306ed76d31b63eb4cf82e5 100644
--- a/cumulus/client/consensus/aura/src/import_queue.rs
+++ b/cumulus/client/consensus/aura/src/import_queue.rs
@@ -18,6 +18,7 @@
 
 use codec::Codec;
 use cumulus_client_consensus_common::ParachainBlockImportMarker;
+use prometheus_endpoint::Registry;
 use sc_client_api::{backend::AuxStore, BlockOf, UsageProvider};
 use sc_consensus::{import_queue::DefaultImportQueue, BlockImport};
 use sc_consensus_aura::{AuraVerifier, CompatibilityMode};
@@ -32,7 +33,6 @@ use sp_core::crypto::Pair;
 use sp_inherents::CreateInherentDataProviders;
 use sp_runtime::traits::Block as BlockT;
 use std::{fmt::Debug, sync::Arc};
-use substrate_prometheus_endpoint::Registry;
 
 /// Parameters for [`import_queue`].
 pub struct ImportQueueParams<'a, I, C, CIDP, S> {
diff --git a/cumulus/client/consensus/common/Cargo.toml b/cumulus/client/consensus/common/Cargo.toml
index 3a7c6b57d6d931b8809e9be9fda4cf4e07e50b8c..09c2f58d45e4e04ca420d6280c39eed12e39ad4f 100644
--- a/cumulus/client/consensus/common/Cargo.toml
+++ b/cumulus/client/consensus/common/Cargo.toml
@@ -28,7 +28,8 @@ sp-core = { path = "../../../../substrate/primitives/core" }
 sp-runtime = { path = "../../../../substrate/primitives/runtime" }
 sp-timestamp = { path = "../../../../substrate/primitives/timestamp" }
 sp-trie = { path = "../../../../substrate/primitives/trie" }
-substrate-prometheus-endpoint = { path = "../../../../substrate/utils/prometheus" }
+sp-version = { path = "../../../../substrate/primitives/version" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../../substrate/utils/prometheus" }
 
 # Polkadot
 polkadot-primitives = { path = "../../../../polkadot/primitives" }
diff --git a/cumulus/client/consensus/common/src/import_queue.rs b/cumulus/client/consensus/common/src/import_queue.rs
index 311a2b7ad8cfddf50abe0b18aeb5bf5f1f193c1d..8024b7695a285a414c89cea74561ece91dfd48de 100644
--- a/cumulus/client/consensus/common/src/import_queue.rs
+++ b/cumulus/client/consensus/common/src/import_queue.rs
@@ -63,7 +63,7 @@ impl<Block: BlockT> Verifier<Block> for VerifyNothing {
 pub fn verify_nothing_import_queue<Block: BlockT, I>(
 	block_import: I,
 	spawner: &impl sp_core::traits::SpawnEssentialNamed,
-	registry: Option<&substrate_prometheus_endpoint::Registry>,
+	registry: Option<&prometheus_endpoint::Registry>,
 ) -> BasicQueue<Block>
 where
 	I: BlockImport<Block, Error = ConsensusError>
diff --git a/cumulus/client/consensus/common/src/tests.rs b/cumulus/client/consensus/common/src/tests.rs
index aca9226570723c3285b2817e6bcdca22b141968b..2a944bc7f9fa221d63c48678f2899d50251b3655 100644
--- a/cumulus/client/consensus/common/src/tests.rs
+++ b/cumulus/client/consensus/common/src/tests.rs
@@ -38,6 +38,7 @@ use polkadot_primitives::HeadData;
 use sc_client_api::{Backend as _, UsageProvider};
 use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy};
 use sp_consensus::{BlockOrigin, BlockStatus};
+use sp_version::RuntimeVersion;
 use std::{
 	collections::{BTreeMap, HashMap},
 	pin::Pin,
@@ -153,6 +154,14 @@ impl RelayChainInterface for Relaychain {
 		unimplemented!("Not needed for test")
 	}
 
+	async fn candidates_pending_availability(
+		&self,
+		_: PHash,
+		_: ParaId,
+	) -> RelayChainResult<Vec<CommittedCandidateReceipt>> {
+		unimplemented!("Not needed for test")
+	}
+
 	async fn session_index_for_child(&self, _: PHash) -> RelayChainResult<SessionIndex> {
 		Ok(0)
 	}
@@ -247,6 +256,10 @@ impl RelayChainInterface for Relaychain {
 			extrinsics_root: PHash::zero(),
 		}))
 	}
+
+	async fn version(&self, _: PHash) -> RelayChainResult<RuntimeVersion> {
+		unimplemented!("Not needed for test")
+	}
 }
 
 fn sproof_with_best_parent(client: &Client) -> RelayStateSproofBuilder {
diff --git a/cumulus/client/consensus/relay-chain/Cargo.toml b/cumulus/client/consensus/relay-chain/Cargo.toml
index cb32b98045760de5621792c6ef45f76faf2e7e08..7c3a901db6c32131e762c3de971606fffddebc80 100644
--- a/cumulus/client/consensus/relay-chain/Cargo.toml
+++ b/cumulus/client/consensus/relay-chain/Cargo.toml
@@ -24,7 +24,7 @@ sp-consensus = { path = "../../../../substrate/primitives/consensus/common" }
 sp-core = { path = "../../../../substrate/primitives/core" }
 sp-inherents = { path = "../../../../substrate/primitives/inherents" }
 sp-runtime = { path = "../../../../substrate/primitives/runtime" }
-substrate-prometheus-endpoint = { path = "../../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../../substrate/utils/prometheus" }
 
 # Cumulus
 cumulus-client-consensus-common = { path = "../common" }
diff --git a/cumulus/client/consensus/relay-chain/src/import_queue.rs b/cumulus/client/consensus/relay-chain/src/import_queue.rs
index f44f440932437ff0cf658f7644bbf2e23670f8cd..1b521e79d4820fbc4c6709cb177170afa60d3f37 100644
--- a/cumulus/client/consensus/relay-chain/src/import_queue.rs
+++ b/cumulus/client/consensus/relay-chain/src/import_queue.rs
@@ -114,7 +114,7 @@ pub fn import_queue<Client, Block: BlockT, I, CIDP>(
 	block_import: I,
 	create_inherent_data_providers: CIDP,
 	spawner: &impl sp_core::traits::SpawnEssentialNamed,
-	registry: Option<&substrate_prometheus_endpoint::Registry>,
+	registry: Option<&prometheus_endpoint::Registry>,
 ) -> ClientResult<BasicQueue<Block>>
 where
 	I: BlockImport<Block, Error = ConsensusError>
diff --git a/cumulus/client/network/Cargo.toml b/cumulus/client/network/Cargo.toml
index d4fc752872589fbfd361f5df49939874d208ab3d..0dd7c4fdb0f60ac2f70f0fb697c901f960515b9a 100644
--- a/cumulus/client/network/Cargo.toml
+++ b/cumulus/client/network/Cargo.toml
@@ -24,11 +24,14 @@ sp-consensus = { path = "../../../substrate/primitives/consensus/common" }
 sp-core = { path = "../../../substrate/primitives/core" }
 sp-runtime = { path = "../../../substrate/primitives/runtime" }
 sp-state-machine = { path = "../../../substrate/primitives/state-machine" }
+sp-api = { path = "../../../substrate/primitives/api" }
+sp-version = { path = "../../../substrate/primitives/version" }
 
 # Polkadot
 polkadot-node-primitives = { path = "../../../polkadot/node/primitives" }
 polkadot-parachain-primitives = { path = "../../../polkadot/parachain" }
 polkadot-primitives = { path = "../../../polkadot/primitives" }
+polkadot-node-subsystem = { path = "../../../polkadot/node/subsystem" }
 
 # Cumulus
 cumulus-relay-chain-interface = { path = "../relay-chain-interface" }
@@ -37,6 +40,7 @@ cumulus-relay-chain-interface = { path = "../relay-chain-interface" }
 portpicker = "0.1.1"
 tokio = { version = "1.32.0", features = ["macros"] }
 url = "2.4.0"
+rstest = "0.18.2"
 
 # Substrate
 sc-cli = { path = "../../../substrate/client/cli" }
diff --git a/cumulus/client/network/src/lib.rs b/cumulus/client/network/src/lib.rs
index f442ed5840bddcd4a859d149635ff740e4d232f4..dab15bba590a0f46720d45bdaddc92f594fb8a9f 100644
--- a/cumulus/client/network/src/lib.rs
+++ b/cumulus/client/network/src/lib.rs
@@ -20,6 +20,7 @@
 //! that use the relay chain provided consensus. See [`RequireSecondedInBlockAnnounce`]
 //! and [`WaitToAnnounce`] for more information about this implementation.
 
+use sp_api::RuntimeApiInfo;
 use sp_consensus::block_validation::{
 	BlockAnnounceValidator as BlockAnnounceValidatorT, Validation,
 };
@@ -28,6 +29,7 @@ use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
 
 use cumulus_relay_chain_interface::RelayChainInterface;
 use polkadot_node_primitives::{CollationSecondedSignal, Statement};
+use polkadot_node_subsystem::messages::RuntimeApiRequest;
 use polkadot_parachain_primitives::primitives::HeadData;
 use polkadot_primitives::{
 	CandidateReceipt, CompactStatement, Hash as PHash, Id as ParaId, OccupiedCoreAssumption,
@@ -266,18 +268,41 @@ where
 		Ok(para_head)
 	}
 
-	/// Get the backed block hash of the given parachain in the relay chain.
-	async fn backed_block_hash(
+	/// Get the backed block hashes of the given parachain in the relay chain.
+	async fn backed_block_hashes(
 		relay_chain_interface: &RCInterface,
 		hash: PHash,
 		para_id: ParaId,
-	) -> Result<Option<PHash>, BoxedError> {
-		let candidate_receipt = relay_chain_interface
-			.candidate_pending_availability(hash, para_id)
+	) -> Result<impl Iterator<Item = PHash>, BoxedError> {
+		let runtime_api_version = relay_chain_interface
+			.version(hash)
 			.await
 			.map_err(|e| Box::new(BlockAnnounceError(format!("{:?}", e))) as Box<_>)?;
+		let parachain_host_runtime_api_version =
+			runtime_api_version
+				.api_version(
+					&<dyn polkadot_primitives::runtime_api::ParachainHost<
+						polkadot_primitives::Block,
+					>>::ID,
+				)
+				.unwrap_or_default();
+
+		// If the relay chain runtime does not support the new runtime API, fallback to the
+		// deprecated one.
+		let candidate_receipts = if parachain_host_runtime_api_version <
+			RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT
+		{
+			#[allow(deprecated)]
+			relay_chain_interface
+				.candidate_pending_availability(hash, para_id)
+				.await
+				.map(|c| c.into_iter().collect::<Vec<_>>())
+		} else {
+			relay_chain_interface.candidates_pending_availability(hash, para_id).await
+		}
+		.map_err(|e| Box::new(BlockAnnounceError(format!("{:?}", e))) as Box<_>)?;
 
-		Ok(candidate_receipt.map(|cr| cr.descriptor.para_head))
+		Ok(candidate_receipts.into_iter().map(|cr| cr.descriptor.para_head))
 	}
 
 	/// Handle a block announcement with empty data (no statement) attached to it.
@@ -298,15 +323,20 @@ where
 		let best_head =
 			Self::included_block(&relay_chain_interface, relay_chain_best_hash, para_id).await?;
 		let known_best_number = best_head.number();
-		let backed_block = || async {
-			Self::backed_block_hash(&relay_chain_interface, relay_chain_best_hash, para_id).await
-		};
 
 		if best_head == header {
 			tracing::debug!(target: LOG_TARGET, "Announced block matches best block.",);
 
-			Ok(Validation::Success { is_new_best: true })
-		} else if Some(HeadData(header.encode()).hash()) == backed_block().await? {
+			return Ok(Validation::Success { is_new_best: true })
+		}
+
+		let mut backed_blocks =
+			Self::backed_block_hashes(&relay_chain_interface, relay_chain_best_hash, para_id)
+				.await?;
+
+		let head_hash = HeadData(header.encode()).hash();
+
+		if backed_blocks.any(|block_hash| block_hash == head_hash) {
 			tracing::debug!(target: LOG_TARGET, "Announced block matches latest backed block.",);
 
 			Ok(Validation::Success { is_new_best: true })
diff --git a/cumulus/client/network/src/tests.rs b/cumulus/client/network/src/tests.rs
index 3f5757d5eac13cd751a89e77545a937b3223c9a0..eb0d7f0e01b391279648a5aea6031a275cf409a5 100644
--- a/cumulus/client/network/src/tests.rs
+++ b/cumulus/client/network/src/tests.rs
@@ -34,6 +34,7 @@ use polkadot_test_client::{
 	Client as PClient, ClientBlockImportExt, DefaultTestClientBuilderExt, FullBackend as PBackend,
 	InitPolkadotBlockBuilder, TestClientBuilder, TestClientBuilderExt,
 };
+use rstest::rstest;
 use sc_client_api::{Backend, BlockchainEvents};
 use sp_blockchain::HeaderBackend;
 use sp_consensus::BlockOrigin;
@@ -42,7 +43,8 @@ use sp_keyring::Sr25519Keyring;
 use sp_keystore::{testing::MemoryKeystore, Keystore, KeystorePtr};
 use sp_runtime::RuntimeAppPublic;
 use sp_state_machine::StorageValue;
-use std::{collections::BTreeMap, time::Duration};
+use sp_version::RuntimeVersion;
+use std::{borrow::Cow, collections::BTreeMap, time::Duration};
 
 fn check_error(error: crate::BoxedError, check_error: impl Fn(&BlockAnnounceError) -> bool) {
 	let error = *error
@@ -53,6 +55,33 @@ fn check_error(error: crate::BoxedError, check_error: impl Fn(&BlockAnnounceErro
 	}
 }
 
+fn dummy_candidate() -> CommittedCandidateReceipt {
+	CommittedCandidateReceipt {
+		descriptor: CandidateDescriptor {
+			para_head: polkadot_parachain_primitives::primitives::HeadData(
+				default_header().encode(),
+			)
+			.hash(),
+			para_id: 0u32.into(),
+			relay_parent: PHash::random(),
+			collator: CollatorPair::generate().0.public(),
+			persisted_validation_data_hash: PHash::random(),
+			pov_hash: PHash::random(),
+			erasure_root: PHash::random(),
+			signature: sp_core::sr25519::Signature::default().into(),
+			validation_code_hash: ValidationCodeHash::from(PHash::random()),
+		},
+		commitments: CandidateCommitments {
+			upward_messages: Default::default(),
+			horizontal_messages: Default::default(),
+			new_validation_code: None,
+			head_data: HeadData(Vec::new()),
+			processed_downward_messages: 0,
+			hrmp_watermark: 0,
+		},
+	}
+}
+
 #[derive(Clone)]
 struct DummyRelayChainInterface {
 	data: Arc<Mutex<ApiData>>,
@@ -69,6 +98,8 @@ impl DummyRelayChainInterface {
 			data: Arc::new(Mutex::new(ApiData {
 				validators: vec![Sr25519Keyring::Alice.public().into()],
 				has_pending_availability: false,
+				runtime_version:
+					RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT,
 			})),
 			relay_client: Arc::new(builder.build()),
 			relay_backend,
@@ -131,36 +162,37 @@ impl RelayChainInterface for DummyRelayChainInterface {
 		_: PHash,
 		_: ParaId,
 	) -> RelayChainResult<Option<CommittedCandidateReceipt>> {
+		if self.data.lock().runtime_version >=
+			RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT
+		{
+			panic!("Should have used candidates_pending_availability instead");
+		}
+
 		if self.data.lock().has_pending_availability {
-			Ok(Some(CommittedCandidateReceipt {
-				descriptor: CandidateDescriptor {
-					para_head: polkadot_parachain_primitives::primitives::HeadData(
-						default_header().encode(),
-					)
-					.hash(),
-					para_id: 0u32.into(),
-					relay_parent: PHash::random(),
-					collator: CollatorPair::generate().0.public(),
-					persisted_validation_data_hash: PHash::random(),
-					pov_hash: PHash::random(),
-					erasure_root: PHash::random(),
-					signature: sp_core::sr25519::Signature::default().into(),
-					validation_code_hash: ValidationCodeHash::from(PHash::random()),
-				},
-				commitments: CandidateCommitments {
-					upward_messages: Default::default(),
-					horizontal_messages: Default::default(),
-					new_validation_code: None,
-					head_data: HeadData(Vec::new()),
-					processed_downward_messages: 0,
-					hrmp_watermark: 0,
-				},
-			}))
+			Ok(Some(dummy_candidate()))
 		} else {
 			Ok(None)
 		}
 	}
 
+	async fn candidates_pending_availability(
+		&self,
+		_: PHash,
+		_: ParaId,
+	) -> RelayChainResult<Vec<CommittedCandidateReceipt>> {
+		if self.data.lock().runtime_version <
+			RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT
+		{
+			panic!("Should have used candidate_pending_availability instead");
+		}
+
+		if self.data.lock().has_pending_availability {
+			Ok(vec![dummy_candidate()])
+		} else {
+			Ok(vec![])
+		}
+	}
+
 	async fn session_index_for_child(&self, _: PHash) -> RelayChainResult<SessionIndex> {
 		Ok(0)
 	}
@@ -264,6 +296,28 @@ impl RelayChainInterface for DummyRelayChainInterface {
 
 		Ok(header)
 	}
+
+	async fn version(&self, _: PHash) -> RelayChainResult<RuntimeVersion> {
+		let version = self.data.lock().runtime_version;
+
+		let apis = sp_version::create_apis_vec!([(
+			<dyn polkadot_primitives::runtime_api::ParachainHost<polkadot_primitives::Block>>::ID,
+			version
+		)])
+		.into_owned()
+		.to_vec();
+
+		Ok(RuntimeVersion {
+			spec_name: sp_version::create_runtime_str!("test"),
+			impl_name: sp_version::create_runtime_str!("test"),
+			authoring_version: 1,
+			spec_version: 1,
+			impl_version: 0,
+			apis: Cow::Owned(apis),
+			transaction_version: 5,
+			state_version: 1,
+		})
+	}
 }
 
 fn make_validator_and_api() -> (
@@ -574,11 +628,14 @@ fn relay_parent_not_imported_when_block_announce_is_processed() {
 
 /// Ensures that when we receive a block announcement without a statement included, while the block
 /// is not yet included by the node checking the announcement, but the node is already backed.
-#[test]
-fn block_announced_without_statement_and_block_only_backed() {
+#[rstest]
+#[case(RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT)]
+#[case(10)]
+fn block_announced_without_statement_and_block_only_backed(#[case] runtime_version: u32) {
 	block_on(async move {
 		let (mut validator, api) = make_validator_and_api();
 		api.data.lock().has_pending_availability = true;
+		api.data.lock().runtime_version = runtime_version;
 
 		let header = default_header();
 
@@ -592,4 +649,5 @@ fn block_announced_without_statement_and_block_only_backed() {
 struct ApiData {
 	validators: Vec<ValidatorId>,
 	has_pending_availability: bool,
+	runtime_version: u32,
 }
diff --git a/cumulus/client/parachain-inherent/src/mock.rs b/cumulus/client/parachain-inherent/src/mock.rs
index 896df7a724253993867fb30f3f225220b9b26137..dfe4a66c3dc19665d413fed47434d803d6ed63af 100644
--- a/cumulus/client/parachain-inherent/src/mock.rs
+++ b/cumulus/client/parachain-inherent/src/mock.rs
@@ -46,12 +46,14 @@ pub const RELAY_CHAIN_SLOT_DURATION_MILLIS: u32 = 6000;
 /// your parachain's configuration in order to mock the MQC heads properly.
 /// See [`MockXcmConfig`] for more information
 pub struct MockValidationDataInherentDataProvider<R = ()> {
-	/// The current block number of the local block chain (the parachain)
+	/// The current block number of the local block chain (the parachain).
 	pub current_para_block: u32,
-	/// The current block head data of the local block chain (the parachain)
+	/// The parachain ID of the parachain for that the inherent data is created.
+	pub para_id: ParaId,
+	/// The current block head data of the local block chain (the parachain).
 	pub current_para_block_head: Option<cumulus_primitives_core::relay_chain::HeadData>,
 	/// The relay block in which this parachain appeared to start. This will be the relay block
-	/// number in para block #P1
+	/// number in para block #P1.
 	pub relay_offset: u32,
 	/// The number of relay blocks that elapses between each parablock. Probably set this to 1 or 2
 	/// to simulate optimistic or realistic relay chain behavior.
@@ -59,19 +61,21 @@ pub struct MockValidationDataInherentDataProvider<R = ()> {
 	/// Number of parachain blocks per relay chain epoch
 	/// Mock epoch is computed by dividing `current_para_block` by this value.
 	pub para_blocks_per_relay_epoch: u32,
-	/// Function to mock BABE one epoch ago randomness
+	/// Function to mock BABE one epoch ago randomness.
 	pub relay_randomness_config: R,
 	/// XCM messages and associated configuration information.
 	pub xcm_config: MockXcmConfig,
 	/// Inbound downward XCM messages to be injected into the block.
 	pub raw_downward_messages: Vec<Vec<u8>>,
-	// Inbound Horizontal messages sorted by channel
+	// Inbound Horizontal messages sorted by channel.
 	pub raw_horizontal_messages: Vec<(ParaId, Vec<u8>)>,
 	// Additional key-value pairs that should be injected.
 	pub additional_key_values: Option<Vec<(Vec<u8>, Vec<u8>)>>,
 }
 
+/// Something that can generate randomness.
 pub trait GenerateRandomness<I> {
+	/// Generate the randomness using the given `input`.
 	fn generate_randomness(&self, input: I) -> relay_chain::Hash;
 }
 
@@ -91,8 +95,6 @@ impl GenerateRandomness<u64> for () {
 /// parachain's storage, and the corresponding relay data mocked.
 #[derive(Default)]
 pub struct MockXcmConfig {
-	/// The parachain id of the parachain being mocked.
-	pub para_id: ParaId,
 	/// The starting state of the dmq_mqc_head.
 	pub starting_dmq_mqc_head: relay_chain::Hash,
 	/// The starting state of each parachain's mqc head
@@ -119,7 +121,6 @@ impl MockXcmConfig {
 	pub fn new<B: Block, BE: Backend<B>, C: StorageProvider<B, BE>>(
 		client: &C,
 		parent_block: B::Hash,
-		para_id: ParaId,
 		parachain_system_name: ParachainSystemName,
 	) -> Self {
 		let starting_dmq_mqc_head = client
@@ -152,7 +153,7 @@ impl MockXcmConfig {
 			})
 			.unwrap_or_default();
 
-		Self { para_id, starting_dmq_mqc_head, starting_hrmp_mqc_heads }
+		Self { starting_dmq_mqc_head, starting_hrmp_mqc_heads }
 	}
 }
 
@@ -166,7 +167,7 @@ impl<R: Send + Sync + GenerateRandomness<u64>> InherentDataProvider
 	) -> Result<(), sp_inherents::Error> {
 		// Use the "sproof" (spoof proof) builder to build valid mock state root and proof.
 		let mut sproof_builder =
-			RelayStateSproofBuilder { para_id: self.xcm_config.para_id, ..Default::default() };
+			RelayStateSproofBuilder { para_id: self.para_id, ..Default::default() };
 
 		// Calculate the mocked relay block based on the current para block
 		let relay_parent_number =
diff --git a/cumulus/client/pov-recovery/Cargo.toml b/cumulus/client/pov-recovery/Cargo.toml
index 7afe7fae34bd799ed75d557ad5f0ca5067743f7f..539802d6938663e1268e887c17f505d23c72c1c3 100644
--- a/cumulus/client/pov-recovery/Cargo.toml
+++ b/cumulus/client/pov-recovery/Cargo.toml
@@ -22,6 +22,8 @@ sc-consensus = { path = "../../../substrate/client/consensus/common" }
 sp-consensus = { path = "../../../substrate/primitives/consensus/common" }
 sp-maybe-compressed-blob = { path = "../../../substrate/primitives/maybe-compressed-blob" }
 sp-runtime = { path = "../../../substrate/primitives/runtime" }
+sp-api = { path = "../../../substrate/primitives/api" }
+sp-version = { path = "../../../substrate/primitives/version" }
 
 # Polkadot
 polkadot-node-primitives = { path = "../../../polkadot/node/primitives" }
@@ -35,8 +37,14 @@ cumulus-relay-chain-interface = { path = "../relay-chain-interface" }
 async-trait = "0.1.79"
 
 [dev-dependencies]
+rstest = "0.18.2"
 tokio = { version = "1.32.0", features = ["macros"] }
 portpicker = "0.1.1"
+sp-blockchain = { path = "../../../substrate/primitives/blockchain" }
+cumulus-test-client = { path = "../../test/client" }
+sc-utils = { path = "../../../substrate/client/utils" }
+sp-tracing = { path = "../../../substrate/primitives/tracing" }
+assert_matches = "1.5"
 
 # Cumulus
 cumulus-test-service = { path = "../../test/service" }
diff --git a/cumulus/client/pov-recovery/src/active_candidate_recovery.rs b/cumulus/client/pov-recovery/src/active_candidate_recovery.rs
index 2c635320ff4ae6f68f33bb9da5ca545098851f65..50de98909ea471ea3de39a9edd85f4f9d71a8b3b 100644
--- a/cumulus/client/pov-recovery/src/active_candidate_recovery.rs
+++ b/cumulus/client/pov-recovery/src/active_candidate_recovery.rs
@@ -21,7 +21,7 @@ use polkadot_node_subsystem::messages::AvailabilityRecoveryMessage;
 
 use futures::{channel::oneshot, stream::FuturesUnordered, Future, FutureExt, StreamExt};
 
-use std::{collections::HashSet, pin::Pin, sync::Arc};
+use std::{pin::Pin, sync::Arc};
 
 use crate::RecoveryHandle;
 
@@ -32,14 +32,12 @@ pub(crate) struct ActiveCandidateRecovery<Block: BlockT> {
 	/// The recoveries that are currently being executed.
 	recoveries:
 		FuturesUnordered<Pin<Box<dyn Future<Output = (Block::Hash, Option<Arc<PoV>>)> + Send>>>,
-	/// The block hashes of the candidates currently being recovered.
-	candidates: HashSet<Block::Hash>,
 	recovery_handle: Box<dyn RecoveryHandle>,
 }
 
 impl<Block: BlockT> ActiveCandidateRecovery<Block> {
 	pub fn new(recovery_handle: Box<dyn RecoveryHandle>) -> Self {
-		Self { recoveries: Default::default(), candidates: Default::default(), recovery_handle }
+		Self { recoveries: Default::default(), recovery_handle }
 	}
 
 	/// Recover the given `candidate`.
@@ -56,14 +54,13 @@ impl<Block: BlockT> ActiveCandidateRecovery<Block> {
 					candidate.receipt.clone(),
 					candidate.session_index,
 					None,
+					None,
 					tx,
 				),
 				"ActiveCandidateRecovery",
 			)
 			.await;
 
-		self.candidates.insert(block_hash);
-
 		self.recoveries.push(
 			async move {
 				match rx.await {
@@ -96,7 +93,6 @@ impl<Block: BlockT> ActiveCandidateRecovery<Block> {
 	pub async fn wait_for_recovery(&mut self) -> (Block::Hash, Option<Arc<PoV>>) {
 		loop {
 			if let Some(res) = self.recoveries.next().await {
-				self.candidates.remove(&res.0);
 				return res
 			} else {
 				futures::pending!()
diff --git a/cumulus/client/pov-recovery/src/lib.rs b/cumulus/client/pov-recovery/src/lib.rs
index 0ca21749c3eb557a78f0996c703e86b35cab6f17..6ace18155e871d40baa2662c8c13b605b5768bbe 100644
--- a/cumulus/client/pov-recovery/src/lib.rs
+++ b/cumulus/client/pov-recovery/src/lib.rs
@@ -48,11 +48,12 @@
 
 use sc_client_api::{BlockBackend, BlockchainEvents, UsageProvider};
 use sc_consensus::import_queue::{ImportQueueService, IncomingBlock};
+use sp_api::RuntimeApiInfo;
 use sp_consensus::{BlockOrigin, BlockStatus, SyncOracle};
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
 
 use polkadot_node_primitives::{PoV, POV_BOMB_LIMIT};
-use polkadot_node_subsystem::messages::AvailabilityRecoveryMessage;
+use polkadot_node_subsystem::messages::{AvailabilityRecoveryMessage, RuntimeApiRequest};
 use polkadot_overseer::Handle as OverseerHandle;
 use polkadot_primitives::{
 	CandidateReceipt, CommittedCandidateReceipt, Id as ParaId, SessionIndex,
@@ -75,6 +76,9 @@ use std::{
 	time::Duration,
 };
 
+#[cfg(test)]
+mod tests;
+
 mod active_candidate_recovery;
 use active_candidate_recovery::ActiveCandidateRecovery;
 
@@ -544,7 +548,7 @@ where
 		)
 		.await
 		{
-			Ok(pending_candidate_stream) => pending_candidate_stream.fuse(),
+			Ok(pending_candidates_stream) => pending_candidates_stream.fuse(),
 			Err(err) => {
 				tracing::error!(target: LOG_TARGET, error = ?err, "Unable to retrieve pending candidate stream.");
 				return
@@ -554,9 +558,11 @@ where
 		futures::pin_mut!(pending_candidates);
 		loop {
 			select! {
-				pending_candidate = pending_candidates.next() => {
-					if let Some((receipt, session_index)) = pending_candidate {
-						self.handle_pending_candidate(receipt, session_index);
+				next_pending_candidates = pending_candidates.next() => {
+					if let Some((candidates, session_index)) = next_pending_candidates {
+						for candidate in candidates {
+							self.handle_pending_candidate(candidate, session_index);
+						}
 					} else {
 						tracing::debug!(target: LOG_TARGET, "Pending candidates stream ended");
 						return;
@@ -615,7 +621,7 @@ async fn pending_candidates(
 	relay_chain_client: impl RelayChainInterface + Clone,
 	para_id: ParaId,
 	sync_service: Arc<dyn SyncOracle + Sync + Send>,
-) -> RelayChainResult<impl Stream<Item = (CommittedCandidateReceipt, SessionIndex)>> {
+) -> RelayChainResult<impl Stream<Item = (Vec<CommittedCandidateReceipt>, SessionIndex)>> {
 	let import_notification_stream = relay_chain_client.import_notification_stream().await?;
 
 	let filtered_stream = import_notification_stream.filter_map(move |n| {
@@ -632,16 +638,54 @@ async fn pending_candidates(
 				return None
 			}
 
-			let pending_availability_result = client_for_closure
-				.candidate_pending_availability(hash, para_id)
+			let runtime_api_version = client_for_closure
+				.version(hash)
 				.await
 				.map_err(|e| {
 					tracing::error!(
 						target: LOG_TARGET,
 						error = ?e,
-						"Failed to fetch pending candidates.",
+						"Failed to fetch relay chain runtime version.",
 					)
-				});
+				})
+				.ok()?;
+			let parachain_host_runtime_api_version = runtime_api_version
+				.api_version(
+					&<dyn polkadot_primitives::runtime_api::ParachainHost<
+						polkadot_primitives::Block,
+					>>::ID,
+				)
+				.unwrap_or_default();
+
+			// If the relay chain runtime does not support the new runtime API, fallback to the
+			// deprecated one.
+			let pending_availability_result = if parachain_host_runtime_api_version <
+				RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT
+			{
+				#[allow(deprecated)]
+				client_for_closure
+					.candidate_pending_availability(hash, para_id)
+					.await
+					.map_err(|e| {
+						tracing::error!(
+							target: LOG_TARGET,
+							error = ?e,
+							"Failed to fetch pending candidates.",
+						)
+					})
+					.map(|candidate| candidate.into_iter().collect::<Vec<_>>())
+			} else {
+				client_for_closure.candidates_pending_availability(hash, para_id).await.map_err(
+					|e| {
+						tracing::error!(
+							target: LOG_TARGET,
+							error = ?e,
+							"Failed to fetch pending candidates.",
+						)
+					},
+				)
+			};
+
 			let session_index_result =
 				client_for_closure.session_index_for_child(hash).await.map_err(|e| {
 					tracing::error!(
@@ -651,8 +695,8 @@ async fn pending_candidates(
 					)
 				});
 
-			if let Ok(Some(candidate)) = pending_availability_result {
-				session_index_result.map(|session_index| (candidate, session_index)).ok()
+			if let Ok(candidates) = pending_availability_result {
+				session_index_result.map(|session_index| (candidates, session_index)).ok()
 			} else {
 				None
 			}
diff --git a/cumulus/client/pov-recovery/src/tests.rs b/cumulus/client/pov-recovery/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..75bf308ef27aa051e42806b7f65e7ab8b45a9c1a
--- /dev/null
+++ b/cumulus/client/pov-recovery/src/tests.rs
@@ -0,0 +1,1404 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use super::*;
+use assert_matches::assert_matches;
+use codec::{Decode, Encode};
+use cumulus_primitives_core::relay_chain::{BlockId, CandidateCommitments, CandidateDescriptor};
+use cumulus_relay_chain_interface::{
+	InboundDownwardMessage, InboundHrmpMessage, OccupiedCoreAssumption, PHash, PHeader,
+	PersistedValidationData, StorageValue, ValidationCodeHash, ValidatorId,
+};
+use cumulus_test_client::{
+	runtime::{Block, Header},
+	Sr25519Keyring,
+};
+use futures::{channel::mpsc, SinkExt};
+use polkadot_node_primitives::AvailableData;
+use polkadot_node_subsystem::{messages::AvailabilityRecoveryMessage, RecoveryError, TimeoutExt};
+use rstest::rstest;
+use sc_client_api::{
+	BlockImportNotification, ClientInfo, CompactProof, FinalityNotification, FinalityNotifications,
+	FinalizeSummary, ImportNotifications, StorageEventStream, StorageKey,
+};
+use sc_consensus::import_queue::RuntimeOrigin;
+use sc_utils::mpsc::{TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_blockchain::Info;
+use sp_runtime::{generic::SignedBlock, Justifications};
+use sp_version::RuntimeVersion;
+use std::{
+	borrow::Cow,
+	collections::BTreeMap,
+	ops::Range,
+	sync::{Arc, Mutex},
+};
+use tokio::task;
+
+const GENESIS_HASH: PHash = PHash::zero();
+const TEST_SESSION_INDEX: SessionIndex = 0;
+
+struct AvailabilityRecoverySubsystemHandle {
+	tx: mpsc::Sender<AvailabilityRecoveryMessage>,
+}
+
+impl AvailabilityRecoverySubsystemHandle {
+	fn new() -> (Self, mpsc::Receiver<AvailabilityRecoveryMessage>) {
+		let (tx, rx) = mpsc::channel(10);
+
+		(Self { tx }, rx)
+	}
+}
+
+#[async_trait::async_trait]
+impl RecoveryHandle for AvailabilityRecoverySubsystemHandle {
+	async fn send_recovery_msg(
+		&mut self,
+		message: AvailabilityRecoveryMessage,
+		_origin: &'static str,
+	) {
+		self.tx.send(message).await.expect("Receiver dropped");
+	}
+}
+
+struct ParachainClientInner<Block: BlockT> {
+	import_notifications_rx: Option<TracingUnboundedReceiver<BlockImportNotification<Block>>>,
+	finality_notifications_rx: Option<TracingUnboundedReceiver<FinalityNotification<Block>>>,
+	usage_infos: Vec<ClientInfo<Block>>,
+	block_statuses: Arc<Mutex<HashMap<Block::Hash, BlockStatus>>>,
+}
+
+impl<Block: BlockT> ParachainClientInner<Block> {
+	fn new(
+		usage_infos: Vec<ClientInfo<Block>>,
+		block_statuses: Arc<Mutex<HashMap<Block::Hash, BlockStatus>>>,
+	) -> (
+		Self,
+		TracingUnboundedSender<BlockImportNotification<Block>>,
+		TracingUnboundedSender<FinalityNotification<Block>>,
+	) {
+		let (import_notifications_tx, import_notifications_rx) =
+			sc_utils::mpsc::tracing_unbounded("import_notif", 10);
+		let (finality_notifications_tx, finality_notifications_rx) =
+			sc_utils::mpsc::tracing_unbounded("finality_notif", 10);
+		(
+			Self {
+				import_notifications_rx: Some(import_notifications_rx),
+				finality_notifications_rx: Some(finality_notifications_rx),
+				usage_infos,
+				block_statuses,
+			},
+			import_notifications_tx,
+			finality_notifications_tx,
+		)
+	}
+}
+struct ParachainClient<Block: BlockT> {
+	inner: Arc<Mutex<ParachainClientInner<Block>>>,
+}
+
+impl<Block: BlockT> ParachainClient<Block> {
+	fn new(
+		usage_infos: Vec<ClientInfo<Block>>,
+		block_statuses: Arc<Mutex<HashMap<Block::Hash, BlockStatus>>>,
+	) -> (
+		Self,
+		TracingUnboundedSender<BlockImportNotification<Block>>,
+		TracingUnboundedSender<FinalityNotification<Block>>,
+	) {
+		let (inner, import_notifications_tx, finality_notifications_tx) =
+			ParachainClientInner::new(usage_infos, block_statuses);
+		(
+			Self { inner: Arc::new(Mutex::new(inner)) },
+			import_notifications_tx,
+			finality_notifications_tx,
+		)
+	}
+}
+
+impl<Block: BlockT> BlockchainEvents<Block> for ParachainClient<Block> {
+	fn import_notification_stream(&self) -> ImportNotifications<Block> {
+		self.inner
+			.lock()
+			.expect("poisoned lock")
+			.import_notifications_rx
+			.take()
+			.expect("Should only be taken once")
+	}
+
+	fn every_import_notification_stream(&self) -> ImportNotifications<Block> {
+		unimplemented!()
+	}
+
+	fn finality_notification_stream(&self) -> FinalityNotifications<Block> {
+		self.inner
+			.lock()
+			.expect("poisoned lock")
+			.finality_notifications_rx
+			.take()
+			.expect("Should only be taken once")
+	}
+
+	fn storage_changes_notification_stream(
+		&self,
+		_filter_keys: Option<&[StorageKey]>,
+		_child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+	) -> sp_blockchain::Result<StorageEventStream<Block::Hash>> {
+		unimplemented!()
+	}
+}
+
+impl<Block: BlockT> BlockBackend<Block> for ParachainClient<Block> {
+	fn block_body(
+		&self,
+		_: Block::Hash,
+	) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
+		unimplemented!()
+	}
+
+	fn block(&self, _: Block::Hash) -> sp_blockchain::Result<Option<SignedBlock<Block>>> {
+		unimplemented!()
+	}
+
+	fn block_status(&self, hash: Block::Hash) -> sp_blockchain::Result<sp_consensus::BlockStatus> {
+		Ok(self
+			.inner
+			.lock()
+			.expect("Poisoned lock")
+			.block_statuses
+			.lock()
+			.expect("Poisoned lock")
+			.get(&hash)
+			.cloned()
+			.unwrap_or(BlockStatus::Unknown))
+	}
+
+	fn justifications(&self, _: Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
+		unimplemented!()
+	}
+
+	fn block_hash(&self, _: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>> {
+		unimplemented!()
+	}
+
+	fn indexed_transaction(&self, _: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		unimplemented!()
+	}
+
+	fn has_indexed_transaction(&self, _: Block::Hash) -> sp_blockchain::Result<bool> {
+		unimplemented!()
+	}
+
+	fn block_indexed_body(&self, _: Block::Hash) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>> {
+		unimplemented!()
+	}
+
+	fn requires_full_sync(&self) -> bool {
+		unimplemented!()
+	}
+}
+
+impl<Block: BlockT> UsageProvider<Block> for ParachainClient<Block> {
+	fn usage_info(&self) -> ClientInfo<Block> {
+		let infos = &mut self.inner.lock().expect("Poisoned lock").usage_infos;
+		assert!(!infos.is_empty());
+
+		if infos.len() == 1 {
+			infos.last().unwrap().clone()
+		} else {
+			infos.remove(0)
+		}
+	}
+}
+
+struct ParachainImportQueue<Block: BlockT> {
+	import_requests_tx: TracingUnboundedSender<Vec<IncomingBlock<Block>>>,
+}
+
+impl<Block: BlockT> ParachainImportQueue<Block> {
+	fn new() -> (Self, TracingUnboundedReceiver<Vec<IncomingBlock<Block>>>) {
+		let (import_requests_tx, import_requests_rx) =
+			sc_utils::mpsc::tracing_unbounded("test_import_req_forwarding", 10);
+		(Self { import_requests_tx }, import_requests_rx)
+	}
+}
+
+impl<Block: BlockT> ImportQueueService<Block> for ParachainImportQueue<Block> {
+	fn import_blocks(&mut self, origin: BlockOrigin, blocks: Vec<IncomingBlock<Block>>) {
+		assert_matches!(origin, BlockOrigin::ConsensusBroadcast);
+		self.import_requests_tx.unbounded_send(blocks).unwrap();
+	}
+
+	fn import_justifications(
+		&mut self,
+		_: RuntimeOrigin,
+		_: Block::Hash,
+		_: NumberFor<Block>,
+		_: Justifications,
+	) {
+		unimplemented!()
+	}
+}
+
+#[derive(Default)]
+struct DummySyncOracle {
+	is_major_syncing: bool,
+}
+
+impl DummySyncOracle {
+	fn new(is_major_syncing: bool) -> Self {
+		Self { is_major_syncing }
+	}
+}
+
+impl SyncOracle for DummySyncOracle {
+	fn is_major_syncing(&self) -> bool {
+		self.is_major_syncing
+	}
+
+	fn is_offline(&self) -> bool {
+		false
+	}
+}
+
+#[derive(Clone)]
+struct RelaychainInner {
+	runtime_version: u32,
+	import_notifications: Vec<PHeader>,
+	candidates_pending_availability: HashMap<PHash, Vec<CommittedCandidateReceipt>>,
+}
+
+#[derive(Clone)]
+struct Relaychain {
+	inner: Arc<Mutex<RelaychainInner>>,
+}
+
+impl Relaychain {
+	fn new(relay_chain_blocks: Vec<(PHeader, Vec<CommittedCandidateReceipt>)>) -> Self {
+		let (candidates_pending_availability, import_notifications) = relay_chain_blocks
+			.into_iter()
+			.map(|(header, receipt)| ((header.hash(), receipt), header))
+			.unzip();
+		Self {
+			inner: Arc::new(Mutex::new(RelaychainInner {
+				import_notifications,
+				candidates_pending_availability,
+				// The version that introduced candidates_pending_availability
+				runtime_version:
+					RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT,
+			})),
+		}
+	}
+
+	fn set_runtime_version(&self, version: u32) {
+		self.inner.lock().expect("Poisoned lock").runtime_version = version;
+	}
+}
+
+#[async_trait::async_trait]
+impl RelayChainInterface for Relaychain {
+	async fn version(&self, _: PHash) -> RelayChainResult<RuntimeVersion> {
+		let version = self.inner.lock().expect("Poisoned lock").runtime_version;
+
+		let apis = sp_version::create_apis_vec!([(
+			<dyn polkadot_primitives::runtime_api::ParachainHost<polkadot_primitives::Block>>::ID,
+			version
+		)])
+		.into_owned()
+		.to_vec();
+
+		Ok(RuntimeVersion {
+			spec_name: sp_version::create_runtime_str!("test"),
+			impl_name: sp_version::create_runtime_str!("test"),
+			authoring_version: 1,
+			spec_version: 1,
+			impl_version: 0,
+			apis: Cow::Owned(apis),
+			transaction_version: 5,
+			state_version: 1,
+		})
+	}
+
+	async fn validators(&self, _: PHash) -> RelayChainResult<Vec<ValidatorId>> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn best_block_hash(&self) -> RelayChainResult<PHash> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn finalized_block_hash(&self) -> RelayChainResult<PHash> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn retrieve_dmq_contents(
+		&self,
+		_: ParaId,
+		_: PHash,
+	) -> RelayChainResult<Vec<InboundDownwardMessage>> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn retrieve_all_inbound_hrmp_channel_contents(
+		&self,
+		_: ParaId,
+		_: PHash,
+	) -> RelayChainResult<BTreeMap<ParaId, Vec<InboundHrmpMessage>>> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn persisted_validation_data(
+		&self,
+		_: PHash,
+		_: ParaId,
+		_: OccupiedCoreAssumption,
+	) -> RelayChainResult<Option<PersistedValidationData>> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn validation_code_hash(
+		&self,
+		_: PHash,
+		_: ParaId,
+		_: OccupiedCoreAssumption,
+	) -> RelayChainResult<Option<ValidationCodeHash>> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn candidate_pending_availability(
+		&self,
+		hash: PHash,
+		_: ParaId,
+	) -> RelayChainResult<Option<CommittedCandidateReceipt>> {
+		if self.inner.lock().expect("Poisoned lock").runtime_version >=
+			RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT
+		{
+			panic!("Should have used candidates_pending_availability instead");
+		}
+
+		Ok(self
+			.inner
+			.lock()
+			.expect("Poisoned lock")
+			.candidates_pending_availability
+			.remove(&hash)
+			.map(|mut c| {
+				assert_eq!(c.len(), 1);
+				c.pop().unwrap()
+			}))
+	}
+
+	async fn candidates_pending_availability(
+		&self,
+		hash: PHash,
+		_: ParaId,
+	) -> RelayChainResult<Vec<CommittedCandidateReceipt>> {
+		if self.inner.lock().expect("Poisoned lock").runtime_version <
+			RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT
+		{
+			panic!("Should have used candidate_pending_availability instead");
+		}
+
+		Ok(self
+			.inner
+			.lock()
+			.expect("Poisoned lock")
+			.candidates_pending_availability
+			.remove(&hash)
+			.expect("Not found"))
+	}
+
+	async fn session_index_for_child(&self, _: PHash) -> RelayChainResult<SessionIndex> {
+		Ok(TEST_SESSION_INDEX)
+	}
+
+	async fn import_notification_stream(
+		&self,
+	) -> RelayChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {
+		Ok(Box::pin(
+			futures::stream::iter(std::mem::take(
+				&mut self.inner.lock().expect("Poisoned lock").import_notifications,
+			))
+			.chain(futures::stream::pending()),
+		))
+	}
+
+	async fn finality_notification_stream(
+		&self,
+	) -> RelayChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn is_major_syncing(&self) -> RelayChainResult<bool> {
+		unimplemented!("Not needed for test");
+	}
+
+	fn overseer_handle(&self) -> RelayChainResult<OverseerHandle> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn get_storage_by_key(
+		&self,
+		_: PHash,
+		_: &[u8],
+	) -> RelayChainResult<Option<StorageValue>> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn prove_read(
+		&self,
+		_: PHash,
+		_: &Vec<Vec<u8>>,
+	) -> RelayChainResult<sc_client_api::StorageProof> {
+		unimplemented!("Not needed for test")
+	}
+
+	async fn wait_for_block(&self, _: PHash) -> RelayChainResult<()> {
+		unimplemented!("Not needed for test");
+	}
+
+	async fn new_best_notification_stream(
+		&self,
+	) -> RelayChainResult<Pin<Box<dyn Stream<Item = PHeader> + Send>>> {
+		unimplemented!("Not needed for test");
+	}
+
+	async fn header(&self, _: BlockId) -> RelayChainResult<Option<PHeader>> {
+		unimplemented!("Not needed for test");
+	}
+}
+
+fn make_candidate_chain(candidate_number_range: Range<u32>) -> Vec<CommittedCandidateReceipt> {
+	let collator = Sr25519Keyring::Ferdie;
+	let mut latest_parent_hash = GENESIS_HASH;
+	let mut candidates = vec![];
+
+	for number in candidate_number_range {
+		let head_data = Header {
+			number,
+			digest: Default::default(),
+			extrinsics_root: Default::default(),
+			parent_hash: latest_parent_hash,
+			state_root: Default::default(),
+		};
+
+		latest_parent_hash = head_data.hash();
+
+		candidates.push(CommittedCandidateReceipt {
+			descriptor: CandidateDescriptor {
+				para_id: ParaId::from(1000),
+				relay_parent: PHash::zero(),
+				collator: collator.public().into(),
+				persisted_validation_data_hash: PHash::zero(),
+				pov_hash: PHash::zero(),
+				erasure_root: PHash::zero(),
+				signature: collator.sign(&[0u8; 132]).into(),
+				para_head: PHash::zero(),
+				validation_code_hash: PHash::zero().into(),
+			},
+			commitments: CandidateCommitments {
+				head_data: head_data.encode().into(),
+				upward_messages: vec![].try_into().expect("empty vec fits within bounds"),
+				new_validation_code: None,
+				horizontal_messages: vec![].try_into().expect("empty vec fits within bounds"),
+				processed_downward_messages: 0,
+				hrmp_watermark: 0_u32,
+			},
+		});
+	}
+
+	candidates
+}
+
+fn dummy_usage_info(finalized_number: u32) -> ClientInfo<Block> {
+	ClientInfo {
+		chain: Info {
+			best_hash: PHash::zero(),
+			best_number: 0,
+			genesis_hash: PHash::zero(),
+			finalized_hash: PHash::zero(),
+			// Only this field is being used.
+			finalized_number,
+			finalized_state: None,
+			number_leaves: 0,
+			block_gap: None,
+		},
+		usage: None,
+	}
+}
+
+fn dummy_pvd() -> PersistedValidationData {
+	PersistedValidationData {
+		parent_head: vec![].into(),
+		relay_parent_number: 1,
+		relay_parent_storage_root: PHash::zero(),
+		max_pov_size: 100,
+	}
+}
+
+#[tokio::test]
+async fn pending_candidate_height_lower_than_latest_finalized() {
+	sp_tracing::init_for_tests();
+
+	for finalized_number in [3, 4, 5] {
+		let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+			AvailabilityRecoverySubsystemHandle::new();
+		let recovery_delay_range =
+			RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+		let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+		let candidates = make_candidate_chain(1..4);
+		let relay_chain_client = Relaychain::new(vec![(
+			PHeader {
+				parent_hash: PHash::from_low_u64_be(0),
+				number: 1,
+				state_root: PHash::random(),
+				extrinsics_root: PHash::random(),
+				digest: Default::default(),
+			},
+			candidates,
+		)]);
+		let (parachain_client, _import_notifications_tx, _finality_notifications_tx) =
+			ParachainClient::new(vec![dummy_usage_info(finalized_number)], Default::default());
+		let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+		// If the latest finalized block has a larger height compared to the pending candidate, the
+		// new candidate won't be recovered. Candidates have heights is 1, 2 and 3. Latest finalized
+		// block is 3, 4 or 5.
+		let pov_recovery = PoVRecovery::<Block, _, _>::new(
+			Box::new(recovery_subsystem_tx),
+			recovery_delay_range,
+			Arc::new(parachain_client),
+			Box::new(parachain_import_queue),
+			relay_chain_client,
+			ParaId::new(1000),
+			explicit_recovery_chan_rx,
+			Arc::new(DummySyncOracle::default()),
+		);
+
+		task::spawn(pov_recovery.run());
+
+		// No recovery message received
+		assert_matches!(
+			recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await,
+			None
+		);
+
+		// No import request received
+		assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+	}
+}
+
+#[rstest]
+#[case(RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT)]
+#[case(10)]
+#[tokio::test]
+async fn single_pending_candidate_recovery_success(#[case] runtime_version: u32) {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..2);
+	let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap();
+	let candidate_hash = candidates[0].hash();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		candidates,
+	)]);
+	relay_chain_client.set_runtime_version(runtime_version);
+
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let (parachain_client, _import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks)));
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			response_tx.send(
+				Ok(
+					AvailableData {
+						pov: Arc::new(PoV {
+							block_data: ParachainBlockData::<Block>::new(
+								header.clone(),
+								vec![],
+								CompactProof {encoded_nodes: vec![]}
+							).encode().into()
+						}),
+						validation_data: dummy_pvd(),
+					}
+				)
+			).unwrap()
+		}
+	);
+
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// Received import request for the recovered candidate
+	assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => {
+		assert_eq!(incoming_blocks.len(), 1);
+		assert_eq!(incoming_blocks[0].header, Some(header));
+	});
+
+	// No import request received
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn single_pending_candidate_recovery_retry_succeeds() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..2);
+	let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap();
+	let candidate_hash = candidates[0].hash();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let (parachain_client, _import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks)));
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	// First recovery fails.
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			response_tx.send(
+				Err(RecoveryError::Unavailable)
+			).unwrap()
+		}
+	);
+	// Candidate is not imported.
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// Recovery is retried and it succeeds now.
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			response_tx.send(
+				Ok(
+					AvailableData {
+						pov: Arc::new(PoV {
+							block_data: ParachainBlockData::<Block>::new(
+								header.clone(),
+								vec![],
+								CompactProof {encoded_nodes: vec![]}
+							).encode().into()
+						}),
+						validation_data: dummy_pvd(),
+					}
+				)
+			).unwrap()
+		}
+	);
+
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// Received import request for the recovered candidate
+	assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => {
+		assert_eq!(incoming_blocks.len(), 1);
+		assert_eq!(incoming_blocks[0].header, Some(header));
+	});
+
+	// No import request received
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn single_pending_candidate_recovery_retry_fails() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..2);
+	let candidate_hash = candidates[0].hash();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let (parachain_client, _import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks)));
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	// First recovery fails.
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			response_tx.send(
+				Err(RecoveryError::Unavailable)
+			).unwrap()
+		}
+	);
+	// Candidate is not imported.
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// Second retry fails.
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			response_tx.send(
+				Err(RecoveryError::Unavailable)
+			).unwrap()
+		}
+	);
+	// Candidate is not imported.
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// After the second attempt, give up.
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn single_pending_candidate_recovery_irrecoverable_error() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..2);
+	let candidate_hash = candidates[0].hash();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let (parachain_client, _import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks)));
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	// Recovery succeeds but the block data is wrong. Will not be retried.
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			response_tx.send(
+				Ok(
+					AvailableData {
+						pov: Arc::new(PoV {
+							// Empty block data. It will fail to decode.
+							block_data: vec![].into()
+						}),
+						validation_data: dummy_pvd(),
+					}
+				)
+			).unwrap()
+		}
+	);
+	// Candidate is not imported.
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn pending_candidates_recovery_skipped_while_syncing() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..4);
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let (parachain_client, _import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks)));
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::new(true)),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	// No recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// No candidate is imported.
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn candidate_is_imported_while_awaiting_recovery() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..2);
+	let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap();
+	let candidate_hash = candidates[0].hash();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let (parachain_client, import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks)));
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	let recovery_response_tx;
+
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			recovery_response_tx = response_tx;
+		}
+	);
+
+	// While candidate is pending recovery, import the candidate from external source.
+	let (unpin_sender, _unpin_receiver) = sc_utils::mpsc::tracing_unbounded("test_unpin", 10);
+	import_notifications_tx
+		.unbounded_send(BlockImportNotification::new(
+			header.hash(),
+			BlockOrigin::ConsensusBroadcast,
+			header.clone(),
+			false,
+			None,
+			unpin_sender,
+		))
+		.unwrap();
+
+	recovery_response_tx
+		.send(Ok(AvailableData {
+			pov: Arc::new(PoV {
+				block_data: ParachainBlockData::<Block>::new(
+					header.clone(),
+					vec![],
+					CompactProof { encoded_nodes: vec![] },
+				)
+				.encode()
+				.into(),
+			}),
+			validation_data: dummy_pvd(),
+		}))
+		.unwrap();
+
+	// Received import request for the recovered candidate. This could be optimised to not trigger a
+	// reimport.
+	assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => {
+		assert_eq!(incoming_blocks.len(), 1);
+		assert_eq!(incoming_blocks[0].header, Some(header));
+	});
+
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// No more import requests received
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn candidate_is_finalized_while_awaiting_recovery() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..2);
+	let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap();
+	let candidate_hash = candidates[0].hash();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let (parachain_client, _import_notifications_tx, finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks)));
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	let recovery_response_tx;
+
+	assert_matches!(
+		recovery_subsystem_rx.next().await,
+		Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+			receipt,
+			session_index,
+			None,
+			None,
+			response_tx
+		)) => {
+			assert_eq!(receipt.hash(), candidate_hash);
+			assert_eq!(session_index, TEST_SESSION_INDEX);
+			// save it for later.
+			recovery_response_tx = response_tx;
+		}
+	);
+
+	// While candidate is pending recovery, it gets finalized.
+	let (unpin_sender, _unpin_receiver) = sc_utils::mpsc::tracing_unbounded("test_unpin", 10);
+	finality_notifications_tx
+		.unbounded_send(FinalityNotification::from_summary(
+			FinalizeSummary { header: header.clone(), finalized: vec![], stale_heads: vec![] },
+			unpin_sender,
+		))
+		.unwrap();
+
+	recovery_response_tx
+		.send(Ok(AvailableData {
+			pov: Arc::new(PoV {
+				block_data: ParachainBlockData::<Block>::new(
+					header.clone(),
+					vec![],
+					CompactProof { encoded_nodes: vec![] },
+				)
+				.encode()
+				.into(),
+			}),
+			validation_data: dummy_pvd(),
+		}))
+		.unwrap();
+
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// candidate is imported
+	assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => {
+		assert_eq!(incoming_blocks.len(), 1);
+		assert_eq!(incoming_blocks[0].header, Some(header));
+	});
+
+	// No more import requests received
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn chained_recovery_success() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(0) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..4);
+	let headers = candidates
+		.iter()
+		.map(|candidate| Header::decode(&mut &candidate.commitments.head_data.0[..]).unwrap())
+		.collect::<Vec<_>>();
+	let candidate_hashes = candidates.iter().map(|candidate| candidate.hash()).collect::<Vec<_>>();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		// 3 pending candidates
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let known_blocks = Arc::new(Mutex::new(known_blocks));
+	let (parachain_client, import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], known_blocks.clone());
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	// Candidates are recovered in the right order.
+	for (candidate_hash, header) in candidate_hashes.into_iter().zip(headers.into_iter()) {
+		assert_matches!(
+			recovery_subsystem_rx.next().await,
+			Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+				receipt,
+				session_index,
+				None,
+				None,
+				response_tx
+			)) => {
+				assert_eq!(receipt.hash(), candidate_hash);
+				assert_eq!(session_index, TEST_SESSION_INDEX);
+				response_tx
+					.send(Ok(AvailableData {
+						pov: Arc::new(PoV {
+							block_data: ParachainBlockData::<Block>::new(
+								header.clone(),
+								vec![],
+								CompactProof { encoded_nodes: vec![] },
+							)
+							.encode()
+							.into(),
+						}),
+						validation_data: dummy_pvd(),
+						}))
+					.unwrap();
+			}
+		);
+
+		assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => {
+			assert_eq!(incoming_blocks.len(), 1);
+			assert_eq!(incoming_blocks[0].header, Some(header.clone()));
+		});
+
+		known_blocks
+			.lock()
+			.expect("Poisoned lock")
+			.insert(header.hash(), BlockStatus::InChainWithState);
+
+		let (unpin_sender, _unpin_receiver) = sc_utils::mpsc::tracing_unbounded("test_unpin", 10);
+		import_notifications_tx
+			.unbounded_send(BlockImportNotification::new(
+				header.hash(),
+				BlockOrigin::ConsensusBroadcast,
+				header,
+				false,
+				None,
+				unpin_sender,
+			))
+			.unwrap();
+	}
+
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// No more import requests received
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
+
+#[tokio::test]
+async fn chained_recovery_child_succeeds_before_parent() {
+	sp_tracing::init_for_tests();
+
+	let (recovery_subsystem_tx, mut recovery_subsystem_rx) =
+		AvailabilityRecoverySubsystemHandle::new();
+	let recovery_delay_range =
+		RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(0) };
+	let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10);
+	let candidates = make_candidate_chain(1..3);
+	let headers = candidates
+		.iter()
+		.map(|candidate| Header::decode(&mut &candidate.commitments.head_data.0[..]).unwrap())
+		.collect::<Vec<_>>();
+	let candidate_hashes = candidates.iter().map(|candidate| candidate.hash()).collect::<Vec<_>>();
+
+	let relay_chain_client = Relaychain::new(vec![(
+		PHeader {
+			parent_hash: PHash::from_low_u64_be(0),
+			number: 1,
+			state_root: PHash::random(),
+			extrinsics_root: PHash::random(),
+			digest: Default::default(),
+		},
+		// 2 pending candidates
+		candidates,
+	)]);
+	let mut known_blocks = HashMap::new();
+	known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState);
+	let known_blocks = Arc::new(Mutex::new(known_blocks));
+	let (parachain_client, _import_notifications_tx, _finality_notifications_tx) =
+		ParachainClient::new(vec![dummy_usage_info(0)], known_blocks.clone());
+	let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new();
+
+	let pov_recovery = PoVRecovery::<Block, _, _>::new(
+		Box::new(recovery_subsystem_tx),
+		recovery_delay_range,
+		Arc::new(parachain_client),
+		Box::new(parachain_import_queue),
+		relay_chain_client,
+		ParaId::new(1000),
+		explicit_recovery_chan_rx,
+		Arc::new(DummySyncOracle::default()),
+	);
+
+	task::spawn(pov_recovery.run());
+
+	let mut recovery_responses_senders = vec![];
+
+	for candidate_hash in candidate_hashes.iter() {
+		assert_matches!(
+			recovery_subsystem_rx.next().await,
+			Some(AvailabilityRecoveryMessage::RecoverAvailableData(
+				receipt,
+				session_index,
+				None,
+				None,
+				response_tx
+			)) => {
+				assert_eq!(receipt.hash(), *candidate_hash);
+				assert_eq!(session_index, TEST_SESSION_INDEX);
+				recovery_responses_senders.push(response_tx);
+			}
+		);
+	}
+
+	// Send out the responses in reverse order.
+	for (recovery_response_sender, header) in
+		recovery_responses_senders.into_iter().zip(headers.iter()).rev()
+	{
+		recovery_response_sender
+			.send(Ok(AvailableData {
+				pov: Arc::new(PoV {
+					block_data: ParachainBlockData::<Block>::new(
+						header.clone(),
+						vec![],
+						CompactProof { encoded_nodes: vec![] },
+					)
+					.encode()
+					.into(),
+				}),
+				validation_data: dummy_pvd(),
+			}))
+			.unwrap();
+	}
+
+	assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => {
+		// The two import requests will be batched.
+		assert_eq!(incoming_blocks.len(), 2);
+		assert_eq!(incoming_blocks[0].header, Some(headers[0].clone()));
+		assert_eq!(incoming_blocks[1].header, Some(headers[1].clone()));
+	});
+
+	// No more recovery messages received.
+	assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None);
+
+	// No more import requests received
+	assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None);
+}
diff --git a/cumulus/client/relay-chain-inprocess-interface/src/lib.rs b/cumulus/client/relay-chain-inprocess-interface/src/lib.rs
index 578b942776dcde99553e0a5af513b03acb3a80a1..7871623e8447a2645ef772a495d7f698660f7dc5 100644
--- a/cumulus/client/relay-chain-inprocess-interface/src/lib.rs
+++ b/cumulus/client/relay-chain-inprocess-interface/src/lib.rs
@@ -30,7 +30,7 @@ use futures::{FutureExt, Stream, StreamExt};
 use polkadot_service::{
 	CollatorPair, Configuration, FullBackend, FullClient, Handle, NewFull, TaskManager,
 };
-use sc_cli::SubstrateCli;
+use sc_cli::{RuntimeVersion, SubstrateCli};
 use sc_client_api::{
 	blockchain::BlockStatus, Backend, BlockchainEvents, HeaderBackend, ImportNotifications,
 	StorageProof,
@@ -68,6 +68,10 @@ impl RelayChainInProcessInterface {
 
 #[async_trait]
 impl RelayChainInterface for RelayChainInProcessInterface {
+	async fn version(&self, relay_parent: PHash) -> RelayChainResult<RuntimeVersion> {
+		Ok(self.full_client.runtime_version_at(relay_parent)?)
+	}
+
 	async fn retrieve_dmq_contents(
 		&self,
 		para_id: ParaId,
@@ -251,6 +255,14 @@ impl RelayChainInterface for RelayChainInProcessInterface {
 				});
 		Ok(Box::pin(notifications_stream))
 	}
+
+	async fn candidates_pending_availability(
+		&self,
+		hash: PHash,
+		para_id: ParaId,
+	) -> RelayChainResult<Vec<CommittedCandidateReceipt>> {
+		Ok(self.full_client.runtime_api().candidates_pending_availability(hash, para_id)?)
+	}
 }
 
 pub enum BlockCheckStatus {
diff --git a/cumulus/client/relay-chain-interface/Cargo.toml b/cumulus/client/relay-chain-interface/Cargo.toml
index 5962c68bba7a561b05a1710c2477b31964bbfe07..e8603693ac8da957988afac9e98468b759476665 100644
--- a/cumulus/client/relay-chain-interface/Cargo.toml
+++ b/cumulus/client/relay-chain-interface/Cargo.toml
@@ -18,9 +18,10 @@ sp-api = { path = "../../../substrate/primitives/api" }
 sp-blockchain = { path = "../../../substrate/primitives/blockchain" }
 sp-state-machine = { path = "../../../substrate/primitives/state-machine" }
 sc-client-api = { path = "../../../substrate/client/api" }
+sp-version = { path = "../../../substrate/primitives/version", default-features = false }
 
 futures = "0.3.28"
 async-trait = "0.1.79"
 thiserror = { workspace = true }
 jsonrpsee-core = "0.22"
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
diff --git a/cumulus/client/relay-chain-interface/src/lib.rs b/cumulus/client/relay-chain-interface/src/lib.rs
index bb93e6a168c849fa9d41586ad8b9ec0013e6c01f..46e19b40f010cce4342f54cbe08e975a52fee185 100644
--- a/cumulus/client/relay-chain-interface/src/lib.rs
+++ b/cumulus/client/relay-chain-interface/src/lib.rs
@@ -16,14 +16,14 @@
 
 use std::{collections::BTreeMap, pin::Pin, sync::Arc};
 
+use futures::Stream;
 use polkadot_overseer::prometheus::PrometheusError;
 use sc_client_api::StorageProof;
-
-use futures::Stream;
+use sp_version::RuntimeVersion;
 
 use async_trait::async_trait;
+use codec::Error as CodecError;
 use jsonrpsee_core::ClientError as JsonRpcError;
-use parity_scale_codec::Error as CodecError;
 use sp_api::ApiError;
 
 use cumulus_primitives_core::relay_chain::BlockId;
@@ -149,8 +149,12 @@ pub trait RelayChainInterface: Send + Sync {
 		_: OccupiedCoreAssumption,
 	) -> RelayChainResult<Option<PersistedValidationData>>;
 
-	/// Get the receipt of a candidate pending availability. This returns `Some` for any paras
-	/// assigned to occupied cores in `availability_cores` and `None` otherwise.
+	/// Get the receipt of the first candidate pending availability of this para_id. This returns
+	/// `Some` for any paras assigned to occupied cores in `availability_cores` and `None`
+	/// otherwise.
+	#[deprecated(
+		note = "`candidate_pending_availability` only returns one candidate and is deprecated. Use `candidates_pending_availability` instead."
+	)]
 	async fn candidate_pending_availability(
 		&self,
 		block_id: PHash,
@@ -203,6 +207,16 @@ pub trait RelayChainInterface: Send + Sync {
 		para_id: ParaId,
 		occupied_core_assumption: OccupiedCoreAssumption,
 	) -> RelayChainResult<Option<ValidationCodeHash>>;
+
+	/// Get the receipts of all candidates pending availability for this para_id.
+	async fn candidates_pending_availability(
+		&self,
+		block_id: PHash,
+		para_id: ParaId,
+	) -> RelayChainResult<Vec<CommittedCandidateReceipt>>;
+
+	/// Get the runtime version of the relay chain.
+	async fn version(&self, relay_parent: PHash) -> RelayChainResult<RuntimeVersion>;
 }
 
 #[async_trait]
@@ -237,6 +251,7 @@ where
 			.await
 	}
 
+	#[allow(deprecated)]
 	async fn candidate_pending_availability(
 		&self,
 		block_id: PHash,
@@ -321,4 +336,16 @@ where
 			.validation_code_hash(relay_parent, para_id, occupied_core_assumption)
 			.await
 	}
+
+	async fn candidates_pending_availability(
+		&self,
+		block_id: PHash,
+		para_id: ParaId,
+	) -> RelayChainResult<Vec<CommittedCandidateReceipt>> {
+		(**self).candidates_pending_availability(block_id, para_id).await
+	}
+
+	async fn version(&self, relay_parent: PHash) -> RelayChainResult<RuntimeVersion> {
+		(**self).version(relay_parent).await
+	}
 }
diff --git a/cumulus/client/relay-chain-minimal-node/Cargo.toml b/cumulus/client/relay-chain-minimal-node/Cargo.toml
index 88673a8f08fe37e4c5688b6bbec40fb36903c6dd..0b541092a3de866fa68491694db51236ef72f641 100644
--- a/cumulus/client/relay-chain-minimal-node/Cargo.toml
+++ b/cumulus/client/relay-chain-minimal-node/Cargo.toml
@@ -32,7 +32,7 @@ sc-network = { path = "../../../substrate/client/network" }
 sc-network-common = { path = "../../../substrate/client/network/common" }
 sc-service = { path = "../../../substrate/client/service" }
 sc-client-api = { path = "../../../substrate/client/api" }
-substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" }
 sc-tracing = { path = "../../../substrate/client/tracing" }
 sc-utils = { path = "../../../substrate/client/utils" }
 sp-api = { path = "../../../substrate/primitives/api" }
diff --git a/cumulus/client/relay-chain-minimal-node/src/lib.rs b/cumulus/client/relay-chain-minimal-node/src/lib.rs
index b84427c3a75a55e30d9867cbe8d45522a2d2f8c0..9101b8154aa72a7ec8b8bda5715c15048a70cd7c 100644
--- a/cumulus/client/relay-chain-minimal-node/src/lib.rs
+++ b/cumulus/client/relay-chain-minimal-node/src/lib.rs
@@ -190,7 +190,7 @@ async fn new_minimal_relay_chain<Block: BlockT, Network: NetworkBackend<RelayBlo
 		task_manager.spawn_handle().spawn(
 			"prometheus-endpoint",
 			None,
-			substrate_prometheus_endpoint::init_prometheus(port, registry).map(drop),
+			prometheus_endpoint::init_prometheus(port, registry).map(drop),
 		);
 	}
 
@@ -285,5 +285,8 @@ fn build_request_response_protocol_receivers<
 	let cfg =
 		Protocol::ChunkFetchingV1.get_outbound_only_config::<_, Network>(request_protocol_names);
 	config.add_request_response_protocol(cfg);
+	let cfg =
+		Protocol::ChunkFetchingV2.get_outbound_only_config::<_, Network>(request_protocol_names);
+	config.add_request_response_protocol(cfg);
 	(collation_req_v1_receiver, collation_req_v2_receiver, available_data_req_receiver)
 }
diff --git a/cumulus/client/relay-chain-rpc-interface/Cargo.toml b/cumulus/client/relay-chain-rpc-interface/Cargo.toml
index 2ec42ebca851e4d30a9ac17acd923f005956c287..ea6bc2ede4c041620acc18a2fcccde38b03d2388 100644
--- a/cumulus/client/relay-chain-rpc-interface/Cargo.toml
+++ b/cumulus/client/relay-chain-rpc-interface/Cargo.toml
@@ -32,7 +32,7 @@ tokio-util = { version = "0.7.8", features = ["compat"] }
 
 futures = "0.3.28"
 futures-timer = "3.0.2"
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 jsonrpsee = { version = "0.22", features = ["ws-client"] }
 tracing = "0.1.37"
 async-trait = "0.1.79"
diff --git a/cumulus/client/relay-chain-rpc-interface/src/lib.rs b/cumulus/client/relay-chain-rpc-interface/src/lib.rs
index 3a4c186e301eab295aa3befbd3c5549636fdb2c0..bb7bfa5dc32268b87bfbe1788aad7b6604961276 100644
--- a/cumulus/client/relay-chain-rpc-interface/src/lib.rs
+++ b/cumulus/client/relay-chain-rpc-interface/src/lib.rs
@@ -33,6 +33,7 @@ use sc_client_api::StorageProof;
 use sp_core::sp_std::collections::btree_map::BTreeMap;
 use sp_state_machine::StorageValue;
 use sp_storage::StorageKey;
+use sp_version::RuntimeVersion;
 use std::pin::Pin;
 
 use cumulus_primitives_core::relay_chain::BlockId;
@@ -237,4 +238,18 @@ impl RelayChainInterface for RelayChainRpcInterface {
 		let imported_headers_stream = self.rpc_client.get_best_heads_stream()?;
 		Ok(imported_headers_stream.boxed())
 	}
+
+	async fn candidates_pending_availability(
+		&self,
+		hash: RelayHash,
+		para_id: ParaId,
+	) -> RelayChainResult<Vec<CommittedCandidateReceipt>> {
+		self.rpc_client
+			.parachain_host_candidates_pending_availability(hash, para_id)
+			.await
+	}
+
+	async fn version(&self, relay_parent: RelayHash) -> RelayChainResult<RuntimeVersion> {
+		self.rpc_client.runtime_version(relay_parent).await
+	}
 }
diff --git a/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs b/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs
index 864ce6c57125ae5c8dcb5419561dd61a43c38579..a5d7c22a2ec89b17c2115a4dd56e4ee935ca51b4 100644
--- a/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs
+++ b/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs
@@ -27,7 +27,7 @@ use serde_json::Value as JsonValue;
 use std::collections::VecDeque;
 use tokio::sync::mpsc::Sender as TokioSender;
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 use cumulus_primitives_core::{
 	relay_chain::{
diff --git a/cumulus/pallets/collator-selection/src/mock.rs b/cumulus/pallets/collator-selection/src/mock.rs
index 4a440dfe1e92f26685415d260e0af9b1eb56a9a4..459b1cb5fdf28c118751c3afccc4b882891d1cc3 100644
--- a/cumulus/pallets/collator-selection/src/mock.rs
+++ b/cumulus/pallets/collator-selection/src/mock.rs
@@ -22,12 +22,7 @@ use frame_support::{
 };
 use frame_system as system;
 use frame_system::EnsureSignedBy;
-use sp_core::H256;
-use sp_runtime::{
-	testing::UintAuthorityId,
-	traits::{BlakeTwo256, IdentityLookup, OpaqueKeys},
-	BuildStorage, RuntimeAppPublic,
-};
+use sp_runtime::{testing::UintAuthorityId, traits::OpaqueKeys, BuildStorage, RuntimeAppPublic};
 
 type Block = frame_system::mocking::MockBlock<Test>;
 
@@ -46,56 +41,24 @@ frame_support::construct_runtime!(
 );
 
 parameter_types! {
-	pub const BlockHashCount: u64 = 250;
 	pub const SS58Prefix: u8 = 42;
 }
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl system::Config for Test {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
-	type Nonce = u64;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
 	type SS58Prefix = SS58Prefix;
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
 parameter_types! {
 	pub const ExistentialDeposit: u64 = 5;
-	pub const MaxReserves: u32 = 50;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = MaxReserves;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 pub struct Author4;
diff --git a/cumulus/pallets/parachain-system/Cargo.toml b/cumulus/pallets/parachain-system/Cargo.toml
index 0c94d0d05a64f488cb9e0e145fccea9ba8052f50..1a6a19f2ab4a2523074bd02aa96053a0f7236140 100644
--- a/cumulus/pallets/parachain-system/Cargo.toml
+++ b/cumulus/pallets/parachain-system/Cargo.toml
@@ -122,5 +122,3 @@ try-runtime = [
 	"polkadot-runtime-parachains/try-runtime",
 	"sp-runtime/try-runtime",
 ]
-
-parameterized-consensus-hook = []
diff --git a/cumulus/pallets/parachain-system/src/lib.rs b/cumulus/pallets/parachain-system/src/lib.rs
index 7657dc4555eee822dd612935eb3c5ac735759be1..bbb74a1b053886b90740562e077ce40804eb01fd 100644
--- a/cumulus/pallets/parachain-system/src/lib.rs
+++ b/cumulus/pallets/parachain-system/src/lib.rs
@@ -245,10 +245,6 @@ pub mod pallet {
 		/// [`consensus_hook::ExpectParentIncluded`] here. This is only necessary in the case
 		/// that collators aren't expected to have node versions that supply the included block
 		/// in the relay-chain state proof.
-		///
-		/// This config type is only available when the `parameterized-consensus-hook` crate feature
-		/// is activated.
-		#[cfg(feature = "parameterized-consensus-hook")]
 		type ConsensusHook: ConsensusHook;
 	}
 
@@ -556,10 +552,8 @@ pub mod pallet {
 			.expect("Invalid relay chain state proof");
 
 			// Update the desired maximum capacity according to the consensus hook.
-			#[cfg(feature = "parameterized-consensus-hook")]
-			let (consensus_hook_weight, capacity) = T::ConsensusHook::on_state_proof(&relay_state_proof);
-			#[cfg(not(feature = "parameterized-consensus-hook"))]
-			let (consensus_hook_weight, capacity) = ExpectParentIncluded::on_state_proof(&relay_state_proof);
+			let (consensus_hook_weight, capacity) =
+				T::ConsensusHook::on_state_proof(&relay_state_proof);
 			total_weight += consensus_hook_weight;
 			total_weight += Self::maybe_drop_included_ancestors(&relay_state_proof, capacity);
 			// Deposit a log indicating the relay-parent storage root.
@@ -749,14 +743,13 @@ pub mod pallet {
 	/// The segment length is limited by the capacity returned from the [`ConsensusHook`] configured
 	/// in the pallet.
 	#[pallet::storage]
-	pub(super) type UnincludedSegment<T: Config> =
-		StorageValue<_, Vec<Ancestor<T::Hash>>, ValueQuery>;
+	pub type UnincludedSegment<T: Config> = StorageValue<_, Vec<Ancestor<T::Hash>>, ValueQuery>;
 
 	/// Storage field that keeps track of bandwidth used by the unincluded segment along with the
 	/// latest HRMP watermark. Used for limiting the acceptance of new blocks with
 	/// respect to relay chain constraints.
 	#[pallet::storage]
-	pub(super) type AggregatedUnincludedSegment<T: Config> =
+	pub type AggregatedUnincludedSegment<T: Config> =
 		StorageValue<_, SegmentTracker<T::Hash>, OptionQuery>;
 
 	/// In case of a scheduled upgrade, this storage field contains the validation code to be
@@ -766,7 +759,7 @@ pub mod pallet {
 	/// [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process
 	/// with the new validation code. This concludes the upgrade process.
 	#[pallet::storage]
-	pub(super) type PendingValidationCode<T: Config> = StorageValue<_, Vec<u8>, ValueQuery>;
+	pub type PendingValidationCode<T: Config> = StorageValue<_, Vec<u8>, ValueQuery>;
 
 	/// Validation code that is set by the parachain and is to be communicated to collator and
 	/// consequently the relay-chain.
@@ -774,23 +767,23 @@ pub mod pallet {
 	/// This will be cleared in `on_initialize` of each new block if no other pallet already set
 	/// the value.
 	#[pallet::storage]
-	pub(super) type NewValidationCode<T: Config> = StorageValue<_, Vec<u8>, OptionQuery>;
+	pub type NewValidationCode<T: Config> = StorageValue<_, Vec<u8>, OptionQuery>;
 
 	/// The [`PersistedValidationData`] set for this block.
 	/// This value is expected to be set only once per block and it's never stored
 	/// in the trie.
 	#[pallet::storage]
-	pub(super) type ValidationData<T: Config> = StorageValue<_, PersistedValidationData>;
+	pub type ValidationData<T: Config> = StorageValue<_, PersistedValidationData>;
 
 	/// Were the validation data set to notify the relay chain?
 	#[pallet::storage]
-	pub(super) type DidSetValidationCode<T: Config> = StorageValue<_, bool, ValueQuery>;
+	pub type DidSetValidationCode<T: Config> = StorageValue<_, bool, ValueQuery>;
 
 	/// The relay chain block number associated with the last parachain block.
 	///
 	/// This is updated in `on_finalize`.
 	#[pallet::storage]
-	pub(super) type LastRelayChainBlockNumber<T: Config> =
+	pub type LastRelayChainBlockNumber<T: Config> =
 		StorageValue<_, RelayChainBlockNumber, ValueQuery>;
 
 	/// An option which indicates if the relay-chain restricts signalling a validation code upgrade.
@@ -801,7 +794,7 @@ pub mod pallet {
 	/// relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
 	/// set after the inherent.
 	#[pallet::storage]
-	pub(super) type UpgradeRestrictionSignal<T: Config> =
+	pub type UpgradeRestrictionSignal<T: Config> =
 		StorageValue<_, Option<relay_chain::UpgradeRestriction>, ValueQuery>;
 
 	/// Optional upgrade go-ahead signal from the relay-chain.
@@ -810,7 +803,7 @@ pub mod pallet {
 	/// relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
 	/// set after the inherent.
 	#[pallet::storage]
-	pub(super) type UpgradeGoAhead<T: Config> =
+	pub type UpgradeGoAhead<T: Config> =
 		StorageValue<_, Option<relay_chain::UpgradeGoAhead>, ValueQuery>;
 
 	/// The state proof for the last relay parent block.
@@ -820,7 +813,7 @@ pub mod pallet {
 	///
 	/// This data is also absent from the genesis.
 	#[pallet::storage]
-	pub(super) type RelayStateProof<T: Config> = StorageValue<_, sp_trie::StorageProof>;
+	pub type RelayStateProof<T: Config> = StorageValue<_, sp_trie::StorageProof>;
 
 	/// The snapshot of some state related to messaging relevant to the current parachain as per
 	/// the relay parent.
@@ -830,7 +823,7 @@ pub mod pallet {
 	///
 	/// This data is also absent from the genesis.
 	#[pallet::storage]
-	pub(super) type RelevantMessagingState<T: Config> = StorageValue<_, MessagingStateSnapshot>;
+	pub type RelevantMessagingState<T: Config> = StorageValue<_, MessagingStateSnapshot>;
 
 	/// The parachain host configuration that was obtained from the relay parent.
 	///
@@ -840,53 +833,51 @@ pub mod pallet {
 	/// This data is also absent from the genesis.
 	#[pallet::storage]
 	#[pallet::disable_try_decode_storage]
-	pub(super) type HostConfiguration<T: Config> = StorageValue<_, AbridgedHostConfiguration>;
+	pub type HostConfiguration<T: Config> = StorageValue<_, AbridgedHostConfiguration>;
 
 	/// The last downward message queue chain head we have observed.
 	///
 	/// This value is loaded before and saved after processing inbound downward messages carried
 	/// by the system inherent.
 	#[pallet::storage]
-	pub(super) type LastDmqMqcHead<T: Config> = StorageValue<_, MessageQueueChain, ValueQuery>;
+	pub type LastDmqMqcHead<T: Config> = StorageValue<_, MessageQueueChain, ValueQuery>;
 
 	/// The message queue chain heads we have observed per each channel incoming channel.
 	///
 	/// This value is loaded before and saved after processing inbound downward messages carried
 	/// by the system inherent.
 	#[pallet::storage]
-	pub(super) type LastHrmpMqcHeads<T: Config> =
+	pub type LastHrmpMqcHeads<T: Config> =
 		StorageValue<_, BTreeMap<ParaId, MessageQueueChain>, ValueQuery>;
 
 	/// Number of downward messages processed in a block.
 	///
 	/// This will be cleared in `on_initialize` of each new block.
 	#[pallet::storage]
-	pub(super) type ProcessedDownwardMessages<T: Config> = StorageValue<_, u32, ValueQuery>;
+	pub type ProcessedDownwardMessages<T: Config> = StorageValue<_, u32, ValueQuery>;
 
 	/// HRMP watermark that was set in a block.
 	///
 	/// This will be cleared in `on_initialize` of each new block.
 	#[pallet::storage]
-	pub(super) type HrmpWatermark<T: Config> =
-		StorageValue<_, relay_chain::BlockNumber, ValueQuery>;
+	pub type HrmpWatermark<T: Config> = StorageValue<_, relay_chain::BlockNumber, ValueQuery>;
 
 	/// HRMP messages that were sent in a block.
 	///
 	/// This will be cleared in `on_initialize` of each new block.
 	#[pallet::storage]
-	pub(super) type HrmpOutboundMessages<T: Config> =
+	pub type HrmpOutboundMessages<T: Config> =
 		StorageValue<_, Vec<OutboundHrmpMessage>, ValueQuery>;
 
 	/// Upward messages that were sent in a block.
 	///
 	/// This will be cleared in `on_initialize` of each new block.
 	#[pallet::storage]
-	pub(super) type UpwardMessages<T: Config> = StorageValue<_, Vec<UpwardMessage>, ValueQuery>;
+	pub type UpwardMessages<T: Config> = StorageValue<_, Vec<UpwardMessage>, ValueQuery>;
 
 	/// Upward messages that are still pending and not yet send to the relay chain.
 	#[pallet::storage]
-	pub(super) type PendingUpwardMessages<T: Config> =
-		StorageValue<_, Vec<UpwardMessage>, ValueQuery>;
+	pub type PendingUpwardMessages<T: Config> = StorageValue<_, Vec<UpwardMessage>, ValueQuery>;
 
 	/// Initialization value for the delivery fee factor for UMP.
 	#[pallet::type_value]
@@ -896,29 +887,29 @@ pub mod pallet {
 
 	/// The factor to multiply the base delivery fee by for UMP.
 	#[pallet::storage]
-	pub(super) type UpwardDeliveryFeeFactor<T: Config> =
+	pub type UpwardDeliveryFeeFactor<T: Config> =
 		StorageValue<_, FixedU128, ValueQuery, UpwardInitialDeliveryFeeFactor>;
 
 	/// The number of HRMP messages we observed in `on_initialize` and thus used that number for
 	/// announcing the weight of `on_initialize` and `on_finalize`.
 	#[pallet::storage]
-	pub(super) type AnnouncedHrmpMessagesPerCandidate<T: Config> = StorageValue<_, u32, ValueQuery>;
+	pub type AnnouncedHrmpMessagesPerCandidate<T: Config> = StorageValue<_, u32, ValueQuery>;
 
 	/// The weight we reserve at the beginning of the block for processing XCMP messages. This
 	/// overrides the amount set in the Config trait.
 	#[pallet::storage]
-	pub(super) type ReservedXcmpWeightOverride<T: Config> = StorageValue<_, Weight>;
+	pub type ReservedXcmpWeightOverride<T: Config> = StorageValue<_, Weight>;
 
 	/// The weight we reserve at the beginning of the block for processing DMP messages. This
 	/// overrides the amount set in the Config trait.
 	#[pallet::storage]
-	pub(super) type ReservedDmpWeightOverride<T: Config> = StorageValue<_, Weight>;
+	pub type ReservedDmpWeightOverride<T: Config> = StorageValue<_, Weight>;
 
 	/// A custom head data that should be returned as result of `validate_block`.
 	///
 	/// See `Pallet::set_custom_validation_head_data` for more information.
 	#[pallet::storage]
-	pub(super) type CustomValidationHeadData<T: Config> = StorageValue<_, Vec<u8>, OptionQuery>;
+	pub type CustomValidationHeadData<T: Config> = StorageValue<_, Vec<u8>, OptionQuery>;
 
 	#[pallet::inherent]
 	impl<T: Config> ProvideInherent for Pallet<T> {
@@ -1639,10 +1630,8 @@ impl<T: Config> polkadot_runtime_common::xcm_sender::EnsureForParachain for Pall
 }
 
 /// Something that can check the inherents of a block.
-#[cfg_attr(
-	feature = "parameterized-consensus-hook",
-	deprecated = "consider switching to `cumulus-pallet-parachain-system::ConsensusHook`"
-)]
+#[deprecated(note = "This trait is deprecated and will be removed by September 2024. \
+		Consider switching to `cumulus-pallet-parachain-system::ConsensusHook`")]
 pub trait CheckInherents<Block: BlockT> {
 	/// Check all inherents of the block.
 	///
diff --git a/cumulus/pallets/parachain-system/src/mock.rs b/cumulus/pallets/parachain-system/src/mock.rs
index e8d2eb70e26296219bff909543083eb9663fae99..da904c0079a00a39dcca24c2d408d0bb381b2252 100644
--- a/cumulus/pallets/parachain-system/src/mock.rs
+++ b/cumulus/pallets/parachain-system/src/mock.rs
@@ -55,7 +55,6 @@ frame_support::construct_runtime!(
 );
 
 parameter_types! {
-	pub const BlockHashCount: u64 = 250;
 	pub Version: RuntimeVersion = RuntimeVersion {
 		spec_name: sp_version::create_runtime_str!("test"),
 		impl_name: sp_version::create_runtime_str!("system-test"),
@@ -74,7 +73,6 @@ parameter_types! {
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
 	type Block = Block;
-	type BlockHashCount = BlockHashCount;
 	type Version = Version;
 	type OnSetCode = ParachainSetCode<Self>;
 }
diff --git a/cumulus/pallets/parachain-system/src/validate_block/implementation.rs b/cumulus/pallets/parachain-system/src/validate_block/implementation.rs
index ecab7a9a09311ae0f952a7842e9f1826b00adc69..956962fce157d3c5d090dd4bd8de78bba4d80405 100644
--- a/cumulus/pallets/parachain-system/src/validate_block/implementation.rs
+++ b/cumulus/pallets/parachain-system/src/validate_block/implementation.rs
@@ -80,6 +80,7 @@ environmental::environmental!(recorder: trait ProofSizeProvider);
 /// ensuring that the final storage root matches the storage root in the header of the block. In the
 /// end we return back the [`ValidationResult`] with all the required information for the validator.
 #[doc(hidden)]
+#[allow(deprecated)]
 pub fn validate_block<
 	B: BlockT,
 	E: ExecuteBlock<B>,
@@ -186,6 +187,7 @@ where
 		)
 		.expect("Invalid relay chain state proof");
 
+		#[allow(deprecated)]
 		let res = CI::check_inherents(&block, &relay_chain_proof);
 
 		if !res.ok() {
diff --git a/cumulus/pallets/session-benchmarking/Cargo.toml b/cumulus/pallets/session-benchmarking/Cargo.toml
index 001c3d8aceac5a5db27aba87d666fdf83e92021c..62c923de59f25d7fc6ba8db15df48e625e16e118 100644
--- a/cumulus/pallets/session-benchmarking/Cargo.toml
+++ b/cumulus/pallets/session-benchmarking/Cargo.toml
@@ -16,7 +16,7 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
 sp-std = { path = "../../../substrate/primitives/std", default-features = false }
 sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
 frame-support = { path = "../../../substrate/frame/support", default-features = false }
@@ -33,11 +33,11 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 ]
 std = [
+	"codec/std",
 	"frame-benchmarking/std",
 	"frame-support/std",
 	"frame-system/std",
 	"pallet-session/std",
-	"parity-scale-codec/std",
 	"sp-runtime/std",
 	"sp-std/std",
 ]
diff --git a/cumulus/pallets/session-benchmarking/src/inner.rs b/cumulus/pallets/session-benchmarking/src/inner.rs
index cffd0776f3d99c99525d12e0392bdf177b246bd5..36411d3d71afa2c1ae74870a1eed5ad1ad916a8c 100644
--- a/cumulus/pallets/session-benchmarking/src/inner.rs
+++ b/cumulus/pallets/session-benchmarking/src/inner.rs
@@ -17,10 +17,10 @@
 
 use sp_std::{prelude::*, vec};
 
+use codec::Decode;
 use frame_benchmarking::{benchmarks, whitelisted_caller};
 use frame_system::RawOrigin;
 use pallet_session::*;
-use parity_scale_codec::Decode;
 pub struct Pallet<T: Config>(pallet_session::Pallet<T>);
 pub trait Config: pallet_session::Config {}
 
diff --git a/cumulus/pallets/xcmp-queue/Cargo.toml b/cumulus/pallets/xcmp-queue/Cargo.toml
index 1941214da2e7b868760fd3a7d0fcf065600a5caa..87602978521fc363539b2aeb81f5b485dbe409ea 100644
--- a/cumulus/pallets/xcmp-queue/Cargo.toml
+++ b/cumulus/pallets/xcmp-queue/Cargo.toml
@@ -48,7 +48,7 @@ pallet-balances = { path = "../../../substrate/frame/balances" }
 frame-support = { path = "../../../substrate/frame/support", features = ["experimental"] }
 
 # Cumulus
-cumulus-pallet-parachain-system = { path = "../parachain-system", features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../parachain-system" }
 
 [features]
 default = ["std"]
diff --git a/cumulus/pallets/xcmp-queue/src/lib.rs b/cumulus/pallets/xcmp-queue/src/lib.rs
index 5633f05f13bb81370a23512effefaf6ae1fb23fa..45126a9425d4c0400c7b76f55173339fd4c4a2bb 100644
--- a/cumulus/pallets/xcmp-queue/src/lib.rs
+++ b/cumulus/pallets/xcmp-queue/src/lib.rs
@@ -491,7 +491,7 @@ impl<T: Config> Pallet<T> {
 		let channel_info =
 			T::ChannelInfo::get_channel_info(recipient).ok_or(MessageSendError::NoChannel)?;
 		// Max message size refers to aggregates, or pages. Not to individual fragments.
-		let max_message_size = channel_info.max_message_size as usize;
+		let max_message_size = channel_info.max_message_size.min(T::MaxPageSize::get()) as usize;
 		let format_size = format.encoded_size();
 		// We check the encoded fragment length plus the format size against the max message size
 		// because the format is concatenated if a new page is needed.
@@ -522,7 +522,7 @@ impl<T: Config> Pallet<T> {
 		// We return the size of the last page inside of the option, to not calculate it again.
 		let appended_to_last_page = have_active
 			.then(|| {
-				<OutboundXcmpMessages<T>>::mutate(
+				<OutboundXcmpMessages<T>>::try_mutate(
 					recipient,
 					channel_details.last_index - 1,
 					|page| {
@@ -532,17 +532,18 @@ impl<T: Config> Pallet<T> {
 						) != Ok(format)
 						{
 							defensive!("Bad format in outbound queue; dropping message");
-							return None
+							return Err(())
 						}
 						if page.len() + encoded_fragment.len() > max_message_size {
-							return None
+							return Err(())
 						}
 						for frag in encoded_fragment.iter() {
-							page.try_push(*frag).ok()?;
+							page.try_push(*frag)?;
 						}
-						Some(page.len())
+						Ok(page.len())
 					},
 				)
+				.ok()
 			})
 			.flatten();
 
diff --git a/cumulus/pallets/xcmp-queue/src/mock.rs b/cumulus/pallets/xcmp-queue/src/mock.rs
index 97121aa78e9ad0359413b41fb0960e65fddf1335..7fb96de7a4eaae7e7f78fae66179a26a3a6c5866 100644
--- a/cumulus/pallets/xcmp-queue/src/mock.rs
+++ b/cumulus/pallets/xcmp-queue/src/mock.rs
@@ -52,7 +52,6 @@ frame_support::construct_runtime!(
 );
 
 parameter_types! {
-	pub const BlockHashCount: u64 = 250;
 	pub const SS58Prefix: u8 = 42;
 }
 
@@ -73,7 +72,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
@@ -87,25 +85,14 @@ impl frame_system::Config for Test {
 
 parameter_types! {
 	pub const ExistentialDeposit: u64 = 5;
-	pub const MaxReserves: u32 = 50;
 }
 
 pub type Balance = u64;
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = MaxReserves;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 impl cumulus_pallet_parachain_system::Config for Test {
@@ -323,10 +310,13 @@ impl GetChannelInfo for MockedChannelInfo {
 pub(crate) fn mk_page() -> Vec<u8> {
 	let mut page = Vec::<u8>::new();
 
+	let newer_xcm_version = xcm::prelude::XCM_VERSION;
+	let older_xcm_version = newer_xcm_version - 1;
+
 	for i in 0..100 {
 		page.extend(match i % 2 {
-			0 => v2_xcm().encode(),
-			1 => v3_xcm().encode(),
+			0 => versioned_xcm(older_xcm_version).encode(),
+			1 => versioned_xcm(newer_xcm_version).encode(),
 			// We cannot push an undecodable XCM here since it would break the decode stream.
 			// This is expected and the whole reason to introduce `MaybeDoubleEncodedVersionedXcm`
 			// instead.
@@ -337,12 +327,9 @@ pub(crate) fn mk_page() -> Vec<u8> {
 	page
 }
 
-pub(crate) fn v2_xcm() -> VersionedXcm<()> {
-	let instr = xcm::v2::Instruction::<()>::ClearOrigin;
-	VersionedXcm::V2(xcm::v2::Xcm::<()>(vec![instr; 3]))
-}
-
-pub(crate) fn v3_xcm() -> VersionedXcm<()> {
-	let instr = xcm::v3::Instruction::<()>::Trap(1);
-	VersionedXcm::V3(xcm::v3::Xcm::<()>(vec![instr; 3]))
+pub(crate) fn versioned_xcm(version: XcmVersion) -> VersionedXcm<()> {
+	let instr = Instruction::<()>::Trap(1);
+	VersionedXcm::from(Xcm::<()>(vec![instr; 3]))
+		.into_version(version)
+		.expect("Version conversion should work")
 }
diff --git a/cumulus/pallets/xcmp-queue/src/tests.rs b/cumulus/pallets/xcmp-queue/src/tests.rs
index 7c02059e5a90477a761ee8bb9ae00d6e2cf6e124..5b02baf2310a368c3b49269e4c594a81d47a3a01 100644
--- a/cumulus/pallets/xcmp-queue/src/tests.rs
+++ b/cumulus/pallets/xcmp-queue/src/tests.rs
@@ -14,7 +14,7 @@
 // limitations under the License.
 
 use super::{
-	mock::{mk_page, v2_xcm, v3_xcm, EnqueuedMessages, HRMP_PARA_ID},
+	mock::{mk_page, versioned_xcm, EnqueuedMessages, HRMP_PARA_ID},
 	*,
 };
 use XcmpMessageFormat::*;
@@ -28,6 +28,7 @@ use frame_support::{
 use mock::{new_test_ext, ParachainSystem, RuntimeOrigin as Origin, Test, XcmpQueue};
 use sp_runtime::traits::{BadOrigin, Zero};
 use std::iter::{once, repeat};
+use xcm_builder::InspectMessageQueues;
 
 #[test]
 fn empty_concatenated_works() {
@@ -536,8 +537,8 @@ fn hrmp_signals_are_prioritized() {
 #[test]
 fn maybe_double_encoded_versioned_xcm_works() {
 	// pre conditions
-	assert_eq!(VersionedXcm::<()>::V2(Default::default()).encode(), &[2, 0]);
 	assert_eq!(VersionedXcm::<()>::V3(Default::default()).encode(), &[3, 0]);
+	assert_eq!(VersionedXcm::<()>::V4(Default::default()).encode(), &[4, 0]);
 }
 
 // Now also testing a page instead of just concat messages.
@@ -545,15 +546,18 @@ fn maybe_double_encoded_versioned_xcm_works() {
 fn maybe_double_encoded_versioned_xcm_decode_page_works() {
 	let page = mk_page();
 
+	let newer_xcm_version = xcm::prelude::XCM_VERSION;
+	let older_xcm_version = newer_xcm_version - 1;
+
 	// Now try to decode the page.
 	let input = &mut &page[..];
 	for i in 0..100 {
 		match (i % 2, VersionedXcm::<()>::decode(input)) {
 			(0, Ok(xcm)) => {
-				assert_eq!(xcm, v2_xcm());
+				assert_eq!(xcm, versioned_xcm(older_xcm_version));
 			},
 			(1, Ok(xcm)) => {
-				assert_eq!(xcm, v3_xcm());
+				assert_eq!(xcm, versioned_xcm(newer_xcm_version));
 			},
 			unexpected => unreachable!("{:?}", unexpected),
 		}
@@ -568,14 +572,17 @@ fn take_first_concatenated_xcm_works() {
 	let page = mk_page();
 	let input = &mut &page[..];
 
+	let newer_xcm_version = xcm::prelude::XCM_VERSION;
+	let older_xcm_version = newer_xcm_version - 1;
+
 	for i in 0..100 {
 		let xcm = XcmpQueue::take_first_concatenated_xcm(input, &mut WeightMeter::new()).unwrap();
 		match (i % 2, xcm) {
 			(0, data) | (2, data) => {
-				assert_eq!(data, v2_xcm().encode());
+				assert_eq!(data, versioned_xcm(older_xcm_version).encode());
 			},
 			(1, data) | (3, data) => {
-				assert_eq!(data, v3_xcm().encode());
+				assert_eq!(data, versioned_xcm(newer_xcm_version).encode());
 			},
 			unexpected => unreachable!("{:?}", unexpected),
 		}
@@ -848,7 +855,6 @@ fn verify_fee_factor_increase_and_decrease() {
 #[test]
 fn get_messages_works() {
 	new_test_ext().execute_with(|| {
-		use xcm_builder::InspectMessageQueues;
 		let sibling_para_id = ParaId::from(2001);
 		ParachainSystem::open_outbound_hrmp_channel_for_benchmarks_or_tests(sibling_para_id);
 		let destination: Location = (Parent, Parachain(sibling_para_id.into())).into();
@@ -884,3 +890,32 @@ fn get_messages_works() {
 		);
 	});
 }
+
+/// We try to send a fragment that will not fit into the currently active page. This should
+/// therefore not modify the current page but instead create a new one.
+#[test]
+fn page_not_modified_when_fragment_does_not_fit() {
+	new_test_ext().execute_with(|| {
+		let sibling = ParaId::from(2001);
+		ParachainSystem::open_outbound_hrmp_channel_for_benchmarks_or_tests(sibling);
+
+		let destination: Location = (Parent, Parachain(sibling.into())).into();
+		let message = Xcm(vec![ClearOrigin; 600]);
+
+		loop {
+			let old_page_zero = OutboundXcmpMessages::<Test>::get(sibling, 0);
+			assert_ok!(send_xcm::<XcmpQueue>(destination.clone(), message.clone()));
+
+			// If a new page was created by this send_xcm call, then page_zero was not also
+			// modified:
+			let num_pages = OutboundXcmpMessages::<Test>::iter_prefix(sibling).count();
+			if num_pages == 2 {
+				let new_page_zero = OutboundXcmpMessages::<Test>::get(sibling, 0);
+				assert_eq!(old_page_zero, new_page_zero);
+				break
+			} else if num_pages > 2 {
+				panic!("Too many pages created");
+			}
+		}
+	});
+}
diff --git a/cumulus/parachains/chain-specs/asset-hub-kusama.json b/cumulus/parachains/chain-specs/asset-hub-kusama.json
index 00e342381ee1c06a65bfaa51111fb55643cfabba..36cccd9b0b0dbad4a5f6c7240a69181ec7ffe5f3 100644
--- a/cumulus/parachains/chain-specs/asset-hub-kusama.json
+++ b/cumulus/parachains/chain-specs/asset-hub-kusama.json
@@ -17,8 +17,8 @@
     "/dns/statemine-bootnode.turboflakes.io/tcp/30420/wss/p2p/12D3KooWN2Qqvp5wWgjbBMpbqhKgvSibSHfomP5VWVD9VCn3VrV4",
     "/dns/boot-node.helikon.io/tcp/10210/p2p/12D3KooWFXRQce3aMgZMn5SxvHtYH4PsR63TZLf8LrnBsEVTyzdr",
     "/dns/boot-node.helikon.io/tcp/10212/wss/p2p/12D3KooWFXRQce3aMgZMn5SxvHtYH4PsR63TZLf8LrnBsEVTyzdr",
-    "/dns/statemine.bootnode.amforc.com/tcp/30336/p2p/12D3KooWHmSyrBWsc6fdpq8HtCFWasmLVLYGKWA2a78m4xAHKyBq",
-    "/dns/statemine.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWHmSyrBWsc6fdpq8HtCFWasmLVLYGKWA2a78m4xAHKyBq",
+    "/dns/asset-hub-kusama.bootnode.amforc.com/tcp/30007/p2p/12D3KooWHy1CPndZYphwdVqMb295KPC6LRt17Ae3zNSr7evzeF5a",
+    "/dns/asset-hub-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWHy1CPndZYphwdVqMb295KPC6LRt17Ae3zNSr7evzeF5a",
     "/dns/statemine-boot-ng.dwellir.com/tcp/30343/p2p/12D3KooWQNJKBaNfW6Nn7HZDi5pSSEFmHL2Qz7chr9RksQUDR1Wk",
     "/dns/statemine-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWQNJKBaNfW6Nn7HZDi5pSSEFmHL2Qz7chr9RksQUDR1Wk",
     "/dns/statemine-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWCKUrE5uaXQ288ko3Ex3zCyozyJLG47KEYTopinnXNtYL",
diff --git a/cumulus/parachains/chain-specs/asset-hub-polkadot.json b/cumulus/parachains/chain-specs/asset-hub-polkadot.json
index 22b11757b66bb7103152997b4d276378f0960700..f7f53f8d7246f42dda05901298831190e5d81802 100644
--- a/cumulus/parachains/chain-specs/asset-hub-polkadot.json
+++ b/cumulus/parachains/chain-specs/asset-hub-polkadot.json
@@ -17,8 +17,8 @@
     "/dns/statemint-bootnode.turboflakes.io/tcp/30415/wss/p2p/12D3KooWL8CyLww3m3pRySQGGYGNJhWDMqko3j5xi67ckP7hDUvo",
     "/dns/boot-node.helikon.io/tcp/10220/p2p/12D3KooW9uybhguhDjVJc3U3kgZC3i8rWmAnSpbnJkmuR7C6ZsRW",
     "/dns/boot-node.helikon.io/tcp/10222/wss/p2p/12D3KooW9uybhguhDjVJc3U3kgZC3i8rWmAnSpbnJkmuR7C6ZsRW",
-    "/dns/statemint.bootnode.amforc.com/tcp/30341/p2p/12D3KooWByohP9FXn7ao8syS167qJsbFdpa7fY2Y24xbKtt3r7Ls",
-    "/dns/statemint.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWByohP9FXn7ao8syS167qJsbFdpa7fY2Y24xbKtt3r7Ls",
+    "/dns/asset-hub-polkadot.bootnode.amforc.com/tcp/30007/p2p/12D3KooWDLxPXYnSHjNwq9ibqgxuzRni5VViuGNSjNe3ueqVgqE3",
+    "/dns/asset-hub-polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWDLxPXYnSHjNwq9ibqgxuzRni5VViuGNSjNe3ueqVgqE3",
     "/dns/statemint-boot-ng.dwellir.com/tcp/30344/p2p/12D3KooWEFrNuNk8fPdQS2hf34Gmqi6dGSvrETshGJUrqrvfRDZr",
     "/dns/statemint-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWEFrNuNk8fPdQS2hf34Gmqi6dGSvrETshGJUrqrvfRDZr",
     "/dns/statemint-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWLKxHom7f3XawRJqrF8RwiKK5Sj3qZqz5c7hF6eJeXhTx",
diff --git a/cumulus/parachains/chain-specs/asset-hub-rococo.json b/cumulus/parachains/chain-specs/asset-hub-rococo.json
index 87ff2fb220a19b1ec01d280be6e58ab2cafffd90..2dde366cc06f9f4b24e802b14461a39c2d083ae2 100644
--- a/cumulus/parachains/chain-specs/asset-hub-rococo.json
+++ b/cumulus/parachains/chain-specs/asset-hub-rococo.json
@@ -1,7 +1,4 @@
 {
-  "name": "Rococo Asset Hub",
-  "id": "asset-hub-rococo",
-  "chainType": "Live",
   "bootNodes": [
     "/dns/rococo-asset-hub-bootnode-0.polkadot.io/tcp/30333/p2p/12D3KooWRrZMndHAopzao34uGsN7srjS3gh9nAjTGKLSyJeU31Lg",
     "/dns/rococo-asset-hub-bootnode-1.polkadot.io/tcp/30333/p2p/12D3KooWAewimoNJqMaiiV5pYiowA5hLuh5JS5QiRJCCyWVrrSTS",
@@ -10,17 +7,15 @@
     "/dns/rococo-asset-hub-bootnode-0.polkadot.io/tcp/443/wss/p2p/12D3KooWRrZMndHAopzao34uGsN7srjS3gh9nAjTGKLSyJeU31Lg",
     "/dns/rococo-asset-hub-bootnode-1.polkadot.io/tcp/443/wss/p2p/12D3KooWAewimoNJqMaiiV5pYiowA5hLuh5JS5QiRJCCyWVrrSTS"
   ],
-  "telemetryEndpoints": null,
-  "protocolId": null,
-  "properties": {
-    "tokenDecimals": 12,
-    "tokenSymbol": "ROC"
-  },
   "relay_chain": "rococo",
   "para_id": 1000,
-  "codeSubstitutes": {},
+  "chainType": "Live",
+  "codeSubstitutes": {
+    "4960799": "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"
+  },
   "genesis": {
     "raw": {
+      "childrenDefault": {},
       "top": {
         "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xe8030000",
         "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
@@ -75,8 +70,15 @@
         "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
         "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x02000000",
         "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
-      },
-      "childrenDefault": {}
+      }
     }
-  }
+  },
+  "id": "asset-hub-rococo",
+  "name": "Rococo Asset Hub",
+  "properties": {
+    "tokenDecimals": 12,
+    "tokenSymbol": "ROC"
+  },
+  "protocolId": null,
+  "telemetryEndpoints": null
 }
diff --git a/cumulus/parachains/chain-specs/asset-hub-westend.json b/cumulus/parachains/chain-specs/asset-hub-westend.json
index 830eb2c5918069ac46fed21a27360ba92c5aebce..b4334bdfe1243eb4d6726ab3464d619aebac394a 100644
--- a/cumulus/parachains/chain-specs/asset-hub-westend.json
+++ b/cumulus/parachains/chain-specs/asset-hub-westend.json
@@ -19,8 +19,8 @@
     "/dns/westmint-bootnode.turboflakes.io/tcp/30425/wss/p2p/12D3KooWHU4qqSyqKdbXdrCTMXUJxxueaZjqpqSaQqYiFPw6XqEx",
     "/dns/boot-node.helikon.io/tcp/10200/p2p/12D3KooWMRY8wb7rMT81LLuivvsy6ahUxKHQgYJw4zm1hC1uYLxb",
     "/dns/boot-node.helikon.io/tcp/10202/wss/p2p/12D3KooWMRY8wb7rMT81LLuivvsy6ahUxKHQgYJw4zm1hC1uYLxb",
-    "/dns/westmint.bootnode.amforc.com/tcp/30339/p2p/12D3KooWNjKeaANaeZxBAPctmx8jugSYzuw4vnSCJmEDPB5mtRd6",
-    "/dns/westmint.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWNjKeaANaeZxBAPctmx8jugSYzuw4vnSCJmEDPB5mtRd6",
+    "/dns/asset-hub-westend.bootnode.amforc.com/tcp/30004/p2p/12D3KooWDfepM7kqUHMXdGqJw3ZmtvAcE2CjPcnYjT2tTfAw3ZBd",
+    "/dns/asset-hub-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWDfepM7kqUHMXdGqJw3ZmtvAcE2CjPcnYjT2tTfAw3ZBd",
     "/dns/westmint-boot-ng.dwellir.com/tcp/30345/p2p/12D3KooWFZ9xqApB1wnFYkbe1qJ5Jqwxe2f3i8W25F3tKNXy59ux",
     "/dns/westmint-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWFZ9xqApB1wnFYkbe1qJ5Jqwxe2f3i8W25F3tKNXy59ux",
     "/dns/westmint-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWDoq4PVdWm5nzRSvEz3DSSKjVgRhWVUaKyi5JMKwJKYbk",
diff --git a/cumulus/parachains/chain-specs/bridge-hub-kusama.json b/cumulus/parachains/chain-specs/bridge-hub-kusama.json
index 46b33ed44c1a823daf25a2e834abc602cb35f0dc..2c63b52d78395167f5a60e1b96ffede355b3eddc 100644
--- a/cumulus/parachains/chain-specs/bridge-hub-kusama.json
+++ b/cumulus/parachains/chain-specs/bridge-hub-kusama.json
@@ -17,8 +17,8 @@
     "/dns/bridge-hub-kusama-bootnode.turboflakes.io/tcp/30715/wss/p2p/12D3KooWE3dJXbwA5SQqbDNxHfj7BXJRcy2KiXWjJY4VUMKoa7S2",
     "/dns/boot-node.helikon.io/tcp/10250/p2p/12D3KooWDJLkhqQdXcVKWX7CqJHnpAY6PzrPc4ZG2CUWnARbmguy",
     "/dns/boot-node.helikon.io/tcp/10252/wss/p2p/12D3KooWDJLkhqQdXcVKWX7CqJHnpAY6PzrPc4ZG2CUWnARbmguy",
-    "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/30337/p2p/12D3KooWGNeQJ5rXnEJkVUuQqwHd8aV5GkTAheaRoCaK8ZwW94id",
-    "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWGNeQJ5rXnEJkVUuQqwHd8aV5GkTAheaRoCaK8ZwW94id",
+    "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/30010/p2p/12D3KooWNyTBwRvCz1Ey2SgC1f3MvymhiAyLEa3cL8kU5gFH3V7Z",
+    "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWNyTBwRvCz1Ey2SgC1f3MvymhiAyLEa3cL8kU5gFH3V7Z",
     "/dns/kusama-bridge-hub-boot-ng.dwellir.com/tcp/30337/p2p/12D3KooWBFskNCQDVjuUeBh6vrszWrUvYMBBhtZRLnoTZDdLYbW5",
     "/dns/kusama-bridge-hub-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWBFskNCQDVjuUeBh6vrszWrUvYMBBhtZRLnoTZDdLYbW5",
     "/dns/bridgehub-kusama-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWQMWofXj8v3RroDNnrhv1iURqm8vnaG98AdGnCn2YoDcW",
diff --git a/cumulus/parachains/chain-specs/bridge-hub-polkadot.json b/cumulus/parachains/chain-specs/bridge-hub-polkadot.json
index 0a642caddb7684b35b74eb4b115157667f4370ba..7d3ba8357037d7310c56ed609cbc43e0359ca2bc 100644
--- a/cumulus/parachains/chain-specs/bridge-hub-polkadot.json
+++ b/cumulus/parachains/chain-specs/bridge-hub-polkadot.json
@@ -26,7 +26,9 @@
     "/dns/pbr13.rotko.net/tcp/35543/wss/p2p/12D3KooWMxZY7tDc2Rh454VaJJ7RexKAXVS6xSBEvTnXSGCnuGDw",
     "/dns/bridge-hub-polkadot.bootnodes.polkadotters.com/tcp/30517/p2p/12D3KooWLUNE3LHPDa1WrrZaYT7ArK66CLM1bPv7kKz74UcLnQRB",
     "/dns/bridge-hub-polkadot.bootnodes.polkadotters.com/tcp/30519/wss/p2p/12D3KooWLUNE3LHPDa1WrrZaYT7ArK66CLM1bPv7kKz74UcLnQRB",
-    "/dns/boot-polkadot-bridgehub.luckyfriday.io/tcp/443/wss/p2p/12D3KooWKf3mBXHjLbwtPqv1BdbQuwbFNcQQYxASS7iQ25264AXH"
+    "/dns/boot-polkadot-bridgehub.luckyfriday.io/tcp/443/wss/p2p/12D3KooWKf3mBXHjLbwtPqv1BdbQuwbFNcQQYxASS7iQ25264AXH",
+    "/dns/bridge-hub-polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWGT5E56rAHfT5dY1pMLTrpAgV72yfDtD1Y5tPCHaTsifp",
+    "/dns/bridge-hub-polkadot.bootnode.amforc.com/tcp/30010/p2p/12D3KooWGT5E56rAHfT5dY1pMLTrpAgV72yfDtD1Y5tPCHaTsifp"
   ],
   "telemetryEndpoints": null,
   "protocolId": null,
diff --git a/cumulus/parachains/chain-specs/bridge-hub-rococo.json b/cumulus/parachains/chain-specs/bridge-hub-rococo.json
index 53aef58422db38f8417d7add5abee0b6ecbbd755..d83431b9ca5ea77e3cccf01e8f60cc42061a2940 100644
--- a/cumulus/parachains/chain-specs/bridge-hub-rococo.json
+++ b/cumulus/parachains/chain-specs/bridge-hub-rococo.json
@@ -1,7 +1,4 @@
 {
-  "name": "Rococo BridgeHub",
-  "id": "bridge-hub-rococo",
-  "chainType": "Live",
   "bootNodes": [
     "/dns/rococo-bridge-hub-collator-node-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWJCFBJmFF65xz5xHeZQRSCf35BxfSEB3RHQFoLza28LWU",
     "/dns/rococo-bridge-hub-collator-node-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWJzLd8skcAgA24EcJey7aJAhYctfUxWGjSP5Usk9wbpPZ",
@@ -10,18 +7,15 @@
     "/dns/rococo-bridge-hub-collator-node-0.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWJCFBJmFF65xz5xHeZQRSCf35BxfSEB3RHQFoLza28LWU",
     "/dns/rococo-bridge-hub-collator-node-1.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWJzLd8skcAgA24EcJey7aJAhYctfUxWGjSP5Usk9wbpPZ"
   ],
-  "telemetryEndpoints": null,
-  "protocolId": null,
-  "properties": {
-    "ss58Format": 42,
-    "tokenDecimals": 12,
-    "tokenSymbol": "ROC"
-  },
+  "chainType": "Live",
   "relay_chain": "rococo",
   "para_id": 1013,
-  "codeSubstitutes": {},
+  "codeSubstitutes": {
+    "3603599": "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"
+  },
   "genesis": {
     "raw": {
+      "childrenDefault": {},
       "top": {
         "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xf5030000",
         "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
@@ -80,8 +74,16 @@
         "0xe81713b6b40972bbcd298d67597a495f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
         "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
         "0xf7327be699d4ca1e710c5cb7cfa19d3c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
-      },
-      "childrenDefault": {}
+      }
     }
-  }
+  },
+  "id": "bridge-hub-rococo",
+  "name": "Rococo BridgeHub",
+  "properties": {
+    "ss58Format": 42,
+    "tokenDecimals": 12,
+    "tokenSymbol": "ROC"
+  },
+  "protocolId": null,
+  "telemetryEndpoints": null
 }
diff --git a/cumulus/parachains/chain-specs/bridge-hub-westend.json b/cumulus/parachains/chain-specs/bridge-hub-westend.json
index c07857894f71663fe80c35f775ea56ddd55accc4..f98a046040f2226b5345d4d793e15ec3e24d6c43 100644
--- a/cumulus/parachains/chain-specs/bridge-hub-westend.json
+++ b/cumulus/parachains/chain-specs/bridge-hub-westend.json
@@ -27,7 +27,9 @@
     "/dns/wbr13.rotko.net/tcp/34563/ws/p2p/12D3KooWJyeRHpxZZbfBCNEgeUFzmRC5AMSAs2tJhjJS1k5hULkD",
     "/dns/wbr13.rotko.net/tcp/35563/wss/p2p/12D3KooWJyeRHpxZZbfBCNEgeUFzmRC5AMSAs2tJhjJS1k5hULkD",
     "/dns/bridge-hub-westend.bootnodes.polkadotters.com/tcp/30523/p2p/12D3KooWPkwgJofp4GeeRwNgXqkp2aFwdLkCWv3qodpBJLwK43Jj",
-    "/dns/bridge-hub-westend.bootnodes.polkadotters.com/tcp/30525/wss/p2p/12D3KooWPkwgJofp4GeeRwNgXqkp2aFwdLkCWv3qodpBJLwK43Jj"
+    "/dns/bridge-hub-westend.bootnodes.polkadotters.com/tcp/30525/wss/p2p/12D3KooWPkwgJofp4GeeRwNgXqkp2aFwdLkCWv3qodpBJLwK43Jj",
+    "/dns/bridge-hub-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWDSWod2gMtHxunXot538oEMw9p42pnPrpRELdsfYyT8R6",
+    "/dns/bridge-hub-westend.bootnode.amforc.com/tcp/30007/p2p/12D3KooWDSWod2gMtHxunXot538oEMw9p42pnPrpRELdsfYyT8R6"
   ],
   "telemetryEndpoints": null,
   "protocolId": null,
diff --git a/cumulus/parachains/chain-specs/collectives-polkadot.json b/cumulus/parachains/chain-specs/collectives-polkadot.json
index b2f3ff812d05da83d28be150de5a00466cc450bd..a6ba01ffa394dfdba05e65014006f10eb68ea858 100644
--- a/cumulus/parachains/chain-specs/collectives-polkadot.json
+++ b/cumulus/parachains/chain-specs/collectives-polkadot.json
@@ -17,15 +17,14 @@
     "/dns/collectives-polkadot-bootnode.turboflakes.io/tcp/30705/wss/p2p/12D3KooWPyzM7eX64J4aG8uRfSARakDVtiEtthEM8FUjrLWAg2sC",
     "/dns/boot-node.helikon.io/tcp/10230/p2p/12D3KooWS8CBz4P5CBny9aBy2EQUvAExFo9PUVT57X8r3zWMFkXT",
     "/dns/boot-node.helikon.io/tcp/10232/wss/p2p/12D3KooWS8CBz4P5CBny9aBy2EQUvAExFo9PUVT57X8r3zWMFkXT",
-    "/dns/collectives-polkadot.bootnode.amforc.com/tcp/30335/p2p/12D3KooWQeAjDnGkrPe5vtpfnB6ydZfWyMxyrXLkBFmA6o4k9aiU",
-    "/dns/collectives-polkadot.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWQeAjDnGkrPe5vtpfnB6ydZfWyMxyrXLkBFmA6o4k9aiU",
+    "/dns/collectives-polkadot.bootnode.amforc.com/tcp/30013/p2p/12D3KooWL6v6FHMtCP5VsiDbMHLRFiW6YBtv37BarpW3hLqnDski",
+    "/dns/collectives-polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWL6v6FHMtCP5VsiDbMHLRFiW6YBtv37BarpW3hLqnDski",
     "/dns/polkadot-collectives-boot-ng.dwellir.com/tcp/30341/p2p/12D3KooWDMFYCNRAQcSRNV7xu2xv8319goSEbSHW4TnXRz6EpPKc",
     "/dns/polkadot-collectives-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWDMFYCNRAQcSRNV7xu2xv8319goSEbSHW4TnXRz6EpPKc",
     "/dns/collectives-polkadot-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWDumvnNwPbBg5inBEapgjKU7ECdMHHgwfYeGWUkzYUE1c",
     "/dns/collectives-polkadot-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWDumvnNwPbBg5inBEapgjKU7ECdMHHgwfYeGWUkzYUE1c",
-    "/dns/pch13.rotko.net/tcp/33573/p2p/12D3KooWRXudHoazPZ9osMfdY38e8CBxQLD4RhrVeHpRSNNpcDtH",
-    "/dns/pch13.rotko.net/tcp/34573/ws/p2p/12D3KooWRXudHoazPZ9osMfdY38e8CBxQLD4RhrVeHpRSNNpcDtH",
-    "/dns/pch13.rotko.net/tcp/35573/wss/p2p/12D3KooWRXudHoazPZ9osMfdY38e8CBxQLD4RhrVeHpRSNNpcDtH",
+    "/dns/pch16.rotko.net/tcp/33576/p2p/12D3KooWKrm3XmuGzJH17Wcn4HRDGsEjLZGDgN77q3ZhwnnQP7y1",
+    "/dns/pch16.rotko.net/tcp/35576/wss/p2p/12D3KooWKrm3XmuGzJH17Wcn4HRDGsEjLZGDgN77q3ZhwnnQP7y1",
     "/dns/collectives-polkadot.bootnodes.polkadotters.com/tcp/30526/p2p/12D3KooWNohUjvJtGKUa8Vhy8C1ZBB5N8JATB6e7rdLVCioeb3ff",
     "/dns/collectives-polkadot.bootnodes.polkadotters.com/tcp/30528/wss/p2p/12D3KooWNohUjvJtGKUa8Vhy8C1ZBB5N8JATB6e7rdLVCioeb3ff",
     "/dns/boot-polkadot-collectives.luckyfriday.io/tcp/443/wss/p2p/12D3KooWCzifnPooTt4kvTnXT7FTKTymVL7xn7DURQLsS2AKpf6w"
diff --git a/cumulus/parachains/chain-specs/collectives-westend.json b/cumulus/parachains/chain-specs/collectives-westend.json
index 8680e3a7671dcb402f7f445eea44baccbe79b00d..6182218d3670cfc661fe528d715bbf222c747900 100644
--- a/cumulus/parachains/chain-specs/collectives-westend.json
+++ b/cumulus/parachains/chain-specs/collectives-westend.json
@@ -19,8 +19,8 @@
     "/dns/collectives-westend-bootnode.turboflakes.io/tcp/30700/wss/p2p/12D3KooWAe9CFXp6je3TAPQJE135KRemTLSqEqQBZMFwJontrThZ",
     "/dns/boot-node.helikon.io/tcp/10260/p2p/12D3KooWMzfnt29VAmrJHQcJU6Vfn4RsMbqPqgyWHqt9VTTAbSrL",
     "/dns/boot-node.helikon.io/tcp/10262/wss/p2p/12D3KooWMzfnt29VAmrJHQcJU6Vfn4RsMbqPqgyWHqt9VTTAbSrL",
-    "/dns/collectives-westend.bootnode.amforc.com/tcp/30340/p2p/12D3KooWERPzUhHau6o2XZRUi3tn7544rYiaHL418Nw5t8fYWP1F",
-    "/dns/collectives-westend.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWERPzUhHau6o2XZRUi3tn7544rYiaHL418Nw5t8fYWP1F",
+    "/dns/collectives-westend.bootnode.amforc.com/tcp/30010/p2p/12D3KooWRfefWRo1AAB8LCJhVr8DDe9CvBmmKUzJpjd2RGk82pnL",
+    "/dns/collectives-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWRfefWRo1AAB8LCJhVr8DDe9CvBmmKUzJpjd2RGk82pnL",
     "/dns/collectives-westend-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWMAgVm1PnsLVfxoDLCbYv1DgnN6tjcRQbrq8xhbwo4whE",
     "/dns/collectives-westend-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWMAgVm1PnsLVfxoDLCbYv1DgnN6tjcRQbrq8xhbwo4whE",
     "/dns/westend-collectives-boot-ng.dwellir.com/tcp/30340/p2p/12D3KooWPFM93jgm4pgxx8PM8WJKAJF49qia8jRB95uciUQwYh7m",
diff --git a/cumulus/parachains/chain-specs/contracts-rococo.json b/cumulus/parachains/chain-specs/contracts-rococo.json
index 71783481e5cc7ba962c04701f71fb21dc0e5eee9..4d920d0f985167d900e739de691fcead5457f759 100644
--- a/cumulus/parachains/chain-specs/contracts-rococo.json
+++ b/cumulus/parachains/chain-specs/contracts-rococo.json
@@ -1,7 +1,4 @@
 {
-  "name": "Contracts on Rococo",
-  "id": "contracts-rococo",
-  "chainType": "Live",
   "bootNodes": [
     "/dns/rococo-contracts-collator-node-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWKg3Rpxcr9oJ8n6khoxpGKWztCZydtUZk2cojHqnfLrpj",
     "/dns/rococo-contracts-collator-node-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWPEXYrz8tHU3nDtPoPw4V7ou5dzMEWSTuUj7vaWiYVAVh",
@@ -10,19 +7,15 @@
     "/dns/rococo-contracts-collator-node-0.polkadot.io/tcp/443/wss/p2p/12D3KooWKg3Rpxcr9oJ8n6khoxpGKWztCZydtUZk2cojHqnfLrpj",
     "/dns/rococo-contracts-collator-node-1.polkadot.io/tcp/443/wss/p2p/12D3KooWPEXYrz8tHU3nDtPoPw4V7ou5dzMEWSTuUj7vaWiYVAVh"
   ],
-
-  "telemetryEndpoints": null,
-  "protocolId": null,
-  "properties": {
-    "tokenDecimals": 12,
-    "tokenSymbol": "ROC"
-  },
+  "chainType": "Live",
   "relay_chain": "rococo",
   "para_id": 1002,
-  "consensusEngine": null,
-  "codeSubstitutes": {},
+  "codeSubstitutes": {
+    "5359899": "0x52bc537646db8e0528b52ffd0058ec83058e85872f195310280d6b3a35c814826c5c271d19cf6466ebe71025804c36921e95ced4fc057fb24377fdae8e23b127d9774ae5d72800c07488bde45c93a21f22799aba9311951d7b8d1b5615efc75ed2f6eeb6e5de52ca2465671caa16151a4edd7ac6df3e6b5bf576b092f4656db34d9bde2ed4b6eaed200d2b397f8ad5977aa92df9811d2f82d3d3326803fcd4f1d3326803ead6a9dbb209fd5acea64d9f22132d337dea4b3d87ba44e23f7938554a910067d1389dfafcc0d936ebd367dbaee7cea783976cef48fca06d1bfde996a40fd2d092f36ddbac4f07a9c864cb49631dcc896adafc76a00ee6c09946f3411a5a92fe14dbc10ee78c753007aa69f3af03591065ecfcbaf52a32d972d2580773a29a36bffd92b369d5c11a5a927e8bed53ec4adcb4ea4b3d4526dbb4ea4bbdd44bbdd44b3dc50ce6b74f9189fa5277a4fd4bceb7247da74a2916386b23089b43d9bfba6d5bfbf4d936ead39b0c9b561d9c148c63d3aa4fa722d32cc3a6559f22136e5af5a5063266d957a7de9ef1579fb5cd7a7550d636dbb4e9d585da76bd3a48434bce9fe2f5a55eea263fb0e345707a5a066d809f3a7e5a066dd04ebd9d964de8df72366dba25e94f5103ea5de676ea4b3d876a89c47ff270aa948a0167c9669cb927adcff8a78f6d9bb9a7a79f2eebdbc44dc76d9bb927303f3d6c1bfde973689648fc270f274a0500ce2e16366dd634eae0cfdc939497358dfafc0167170b9b366b1af5fb33f7f4f4b2a6519f3f203867ac8339504d9b6f9b367d8a4cb369d3977a0a81b3c1d2cd487de69ea27efa7c81330023f5e9f3138245839182824b880c42b8087923644a48104268103283101b84fc20048b101c84741172038f3042dc04b141480d41a4f0c82945516aa3f485121c253194c0502243c98dd2184a6adcc8505a41894cd2144a68949c506242e94a0909a5324a6194a450f2a28485d2104a4028fda094a554a594468907a5354a4228e594ac502a42890a252b252c251f94a050d241a90aa52094ae502242498c52144a39288d517a42e98b921aa51e94a650da41490625334a33286151a241c905a51b94ac28e1a00446c906a523945a489aa31483929492114a4904810a5225c894202804a112240525256e6d946a507a214894a42794a024bda15442521b4a51496e24d551a2924446d2559215494d2485917445929aa4374a5992a4506221898a242894d8245525fd9004441297241f92b0927048ca21094ed299db55121349372429712b23294d520f49452411717b238985242c495992ae287991244709ea06c52d0d25294a282899a074c2ad8da428b739372e6e6b24a1b999a174e5e6e6c6e6e6c52d8c1b9cdb17373092d6b889713be3b675ebe2368612971b1a373592a4dcd8488a22690c25189296487222892ac94a9297db124a5d24d1b9c9b9b9716be2c6c44d8b243694a69454b091b999b12511e406a52db62892d6285551d262abb2fd60f3c136262989a42eb61e6c39db11b6226c44d886b8bd51ea420115055214e040c10b14c44081160ab850b085021828b842410b40d8001205903840cc007206103180c001b205102e806c01d102c2068817408e00d205903940e8006903c81b143c01e206054f40ea0091024818205a005102081240c4002903881b2061007903640c206680e4809001040c2046001903240b205b8078012203121648692059813407290e921a486b90bc406a03690d243290e4208581b4856406d219486320a1812406121c2435485720658144055217486c90da2065215581f4051217485a206d81f406090c242da43290dc203181d4c4111aa433351b6a628e66382a01a988a3374854b529908040a201a906a41f90ba20f980640392104837207141da8224035215241590a26a2a20c180c402d215d20b4856905640c282d4029294da9cda1b484f6a746a6e203dd5ea1c85393aa27645ad8d9a15b5343535b5ac5a153539352a6a583532b5336a4fd4c6d492a86dd5caa8ad5163a256a616a666e6c84ced86da1035aa5a971a0e4746d482a86da9ad504ba31655ab52a35283aaa15033a196426d4aed84a3306a351c4139e282347534c5911b353047491c4d1df970d4e58806242a47648e6a382ae20888a33247528ea48e4e409ae1284a0d8d9a1a35336a6cd4e21c997084c451961a1947421cfd50937234c4510c476f20412199507b8254a65644ad841a94232c35186a52b528b5a7da18477590ccd4dad4b46a706a40d484a811710406690c921624256a5bd4dcd4b8404aa2e6c2910b472f1c552155d5ded4baa88551f302002a00200a009e00a0040040315ac3488ed11c2336465f18b531d2c2c80ba335464d183161746564c6a88c510e46628cc618e58cc81851190941f486910f464a18793142c20808a32aa3278c9c305aa2088ca236456614bd297253f445111b099e48f05454a7288ba2354558145d51644551565115455414a9291aa3084e9118456114bd51e446119da239456d14b15124a7688d22358ad2288a5384469117455d147151a455b445911645531449510445119604528aca1489291a5364a6285714a6488722218a8628daa1c84b510f453e1455155915dd5054435110455d8ac0147129faa1088822228abe14b1404487c80da239445a445a10b541d4059117445b10ad411406911c222e88d810494164055116d114445810ad21ba82480d8f268892203a431486080dd114110d4452442ed0e8d0cca069d1baa065d1bca0b9a16141a382b68626066d0bda15b42dda1bda183436342e6859d0b4a0954123831606ad0a9a1a1a18342b686d68706856b4226852d07aa01d41d381a68526e54714b4187e68fd00e3c79c1f6e7ed0f9b1c58f2e68597e70f1a38d8f267ca8f131c647153ecaf898c287191f593ec4f880c2c7950f2b7c28e1e30a1f4cf8a0c207181f4ff808e3230a1f47f890c247123eb07c2ce1c3091f647ca4f181840f343e723ecef8c0c207103e7ef0e1838f2a1f5c7c74f131e523071f37f8d8e263061f5a7ce0e023061f35f8a0f221830f1b7cd0e0e3051f523e4cf001a5079d1e6df470a3c71c1f503dcee881468f363dc8e851460f317ab881408f317a98d143abc79a1e5cf4e8a2079c1e5af4d8ea71450f307a6cd1238b1e58f448d3034b8f177a48f5b8d203aa47951e2af478ea71428f283da0f478d20385a13186c8186a63880eadced09ca12f869a185a82c71a436886d20cb130c4c4501444270c95192233f4c49013435d866818e2323435b4654886a119866a184a62680d8f38435578bcc1c38da11278d0e15167e8cc90191e51e51ba51b3cd0f070a29ca20ca34cc3c34bf9a69c53b651aa518a51c229a528c128db006d01caa1cca1bca1f4e2f34389435955ea4093a3630bc80d9f2b588ecf0e2f147c62284f28a17ebc5146e199227bf85187f644880c09459eb013459ae06538193b56bc0a57c39386670a1e2a78d408b921fae053b8141e058f12435978191fe3627644e146ecc0c251e57ba127879f373bccec68c27331ad1d563bceec48b3638a1d68762cb143cd0e2a763841d466c7133ba0f02374548103051d699284e051a5b481a80a991b445f1c69a1430c1d40e89842c7950e217478a183091c597048c1a1028e13703cf17903870b38a4ba273e2c5fd497c28e137698b0036a070a3ba4008901f202e403500f40618084005202c80c5019a01c1019a02480c60001014404d00e40460055015901e900540410124041001d01f4c34f969f2b3f587e5a00e2016808a02f404b0081112a63f646880c1d5fe0b042c71338a4d06166080b1d5be810a3a38c0e25886010a5884c1852c1480d9e2578cce450a3a4a2c30522283ba4a0bde1a3838f227268f1b8f2e992430521367c58d12c3c3de880136323d44550981816426984aa10da42c80a212da12b8496f84942880b212c84d4086509352144c56b8a0e2c3f48085509ad299201e48256c3ce0a4252b12b84b0f040c10384500a3c4e04a9e1430a0058f091426c851e758c8e8811112383c7123b8a08bafa1913e405b7411b83d1002a03880ca0374067e0a002c88c1e2980d8007901d4051017b33633343f63004df98102e8849f3340503f687e9ef871e2e78c9f268068009201a80b900d403500dd00c405880a08871fad1f2a3f59fc90f1d3c50f0e3f543f6b7660d96165470b3baefc5c01340534c3cf0a3f2afc70f123e5c7849f127e4ef879f283c20fd48f163f707eb618f2e147cc4f98a13143b921314361869018023374c4901143450c590d113134c4901043410c0131f4c350d5500f433c0ced30f465080c1fa92214889e86d230e26276068e18662ce0100207141f3a38a27060c1f106870e38bc8463768c89c1f9211326b183881eaa1e23c225626e625fe0a8020711df0a9d131d149f0b9f161c6070e480d31061f0a1e22bc38788191ca13578748095007bd2f106068567071f2aaf3a436dbe341c8a4f0d9e2f3e2a144df5e810cba2a7aa074c8f1821287a6ae8a1a1c70ac7949ea91e247aa8e85902c70a38a80815d183d533450f991e287a7ae849a247092133312b7420f1c5d033a6c74c4f143d677abaf4f0b0030c8e283b8cd82146a84c0f113d657aa8e1c9f5bcd023b583a5e78a9fe951057da22fc4c6e0a9417ca1a704d914ae3ab22e80e420e342b6856c8d0c8b1e5fc8ae90a5d9b922b3c267061f2aa322685f846478b8c4c0103222c645cf10b13376a0e830a227d703448c8a9e1f6255c4dac4d6c4d4f40411f342088dd0191d6076b2c4cad8a9120b2396a667879d14626a088d11bada99125b63476a0786589650cec70d1c5038aec4b6d86921262766468f979816424fec40a267861f37b134765488b9114323b6f5b5107ba3e387d70a3d5f7a6c100aa32388589c1d17626cf03823d406aea3a30cac858e3160516052626362b99898589898103120623ef8d8e05303cc0758558f3774f8b0019f344224342064e5b3868f9c9712b12e765878c5f0b2f27ae195c4abcc6bcc8e5c920baf2d2f265e33e838e275f592e127f722f38a7addf032a3c36ac7113858d0318410181d45bcaa7c53be2c9f0a4454f8b0f1cabd60782df1927aa910bae1a3864f1baf2b426614a5203e418b52a2b0c305a324c434e214a2146214229608855806005484a61073a2181e47f0b841488e8e307a9820c609d708b3422a4235619aaf8d8f0d2125c2abd009a12384c4f41cd113068709a112a1181c300839e153272cb3238c50143d458461ca2e3d378466c226422cc22770a480e3e9432126c667e5232344133211e6be2b3d42e028e143e33b23c4da412684a2088a0f0b62153bb47c4f580d1d64e035b01939d2c06ce460032427a6824f0b3e2ee0386014b0844f0e0e3538a6f868c091e6abe183e1b3e263e1a3a20707a1243e193ea92feba3d2c3e5abe2abd2e3c3b7e5bbe2e382a3051c5670bcf04d25e5926a4832228987a430493b241d91a443900e4242f00c81cff0e1c2e3c5478b901a3e587cb2f8d0f07ac3e705a1347c56f09101f6c4e706a138580b471626b3e36a8712465bde15ce75589d145d14dd143fa0104242084b4798170b424c0849d19de02571a7e8e47454ba35ae96f742678487c265e34d754fbc1b3a19baac7b86574427a67b73b1e8bee8c078415c389e0f5d994ecd75c3b3ba6d7469745f3c196e1a9e0df78d57a5f3c16be196e171e9aa785aee185ed5f5c223a233e3c170d9f08eb86a7464745abc1dba213a2eba193a303a13bc1fba1fbc1abaa92ece7dc313d301d1b5e9ce78593aaaee8a4eca1bd3f1d06dd195e041754c783d5c333c1e2e155d1b9d170f88dba68373c3e8d0e854f084e86af04ee8a23c335d0ade5367c5a3ba5a74733a163a31ba26bc2e5d95f7a483e2497542746574307825dc2c4f4ae742474597f38cb86078345c32ba2cae1c8f4c874397a693d2bdd1dde051e9c878583a2c5e0c1d0a9d19170d8f850e8d17a5cbc1f3d2bde0e5ba24ba30ba2c1d9dbbd5adb96b7857ba1dbc2f5d94ce8d2e886e8ceeaadbba713c24ba2b9d1a9d0d1d169d129d155d182f87ae076f4bf7d46971bbf056e8b878536e1dcf843ba73ba32ba2ab73aff0c27463bca8cb85a742d742d745878467a5a3a163a3b3f270e8a0ba2aba2ede0cdd119e0e770b0fca75d3b9b956782e5c31bc213a22bc14ba253a36978e07a65ba1f3a29bd269753178653c257410e133c75be245c56322c94c920ddd96fbc5cde2aeb955248d49fa92641524eaa6815581a5402bc1270a66028f0f3c6588502082eac146880a0ccad5c6288a212d7c70f0c9c1670bcf98201b84a6d0a478c4f01431821e52787ee8918514a586040f11444af00411b33ad2fa9e1885213283240686028c4a0d8c2337b51968507cbef0f0508ba12807a4145c5f884ed468a871e169a226450f2a788438d242230353a1361554442dcbd193da1a9e3044573519f016b32d23286a5a8e64e04902498a874c2d8a5919b029b0138e8890f930a486acea284e0d0a9eaa19193e8c30fa6136c6f806d210352390823882e1e88bd10d24178e82f099aa5951280ee42434ca115a02920efcb4a12b50156815c732ea8107cbc70b0f1a9e1c84aaf05cf13c21a402cd0521167890e00133b446057ab61031d1230300aa14cdc063e55385c7089e3346584268f858293ac3c34451135f1c9e237c6028a2226ac228080048113a23c7135199a2168862f0e1a1e84a100f4155413d944f2594f20908060d07d0cd0bca2bcaab041d5474a8a0a34a4843c825e829084ad0931f303f45fc58e55843db92230b1f337cdef8b811fa227482100a42503e5ffc58d141830e2e3aa682b282ae08b2826809a22745551cf0000a4880870e3cc03060011c1400a780042060030d30b880c900470098400221418c4a2f461340fa93ee28e3eb6a4484221918024211231c183204a4f5032546860c71191995514c118c74a08892214125d66c624404234c4018d2c4c8067e4a28a69126459a8820c211118c2831820150f9c434b20127a6910f967830e483224b9280e00134d3489322479a2829d24404254766e599992489084d3c28c2a48992250588954d783064890694689024c9920234f1c04892244b0a2041c944adbc4a92a4880749921429c0121c68b20125469228318d18d1c090254d8634e1c0068e1801015169668a90e4489126463e1862c488067e9465e6120d283932840426463c1002094516e06512d388074a9628195264c81110de88074a9628a089120f2cf1c083cf5192f9608907463ed8518e9922906004c910114420c1c8064a961c114104230d20cbdc04c111109e8911244c96448003b214338718f180110f30c0011f18d9c0068a38408232cc140189074638e001125384264a8c3031c2012547bc04a3e4880682ca23a60747445072844993118c0c21210908201419c2c4c807498e780087c48325497042a5115304a0b2885964885069353b30a44893221f1469622401b19288101c4952e44893234a8ef4944378c003232318d92985984c9614202c83984a9680e081211f2439e2810c0c5152c483214740f8264a8c746003461af081910f3c90c4032547943ca008130ffc8f1288298291234d8e3059c281261e28c253fe30952c39d2a408130f7c30a4c99224220c3902c21761e281ef013a339178b024490686186952e48323498a7ce035a991241928d24489073430a4890746981cf940c99121437e7c7c6a3c29e83cfd740267eee9e9a953fde9c613c6132808d4b39d0e1da5773b7674a5bbefd0b1434775557af1bdde9c13cfcece49adad305737fb60411f0c06bbd6deaeb39dcb15e472dd7b27c6ae6e6c1bbb6ab5404020b5d376b5d6dbddb8abb76d6d0f602e97b5b55adbf5deb6780609d56b67b543d3625bebb5f6d21ddbd535e7ce4e672975d9cef6ddb996523c278fed6cb5b65e7cfb6bdc19e8cfdacf76d45adad9aeb3967695626ca9a576c7eed8aeb32edbd67ad39b73563bdbd5ddf6760fd1d96de7ec59a4bb5d1647f79db75e5bbb5d76ce3bafadb5e698d665adb593369eb4765f6a9b4e3ae9b4b39bce57bbaccb5a97b5b35dddd5d257cf796dadf7de395db66b77ebbd5d71bfa69db76bcfe9d5f6be7bad87fbbaee758598ceda177f3586b1eb55a7bd3d6df3b0f3c393c89069afa56dbb869ded28b5d6765dc57d47fbc276dadba331067ed859efbc5dededface5b6b9dd3deee98bdf74e6ceb37dbce0b58e0f6ad7d299dd4ce195a6b6dd74d6bed6c8be9bdf745bb7beeed5a67edee3a6dd78b319eddb6ebcb85eb17c39ee7dd8bbba7edad5fedbeb56d57f1bd4d74bdd9ddb1eea6f4daee565bebb59dbd6d2bbdf7decf56e0ce30bed676b8b3b61b4601a309cc607526810818cd6ad775306b8320601fe000db00da7530dad18ec26c87adbdaf6b6ddf49e9b59db5b66d7d75806fc5d7d6ee5e3ba715dbe25bbf59615fdf6640b5af3a6f7bde9cb376fbccd961cf026c686dffccc9c1ec6e9702ecb4b86bfbd5dbb5dabeb7abb3ebba2e5702dae572d9ce456ded667fdfbd0898f34edb557c9b766d3ce7b5f75e7b6fadb5776cadd6deee9ef852dba3d77d631bdc7aeb3d408f3ebafbda69e79df3dedaf7d6aeb7eb9cf7ceee0fd697ceee716c7cbd5183db38ecbd12d81ed5da3b271d6f4f3bce3bc1384e30e6c88163ac4512e0b045d7ebe9dd6be9a4745edaddb4bb27b5f8657970ec05bb3783eb22e7bc3def9c2e0c6e6db1bbeb9c95d2897b62ecaa2f9e8abbdeae6fe35b635d71edba5a3b7c71adaf577dbd6aedefebbeb5de7befadf8f6c55f13618b71cf39bfef15eb3aceee89a3bbd6ee1ad35cb7e7d7d54be7eceeeaad18577c71bdb5ceb63dba6ded6a9db39bb3ce395db6bbf7dabeb87bf6b5f7dee9ba3dedec6a279eb67bd63baf9ddfbcb6efbd75dad973861730d1e9eab6b69bdedbb4afb59652da75d4628c71b7b5d61a000fdd7929ae94563cbbf6b597d6effb3e18acfbebee5abf8675f7bdf6568c63b4b36fd302e07edaa59e17d35eafd7ebfb78625d677dbd783a46001e9eef35ef9dfd9ab767db49afb530db9452db614a077085848484eced6cd75fcf3969f7c4b762dc7debedbe2d807bbb7b69bdd8828bedb5f7de9e5d615df1a4d65aeac273cefa518c3bdcb785f4ec204a33a9ce79a7379bce497d66dfb67de78fe6d1f576d76e1ed6de6badbd8d67cf9eb3ef9cf3f69df5656dad18e30fd75aefeddbf7d68a83a6ed6ece796bed396f77d973ced7ed6e6b6dd79dedbace765dd7d98edaae76bd5fd7c63970d7ae8dfbeba6b3edb5f366eb7bbb6d77cf39edb5d3764ddb76dbb6d3f6b4d65acfde5abf7a6bb5f31befbdd7767dbbbbbb5ecfda396d0bc1424816b56736094c9674c04807ba0e1c69a2c4034c4a1f0d34f1400e9f118c706048132547988030c403118e748049912622fcf8090010120f8a642049922545150001e900fa9109794a961c69e2411111941461d2644893231de8c0121a58062931020208458428f8c00813231f305932c4160020468e3069520484c74e93224c8c2831b201263dc409c488082218610242079678308489910f2cf1c00893214544f8c00323439090d8020004040f8c88702335708489910f0c51420a4000807c6064c892262090c0c4031ee14432f2012349868c50a4033b7c6c604992211b507264031b5892e4877640c734c2440343982c6952c4832549921411fa719f118c7ca0e4c81025478a70c0030d68604959812dc7084b40d04447110e88a00349110f3c3082c4160020b28994040469081023488a24c9c0900d2839c201118a70c0294892e408921a10117e204d204d962ca97d50c408131a0946900c693282112513804d8c6ce0c7d14412a18908474630520480096484231a30c20484da0f9322469278f04192231cf0604893241e28a201231f0c69328211a20f2831527b26d210254b8e88c0c4c8078c84e088084334b0640913108618d94011264b9a8830a4c9084628f88012235502518c76a24e9c9c2af69a48136da24446404740ab48c489f2c09c386972aa4d4e16db8ec89c4e4e9c3871a2b873e2e4f472f2c23122d309e8c4895348643a019d383971e2843a51224ea89313eae4e4c489134bc4893a71d24e2a1127ea395d274e401791e9e4a4894c274e9c3871e2e4e4c4a912994e9c3871e2748934d1a6a62632023a82113491e9e4c4c97472e2449d4c274e9c50224ee8a444a6d347c4893a716a274c643a71e2e464893851a7ebe4117142271127d4899326e2443ba74b644ea75a89385127a726329d9c9c9c2c91e9e4d4449ca81325329d28910f3c13e89c9376408422339d7d056960bf7e76fa5a1aa06935e3af731ad5725eaf9b5b5fbcb1699d83f3d2a3e939ec47c0ccbd474eacefc899fb7e1c7ebf01a6d1f44a26bd47ceabefc8a4076fd85dec939cb9bfe444f3969c590f7edeb4f5c31eedcf012e5cfb4767d677e464f3984cfa4bce326fc989f595f467328eb50968b509684a968c13046925b32bf7d3717419a72fd549e2a67561d3baae61f41cecb0f3ea390e2ea3d7afd9b4ceb3fdae7426e34c368a3056d0b4e9b52518ec980054327a65320e356dba92b196de3457ecc35e178bbd5e410e1071edafcfd409ae1399aa77e2054f1ec6d8e502c1a40ac4da9caf97f7bdc018f34cf3d38226d665a301965e71c63caf7e3a08864d6b75318d1e963949f89ddbaef4bc9279f6d5c7a55eaa1d39bf92d63d3204275f3b72fe2543a05f4b59d34651640a71b41973f82fd8088b894ce1cece0e754df0d3c1b169b36932a650c4a03f9c461ec298c3da57045fdd7e6efa5a7ed80bc32ebcb68661d3573bf83874d9d40447cbe9a4dbc705109cb4abbd1d0c870f63b618d0b74d9b8ef1ab9f004118d869d2dc393f2d2dcf7a5e6dead12e5daccd3d656dedae94cc8df5d36b87b6e7bd3def9d3d3ffb7db5e9d779deec89f1d7f3fb664fd18a626d2ae2d0058a17f404c1d9136661b0da14e60a43f1e94914674f58f87a75e9029b0e9b3df5b198b8c1d755553c9687a736e5e9a9a64d8f13274e9cad7eeaa7ad3265b0b0725858397ae50a8da253748a46d10fd880b035b540d822d224ada082172f6871834ac95cfb89c1572ecd5c67bbae36ed6a4d5b32d2aed5daeb75d8625c9b627b3bcfc3ae0fb420589b821efe3e970b14c3977dbd6ad3970b0c43517c8db0988dc56ad398f882c1c631b613f2ecc8ac4c569bca62e118dbd9e1e191f5843e3db571581c386a531c387ace66e20615289cf5cfeca01048bc807e3b504f212b24549b0ac9c40bc8e9604fd8248ed0c7c75a1ce20538c40dea2ca4e4f42a26a0fe84402206f4abff881b7c5f4b112899c7201b14549b067d4f9dd2f92ee70f7e0569809f3a7e5a66af4e9d3a687c63356d3add99fd0a81d6f9200d2a75fab4cc19785b358da65b8a9b02ec0e019c0db6e7f027d82406f5313da23ec50e425c09b03a75ead4c1599f22045e38eacd349f8a995f66fb73ced86c1a2d6b89a9d3323b3dd0b43159d366d3bacce14fda2c67530a05d29f76e7676e4c17413f734ec4e93a9f4399567d9dfe95b67fad4c42e68c348afcea1ca8b79f44d599d88a42ceb4e2e92bf9fe545c9a46950d374d9b9ffdabe7d33b391d395db10ed8d06adaf47cfa52c5b8e9acaf1637e8a7f7ca0c9ab6441aa069d573b8a1533f7d16c66c06469e6ebe3a07da56bdc432e699fb60cc33b7d4b6ceab1ba06d9e57cfa06df3abd7755e5766fcb9f3ecf975b00bea60e25cde347338123e27c1e531fbf4647dbe03e8d313eef32e08970b98ff91411ad8a7a7fbf69f1ebba7c1cc3d2e691e49bff360b4b49dbafeb00083846043d2a100fc02480dc53746ea341bea802a83a6ece8c29f2374e4c0c2e7290e7dc8e8112ac1357333520f7d66fcb5ccf46b7d30d481030dc3202d464a69688cf4abd7125bdb8dbd8041438c193fe9c608b619337eb1ce381db464ae9e6dad334b0659ff5e7cf0fb697fceb11291f42db901a51fb401fdb069d3ef7f3f450c6a109531e39f4dcb33f744d637e9c7433f3d4cd2477af0231f04c38e3d28864d32b9dfe45e5b6b377dcdef3ef8854d0a451933fe26917ca03e0e245077bd4b74807d7abaef121d409bacef121d307338da643f0892e26bfab44013fb06288334b09fbb0cd220dbcfe1773926097f014eeff4e0ec4aa77d65a70fcaa09d7e1ee1e9e9090a18864de626e783dd649006b39c3d6893842f6b5a934cec2799755e93d9be6c62ef9be02b3b3d6e123f38412a86a0eb9bd8ebae9db529ec15e400188e3af838d0b2a9096e56a2ea84b6f7c5b6e339dbdb76631dc8c9ea0f707b3052771a0678bb8bbb6f4ecffbcaee7e24fd3b6f96ee7e338be779b55e3bcf97baeb3cff3c9f9ee779ee59ec799de7ddee6ef9610e1b3a265c14e825efd3db755ead574abbeb79de0e144adc7b6fe7d57ab59d77cb2b06947ba65aafb786aa2caa46ebb5b44dabe53c4381c699d342d0f5e1aa69141404edfa838505a769641b55d5cec699ebc3f408ecc2de70ab6a4ed5edc6998325c6e3389b55354dc7099d8765e3cc693531045d1faeaa44412958d092f72948c3b6a47db0434bd6efee75aa817d8fec076f6d3aed7d79e5e7fa3c4fe0f23cf4a067a19f2eeb5be8d3f112e8fac8a66aa276daf952bdd1aa4ad43e9b8de3055dd95d9ad6cef364146a5a77f9762acec8d02aebb3197eeb19d3be1d39db664b17f8f2e979fcd93bad96f41243d0553573b8f63e6380e1a825f4a44a7c617c45e91499ec0b367379e6aa6ca882618cc910b754553573aeaa99fbaa660e57cd5cd59aaaf1fab5555dcb94a0b4ebdce941586d1bddc03af52a5ee0f49d5332f75fb77504aab812f5ac58c88c1e5da70e56d25eb23fac619c7e49fa95f42a5ed03f4ba1a6b50795707f4ca2f64af298b4f649ee98b4f6570070bd1dcd191522348fda3bf7e77e2b5e505f681ab5c78e18a767a16fcf478fb44d9b5464bae5d8b4e9b6cc755de5807328f7d3b75beb4e0fce928aead7c1c9a36a9c4e8cd1faeb4e0fe22f9cf506849bee7a1a358d8280f85ce00f16d605dd53344d23d900c3d9e7e3ecc31e3d02bd08c570eb43d10df1e5e3f271e6ae0f7b56caeb25c24659e8e3cf9c560bc1719ccddc693406c07034aa120549196361d836cb83a3424d2b673f468cd4f32cb613ce7adbc14dcfb5eeee7ef234aa6939aed8e10967bdc57062087a9ebdd36a496208ce66ee345aadf63e707864a39696d0936c27d6e313e27af35eb8e91e39451c70256a9f353152cff85aa71e1337a86e7d142f70faeb96cc7d411f11e7df33eb82119e9e9e4a781aa5a30b8e703ae891413890861e19e270bd813e3d8f3f3dcf7e7af69f9e693fddeb0d2c6954256a7761fc8d239ecdeacd2b6725cafe99466567a251d328088b917aa651df0ecec2596f41b8e9206c84bd4458080361ae0fc3bc0e766130180c662baca991d79c46d97ae763dbaeef881b54bf1e13996e99e905b61cfbe9270f279ed3ed1d2dd0fa1c02effcd9b75989f2ecdbb3d06dac44edd4e70ce272ea7406f19c7a53219f53ec947ad8b7d0e9257bd23aef42a0817dd0c13a69bfb08becb76d03cbeca45d24fd908cb2c374131c5702ad83dba13a8849fa930c9bd66e71d33ae3af23206dd3da3139ff8a177c7fcb1c58c6e9ed95ec69d4d51130dd7e95b54317397fac37af3ef4e6837e64cfa3ce316927adf34be249eb3c24c349d4b90f0af49db77bbdc92651e7ed2506aea841f9d5c18e4e5a5f5e49a751e7fd9d3bb122d375f0369de46b4ea3cebb725a92be6ddb2db3d3579f35575f2990fa9cb73989b2877fb6e799f5d3e9bc4de799b7a5ba807a9b9528c982be619f6e800c10d0b6ebd3e7c40f82b344639c63d244f9d8cf315344fd143118e1e9e9e9c907cd286b9be7d485da96930cbd054da3eeb9cd2b939a46bd820bc3687fe6ccacf93c56206546eb6631e3a68b9932ea9531fc993323a784d115e59e1941156e0ee3f74207317a3bd830c6581016cc88b9683046f1674e8937178c126a5c1546d8cfdc122ebc25b3c40d9f67ee678e7a47d29a461d931334111deb4da889a8d3a6e5a1a7de65c64fdde7cc9867eea967b00485a33ef68d3e519ff56de2a87bdf2c8e3ad19871fecc55a1f3b39fb931711efc997b6285cfb3cfe3539f43d40975f2fa66014e9f2495344f1da44b3c75b0bb31f582b154be7cf73347c586177fe6a848657abd9f392a2c8493e48165fc7ee6a8403d75d00b27c9c38571e6a6c8f98cbfbdfecc4d41e35d3f7353de3c75dcb676707addb5b5e9c4af398da6771a600a54ba7a6eef1c77e4fd4a32b11a8c4b6da77cf91f208c4f4f4f4fa6b8c15ca37a2732b55f9103da3788433b83cc9f6515e3cca140e7e7cf0761d3ce20fdd3c14ed4c0da5afbdb3df1004eef7947f6579289d7f9f526de579f65a6a0177624fd2e8459e7bb72ce0972fb2dadc881f5f62a6ef0e36d39a751bf12da57a738bac15ce3ab37a984f6b5a4d3a89d8a4cd5b1c801edbbc41dbd4fe06cb0cb89b38b854dbb53dcbcf52972507dfa52b7e84239c9821bc5cddc14ad32d39f3925694d6b6f91a92b2f694959d3e82c05303f73297cf99cf4ede2cf5c0a5a3ea9de869aa8bd995a641a6a5afb529da237ad2730fa7725e7cbda36bd3df79387d3a555053002237510e4911b537ac1030c12238cc712230dc1bf4318bf4b21d2895221e02cb118670e052a7f7fe6a0befcdc01abcfa13cb1be1dac24fd998332e1ad5766a7f76a5849fa208da261d7c6a4b6e591d6b6eaedb2b6cdbedd825a976fafa06df4abc854ba19af5b6f5baed5dad6df9ed4377f7a7a7ac2b52ff5cd71ed19b40d7f3b026690fa0dfbf67621282ddf2e1b9aa06d38e6161f02adf399c88b17cc355f1daca195b2e19df2d6c11b7622130a6f1df4c2ee84b70eda8ede3b9bc7ab3a6c06a965fb52a5e41499bcd24e7176b1ae0c9b76cb59d3a8f7cf1c5494b7a5ac76896462fde4e1d4512bc60db5b6c4e508e001a64f18381b304ef1004e6f6de944a9018e28c0103759b53a387b3a48c3e92d22c0e991cc3204273f3db7d359cea6cd91e64e70f33377c2d567d85b97e067ee042d5f87f2f8d667dbba0b7664a5554480d3cfa665fbed1d599dbea903591005ac22d36d3183f935041242e73a69450c286e5bd005f43bef4afcd42f497f0ed94a1b06f00063f546d2949242e8503a2f98148ce1db07619d5704387d7b57b7b7f3f6ea4b3ddb1674417bf5da3975dbb67c1d49ed1cb7adbf0b7fa997da89527a05ce068c20ec048b00275ae2a659b70ec23208c1c95bb74e7dd2b7e56c1af50c80b36badd5dbadadd5ab1170b66de64c90f3d5e7f449823cb08ce0cf9c09514f7dbec02965ebad7720ccb6adf3e925fc7470ce202f0741a7d05fe49c46619941a610fa3100cbdc0f3af590cc4e3ea4ffca223879d05d6e7dce209fbfa6d1abcca05717fd23e73412cb1c7a9d4fc910bc3a75eabcf12e0fc9ecf49d4ff102fa2e5f6a909c6f4924aef203f43bd7a0bff31637b0de6576faf6f994ccf4a93f7de72106a0cf69447da92e35488640eb3cf6900c1231f0fc2b33fdcf5d64a6ef72b02333fdce45af2207d63b9f2253e84b0dce928a71e64c787aeb9d8313ec708a18880e96d93e58fb03f85ffe2aa9a881fdce41708aaf323bfdcb43f203f84307c94c1ff4398384650e3d49909fd30874d0972a485607690892d5a7f82a43a84f45a6ce4532775e7d8a1b58ef7ca9977a967982f2a0cba75311035ae7c3724ea30c9621d03a0ffaf52966301f2ce79ce0f3ea22e77f24f58e9c8f49fa348dae7b646ea70ed2b023e74fb19d3e7acd00bddea4c0dc7d7a2ec5c73b376a97f2e32f0740752928509ff991cf7a93f25336ed780572293b1cf4e9b8dea4d4a4e0f01f9f3eab37293e65938fc360fe137318e93edee45336c586fcc79b7c3c74984ba96513c63e964da37bd59b6ad9844b14a83761d7e131177dfa586f525c6593cbbb1dfc299b4af778f80f6fcf7fbca9fda76cbad7c7b2c9e5a337fd38e852ac03954d3299ef944dd5bfb2e97312f426d2c1b2a9566f023dc879c6d1c3b2e95e77954db56ccae12e1fab8fde14fa58365d1e6fba4ee43dbc69f41e65934ce63d65538f7b9eeb289b643abcc7ebf11edee4798fb249c7577578d33754a240e3299b78bca7c783787a7a4ae7e172b98e1c2e17e8fac89e1f9f581dbdfe5c3e15833d1746deb0f14f0cd698f4c63ababc1ef0863e3f3e9884c5aeebfb2a387a3db170f4f9c29f98d7b85d30f2f6d4dbf353f18fa2116c1809ba04b11eae1f3f787ec0fa111179533b11d1e7e3533a6dc44e0b8b8abcc9e54545a4e7c1bc74a2d0e5449746f326d2693f6818d6337ae9453f312f7209bcc9c7252022f226d0897a10b904def4dd1f3f40d24ba7dd1ea7f58f1f3f8abcc9f3a2b2e9c78f5875097af4c8e14da1e7f8bc74221d9e83878f044ee44d3f4e44a3f9f01e6513cd79f470226f72390f6f1acb21e7e1e91f2ffd478e1cce43870e0ff21c3c3c8737c53c07f61f3e8137c17c025a137209bc09e612d021e721814fe04d3ecec39bb013d184844a172272216f225d887a13e842de2328c879e8289b72944d399c8707e9f0206f0a3d887ad3f51e4ef3a6d169d4c70f6ff2fc47d9e4e3879765930fd7a1c369de54bdf4a6cf27289b8a8a7ca86c0a2a9b829c87c785ca2620200f2a9b849c87c783bca9c783ca26a02007f2a6b05c9a44d4875c021ee18ee7289b80ca2620cfe161e8a537b9bc2c9b767878e94d6009c224a2bee3127893ab1c61125197a06c2a2a51a044a0f7289b5c2e97954d32077b38e84d5f2901b06c72812e5436b93cfc3cf426b25cc024a22ee44d3d650693883aad6cfad1e33ecaa6b26c2abd07e94365130ff7b26c9a614461034d9d2d685881c291519c70058a36ca80414a143829a42ffd9478125127cb262fdda79c9388fa8e7256a2e93a72fcb850d9143473a0b2c9e90820c4c0cabac1cb1347e07e9c628072050b64ac60236b06dc8f37c5cad924a2fe5336cdca59898eca4cfbe94db0729c44d47194b8124df7f1a65a72601251f7299b7a4a14284e4acc656513cc794a146a3829d577caa6d8cb616593930d38b881830d72e28c6106ae4e2cb680a8818518e490610327a53acc9bc63269125187954daf725622009439e9a73779656d125117cb59259aded4259149443d2c9bc012051a4e4ae7aeb2c90222c090d1439c29b674c07d250a8e93b2638c1a4288b9c28436c4c04969f7bc0997b44944dd2b9bba725622a332d77e7ad32d7d1251b7e55889a64f77aa4e88daa88e9c2b36637bc65fdddb466b5bb663dbb27ff5ea436da35f1b57a368f9ea61db2afd3cc1579f6d9b5eddb68d7af539544b24b59f3c9c28cd57954a01e7cfa13c7e3b48a9e7f09b5290929d133b9c33086e5ba65fbd8211835a62b0434ada0f67102674eb43f0fe033b30b08694ac2f7ea00bb5fe03e16b0661429f3e04023cf5f62972609fa8a8c1f8f4d4c3b6cd6f9fa206f4e9a937ed2c703e6e5b06b220cad84e3d57b74d9b0e5612696caf3e7d8a1cb423a9256edaf4a576a2d400d4a75b5c2975908695a43f455ae2a6515feaa55eeaa56ed2368dba53d310c059d21967ae042d3f7350e27c867d75097ee6a05c3d089b4379fceab66d2120a13e3f3b7d6ea73e7db68dfaf4296e808496411bd8a76e9ffa084f4f4f4fdf3e450dac7799dbad4f51833cc25bb7650848a8cfcfde535fea39544b24e34f1e4e4da914700ee5f1db67db66d332fef68c7ffaecdb6ca2f6e9e0a460ec9c3e386b23384b3ae3cc41b1fa998312f519f6ed14fccc3d59f32d32956e46ea33f714f5edb36d9db7dbb6616fc76d9bdf0eb6c884cb49631dcc896adafcce813a9803671acda76206f33b0769d891f331491fa462e7604736a1df39154360b24db3aec1f89d533183f99d4f91296c1af5a506c129de323bfd754c66fcd83b32773e9b867da96232dbcfd69bd4f77c8a4cd7971a04a758cbdcf4d53199fdb177649e4dc39e67d3f2088f3dcfa665101e7bee7c362d73e0b12fd54a7a65084d5fbd23e763320bbd7590861e39bf23e74f9103fbd5977aa92f1942fdea969c4da33e45a65adaa6515feaa55eeaa55eeaa59e435d22197ff270f2684d019c148cd4e983b33682b0d9b6f6e9b66dd4a737694194917a7b75b045a65a4e1aeb604e54d3e65307ea600e9c69349f8a19cca70ed2b092f4a7484bdb34ea4bbdd44bbdd44dcea651776a9ac159b21967ee099acfe3b7d3da96c36f6f9fb52dd3bebd7d82b6d16f17ea1bc5b58f6d9bb9275fbe5dd6b6fe7670966b8c33f704cccfcfe3b7d3da96c36f6f9fb52dd3bebd7d82b6d16f17ea1bc5b58f6d9bb9275fbe5dd6b6fef6297630678c69347fa9c3b64d6f9f435d22a9fde4e14429ed02ceda08c2e650f66fb76dab3e7db68dfaf44a864d6b072705e3d8b4f6e954649a65d8b4f62932e1a6b52f359031cbbe0346fce837b8e3c0e51d8736de5d022293773219143229643399cc8297cd32b299e66573cdcb64a46caa053c25c6cb7c9c32e36534e45ec6c5cacb649ec4c5cbcb7c89cb192ff30c6a50e265be802e33bccc25d0e58c9739111bcebccc3970430d2ff308884cb2ad2916beec2f6330e18a5516736c8061075c990131a2cc50620c161bd8c0955b5f3a0444a6f2f3f179c3870a1f231f1f0b7008f13e6e7d1c6f51e17d7cdce2c2fbc880e57d6410e37d7c66907a9f19ca781f7f80c8e4a3c5872749c7a48fa4cf487780c84436802a8b0c3f34e41d884c4320fed29041439827d0743983afc2c0a0021465b4cec065600f9f808770c520d6420c345a6ea4c25ce1a2a81ea66e10f346540e980c6cb10f8e827be08a41ecf40316313388b1c61163a48189a872220b164ea0a2460b1e033776ecf3090a26f1c54eca9e147a72e8c90daac8b161060d345a9eb8b206082c4fc248010516380ce7b1fb50db648e9d66020e7bad6da563af20c9ca9bc70e42178f9d52b5f0b885359e3c7a92f4f186277d76858d27ddb144f1a43340642269d5dddd5b18e3ddddbd8538efbe0091c97b10f5b052e77b04f91e3d5a28e27b380722530f1fdafbd4de27e97d7c7c7cdcf8f86433646a0518b0c6b09ac1a7062b4c1083c418392d7cc4f0f1f1f1f1f171f7f1251f2712e77d5c012293cfd3d090952e3f24f443433ee67ec81320320dcdee388ee3388e6e463bc680458b248238210618c61f67486931818612527418c318ed388ea3d3323f5efd3866fde86f8c3e8e3e1bdd475f1a9dc893d48f4ea746a7b9a91f1d0122d3587e967dc982105f0ae0cb928533bef40d44a652e633d35ee633d75ee63327bdecca6432d9641382335c5ad8da8a1283824c8a2bac20630d2f5a3e7881cb73eb8dec338df2b22e4a9c00c3166fd498029729d4500a66b8d1068b0b104f709946b9f94ca55ee692f9cc94ea653e33adda42e6516fc86432f7282ff325a89739912a4f595ee6748a051d5ee607109964540391091371f53cdcb6cdf63c3c03918987008a88f8e177f8fc8e1c8818034685373394c1edf0b1de5c608ac8a2854a0a2cb0e07680f13b76ecd8b1c387da36fa8e21bafc18e20c11508f1d031fc7711cfd02916964129976f8586b6d5b0bc5bab5968db5326b496badb56c2cb53ef6892dad7523c4bcb5d65a6b9d6677b8b546cc796bad47f165e90610994aece3e3e3e3e30510997c8e60e149d2712213896532994ce66fc413ef6edb66f4ee4b22938fe3388ee3388ea31340641ac7f81d6e77f80044a61dd8ca95c7188d164d6cbde0c5042b65e0700e465c8973450a5bb8d0431b01884cd80291c9c6604c56b440210d3951fc8004cc842943a8b11245858822605fc0606b1a97a7d674f330184c0ac6039b3307ab063561b24e7803d3f284152f4facd0a60b181b1885c960305ca6590ff322a6b8c416bad8b03587ce166772f0f045113ccc9903861b3898170f83c19c566f8d8379adde2c0ee649581ee6207c7998532a330f73312f93c96432172232c9bc881bba0e20510608286ab278438c0f1b305b47508501c51ab8b18b1f3d88c834628c31c61863ec4a2213aeb9568494b7f5adf5918a22a0de7ad24d648251f13adcb6cd5f87db44261dd88a89cf217e8e1c3972e4c89123470eab176a8f3d00d8caca5b5bd7b0e2c4145794c1020bce5e7139224b1834c254c106ce72f1d62b1099ac532032e5485ac1cd0b093910914988a7673641c3952914a874a1218c9e1c305879e349cd124690e9d1eaf1596fb51edc537b7ac61ebfadf99e9eefe9e9e9e9e9d9eae9f10adae67d8f27a9f91e15e4f8584186c78e2432e1990a66fc381681428c1da4a80cc182156e9c66a46819030d16a6aac0c08d5bfce83591697432b009660554d898a992431531682a50bdf52391c92651d17a987dd806b6ca4861072b6d807982839580050827a88ca07aa30607d3e2610e009109e64622534f549a0f0af20944a6201c65e681801c03f908e43320a7d5db0804e415000145b500e4b14b2032616badf599f52291c93a91c80494c4e67fdcfe384d64faf982f533d9cfda30430d97aa357268cec0cdb8c06a6325c417209e600237f3d9cc279879056dfb7ee6b229764441e4b39f790e536f6d0e467869c10b1b1d88d0818ab7bef40587b7fee3aa73d263ec13fbcc13eb31f61c54b03d9953250b2fb404f10687e7b401c61922d408024e9535395c79ec4b396479ec3eb47a884cb317dc3c8e358fc38744261c16fccbe7cbe70b8bd7ebe9257bbd785e4e47a00953058a3955a8c0e205b4e58b354eac918688165e57bc5ee3ebd5f37a7df9d764628c9a14b29290624b9a571923aaaa4851a78c2957e032b5b2e2f5a268fe952996cf6bcdbfdc052d60ff725c6f4a62a4c842cb5609729ec0bd7cacb7211a80b8e18a0e38985903f7f2d9eb5f3ed43698bf9c566f33f7f25adbb0bfbc82b6d97f79d209ff7210e0fccb299515fff217a2bc8f5b1fe72132f964da5b9fb9f636e9ad5bd1f2d64b91c96ef91eb73d4e8a4c3d52587e1c8d806943e607ab33ca28831baba0e10d183c645159c10cdce8b3d15d641a5d18e3656edb06f432df2132c97096f1e02c5d3c0e7a8cb3b8f1d885338f5d87c884b358f1b08739aeb723699881c313399421f3030ee663bded4083072c2b5540e540030e46c5c33c870b894c2fad31599ec72d8f07894c3c3c9f2dc0c01b2890e092454555143be4151f6428034a165e18b1a36667e7b593dbb13b7667c691208b34aceaec7086145aec842007385a6a98a2f2a5869d343b34ea777ceee09dbaf358f6384c13bf837f678ef1a68613c6ac39c30218dc8e8ff506012c37d06cc170420a57703b53fccece0ecc7776722ffcce1829bf93fbf218e39c9ac70e341b63c348411466cedb9c18306ffd4764b2fe7abd5e2f9f894caf30383c8cc7c31c87c804f311997690c0e2636e63de2332c5b0054e43b4d1c31774c0c80d710697670e0067ba60f16205383244c1e57925c5e78925e6b9e6c527224c14679c17773821862d2c6eb8200697a79c17b524410316553b4c810197e953149f299448afbc288e9ee9d48bb4cb8b0ee68917bd179d7cb881ea873656d841079c18c69b2c6e70a186143540e1449f8934f1e5a2e84964bce820b46de69038f32298393f62fde83291698caaf2b87b4c019a364f4421434b0d5438ecf424068e16284f9e4ee80187a178ec3c221356f330b76dfb7998ef884c302c55e7ed5bc7f5c6848918b6b8d962861931380b45971bbc40030b2c2c51e0accf62229375305efef5f251647ac144269152851fcab208b108c5300cab088bc2ac0fdd868e7fb0e1431f7f20e34320ce7c18c40d1f864100f1a110533e14a28b0ffd25328515b4cdf520e833d0c77a7302824e1b433cd9a18c116fe040c7f5d68486295557d0b04214291ce8b66daf077d36f1a07bdbfa411f6a1b76d069f546a79e9e9ea0e040273e87e36799509acf43afcf13bcadc0822c3bd1eca0c5db27de3ae6e1cb5b1f7960e3adcfbc0714de3a2d8bb75eeb418cb7b9aa24de7a063ec4f0d64591c9620d3d369386cb9b2d563021882d5ca63d3ea30b197e7882460831b85c7b3cd17c4e7abc83138fb19519b884e1c21413c458c1610aa2c069430566072e9ac0e1338f77b8e2b18722139e22139844e75d007897bb442697053914e18394368018030c162ecfdc7f376cf1a20428285b846083cbf3aa89cf136b66fde7b3dec6a9f5df37e120f19fdbb689ff559963061a2ab264799306eef3b1deec0d53acc050278b2a67e03e9f7deef5469f68f5567b7aaab5cdfae715b4adfee74966fc1743138fddb6edc763ff44268c99f82c7beb136be8ade3b65918e2bc752c32d999c8f46de5be92d8c129de3267f0d72b9993bedab256d2734ce65b2649faeb5ee969358d7aa5b7c6cb6a1af572cba886c7e3e1e1e189f3cd43278bc7e3f178b4be9de7a9de261931c46871268c13cc68e1800917ae6003cb131454c0659eabcf3c57d820074a1a2fb69021052ef31c8db1441b50394061060eb8ccb3c4671eaa1e2ac410c3932e654c91029779aa8a48a551d5830d3b98a983cb3c4a7ce6e1e1f184d8f184d8d9d9a1e0f38e67b5e3edc059a3e55ded60e59dac6fdf79aab7263c50b186156e54314418b818d85c5169018c30537481cb3b663eeffc2093831b58c4f4b002145cde11e262650a126db4c0c6175cde29f37987ea8d1855bca0450a55ae5481cb3b555269e274c1c5992eba88c2e59d243eefececa0f1b6cc236f4b9def189beb39e6e63bc76271be6374bca9589a9e5af3edb1a77a0b6a012b8925a4a670d1028e016b30c166092b304f6870390645e6732cea8d09476861c1d2c30bb81c93f2010a0d3a48d9b2c4132ec7c67c8e398123e58a2ab9354848e172ac2a8817a228b383164d7481cb31abcfb1d809b81c43d3a53176698ce3d6b79cef510e9b4e0e1c0f6af4a0460f4aebdbc7a77a6b8016362baca086ea0a10149032354519583444c1059747027c1e97800107286238e38b171a707994fa206cc042e5698a1ea4100397c7017c1e6580d3c40c5fe2d0e9a10b2e8f5e0d476c19b125862e5e707914c0e7711c3b27609d133018acfc0cebb0601d16acd382755ab00cd3fa76d853bd39f990c50819d8f0c2072a41e09a68a9b2830c6dbab892c2651894059f610f284303125a4411061414701976660e1d352c8031420c2ec3847c86c98161071fd01843cc181e701956d5419826ca8c7146ee862ab80cb30af21996835d859f61683a2caf0ecbebf57af9e7179d4e2a8dd46bcd2bcae7d795d3d3d3530ab8fccaafaaef97d5b7bf9eea2dc7d6102ae8b0a5ce530a38afaa8344d40f526c2185cb2f28a5cfaf280f58d150461d299ef8a205975f52398240634c951ab2acc9e1f26b2ae9f38bca0dd10d5114c538df6216b1be4551ebdbc5a77ae32903654a0b2d9e244107c743136fd2f032054b0956b82cde3e8b3b7e28e1891daad0724310b82c0ae0c9125b5bbc58c34a0a9745db67b10528bce0220521b288610b5c16ab2e20e78d37554d7409420b9745ab007c1673e215f8594473c31b86a18ecfe1cdca82e3267413e650ebdbc3a77a2362a3071ac0e0824d15181c024ef0218d0f3194e141085c0ea12af81c466510a70b28506188a105085c0ea52ac085883160766033250697c3290a3e87542c50b10026ce1773d8a882cb619512982b6560b0b2e20a257039b402f2390c4334570a78a5802008c6997d06e94055a20ba5c5e53308a299aa9ab2a2ba55a0d43708824ff576733707da308f6ca8e3da9283e3b38b0e15151cab4a64a595c367d795fdec42835585654565b55c5256cb35e58afa76d753bd59eb82b2553e5be5fbbe2fcef767a33e1bf5d928ad6fff9eeacd49882656b0220411595c78026733e2052c88d0a212c610b8fc41217dfea20460d5e6c9992576c812062e7fe51b75803853058505145cfe6a9f3f9a9c329410d382165180c1e5cfa80b9a2ac05881092fb2c0e5efe8f3f7799fbf34701a1863dcf319cbc172b01cad6fc74ff5e674c49b2c319c20f5e4892d7038b2b851831730be1831042e6328007cc651665c41840c5dea9cd1c21bb88ca52c90c58b15ea6429918512b88ca78c3e63aa09dc5061c68cd4171baec0655cd58115eacca043982a3f88c1656c35c1679cc357b1cf184db5c1ab36789ee7c5917df6e8542aaf527995caf3cc7cf6ae5c9f3d34b9aa9c1515962785e54d7951dfee6969796a3a355dd7819fbbac2eab73d3b9e9dc745a1d149fbb9dcf5d7deaaafec9aa8bfa04d420c594382fb081e60c5ceea4b2d28861abaaca1a335970b99b92a0bd7baab75a3ba8de611ef50e75ee95f37dbbeadeceddceddbe5adf7e9fea4d03545664e44cd14183095c03ac6809220b1b30b87cc1e50b55f4f9462dcdd152e16a092bd85081cb57ea99a8f282cd12536bb081cb778ae8f34da20936b2008144d41c32b87cab8c3cc9e003114b80d9a2055cbe56b4cff75ee1cf174d1af3288d3a6bbe71d96ae1b27563b7e4d8cf968e1c8b9595b357e2678b06aa0acaca52b594956aa9a79eedd4b7dba77a9ba1b075050a525da2d080bb31bcc14413403cb1841bb86ca17e7cb6514f6d9847d4863a754bce379d6f2a365470ac2a11b5d2cad5abef734583552956ad5a55ea9b6a4d7d3b6d51e28430aec030b34514383a604cc8d5904396a83570b942f9f85ca3fe013dd5746e36b9e1585cee38fdb9e948002b4b2ba7449dcf7d35fbdc6840a89a5b5654f4a9a59e7aaaa3a8e786faf67eaa371a5589a810a379443d53378cea7cad12b1a9c1c9142b6ba45aed33d3adef4ce97cdf3adf3e8229e4ce23eab0cf140dbdeaf199e6de9c61430d161ea00893022e532b2d60ac08630d39392e607099560d7da654df4e00f1268e196c18d18515b84ca79c8aa03285161b58b8410317b84ca578883004152e96807a2187267099427d3b7daab7a946d69321d2a499a287295c3b08f536732334cd20f3319c6fffa06f78d46a5f40bd89600b2a6b54ad51c3104ae0c42d60cc48b1050b8d2370ed63dbca6f9fd51b08be887921972583096070f30d123e404961b5421a1870e4b7d7ea0d5cc345ced6960d57a6e0da93eacd296a8a4a0c26a4a4c09c61f36f4740dbba6f0fda6124e58cd9b37aeade55bd7554b5bc7aeab128c6acb6515b75ea9ed6992728f4f8eab7a3eaaabc296feaa9117fddb68d87070c0f5ee4b0a0a2b81900162e40316685334c54b1e3afd3a2e0aed7ae7bdbec5f1f6a9bf56ba68aa82f62aa78daa61a2f6f996ed28b6d8cb993f3d44536c6ec413d751d51c6dc613d751d258cb9d37aea9d54bd75609aa876609ebad453075a63fc2162cc37eba9ff0c31e6ebe6a9fbb419f3857aea2e2863b6544fddf564ccd6eaa9e7b062cc36eaa9fb8031e62ae7a9fb5431e64af5d485741873673d75212f63901b63109d3177cecb9a4db34ee55cc7f5e6d4835618639c408515365870d7c77a9b67ccd0440a4fcc40060d1ab8ebb3b6e9f8eb4b6d9b67a4d8fc75034cc15d4740dbaa5f5f409540df2cee3a911984fe2d7392e9e633f6d68431cecf5ed65336ef65795a3f2c8c99523df59fa83153aba78e63cb9867d653d731c3986b4f5d870c639014635014639e3d7d7a6feb270fa71e94de4004d65707d3cc727e45c3a242484d39585268d1a98ac799d36a49ef2abf32d73e635c7a6557deb252b51595c2148a4a59326eae6857b9a41a062f18395949350b2b576bed94684f0c8d33d354d0b8de701351f73468da82a73da53d76a29fb46ab38c6b59495adf0f4d45a1c651abe6c266f0154583473a45a7e8149dfa1c0822d153f48948cfdeeac661f89233e6e8619c52ac91e6a7d3adb6e546f3d56ba3695bee5ce7fa0ad7a8638c3f6996f3abaf34acaf20d8331640a136a50fa118e1d658bd3dc801d5addbb2896e21b3050b57cbb1c9200734d9188ac07539ab44d49d70740531a4dce09ab4311481fb62264610f5ca84125d6ce19a8dad33826899c21638222ef37da600a119eb6d9e51738316a806377da4423a3683ccbff51265bc50841c3b058b0abaa020a7de3c37b889a3e30cd2949642608ceea4521b95857abec549d494524ae938f61830f27f62df9c436dab8d6b9f9d7bfa66ca7cf7d8947a014e1076619fc3af1d7edf32e3b0c3212c64881e35a5af69d49e613fc52924a447ed7306b93e1d83de7b5e9991bebd9360ed3cf3269b447448e8a9e7a0a17bdd23e963b2fe92d17a9e98002a6e1062923e4cd4007b13fa9e2f1931296bdaf5eb6037bbd65776f24b7d450ceacfa6d1f52b62207b3c8daef3e030e65946bc807ee7216006a1df6e80a519c4ebaeb7839f0bac616843f186af2e8489081843ec1397f87b755ec1346abf64cd43aa9e77de5e9b41ae6d4e1a2e73fdeab9025cce6bc9ead1cf04705230ceacc70fc2dc67b3a663cf2944468fbaab761ee5f1abad73b6387d3a4d9ff4f6c4571a155f0160e6ab8733c8fc0b68f5024c2113d0a35a1dcf20f7ab275121d7ab07a103a0b819c47af53ab33cd2e2701a75e4fc596fb32aa34226a047dd58f63d8de8a474da5757363da26ec92c3ef54ae671a444d4db27a042c47944854c7a947da44479f674f60d7b3ac1d73a2ce07ca0290476adb41d40355230dab70f4e103654a9add46dadb7b17365a2be47fb5364a24396d236401e58c85019ca5dd553c7a283a18b65083ad8b4030428194234f1f2d09b447f954ee80d67e0f0841b8113b17caa6bc4b8f2840b3d748a9b1e92dd5425a20e929d5425a2b9eba1eb6106b150f689ce9c06c208f48942d1282ad552f5d6553df5d4a99c7e6aa88ea256f5d657748a52d12aba45dd502d9a45b1e815cd3d7522f556a192eaad5ee17aab5912584006b5d955156abaa9595dd5556f9fec535fd927fb649fec937db24f7dd5577dd5577dd557f5aab34eaef6a200e750c6584f1d88961644199b0a4d9b2e3fd1b071f3d4a7d64f345f94f939837455d3887ae396da47943137d553ef5c5fd59b0453aca1455563d51bdd929aaab72030344195a3aab7ce3d5555ab7a7b2921451351b97a9b584f58f5d66e80897acad59bcdaa44d45d9eedd553b753b6aade76b05c60f384a36eadb4eacd6e5d55ac8a3d5b29cfb38dea3c5ba8ebd93e59cf554ef55cb73ecfd5cd53af50f576abb4eaed6e7555bd754ff5a9dea69cdeaa37214efc90c351efacda5436abde26ee563df55ca3be3db79b7f7ada54ae32e3cf7aea76abde3aaa4ab4556f13473fbb35ce9c56fbdc517554b8cc495e996b5d9969b7cc6ecb3cab651e3fdbada77db7b08b76678454709b3703f4fcca54e0c458e6a90be524498fddf3d12365b3a6d12eb88451459417ba60a103ce735c6f338d344e2023254b4e961138cfc7b6e578cf6750de73a1b6d9f7ca7831e13d1fea1b12cef309fa66715e999324fdac69d477488df3f3f85f051654100505b78d02ab4f373e53b74db36e2906b369b69c4c21d4379e42a075de96b8963ec33833c654483f7df79ccfb68296d4e166a46fdd5235e01cca74eaab8374ca98f108ed188fe36cd644d9e57c0561a4de77765f9fd7a7d87dfd3a78c90e81d6c9b5c75f7125aa331d75c6ee330e9b766f39d4b4aef34c6c39a76a1496913af833e74454d4487de7670ecd165446eab19f393466d00065aa891a5e18a97b3f734ea020fec44dd9db9fe294fd528330bf3252b73f7363b4f89980493b88d9458cd471dc305277aa94e20052dab5ea1b7f5befbb09be7de2981a2b9696f3ed99f64d66cc649b36a9379993be1dc70c63fb526d32d342da4080208cb39c38401056e6ea9de7d302a624d09b2624fbe9e0c4b569d4b3d5f26db5ba714736cafac7b35978e8dc0019745d077a5eeda6efeb76cf4681560bfd96da05bad7a1f7f7b57f8eeb6de69f7fa5ad5ded6a471df4cfbf99e77663bbaffbba0ffc423253ea7ded7d3e64d8d928584f9967b232cfbe1b77ca3c7e87bf83b9609452ea72d06999290d2908f38f524af1835e38dbe6813e3dd17387dee527964840c7fe853012fb8b9c7f73b92aab29ab2aaa107c3797abaa44561d9656eeea3db0f3a837f543d6a94ae4f98c9c952857aaf7dcf35cec3c0f3bcfc18e7a8e1decc2b0a4a08db259b0c884a5b244edb47b81cb0c094d500be9e775a0d7ef73f78f04cbeeba8beccaaf5aa956ca542b6a807308f6faea95323ee76cd652b369bb6d9b95eaf54adbb0d75aa63bdc5957145c6b57bbdad5aeceb0d6aef67887e9ac56a8109f6ee61987833d0e760eca1c2cebac6cd22f2b9150c71e7ac65136e9af2e7390862e1004c12ea43ed54a48e61e59474ac023ab539242598088c8d4951268da755abd3c31d1f330f6ba0e83d0bbd6aa515d9ca69c68a9516029f5b4cc18630fd32ad536afc3d573d5d26c2aaed5d56cda06525ad2285fc63cb3de01d701d701b776d30878ea737518c6d53daf51558a22a1b0d0bb5caf7c6ee279742c3a2e73bdf2d5bb58e9792c5d0ed210638c71999bdcd06928964dfa6b876b8da2471dce930d6d2d5c6f34d85862b1745d98e8304ac5ae5ac118e7ce5522c1ee3958add02398533237e9ff600ec248cf5f3727a79bb2aaa20a018cecfc456207a9d774e47c5356555421a89d567da203e6b2b0ae48a0d59b0444da5f1a8dcaf92e8e04c499e52ab3fe7ab552add0a3ce63f3b7b5aa955164f2ea956a25ea270f2719d5714617a746f399054b38ac20a96dd4e57297cb73b9d7b9c8f9b4b3656c995b7332df2d43b22b73931acd556b57bb4a8f8c2523813864407acb28f3f6e3742e09d89ce7799ee7f6ca734bc6f32cf6c8d832360e762a327d1220a927c146076bcc9234ab769387b54329481df4f04e89c47e64a810997b3d9ed3fe23fffbf9efebf1efeb299158c7fe7ddff77932d2f33cb282c76dc316bcb5f8232956d33af7488a864a35adf31d926a21e9d434ea9c03dd0fffead38db5b96ccb809f7be457668bc18e7b348d139613349fdbdc67afde9619e31d8cadbdf2b2bd42f3d4a9a534ca74e3457d4e4afd029452b7c00c027a964c1a2f63c652f8fef7d56eb216eb33c615046dceda2b0cd6a5c622075f99b32df3d5b108da328f9d46fec4fecbdf7f4e3f179d67472c9158f7e616344a961b58695c8df1c52d6966f1df671def58ebd8abb5167b8e1e79fe39f59184912f72b4f9fb4ca52c4eaa378cc7a4a47f79fef139e94357cca98801072a51e7b11f3fbccbecb35ae6d974537618638c71ec85bd8cb95c74ec193f164b4b861ec54017393f46c646d84b74c54a6f84bd44170d63a4e721f93978ef379b1acdca735711add55644c1c4184b861e791e23655d8d92954935365f542a558a1b698c61c970a0dea85425ea629e7ff86c9c6ebc091e7b341ed29be63948369569e4f90e399bf692aab7ae32893cef3a88f73c56e61f3bbce76399dd86f71c56e6d996f7fc55e6f11bcb7b2e9619bf2543856032960c15b206b319e1cce2e449e7338df2b4cc4926f82413fce772d07392099e3a58e6b906043f10047d823766cb583223a56d81db9bb4cde59e8fe095164419279c4f02c2bdd7857375e1ebf8ba72d85b2ed2822817f40faced20d4f6cfcbe7054f7d5ea86de15b53a742104fb58deaabeae8775de756c4a05d74db36afc3539f97ef4bdbb0776b48dbb47252076af1828eac514dab8ec97a8592d8f33aefb3123dcfe51f95ebabf244ec752e57d7755ee7bdbc0ecedb3ae37cad5a9a5661d55d6477695af518d9544d545d2ecf3f2aeffbe2c258f4ce3d8f82b1c25f10df8ea7b07f54f8abf23cd173795fd5e7e5ab7acff317c47b2590103a23c55daa9ee22e6d7339754cd5b7182dab54d3aa53aab17aee2e1e6edbbdd5f5597df670ad78eaa3faaabc8a5d65febebcdcfbbebce72e5749c7d1411a7ad86ddf62af3c7ade4725c2c81c7eee2e5fbd124f5530747925af8b1e862f6f2fc3cf45f73c879e27865ee8a0e779def72524a9836cb442e0ddef6c0e4ed562a31582ee4ec9b1b92d38247c5e72d5facea9d779c65d9efaad4fdfc5489cd54469bc88e09d7e5e6a92a9f5f89bd805d2d0e502bfb2ccb8cbe3a9cfcbf7e5f3428fea54d83f516e6e4e3cbf4f8bcda5ed06dfcf2ff6e93e3a26ddbddb749bd6ea3639ab043887c276f3f66995fabcf0d2ebddc6d2beadd56ddacdad525f775dfde5a3ef38d8910e2025804170761b2a04f496c9ba6e03ea1f5d002533094fdb3bd201a4059a663d14996eb980a65977eb721e9f3197c3becf4d7fd8c12952bf242eb3c500f4db5acd468e531c275bcd0637481b4edbf085b3052484ce88c75929811b460364800004b4ed22600ca788c1c5b59b9acd8d037369351b2ae4fa971b0e752d354ce40097b9fff376e3026f596d576d576d47fdbbb6b39d9d9fd34b69d7cd861e5dea1d25e7bbc83cd2d6aa37af44d679ca3cdb29f32c56e6712cf3f8b032634b29f5fc13bfb2dbd02391c41e92f3418f9c7f733d655545150291bc1e929d833747debf5356555421a861a7e5e5b2b0ae48e8d0bab5f6af0351ec9fc841f8d41770ddbaca3c5e5a66117cb7a147d7b1836238bbcdf77d5f0922a1deddfb95f436f66e4385cc76d36de8d34f1e4e311a94440746360ba9ab73512a2e4aa5ebf068df35babc5df6690a34854953f868cd028c47a1e8df7b9d46ddd06ddbface39ff3aa5d2b60e4c4882a5ac69d661e4ac89ac5fd23b72c8ba54077618638caf771df62cfbf0adec2f9949f86bed044db3f7761da5722f7849f0debede5a9ca49c5cf9f6093a85ba0ed2a8aeebca4ce9d3146e30a74ea3da16527fea4b7d6949eb32cade5a6b2f791fb4e16841bf641ebf765307d5497deeb0eb2e85aa97cc34aa3b10532add5d57664ae5db5f2592ebd8bb978334ecdcf60d86fd8a94ecc89c24b4f73a6d0a458f6ed7a0d3145c18872e7a0e5f0c5dbed42ea7295021a2df24e163cf2fbf0e236713850e92b369a0832ef2fa477618634ca9b8c8393df2fe8b9c685e246f991074f82267d68b64f71f393f24f3c49a689e84f748f8c21739732fe6a4bf0e92b982bf7e690a34057a14862ef23a4da1a36592f09178de798e3d27099f6ed079dff53c9f34054a05378da6408fae057ba70de84d4bf25ac5ee955903ec9e7b4e450eb07bd73fcf3fd0033dcf562a5b29d0bd1289e7d62b78ddeb6d01b55689dab168b39ae715bbcb73dfc75e31c08ee42be902da6b9fb7e7ae32b7d6579b5fed2b7393fb9ed7c65e79dd4659b29c4da353eb9ad1faebe06c9b68af6c88dbf6cda7d43bb75a3a7a5bf2163168aff3b1cf6e7ee756aa6dd85e91b669340a84ada6584dbb8e49da85925d6bad33acb5bb73ecf64a57c312494fec59a8109877dd586b576b1dbdd6dad55aeb88bd76b5d63277b5d6760cc31d9dba4d6612bebbbff44bd4cbaf8300faf597775d6b399b96add483536cef48af6c1283d0bb4aa99cba3889b2573af74a2ddf65ae4ee777a4fdb09221d4af6526e95b2d6d0b9d3acd560b75adada79452da6c3a5a52aaa65da75cc651767d766777763b328f5fbba9bbcbe70a62dcb98d6adb152a847a97b523b3d5f2b962d0a356aa7ac556eaab5b8c2b92f62e379cc7cde6316eaf182f75deedd5c1aebbbbeaf60a3dea704852275f64a669fedaa8a6d5ea6d2ed5db78f1757da253cf67bd11a944d741085d7c9519cfc032cfc65ae6b1c7bfdd22ec25822008c242075f65a634044110f4296ef07928bae8a04876ee2231e8526f1fec4291a4ee22e7831f39ff2586dfcde55e62f8793797fbc8fb1e59ab82980a0118ab2aaa8fcc24fce71d9656ae4c8e04345958575f48a4de68d45425ba7e619ef1cf46fb9d035910a5b3204a57a79ad6f91539081f741a556fb54b134dd51b7d9a449d5fb759a810b0cc22f8fae53b8745497de7af32cfa2be73b1cc2385facec3f23a1886360b15d2555a76f6c1cfdb7313db5adfdd074b249f7bf769881de376ecd4959bdcffbaef731b65b37456ea3f12db2cf4a8bb2512aaf5938753487f60d1faf06d9adcd37ee6d248bde730dcb63bedd8b6d0a7cb663388cb67023cefcaac81e71d079e77d76de716fb52a5a4b520cad8a4bff33ce1f4752b6260bd2b91745ebd8a1c84efb92533bd9db7e719fb773d1c92a46d525de49c46b9c3c07324b8ccf43bbf4e450e42afcc22387d579618a047edd662801eb513482b0f52c0f9dacf9c14605e4b79c63873514c3d08eba65b4ce97b9ee739086da3ee791531c05edddaf99f4fcff3246dfbdcf316993caaa5925464fa4ab092d45bbca086ee91b2a675fe91b3a6750e52125b6bedb4d6f3eff3ecb49ee779d6f336c06edd23656aa83e003f7369b61eecd023c94cc2e30e93deb4ce79c8a1a6752e92b49e601a75f6b1c5be5431e979041f3a3845ec1e199698c480c73db7967a8ee938c971423d1cc17b1e965b8fcb6c2df93c64085e1d3a1ad48f0ca1be2d337d8c012ac4734aa913994142a70ec2561cec796a71f114674a4ba1a6754ea7c68cbff32cfbaeebbc8663dbee770eda706c9b7d309c220634748fcce3d76e1a213779399fadbb440deaf37c6576facfa9e712689b75ec16a042a8e372a97a649e5b5f1942fd4c9fa74482dd257210963437690c5021edd6c1fe97e726fdd4bf26fd18ce872fffca8c2d8ff82a9160f7ec0c1262b79f7b8e3f325b6f32d3f79c92a0ad8db17f5e89017a64490bd023cfa78801f6cf6b25638e496c4b0934cd7bf9cece883dc31cef603c96485cfe7258992948438c7d8a1bb8fc5562801eedf88e63800a81b9873d8feec54a0ba28c4deae3987b22399b263a0f399b163ab8437a0e925f1aac071f3b9cb70f7ae10ee93906a8904c1fbb975dee39082484ce187a76f9e799fa57e6a9f59e0309a13336a91f96485c8efdf3dca43e0e7748ea20484e1739c9fb31b2fb919c6d1e46de2f26a0bd178218e9fd484e301e46760f92b34d05b5f7dc456612de450218c6c8fb2339bf781869ffe5b948e6a1f73c24b373103e760c5021b8cc22780cd023cfdbd6fef9e7574c00765a923637a9ef2ab1836d6bbfb208dee554d4e0becb2580012a643e752c3251382e127f1a808f4b0cd023af7b51d9153887b26beadb41aa449920226857337478c837aa2dd3dd3ce01b7b9370e37a3ddd8ecc9c463a50e8c6bcd1873378401644196fd4e71b3595febbaa3252cf37ea23c08d9af9b7e3eff17b363fab1964003f9d9237aa69f646812e50002e9f32c0d082d16734afd1926a33d7c1c4cd4ac443280a791f21296290f71b55311ec7d9cc9d76a3e634a27a519f4b283d900551466bf5f9b6e71b35d58cd4add50c329780bdc4f005be5caf0f7bafeebe6c7d3535f2ba51d3a87d8a3dc218e9e71b1535834c97a561126090d5487d92752800c300f27a42d39142194ef9d4487dc7ecd9ed6f7d7a97d9faf51d8fc4ea98d3363d5bbfa0b5f6ad5324d6ebb5b5faf86cf5f4000a99e0d291c3489d06513152175d544028aebe49973fc93c58b1a27c937edb964e3bdf3c5867cf6aadf7cf3287f05d7241bb619c0eda89e541e4349a4efe1cf3fea00d2959a3e504b507bdce73e51ebc2125754c1927f5a725529871bad377a206fdf901ef85940caa619c9424a378100c434a22c51e7c8594241f8485346cda48e974dd075d2125e79807c1906e7d93fe198641741a4da74f3e48434a69adb5d61253923e589bce3a6b371f14434a06553182ae0f7bddebf57ab57bdf65c6e0add5349a4ebe13ead4dd9910c61337d82b465794466204550803863860d8c57a0ea9f67ca98397c4f636394ea3e9b9bd2b6797eddd0d8b81a1dddded7469bf99dd4fef27752827b47cfbe74494eba737f53a460bea57641232676c9f3927a0dc9f6e6366089933766207138d1fb2c66833c507325de0e6246a217346ea4144217346eae057ed373ffa79dfd7177f1dec959bbebdd2303e8823cc487fe6a86cf1f503639e5a1f82717a60b44dc63cb14030e6596684316312c62cf8670e4d154f04678461cc73cd4f179ba80efb994373c4675cabb70c6b196d894688cff86b1c1c41966afccae8527d005d54c3e5d783420b7a50682d0882200882200882200882321004411004c11d30068e200c7c8122c803822008822008862008ca40107410e4014110044170078c812308035fa00886a0cf21d0e5a29c717e8eddf3ce83401fa72a91cb83c07201b8125defa42a91cbad5777b9dce572b95c2e97cbe572b95c2e1e97cbe572b95cae986b74c15c2f97e80a5d3b2e97cbe572b95c2ed0e572f1b85c2e77b9765c2e97cbe58a9539692c730d5666daabcc2e967916967974395866ecf239e42a9174555bd0bf748a172c35c6f7fabb9d44edd75b64ba5b43dfde4d61220c2e3edb6f0787681358d28228e375eb5d77bb3bd4b6beb4b100eb0501c797b17dca9971bee734ca73ab71b312659af577844b36b153f63d6f99d17c93febb41fd5b9bb49614531843a1b6b5579fa049faedb5b43eca7c687e7738c6d8023887f2d47aea201a2d9386b36363d382e819374f1d010b985464ea604e9ca6cd8e4d0fb2faf605b42dcb9e1c9b1654cb0bfaab4f345b53dfb7a3ad215adfa2d427eab50afa16458cda61e6ca64d9ecd333519eba01da167bda449ca7ee80bed10ee66c911dacb14576b0469ca65136be833971ea8d825d694fab75b73c7d1026e4c3c8b342101963914934fdcdcc8ca76cfcf44c7b4a641a75ac0336c20451c5eaca062b25bc30000b421851e50bd60d559c8e3063652a8da82e66f04202565031c4131b71c8acc1516fd0cd48d4861a5798b18ad305181d51ac582903081fc844c151079b64c2a19623aeb7118f4d733d8dfeb9164e7103161c1aa250d12287095d58b1854d1874a080d1c497295cde4063ab8a242b4f9ea00165cb1628e0a87f754609346dba039a363dc794e93e4a8c198ff566bd2251e18918d0d082ce1a311628430c2a306cf8e2851796a455a2e995ecf94bbd546ff38a23e44ca162851ba4aa9c682013272b88317030030a9018655809a3042d5462c628564d6441f990060b1cf52025c69cf4f6fd73edebcd69052d4b94c94a618827a2e0a867506f04c8e22a8c2a3b58199385a35eabb759059d1fa0baf8c18d2eaae07c80f9c20411433411061838ea4d5aa0c63a6003ebfb67ae091c3e886accf4c9cf6eef8d2e014b6f619b6843d31841152a9cf17ba1cae8ed60c1186341d42b2c9c1ac6cb0c958b5e82ccd39a3ac3e88a42c71841156c18bf17b2466f870e33c682a83e8c3b50582f23e6a23271cb8443305181470028cf820a3c3213abd7707b45457bd29a514ff21c9e255d69693d76a7548fb1728f676fe7d6e31c7e9bf498fed3636feba9d32fa6102f6b1e519f148c9f727efa02eaed833158aeacb27821b5066e7a06f5a6c48734ae68a8e3031c32b8b9c64f4faab7528baa2c5cb67c1993046e7aadde387813478c272d5ad002379de6333a544edbaebf7eaaf1130d26c030a3c314335a7ac0f19852c2183e90c172c31cdc74ca6606b1483c5fd336cfa7d3acb62949fa2449dff9748ad5b699c64fa757f5f643852fb66003051bd4d8829b4e73f536dd8c81aae20a1ca8dc2002379d5ab56dc6f9e9b4aade14a0860a8617a640ad7005379d52d59b13d40d55a2f8a2062f2aa4c14da753d3a9d4741a359d42b56da2f1738b0da9a925a06250839b3e42bd153901872ad4d890c40f45e0a683309d03d3894ca76e289cb6b5cb7e7a1efa3b45fbebb9f6d72b1882cae724295cb640f43ccb5cc53c4fac99264c0d9f67d65cb3e379b2993c9ee71c43c5e799279dbf9442e1f04ca3aec050e63395a25a669e6917aa1fcfb42a881d88f84cadb2e0320503e49996b90af24cb1d28c717db280cb74cd5f366e846e9c28289fa99c4ce9e4f0dc51a07478eea82b566a7c6ea91570b9b5fced2e545545647d6e2b2cb8dc60fe7699abbf586058f8dc592fe072afd9e1b9d9b41b1e9e7babe310f1c6e7967305979bcedf1ae56f85fa5ba3ae6471e27395faebb3a9e072d5f2b776f95b022e57aabfb5ea6f0de2efd3e76af5d72b98bff73aeedb787d6c9bcbafcb665efeba50dfc64ba5c4cb643e01914966c18f3e479fa316231dcb71948daf311c5fd801873566be0cc1652442c2861bbe5c41650410e319e338e5b277a1f729137e047f0c72c58c366da441051565e04624b64cc1828c0e55b8c0c18d66fc38923e468d3e3e8e3794f9912aa586a8c428d88a83891c2441c6103343331004d000831660404020160d47f440ce7b7c14001483a85252401809c438cd510819848c31848c08008000000c4940006b67cd4a671d8eeb97db808a1f898264529b80ed91e57cfcd712d3830a233cc8610a8dc93a904354332d38912214c4ba12c090ca3090ff80c06cb72642f17ac3e262c9d921669aa362b8145d44ba660364eede73b562a4e12f71046f4baa47289220f12a6dce97c225b4d5c05f261071bb47285ea0391b1a3a5718064e6706851fa190e93da7f2500d3eb1198846ca46fc43312183269b8a1d975d85239e244bcba3675fedf05c4b921367d274058a851a31c3254f7644347bf38510275be044e3a668d2482b2180cabfa02d6415f0d7acc7bc894de299a29b0c2f3449d42d449962a4dd1f4d4e9d6a932c12d278ac94d13170092f3fe51287aee5a42e38e8071e082289ed53251604308476b61825676990d46556caca879c4369d1ca9bbbf75f4d80cc9a459bc5542771669ba35ae7ce65ea302d5c0f5bcaeb8c560a61654119ccef52d576584fce152846a05012bc054672a660ae749159941713f665cfe75be8a693d25297331e143186ecc16aff6dfe8014b5abbf1c76cd9f92ce8d2ee48c9ba328f71b73a2e6c5804e738850f52131c2b6061166a2b532dccc5d7bd898da65cccc8cda6c7ab44c3b068479c256db4387e2f085350a0a7bd0ab66224aad097d4c00b1468cbce488739b2c09c41af7f6c33f1db8a9edfe3fa907f850daa13c0787fe80ed73df4950567b10cfc3418e0369f2829a6238778025a5901cad99e4653a00547c63c64a1b031173575ed60d098e51ccc5beea78af314158387c84f3fc4d56540fd96edc3100b62cf3cae2936a3f0edadf7dffa812bbac63bd94c51b8d22542db75e3cf4a69ff5eef51bbb7c4c1d20a01014f88858ecb1b406befbf596ad87431e96a61f97a64530c440bfc60c55ff9bd7214e56d3117fc12639f27a948f4d1513dd57f6823875362f95f4ff867fa7c702026f5e5bd4ee9a2618dc3530b3ca60254e590e6cc96a627575b66a80603235e24ee8e84cc75d57fd043398b827c2b965b43c604ee71507577ddd0ddb3ea290bb9145d4332e4b848ffdd85c1a6e656928dd131ca35193e1c634011cd60a85833231c0a885e60c276017f6c108d25f949f77c8beea48d6a0c3602abb94a39c1a96f2d2f1942bceb6df71b13822ee829467ac9b3959bc7c62d12d99a451003a5a51d10d305c6df19a10feb4028cbda3567bf8298898f1e81d65ffc2ba1abe7bcc274d34c22d779a45b4d142db69b89413f4df133246b810289846732f1ff65b2d40566c1c972fb654ffd6a510103d2d018d58c85e60115ef320e448fd1809fe55913a8ad85120a4fe0d2cdcc1ccbdfd3d901b68937ce662a56c1ddad1e1d44b40b278d4cbcc3e06b7c8b0c686af54e75f766ae6de3d4a5f56a569fb6f2a1a3b637ec6e27de60b48593ccccfb534683ae0580d08045c82ea0512daf67de7ad8a8ca60f9f098ed668394ee1a8e62e84c97aa8fea78d8873a65e50b5f6c8de2a5441db872a997168ea88a1de2aac8fa2b75b9055440efad209853977bf2718c6bfdd465b4ad1dea453bd144c87d48b65f7f1ee854e7c18e0d60549b7d57153540575e38c5765000d2f49cc999a1a7d6c0a635f3d0f9215eb456c3c450d74a0abb9d5c168aa500e3d21b3114131f9d545b4fd6f626b0dccba6d2e9128d8f4eb310ed286793d7f3db61ebbc00ec81d39cab82f2c568b0d70eedd8699f652135917004057d2b027aea990e69123c470a54b80dc8f251d64bee342ce2a68dc17f7d665653d0cadecbd7ec87d43e660dcf9a8e8adfbd714676011d66208dcba39576b17729c576b340ab6668eac75603c62db496ed90be5f2daacab73ad3cded8196e755e7b91f5704bdc596e565493e20b9553a47a6d2bdae75ec7f77b33762f13df875b8442bd8edbb34575ce3d45dc0bb7c014bdeec7076e8d703000abbd7547141cacaca63a741ebae0c65b250a1b637a1f4070d71a3ebab06f4ed3d0741d8bf785063aaeb584943d3028d82779e8a429142c04c11f38835e82daaf251d0b3f215d8ac2dcb74278c03731ab35e1e470bad6400ce292b42ec8a93c3d101b1c5fc2469d49e67f263f9ff71134d2a374f4b311f58cc062aeec94897cfc3e69040b500a542782e4d96f6b37011f186844cda26a9e36bc5c0e37763dc2e8d88df83be8101cac9fd3e6792b472fc6567fcfb3baa58a5bf17fbea9fe6d55596a11d97e6daba2de15d556d36718ce10ee220e31ca71e5f8ea79da7c10d1c01fd32ae1c0a22029e6d40c40d893691d70ebffe4578631da3dd428544f456f48cf5485edf4eba94cbaaab4ad30ac78efd37762e558c9d772623d44362c4072bed92a6d9b23f1a8ca18bc3d7e3d937ae5ce73067a09cfa055ae8068d34375ffbdecbfc700a0ab00b895f95d67e6d7c25376f123433eaf0d1f258765e194b93e810e44a72a138d55f0ab7cd725f9017e772ba3ae5fee3deea3cee47464ceebb1167fcae7cab383400989ff1362ae465e51e306777de90ef494b93f5d58030feb0eb8c8c7155575968bef6855218890260621e19e8451ddb80d414386ca6bdd38cdcce81b7a68787c1b441e2f30353e13713e1848bb2bdfcf740eb4be2fb4ed3af5a8c9274e10f605898e44931793e2022f35c2c20ee367c252377e9769739e8d6e63c08718f6f83aae839bb095d5b2be655800a6cf8cae1ce77b94099155e07ba1382f7066bd92cd834558f24a111275991dc6954cc2a81e463c37495f3b0550742afbee43dd1c5a09d7a60f6e54cd4a0567128e96a710792418f4e6ac904ebb3616ada2531a1eb23b91bbced6cec446396fa1481ce7d78249d436c0f93e8f00155baea13f24d2d4522eb4eaf28ab279f372200ee530ddacf015d41cd333d6f9b0959f2cd7f7d338a3659b51ff120beacde3db915657f43951e8a18b04d6478315485543660f2d1382abd11dec340269a16a828e78f6b068e4afb0cce4b222bd875d18257971559b9b2003bc2fd056b73c403cfb4d9865d9a9bb4b51c1e2d3e434598c92518d40be9648cda87af9bbd82975af194fc8c4f80eb4fe9e645a4a8552501265ffc69343b1fce281c5aa59152099fdb23e0d640cabf3908ac9030db103e1e1fd1da3c444d4c57315418e4bb68b27e358bfc4f2755f5cc7076d1a6e06492c2da02cc5fb94030453478dfbdf73e030997dddbfb8a3882792254a9cb01b3e4fbae6216fd0ee4f16ca457f19baa043702d0858ff3edcd507844405177181dcd009d72475de994ab23bb9279380f6e9f024207c0c9322cfd1d9b924977179d02f0dae4e6dc4464f6eaf1c9a19debd33e45fe5f5c60508c139f2fc2e00a2f18f980ecda314448e0f93e1beb2623b525e49f1efb00007ff258355a261a60557e7b2f73c31b4b417ab082cd37e623a44db83d820b6c4b4b6c8d57918e357625a4c6276af9618558981c87e20fcba887c72c2e218a585a5904e9d1d08dae151241452883e6ef440a99109d6d98351221af2153be0bbb7c8d1ff8f0e9735dc211f0e372f8ca81fc776704887b137ab2f64cbbe4ab7d3abb79f65b73c77abbfd6a621544e3e8ece8062dfea48aa5443d7bbce5dfda90e3428588d60ce839c93850aeb5762c622b72cc24fa05e3feed98cbcac016693b06e62397382aa2556182412dbbf3286d83beaefec2eb18f50bdc95f4cdd2ec9c12c8938af0ee7f664ee0d95b4866f25008c528f232edad5f05295e14b74159596256b7008ef6aa69d8f4dccbc6330ce7517771061a6007dc29fbcba7e825bc144f137a0768ce172d264b7356271f6d6dad11b0c9fd4259989f56fafc3dea887f02ffc8ac66607d3071619f63fd24939c97a3ec48a1677653e09ca0cc3a88a1a4fdfb74555e1316abccd932ac9951d60fc5d4a74651b15d3e82330dedda4b730698b5da48e4b1f19e3d9e7be25b5a12ac72ee53cbfcbcb8a9028251dcd7d8448e5854042fa252f2da9497ec6e3979cd88867808ed48ad09775a5222b6742a44627a18621e11ec2aeafe1983ec3b943bfccc86f8d7dbdf952f8a960902030b56cc01000aca3a8d5609d1d503daf4be7bd2530bfb9745bb7b3967c8f4122a504e26cf74c7a8b5308e31b79af56905c44d20ce7382eddab854a487e1362684c7e300489a888b085d028429b0187b94b39cbcbbafe5d8061d262658b4babd880021ab48fab17847aed3bd3c4c15aef011d76af488370280f8022f8fb4b0a0e01030a7566200b247967117c5e20e507fdf895d6f144ca4ff41a5a44c74a89ea2eb76981b406b2820e8a1c7a21f97b96d6dc3277c195e61a1d84e25b746b71751d3c3dcf0e078c65320476e1777b85870c6797e5192f46a3bb2e5c2683436b4bc3b12f7f115131fa064166259220daf7d71b8dc37ca9a4157122b7f182c37c00bd9f77ae56823f2d9e1b53f2c861ddeda16a7a8406fd09564f8e71a131d5ee473d6d0aa45252d1c154ae07a8b7c5184bc002c83fa2ea7eaebdde2a7f28b47b34c5af7d2b4641df9b6ed9521ec4c4b5f56af8e9416c091cadd784a97c5d3f6fac8580dca49d55b8a4ccaa72b5a934b867987f922fe0c79621b8981d7b11b9906daff4c99552c529478793f0990667734c0bc9956d3fc8bdadfa38650e137eda35a0b2e009e46ddaa40168fabf0d6fbc6cd609d14b0d65cc6324bdb197b5887718af563e91a9435ca61807d115df8e4d8770a81d0b2bf64b0e12ee144b1339f0cda4abaa00a48c0819b998b5a9894838fb5f09ba5ea08f2e8999e0e9e0b433a6cc42938a0152344b03ded08196e6809da060a70997af8c329182f2c71123b188f6f164432e5fea4348eb66a19d5acae49aca6b20ce47f9012b51c4694744f0fdd2ea4ec78791d985c89a08ab83a73b14a99e16c62f084b6d3c63ee87f30c686fdfb4366c90686e8c722469d92f0bf313da3ab27779eb7812a4601ca8e2a8d6b4dae385bd447c78de774b1a8ca7e1bdab25498fec4f8e0079019cb11c86424e7d916182e345f480ddf68881b3cc0fa70a247d8037a67193787171e50861a9a5639b7e5555d0c52bdb73d98c20491198d7d1ffab54511f148d4994aefe4e0dd7937afb391ea7a6c77304d1c7652d398a0de0dcbcecfbd842a5f4cceeb363d362f8dd1eb4f2d9f4bc699d411eaa1c1e03451e44ec6f71583bab9aaf1f5397a4939e32846e5791eabb35cbcf497c55acfafff7148e0f8f67a4b55a5e2fe9980b8f5965724fdc5edd49e4bcf7e930a9dc1ff571cf3e21f5fe2412cfbbe3ae33b50f575a0c12ebcd60415b1f43dad16c81306e2ed6ecac8969f4823903ab4d1d3811a790b02629e8e6b747c3641f84aa6192422968b58256afaccaf3852515d2e92c9269b47eede2bbe612b8efb4112a4bf66e1bb926dc007e96fa0aa626b27a92f64bd768b18be78a010d6443eafc72d160ef23694a7d9f94c61a35a2cd8c9e30818da5a9485206a05286e96aec7916a7ed2138e9a1637d62d509c6557054a1001b30b81a2db825982921f4801e33ce03b6fa894dbdb1393ee3692f72ee10cc31384cee192c492c1386a29312be6829c41023ea4561f8edc90bcc9e0314528c4928da63647cae27c34df7109770895cbee9a32f60e8e84cf8e34f9887d78912d52805a35c1526768f8882e2b048f65fd18514abc024299b61865b2f9642141f7f6ee813826066f66bf7746ba5ee09999d63c72f74a04693c76c0cc21e2107047db7fe218fa65d66d6bc414be480cfe0efb038e19bdc86586376f3f0aaa46b479e046dac81c7e626ad9790b02b69a3df6e14f9c9b93f5e846df63597ca2279afc74bcf9a20a726377d3d5f771ab0e5e911f3b918c0cd2d98803e747b4498488e1479fa14b7231b64f378aa1b1d5a522cdeb1e716f0de223a37cf598afa39143a0d835d30d0e52b58a40ab2d8ec9fff3e83dc6a9606714ac1f13d1c4caaeff9cd8037e0350ae42728be509e7d52e5c7641ab35187bed88349e6da7fc501869ba840302c920970b57a7e2ecf25c7640e49b3c2154b0e9347b203f2f0bd16303a85f2a8841b28c56d447861f0a1af8755ac0560ae879b9f73f45c2429b7825341e77059d3d893ea0011fc4d8c3595b66bd22c62e5accc434c7d6874b4888a470dbdffd8e6311a0c8141352bc5e652f9e8214e02ddebcb5052d49bc259b902541b2cc15537c54a3c5035e43fd089ed98f1bbadc0ff3bf4c309054f11e44c5b5ea6a33dd8300dbd60e09865ba5d78ad0c3293d9dc38eb72f758cb959d3771bbde41237b6a1018ed4861369f842c5decffc76b2dccf87b0b2e4df8833cc77d0d48a042b9665786975b510f5c16cdf5377c9f0b1796a4d709beff52daa2307a70e4b83feedf05a3f9e66ae71216c67dad9629d2b4c3265c36c8b9d5f40392eee797d000e97a182a1b8f68234e67cec45742c32d522ba8c4d8a6f7e9e88588cf8fc593ee17b413687be2c481cc8d0b451bcdddfc9425ecd82a07215600e9860e00093c955e15b439bcd4998d80fc88042190790d1317d36118c7fa75c2ec92078376c9788a3be0381c62b2af94d852c30c2be9c54831c4f672f99d473bd1a09d6b6a3b3539a472d15fd159da91cb8d9d26dd176a32e99691b203a1bf7add4f5fcd055b629c08996a17c8fefd0f331cda252037ed73d1e484a177286f292f750e6ecebdc9dc2a789e036100ae6132a54cf4a7ee0acedb608bcf5373a773def5e32c27e970518176f50ad40607dacc6ab6fccd6b210dcf82bd17dc638559284d2c04cbcda0eef8faea34ed2aa18f7662ff369269374588a3a0dd63cd781843b7d8e5c28f5a54f1409dd29ea68e0bacc238e7ff63d85558a9e658800accad1e47172e3f9a9f491ef5f6296803ce734ed052f8687c433133332a8b5d7c2ed23cb85bdcfcb2b264e00626247c2a3d6068f2231e196c970fcf05fde4cc25d90603aa4edbae712614329a7963a914c0efb44f0ede1992d97103f8c30b152f16a566ead74c2a32e0c94c7f948b3942312d7c735c117261de516ae12c6843b938e97f086a810cd37e3d8560c9f3941e54e3950686a44344524c53a60a28aaf852c5754c12cf1eb52f32e951e0bdc481bed7e3d2fda094098be0c33002cefa15e3d2463bf634d73a9ca2d2cbb5dbb2ad7eb0dc07fab8a2875feeb7a36f0ec88b35dd6682458e8771a7263fccb81673c25988052e68ee07bfa61945402d317778c818033c9866f3c3cfcc303f047b95de5799ec3aed7747c0a177fcd0f29a0691a4160ab15c55bd5cbb54b269984f257626ba5a6546f9e050454cfe468c8cb01b60f6944c743c0875d031059943515ceff1ade011678d820d2804095dc5fba0081320451fd5e03b5850ec353bd1fd4fa07ba9438008ed873139488f067acc71c8893c467ba74e5a6bb2ec1d34e723f7e49488321a4fe561ed91233219a5d4ae469b4f9247751512891e8f702e313b11467db94ee6e5700389321f1d674f2913ad146239b3951176c26ad1c14535e68f746f6dd23e67024b0bf86a7665db86d7033e316ce1292391352dd77da81dbc230178cf2c4afcb2ac2b639e1c4a621eb63b453df9eafe08f86df35bebaf63642382f31c3bda23eef10bf9014b5233da77eb4cba4a558f2e815b9fb3958fc9bdc35b863271d314972bb49c32f554ce52ba967900838ea0db95321c83a08025487db3e9658420fec6a81b65a9857f361e938ad86b17f25a8d50b358ea248e119887b150643ee484bb4237425284ce70a9233f394775e129aea38388b3a01d385ca2a02d3c3b3e878704335feb966281059381da690043952b8b26a29cf44af5ed2f00d23bc4d3dfa8e2f367c4f89fe5af759fe56a7ca16b370f62b83d9a15f18aa7d09a362492950c18ed83218fae497a3999fc3ecfb07f2f63985df2021a6eba93a0b3445db315c07cd8b88b44d6b95fd76648790dde7ce80a5205ff1d23a5516c20b8551f99f1c5d5360370bd84b0e6d7dc758e38882a45a2cf74e5d71074afda43fa13407cd3b67754b6c22b25bdbb3b5fd2cab572562e0592e31143f8d4f2811546d6fb39d35718983038c1aa2d31d9f3339748872e5a984e2594a2ff3bef8c88671b7120dc419b39e06493a48fb1868b91900e1c86cb1bd000104f6e7ac273eb1ae37b527964cbf0e0fd15816f4dd81739ff898d09d11cff2e574b9bc66710f51f734fc7ecdaf1d0bcf980ab86841d87f477c984160a9aafa37b4f74d506db55381bab441cd1ad8949ae9f315be9d970983d331fce1eba555cabdc7043dcbccf9e851421f09981acf9aba80aec8d4700ef62fe946db68fcb746b089d32dec03bc552404a0aa69699c2f861be025ba93647da84655cc6a40a41fb39dbab72f9bdbeabb044dfcb00320e5f6a50996d2006b1313bdb3a27898da1c39a6aacbec4866a289ce26885f27ce62bd64141ddceaa36bc25b881539d0344959c2198a23d68c61818ac35321087eb6ccc48a1843009f04f2c83f4ba4049b5f802f1bbf1462107dbb98769cda0a03efb78e7fee8687a72ca09f4b50fc3f0fe56cbcab0a92f2e1854bd8dc1b54d51d785e7c6b917615ed89a01825320239c21dd54818ce8068f798eee28ce1693705e389f0d10ec63e10fc7a70b4ddb8e344800864bddc90a863994caf5882f03ca186f98906cf4a5520e106965bb258a838f38d60887f07341f4f8290991e300bacf30aae9bdd4df0e04c931e5b8529b1404e117c2733ea2d32b2bbf01971c60943206379e7abebb30a603854fa8b18fbb29121ad09cff51336cda4fc2194b34784f28503bedab1787fb55b526e7bc23a23999c43b22c0f81b91e80860f19a2cd3d1386c14f862f06e779f94c4ad9c92362c4ab06f38510fd0823cff7025eb1fd7ef1fb4f6313823a96db08721aced77d3d04573707276e717689489a30ac3cb3244382720376b09a5ba13b5c66f1471c244669633d6039d9c659cd8909fca0e97eb3e531dc8d20d64722230177c5460be44863f15cb235e3ff0274c18785c6840da2374e7082764c81d257bf3ce77414f5a5404459bfaee6a8071147db91c9863528b6211edccbd540270b850428bc12538d2d8338a8d700023c2455cd336ca1884775dc70c0f17259f2d97080c7c10113a0f6031b1f24d1de4761166179bd96133f5c1e6add73aa610e8e0eeb3b521463526d8ec30839164dce8911f2086dafd919c6a38004ad1a70245d8530086f4bcb06aa519b93a4e4b3ef4d6c4e919cec1604bf4a2c784ee2c0175786cab88ed630b9bc7a62c8a8c3bab637a34ea1e818077036fa9046e8aef6a0eb9283d0255332df32812642774569a68140ce9fc00b8c94d077842fec146b0a385695215d4c27c6c5cf2f9c67e4ef1f8de0676f78e8d4a7cbd5f4c79359a1ac7c22c96342865d4314bb1a853d215aa905b2989633d81ebf0a8fe7eccb420d61b9288ce8158f99222ea1977916f5fbf574b1275a0c435a6903342e186e3dbb6402ed7b08e0a934ba6bdb5c054a645e3598da9722653b8b4a21d8977f5930f6717f0c921ebb26e7e10c329c954f68a153942aa38edc98c44aa7818ebcdef85646fe75b4fe465d3c93b959e3952cd70b1747894e95c481c18d3007022b18554e4be0257aa181a709c5ae6b0ca84d80e169f3ed346da9ba2af4a0bc7165b5c38cdc72e7682f64f903606207427189ec55199ce91d28004d789c28b750829ff9264bc587cbdac5952ee3e096ede3a74ef2f3aa7fce6d6ca527820f2390ab32eff885e756749f0980d21a1e8cb486bd353f8d96089c7ff600efc7623ade3e92bcdbec89827d2afdff752bd35ccb0b886fe0bda8a88592b5432b20bbb9805f4e517410d0346d6c4ecb0559a0d633d80c6928d88b411de1b389b4ab77bd83e0fa93422810bb0ce69cc33972d2fb092a1d935ac85ca8b927a314943866f616a4641aacdc46b1ef8fcb17b5d3f8f20e5deabe17c0e677864e9956e997429a7865789512a478456fb5e3a073d29597d882208b1119a1df359c25c6d31a1d95de35c0a8464fc48740326f73926ee8543877f52085d1c8d783b20a0aa7ef6dbb095d8c7e9c701c763fb6d2a1ae26ec3d8127cf9cace836af669f21a086bb6c262f037c6b44d96c45409f0742a7777e04e0ef58262e7b28bb04a32a328404a00a722b20711d325ecebf9c8f264dd2247b15d41720d21b197b428181876d53b0c902846dc9b430a89a731358b6193a17f484c5e6a292c39bb5ccd4003d5e8c04ad9b084ce1d5c2e4e5bf121addbaca61362160802931abdc25cf0c91fb2147868c5ed41367864476b2b91cec2b1a61265426f00e7b607a24fb7faa810899233503e40a48ecf08724abceca38cb64d9354ecbbc68746e1d47755ae376776ae24ad3f0a98937c3ace282dd767f0c906a33a9fabebafa5635353437c879b620064c1fbd8156ede8905e52532db56217e5a1518b10b353ec9784773e1ad50950c579028bcab0c68b54e8803fd447aa0b6a17d030e34858cede2f5a123e7220a5a8882219f80783cf185c55d86854387ec899e1a795e2e19f7eb10a3420e70cd980b77690880cd321419dd5939036de2d99ff43d49c53a283e8eabf8b92b0dd4ebbc8a8e5bb8c2965cb76b3ed1c98e521ec69581f79e5e2b82aee3431bb02fb41fa27d433eb9ed0c98da41c8d18a1dfda23e5f871c99c682a2612a2f1832ffc92580dd91f0131c0dadce451064ab6bafb8bf32e1d93057ce2001ba982d16abd4b1022048df6df3c955973e20ffbf422435d15c964526073ba61b8912f302f5ac7223783dbfb821da4875ade763ba2b3677a5bdc087dcc151054c50d003881dd2255d3ed26ba053a83ad5ed8c2e3c31b7507489beb5ff2bf4420d9baa4cec8d1aa4f79c0d7e5e892d700228af9a9e03f40da32ee8aaabafff8bd7b25ce3ab3bc63ea21a98c9230423566b935591ff07d509aef98e46c70e137b4b70a4f9cebb70175904cd77767f7f25ea199d14ce6b1cfdb7362de8dff97d7d07a29592d9dd7036e7ab37590c0a4c5246caeecf19745a4332b7df00cf40810971dcdb9946f5256def383b815106e70d0b605fdbf978c73a1867dcb549ca124d54b6099b0d464e909b71cdf40f73f4d81be5c1802eaff7e9f5ea57f61aa69e5a2c744df300885268ff249d8ed5124b5c4793787afba6bf4f6dd26f9baf584e1666d00fd1400a745e5eced5efbced5fc94ae458f492ed6d2120c0e98a888504fdeb348329c55b63a1290a6a023112493dcb31fed754848f0990ab63655abe73784f8465025b6589c1384ebe9a85740fc1913b8384dcd4d89a464cca852e34f5ff525d5476dfd9819d71bbf478f1b7e9e9d0a3c1b86264e8f4b44418da5ef243e8b52ed91eab4dd273f4335698048b6e6d18987a74e346114e72da769d548b76cb8d4b8acbaf337befb81b13882e1f02693543805efdfe90d6525601b2242e8b156860e423dc0cacaf83e5ff66ef1e41f24cf40f3f2f9354805ac7e1d1d295a1487d159700943909503a88ce333f0fe53db9217e1db6cfb53b5493cd4092d8133aa47059afed2fb183d8a0af981821340967c7d05a25b2cc5862c1caa4ebc2a938f9237e1352ca7b408703beebdc363c6ae84d5819ed2f85c08ea014d80a93ebd9306c12e447512a6f3facdd02d4e1de923be9b32c0954e7b620b31f1d20ddf674d44881b3af2a03676976351cad7b332b0131208b79bf049f3ae8ea7d29529fcc6e7f7004f371a1d732f308e969db0603839dbe8f14f2b18079900e8c8cab7815e45784b9577ba1e03a43ee2b42d1db0e43335292ceb50c9c3ff9c653f0dfbea448fa6de22b058811753f5b8063208a79c72b3c586b3672155edc058dbd03706bb2383381bee9059c332f3724c1cb79759b5558c11ecc0cf02c20cc8e3492fffa90c74c2903196116db7816fec2a2a7854140fb0e4b2f977bd7b605682bf6c524b48b3d21df405cef2f67a1a96f39a07cb114601303413af47b8ae2fd80842fe881bbfa52f8ea85a236004c8a973a93c8b50ddd774d267e1b1e5d640fe9b4a171c6cb0b934100cc8ac7dbcc2eb98e5d7d9f3a2305b14815e2bbd906c9c153779b590862a6c0b0cc5527e16f4daf4424b0b7593b6d3003c771af8e9acdc6dd745c931f6e487279483d29dc7298f1b3bbb1c31894da5556be74ad34623b749deef5bbcefcb71e7489a1551b4b80fb4ca94300f454067687c59070ccba6b514f2c68411d5926b4b88cab0209c0039214d617bd9cffac9a99b3528c5647228fa4090fa96eefb13ccffdac6094eb7a2fe6f3e8e979f355aec8126d1ac19b726f3e681845f02ac4844325dab0d718865162e717940db12e48f47c47722cc48d242642804e95ee1e56dc6855124695e45d852d81cabc2679d543599510f35f8a7888163fa37ebd985a092f121f59ac12675f61c06679dad77ef128313fcb3c684f84d48898cc6bc79e56ab101d9e4f5812a52d79b8ac32c21957bcbe956a6397899e0ea7ef07603ebb6c763eb0b07c4818257884e1c37679ee55192fb431306e37f0505f56d023482c6db1a4363b251d6865a7807237c8406e5e86565ca6df5dc5d2154b117144df1eacc6e086140e04f2b09084707b4c74d5d8e0a06b880259791d8bf5a3825095a71e3aeb156942fd0707acd1b184abbbc872aa5d9e5fe8d2cccf91c0d44352520048a31af078e3be701992202c84024aeae7577305da11246af3758fab8a166c82ff758ffd9092873a0ada7de4d8a78644180b4bb495421b19ce945dc31889cc0d887b52b04761c5deb1060150740540f4ed0e52d7446f27169a4620ea63a0f9c2278469f439077e247fa8751a464f80befdf8dbbc4589255bd000fdd6ec46832981ebba1d58ce1fcdf2fec84edee5df0c26b866dbbd6f4dcef9852894877df4c2bbd6f911dca8930238310f7b1cd4d22cc22be283ed31e12959afa129a59d8fa51d2fd5c8de518620e4e4d9ab5efb35b853475cce719eacfa20ef3d477151329d66450c2894bfac0c2006bc83b0083b1d70d88dc10717de8fd2b414c7b116e6312309f2aac3218b1a55b235163c8754646f0136b78de2d6f4e48c886ec1ec34a6df0d98da86445ca0c2ffde25c6dbb00c62f8823c224a16f289dd75dd332298779c2770da93c2934c6d83f1033f2a16b1784a3828c89341d8551a38286c55e2362d7cc106ed0d7a27729b62c83e441ea8b5a10e19fcc0a7cacf0939a82a43952e15cd2beb73ceb27a797607429c5f1c5d3e5600e845d1fff8d13f6990c172536336fcaa7273c86a0f9674d661973ba236bcf4a12a8f450dd2a36601d0714b7bc0c0f9ae9bd75a06de341e185072b552ab64321c3c5204971e12c4be72e64764d8bca95963e882d14283ed5236e52776ec5a4b0f44e3bca0b90d0a344c2e59d76321e7f82f5021b40cbe48327bfad984326e6c661c747fb8390ba120cbc633a196b7466dcf2b2d43e03c14430b3c770bb5168afc77806784a9f4a8e1f395ebc63291072ed6d98319e803b153da0654563d588cb4e3bbb282d779dc60ea7a29bc749b429a8324118efab4657416199e0a4a577d32c56d4406ba72572765a01e0b359959bbe5ce7bb436862f2c3d844bf0245a3f968f606d025157485c2c71d0a5bec8d6c58d76f4a2198de4e783b1b3a944e2b1a5fa00e9758d8707e4366d1e66877ed5f1f28a50dad7838987ae94ef13a710bc5a5750cce7529c6efa870084b8c598fbff400e375bedfb142568272d907be07dcb82ffa6a987b580d1e1201a6f7e9f87e1636fc96ca3d79e5873cf3a1badd55f397e2063d0ddfe7fed56338008d9b0ff2f5bbbd5449dbcd1dc787a13125e3d639954756994cc2283503e4e12fc8fabe8c76f1bafbbdf708cf72e054a580bc2a3b201010e391f9205cdde50f7beac7264c0df67e0ebc925f0c3beeb32dbfcc27748b446032cd51ae827da84eb4d8ea402e47651aea00c3a1389faf28752038b26eff9e10f27257751b87be16b383a9e2989ad6301e3d0a836c01c7334fcfd0c3b37d330e37362850af85a514d5df3622f0f511a06ab9621df796bb04867c005850faff77148ddfe1820a35af0b1716c6d051f753cde240a2a1ea901e168d69e5b88807f7b1034419370e00db83dd5ad7f69fa67ec4431893a475797eaa5f1e390f53c22048a7f18313e96c9f990af564b43aeadeb6949f2ebf23132f35ff52b5183dbfe3dcfef82fbce66652ee9070eda0a21ad29534ef7a39d0a69fa8b8a731d4c52f5daf8da4fb87c45249e66beca0d51b1ff0b1ac57b2cee200451cfb4cc32d7ef5ed21cea6af01bdf0d80555c16608d4f1e80ac37ba8648740cc62c74733b1304cfe28ae8022b54d3f3fcab35704cd1620a1dc0bf985c1a021d44ad0668e63f5e45843c91329840092e46a882552d2713f06cd9cde3382e44d4345a5577ab48902575f77368122a0459d35b8346644552822295005bfba7c5c70781244efcc7c56b1a090f534f64fa4f8953574c5f4e939e8681b58cb824c0a8457d224be5b9d0caaa4f1929118cf7cf966ffca3780fc8454a795c7b4443d6faca478948f28a14da1549690a56961e4b79d655882b098f48ff25418ec72fa8529b24de7321bfa62293a783a864ac12377cb847b95f22dc122b9a83c5fab2184f350f5d84d3b2bdc074f42bedf282e123e40296e0b5337103142a5e8983400de3b1b3ffa1643edcd9db4a66452748ecf09ed314ba2954bd43210e4d390faf4684b5022b7494c09ae990e24f2ce49e850557a996388040524142497145893f5bc153b3c0479f8dea57807d2c35ca057cec6452b9430c6c8c70fb0b240beed0e11bc9efa73dc7b06f358dd993fa5842d5b0ba444d734f4f1b753c1ca551a9d02628d2662fa355092262629b6eece7a8540c7adc76e5850ee3b9c87b13e03bf26164413740d1dca31d37ead702dad3794f50f64cfd7d33c87981e5dacfbde4ddcbd28f715256f461eca626da4881184dbe93055f1c49504dc35e9112ca9d1e54bac74dfdc82495594493a1784d4e8d0b8d5dd0f699245f11d20b9ac7fe7af8f601180f314c200ab1345ec22517d40db1866e92df922e608df92562d72b07be05de8ce780e9bbee500c748411c266c857ab85b543222cfb8f1b8a200c6c9eaac351a30e0f460d095e3a85fa0fd24b56eb94841016f4561ea0e3d2d6fd8255a2d96b93ce46bf0a6bb2d84da13d459b2d70e80f86269a13b36fa3c73e5636a79d3094d669e453a06e36e1da3fee83acdcda8850ff8e07ce8886a0ba91f630940ab9f4d20c13d11b2a7a8357b333f464c4c91f02b30a0f6b98b092a0e4db2576448e5046ee23b74563029a4aa4791beff11cb0b02b79361301e99be75e078816ed008f59888575c68e104822f33e3e982046580b1e78bb1c9d280cd46f56e7782d1d7f4ea6cf4fc2494084adbe49b2a06f47949b91742eee585039ff65b500236117f692c226c85ac87da1e014e2d66b28eb87e10dd8803f6b7582cad78427718cc6561f38aaacbfa6e441dda863388b0caad3c3660a3250781bef7cd146c17e9e055faa12b62ef84ea999b8013d551a3f5cb87974dc19d62c99002b6382b530d39f6639f338b2aa60d33f912fd871e02ec238e06908535099c5cbaa7a44c86f5908c9cf0b09ba3b8f5394bc7ab19d347e45572d1c878b92e5910896d4ad451290b68dd6d025b0e4633aba6a840c59db922849a0e4a0d4aa49c4463038b44667a394d83b42affcc9415fbec9e4c66eea95495a0941b00235f54138d791b6db9a3ca18033063a7946959be1648123e2da55db54852e0acf0fe3434ca084b0eef53f381f78c469d8094db60d292102a1919656c2aa8a21c608106c34f00f7c00a9c111b979cad7d7d6bba1b333f1246fd65067c17e3b66e1642ebb66f484ccf952aa072cc6ff42013cd71900ff837da22c8b1931543c3fb4b6cec62afccb40cdb259a0a3d2e511f544411d1527961b416883b97f32b1f90c424479d7ba64cc24ff80927fffe09aa85de0138a4610a83df2fe156968c586e1f10f07c807c26d37705abcf1dba1f0f44208f2438854b4aafebf6bc37a8f328016fceab25fd19a349663af6d045369004c233a9a3fb6c4652e628cfb8d6c4333a95ea07d6ae163a68641764e370879568f0e974f33ce73181d47cfe6efa5242f4c3c79436486d4ebb458f8f646d46e9b676fe7d26c33a61746bb1e742a82687703bb2635d52703e2973cb9a1403d70393cd2cbf632345a0dc0aa6ae9a7ad3f7f8a4377685a4573bd4585e7170b0e11c843105255238cd23c00937dca6cd8a10967620bfbd225f6200124a59102a4e44927030517f7c2c85ce7b9574ce88c4f55e70519b765698d740bb36d256c61bfa4e2eca6495e89a96dd515162e1ec770cf8182baf8f7a064468eeab24c33fa2574cea0730f8b1b28be7b6874e25752d30632a7870d1cdf02c9f3d4c668db7c24967aeff1433155d9f2870d8d635255691eb7eb68516390775f0e44d03a97365d48757024ee03419fb77ba481b7615feff4411d9ea2fad060b23106129e13dd42ff50a20baa60a15271c900fd59ee3be72309172339ed455359553ea54bf2eb3fc8e882a37fd4c9b57502558f548a2de98e9919de0ee0690e73c4e010d51c4d4e0ee752694d6b4babe89b26748fc8593a7aa96cf5b8a7dc16167151e463c99c95ac5d69a038fee4d494ecdd02006110d7dd8230fe0efbe2f4033a182117e7009a6faeb5cd107c22009b56c970c4788605ec7389d46902a93a2305029ab67bc10bc1cf8c6355aa307092d5718092e8806fa545006030ed6bc8725410f5399853520bfb8e00007bc2f8c051ddc1d99453afa5d8030236927e69e423ee2e903d74de0cb0076043c08e529df3d69e36e5ad3e2eef4e5c4cb0c4051372d11b97c7fe7c58815b1210e907f4fecb07bd42c2a1e2b19f4d1b8ad3263cb4167553397d3550d922411186609c18228ce46f38764ab8151eb8b1fbe3bb4c79ce67a179ae26e245bc57767b997399c5b907cca41ef02f9abcd055be568488de69189cce160ba253234f3c9ffea31202e9f91cae57790a9ac7cbcbebb5eb6c81a5bdf45c6ac5f569acff8be6744a638dfe61e8f871c0e9fd330121ce86b3fcb5806ab3c4cd2a25ad27f564afe7ed99752427306d09f86fc765463303912a92f858102b59792af412c4ef07e0d4ca4d6d1ebef7f7e88bfb7df45e425c3269e8fb62402077507c2d091eea555f46c65cff6a445f64fe29f0c7c90362917a46480e8a9675d1c6cfd9115d7e971e4b8b8b4fb0f650bac2a8c6080f79a0e619bbaeef74336b22dd645f8921796eaec7bef9c87805c7402b3a886bf2fe9108cf1b690d9d2a79bab1d6b5fd100656be72ec68f6a3226a0887de5f871fa7fb4f2813590088c41f9cbe3117675b5c4f110cfc6ddf1263e39e3a29a39a2dd949b3cb62a6c103846828d12be66e1a415a9e15548974036a6d1b75e5a90db8eccb107e34396fc69b38d901481347aa58761e7b416ee5f2f28b22842d617670d0b0f4878071e088d645202a4eba05b1e4bc66a18a503bd618618b4a4534030c41bd053a929147f5b2df98b8ba57292173b2c5a91590aad8feb1b000c462b697fd777dbc161ff59e449e9406ff4bd0eb0480447fc95185d732f3e8e35eb1858bb1a1a62cc917aa8c42bee34c1b4e72ca40eee7a999c4e7d3ba0d8cdd92dc0dc362d1d7fd7cd8771452e8f7ef60106995b573e12648af6d842f4d199e867fb7b5800e16ac2d988c952a0a10516895e893d25f3d134601339070686744fd5426d138ea6c8d9d81c997f1682e30e64951665659c9b87b6eb7a1bb64d42c3be10049a01537b465347e0a2af08cd3b63cc35074e4f47d1d20b50238001992e2f21f76bd61cb6d6edc445b2053a30120a859936af699015beb965009f0d0dbdf10e744dc48531b080c85f0dc71395f3d4410fb608bc3e3823d44c7307d7c8c5c4829a965bfbdefba56ac2789226dc7e11156b3cd259bdc6a0ed5ec5ee584f2dd4bcdd21f0339cc76b212e0f1eb06bdde949886964cbe249e8e869a86edb4e5300067df600f2065eea37a8752e3662c0e0fa5b3cf619bee70d3b123032ba27637ee80795b11734d4dc23aaea3406a346f5ccb86ea3a9861455673acaf91894df9557218d6255a116b15bc58a236c9547b649b881b86f81571d52656105f27aad78f94935fdda0f57a46c15ee1fd7c633bae67b4ddb409745437996afca17be500c48ba5b57f7b0783b40131c2e11a64cf7483d434ed0cbf9dd2b031cca6e2a53cef92acb9f41bec05811a781b4ba0044206717dd62363a74cdde90328b07f8e32eddd0b044d911fddcc92fa872969c5f76115ec6105fbc765fc5a3032be1116d9c7cb69d36c138384dd9d245db78889a9bc7260cebdabf57173dc9d5a1378e6b55bbfc1982db8afa1e5c4b893054ff9c68d19f4a643bda286d950b54fc2d010fd88566c9de55311d1c6c1f841e2aa24b42eab767e8fa20627b13c79f24cb4a1066b9c6e62fb10fce0560daf18236c1ff61359d00fc15ec38c43f615301e0c912064514ac1d6c389439d1062b01e754d6f2945b8046134548a12e98e8cab224c4c97f18d62100762485920a8e2bfc0351e23b52f80461f416c3ed0762f69e5a3fdb4e3feaa77a0d36f93545cb8ae41dc8611e96751dfe4b7f7b4cea5170f842004598fbc199556533876586c53d110fc7c3f412cd9c8dc0adef2bbe0f9c4051e1b200484587b71a6098d83f4ddbf1288df8408845aca52ebeb25a024462a1263b7b59fe3238cd5396218a86efe64b07cd08640c180c3efc10b6d080a3fd3868eba2346d6a04a63e65a08a39b57d7a4c0262c8bf5e758f0244ed686b0a267b5aff02c93623800dc8acebc024f089efbe519101fcf7e5b3d74a046808daa0d34795cb807325d5c8f51bd81b5b2e0865dac06113b1249c86810c937c67ecfd77c24db470b4691a09ed874b7af2d4d3a4927f259aa0af304ad4d878643559977fb8dc8ef49bc5292f30a7fba3d93382423168dc667a6f2a966c36f7e5effe73415d9a32c84918a9cc4705756e8bbe7513c3cb51ad99715ead3d499046a689589801eabf5314a575db0ae90db07281a074337b167c5d746dcb595070197a74d5f46512bf54898869641433d6c0d8ed308eca66c6864550956e253a463ec2615269d3383bc3ff311e45957bbb2b3c0eaacebeb441e1feadbe17893c513682b191a43feca202aa09a019c4628a0335787859b9dab96381954cb799e449769a7673300fe9c8531ecb928260345194c86f0ee59741a92a14dde9b2de35c5f5c144bda49fbabbaed4efa70a995aa52534aa5fa4b0584420dbc8e154cc2e3621e0302ca98931115eabb26148237681c1b085ffa7612b8676b6df49edae52ac014e86c3f4c1f6f4980abeec773301817513c9921471247dfdb9f26cb91346a5aa116d4481d6d0adc5930e305c9532df82b38d3fcb029b4be215ff6fa8ca60adf9b96fe27a80408e36d8cd8f5e52bc35b96661f1a05c9b9d8213d55eaa889c2399c59381773a6274af6cb2479363723fd43451351e343a2c444a673fbb77cb50d70240fa63f5e1234fe0d0f502da78c73a19bea90b4c8175f4aada9e4e68e920b646205228b328aec17ee06334352ece5e70a08260922cbf9f3bcaf9c97e416039d4469cf53d5d49d83ee1b56c01eb7b590c0b25fbc2f6e516868800c79c353c0fc418524dc0912700b27e1e636e2b030ce01212516c9a55b05834da7717e572ae46a744e2df952d5da4274951ad37a86d114846386cdad28cdcecad93d33bcbe7d19f0af85413c94166b816b9cdf41d2e095cb0f23b37753098939a690b8dcfb509d48468b52d220f6feeef91496720ee909684da6d5fe9768454b6d2f27745d281fc54a3be0c2812688e1fcf8bff7cb3c7687e2dee7f78defacca1b0e31445b883bd759f7cd7f8fac8e7f76afd3373b5aa29b04c72d3843c405ec71fcaf61a076191b7b27044c3792d9d15ce42cb0ac079305236dc016890b8549f2cde627242e3e93e2e45d0b77b8edf20464faa117459bce4b6714ff212369882c4ba698ef671abbfef00c429be5c70a82e24db6066dcbc9043a951a8c913f74236c2679f7c1b8b856698beeb2997c99d291b1ea875b42d11359d3ef53b9fe3ea562e146d85baa3edae61032da8a10b36bf92598d8b8b29095e3a0ac23d3ba1c54641f2c3f3f300e699cdb2d822e64c3f20df3edf6ad95fe6eca1f8775766359a02a242016b1cc34b7923a2038e5dcaf1740377dd36b26e04c1c170fce09f1a1d23e67c16fd4855bea2e37669de1bb90d91c187bd056333ba8fb2f434f7756f5784b55431752f2e815a291ee7d03adc7258c5fd450c12830bec193e4d0a395e10a2475321420415d8d55ecabe989696d6eed6e1444c2e58cfa8aa71d5c0da89817e93a7ce4115deae72dc360e038c19545cffe9c414a999328ba1eb3891695eeb773eb258a3c335385f224d989aa1f22066fe92a277406ecb69cff31386eb41ad7a26a59e3447b3a0418ab1a0dce1351eed5c439e762e3accf3d82c741fc7590a4e7ce1ad3a913a5ad2e969ace41bef249ca60c230b14ffd8335f862bddf328d6285f3dce57ecced19b24669481c677994cb45b2c53cc53bdab02e48b00a2681e91942d484117d813eee1a8f0ca4cbc09590450f2caaf9e2580763af346885d9ffb9a186096bac093a890d8327fe22dd673b36aa01ab3339c6c06ccb251ccf83137d248f94c66dd26e30a605a0d21f93820c0e6483b41fc67dc17dce197f7d2c15634e7d5fa62c2b93319e269b65862e35fba1fc82b2bb795278c9c8c7c091f8d2fab1ab0da10111eb5c44857bdbb105cd941efa89ba1f19c31df02537cb1d1eea6a65637dab513a4576fbdd969a18e1a2fe060eb011e030cd9b8753ab93ed3f7e706c42033adf597eeb26140c3f1aa826b0b5ca1d70c7a5813cbfc6f86b163c1ae7a4761d14590de832cd2b3e44fcb172484a1ddc890d0557eee824b4c58deaaaa75958b78d18a3605ec2404dd3b689881d5c6a5cdfdd5ebf92bc0b9bd4696aad6a6450f767a46f5726cb75e90d8fcab145252a92de20ec3806056aa069c1843fc179a994a18aa366d1282a75e6baeb465480c7398650d0a763c1e83268ea2f4613b6819e237ddaf8c721b04161cf0579351cfc6320e27d19699d88fbe1f0519d3d64f3b94039c5d49acea1ba7d76aac441afd9b74b7124cd2950fff4223401ce387c08169e9a1449dfc6107e0db1ae49a1681e52943ea029e402fa58006d8a0b817dc9aa6b418e42e09f9362d6350ff0660c8e6afc30e380c18326c52b3dc87de53c20d09db674c65c9226475b9362798db8ab693aff22fd80a3488c52afc7fd047a997a45e9d584a07f30a4c65e4029c34c28be2e98462b32efe7844c05115fb2a3a39f2dd4812acff6ca4287a4886e80ecabcea4c02b112c2826240a4c53d3a1c4e838aeaa33509fa5d7a59d61e61ab150ea1b434e96e143b0b3f7f50a25f8cf13bb89842bd9de1c4bfd14c2d585addd1f42876192e7e05377492645a4fd5d4d9ef73bfb970a90cf4ba109cd40f3134dcd1272b210f9014a3c307566582823c4d2234339ed9e5e03e414b29c6d5cfc913cecf0874bbb5462f7f5247fa446fd5be9d0b7b2067b6471e914e9851c81c4714b0829e82caa4ccdcbbd63e4a2a1380d22c5ae760614a58be8ef8bd0812ef403adea377b258447e1259c8f175ba216173ed0ad8948e35d7c486704b43bac56649e50dc01efee9fb35dd93ee7d97d0cad214af07476a963a9814dcf0565844fd555d394213140443ca0fcaf812047ff0460ea9fe48588b90a7b55dfb0c2c64d5b36f2232855338c80d96c65eeb600ddabf8e7cf6c04d467bc48de5e599d2ff5a5d4c740a82cc8f20c414a967352de4747a1a4c6d98533e3729969ff8fd1f54ea013fa407be28dd7301edd08dccf8c7582e47fd01266acb3e3d41e64863d0949f70e33a5e258e7eacb7aa6fd7765a4ceaef682c249d9772d6107b74a443a5a85a8ccd52c6a159102207f483b45db81f9f648b84ebac119bd503ab9a3ebf757a85c8174cfdf544b0c1a3a84ff08dd4ef49e53386bd55ee763fc6b8cfbbd9e58180b621fdb378847e85df35e0884c8a2409c8d092b65ce5fd84ce04066fa7e1147760d52a29087611ecf74388c84e7221848caa28ef51898c7125c003852ac13968587e6c9fdcb27b97f0880598239316ef54315b82bec24f5cdf0c9e6488abdab94b2d3aa04b1f122fef79a58f282c111102af453108481b934e2da5e0306bb5cc2a4028ff706f46f2580c004c1f35b7c7becde447d225022f0b8fcb0f46d0d78ba27d3d3b85d269464e50a7970f0f302a5af0c7e6a12085cf2b8acf2e730db9004144cad8f93a8810bf3cd1b432be8f48bc6937e93aec56d19941138161559b4e8c284a71d2abdaf14605ce1f43f94f6c6899d3f6256d2d80b1e7c101cc55cb570c14af40fb0a03412cbd11582d18af50418903c3e5c84febeb84a68309a7517895e1c2a02c4cf0a6899795aa71c57562d9986e9fa9b4b4da64560de0d210f84e937552520209e7f0c571f1a25a165cc884557a530972cbc1f169a2aae9cabaad1a6af2dbe38a7078d5a17daf2eff49bd943d447330c76929ee91701968116321a2bc4cc0f3ac920eb75c69151434a534e8b44a22e5cc99e9c043ccb02b8e9c47ef230f4072ebe5e0a6be38c7fff1148ba94a71cb34509b452da2fa0a39734bb78389222546ebd0a8a87ec864b869311f005cf192e38b26b6e2edc3140309877a3780202f207deaaaf5861ce41549a1cf1ad5ba692e08c41a403109f6ca99c16e65ef046aa82b7a7b738d07488f827c0160e6971c4296821080b463840b6140ba3eb799ec67667f9d39c5a27cd906512dd780ba72282b05e17f880127711e0f2eb6ae67c408fcb3443b7a9e86364011c13a6bbdb57930847dbd6c75dace0d3d4457ff75c76124c85ae6a6ea07c1c45aefa79a5a93da5f8dec1a00bcd4fff658253183f6f3f621c1e0762b1c7a626233011ab01a22a1c5d54220ca225c55f37c054d065d843338ae43211620c223907166f512a47076ed43ac87f2b71f1318aba06f4476600232c308ef4740c94f62690b134ef9248b3fe80046c5c111500786b8d01073dc50aed157b7f900037d887b9adfc9c0987b9ca62fa280762329fdb537347567146e7b4834300adb850a53975e02cc0bbf44c6842839eaa4ea2504c59baa8607d80202ebcfb4bf6c92867cf8a04097e62b2a30bdadccbe39330a7519e16a30761f84b84ab6198b0b265d7fdd36b4f21f575b5c2deb3b4254a660d7c2558b034ee13a7e70543f3d96672a4c26d4505fe459b2e5c490feffae301c4178e4a3dd6f798d22205e96d9571a0d7fd77a63feeb5224f8280939c47c003aea7614efa595ff54e31fdfa13717567a852ad447ed63e275e82f49b9abc12da0073f398a6f6ba51f9410a1168f8b380d0ec4e576cbd55284fbc6f054df8314611287065d269f2dc181619fbc83d04191c0b0e7eeaa7dab4efa435e5ce9689de2e583eba6541c8b857d224ff15d2b4457744dc65913a7a5735ca7d9dd2e257319a4d9ca89c72a6f7943e3d698d01a55087ae1b3551c1f4bc99678a95f91f8a1c0e48751740061e22bc3b2a96b0dd712995f87748f1165c3c98bdc9330ef4dcca5d869487ecf6113345f03c6162046cc4e652d484eeb0ac343f5658de8dc0baf8503845bb649626f3011646b74e150b7d3bbf640f9130cf02ee63d18f1e9232e2682727aaf08b6ee161e35842b91d97f5eda3a943930ee84e136c97ed48d7cb717aa718bf7f5d897a29efbb64477d9ced0dfbd0fc6e2337fd42ae21f816462fb916507a5823248225ce6b714a91c1ff53fcdee7ab8c1d0be354512999b1faa1c96a79d62ef80762740240efe558f97717c4bab546e986a31f221937b7bfdebf5e6d3567fc8bc5f5ee65d727d3abea65a385ac30b077d81f8d80d7969d9dae4d1f31eeb066644b16d7dc6ad9b2d4ec4c4019f0e5826f49394d58f4670a9f573a02e9d41d98e14e463e0b30808618319d4e12a34dba0eabe579910ab8fa3bae57086ca3420508464ca017015fbfbce07ef4062d02837eee13a679273460e3c65827ed140b59adac34a71bcc1342f1d668a7a0a087e589a8de2bfa2418f4c23c334d6f46350403bdf82794eebd500601412feb3353bc138a4920e9c97f262aef826a0a46fa324f89c2bb90491727624968a7b86474bdd008878abffac434de54e45cc3d364521f5ebf56170c84457742992bc15b6fa67e6be14defea8844e39ec8a7f2040266583fcb0acfef186a4c88fb949e68fc92211cdc62d438d19864254976564885cf6c8eb82790eef309220c8e6ea2f8df00e6ca1d386d20815a1549933c5d6ff2e6244420dca06d38f34381aac277383ca410d7d3c197cdb60c0171d8a3d8e3ac0e410ab8895fd82a30a74dac9329bc6174af8f6011b12597d942e905eba2104e862d9ee7f2ee4d3a050ce7918573371cd4b23ef184aba3db536f25478feb852d511fc5b8d97a0e85cbf6c08d2cf0b118647756f5058b1cc82bfcca011f0fecfa792b12564bb1046e5d5669af6a537723a5b23bbe1f9c4b69beee09371e606fb80b0f1f4787ed797148e34075cd8e6b53c6b3dd852c2fab98806465297bbf1eb647d818f7b1c89cad2ed4ff481a4f6e6650e788d0db5408542f1a14e10d576bc0b8c9f6fb37dbdf3f8adda27eb7c3a346141d3f102a6aa18dcb76a82c9fbf70e30f85c935d1522105c68341f719be4a80bc4cf8a14c129ed3d95011f183a6fc23356c805a4a379364ab16b6781ad71c271fab0d328588d5bc284cd533305aba9013fb702bf3e34872ff92aace03ab51e81a216994112f477a05509b68501e1b1a3e14fb05d224e727525a402334b9d6ec4a2d802c51e055c86bb3232f905f65647bed1fe823d1058698f800b27124b46900f1f5aefff31f26e02ffdaa8dbdb9bd42d29a68c8c041e6cb31020b06405804bea45a659e7f9d8f83cd59eb5307403fd9e84ed2fb21269423c8f0dcd7a02ca6112fb771f0058339d6c73f7a2ff4604614362379f95dd5f322d2ba5c39c20d0f55c25d99171c60fc572060ad13b4663304bf2d314d2bff96d23400b2a6f5d4b40acf876bd61c676d556499b02e0ff59b47a4ba7246e923b7595f2a3849384c9aed921069c80fa93cc6612b81f61d718c36d0e6ecce7aa93f177eecf542d21b8da06e44e8a221bc30fd9088c77423d9a875af844341a1d5c4449f8e032f1bd8454751e1e65746cbfcd38212e4c1e88493280cea9b20ec79b2537fcef343aec81739ebe615e91baa852856296f2fdce9787e18b9709811cc85eb943f724a518b7c07a5f0c5c990c98b6d025baac1e04595d1d8273afb2022a4347414d669f6b0dede4ec361c7b892a5c518045ebe919b0266c759c4260a9c9f204344b20ad5081e5e660f1aa9582e3a045b7721b3e2632c3b0bcf4baca1631b7c4f19bcc9b99b13c799ae546a46830aa94f228504fa7f00473cd316028a038125fde702379651d7c2004bdad60e2f1b2f83a9ec838b9c4ce40ccfb506d57f8d508e38f884a3de420d087d7e13d66314f6e34c1d1a2a2185e804ddc98e74f97ca563ee2911cf715cfe6e093fa1a390667e8c73136358344e2bedd8a575187a3be201747cac237d79be60f301854717100fe8a4b9294336494c3f9a1a5709dc47ebc5c5828e309bb1c8f7734c68272269c9af4eef9a581f4578e8c581073e99da9842b63bb6acb4a76ca25d8aa57465f3425de112a93b84cfc15505ac27099ae7567f6ea6c2076e6cdd062263bf75730d6d363a14ce4e3d2b1cbba5d6d7559db4eae5f7c528fd28fda0da198fe9e296f5b595d5df9f2d882dcbc11f80f5120dbee342518851e01a5055314051948d5f18a7820d9da03676318ab4a4b5d2bbd8cfc4dfb936137c0eade828448c566e780858e33ef3d1e072830f8a4366103840d636a5210fc49604b0df0e719b5d2c56e0e27bba894fd4e81af521b8fc08eefbade7d0d13e5472ad0a431094cce4c72c368f35bb18c1c49250fb6c332980851086f12d074520114d9ef0b757b379e057e5afa075b082cf90ef13632c1cdc06967c5648b031ba0853a90322bc80de490e96c4a066357c739678110bbf054810acf266533ca5dc1307700359184dc9f1453b5a004efdc8e2fdadb455ebdd0f207bcb9ec3103b81090dacf54c2c1b8df32939e01ec1d0a3f40c07d898d36ef8246177c857550224afc4be236b2e959294a9fa1142bfb0c2df96944eb09242d4a5a41d1b9c42f6b68a0775e4fec6f91808ee911d4dc4a65d99499b420a142712f121c44450057f26df7b47485303a969a5ff7485da668fea9f6e1c95727c7fc7125d3a388aa870b7fda95c99702a5448578a21958ad06fedc556963e0427a34bef0296445780872c0fe93931009bfbf3b17cb79064db0641370c7dad3354a8c0b321028173954e7537338b519e12c6b84c6e45e49e412bf43a4d179c9c67078802282039b4f977d7712f571b43d9f27e247efb1430aa2c6edab37105a386e68829c03e266f551af40bd453d5a344ae9ce0d8454a3b318836124659e148bbd3056da102aba2688d0007a8b2ca8c379ff3263f98d0c643df9d48e54caf58f1c70e9d5030caf98799e0b34feb2a3e7536cc4df5f8877fc38cac329e4ae88585d0d8fb62428c7acf50d1d299c0b7f138020c91ce2c93ad4bb9883100d7b57bea32d2f41a47588785da1077d4edb0b9c7028d2b88f044d6ace069bebc245d5a89697f3716a0dfd60e472d317b89bd3ce65e7314156dd14fad575500638cee3f078db14bad7e1d22ee286063bd38286f1bf02cc09ed70c90478e58fa25f734b102a63bd3004126455c39e0cc2852772bf63e80698b630666026c6553c3d4fd9142bbddc99b1809cec30b828f95fc51fbe6294838ef7dd17b437e802146a1e61962c3a1da2b99746b82db459aa3b9581e663c0bd4a19a4496b543f18cd7c9bda8e055dfab06e4b8aa0b349b3b6808daa50d564bf482d770066b2ab61d86e10e3383d2a109ba6a030780a0a43e26a6f38af677d7ee8244b1790e95ea5251c8ff5a4bb21c328c98314ce4f92f7376ecb60e65f80ceb154a7294f001073b6cc7c752512f9d8566dfd72f3da1c45de3ec4558cce7a175e9d60481cba7278f4d1572fc18148a58777ea647ab66b8f113b2ce1c19ccb08a0e3cb653a88c96311a935c80292962710e215fa490002eb040526aa77e8032dcd2c04233924e40bc0a5281e816739c670f1f414bf1f98c90fe01dc94031aff1a9a5b30d0b24a07aadd9f7980e13420488a63c173b4ea7d26ac5592a72d3e1f17a24d81076dbcb0f404ef64208fb80c32e2910741a000888b108a10885c1e6464e0d88337f0680609b84dbdf2f6cf621a6c88ecbdb7dc7b4b99a49449cae908d108080938487090e020c978b818ca3363180e161a44cdc211c221726a29e120c1bc5938487086240e16897d63d65a1a3468580c730ca74862188e50754c5a898324f6b0ef18e618866198631886c9c71cc31cc3304c3e0e128c4ac9b40a8da1a6a19c17b9a3cbd235f4aded562d84e10c556be5fb63586452849324f7370b47c8e2106198c42a8643844394e37f384972fc8e31c6fa31621a4252bacea87bd21d7547b43ba25e943fec65add8f7e308350e91751c1c24b1877c0c6728636fadc5fa31db614ad84b1c241107862374bba84c1fa348993ea62477504c09c39424a694d95c2991dcd101c91afaab5507a46dff758b2737d6300cc3300cc3301c249876af16668952a051ecd3c2321b5e6c4011a5e0c8a8487a018a581a06c23e4828504abaf26151997e0724777446b2863e50a68f8304fbcf06540be3a850fe6a2865a991c50807090e92ad33d23aa3ce0807c950969f103a4487b2a5432d0cc3308b61188665180e92189c211c24348806a042bbbdfeb27db547795437b5ef1e4cf22ff4120293fc8b7f7128ff42249fd4a266e5692f87722f90e91d0ca5317b7528ffe2517d536b51c53c30f2e25e8208989f758fd34a8446f7e219f5a8cea332fddae1da5c0b8149d46b9e4eb58a60b49f5a0463d43c4d33bf7a4da47d9a664ef7e251d49f02c19e7e77ecd9217242e5c9fe0ee55e1c4c76ac6bbb7fa18083e91bccc164fa5fe5c9f4a947dc3d51ba4eb55aadb24a04abd5a1dc8b3b189a7de4be5df3a8dc9f2d3d91eb5700f6e040c431bf3e05a003b2af98f3be98fde97ffd51c316a0ef5e29f62fee25e2a0d53bcdfb1a0b77280ec41ed71f2e75aceba306a46fec1199441c337ff75e0cc3f75677778fb21eccd602a5a0529a594b586c9140fec5a7d164329bcc1f24cbbf4426b1470413714cec99f0b8e7e31fc1c41ed2058883fe7cf942a6f3b1e4af91bec41eee5ffc4b275998642f87f22f1e65ab7f6926b66f74b16fb2cbc6cbdaabc336b8e8fb25b16e763f43b64dac7afda940e6cb9fb57bfaa781fae6fa51658c1e07a49cb2a63ec64889bf069232e6a59431d7cb1889a7bc52321af1883f3d0ee0f8681affeb81d034cea369fc57dd7b779f593b1bc84a79bba77d8876864e10f291d7752f7b7550dfd83a677c1b8dee51f77990fd3db0d1a143c7fd19e575754ffb74509440fd31bbe2d7ebbfac77d8795d734ed93e9df775b37b56dd7338462ef55c8cd8771ff117b3786387fb27c6186bec1f59eb7f3ad3fed53ea32c96d2d2084a29b8582ca5a51194a24339b15a2538fdace44ad6d7ea5f2f66699afa95477def9f9f7b351c75a451ee9efee91fc8aac1adf56fe9365e7e359075a7f657ab1f7b5dabebfbea9ffee99efeb1b171fe341284caf3334b7d28fd0efab91ec37a7c7a80682361edcd79f157db6752bb3c214d0382a6997fb55fd877d761d885f57babfcee79807a25782234cd7c9bf9f7c606bad785f5b40fd1ced00942b9bf7bdae7ea20ecf6cfc30eea1bae83f22aaa72ec9f8823621040e9e64f3b2fea7d9d4f8c3ed1c7872ef7eee99bfefbed733b885e5804c23207cafdab0c07a17fbdafa89055a6dff4a77dae77ce8bbf79d7cc1fbc72f5ace40e98454b3dedefc3f9da85bf2e5fd7a5ad5618ee1ffad6f3ebbaae06b258c56a0a2aa519e804108c0f91fef158148162504c1287fac746ee1041d6cccc06b3f911b28aba22b432edf293cdfd137b5cfdd33fddaa0a59e518ebece99f06fa81505adc20c9ae6ed0d878aca5b4148afded8f326766d3513a4a34ea2855f413bda2511f3552dfc4efa2c4277d73243d1a759496d2fd14bb933b5e7a2460a069e8cbeeee188fbcdb7647893db477ce3977aefd5b6bce6d7286f34696de87822ce90814b0d1d135f47f9b7df4b594eaf21d08f65dee8865e7ca0955b2fc68d447b691b2c45fb78fae2d1ba9a32055c9313e89f1493cea1ddd77948823620c3ce9e8c369adb497953d44ca2bf96b2cc668d447b291a4f596d251628f4dabf86b29b93fca7748bfcaefda492965943eda6ca251d3f877d9fd8e7229edbedae5341ce4faed310e6fb8a368f88b4f5a4ac52eff08062a7ab946c03a8a43750f98e629c1a9a3bc7c2c423d69358d7fe745a7ae711bb9c307bcd2513a4a4789587c32a3514769291d05b23858e21d83fac6bfe2d8137d22e658c6c2321625fa6c8e40b2a6ffcbea67b23f02654c1953c6d4444b2ed024ba59cbe5633ffba61d664c19eb02cdc6bcf84d816690c4bcba94d2be94d24acf340265e9cda1a6a1dc574f769ef4e91a6a6dcc58564aec3d5b82da793ac1292fc9ac85d98c29f6f8f859ab6fb0ace594e3c79e2672239e424e3afa9d4ae52a2a7b48cc96ea93acd53d5b8a3de2dbac953f9d1abf8c9531d52f63e5fe8a6bb5fe5dbbb7728b12674c1147674b32be943df2f664b77beef65fec210206c3300cc332266c5e178665ac8ce9732888e5a25e40f071e12f05edf549c9a146a040c6443f63a25eb2638ff9771e8faef1af9e8e8c29f6c0f0a7829c31314907933121104cecc9d66216b3d662d7953165ac8c6912010009bdf38236914aaa237ff6fb3f1d79523a3f87c5f4af992307cc61638381ad8965315f9f23c697b36fe20dfd1861ab3af5cb53c9a631d248e316238ddad30d07f1ce117b5cda9c46b9fafd5f87b9875a05fce698f9ca7b79fed5ebda5b35cdfccdb3a1fda0f836cdbc2e9baae35b41ee8f5ee36f02d93e429bd8233eadb273024ea60f6d628f6f053c32f5bc5d31e7f0e7d137577d9cec15eb74f69823e2706cfb5aeaa98cbaf9ee7d28c8fed06eb287d05a2152fee26394421b1ef9d3a9febd61fa9f8e4dfbaffb14f729fce9c831887f7ffdafc39abf8fbede57bd8fc39afbd3c639228ef8361107ad0f73c4308bf7bf992ffe741ce78838b2f7d1d9e7883dee53edfacd8399471ff36ad4917997f560bdd6a359f36ce4ebd1558eebf3f53c639f8d4c51705dcd5be5ebcdecdea7caf4698e1c1107fdcba39f23887d7f8bd57cbd6b3f2e1db6e6f84e0c9792877477ff7fa718ca1a0c7f3a9375357501283bb761d6ae5651c65abbafefac5e95beeab3cbc3804782ecae5dbb766dadbb76d55aabd1b5c6755d578d7a5d5756bd11dcfd727f00789147d6388dafda8f8a47681afff7fb33f765eea7ea14aa59ad40b4af9b41f5adad6f23feaeeff7212fed8a17b6df39335b1c2465533f2fcef035e78683a4dea67090fa345b2c8d7458a753d2084d4d2f957aa8c5546ad21daf9289a1f365a4a9d92d23b5caa0be8934a666b3a4111914a59154aa5930ef98f9195c420a7f2b8abfee23fe6cae8155f8b334b0c4319f3de7c1dc35f2a5ccdb98d463216cdf7d2ca1460a64fbee392f6668af0d962077441edb45fc7595f5ddc8fe9147ee985de37fad2abb8dec9d67efdc77def69147daae33f79c079b66d2b8e7818d8ea6b12b19248d44a29896192383294fe6539e4c7d795b4dada65653ab896b35711cc73d09ac56d7eaa00fb61e2ee9c82612582434b5b827a1a9c591c022a1a9d5414d1c4702d724e3595923ffa5c41c8d9a5e24543f45a7a661c516f75f6c39877dbe8cb9f0d76fbfeee7c30bb6b25f1fe3f873a923f3f5db4378df2186b0b1909b5b7bb8bdedb08eccbdd19fb971106dbea55fb9af1f9b6213f7f3b78f5a04381c843ecd73bb1bc5b129e2a8b3953d36b9b66d9910559e4f8708c91504b93e0c1326cc19afca9f905c3fe210a872855a08f4f377afcbd15bd2f33931f23bed02a997a95f6b7dea7daafa4b626a26e3b917e3ddaea15fbdeb37cfb3397a54c64bbd7bdb578f6e1fe31169a27d0b3ea7c97d1f32e56d9ef5aed7a95636deb69a5a4dada65653ab49ee6c9d3a22833726259a4352a883268e3e4d33eb47719d9a858f3db455ab18167233c47e6608b1f9f4e13786b8bd6b2c12e56b224c6c65d673ce3c4d889e3f9d6a42ccfe330437531c24e255d3c89ff89b46fe8c3e3b6e748d8c452cb043fb6fe6fa5dcdbb51a4c622d12716893db148f489456cfe6e64f9f0060d26ba1b191681489b0c99949766c72260106476eca3b3639ca691369847d348aca369e4851fdfef3bfe7464f9d9553f88753ac39f33673808ccbe8b2bfe26bd30cd19d6e99cbdd42c40f3d491fd7db4536c4ef9e97029dddd7d524aa1cc117b48a7d247e7bfefdee5c11ce1e7cb81d46fe6ebfad642a87f7d266fd4b2bf5e96fd47865db60ec1f3a57cf9ee7d3bd99d6213649ed28358ccac80c99f2112144639cbe27d68f3e98851b3c0bc39620f78a9f6a33eb4c9a1a36fb41fd5879cda8fe8ae63f60dad6f9363be8ee916c8229071f0469645a42e883fcd5019001922559125677d3bf97767d537b53f1d59d53773d6af33ebab6d8f79f6e22d04fb15f3ea432d848bb7f7d19a1773cde4d5bcc7bccd8b5a0816c6969bf6f77d48cdde3804fb90508bc0cc3447c4317f7ef5be9d5cab471f6a8e4d9099cebf7ca04dbb9de865ddd66dba4db287749775a12eeb3a5da7db6a9ff6913d4256ddb657cdad6ed36dba4db76989ae8fcd894d6c3e8661f75ba7f3f439b1f998bc537efdce9123e2c01ebbded765d94334ed6db04ec3df4ed63ece7cb7b7f1212f7635ee7d74773fcb7864ed3f1d1be87458a733773ffbcf6e17dbcfe1e58838b0cb56fce51d2e52305ad37e72ea2c93192b63ca98baebbacf96baa7aefb18b7f85babebba7e215fec895afc9a88e6e19ed9e9474ee3e2157233a68c29636a2ed6265554c906c810a90a21996d9f79946e74dbb62dcb3c98654fe9467f9b59c4b6542a95cab8546adbb2d734ec436ed943ed470a9b2073ea3b2107d9fea6340d7f3a9db7cfe8474de6b598d2b4985519bbc8c514fe4ab0f37d961d175fc3dfeae55f6f1e8938320c3bfcc5cff17ba7ebfa45f76d7577777777cf65755fa88e1347a87e72baadeeee9ecb8a3dfa3add565fd7d5fdb2bbd6e6edb47baff6f721fe3a998ec39f9579ee551e6ceebb3fc613b24ab5766f93ea727d0111e3a4eeee3b4320b4812df3d5d36bfd2c9bb92ffcc9ec1f1b87878e76bffcaf965ff7758cf5b4aebaae6466ac9d21305bca9ee4533bb5321684305bca5ad795b1aeebb257fbfbdfc6d56de3b66deb9e93f9ae29efbb39f5b0635e2626d5711abe191602c1a86eaaad0ca870aad56bfcac562a94a830a28228e7c81049cb53dd19022710acf0679208c80ca916c24eb6344e1c9334d1d0842f753a5708e79c26c0871cc771d7bbd7034ce719b7bd07a9f88b984cea2bfe388dd366683cf729ee65b85b5fc5fd0c37f3dcd3e0b8af3fc3bd8a7b190e7f1b8ed1525d867566c6f0b7a3ba5b5f2fd8dbbaaced9ecbba2e540bbb2ded37215953fbeadb42f56bfdf6be557f42ba7ee4e9aeebfa9407bba6f32cfefc76f5fa37cd47c84ac80abb7cb29c2f6fd36dba4d5ad72ab34e21bb33a4ca6aeb4c52b12954ebaa6962be7ec59fb6ca157f59ea5bf5177fddcc5bcc7dfdce6ba75c5fd658fc350bee88f9fa3256e6edabe00ed5db9ff120acb1f85be56abfbeca83b046c683b026c6b3290fc29a8a3f8b3b8ff3a0c4dfd599b95efc354b7a3844ba0ceb502a313c5ffe3c328fcc235a571cb29d4c1f7a5fcc70eac85f4308f1ce10f813dac028b3fbc31cbdf9d08399fafc74647ae9c8edee9e65f89b8eb120125f58a7f3fcfe1cb147c5d45fe21c1147677126a16549cb9329a39624b90019224d01263fe505648834c551ce6036ef17f143efeb768644282394797a414c1892edc30cbd2f7b8a8084d9e137b3ce7f1143fbc33ed43af81bd4c7acf6d73790dc117b644dbfbd1ed1bd78fbaf7be48e98ef6cbff3be9b3bfba98ff160d7a4f0377387bf0d43cfe2ef6e15d7ec37fcc51e1c229d862fbebe3520df4e906c3ef6f1b19831591c247efdf815e38bbff8536255d3c097445dd7160c4927f9249f64972e2d21b725bb0cc92ef229c618878cb82d664c68b58a40d159b28b7cea1bfba3e7906c1a5526a6fbd4fbf3985165dd67d6d339816c6f6f6fefdbeded17ca2eb1c7add15ec35a6b6bb8b52380c2bc7eebe9446f88f6c3f108ead75aa56ca7a79618d64e60a2302f4e18544ba8bec1a0bcb466545a3fcdb41a9fc088ce03201022444886b5533bb5938dca5f7bb5563a49a8688344f924bbdc7fca6ddf62dbd9e5c1c3f2e0216df53ed94ecd833e0d3c83551afe3e853f9afc41281aeeeb16e6628cb1a3ecd27aca8dfdfed72dea9fc9182b965db0df30ca24621a11510a8a8e8c8afc88c5314142c113a5a42b407287e5216be81785badc5450f3905d628f28bb604342b466117bd9057b95f6037bea1271f88e4cbc6144c693fb69157a854a91d2374838429747c719ba70862ca5adfe55ab7eb495fb29124542ea0f1e7de95d4511c7b4444d33e9c543c451630b91c1be9958c624f603d37e6c5bf65bb6719ac6dd2c8b1e85497a3d2da31ec51710eeadf650b3008721440007dc07a15f9fc31c74cf3d071d9e004de6aee4fbf47f27438d527af1373ffae8a885303ffb0de6b993334f084cca5805200224052002e473407ffe0d0e289e004d9ef8b548afdc262bad94d7753d10982fcc01f641ae9f8f5d3fff9a4fafce67b3901ba7a58157afd55afb4060b6b84719ddefe4ea79a53b997a3a344f3c8fecd018a5685acc51ebcf34ece5e66177f380c0bc7d6b22ccf99b2a6f3f3f6e98031160de1e08cc1be6e07e90edfd2fee5146c74104b6f7dfb0f5afbf93b5ecaff7d15afc6c275f9e9055b6937a9d2a8b1d4504cadfce95adf56751fb61420c93afcf2eccc1f51c4c603ef640e6633bf9c21c4c80fef540e85fbf93a5f7d91360dee5c1a6913bb97a3a32bbf4766a8c5c64f086b5dd1661eeefa6d0147ab9837bf9f3370fca9ab97d37c69fcec51ec2f931ab86b0f320ac99137f3af3c80cc223908081a691bf799a77adb2cc23aa2c9dbd5de4f11dac6b114941424341b7755b49ed93745ff67c287760d81edd7859dd739b983c31caf0b74a3ab2f8eb8eb4dca6dba425e96abf92c11b9f44ea893e11089e2063354dcd5873faa493d2bee6fc95dc81c99f8f79b06b26fe669ef813e2f5536f7a8d3f2ffefcd81fbdc914714c1c89e4c7244d23bf1592dcb1ea1a19a9e8bacb982e13155d3f9c5622b9103c818ea68935d38f26d4ecb3e9576f5a20dec01eb4f7d3a399a293bfea1d4346c0c3c3c393d382cfc911171087601a7f274fa7de7742763a45d7b369a0bd21a7d1fc88c51ebfb29647eeba32568c2e1d664b9e3db93b74cf5a19cb354fea71d73e49d6c8bfaeccc7249998a48c295679728450c694a46faa50dfd8bec9e250df5c2dfa47c759ebc99114a4bed1624c52c2b29494c5664b118776b7e838638249599496582da72a4949599496582da78c296b5de9be989494456989d5723a2229298bd212abe574252961594aca9231654b98ecbc3ace98ba0ecbbb4aba218337be0e128a431887481783a2d67de65e33cf9caa0ee7ee9f651c0ee2df699efa6ebb56257bc8f5dd7359d777a1622eee2f8bbbb298ec552a2ee6af98ac7db2f631f5b172316eaff95796ac9132a9afd9abb009324c98c89289acec6df7f5b3cbebbc6f7b4f2551854a17647b2a3fa6ea6f457d633f8b4ca4f48d86d437be554febf0c7618ff83a358d7df9b14adfd89b14b3f4cdd2a5bd8fde346cdfbd7b31db3d70daa7d3938079fa6d72b216f32e13dd175936a3d24556b4112a7ac1f06d8a382e6be547a7a5a7c88aaddb64f165451cf3a1f6c347dfa6d8c3f1f4bf2ef7effcad9055c7c48e4a066f5cd4b7d4df1bdf1b8747855d96ddb7b9325f3b1c247eea7df406ffe9c835e653ef9ca6923de4de7bb3aecbee8c4af53efa3f1eb9ebfc93c1aeea3a9cfafa997b39bc8ffb186385075217847b9a3f1b597e8ce1e4dbb8d137f73d889cd77d8cc7fde6655fbd2d85bf2e620af44d8679340df612d340e89bede58b3042962c9f0325608004c73611c7f63e7ac3d8474fbb307bb1a7d3adc03c9d07ee2e4fb54447ef04fc29521779e060d935af970f1d5f8c613c6e3ef804020f9c1c18b6e97af9e725d8c9d4f184d298901000363afa467bb96383879ffda8c0cbfc562b56b18a55ecde6d7becd697e9fedbb04ee78abdd4800451bd4c8a5bc91eb24da019b46533db1613f363c326c81c24feea7df4cceaa15681f8ab9899bf7826d5550efedaf8abc262eedbe0e0768f8140d6c81a3466548fc5ac40206be0cfd2c05f27f3d867d793f1be940a89acde38a50b927a9aa30afbd4e3f40d866d78f4cd86bf1d1d3e401041e5a5bef364f01783e7115c42df443c879a267bf91418a16fb8978f011238d0371eb8b1fb9467820cd3e1ecabc7bd0fc9459cf5e4f8932112155119ce0964efb4220133ad780e512d2ad17df6db2650dfef942ee6f8d8cb1f81ce0986449e98bf8ab70b91a4c89247d0375ff4c9f2e5eb488125cb17d237711ec9f00c8a38a8467f66136498301afd86dac083b2e662007850d6f8d30f2bc14ef6afdfc90c816874172683311fc3c5bc7b304713628e3e5ae5d994cff81f8f2c23833f21170a94a3e8c4a3b39911ca1328f1a86f3cc208251ea59e4428f1283a79840253114a17237f4e8a655e91551ae98994a67972d43455e6e9fba71de53a6722f729fb1b0fd5c79ff160d74497f163fec6dcf757e198ef4f79426e4e358ef9ed9389784be1201c4ec58f89c19f4dae10ebf4a741893dbad4d3f834a728c65c8412716028539bd5d3fe9a10f38df939b95abb54adb5d6dabd9f90ab9b1073fdcee3381ae39960e62933ec9b2e151302f7ddb4b78bf196a83eaa66aaf352de5479b69b9dc77daaf3b8574d7b3bd5ca86bf1f4139ca5052ad8a4953aceabb8a85eceaeff42142d3c818639c99f9f994523a33efd74e23e04f87ce23f388c73827d03c32857c1e8938669c402b2f02c91af935bc11648d9732f85ba5f0d77120f40d7df9590d2fe6d08aed8c4c8ad33ea6ea8c855a08b486077346f017f6d9d51ed6f062ce0cfe68b2c532f8fb6cadf51a1eccf11148dbadfeaf8afd3f1a77a73f46a801a594d6520084f8f34892aa3ba8769ab5d61f556a3f22abb770a2dead76c21c52a5606694f4d250fdd43473b61366e7532e15239375ef9fb2a9c73e06eb3ccc3ee74158e3d87fdaf8334f1c649bb9ceb751b311f7164ebd85edb229636f612f5e4107c42c3fbb7df37dae77051d00b35cad3af9f6b39b61af3dbcbfbdc420b49127c39fcd5ec35a8f32bacfb66af8e26f15a38d6feb471efb596b234ffd8865adad85e05fa5dc561001ee0120cbb7b25b3d8d4d3bf51691eedc8ee922fab8e4e4522ce24f820f099452127ca453129a464e6f49eab7d467b77ec639259a4352a883702481ca8b7d7c7a9fe22ffaccef7af994e28f6ad9474d7a15c31cae336b3848f69a4bb8945d38887c9a351c8b6c7d49bf289d99bc500b217bed66f752ef3e6426af5fd83557cc775ecc432d04ed7df4f5628ef1ac535ef79a977d7679dfcdd777deec9aebb378df47779eed9a4eb5b27182dcd15afb228337262d9a4924510f550924839aa67edac72f0b0a21aebe060d7ba5b612648dfc1586b0c6bf06863f6b37fc75b026854bd89efb2ef5d0ebde53af4abd4ceae3c758ac43b38d3fffd2387c7dff7d03ab1c092515ad6c95f9920d83a4ae814a578601ebba28a59456aba2d427538bc3ca664a4a29ed726576499a5d94565b66019a10d1a03f7032daa214b95bb95dce1144ee8e6919fde1a71b80097898428b169e50102328055fbe48a1c20a0e31447194850cac75dff2c4e50400ee12e6402a8248004b240456805ac1e7878b0f57727c891ca07648010807a19e219882d0c4889a517ab02088682875777f2aba9e8caea7a3eb09e97aba42e3be246da0b5ba13a0ae814244454647f503274897f5a1d671170548d640aab2129801152d144102e6ca0e56a49851c4103f4a2cd800a588232fc208168a70a254658326790e1723f9810c480270ef1a041daec09c14883a5882c44519cd15985ea0a257534a6911445711451da5642c5d23332b5c32392d18436906223118838b0967e8d003130d3cc43086100d8042c6135264b021861536165e70b4a4c4c262ca93c945883e61f3972bb5d65a6b1da247d6403f22a9a91c51347dfa48540a7ed0c5913b125d20d5055439a2a703174aaab5d65a6b6d01c91a6837c0138617536c30a227859c9a421152b8f8c2e9ca911804143ef85213db757fa03426534a29a594529addce5e6e81a5a624b8a0e0821a9ac8a14eb61cf9e28c1b9eb8d024873ac9b469854c690a465de121288b134e725882cb0d3a8c20a2cb9129ce20a203106414696408713b87c815184507617020fab981690b27c8a00923c50f0c8c28a1b4c5880b91ecf3ba2a0b5bb2eb82514481c219405a98086191535110c207061e8000c3e48c1fe60c027c6a3a005ae1a78b2898846090b263431944a000030d4676d0c2872a433cc5f0b86cadb4babbfbc0d335b0074888a888e6f860c4e3b213ab47148baebbd65a6720424198c1a7938107796bad32431076bbd67a290d1840a18b24a640214b171920184ee430250918a1275ab6c860832d2dc82d4a403426d7985a6b8d4019224539e55a2350ad5a72dd7295b0abb5d6aa6a22abd3c2aed64a238acb94a394d2a80ca9bce04aa6342afbe82fa6bbbb534a295d81524a9f80fc49c89f88fca9c89f8cfce9c89d521aaa5a01217af8220c178870812987be90021123a428eaa1410e6d92a92731428585524a29a52f709235d04eb922e0f0851727aa7801051d48d0c41561a298b20394144c9a82524b6828a0ca0f62c027f9811947ee8e84194ad963b2cba6ce6a1401c5282795141eb76308b93483055d50a1a5881f2e722a0c5ec2c8400514229c883d5831349bb0c85cd70e34bc5b128ab2451039ec50802a4a4891451339cc6089872c82c8b670c1946a8a34c865065d640963064a4536c85069c1608518525cc1c40e5910512c0afc4113a3ebe7f5f7baaeebbaaeeb0203c8c1107230881c8c2207c3c8c1387230901c8c2beede442be86ad5509f9052aec8a03431b9ca507aae5c5706a77051c5dda7ccc04b76ef62c65d50720960014cd4e800738070a28149b48853d740a8094291289e09420b3d346764700926650ce13446910d44c02fa0a8810bb8e011c3c91245332a08e001535810b2e1083052f880185a4485310319397cb1a449c90cfc000a12a51489a3a24ce945a288226ba3bbbbbb7b4e22eaba6c784ac20c165ef0e971418e7bb084c4880d3d70e942498eeb90ddfd336014a68731c2202203913158557c3194430a579428c9628c2de668c1436d35b274448b19acecb1570451596801d241c91522c238a389930c2d202c49ae48725dd1c446ad54b400ba3424c0ddee304148c28252b06cef8848ddcd73ce39e7b4704a989e3c274b899873a587305fcc5002064c66d0c40a2e53c208a9b025872737ca000cd410352882088b1c6fc20a931328b690c117382cc0df2261440794ca644a29a5129042650619b4a082d1530e7dd222032316961c9992146f50c2c5551246763b7bf91049c4c0240655347912f20068498a284a5c707246244a8a9a2c4c25a1a8b5d65a2b0c3dd476aaa699494201355cb7be8561587145557d70208e6aadb5da5c6bad950c2f6480298348193e650401554a29a5b572e9a2625813535a3a6412025cbcc0d2c3145cc0f89053e1921622a070c10f2d8881939cfa021880988121090560181230045d3e2dec2a0c3e502a4e59dcce92e1811bb1190e2d886041891b8840a1b5d3f34449a9c81425c62822dac0ca62e6a7bb6777772722a56b60158ba503814896d5bbbbfb8581060e22ca100096b3a547c2d9343933a440450e63ac40a5860ed4008c218ae881c8942e6a68b252a158ea64adb556df810560b462d003124cf084c089962a4b58e122850e4332d828b4d0965451c10b274614a9e28615237e64e00518442ad000c5130b85944ab7b071af59ba062eb59ebc5c3eca00735d36d923922462d82466d0903e204d7b3b9bdd5d6677778fc1a76b60901dea92ac98fc131a293699e618aaf0a06f61930e56b0293a3ce158f5a14910d30d34c870c51139b435440e4218f962872e52c8a133645a952041c017373371d28a60753586da022d15c31738383561c60d363c718617616001c34a1253086df9e996ead12dea248b099756c02d2d7feb491481050700f8400708020e5034fef601558c90e21b0b19317801891f14b238816389a817c2082db510156598c2a4848a7a4756d444628b218d8915b650921d206151f8b0a05a7d5dee5657ba933ba0ac820b112d74e0c20a10560ab084165e30c1822241a470c49150da62c429a53fe7e452246b3a2354847e3ad72c4972adef81cdfc208b224af3db22f4032b90da97d00fc200b2d1dddddd3d3b1df9161ab020fbdba82de82c64f4ba39473dd77529455a6ae2eeee4edfc22ca65861454ec182755398f9a18b135a8ea430c4d30a3b2e70a2065b98c14498216260fd740770772dd96ff6e9a40306548942650302c8ebf2214c0c7a8862c592028ef0416206526cf18506411997a22e00461821c31426499eb4e4542572705ad26207316408e3822c8ca85958b92e7b1373adb5d65aab1347b206664a2d9c39929081c4c48f9128925c71f4c40b160cf580a58a11242c0a26aa54e2828a61510861310c77edd66b80fed65b546458aa455dee8167011dcd656f4733a5f4ca94524a8fba0622d92b5dd22a678952d7c0fcbd8fb623f4b0258620211e1cc0c8a134486106445cd80185a83260e882c200abb5625f31aceaaa812e38602903882220d6046038028a143c6208d104901217151f926454ded3884d89125cad59cc306b0a4d5b9c156656d181bfbda902833036d021f24c4a6ba694d21d20e450246b609e533277777777128c11b403184218adb094e3495468f2c30f3dd090658a1768240f580c4e764d5132299b32b8250b316696a06ae3c20f4e52208aea2923a74a5912850516a12e5af0f9c9c207aaa425fd8caf75d65a6bed72adb5d6397568424a1047846105062720a8d0c4c3194e40d1030c2e6c3942c25055ab0e4aca44890c6a20830c245ed0434e25638b0a34884113404aa090537d726559916bcd150a2472b539b54e0b3bf874058c262f30c289900a391b68a28614bae8a289254d726a0bb9d6caa5865c6b5575ddbc62d5028f174f28518241919e2b8e60118288134ac840528455c55fc0d2644a0c60a428d294041517a088228815b0f8b010e95b1803a86b8c298024569480c207281f7218d225a9064745507872caa13d57f0205dd18254128d1d15a8e05084122c54987822c7999050c14512cf1722a6ac9085926b87a794524a29a533534a297542c30b2c17b080a485276ae085131a869e9eb0b468819226322adadfa6994baef7bfb0aa6be64f9f4a60d00213a32556dc10460ea5228a0e2c6cc1fa42881caa42a653921c65fa36b6d890699643a9e3954af5b4a514d029bbd6908a0badec4ed9092d5aa862a406595a3b44f00075c4154010f1c51044b2ffca4bf6b7d13794ca91313ae82ed98dd7dbfeaa958d870eb071235b2f9ddba60182420b3c41b880a434454e094d5a5f8a28618616a31c4f21fbafa62481c9fe377a87e7f87bd03b668ee34f088f4cf16d9a39e7dfae975801f5d924f9a39f10c8caf304f662d23435d73f21f7bc98d02ca475a8d4abd90b6b9429643300000401a3160000300c0c8683a201411056db011400106eb454584a17c8e3c130886110a38c0186104208000000038051a86e27316406d6ed3ce3d1a7c5e1c03dbafc9fb959cbdfe5eaea1493038647e45084e6b0813e1a7b59819589054d92497a633b3057b8e3ad997fd0c9aeee337a92b499c31c012f9b943427d6624a605d4b0b4b6f0da219f03fb4c6bffacc6ff0be939d2056ed0041aeb82e7af238aff2054aa41dacc5d514641603e9e99b16ea90b68694d26f9c605f4de0de2a6926e8db597dd67c15d4139053ba077c197b0d22d5a558da1bd01809e1f8db0414ddb59b24684e4e788cf6114bddf07449a98e9b86cbf63a180142972d5b631f8b60643047128b90821ecf77b9957ddf5b372c216e44906f12db98c6de507f798562cd7c67fb177e3cdb61700910b782d4f56234a77ada08c97a77baddeb93b450347161e111bd48124f7705f7ac0e8d5e7ffb588106ee4b37eceac6a90dc6f97c6958fb86a819f81b5d417a1b77b798554d42831a709f32942a9a2e0f830bc0ffc1216ca41c3a852a0753375fd1d5db296335969963c4ef6e869fd758229221284da29212200db124983873beabf012c16fe6a095c5d09796256defd7f57d3a8a6982d15c5282f0494038faf4e2b05f3c45ba5044089b6acc6b5d817a0c56e0f896c39611ebe0345dbd7087b530a4d4ee0dd7e0fc3ee367c4ebb27ba8eb363617e9c8fb334fe85a60e9b3d0ad423dbaee6a4449102f6f4a752eec9df7b9d8c3f5fe8d4d05dde33ea5c4941cbd26f46a5a1212e8de4e39d491a8ff6fe7ed2a39ab6400ecc3af2db68722a34ae3a0b329c04fcf70a583e36cb4d67d669a1be32c2de204e5479812263599eaf6910e4e8e0e8f9c2cdd54051a2b4b3ab836d85495061eeb6b957eb2707bb58e8881c871567208447d290ac4e6f05748055a9b3b81293533ad6bc50f5cb55f36d1a5a25e0619659b96e686ed390df754b7d0caffc7149ffc0b4bb17395a15cc48134a67e7290835193928ddfc4748072d24cc005fce5065c6d354681f98305cac5176e5cea58e430b13e00328d6057f11f24e16d1849d6243852eb4d307f84559b665368a8b8a59deabfa60760c7b390cb66ba0623a0c8cb023932aed58e9f72ff02120b4d7c04893faf91a4a04a2594a4f7ffc2f5c0851617622e3c7dfa7de206a31875d3d7a9c84afc4b16c0d549cafd55a68bf679e829b3add2f429d96e525b05c69bdc526abdafa6ed55caa9af6cc1bc605ac0a52495e6cca8e4bfb54e5058508477c0666ed5364067b22d5adf07de932dc18ed953a6ebccdca490ff35dab7f01f82c9fed0a0a57347c3e0e7185bd0cfa8b1b52b2273940613f2684957dcae15d75efd1b4d8ed48a3610fd7336628684f82d3b9af2a01dbfa041dead42462e281402a0267c81ce65bb04207266f52f2122d2f622685e300959b1308bd76f8c21929d74123117443fb08ca797fbf4350bcd07dd453c18ac83681e4eeba6fdd70fb4259577cd16a11472a8e9cec88da814f3be8872a3ffb0c87770aba333f4cc44aa576ef1d4dc1cfff4b222b3a7787d18cd8eb7428887befb3b89f56f534c2f77b8c4243234a59496199c45202d85201c528f83ddba85b588e2c3d18ff684f348a983e017db3abba6292e98d4aae02c17d1dc05554c52cc106002aab9898cd765f0d1e213352e5b11cba418133b0eb67c0ee365a037a97e7412a3e7d7b718d3900efcbc5563d69e6b3bfb3b31383a112f29dcfe12de51bba144ea3804edb425cade12ef5086da539086c12d9d9c0e7348f689977a62ae850acb3d660fa251c5ea72f9d509c2cc472fa86ad3af9b10a443f1efc5b4e1660524648e0cc0cea41366fd05e93701f3ced4600146e93fa2454af7913dc8ab955a6f2a4e4e75a314722eea3f38944e5e604dd3bb974df997567a053c99183c88f2f018d539e9a4d01a9f92514a85c909ee4fa64a12228694538ef9827be3b4e2cdceba9765a2e8b6f729eb7447f0f2c6e817fa7dc9488f74496f0bcb13c15b0fc7cd51584d8b48db20359765e31548faac52f62ab73982e924e4240e5ffcaa0d8c87c7164bbed9d5d62abb4e7060f6ccb584a23ea4877ef34bfcbb59b7dffd2de8d1b32f27643e9448821b667f6633850fd9709ca0e3636c8c05e487b26b8524a86b44d175fbc851377c444c185723e12fe8691eca23a640dd925877e7221c45cca8d6f49587cc20a240a187a4ae8d8c7c8283944d683a422bba9f50f720b53017b1073b85abc1bb9f996b4865b37c965ad282e47b2bfc9fb7803992d8e5871339d0befdef2eac3b91dcc2795628aa946786a25030b11836157c4a3a3afb673643b089fbf5205890103c9c0cceae49cbf37033f3d1cf2473b798d81dc675f8cd7a8a96ff470af1ca0da7e4d53a4c447adb3d765793db935f1c0adb00245d3a31f4cd5587324bd393d9c249ad5aaefa3a1bef44035958154da5c658b36b9b0e520e9dd79ba47fc3381fd04b7d8ed441fead7223e324312b81d2535cfb87b460b1d40df5bae2472b060c422eb214e5aa7ddc0891c45dbe10f29829c6e17f115198e82ecacfc9d6e9af7f8586681e4d0d83a5b006414be255e051a5d5dccdf7df0bfa03364c166fcaadb3c19ae0b4db03e49c190b6586455af2322c8a7f24286052a20e16f73d2df4b5ef8a2eec9d2dbcdfa67de925053ce1a7e8ade4bead526b4f5031286a7aabf29780c1f9e562e4398963edbe970f3a26ad6498938de849dce0fac3e9df365d64b8cdb6eaba20b20c9c2668edad1738611c1c7ee866b78e995e0d5ff10532fc7f47bc350afd27d80e974b56a9e463dba6526a8f7f9f56c44f2a60e9f42b877a7755870dd698149334d60162aff0f3d4466a8fd0dd31bc9f0a6a0231e37cc0a8514b28c855e804445307655f3e21712047233aa96870fdd3d0a30c395f9856a17e9474edbe3c1b53beccdb926e1b687d883361e22b68bb54932a76bdee66df664b47939093d1f50e65c29335a812c634c7153d9f34c640d5dc96d7a3f35288bf792fe511c1984dd23994eb07f1d8a41765c450bf4b36bd960b72f301a225306af1823636814f010c15266f172301f27952bc77cc87f1071c900b48db887773a924d679815ad26e9bd64b2f55445a7c52fa86555ad7a103586a26e91cfb4fef960c7a6104483895e312335160a95948b65d0e363f341524faf09df6509e6c188a93c44280384963fcf095349b603772e23d7f957471edeb3cf3842e9954c451c562ae6ed082126e11f30fa633e13ed8b8aad2a68ee8c1608961b9aeb8bd978dffa513633fee216cee3935e8ffd70fb0342988f37cd71107e6cbde9a7378bc3f444a29bee4e24b27be0172a12dd88fd281c34c2aabf47340f6dc74109e613f062234dbf3926eb9525eecf5b3e7b2f0db67f494f947b03c7136e82e9186a0f73de7b6f16354d83e5dc00bfc76c95954ad26c6eb595a8bcc8ba38ec6bcfe2eacf3482fb1ccd10743c36b4cbc3049cd50f3eba5546d630e7c1e6f604b90c58a9bb9ea9c1d669a6edfd7aabbb46e8b5c122d99c7f8e2876eaf5995e328d70d09a52f6455348b24ba149c9709e73a190285ef17dc742c42bbd39caacbec723b378b848f27ad309cc5f7748ddfb2d3926645dded9d45018d1e559be859a5b40457a154c482ac14327d2537f457a2aaf1fd70a723b35acb156bcac4284fe91e4d9d26334b40bfc76f064f8692e4977439fb25672473cb1518693991b8d1eb95d6ebe0a00a6055713bff7dc495ce5e30357c11a4f3a2a484000d19b1cd7248c137c15bd1fd8bb6a87b635d8380079dfbfec47de5242517be5cee7dfdd32538d26a335efd2167b8d91bf9484a6745d95d79a1d0255903128a7e19b440a165474d68ef888d21744b655428794716d6d835da8fa46e45c456e6592415a005e4006b982f6e3dca2f21b60848c2edcc80ff833ed480ac22c7395bdfdaa464f3fdc746ed976250c5952ea6a7b881e792f2beaac5ad38b9746bb74e110f9fc37018f39397cc83333d3104909812e6f8d16d7b285a30567c16493609fc2a3d51d5198e108393c47a7c3192ba0af2023878aac94c45f81ed6e089acaf059ca62d1a9f8250b7c837006086f5b055073518e7a36c6bfb99729b520455189a27aac377ac4c9f4c6ece7ab5e636fc410add845437551589ad44f3585f46e6066ac182758255989a299e7f144b63fa47afe2654a54ad4882d6b4ab4e3e79a6a135b68fa3e10b7b270174b387cc131f1fdda8a0df55f70b16ce6cf001c97a29ee517554caa7afb9ef13774e359e975d208571cc1e74e6197e785daa627910290ab3a5fa8970aa2ca46d776c26049979ebd0a25ec2d326c7a32518eb6206ae3b0fd60dbd29f63253c7608895e616d0811c5e7d4047421a5ccbd6c07854e096b168e1e6e6d0706956bfc4e2521f75921f9ef0496b3cfa768725a005bc996ade6257608f85509e49227b9915b086e0fceec7e45f0cfca79732d06bab7f01ff7660ef12a722a83a69ae76a2e6bbedaec067d1b7bf4f3356d48402fc95deb8bdbf2798d852d34fa747ebd107d690d95e18bd93121253999ecede5a0c699a4bca98a5fb9f24e127df83724a7ae77eafe623995bc0a0891a306ede8f8481b6109e2af2eec9e29bfef61701fe3beaf142bee1b29561696d16331f9e72e4754166685c2b9bbf5bea429d14ba4f2edfaef69ca2b8e9ed992d234d384cdee7ed958dfddd2248bcfb07efc5752ceff11d9c9e94e8a8dac71b3eb27a94d0dd0002eb3109e2ea600b3c2b5ac53a1eb65327cef73bc99fa97642438202fe05b753e50efdbd6210ffe0ef9560d25e9f0afe6401a6ba14cc1f680c7cbb0fce39a916805311b5008253e29ae71e299997796d254d8e1c8b49d46bc1f75b5f264e9e0b5e629f94116281f67aab11a8e7d9027bc039ea7109124ddd24ba767bf947da4cb1ab6f20c1f1f3ecad8ac5fe98b89ff5a5602e048242750791ecaa49974cac000ea83d3244c27f0cf012b1f0d2a0c3fd80e6583618f3e89bba3bfe6b38ed40c525bc21e01bfb3f60c3ecaea82bda68edd6dc7dacc4dc59db8a7e172ba6e01fd0c63ea22c0e8cb1279e7269e96715ea18967943c6cad4ac3fc1a2928b9c69f8fd480a7c71531647415ed9fbf4ef5b0ee575924e109dba0d2ecac61c609a598d8813f5e30cd77826afe35c362e1b0ceed5b0f294a90d0c65814898489dfd989baab116c44e9b542e25a2b40b2f50df650bb64d4ac33df7cd956ba37da7ef43cb2996ee0b614217389d5dbb9444b366b1f57abd4da084312512eb6811224b72421bae379b18b3ceea05fda400b7ff86a81f750c232a90c49038652ae3de6778dc9a081343e819c115374ed747bf72a27b468b44161e2c7c80bdc44678620958a978b3c5faf0bb8aa54bfee16d9ae5dea2a7abb80818d821489933246249806b87b26059623da82534c444af8fcd7fbe8fa221fc1f5a676d09b2db3b4f7a26a82e68f09117c303ad2c990aa0b0f94febb173bd336f99a9662618aa32a548a0410a6c902525ac35af8a11383389e6d2105d0d38dbeaea87fa56747b37455a3c09378289400002ce006b9aed388022a044e7dc5727e41cc8c45adf164801d0aab10849b6d80af00c4ed781427ffa252573e2e92e9893da24d198c18be2302d4ae707f1e015b6d3dde1e0f1c756824b1f17ef9a27e7b35c3222d8502fdd069db9633bb823c0bbc15cdf66325ca0a883bb1984196fae7c9b88806977f7adaf069c490a9360904a6270ac78855c2fd6ce81924d0e3f66d3674a29e43d7841d14995377b81b3df8e3c24ad9e75a4a742a1114653378e432be0bb38e644b3cf6db0fb2594ccc7e2553dd7ac8c37d9bbba17ddbfe3345236f0e0306aaf2efb95e76e7e1085d344e78f4f171ef734d5ac1167a8c0fe46b9e8033bc60ef7356d6217ef3edd87d9a7206117737edcd0de8676f41ddfde1da879153da6baf66cec2e9e294d8d168130571d04b9fa0d67a80670bd34e61780e7fdf595468d28964c496582e0395e58a272339221e27c899d074c9303d52fd409e97656e5bf1a5a6234b6c85780ffb0f7eb19a6b2c89b964118ec946b85a7f42a18d260fa5d619e4db1fe2d1604d65f11ff9ea6e7ff54fe9218efae44d52a3b8e0931be12b6eeb62dff68960d26555a4b222f3b0e8c674004d26c05cf37e44ec88829bce62cc037e01fd76e0b90ab71aee076639204a0fa2ee7faf5dd11edb5b187c47b0f3498404eb6eb04c040ae50a952faf7345d103f9025c49e54ef3cff58cc9cbecaea5d0199a8fbce17b52a76f14ab573099b8229d9c3241231fb980e8052e1706923ed2fe258b64fb256a246c24328e1a58eec863ddb82b7686712f80e6f0894bcd5c4efd75108a0989e269150e74183690915e16c706d75d8e02d1870602f45a75693292c3435b7845b9ff62339bf37256db48c1f7cf65dccf5ebef80b653f9eb25c7ab7b682a179186b21df221df523dbfb7ec83a299fc3af85072885138ddbb4327cee5d4fd1a351ff994a485f3442c57acefddb1dd83f35e23575577b4a1b8ae771d56bc0dd319be81ffa695f6ba8b1469951dab6e6a951a55d2a835dfc3930e4ef18814c437bf0c32bf49db2020f0afa676369dc21737e06696d01582209b9651c89c780be779febbaa76f95b6e7a794392539bfac8db156ac61e05a5e7766aa7640155769b6481f31e0e04b40e4f2f6705230c42953ac648bbad57f23dc3acf6e0d40dd1a0448b13275a1d25114ab45b219979aeba454231b6ef2c19f1d14bd1e8df41a4a196027b90fe15808c56b00d1d9858d646c401ee823212646390cee0c41aef1c268de3e0445f5726a3bdf9fb39d260202b322f8153ae8d3e08fdb93850ea00de84cde7fcc873b9e29dd46338b1274a19bb2dcb1c5d5137531fb1b15eee12ccf3f622b6ccf383675a404b496ae72af2934c2bf908b73e7e7d653e90d4989856fefbb6b6b0209f22fc90ba0246088ac4dbfe14aa292a8f3587325fb78adf505646db4809b75b91bfc844ead709fa00000dcc036f1445fa2da90a854352fb890daa3c719cb99db3029c8e3321a8d68ac7cbb7c4ed5a8ab883aee89dfb21e21424e998e2cc64bbc3e8d4267850080cf0a804fa0572efbc6a6de370ec24bf6b8be50da69359fb5e514166e36df033c0c27f2176b791df7305d86dcfb04fdbe415b4c8098ac719611684aa6fa3a8b620092f5d509e972be39d8e7b915e50003efea35787a0eb151d0cb4d42ee058e9eb047a8e18fe2917434618b400c9750881631f784aee65465bb0a993f761251bbe01fed683cfd4200112999c1e118bad33a1800cc036c462201cb14eb311742198a737c2d06addd0cd572f2905b16df02104c72598b18bc2810b9a68797f8c60b3081aa880c058954592aa111c2358529947b46f985ff7316915da11842ed713b137c1d99cacd38377a4073adac460c600e1efc5a9ba08e9c176e81c3fe4dd302081a290515a7bc698dd397ac9c00b91b096556f4f8349c0ec0371a00b495f455d1c1c2f7534998edf2193060997c8206f0325ddb5999bbccb58627a72cf4f652335288708e8127084a5abfe2a1201bec80bca5e9cac3b86663ed0999cbb35f560850d806102c724ff188456be78984c0a7b18e30056e6ad2147b2c4b210dd4fa0dad98852ec9d6c756b9075b37115957124417c20b1d72b0bbdb71085828828bb9ed91b02daa2473b49b648bfa99620e86488486806810626cb9bba698678403b3349aa9d8aa478c3008cc660b4958de2d1867dec150eb0068bbe23bab18760b4d5eea449b6cf8a0aacc7f9c92fbde7d882c59b0dd4f1793d4032d3739687eac4a7d743b70a715a9dd7032c1edd330b7e913b53f5509a0827c94faa68041e98ab67e90d40024338b628d6314c66dccb647a7a4c6fab48712db7034e2241273006829e070e0365109471d28130086d5c5261f7418a5fccab2f6fb85f6c6962cc8e34aa3364c3c883bb9de3cfdac133d1d470eda94173af09c85dc5dc795746e0dd7395e5aa4974b537ca80d491c60ce665dd04a0ee780101264e52d72cac0e4bc74251a9c35888eb4deaa560b27f9514ddb8e97310da7dd760df261408473642fcd04b5499d05cf0a0e9edce1ceeb3e3302e46fdac165e282c7d442a1b715b4bf19bbb33132829bdae62bc47b898091cd0402d2f27080a71fe6b37bf3396b98b95734d57bbc839895dad812e658ab0fb9f42e2da9600df5214bef10872b333812ec8c26f33e5ee99463346d5c6e75574296dd0a93e338fbd27c3f48029fab2fe6bc5537c3e73ba7f6559e1b3716687c1977d54fadf556bd148529824fa71b65e184e1fbad43b4bf50a32fdd4549391c284041a939392e7267b58cca8114e903438b6f7c1de15472da1c0e59089c40547e5e7e4cd8ce519cf18374e1c6427be4892a63e1c0ff5f8779c8c2c6ae69caf20d8668d32310a879d8024ed33ebc352958523cec813b5f9abaaf9d2e7b35b4e596e30e2539a2430eba93a8623b7e8dc45696a18717616b4c717236ff496e685e31d825cc220a29111a585a8673555bca769e860952a52ed75734fdafb6f10a0cc7ff3d93059ff2d1110052343a43c74b3d95acaccb101858c2e9247ccce978641cd8dce37252c9e7f92c7fddf1270a766230e34a944354597afe881a32409fc717760deff0c2308fcff11bf5a38c65a8b5ddc49d4b81632d5a5f42bba7eb213158d0723ea8fbf83c1eb0c00a8c7cf2b22509ea3f63117ca0600a939e04820fbd508009f1fa468b4512ace3f3a4eb883224104d4f75203acece5dc433e8070bac4649740b808384692cefb38475d3f2d78546ee0c9a479fc9ceecae43502db6b3f328302fd4c0ce8b3ff3683fd5903beee802b81b0a3dd1a10f2184482c0723831a87fba580f69db2187236ae7b8617d767e9dbabe17a80f361e46cb8a3961116c1eff6d3430b98694e9eb0626d9a9290d4c029a68cd968f865bc700514bbac2afa1240cea5e13abb972cfe2f5c4a23507c97199e38109051dcd7a6ec16d8854a5cab80a7afe3e8399944c35353bcec4ac3c137adb1218515e9f8253602046f64c00e7e533a3a7f63ef8ec6b2a530421d5c27bfddc19ec04704926cb00adaddffd1e66fce77a139994c1a899ac52fa4be82fb3dfc48dfdcc1213d68d9d3e4bcc26159de467e57457211d956f4dab69acadb0b4fc4c263834532cbe640f2ca791cfeac893e39eed79f7e910849199636195c426506eb57eee869a55e9c48425d70805f99d9425385c009d5c8284466e80d13c29694b2d99422b42913aa811389c1db5f6bdcade8549c64f0e90f59a8e2e9b95fb51248ca0da3028a9f242ce1889c2c909afe2a3428de1faa72a918240d49fb5317988457753b0880e61b00b7c1dab119b8294acc2d709c451e7aec4c47debfb13030eee507b45dc85005e9cdd1f99292f55f6fa4635c08de481fe4022fca5196f525c96172c71c04b099502ed75c47b1278c70230976e45b1616060219a5517da0020f86496a154341d1ca2bfb50213d0d748bfd361706a6ed1c8ec4d70d94372ae6ddfa2bbd901ed6fe195ebe0505d1b17cb0344633c3d18788bfa12cf7ca1752757ad8e07adf1e0b0dd6f8a95dc725a9f8a49ba9cb73ee1dfc36fa602921a0c74e5368a4c9fa6d6337e4fe78219906a80556034e4ea138755b775ab81a1858be580cc1840bb646d7a01823e06e72e8e4f86ea922e67149464ab8863bb06dbf04a9b707c181d132b51e3178c405dc6e28da45bf14ac045c18d79fc156af2e5af67554d811680a1adc85784e01812c4313e1dbc25de922fbda597512706cb46198cd154fc5b4cf713af18a9721167624906030acd11be138c844b345303a71a5c697bb376ccf71dd55412a76bc4c05331fabd69fdb691c2943adf31713c76413a77cca27ce33cf7e2c9706210d5548877b082ec64ac55f20fa2aa1464be91cf614bace6c6ec889522dd484c68b74a1c2b1f711f59cc1757283f1c9faff45f92cf981d20079835ebfff80400584d2a2598c2a0a1328e456d2303d920408cbf01df73022410d8986d06a45be6e5b10e295aa75224be3142f6c54975272442adab32edbe9170d3ff77ccf5060a3b9cd0532194d3ff61753b57c795671f44a65e41758acffac18c3c030ce1706928bbc175ccb644cae0592f28ca6efd1f3fa453e5167911dd708b4161a7cc739a74be26098594105d1c41b67463a7710dfb8f331bab93aef5d522be88694511c084980b116240f6f15d32412ea80c6f1338199ebd4920e48a855ae76c84d0fd4f91ad906a6380b80e9c40a555804286e83b5252798cdfb8aa1e9dd31393a6d4c14cc6c5c22659d73aababeba7e4b4e7d1b2d635ef6b4af2810bd29b72ab753bb4bc975359a89ee9b3397b19874658f7b64cd71ab13e7582aae43f457186c4e80aae8c8e029e18487d09a658b695206dcaed9e3aefca674b4678f64c7b6adf6c3a5a16078bafcc7ecd1d84189b250d84a78b6c7107f23015fb587926e612cefc56e6d4036f2c22f5e9a975fdfef8141f4be05a286321dbcf36f900f1207f17a2ebcae5bc28b67b7ae7d0e7c7f6a220819e921eab777caa048999feb17747e935bc701b662626a97d23cf4f19787bc511b0b3e47447c23e3168be736eb3a5c756491ac694d9e22c5162dfecee5845544ba724e6d4768fbe83daac3084778238520eea2352ff3e979972d79fc1a9ff4d59c98c26363a7bc5a3d20e7988944bca4321dfad2c9e24c78a57c5611caaf0a8b804d9596da904d30d6fc7ba59bb528569e2198e42384e2f35f99b0370ca029368caedb38944bca209cc03d0a39fb0689867410f4ffcbcf7c07df8b6773764e4c44423f221c72f38959c7486cdf14b6370a6aa36c2bc494f1a5d52cb98b04b52a0fd5aa317345c75a125c89d638f6fa4bab7761a411d53777bbe6ec31a7547a0532c1051d46d3249dc4a065275fb7d2ac6361edb0093d292054ef52f12b77bddf2a02406e40154ae928ec37e1dd6542dab73d223a15247cb00f6cd97b7fa9475618c36844cd40ba87f85396a51b06245ac48abba12c7e53f28c2c583b4084af190f8b11f1c39036379ca979d4a763e150aab68370264f4c349f1abaaa15f6e777df081855f42bf12733417d3b82e4ad30fb61f90527cd1c7de5b9a76a74ed7fd4ef6e40de4ddce45c84127dd6b2e68a8b00cb0b91a8360018417bdf5d2d0dad41eb92c64c5d8df4e1f4bc61673c2a5bebfc042992d0e0b4ba79f032c11b85a7a2b56a6fe20a4e7738fc03c649d8f90c030a566fdbbae8cf9a705cee0808f226333292b358ed8ac131f6363f9446b8e095fd494c5d8db017188dcab28070bb9699a44f3d1a65fa1d76646e763f313be067272e25148ab180c1373c29b2a5d1d88cde23ad21e4ac074781f39f6e6a937437ce2f7175e0a196a0809f1e11631e2eabe7b37e23ed5ceeb02288be353e5fc59104730f487a0e715465fe52a17a672c161fde5cc3a1291d302893c2bc07122172cc0b7be1b570c570ee5d5ec0a9fa302eae9f7af11720a5eb6351f0a593645551cef15fd32184ebe52826f8eb53ebfcde692fb25dcfd42fdeb1784ecf81c4226faa5c0a3c57ce8bac7004a1d7aadf2ff57b59325a1893aa5c64e2eeb1a94213fdf14890ef1ea94182e67ee4f1974a226424549d98fac21bc68f5cc8810745f569b365b358b1d0ef0b3d6bea0607b6b71880d43c251ef1d6b0503690c6b041454d33ebd2671f9a2c8d728242776818c5341f94aa0c85490582a46048986df28967fafae73118f606b1e5d5444a5ae9ea4555fc483604e5415717385275dfc688ead7a09276413293c75067037f19dcc5975a7d126c666ec84611265e9d074c51ca9b823b6a0262451eadc9838065a6c7c1df25e27ea5afd4722aa065d13b884392477160c874c7529b2f16649c0d2fb84ea151ee47330f506f10f0a43d5720fbf3d2830ea0fdc262249428b1a96e7c1a51a8f1cb054dab4be16e21c330edc26e09b46f985910dd351b0bd751fbbb54ee55dacb19d5903ab54fea261123efd3f454a9eeb0a407c8e81f6c3f01e5c38df91fce785e1a915df5a0cf564f4929e8de88c3aa60b8c344ee82e4a986db5beec9b030060606bf21fe503f92dbf05e84582bb98bdf14a341e5729d189f3bb600b10daae7d8f863b42eeee63b478ff214df14f1dbb0d96101b4e89f5b16a552436007d51f6e375a1ae86ced587156084d20fc7588f68f4a7b7354de53df443d0e7ae123a0d9c0c1584063bb994761fd1324f84b3c73f016dfa394ed6a06d94f4941fe46a136a77aedd15d7442530014ab776e8b29e82490afe40a42c03c586d25009bb39870e80521fb8a98afd6c4258e0231624c4b6b5d1c90486468fba753d40125a906e9bb422afa9f4f1630168906dfa7e107bcc4ab7db4c4f418a6d48102b104a7ac01a80a37902c37d4ddd68b11545c94c46dabb2ffc0499ce92b9ce7e68d9fdd9b661b08d3ef2070e5798207d155dc4031d8e790f755932b5f110efdd103db0dd5f57679adc68e63566996692d58175f54f8e88d56687d6c6984462d98528bb86c5343d0066c4f5b60827a8b32f70ae47128b56768806c2a90cd270a9823a4927d65133e753283ace4ede88f77a79bb0f732abf6637e50dd363695018e1d46fd1acd4f02cda0cd1fd9a0181f7e258d9aa2521c134af1f8d9701c1a1387b2068f636e316b205ee0e5f23000f0dff2877a7535f2ecc1ba8d773733ffc0c3c1d13c3eab0440abd61cf7b1d1e713de0bb2122e496d85777f7ab9b7fb7d18dbfafb49cc0b7672b91aa8f4538b22870e7bd5613d21dc80db7ffddc4547653ca9ac95ee2fa863fe4335bd7e47e1f16a5ae5d583b1ae5121b5d115a4e145ba8d8ae35d77ecfdb9ee5073b5cbf91a655ae59ac7e9aade352d56a0bf4e89f0a06fd5c6720994d0c10898928047c44ec2ccf98c8b55fef25f3c63af65546d9f0253a5cf60d4af355bd0af4654e76f312ba5f6863873403f3e5e83a7abdf6454c404bd171584ab2edd6fc41c92766ed08aa0d98909659e0ae46d59018f4fdad55eddb76555987120743dedcad6d864d39975633864a2372d4fd47df22891fbe574cc98c8dc0c6ce31543deaefeabacc5e61524e857fc6f2a25708ae9ecca69bb73d329d0db216ff367d0fc4985a805815261b8fa94c381fec413d91b950bc628b318106775642ac5598f6e28a2e0ba5ddd3997e066d4b762a9e8e0daaa2b5715f7c792ee80617d4a4edbc844dae497fd6362b84bd28417d686aed2edb5ab0040209dbf93ea3741a035a7128dbd57d8f5c3b86d74ee9e4259c60e91f1f91da169b269f9dcb6ee0f8cf0912d60a67485153e0c714d17f2a4ddfb06e69d5e00693c589427bafc268f7517e12721bf77a63047d0e7dbf3b7e9f0ab760cc2ad0b9e08454a92d5aca6213c8b1687c2508514d1959a40274ad42c5b4a9cc776fe16d6b5831ac741f2543100dc04127df5ab40814e451aeb640620b83d61d0dc5dd4b4e1b38f9b31d88448c6f82ef912da2b7f6ac2092aaa57c91db3e3fdc2737d18cd0d26d3dec279e3d5a1600f439cf7b39908ab432f2013c17c664d9ba082c5e2124aaa75533c307d1900189412b489290ae2f64bbfdfab33b85abbbea3eb1127997c1a25c08496803d30830d435be29bd7712610d80978d99bd8cffcc26ec7ce36721bc1608d693766862c5eed5a4edd1ceccecafc431b43a0ddc4e61c495aad84324c5fd72afe796f56ffc2afcd8f19dce0fd07189e5624ddff289ab50bfb7428504dfc61d187af96fec3b3e1c667f9df971d25ec45f58295690e4f20799116f4798c5aafd6e8a668c83de256577290edd42497e0fdd2cef8a584853d518b2885c076adf5fd5c0a590feac6805296f580852ed94d7ceee06e2547d860cf710ad7349e45da4ab78b52924bce58e2bb6781a42da093e7cd415f862450f0225a6c0202c24c6d61410a153949107942da590f8430cd2fbf8313b723f43256a5c516c7dbc4284c6bcac9a45d5f99125b4e21171235259858bf34da9e23151a90bf7bcb29338af2279181eeb97dd9a7a5b982a9881270bbef36594409641b653336d3078408159bae855c08087cae314c6a8d1b4537d5983cc6a5a02edfc24616a4919d45a70db6991879660cff2e518a84dcc7b756a9d5948a4da2347b02c0f8a64b9e658502e34aa102d154bf2332c6006d1203e2fc8535d51765fefd3a0d58bdfc8c0018564307580f284add372623eee43356ed643f55dd842a0ee31d623fc293954169e20fbd4e17bab888113358ecec7c3f064fd4040a0c28e88389fb6df2c2340442e547776e4e1146bf5a40d2ead13a7716c30ad257df55bedd5d0333c1b662dab75715e1d71cb2e8a8e75507a67af6ca54eeac38574a20d6544e9eddfbaaa8dc2614fe19a92e7d1f9233cd1cc82056df90b6546c627030a85f5a2583af926c0319c943dfc4e100b53f44063d25b15ca65f99cf16ace246dc3610dfaf02c839617e198f70532fa7811c7d6a0b8c090f03c1e99b0363a9be4cc300b0f0c049a741ddde557885ef2575b862e4fbe118597eab7e3b084841164a1104e4d77c62550077167a843e2d26d3bc34f3b58079cec354b2176a3225cd99228d7d4175ff7cd110807f3eca7df67ff3f739156237fddc5c0a569cc2a10a6690433aa9a9f380f0d6b828e8e9c0f33e00a08e1e7607f5be89c93fbb25cb717ae79cf3a55ec27884481f4f026ff5e29802ac326af82c955e93e48f48380cbcd68b56d67eb619aedb66a57d4c91705a6e5da971b9c3137d7416067bcb8572840fef86b698a0e127e79f5a7bc6d525aa71db42ee1b43431ddda0f7bddabdb59441f846107cc12d40e3d88af4f0d46cf2eb3518e5818db50d109043cdb254fc67e86c3f8dc450f12f6a89a910bbfd226a6b9dbedd3073ebaea5a725db271e18b87cb939e4623715c4ac47fa5e704c3e232b037b9bdc2e55e024d89225efca5b84dbff544c98318f7a612b9fd74d700284c4acb70c3cae6c3ac03922d68474e3d219ae291ac27b0138799c5026f6fb41ac0a3aba6f343440f934499181848b1b248c573433cd16b9f7eecf856f8689c6d512431d16162e1e7900ee7b52cbad1ba1db00563910bd1ddda16fd2bfd1ab0f7eeab9141312da2c45d0017983b41ee9fce77831426a5157174d318efed0065c06d0d98c496d6263f2ea0247a7bb3bdee481ae8e2b05645e0a056e8966f6bead0c370c6e8e357213016b6f24ccad426662dd88ea47f60142f4553f782f1b62a9895babbe191ad0d2ccdef778f0c2ed83f7c00d1ecd3b146c1dd7f9706f4d183ebf1655ab84a1dc33aa7dbdd121a60b732448ddccf417ba5eb4ed858d3ffb9bc002aaa32bb56727c4b6d7775ae517184901bed6834e48c00b018a000d8b5f9f834c2aa340e286df02657fa0486bf412176df2d56478501b14011c3b3a6f2e1c623414941c55ee8422269219be08f3eaa54208f10b6d8b8011a3cfab153eedfde72f9df8858802c19429a92c36fa24cf9c620d6b353df249df1dc9661ed38228dc60901c4e0041990e2d1ecc4c6649eb3c0147dca3853f93fc391e7e4c0c231db531a28989b3a66f86827471e06c60ae72ce467982c2a198dafe7db9e32b13886cc889f5350fd2674c72c2dd7ca9dda7ec1725b95dc95ee46bd0a58364ab7dcb56c893dad2410a690eda7a6fbcd9616ab06242fb465ed3a311c0832b3dafccc7fd4aec7a29438b829890d0264ab1c71caca5275fdc9365b0b4a360b6233fda469ca9c04b4377c5c762f8feca45b9c5c5b4bc98d48242c11b32e2bb83bf2353e520f9ee0e9dd50cce0663f10f9578e6f5017ff1d38c53d2401cb7acef212c42c3c92315019f9ba0b44ebf7d91cfc2b74a36b5815de3e07fdcc747ca873cceda066b8fe4e36f0d22c68050f6cb84bf99649bed41d2cfa690d855874f90a34f7effd444ecd1e8e91020cc36eb4e526e9c955aae390e770d8adc29339a3784a39b2e3241e249e377da468532b48c6bac5e7fc152a0c2221973e7ecd48cd1e4438818f4421635a5880a01d0145c7d108243d436cc6384cb1db3c4e8a1806cca564a19245404eaa0270be47010dc933845bbe1aed167c4b0409cb09089c2539d8d84c8fa8e3daad0f567c7787a21ffe2007020e9e840c4c27036e6c58b85f1b042811704df3412d1ed65ffcf147daafc825beabf88d45d2697b3980ee94f2e28c4c510a6ea286212f349ee9ce58f9ad390f388082abde3cc57b24131ff8d409592d4afb72207d7be81b9d6f327b62edd48b778662f1a7c1285b8edb925ddd607574db6c1004e924fea133014534d5994002dffad8aef98b4c5bc5122917dd6af585168b304e3af3c33a3ac70907790333c6b46411f6085e5cd45fa21e49d2dcfe47e20f050b2f51e1460472ce6e72d24934d5168e2091e032a1f7225abe9cf44171629ff11884331639b15665cd07f1b97da95259c2b2b6d02779aba64cbc8386abd9ec01605a0472c61aac130b2b50b30ffde0a382c4b03cbef05fe18a059710a1dddfe10dd9f2a0df8f1a29c62a73b6e3d7816f15c9f0774fa5252ae4bc9cff8de151c08fe7d9433986166db01cddbe071e9a24866b279049d134f24170e0362c57b3f8a24f671a41f430ffab779ce85f4cc791de5c5d4973b95e3d0021e845a27694174c50cac104215ae199de0c9c6416bc5dc0f67d9833a1307f76da4d2dc08e0738e48dcfdc351ed590894a669b7454167338c8e54607b1cb7e83109c77ce6565151288811fd06e85f78bdd0acc731876306dc09486ecf45b0ff360937ee095d6547998ad7ea915f8e45069adf41a7138b923689bbceb72ec50a28a39a263d56cf7548758d16ffa678766b0f348ba23509d19d79df2b0697d8ca50489aa875760004fcf64780c1a7b8f496087c99a726bbf870531f386387541183ab56a93c585013d945719dfe6d1792c00ce4327bae8fb2c5d6c69592dfaf16a80c8c51d96767055aa2042948b44c3db1798dc6251add9d5201667283f5e8ba22582b72ab7a888c547a8e2200b91ca764a5861f7d2819cadf8d564c404c93986045b8fa71280c1e1afdc2bb23947277d6a01dd53c5a69c6606f2d6b62e158e6ac8e8ed5b90907f54c3e9b70911e2ff64df0c06b84f9a66f6000a996789b282ad8cc1854c9c9fac5c0bd9ee8bf8af489996238a6a2a8eeb447f4745e53fcd821f079b2b141a2eb03e9e14f81345b35234fd62ff8ff9a8265ab1d940d6ef82a5c0a114181b9ada05db89e6069895de018e45b0c2325a3f8052e16aced660b60dff921a9a436acdd84ed61a3e2860e98e4aba16e2dba0364e200dcd1309988969da47b504f6b2ed2dd3620d24c630d1c1c7141ace520342f1f8b4f8ca70cdbfd3a7fc02ac3d41e182c264041daf46d331fffa1652417b944955387bb543c29db51be105adf3e1774813750bb0ad4170c473db702c3918da93907e1dfcf0a98ac1d3228699ce934afbfbe70e9177386c4d1b43cc78220286e3dafc0dec043617fb8b4f934965b61937dcb86eb679af8eb6a01f9a53722b8b12fc40dc1ec854923279d6a7aa2577390c8e101843e11cb3b626400ee2581cf018a71c7b67c89a16f24e75a78e3816b8340dffff2dcc50c3a8b38214830b70e2e239f5028f4f7716dd8b0805c163ba3aabf9215c8bd3680bb6d09bdbaa3de795978b0f128c9d86664350f07066a6b29b7f81eff281bc8cf5d07b01118591043e93750fbcfc568100ef4dcd1878879f9bd7abdbec3d0407fe051d5006efac0a892b25723fe8d6ebec81416d8730486449a65c827eebdc170f5b0708b764e21c0c18e7ee522d55b629598880e4f3ecab72dfa21502061735aa36de7ebff93d85cb7a2aa03228ee16a756a77df6ae26ae5b7eb9dd4b0b2768a8ce4991a9caf5d6829375dd6a22cf7c5efcb824e2b15d2c6031c3a32544a0bcabcdba5c3f19e500d5080815e14222d8d9f3f5c3a06a8f1bdb397155323e484766b2aeca78dc5b5428071a6509506fa11cb5600376782a3f41df97a15d186295194db17679c7705988bcff36210e1b2c0cfb8ec3593b98e5716782366174e4b340b9603e4e1eb7b318a005446991d6ee920e7a402f26df7cf0df9e8e19bbda3a2bbcf55a5046123ee5e9fe531394f162f575bcd851e3d8376a2cd70a07e34bf0976445f4fc96cb8817645f68e27e30bf35679941e9bfa35dc60b1bc6426d4b6f316ea1fd46cbd2fe4ff09cc8457540106c94d8a477a8f7e7a7f20e0f4b417a6504cafd37d3ea3f0d9c121b1d6a7049a4e7be2c4d96c9a58895593b95b0c8733cee6e21138120a4107f3b558e0c741f7eac17aaff5b431ef92acb2f74077ae1433970a90ef7124279648c16e19b5c0bb061be34e07e9cbab41b1d40aa78d65c4fd8b67f7501b6e555e71888e5b3f78151404eb2b019908bb3718ceb560e9c9ab6142849bb1ccfe32281a5050aacc244ed85e7ff1d2a66b359197ffb38dac24db7e95afa9ba67c6566d637635a059229c682113e13e5ca09ef09c5ee982726361a473c8a78c38e98224af9389a95b668661ac707150b34b59085f76f53eae40f18554b68eadd89863cccb22bc901fe252ea073e0465fda702d66af5c41456f453a5fcb4b42cbff3b1c46bd7a67d8c2986699af69b7f274561291a1d23e8ac67c66997d038e75a51c090e854a34a59895307df338d4489630e69815c4286c15b0cade61924cab6bfa72e9d7c6a2883f2c719a6eeb2f52ad04d46794b7521331c3acaec17fad69309cd8e5f5ba2587e2b6fdf96f3c3a0efb9ff1a1dbd4fe63a47e945db644fa2524017749472a4acf1ce36736dd79ad20fb6cd56ac7120fe6ef9a234fd64b0f382651089229f8e12caa265f8653c3455557db3e66119f44788b3219b6eb56aa9b473024d1f1d9ab9021884d2fd54300e665c99bed0c1b8bebb7c0450b0aa7346af40d92f147c4debd4e18eec8ff06e41f4428b6263998a055790fc6f9d2a6fdfa751612cd806b20044b686e2db6924f14a706744937681f2b01261c164a248affa130a188f811dd0383134bc0a3255d6a2e2cd86888a8d20a8726dd0ee9bea4eae80060bf571f1c9fc8d431a80faae611a21c75fcf38aee804b19cca8fff6042bf6adad856959d457987bad209deec3b8db3403d7232612793fa52f6ee2d092d62f00539f93fded8d68cfae99c664d1b85802849e965a83699ea660ced37ff9347d23eba51786858d90cc92f8b9e4dca098ca8201f1b0c50b1965c9d11cf90a5328c7fef788974fe133f9c6c5fb82fb9faf8d2c67abe04ad0f2b6d99d997e2fde14946157d741144afc4c184708d6eef5454662a040555eaa9a75ccc3f5a8e96c7bf79f1731f22be6c0d5613236715150b82f7dae0f49df8c0c1edc0b8efabd34884046e82711c633e5a4affc95bf4fdfc867f27cb4411fdd021a25e0facc39bac00d48703b133a4cce73a3251a97489a5e91a5c750a321ba05182c9e222b2b89110b2a37224e7e7185b6b312084d8ad42321628a1bc5065576a21ec6f4575b1bd12a4fb114e64935268a2d1149c705b5dd2f33d66400b1ee8d0f9e27c38d90ace9f1212773fc21ae6e14a2f216d18d8046f7cf10179f478910fca7cda830bf659679fef90c4771533272c12d68225ab13d7ba40bca75f3064a16e75abafacd0c47f3e80ff3a9fac8eadc6b35c7f907796dd115f85a1ddece1639a4dd16e4c41e387eb4aab0d1b5a6a821cac523859c181f5838331292af25a0f4421247feecd0f08b50879c09a0e9b3c8c080acc11743cdf68cbb98f3e6015215f98ed03d77c8ce6515bb6e5809891590f977c25bc33c4924fba67f8c68407ae44e22b1bffd2cec742ff87df31480955dabd878f78c62fa22c5fc505e84799224b7b2e696b6b8d7b3af2396b37baee8145b38699a69e03b25c4cc303573ab73250917236690462b58ade7d74adaca0e992fd1c00088d7e0b580ca6c94956cd4e088eebb77edfe8b50c987205cdc013f5474d712d20a92c6d465660c9b7586ff3bc95e29cae9530686460459fcc76423907d18249b27df63172ffda2ff9d02e27790fa308524d50dfa45f1a651f42db129654cdd92e6fca91112a8e8cba2b74ff720ec2e8b584697744f27f04214f608eaa334579bde610754da818ea1cfc475eb34ba01c3511655c324146d64e25225ab962959a38f7f058fef72bb44de5f5abdb8f71b798d468880d82d0b95a2e23c15db002120bfba2b27d3512f9581aa07779b63c6c4e7c623a423c1055a33b20ac79ab152f4459ab925e6b9e1a8fc4522e9985c1dca6dd4683104ac0568f54f8f95166334aab6387a2d8984adea6cfead18300f6ad6e8aa9d4c9b9b1caf35abd61cae34cf0cd8561a60aacdf99d0ee5e79a7e10e0b5faa308a25d2714214180533d0786f174606c6900abb21a978e9eb807419514105351f5447ad7214665971c07ca269af5c1581962cdd1eef068bed429ac0447bfb5c6a09ff6a642cb3e4fed99aa194046bd2c16407b259064ab7c88eb431e9922c94872e464cbe8bb61fa0ba6e2833679611d7aeb0020967400453b4afbd7d08e63b974dd5a82be387d04384a0cfe2340388ca7cc65258a87c79b5789a75a625b42919accf2354310b3d13036195eea53200b57aa40f9581d0de0cc8bf8a79440465105810174b3a3a6fd1f0d17d42f166a915aaffdfa1cad7a7f21525edb291ec528fb28ef17de46c715ffe826c12d2fa6cbae7ff18209481568e6e4d517a963d89a5f82ce47cff07bc6114250fa8bda74d89f6b3b449a2543da70f7598bad8b41bac34ba5e446dd67f47ec45b48d399a31bd02749fe315d95b9def594f2e025c7ba4bea91c50290b76548236efce6adc9204a68045f51224ee3d215406bc4e91cfefa389f742743cc3c88263c58184345cd504f7a2d3ecce6e54c2e62ca0ff741fd7d6781cd452365600d5257ace82d1108fda2604408b0e5282dfc9b2a3d496ebcef1dc84cd132e3394269b708552ab7a299c2a92d7d5c568fe5b4b9be573106f8c43730cf36b5777ff259cf8921f3f023625e8d5886cb90111abac390a9e190c4e58883492f6413c01592c6d2081bb22baf381ee5c611250633097fa141e734a37e4ed25183b0e195e3515d5397dcb19fb9f2a8e866551b2ad495d73ecdf17879fe2760470314ecb7845c7eb64d9f8b52d4db6e8fcfbf862c989f9e7b00a61bd00eff86f10ece9196e4daf34c37270c32218a13b43dffeb77844acee6b0d140ebf2cf6bebed2a775715167ce6cda868ddb7f49e9a3dff88b047dea375005bfdbc4670d9f1db8f85e2c19af7ce7596f59c52ab90563b25ee37b433312f9ff6f91df42f639c129df18d521fb102dca9ba02329dcdac00b75c01188c147e22926451a324a0087023979577669e75a072a24e3fde240a9e63da294548c1944888368458217b69310c24ace65a491706301601cedd5604849d56c8176897531ae36a0c0e5fe1e58e037e5b605b8f7de118e0132104a6024e5ac0351b97797861469434c169f56293dc759533bb0a9f9d3aeb8c078f134e25db575071f2e3ff8d0bfd754f2b00cb9b9cdf98cdba48cc63f52acba1337df8ea5bdff0b86f6df05c30c9290c02fdb4fe0e803581e58a798ed9b05d161ca4b422406297e99998ca1b05498763560ebde728022b870806ca108f7616bf42d50d7b93275b220136ddd6569517fb6df47655b9f644c839a5ca6f6fc9e9276e68373f342a81dd760aee860a929968001dca568ba4d653fb44061721294fd13e3443cbb228249a6594758548525407126cdf73217e3d4355fa22bb02f43a40716aaadf5d4848769f5787b312fcbe2446ee9fd2f3d9e6394422b86093b9adc59434ce1b4bc8191ae377b4e5a465a65848b214e00bd930349493f081fd06e4b604f3127137b237be8b49fc25d339f4cda47ed3b41e500306e8d28a4ced5f1255e83b5d6345af8e127f26573e3ba4d5f401ca1e6f8e04a84c397b220e9de5f81ab794d902a1522618e8951ef3a7c0b18e2b2d1a44470fbd1e364c11904efdc7b4abc7940f98437c3b94e4041d3bfa54a16a147c86a31dcc443f417d71b665b3ce4c4fd5c93a64d0caa7475ad841ebf9ea21c81ef6bd6288b7243223a7e16966450cdcfdf90fa3d9c0b619499ed26ae03f878e22da3a4fea071db50fe85b23dee399cb6c424206e663760201045dd28f5f68525cd9184d994ff5b7ef095e54f4f1d82dbc32d9c42d938b78d76c9a4bc7e40363c5560434847ca2b225e14f5013d6c2c9886036de70f9226c28b26b7f67181ef7083ed0349ae0d4aa480b969f6f80f1074067b6903323b0caa86173b5004935a774521bb0c84432fe277af6b044aadcd3d8164be6acc7ccd82e387fcc704d9143128648bafc7a0c0cdf7cd108010d71653ad92a4e8779117449aeab5ed7e536c653a60fc754f6159bf7857565350be67600a01685674b2dc4de2e599978431a17aa28815d152900d387214177f50873926b5eb01e03cbb53947326f41df437a1c312f2433f5ddc913a81e2ad4497b08bfad2efc20277ef0cce54dc3bab0b85d2fb96fa615608ff0dd6a1002dcbd16434a058ba48d4120549db425f62daf11a66473cb6cdf845058e75ac468a836d366f5c2beb3dabc3f2de720747a6f117174cac0db02ef18f99842553657f1b788974bf52adba26caa2c6cb240a2db5772264450f39a498e400340c6b62356738be8bd7d6f508f1f3784a34581c8f54e26b10f91a5c2242ceb6c14ed00256ade5e8fa85703534c0b5113645c75833aeeca79b3f58d59a1c15fb3d4a45252562af9087a406b30140b06e7e36a49fb91dfc35ca4a9f302c96be68db70bfc56e6571a6460b11677914b209992fcb02b88c146231313d41724ecea37a988b6c7c5749858d5c510dece0e4cfc003ba972da9e0e113e46f3e96908a6d987b7d9e3e45137d8a96a1332e9f286d4c192db7669d2364aaf49581b253ef66e8fcb697cf1d11c301dffbb932c26923f1e46e708ae5e4f4aa08d213efef71f8c6479334ec2e9a7f28bb79e21745198bf0a69484465b4c277d9e1d4d05349f613759de6250ba6255eb5c3abc3c1f4aa354ec9d4bb52da4a5ccc1bcb14b901d3ba45024571cd278667e8293bffeb2ea28feb8a257f02095ad95d6f7e59c84b9cda3d65f641ede548943ed6e3b825fb6f97f1ecde8d481d30486239769d271084dce4dbfd80f70faf8bafd8877351290641522651816d638a8193024d4f86f4f6afd405a29de090c404bbd225949c442fa451f89f98338be1af2cf807830007e1919ab0b0afa42a8a7aed62aae559000d07975903f9545257b66d67e2e0d04c96c041efe309f1e3f04ffe195a433476f4c6082ab5537bf5f3ec4ef54132766df71336674728dd85fafc35968e0354d6c6fe04e7b08f20e48b3b84d6c6886855d7e0719a3e2acde8469743061d220c96473a58373532611c4d4a1499f1cdc28e625ceab1309b64d2abc1c8f5886182f8b16903df44a26da09b86a666dac7f4a55b1ba101b70ce3afd51a4124df0d198c17dc582377c60d76e7d58817470a77cfe663e46d006bd55e968a1a396c5b90e489a019ace2cdb067f21b843a6595577f4f436bb8e20fe4eba8002002378def6f9f242463d68af0967d01e922598cc1734562eb1ecdf70c27ab79edb1cc6dfe91257803ad4bdeae4103d43f92acec396d458bcf3422536712ccc01b6cf958947d2bef3b13681397fd3a5614c2dc70639fe19415a204c2cac7738fa5cb414d179a59ddf2fca5dbdf0b9f71ca32882a614486130674f0e9e87030aa04f91060ad27c6c77c23fbe160414e440c40dc8ae8570f11789811e7b80d919bbac1729f5a052b887221c95e9982def61774ef6b6834e5605a2b903ac67d1091aa28a31be6397ef53ca011e895bbcbd356e833c049b8942955156c576b965f56a50aa741e64bd7a52910b28821305006f059933e66ec1355c1730f13e54315ef0fb69abca4c89862564d14e247b3a281a0f7da1b4b59c3de7f6e8149db404debd12718a565d2183730464474f28893ca0a5e4d3df08f1a6e5dfa3dac12e21e6c77fc6adc8b391bccf86bbc10bdad3b08bfa397e013f4d9421992e92567f0d5fa7668656269dc5fba6274f015b1ff2a77180c5abe1b23346bc248e60138e8d7c5b0351865d3f32a63c05c2220ad5850a53738ae585f3d5a87c992064c1ee43d828dca86c9362ac032746e30ab65122dcf63525dbb5b7f4c2fe7c55cb261c46909dd5d526c4d03dee69bc36be1c963ebb747c5607d33fe8e80f808db2b8a0b617ca57707e1fda42d4b3c673459e105c7ea8bcdf756caeed8441f9bb8f71195cbcf206f7cf7257f32835031c86f71a9a9c1777c4ca04f12ac0be35f0a6f0eef19963261a8ba82b6a09fcdcc00a95f80c18892abf91a7c7fc76c7fea6c76ab657aca8aec88f83ae1233d51c54c94afbec272d7268775fa2ca82d1f5155e730f9ed0af1e5e3f041f49ff951ecf27f23144c10d26d80fe02986f68e787e93a97437a6b67e0e22174177c3767a1961f5a249780f8d27982b205cf2c4d8df0c8dc14278fb31512c590770ef7a60139e664f723151015bfa88a1d94fef5cccfba9f315507d0e190426252e5025248e2727ed510e089177ddcd6a78be55eaf12a18d77d87c41c8bd4063d2a2f66fe2c78df37a4f1f3da702c6335a1ac01a1f574280bb0365a8b18af900f02c824ada9368c3ed361ee2120d4607071df4f4b18e7acba3de60929b3aed88760d994cffd4504f86178b081c22d3bcd08604619f16aec80a39f5958a70b0fb21e82e841428ec3beb9d5e55ceb840beb36cdadca651225bf1cd281b03eb423ea3e7282b6285caea049bad8c2c9facb05271c4114a0b1250d881a929dbb0228635fe48012c0a809eff1d9e7342a03ab709072492e3a288dd3c00d4474012639ba401d6229cde5d59dd0895177fd26ab8b24a904b2778e2228cdaa95d5e2e967a87f1341673573c81ab05d3e0b92e42e36631d9340af84deb6fd0c45fbb808037532235da5b240d2c76e29139de06313af168279cef4b2ded02f6ed33db82b8ff84ce55f02952021c1bc258ead2be227bb78855707f66a3b552421d154863fc7f301989649a2d4197ff14662ec5363fce81ba4f3905a05ab6367bcf9f46d9b3aaeb2c08e0b3377f60817c9c7c18b2730a6844fddf511c533539cf385e9cc94ad5692532a0f39dea739ebbbde05a88267853c9f191acade8f0e29ae914e954d05133cddd13b497e4e00666b9be909fd51d644c50fba67b64b0cda4481b1f7535582c6d236d2b4234b329564197b39fd4f061e9341f13611075fd720dc0d0c9bf74f8983d74f5b7b8298901f0c2acde6470230ed731794d1d6e2f887536e5a418a5a2dd5c0699bee4f089b5799b1a907177870a8fe8f62364437e7b8b388d1b5cf3c052327b808635af7e0290cda0e0640dacc569cc61fe87472921e49e62549ee8f97398451b40cc6931fc95413b024024b67c5bc3aaec387e401182f00e963799cfd725f8b8148a0f3e2f7635c5136e50283ec6e5cdca0790cef8312496590a6b504d11ae1f8023102358ab35a5efa113c535a5757da2b68dd3663d428b82c799e1c62aa94da192defa500af0174c7499cc5479ee452826201652da4226c3ecc131a86e27635c4a8359f6751686c7a9c40f846fa686ac888dac418be7ea38ee8da64634d4d6ceedc0a9dc182935f896bdae2f4efb0a885309f78107105d0a0774c9603370eadcc105e67041dbb846483925997b7e6dac0c55ca8d705d86d05504eed3f40bac2fe6e3f7750123ac1604496c9761e06333f25191c7225db4473f3c0b2a2a6f537e159f8b3c0ae23ec8bcfb92ece19c19c0b13c54b301e3379e1c49c2e2128d9baac119e4299017775387eb7d5c2f8a23022106da4e6fe9af7bdc90814d4943e2bc68300729fceb182e867b09dd83a62cfacf603c1d16d44210a2294f5142408e4d79102aa02929e13d6c32283b1554f89c635262219cd6e9c3d9f8cf0277808180b9b533a5ec1976aa04c28d8796350f70b158d1b25b9942cdf1e599ec20521e7394d7462ed891554af1c6379e50dc14a6650dcf50f26b6b5aef5780a3fdd0c5890c200f19f8088569afe7a8edfec39458dea4aa082f1eb0fa0c8e8d136d87a00c38a780fe35959f3b83260a343304d2051d3bb946141a8014d79ca188b4ab2c34dcddad687003ecf0291a78d92f389002500e0dc7d8276b23ae121516109a85e4854f35c489728cd0f76ee4221312850ee43f48e3aa2d9651821658a0b5cd1f90b82b853245236964fe7d0aea54416639ecbe4dd63d0f548a3d254d9479cde10cd2e5555a42be6e57389bb547354fba762209d24340c4df4a1ff9fb5a8efad302886f9e1d54d56fb88215c5adcd9ba43c4e52950776fa8392f0650b209dd488d6a766cb76e10bb1c46ef3c6388e9f67bce70a241160b5f7ccb231787702ba46916b44819c43fed721f84add1ec32ce72101d936c3b6549091d5736022e320627b9076c3f3cf21b0ec2cd330a43ec4e3cdba739ab343d70a861316fdb48bb36c44a9c9a2f2c0079ab149e2696615aa5b3da8f0f8d23cb23a35f8c09333a5e551b1f81e638e6d5c5e45fd8f378f678b361f3c0ab983637412156080d8a509bc0128063759cf00c9149148e8c55169aae5140406a7c8815f94a572fc09afcc2024a3cc89531fdda2bff82cd18a1ef7563a7105b4b9c414de1c3b570e29afef2f6cbe9caa7d3783a24ee4d3854de10255e1b0bcb20bb4dd9a4b37fb4a09f6161ddb83a767734db4200dc6ae655379c18dcc65eafb25c033e2cbcd9a0850973c94dcc8722ad2037dbc18f4667684fee38862fc64ccc9cb131895b7d752ba4af03a3f0183b226e1a79a0a1e003046dd25293603ba6c1d0d6a8f314c10252bf086d1029b00a0ce3dc4ac06ae1d7868dc9a347c08ae2dd06a38ea0871999c4147fc90dd2f2432e757108e5dc714afed72674e80452006fa08703366a6ba482fd0eb218f32c137d856abe57349c1ef491d94180a86f22aad9729e2e272b668a0d1de13dc69b84c0d85766ca72ce53293fa669de70dadab0016d74a0dd241ab7543ca5a4275b2b67ca698c3549b764eaf39ceadf2993bfaec088a72f6b8be4d9f1f638608429410e4a68c8e3f0820bf4b2e9e6b7637ce187dbe2b0bf1c3fde18703a2fd5b9769e121b78845b60352da81335b8b62d2fa08fe0559507834ac3d2daef0f391c763aef3c8733ea196932cf69302898380a5a71147bda04e8e3dc3f22e1acde43d59a6b694e07aab3381554e1a4d101aeeb06b1fd0aa3ff79682b8594da8926f641774255ce83ce70892d935ef756a7f7a6e8abcae655234d5f40759748d8a4ec0fe9ce249d0cacab8873fd5f47526cc3007d74e228900da9a3db537df6be7e9ed43a222a322fc3c01aae368315670d02575ce31e67c2814a78bc2f23cb0fd23847df18228887731fd87e60fe4ff613fe3b739c81f0c038421636da05c2c587ab9e8498ea0f23199d0dc80ef5aea93a09aa3b1406b4ab91645f9efb0d92d654a69efbd77f102fa020203eeae98efffffffffbf71d04c729e51f6a8eff399f607d3000352a67b3aa1d861ba4d40127674c520ea8c565462544baace74c0b097a2d4d94fe96c34bf61078c4a5b0d7070839af8a889bf3b37ba3ba6b8139954baec9631a8b9e069d28d69e85397d2ca81e93511eeddddc914772a97cc5c4d3367f3f60df793dbabd56f45cac495ced991ce6fc701c12631c988891f3ca8538e2fe7a848893afdc50ea56568d7a62900c8a58b64b642133f4b44c0184271e3acecc847274689190f254e017baa0566d9ffc74a8f71db3c28912fb5838b63d9e42136b0ecff639fd4ce5a004d6825faffffff1feda4b8f387e848a9e5c8d8206849157762259fd379f31bbe40e60310026e044489ec06a61e9bdd16c3dc0cd22cd2146b9a79ef8352622c935ec52bab1c4d784556d21030e8460513002b024427df92c4278485eb5ec0870d5e1481dd32fed55737a24b7127efc635b2e3b78c97eaffff7783351d4c895a849ab4d430710e881275cbdeeeeeaeb16c9f287302a02ccaa47148ac3fa2870604fdff7fe14bfff6be2f4cba74d4b2a4d4f286c911e8580ab1a6182195152fe7523270656ded18335a72775fb13bed34d628197599bd28b9988a36cc19248840756dc198c9b9925ad43cf9777747a14c71e792e982a2f9ee5c727ab5a61f3520a8af43567fb77575770fa6b87348cc8d1ddddd3d77777777cb8ea38a3b717777e75aebb8bb8b4929b79bc34bfb28b495edf6eeee7e740314477cc8a08133a427e74036983782542121f950196b4b5993e8baa3eeb5d6866242256152955b76902c5fb8fb828cfffbdddd7d9a29ee7c773ddf2f170390fdff7fdbd586114a98efa17577abad4d65616966c4590214a48743d114cf86d1d20b4d31f0fb3871836f3adce01a0157195a98f2e485ea7f892713e7f0ff282654f5bf2561f2ffffdfcb067cbcbb3b02b7bbbb71ad79b6b85a9abbbbbb1f9729ee64bac7e6bbebb9367c7d41c6ffff8f45ebeeee01dceeee8601ab89e2b69a73c3f0a918511d614b18930349540d1939ff600ae97b2146a66796f3240fb927635689a8f1419484836b435802ff36dc3f71ffe40312355249260f1ca0dcbf4718b033a2241f37ac7260a84818bbbbff8e29ee4426954ba6cbafe9a2e2c52bfbff64cbd34708fdffcb60b68c662bbdddcf332565bb6a55a71d2d66d96759c7adc730718b96deffff594715777ed0452ea4f27d5f5dbbbbfb2aa488103121665dba2e5ed74d83f8ff7f12437ebaaa9c6fb84a965524cbf6598c417677372d33316ed4d1468d964226ccf0d7fe1763286164fc30cfd62e355b157f427f001dabdedded62b963ec021523c5996e198595a2e442ea045059ce146a03484f05627383ba40922aeec4eb5807a5e44cc3c893e8356082183ab8d5250849041b85c04e58b64be9214e0178fc2cc9e193340219d6c0c4f343c86b1ea30a08f2a11e431302e083df700631aed265fac1d488566b7176088ef0783a53415334966ba62119ca143e9ea06ee4ba86db294ed420440fffafc2fdafa13e14d751dcdd7dee5984e2e1bafb5c87a1e894442dea289297358208f877f932dfe6cbfbb27be9bdf87cb4eeb550ac5da1d950d7aa4c194171a6ffe7387339c80f7ec31ab8482008027713d66f9825e9c54a7777fb09cee75c6335f1cdb4698e066663777707a2a92c9bffbf5b5c4332ec61ad351e8d4863d2a8342e8d4c63d385192521cbc70db099b3a421051b4b70aabe9aa46cd0c839e79c7316f14b71273038241e5d4420fd02a01a136eb96a5f3814128547215298142a85cbbfe0ffff4d281d55dc8979e9554b529036ab06d08b2148466cd8f8caf98e6395f28b098b8c68068bce61053ba687d6dd5d432fe3ee203f6b7777ffc95032819b08561d3c1d37533d29cb368e16343942c818e9ca3d54510fcd13158d8f1fc65f8d28fd37aad899a8b4047ffd32cfc322bc0daaa8eaff7f0eb1767398b50ba5535145481571962df2202296d6ba70c5eaa1b5027a2cddeeee5fcd1477bebb5e0bd377de8cc3a587533854712726aa7d77f7016e7777e35a139d74f7e7dcd2b09b555d59636b462740939cb2e9de27ae52dc19041769c5547227cc6eb99e8e05046e72f657749c017919ec9dfe61688717bead2b8bf54b712730e801d6d01d886a6de487195e3c33ca9a179c720ec3116308e110198c3eba1b28aa41df1b4d9aa5b8538779ed8d8a5bb57363e9ffffefeeee9526f4851848cc882c1dc9b2582053c690a3cb4a0aaac7d00ae3d5620e95ed9fc1217677b7e265ab9b9cddaf6c61292e90f8b6adbfee593c417c9f65b377eddff662a59d445e5a5355ddddc19029ee4c66174ca9f22160c8a70a496a0c7d642f5e24b9e1222bc9728910520fa572643a82c52915577019f26b35b5c67234f1b213830ce76d8e1db9f9f9729291c56348e8e1cf93082de7b21ec7b26009181e61093233702d0ddd24773bce6a57316dcea792a29e2223a01ac62579a7b35932e9bc30a77e2ca12005c879a77382167d246bde0f96ffff9f83f7ffffff23bd2aeec4415c2b2e196bb5ffef14ec97e24e6070d8024674a79e93af96fe3f567a243b55c46bc2b464627607ad60b1adbb314d77777777f7d38b99db8de359f607e8850c6b8759a329c251c58ccd2e2c0a052a15a6b33e8530fece434cf772ce39e73c944c71a772c9cc0d35df5d8e458f7882547357c8d3b8b334e15da2a3c5115e98cdce8eeb08a8b4faca398a747dc54959735b4a0ace1946a41a5c37825b787aa7d6cf830b2487618a3b9144dcb6367f1ead88b3da40608a3b8339e030abe0ef6e777777d5f6c3c431a2ffffa7756817e04ec8d48aaaab2221164f1b609070e96618f9e1142514dc004c495181eef95465e641faf3935b785055a4cd565da2195f116933b575a7f230a0a503ab55c3a30002fcd13d8b237447dcefb8a826e9b29bc46bbbbb1bb36c77779fc0d8a9ab586f0aa6db305f3a648001341dbae7938e643afc53f5f6ffff5760b469faffaf94e2ce5c9211b701fc8cbcb22e98248c15982f4b4246239827501d430e4d37fcffff599645a6b5b35d6b422819b0f1abffffdfe2ef34a7c837b720776d0d26c262d2ec022ffc9c1f98d282ced592cac968d54281a8a215535838491e50d979ee0a08092ba32a11c3990f50023f3bbaa6926c0d25e5c02939edd3146ef6577cb6283495c9d0085fe085081d70dab5637a68ba1f9a449d0625a8a43155dc899dd2dd0107d0d29d7b3af9a43b340b68400541ad2341554077775f497f76723f3fddb6b6ff67571b974dc7dd9d4830e7474fe8416263e34af7e4c3021ebf2a182e6a905b2c1d1ca538f23798379a385eacf42bcd11db42a6541ed112b5264a548f56c4ee5892437b7284d145a403107777771721a050530a8f9400847e13f80d3f21c914f9a19e957346be74f9ae0be0e9378ca5441160c1247623ae2a09a214771e29ad2e248cb7afd5e7c8067cbcd9649be6348d1ae69628628b6b5d2c2289dfdd8d6daa920082eeac6aa4a4251dd79d9577c3c0a8e90b030f286a76c0c7da8a6e51cdd0538466e9d73382560b289dcd970d8e168b04a4b1089e5c4a9c6d2d3d449af04d3fbdea757087def508485451f9ff27bae71398d2fd27fe0d7b2d8bb4a50e9a04ffffff27dc55a05e8a3b7d3f603007347410197777ffffbf4dedf971dd8f378fae4cd47f6cc41db1472b62059274b73e877e554c1a610f191f2b843882c79220b2a4520be9fe2d019bd56d555296756bb9c5dc6a72bd7dd3315320285a42064c81a916b0465ba63c30850342976f0833337e2a94526646ac64083bd3faa2429ac81a4a1da7867b77b77227c59d3f44474a1e288d0e22e3ffffc7721baf506202a50ebfbbbb8f39b36c7737aeb5d19f4f382bd9ac79f6b6351a3cf0c2ea312426e9050aa64f72c8346635f405c4063c8f8c1dbb90bc84d480ca7989af1c234afcbc5a572cce258e939b0b3c2850f82021516c01020ba7a0970b25554b39ff2154320000e79ab3490fabb65e1d402c21a5d0dcdb0dbe1c230dc521494f5c3d0ab46648a1d42196c4c62a7bbd5e3baf9e97cfdddd8f9806118d231a4aad8d470ac7c955dbf690ca14639a81e9c078fee86eb9826dddadc6286bddddf9a94710b77bc5ddddbbbbfba4c46d5dbde626c59d3bf8a7756b88546e1d6a50947ead547127fe9221131693f4f2cc60667a8cf1f4989951a5b3f260212c1cc8785d5f77393fb1458fa11d0d27235c0e121f1a3bbd15403419c633e13a7fbc4de63b336ecf5aba778c77776b1dddbd6608516c5557aa658a3b992e55338eaaa8448c1f08a704c30ce31904184183401c89f340713b14000716b480bc78403c343834160544a260000c0a0380600000000000c060d020001013c72262de36c65f0adf84ce4108bf23c23969010948c6cd688efaa392a4e67d32b50114605e54632afa8a8c2291954792289457a422bd7ec20e33b7b32b609e85e1e561e355b4ad008678ecb6b85196ba9cf570ce10da399108b378b2a21f2e4e7d31d2a4afc3707451da5adda2b38469da940dcc01e2f9ae0ac2a0c5e9e9d2851e743fb143517a1b52a4a6c181ca19affe05e22d6203fc7507ee2e333c1d2282f09c29c20a5365c9e841e9789e2fdbe0e0e46d9a20188d695773d8ed25bb083a44a22b8fab9696cb220e53a3d77980f85f73026c41c3c1d1af9e840928870ba8a062524a22d3c546999ab5769346880f427bbde109a9ccfec4c072e7d6e34ccbeec3801f3322d75e3e72dd378edca28b7ab15060afb9af31344673e14ea5fa6337306b716c9db9e2217080966996ff59fe143be3d2d53afcc709bef81e85bb3f3b2f5350a9b192f4a79e0da0c1a39059582eebc74531c2dafd58f6f4c710d34f480cd3b71f7b00f03c803da8cd2bc1596c1025fa600c8f17aa327414639a1fd3065c9621874e5aee44242c7a71ad10c03bf6d2fecd0c8d67f740b87c8a9340bcc52f32ff3ea6589505dab66d118c2e999b8e4187856ac61c021debc4c7f9794009928ad765bcb88cd7afa331177d85c8e19cad85148ae83c8e5121cfbe94e322dd5a729148ab708a9a59034f241c9ab44ef14f1b9e0197ce68233f73ce541b456b58c9a20c184b54ec01a6bb4db6919485a440624b7c91f7f81d61266a454adc2a381688c6442291cf445275eaf23718f3fcc1759d94f6b1e6c751ad527e7d966ce35cc44fb63ec27b67ab1f8e6157713751e9f3d63a4aa363816dc9d5389fba4fa5d04ef2c58011b2f9a6677a1fb39f149397c851c8f06c6f93873a09f96eac9e101461a171e7de8744e3baf7c4335e7bafa1dd69545a7f6a4bd9bffcca185b1222912470fb29a380685c158db5d871c7bf6ea50215810a1097aa12700b1dc0c856d3a119c00e675dfa752d95015b279b5da5183bcbbb752970979ead8c764a8fd1b61f6f057a7da6d8e644de90fc7eb51224a13872645319f5ac7fb3a8566c5b0ee272e83677722b2d614b6dee72106f20d3684104e2b43c35c6c269a551e35a6e3fb0b4747bd830f9c41a05e8a112fefbb14140425386e7f2945892c337baf4e21b85f2de431ce6b86445af57d867038b01c23c96918e9f269721c04c99c1df619fac5dcb27b345a954ca645fa68db6cc6801476f72dfb48b0d711ea631394c6cd10c01a653c8d3aee69e76f13f9799aadcd4ca6660710867326d859ffa72e2ab31257f51b94664f48c6d1dffc1f91f9bdcc97c05d9d929adb5382bb6177f1897e864c67aa224fec78072d30c1b40398fca18e130a77c225fb9f2cc275d1029e489127e98609ecf5d89d21e0005698ca23493b741b4ea9e2fe67374f29fc52672f1486006ef5b802edc669718d6d2bd84483617a8da1b21cac337213264083dc2614e694946525d979b2a4e129d96c3b5ada85f22a74b0f26e708273fe3758448d5f1fe86bd628e1d49c59606d8cbcc6214005f4163d8c52cd9436fcf3aba4b492e706885cbca11173256cb91535cb5f3dc9196270323ecdd374dc9d7f6f643270a616893547539887f64399dffdb86da1c2b0a6c377d2a38e2cf0e004f6852531ad84e2b476840e5da958c62b937e3e2372bc93aae341d7a0609fbd2c248f70332319bb7748814b12942f739a1b0110266501b9a6520014ce3e2a6e985ece70ced8d238b15045a9888adb539a5bf11c20b4cb457bbc52fd96c411f9552803b38a0ca656927e9c0deb1faca2805e84661e8c08974c898f628fab2682a43bc4e60311a2e9869818da1f2ab3124950c740bfd2d655b287572b093ed4f71f0abd606e4f121fd100245f06b486d59f8f0ea260ce73ed309538dbaa5e5c8ef0533e357099b6e3793161353448cec25e93fb5b118b5b335470097de97e22a2fb925f6536c3944accb9ef07ec724aebca44dd0ba4234b7b87078ffcbd92a9ba72ee91dd1c9344229ab779ac28f35a7dc54264b0e86ce687628c8069b1d73f44845c20923f5d04520004bc688433119d3a38a2cfa63d1e2c2cf36aacda6af5f135fe96deb5e8d36ac39540a038232f5c6313ae9b3204ac689cad02c5307474f3bc0fcf251caecced019bb2e3d19d4a671e3f78de678b485d3d5906e8d381be5dea5429df82d192b3ebacf57989cc6cbc208cf0b3707a555a98cb7ddf07c1ecdee716c92d53c2a9b37847ded42ba5474119531aa32cafcef5678250864997a87a56c5fea50c5d0bf84869b64aa19fb328150f33e214d868f72d0f8952ffce914676663de0c599114253cc9667a034e0a24bb47c58109edfe56493f09309515b2fbfe4d8e011535f4c46445441565601c905ca8c607b3417834d6eb6db1bc51f6ae8f6711a94f0d8c244200682c9a6a1e6a2cdada456d96e0dcca839b05248906653d2024ce92c31d660f077427b7ee8fa2b8e7a39d18d532b51f303e943b7fe18dbb80791b0f7721c57573c74c147811ae5dd3b1c8a691e4172378d69622e1d9e4b1711ccc09f5c4d4108e82e2ffb44ef43541f87e7170bebb4c1f3fd4cea1729a985b484cf06a793cfda63c11dc908c882dc1ab39f5bdd8b8d6bc38f1b96686495f783dd434c0b86feb24a43291da73ab1ea5ba8ce399da2bd72361fb0ddfbe84244b727fa80df900acf9dcbff95a999629340e2ecc2a03b3bd2df58bc9bd5f625bec04d4280fa08c97add25e88c2b5a2bb8da04f8de55259c7a7f9b449fc041514dd842b3c58d6655f321875baa7a36270d8f068121db97d96b9684021e3af15c68fc0fc653aa92a12dbca26945b19befeda8710cfcd7c25061c67217b15a2b5088a243f8ad161a22fea2ea0388740be30a88d581311dde2ed14d51fcbd0b7ba6aad0d300d4d3c321a43c8356864575bc9b4d3c1d6d9e2dec4458e214eb9001124b059c5446257705b84513332ede29520d1571de7638d447fe06487157aa47dda1ff23d20b2c78192478f42c5667eac93f6870d796dc3f8637238a9c5b74b321f107c0f9141e5dc2fdfa46ae5ee7e611ddcef5fce586fdfa8a12b9b3000ea93642a714d82dc1f88f0ed3af27bd924492fa82b25e5aac7a32ca560b20786615a8212d05ba5a2070771cde9020d3c3785d69234345eb391cae486483033c8367dae1bc2ab73b9a5792874dda0ca5a9d7ef6362420e95f4e859748cb694760cb1a135ad4efb799691e5f58e5d6ddb9861f992c901c45da70d510953674412b1db1604b74cd19387058534741c316f949b9fa45f329c8aac22409349264f6f3f0f536a3aeda1f8a62c162e0b449448a3a9c80406cf654bb15253e9d2fa00ec5288a38322d8c8e4536f7f8fccd45cac285fd6043f853754be3b16386b8342b185c876b4773044b42883ee08a96a5f24b94b25091a7709bcb9381086c832dd6b5b3280a808f39d50d4d44d16ce7960a618a0800ff5420803ca40b47bb51ba91b7a35666104b6faaddf2703500e5c3dafbad5b37f5a8a282b9364e121dc757f0ea28177da1c0a3708abed9fe0aab081b0f49959d2b79a0efd090a66e8c06998117f60f87daf34d16650a1c6355812d227beb3497eaa2a8c9741ea4612a2596cfb6003c985668634bfb73959286140d9464cfdac783e9d06f4f2d94d84f1c810dbc59a7d799081b77e0201be02c50d73d87d1443256e405cbb91a8b12ffa1375a03bd1b7320ca4756d9c1dfed19299a0b212b73332e9e270528edd327e800d9c93f33977bb664de36e0f0114df8fcded4709bc17031aa3aa41e19ddbf1c1c1523b894e9591605d2ab54e04c351d4a8fc62ea83914d19e5b48bc678fa092366f87e50aad45591ef386fe12f58358ef61283fec2133c95ccc56d9c1890156faf2e614baa89c7c6cfd20ef5777594ea263a6059c31567805ebbfd0fbd8c33597b744dbb48ae73cbfd0dac9200c1dfb0e60f59f91494123f908ae25026e1715fa171daf26d9eb2d1a7443862e0220322a1822eaa328a81283be14fcacf7358ee5e58151d07fa9b05803140cfabfa4176716f0a7bc3c4776678d1cacd3f01e2c49ad2cb9b59ff2cd5b74b2e618d08a6d42c8ea09399ca18eb31bf08c194abfcb27084ba708f989b7542d848daf1dbdaa37798c5dbb5056605b568083ddc7c195e4f4f9f456937bbf916acea6ffea3898c990a0ecbf74994f8095dacca96453551bb121e1b7e4d356a1cc21818f5ef808192bb50c13446a68720d724b04c436f48be22f1929f2a691132515e6da8a39f657982541b727c796f9435a10e21cb2ec6d73a985e7ee8e8b11a7ff00f601f44a221e99414accfda3e222276223eaf491000987c786d2e43afd9b3779399cca25a2b92749c2c2e27f8d68b2cd1654134757a588eb1444f852336bfc800971be1d243d68b30a844889a24f6039afad67cfd8fb4b7c25585ee5961d96dd4e9409871820677ac2d47d4595437b3d8a4b2c47a99014e7237e6f1732891dd48552de7c4285c9069cb34b639bf49f6e2aa5745b190bd61b8cc7ff9b5b6cbf0976ab4f7dc9365530b1ce34224e6f0d424b399897cd6fab17c7b997b3ec17d055cad043296dddc30cf16e880e6e68e76572df8bb3ef665817394bacb504b2263a214ec725afa9003ae51daa69e220399d72240098278ef7af4cdd43e2354fe600dbcb9d087d78316c4c6b1c0dededcd2d25f6a7e78640b0fc82e72a26ae8f015ccde9bb36b69c4c4a84d7dd9665e3b331f77bdeac6082920443678964f6ff2ce13524031e04be3a47ce529b5b2adf0a1c6002ad57f7b799325c4132c493014a0593f6c022a83e9b7d968b17714a59c5c573685439e9858014ca09fd809b21bc15ac59aabad8ce8ded53ae68d6ac47e262bbfdb71ecd77db9ea15f87f7ee5be9a7998a907bc1b2d3331237678a9f8090fd72622ab9695664d9591e240f3eae9ca9dec5bbf839980613b143f26935b711b8ffe55302d75dad717d633ebada82ae1890f682839805b83cf6481bcdd02f593194253db4bd37b43ca44e9b256b6e3d0cbc5d03a7565b0af3306aa3528973cdfdac770786340beb08fd01cb1b719adf4d8e9260fbaf70761da1419861a03bf81a2941c406469225b9944aba216762647e976f40a7621eaa13d8951eb43d3e6301ce04e63093f9c0d6b3f9dd5fa2de79447d5ebb4eabd217dce621d41e27671061000b6693c8d26663cdecc285c293de26e57d102016188d5a82610e3c8cf37b3074228482e84a489555ff60d834fc465e0808c4dd4aca02326d29cfb72a33743e378c15ba89a806c4795dda37a57cfd86129c498f1f57dd2fd0f17dfa98c1a84ac3436f9363e61b6bf445da8360a5103a105850093e221db62bb6fe5e78a9c48855a64a0c5ceeaebf6c7c1df4afed5a7f31ad481495917c3c3c7b82b685b1ee46e92159abea1030dcadea96b45b565ba20e4f85d93a82297b9e6829528ac220c2614204e08991a9141220d42a9602640602fe0d4062d5a79328dca4c4991a84723b74d38eef58f09cedc82e7bb2a00fc66ee7668a9d1898022c361ebe7de6faa09dc66ee7d0352c84fa26abcbf57ae4a0a0c3b665e6c363b5444f0bc2825728899be1d99bac8742881fc8cbc1d2d49fd05b423332cc1ef092250a6292a8ae439e25b7aaf91094f6d28129523ec6e6e8069359279d528ddd67a75cc485ba2e81e327e851e745c64297802f7864735b3c5a6fd423939b48ca7a10280b726eeaf2e3fa8ff343618253f86e56c896efbefc65daef050466a619f4c306cefbb4a0f636a4957fd761ec51999f8b2b927548103dab890257d0506b318cb4b199bb724f75c0860da1414c0c17e0b0c57bac3b8ff727452927c631b9dc9be8148701992d57f9ae28d92d5d162586c35c71897d5965623b1e8ca72118a5593b70fb50d4749f606242d044ebbd2080a9c4f4d0269110b48fdff5a1a5ac8b2f3d1c10ab47907f726b5aadea8cf53d1855f4954c1c94917649b346a6197cb12511d9520c852b065409fc507ffa49f818b6cc112d2299fe1cdda03706bc9dd2ce6c8dde7ed3348b1fe2935e0e5087f82ac6ca450461d64d1c4d14928da38d6052b3e38d6b298ab95daca2754548197485ace21b41554a3868c6823495c5568d97e8b1ffeb10b85265cab250fb1a5c66d52db4f1bbc748c019d56436cc4af9f6cbd6544b2e2ff379e59223e2a16df18fa09796431238838575541ee828db07fa24ae4ce430e674200817dac1e4841d5f40ccaeea845d461a21a6a182b2afa57c554773c2aadb9a044ef49b442d7c543978158f2dc58a8797156d264b56969438abac2fe45d0af457caed5a4492c02d34b307058c26b74d3e58ae50eac1db9bd6cd925c9d4e04b94a29f1428cbe496b8300e682d832132c482c4a397dcbc83dfcc2afb0e54ba9ebe96f9436bb5c2080722f6f9936b3fe9f40a1e90f20c28baa3db6b3f5f80d046ac7b1851e29a56911e448b5b43f6f221ae91a29eb3934eb6c94489b4d3f48a0d3b5727210be78a6cdf79f1981ad49d039bd16a4a43be7568ac8404ab52a17b5526dc881d2e4fbd30275d4e64ffdd806f577c094e348936364b3e220cc1835d0f07d3b75a5dd1d2dd1909252c03537bd0a08109cf774b2c4c704a649a27c5f388d19058a382b20684c5e3a57c0b1f4b7c7de83989dbcec2a7e53675d228c538fb315108bdb325191614a423a7c45bddc546d0cc038b08044f4da2847e78be50f076110c4803be7476f3193dd0d5699c556df4c77cac42d1275c4677d3a602d9a0b26a7e0e008c492f2c7b6922cf1866524f34fed198823e1a6021bd9da47b59d4411ad6294c28c55d2518872cd5924bdf44e03f448fb12a555a75a583f12235a65d054918e57a0cb032f32670833b9f0bc0542191ed3d930aa27fc793b04cc0f9a20001e078280fb3268cad3e49d2884b8b18bdf193ab3b8d71a779d20e57d6c3d8a1c148a9f794852f58393b4f15a9289f6f6520c3af08b64f6702493778f78ff2d5894ce47a212ee32f4aa233d6398d8211df5f17eea41112f3c91a5d43a4b45d670d0e8901a67dcaafc752b781c3fd28446e41d1afa8d8766190a12205315feb206f192cf224522164d4045ab3286140a88dcde1cf331340d514f974c8b3ad6646674c1940d69e55a2f4a95682dac6b7757990b12267c65b16422866d6b7f4a3c79969aa27a46acb23a0a004c77664ed42d23cdc23eeb625fdef5bd1d1e51971834e08510988a107709cec518dba65df556448f9886992ec1330c8b983782e16cf137a6abcf7aa95b1af69284d36cfdd7fdd0131b95a346134caed10f5536e893fce158c7ce36221d78381450efb2e9945e6e20f98e443f1403591229652f3c0be1841ccf1969f541b1f9308b0f18be78fd7d0bcc21c9d68e39ec2bf20cacb810c3ff6a3b87aa3f74c69b1ec35d94212f88af850032e0521a7880951f0d6d030ece50b6e0e30e8abebdaa731a52d651ce764e57bfbbab558a5ee9c0042ad870e4d989536675f6648232c7f310e1c5f6fd4bc78e86e9ad6525342b49a63cf92510f8bad656d968fd55f6e20a34aa244830c24b9f26e6357c5a713a8655dade250826624c24134a061cf46e9a7fb20a4914c96d45d20031183a5a24d40401b2d4f0c482d3746a004b8cb6bcff12ee882e0bc684151f81fb6a9286de66b500b3738c1f3b4262b24f8fd44e3718cb16845a5485bfe2f5dadab79483a2210320c6756dfe5f7db7142d2c5a4922125300aa5aff4398a565851526ab76a9ffaf11ed5f23a17abed18b69317a75acd8531ae1ddfe5e5f84d1bc85f4bbf3a888ec8a40d2a96138be4a9c12585d5857af399a849ec1bb41aafc40115d0e2c21ec0397f19f7c23d0de664ad8d55ee697771c5ad59daed1775e8f9472ce0fd6e09d0da832c815c764177e6307daaed1b842ab502514f6f6f79de29f68bc252718f7482945b105c07bd0024643232b79fd5a0857f843f934dc96b2190427704eca50459e6f6f7fd0aff47529de2054ff0aea91e8f63a90620766157f09f24417cfff4b607439a4800aed506140a47d0857834c93b31fc1f8b4817a5a099fdf0b8194f414a14d65b4299512b976a5d26923566801a3b8dff4fc882b3b736fd7fca414b43ef8bd61e48ce15464248b344186097f4659883f2bddd5f07079e9c409528dced648a8f039ac6ec274044ba5938ba1d2b4fd0ea26b27a452bc498b54d99612cdd45d89e40f579c05926184e1731e770cd683019f0a1f5ac087a835e9145ba472da870dbd085bda9d5c3ebfb54d5ddb4c28ee206bd7fd914a4ba995adb588bbab4f89a44977d1978176898aea21e1e5743893d7426e8c3ce16bce902565d52298a4ef5a46dc13dcd514862fc23d1835b7782e063ee716276ce21728510d64db0879d39fcb1718aa61ac534131680d7150e4dbaab0b718a344c6a2feae2c44a0735b605ec24057c813c9f7e0173925be8d75f991a12ff0477a49c232155e55b9554a95f91cf1378db020615f4e8634e88411702d32e067a21085a3615bef012b415732ead6535c88d55ca808928565a94952baa94c5a6d24dc0017023169a6adba94752839ae4c3d37806e91d46858b39e584544cac81bd8c3b20291564ee663baf2c6742011aa164ce1502d166a1188b094eeb594efeaf4400e7acf6036a9c3a427d02d0633bf54c499988b62c559a8caf08fa487add2cda4e20360b9c18410f3527941584f58d9a63419e69bf800f8baba94ef050fc6c4dbe2172ffb63a0078467c9a99145f62c222c20251a4a5777c1372a88f9247ab5c98902b3d1a9ef81fcb335e6632502666e72eb978f02c3af3ce81a2b18d39e2309ed158b805309d4755093fcee0b8c85570429e91292a8c6ff53f852b2e1a88e2ead520c0562db926cf0a8af1daf894fd1a5a97152a964858cf3ac77588429c6a15ac0c0379fbdb10ce0791042f60eb3ac7463464adc0ea798620afd28446eccb1728e8e9f7663929b858825c1b5d339e70bd8b7e7d2255e3f50eaa7c53e1fba008ce92d0f07a44aee77df4aaca94c57904034898ffe7d6fd71ecce3f937e52f7e49f4eba5f31e139b9e95ffb794aed38c404041c4dcf91b4a3d4c22cb9a9c08a6ae845289838a8373b4bbfed5ae840333b11af43a21810ca1212a181ec6f677cd32454f2e29495cdae7a7a18d0d620741c3fda6470da2db8e0a0f966846890c887d2682d18fea79c2662924562572d13fa17111b184d441c40023d5a61c1a9a337674dfc9cc99dd351926424886e9448a97776416b5b333a7ccbf2d83018d97559e7b8841d2c6d87b6bc8f4a4e16baf63ddd9b57f1ac7366d92313c946b924fa257f5608712d13211025345dc4bed52b92297721bc43b4472e32b2ab32f165e4db2af9b5a251ba7a53a5991a2f09d46c9bba4fb223933f527170cfb0a92ef602cc5d2e2c3eac270df056e666d24cf4af46daeb889c0a5c608d0f18ff258da1c91e26d4604ee873647725c8846c2a32a22dcd6509a539340fc2c0897917daea024f1a7b94e7e56d24734200f2bf4a04210e87e335acae2be95191cc8572cf1554ef5b3dd4899068a62d500dd61efea5222176dd90314918e5e9b3c55245a2fcf22b86a7c78a9bf1e9a2dd4af2ee807b95849a4df479a24ddb629310c3ba5b03e33dd6bcd9367178ebd1bb4db15806c72822dcf26a758ec22716db0b3bb2ca0fe22fbcfab10ce1a5f62854ebb8ac80b481c5ef455665d8f9d36ac3a0d740ee46301da20e93b5e40d415710eea874f78e7ad68fac9d452f5e2954f2579d565c224757b398744852df443e6d110d0cc029ea0b9e28ee08aacbb7300861bdc1b2c7a084e719f8ebf56ec1590c75e85f1762bfdc1a784f9aedf9772d4424b4b9b843429659232cd03a4038703301e18213974606aa24fda4495ccbe7dc303cda6a5aed5450b56a75d7e372b73d7ff3cc5099083a6373bec6cdff466079d5d3f531070ab6d3daf60266fb5d6daf0ba53ebdeb6e7ef78dfb3f747dedbaf2c6fbc633d3de4fd47521b3b02a980ff997cc80f82c1fbef3f32e67bef290924dd07c93995877cc5658e04e5fc190fd1289e52552eb2a3ca7291fd7af2803292c46a27091d6a4e48f1247498d522f617b029cc06b66136347b009bc27e50c40e62840c6def58d5261881021d5512ad97c77d78c44374497dd479dfc862457647c9c50034da3edd5ecda637b3d4bebbac674ddd5c4163f243975566db7793c9b44112c06f7a4a8949507dfc74cb784a264195aca70a4644ed8384874c088003fde221fb250f590190345dd61b1e76766cdb3ac5b65f593eaa244b6150d8f8b6eff2e229f406bd9fcf43a0ea0faa15e34d6136556c016cfb153b07e2c03b3c85766f2bc91f4449d97a34e8df653d41218c5907b5a2961dc5840fbec77cdfbdbb945c64ff1b615c641f860ddaee92d6400d84a409e92d958fd45664bf237d85b92f2d2641dc874497f5b4a7d19a9f978c6ddf0352c01fe31c208efafef5e429281ebafe647e1f2f7883aeecc82363ba0d54e948900528296445f67d903cd25756e4ef3676e4bd7f0d2a3425712a6f807d4a02c1e07df71d19d3bd47c678ff3d259134e8b29e212bbaef8ddde83656e424a87e1983da2508fb5bd343fe2d5edb950461f205bcf163f2f33a79c86b13f484050f5dd2c117f07bc8ef3e055fc097e4569b6b19e41bcc1b50379c45003143b6261414d09a36258205356bdab617003141c90e9f233dc4a0053ca8a1074f2041da96b0a28a218800c2074a30418990a502d54340c1891aa488000421a448428b88145af0430f5654da0a5cecf071b16ddbb60140734d006183ad98618cb78fe270841244ae78425545137c0099b1c1e4b2c2662623c5dfebf1783ca7968ba8ebc541e064f3f65301c6288822d43815360f56564433c6d883b11267de68d5ac4464204316474c70ca6105240f0d37a0768064083f5675095b0b638c310e2213e48431c678cb2e30fed071e705c618e3fc6d6009530891e1053790c20f24ec0325b36248113d20e1094948b846b1f1f6c3a582c7e3e13c006080e7332562082adcecee15abcf732d13a78be8aae5d94cb83c1e8c31c630b66ddb368c5db8acc7052c2a7b59cf6703ccdc8006de440d1b5919691971197919b1f96e30dd2353a89d200a1d7ed0d0a262882c7aa8010722c87270667208638fc7e3319272115565969e31b16184e64364912bb0f8a10736b0c1ccc7cc0f178b860920e018a112f9f1c4e7c79192d5ff40d1160ee2854527f623a26b0f688aa5a11fd0d166041d8945a0a3005091d71aaf8ed657a61f92045c1d56474e0f16d04487355a0cc1155e6555c15e35365340829a616345c66345c6a3074d0274f42e0409b2f276c401998cd0b6c19808523ba2b77fb11244c623bcc2899c9520321e9ec7c20c1b2b321e2b321e3d689bd77d77c4dce7e95ef01c12a03550de054aa3922bf8eda8878b6a0d0e5019f6335986b607e80903727e21bb319d8e8050e88c1deb9c3faf7bb11244c6637371e538ab1d18d6a93aef0d4fcf233915f8791f09f2bcf76c402087ca0e17d16831506688238f1616cf7369a1857098603ac2e2a2f242efc70256ac48981ce892d22a0e74073a02422b1074a46b8dfab6f40d63fb9730462ac35f8f01a0227f7114a9c81f1cb7d1d2909365fe0ea6cab8c8bef7797e1836686f97748702f943ea0c7e9f67b50bcc72597054b01882214fc924109c55490d2fb11d98aeabb67bce765df79c07d3799c37e2defeb8c34345563b30ac5355c40955665be9e1229796971d98924b9118db1e41d552f278c0ffbc176eac323b20a93f8fcc5ccedb6f2a90ece396db1273ecb6e3dea4ebbae74a93ed755c0c6fe125b603e371b1091656351f80719c870331f799e34eee7307c391261fea3f25751ef046f5d5563712546fd0918915511a153f8ca37b073db11938c0e6604c27d4f69b0b242e24496d97d5a4d871e06d012c74bc1d7654cf7aeea02738d3dbdbf7d72d2fb697f5a4007ecfe182c5ef92c4b173ef8f41959c29c7719f3f9331f9393286fbee29a9e33209845a11f5907f1ea2c126805d44c273ef5ef73074ffbf1e86633d7935cdf04111267c4a1241500441176941402ff8e377b2acff3ddd9f1f819e746fc36350dbbf2c416d670dec4c52f006de6359671b843b8e04d5b726e9ef5df7792d3e088a1f2d82274272e8c0211886e1830f9231e087644cf8a218829d7f4e21323a72501a9a6ecf529b73fdbaa1942822b59aa1f4041501bd85a0663d52e6e9649a3e601c7a77a6794a9d4cb3fbbefbee3b750e8000906e57d2c71c3a5c849af5489927d4ac074bca3c15e1210435eb91324f2b6c6b7ac88eeac9457654535efebe7187f7e06156191953ca3c519d97927942b1f430cd9226d9b61e499947cc130f966c9a2754ce4169e8ed37ca3ac3b65f7e866c7fef33848afce3c4f64f14db3f4ed8eed58fa0a2ea4becea48d8d589ec3adef0eee723ad33d0519d51117e5a0db51bb6ad3b1b93a00894312812ac3626cbcac3b6755bf083434fa8571bfa10e8492541f8393293a05a7de4d1a36596a9b905d5e452627942b5edb7982c2d25160dbaff79f1f5c310fe878cf97cf89a8cf141e5438274e87f100c5f8f106208e94382ee973c25851fa349d0254115f87c8b87417f091953f2fa5b90313ea894bcfe9816ff794a12df148e2563758dd5c68aeca706d99692f448492d464a2a1929491c29291c2989823774d4d3934157b3ca783ae8ae7b35b1d05a3a7741834e024b673aa224ddfdd06d9bd74aeeeeeeeeef59f75198f2939b6e8aeefac517b9d7dd49bc97bb97e39ebbd7af1e89780479df7bc7151e2c2eb26efac96ba55a7a719a448bdb97e3a13af3907d9771999a64dbbfd74d5c124fe1dcf493a3aed33c14a2b532068a9f324b822de12957dd70d3511ba8045dbae94f6ba676b1a3cf8ff48fc417bb7cb14b5aab0088f421ddb4ae474fb9c855345d3f7fc97f4a48fdc918e4c0efddfcb893d9712bdc0a871d832ae29b84b7135f2463446de2e6b6af4391e36284bf859b9b3347d54a9e72d34f1dcaf34f91cc844eb6262bbae1e7069edf128ece8b3b08baa3cca89b75aa68306eeabe0c7a3a10bf871eba871f8af77d90ee6fdebdd7bbd7af18de3b965e4c3a550cef3d55abeb27d529574032b224fba5565959f659543c74aa56d786ab88ac134482a65b6ffc5bf7998ec4f0f16fe00dacdddcd774c3bffa8ae1bddffd3cef5e6fdbefeebdeed7fddd3da04a68a2c1fb37d4e1bdf7deebfe2b806f3f94ade82bad58a7ca5759b870685a3333ad56ab354333d36acdb46a6b8686a635a393a269cd9cb93543d36a61395516ebe53ca1baee844a9d4e6528a5f372d21b198aa04ca7132a554f1e429df5b4045dd6563dd900881dfca0d5f27af26aebabad56cb53504aa599560bc745d39a71c5aaa0c101411004c1107c4a0aebd775e1e84399118e3bba0e0ab3167ee17ea127f63f297459cf2f14bb4e0cbffa79b5db67fde2a7c5f0f3bc6e01db3e9731f881200886e017e2fc23045812172c0ab558088a20eb541531b14e954c66c1019e4764e788e73c552bcf8aa7947507a5a173f6bcef1b419e33c873c6610720409ce7c9d54e6705e0160c862a9333062dc63a55499842c84a65536bc5b8d61cd8abe6f5aa77acaf570dace6f5aa79392006ef6328e95dbf94b70beee11a988b7488a3ca0acc8baad2d054b3a55aa54e4fb56255138c4ab5c2b666eb2605aed513765951236d52a956ac0a501a3a5419f6437a92033db10f46a1cbaabaa15d5f1eb2a35ae32218ec5583040bf6aaa92d71ac2bafad11e41168d5b638c2dd8306acee8728cc705ce7deb97bddb6799d9b50667428977b55ee587ae9c66ad2c99776f7de7baf5f9ce3defb96ccd7bbe73aee7a5c576b0b5c0b5c0947e7c5b1b8251c9d1777107494191ce749424b1eb227cc8b87ec270854677bcb5eeb184c7224090a6c7cf8e87e48c1ecc60427581638fa0bc2089b0b6b02899bf211b2c11cdc98c2f043518b5ad4224e8e169f96eb07e2f1f3b2e658f2d162de56d4a118862533504248e6a6f0dcbf0ffc4012f47dff9d299aef539d3545056bdb2fa5542baf578d0d07280dfcb6be6a4d85d5978d163318012e876deb0cb685011559cfc50ec1ce35454fece3d1db0520a2cbfa4ae55c5f8f23dc9fcb97e3eec0a63b94b4cb8a2af9681104bfd71763dbf7ba959514e650c2948bd68d0a6a332c4e981484c89080628959f5b258edb04e95ea3c1d549da7ca59a7ca8432e3dccc991a0c1b7407de50f9b40befa9149a6e20e693c2071292da455eddb1a778320defbd155f4b6df8052feb5419f17cdb6ed739eb5499b6ce73f7dc3d8f7b00a541e9c9ad11aa3276786825546b5c00e731404f1090b376614590197a9eaa15e53e7fddde775ea6d7fbbecee34820dddbae84a3f3e2445c8133bb3b393159ccda584c96238bc564a1e7c570bf86975cf1508d5559cd89b96a33174d4e4c1673d5662e9a574e4c5653695c4456972b4cc55c3833170e4d4e4c466b2597986c76a662d5858a8142b315c9c892e88d49cb29823a732c269bddbc22821298f67d99e7c47ee398e76245ef62471555ab359409cadad3dad61dc15d47ba51772c6bccde7762b669b51b1f1c7a72cbeabad6dad87bdfbbdf7fa44782ea478be1573fafc6fc5ef7379199c462a080b1998b2627269b016006cf2f6a0795727777af31701f4329ef92de558b97d3e30e1e2a28335038a8140a07953abdaaf4585315b5bd5036a899eae25e3536af8a7ad9d4578d45d5c084d417ae3639baacaf173b12ed48244130bc488aa40c268a309128495b8f0371845b04750af444087ac2832ac3be165ffab4765754c9499bf27b13e83e7fcdf4f571359e5255545e605608d1503ba8540b1d13ac1e21c4902f08517c2d8ae2eb0f8cf8d11ffdd11f7d041cefa3c3afb434f9ee63b20cc9baa2fbc3ef6de08d5bcf151e3f25e8165fd2a2e4a3eb1d4d3ce42219a35fd4265a143519a33f1f518b221539a3cc7077cfd9f373ee99bbf7de7b7ddbb0b9362a17c0390059fede36ede2660697cbbdf7b5673286fbcc659af3dffc5c9739dd422ee1e8bcb80c58682db41613adc585ead0643c6459682da60c2d8e50a8d4ca1da972d0a1990100000008731800008240104561288df440a57d14800d6092584c2c3a1407839138200ca33088821808820088411886c1186094538e41aa66013808bb6cb50486bc5d451afaafc4f3197b4a7d9baec9e18e946fe2d87324a85c92ab76cb8372f12fd1ec2d9531717c25a5bffe32f048100fff0fbd3b0f832a30065159f0a62ccea993306226dd8410cc01a94a6985996bcb4274ec3824ec08929d3e2adc9cb790c409b309d69c0dce21a1764dd48558b74a0c45c2817ff93416386a21aa665f70c62d0ed2a274a326fd791065cf381dae5155920f11136bf48cc359fea6bd05c70f612c45b1267f792e6f5cfb0b79420cd06b8872ca4119513d93fa2c84a19b2ad0789f389526371403a7b906da721e9262685a149e045b0bc4ed43c59cbbeaf6e98cf1a39eb4cf2179c876ed0e881ede61f4632d648d4cce5c1ff3194809f2c9ced9f4e01e324f5558eefe60f93035629ccbab4c6f0ee4654fad231b62fc738488c99d2134733dc378e4801e9084afe827cef432c8cfaea38ee3df08eefdab2cf4e8e11764d9e3e14c6fe30744ee1a0edd601c5e94d13916b848a87ee81027e8d15c17626ba007d4b1fa9be8308c7adc2d832caf5d9a058e07cb36f4f7ec958893ae21fd37646c07aff19dc920677417e57e90ee72a6e5ebf3fb0a66355d96e9632a01ab2257eaed10e6737d186257a534d677884d15aa01364266b442219827e8d96eeae959ce56cb2ab0a32a47ba0ba67d6b4c5a7660ceb88e0ccb6842a9feb330cb1d531eb4cb4c87971250afef6ac4990b6f084a68ee1c7250caefb133ebae7f89c039dcdb4ea95e09b47c304e198b3dd91ce166e23bb4c2ebc8a70cf06a5f87c60361c485b1daa31fc8eaf0fe4d40e68c22f1c77400b156347b3bdb260ebdb05e76348b6cf10778703b67df8d476fae109a212b299a858620fe80bfd2ac7500cd19893043801214702b10e1d70dbe9c12875d37a8693aa53e9834e27e42b45c940b257426df1302b206aa71642cb381974dddfe952c0850869dec478dc274892fbbb37c760c12cb86b42b31532618a9715b2b88e30fedaf32667603e013d5f2882d9896fb3c76b14e84bf75a451ee9e954ec7b90a2d34bc68f6a382c95881a8b70d9ba98a6d024f491b5808a211ab543495b97ef8ca8c07d5644b06d70ad9a02671c952ae99ca3fe15be9d380133c60b398cf6b56a14de36e5785cb656f413f0a6a3091e6ebff08ed476b34e6c95a631e6137b2c9f0c9366464fa358213bc038649c8b281f814a2486601829306c03cdfbba43f9e488e2c23c64a6f4c16d02b2b8021c68bf43cf443806bec46716edcc2a8fe39c96363c0a8ce63dc05b04d6e13276e7e1aebd183a7da197864aa3d8697e5e1febd6a402d390b2cf23b3f24a55bca8363f25a325e2dfc73546cb6a8175b0643126d937e4b228acbdf3f4b14a78f7c2bb6ccaab63ded20f94e0bf5d569ef1d0fba44f778b470263166301aa8cd5d415159bab3125a4e623b4a6a30c0ec70e967120220d7af7db2dea750382d3f2fdbb105f6e6e80fbdfbcdfa79dccfcdb2e59e355eb825923528e7f8bdfd5f782b64bd7f701e14919346b4d16f2a6a4ef854b16d43937c2b1b40601261ff395e39900904bf327eceb028718553886c4d15708516bfe54f809a3759e48532d959dfcb9689170662366570dd61ed47b703d503f1795b46a729d3851a0280d07ba63b3a6e286ec71ea543d63c7c4c7448d13e2bd7f1f685ca71f6d93e7408130ae6a1f5dd3289b8e27cd0ea6c3c2b224df94f10c75bcd5c31cd6eecaf5605dc25cc5dae2b816c59f31afd9ad35ebc5071cac0bf3ef8d132d7669a728fdce03dedbcecd3eccbb675364a496a59bed5653b4716fdf8bcc241d1d88e831cfddde38c67690b5e329dadefd2f68f5ffb82deb4a5dd522e8e1a99efc47683bfab9d094331b2b8cd225a4c3bda523a0b8b26cedd646e32518340cf61a4140ba9ea3e2ffbe93f99a09b17b010295b22962a45a2369d1e9f2ec28e337ee187a22f9970065d064cd5409291911b7490e032782552061524aa74d6facd658648560ecbd05003ac70054846876c0d29829719adcb58a5018d4d83a7b052a1ef1cd5b65e057b5c264f12de4dcdd8c6456f09685399d45d62e5e8032b29f1e4ba703d2d41a0996ecaa0ee2eab26d9ce27756ce4192ccd6bc5778a134978b7bbb18ddd7868ff2ec90ec94021ec753b63a8803a03867d3682dc1f334af4529232b1cbcd7acb67cfde1aa22e21038f8a0350e860075f9cc4b3831fda454e30c1f3dc8aaeb6d058dbb7ab1168d5a2d5c1255dab346d8bbe2f7d8b7ef768243197e49e5aa29b8244cdbcffaa5de164509f8645f173a0fe2d2eda861c7389979c7d7c9565a00e12004be7a3aa8acb9e3eccf6d21bb7bcbce9827625e85c4ce094daf9a024e8b71fbba26021f78cfddf1d3b00f539bf321cb5302e44ebf894a9d179bc5205fdb3ad47b48e093b7a0637a1b0493b7acbcb24c673c8811fa3f688d0a9a42495032330637fdeb9cd0efadf111df63ba419f45ff83f57a429703cb42f43805a099c42318a64603eb6b311c996f03bceb8cf8e2430400365ec732927ef32fbe1f02059856a3dda403ca98c2438b6a834e012dc089bfc436b1cf801a4a071ff7bb3ddfea1ff8fe8d92842474da13013cbde67914ed09802a85941bd743488a1ff27f6a1d6adf20f204c018f5d66688fe4192cd9f49d57e34559cb984c04527e1a77e18c4d09d36542960e38e03b64fb3efe882f7c60d3cb892d5186b0951802f32664f7dc3960eb3f1493651d90840fcc8f03dc011f12d0438c85407c1b5a7ca4c63a61fa3d2c312facd0f61e6654085938bc63e5f1298ef9ba908db864dba87c69b319810b196ec640306ea1f412c826e4522bf21fe8662feea6f76ecef5e71ffb0987daf7a493a0a2af06bb0cd4a0c215c619c029d463251b4588291901e9c6f7a305af699d978bf8dc82c6ae4545790d5c4b22e27ea2b81a412dacbbf61b42710b40b47b64778c30f6c0655c00f22aaf9a638db63a08040aec986dcf73abd91c9fe59523d074a19b371e578191992eae42c8d56b18d4b296b65a27c3e7b381c45cbdfc7f726dbb09e1776e39480610e36a37588cee0789a83f86e9d10b7a545cab6e4b37a077b6044436f4af9b1a6ea9d17d00853aa91ffdc96b72f5ca12f970e98c5fc83e7d1497bb2d5efdaeef60b34ac955f106eab243fe72b50ae42e1726b20f1db43865f5c7d37398b12bfb45776bde19e9cfe82bd40b5da0e5024410d3a5435598dabb50ced13b3afa7f4135eb6889015e1bb4e4ba84223ea58a0645c05efdd2197481b9b3fadfc52c96ee0c3440d553247c336b38e127d353893b7ab5fc4f7576140d40e76a7a4d9edc4fa367b091ede985b06f6ba5c6c9779961222bcd897541b4a9816fef5fb7119f6b4805ecf14bc1080333c20b6c40fc642346cf9a087f8adabd135d090234d725ab8b07955bc6d5e9c778a6eb57423932f606e5a309ab939c52763c93c42b9404c7f962aa59061e3567835d84b5e8d2119e9ad52085816aa5f1be31a2ea292deda96ba03ee3a421de3658b76109d17ad0c7d4bdb91a06b3165af8c3b1edabc5d978f025b5282d8bceacce2b5d4ca671b8e2845ab7d4ce35410cd9b4306295b679ba9d18397361d0b8b8c8bc617f2825f1680023ad32e09266fa3fc1f422f9bc1ed017f930566f5f437df6e9223bff3e98012322f51e648327a1759b5110a51eef2f047f7d16131bfd593ef9d33ee0154099fc712dd57af102d6620adc9e83906d2104afe2481e34f2b5c54233765c15ce21c24dbc4bf1ba6905d00ff300eae54e8e87e3ef285d03b2332251789da164b95f0d489b687147792392a9b2524829ab06891d9e717b8d15a51e5bcfc9d0c07720f3eef10cd4c81ff69786fed93c8da0053ea2af9c5a01bec25d06d5e55b46f45aa5757bc29cd1a7ed68cd401f33e5d68699f73588a57997e07fde1b8ed7800380ae010aaa652cba2ae73a49b08a8b7b20ccec1a3a0008266dbdbca10627b2c7b7ab1ee6927f0913d562a8c29bc8f04697269b9558467011eb9934a49ad049f26d038fbdc1fe68098be12c535e1bb481fd9fedfef9abb601364a28da418f387b1158054f0c41b4022f3179118143d447e50d1124c537ea2346daf68c070a60abfcaa70a6919643f584e48bb919ad5e8cca90890148d1eaacacf74a39c10f3133bd9d5005f11838dd940c817172f061d40dbf42d11ba86014ea63752023be8ac0681416def4b96d3e29467bd9f9904ac4420fc8f990da9515239c64abb06f663882391b3b7534ca42d0cb834808a9bb6397c2c97f254985137b1ab74f478258b995667969a5729c11702941c0258250bf29e8e625995ca5bde6f68d12ee562b02f8fcae0538570c539d02e4e2f686d796d8599e9495cecfa63a16606d10779640efcc4ad4c6fe0db77e6acd46aaa3cce443b740e5dd361bdc43362c338551d9e2c138b0556bc33c1b54fc703851b2ce06567ad4f264dd3f0d65c81adfb2cf2c3892b84dcd524fdd55efc72d546a76cdf72f58a80bad6aa20098ec378816f7217b20ab21d99f10cd872e4a5193c8500cbc31aa31e15d87de6ea6052dcd55754ec5f025ea5368784f70f4277a8d656b1190a22e93ab3785f4d47c2447f9e087ac2711d74b3bf8a0dde6ef850d998e1212ea832f479066ebd4c68985fc47ce6ea001558961170efeb57aeab5c626a2af6ff8aef14c055630e581149c6f9d594dfbe912656887280219ba2d9f506edd1e294c14ef31a5aac38c296da62ada212c422e4df8871bff59c272cd7fd386e4034333629acf5ab3ba7715bf539646d60dae2fe0187f44b63b1c106226e50606202c0e23b06a81729b4315f52255fa416a8c7bf43a32eb8b71baa40e4baeb19cdf4e8e1a6f829469db604394b7c94fb2bffe71673c8bc70c3549503c38c21dd5824bc164dd008bcadb002b10989136399aeaf00c7b19612df05972a49e732799705e0020c0d23e167d404faa255808f5e48e984df71c98651150c36a426fc13a1f0a78d3d521b68f36591f6d79bea2353b85e604f2a53d554ca8a89b6c8d900987a34235678772647edfa6747e27b701f5aa2ba59495a5c9337961cf51336a295febd9c8b2fbf4155cbff8cc624b15f2c09b624acffca90c4b77304547f874ac68f97668491b7d8b53191c908481b8c89e29d6e4a2feee8c6c1966dc5d520989fc0b1a5323d14a8222b3bec3838cfac13b43f2af81e6d5f7fb4920400ed09b3acf065427c37c038cd7066674bfdc00bd6787528e6cd35fc9efe1cfeb02d902588d88ab00cd8c226330464e403e901c84f41e08e22f5f28e6ac20ca440916e29db851e8b4e8e213f7a5febdf2c5b92de78b3971efe2c9a410a4f12dd5e68470be86e44a9556a883975cbcb315a1eb83d6a95ab445788ab69fa0afc7d4c4c0391761a67abbb37f27ca6ec7865aec1a92631141552fb8cee2ad5903235335eb77048ebbeb911a88a737dae5446905ec0ebd906aaccafe6660c4056342b70dab921c0475c13020732c6483ba61261bd33bda7e504fb9edb7eaa865a90a3556fd3087f6cd45ae04777d606ed25259374040252d9bb08bfece6490fd511079b8f1f6c2106a99b42ca3855e15baf8f1ffbf782092660ff285d1f3732312b2d78c91d832f56f8ad689c34b5246c713c3f56180516c87bd4c0763a60e3f107e5524b139062f4b0d4fd3fcc2a2200d1acee297d3a5b6c499772b7e674b2569034c2335c0e2686537ca1967669a6afb2cbbe4c03413a45ccb30dcf59a21081cb10e724d317e29a3fdd6d8b8e9d39403ed11aecd06305413d90cc7746971d06cd4c1424468f2f9ffbbe1985730aa5bb2737e4d561c1d40eb5ae4268fdf3adc29b6a7e4d77faaac27a961117b7ae54ae2d68ca05cff74d0e96cc9ddf24ecaec1c870f6188d68d40e8f108ddf8979d27fc39de315344c90bda33426abb738510206db55460eb667849ff2e3f53bac6cb216639d43a20ddd0b0c452e0afdd74c36d371bdceb523a55d9e5e89552031e3e4ea39e22caf85b7d8cceb40b4e0ad67a643037a9cedf9b3734111e9a6e2640474abc237afbf7a04c9096b97a25d64b33b060f42ee055dc100dd6b94a2513d9ce79343d694a5103157e27945da4d69d14ade55f24a15037d8398b5c1d1558d4fbb8c6a44af7a76b1ebc9741ae0fd8f1fac955efcd152be5f2310ab9a6a10c6fc319bf536fd5679df850368f1bd45797faf69a62fa366d7b1cf8f21e6ebc5de3a658b53b051d6e5064dd9baa643b14cdd523ae1eb86765bb6269d27444f4d50569d8b7a2ff2e0712a472a39f621bd4f4c1963f027a458cafab424f23458b085f472cdeac4631d22ff0731ea272260262e00be11fc93caa1d352f3581878317c22e0d49ffcc1130375bb7e64801fcd12ca3b724a28e429e07886c77ad307d10a1f430d6ee23a9ab016391f96ea67afb6000f6d07dea4f2fe553b70d3c197dc5b54c61ace4486c699a5dcb4764a8612f43be0f9515fb10e7faba3370d4f583b8b35e2625c233d6a844dd970f99d935295770f502f40eead91610ac98aa74fea018f6b1e09e7e9077ef5803bb28bb0a414acd505ab21882821130a16a34911a26a1abeea1ad658d6afdb5a24f1894ca0045d032a99300fc1b070b343f64566ab189de55c7ea7b251cd6f702e8d206948a034d2a562b552514c415f76c8f042d2b4241d8a9b2f3adb9b28c8676c40dbcbde0217f0e9116c59a822cb790927e2630fc4659f8ef6d77a211032e453d1bdbaf5cdcd9f95e4afbe828b24d0d987ac3f476994d1edf4374edb02190f20cad9d7e6515d609529492d8d1dd2a990c4adff6599e1110c52bb3c39b0bc08a95cc34adfd3df813cf916b3a0873aa13845eb44732cd1f84b7a9147b02a0e7509e13372afb344586c85814bb9e43b183b9f5b2e1968fa287163cdc3494fb5abf5d4793038e56abe3c2e4420a78c707091c2b803dff234d9be6c5a5f8f00ce5f308f4ffd9264e8c9060ee502fbfb2ccb587df799cfce826e02afa19fc33e54956f20e97f6cfe9023e4af1446d96bec15f01d0790878a446d0115d47a41158f3828f1527f859412a13f75e1aff921b04b39df28bed54f67afc3dabf82631128ef703419e3952e4f494c8126987a707cf539381fbb130281aa3b12a156e8cb18dd050ec714d8d9965b1fc5eae0fd3d7b8c530cba2294ace3e967dc53172ab680e5591e91f50265945079040f3f353b279e28cd0b08d7c75d11965b35b575e54e345ebf900391c2dccaf4a457e2f1eb2a00c6b167ddfe6b1b8eaa6cdecb5287110a6c641ded1e94997a93368d1633d30d11258387639ee2d87cad72dba606938663fa68520679f677d17d882f6bc069836542951430f3c1b353ab0bc9266ae838cca56fe86346bb10f4c5d8467d9b3411b4ccac108e797e7dcc9bc5643d02fb8368e6a43bfd7a415fff7e5d760b9f93533e45fe7c928566f5ce8a3b8d430c0cef83e9bb704dba6d0ad75e6ab97e5668088c8c8a048070eea2f077b0bda51e8c64c5ae3cbe54e880a88d36eb50e5607d2aea8147030badfa883e32ba86104bb2b0453469ea65e3238e5533200aab6da3b95b4861c1bcb5eafc1c9f83267a7d03ea5a196cb157dd08549a729e4b6f296da64913c8a7cb17f63da6ac5e274e1cf6e110023d18849afbb53b4fbd44b3a5215810e60457b1c32149d8a1677d3f5e9c145235c91b0cf422b07b61c3eee0b0fa436fcb37160cd71feb9653ed82611f98b18c727e25013dda8dace3485437673e3e123d8a4a4e05146beacb8bda1828d99dbba79aac77ee132d9909eaadcdcda17850370c1ab9a65209a3ff55ac5360824a998e8a4ab103ec166635bad50e2d98c6c5780b5371e9736fcfd4e0ac565ac5cd9ed1415b35f4834c7a52bf34e8ba634fa0e1c0f1dd6a659ea4cca19fe7800c794c25c09835997d2cebdcac500e07ae5130cfcdb1b7d3629eeffe842c01daa9b76485120c423a016d8a2ab47b30df31470ac16bf9548f9387482b66233fbf022c6025ef12cf69256380d925b45a23fa78dd0482b68e6fe7ad30dbc4caae6f3ad338bdb659f7d3dffe527ea348a58643d41a594f1ac3a297f34653af31650217172506e87724dbb7051b6352f724e5298f1dcb0640fd8a703cbbe29dc56c5282ec288308c66874d3435fcc6e382933af50e83f2c8c76dc5cf0f332d59b2c4ca0ca284c23915105a7acad1b566f5276696468bc4e48151ec29c4737a6f30a9820dc774d5474965172ab2423998da2af2f1c9410a36cb81bdcd4063717376a9e3e112d3f25fe6de2c914421948f3e3728801c84a0415c412d5a1ac1bc214d38e7b4895e8a391b52ef0107b21c3333e86e3dcfc75bb17e4d460734cb938492669c90c7b5cf950584d4e29e6611a6afb5f10b8036940c9f7298858fbad64ed64d9fd9682a7b3906462068db802b259d43a3da22f85bd4ac213025ada3d2aa765bc152bcb34a71e52ab2014c8eb498cc9baa2773fa4385740753794584b516ac4477a7f989b48d765d2343bc1f0e61d6d4faa887fa6a06896570a71b5e27fb0ea367b97810c9c55e164d4d4bc41b1018b01cadbee8c1de1223a80df06f71bd0b83d6f4cb4b371786c10aea3d9d0d003305d14e25320c6bc8ae605b8d973c4dad8d54d9449258911865ce2c7e8c1802e4688e11403c190956270118d16c85463aa278c19221c71903230f18a846a81f2855660e009979bf30c643a60daef0481df346af5a89969e835f0abb4ba3603e8718d497e47eaf55fe82c5445d2b4ac77145860a8ddcc72102fa5c84555cc3726324fce7cb46d739ead0a2aadafa38f27a16dc38625c8d34cd79268e4bd49650caf961158801c78635870e21eba0d7b8f2aeb3591ba9da4ec550561666178c9fcf9ba5c1187b53c9cf55db092ebbabc6b39c759ccfadee084a6c271e05bc136905e966c15adbf8c6ee4966e640b5268494416ce02a4ae9e4950e891becec11773ff869f033b872a0c1071a68c59536f52ad735c18052d60e83560f4baafca7991564c3a6603c397cd42b95acf83d854e9325ad16ab1be7ef1f5e13673ea187fdd437b14f4b1641aa38099bb3e3128f242905181cc76fde05975045d54cf4a5ba78ce2e54e9d132cd39b9622a4047d617b8299790399399b108b8fd16a34a1ca6b243c6de6cdac5d7340b472dadb1876e4a67d34123d736452a82d629982c5659461a0709e25acca938cda1c70a3b97106394b8361b0d100e3cee97cbb841a2f87c2b821a2b9f934624dc2b807881dd49b2ebff110bb5c982fdd50dfd10898c8f6ecea4ef964da4c887bc57374b26483ec8f485af43228c73a4d2706522d8362a8d18b2b4e5568c864725c68e12598169fca4f7348dc7a3500b523fd17c0f03e51dfc7c2f632aa0eb11ead58e77284ac708ee0b30043cfaaff2bdd01ba2cc12d194c814fca4c3ea3213a67252e34643fbbc0ca3b00491d033f3459a0438a00e7e8e4640dd7203c8484a66b98bd036285d347f4addad8b649fc65e8ecca0c77354627103d3a49d3e88524773e00c1d0468f4d97c49fed38b107b4e1090b3ca9a54ac84d341e94d2c3ec7b648e4d6ec12f330c230433c5dcd4ebddfe89a7d72a3a45387d9995a5a678ad2beb61b5a0f5d759bf25144bfea8cbf8dc9bc0bc0e9e9a8fecb35b82c2114ac0f873a89f01dd707939b1c765e3eb74c69a192e53fda8722d760f05665c5ffcc77b91d406842837ed28e590244dddf1286aad06f891e9e0d7c4b84796ab0c96ebbf02580bf8b7f6fba53eb5161f3bbfb86fc702ca0d4017358c64aa56de6b25b62bcb2d8c5a488b55027c7480c71ab10b006372e32b084710ad94e3a9869121e229a15df8139164d388e027dcd982ce93f4e3cea6f2495b5b0d5ecb87c87206ece105aa2b8d401d956bf40f7e46b0b11dd2722a257c9fd5582206ba44534c52948bed5570c153c0692a67d83f12a1e535d8dadbce9869e86fad79ab6fce2f6e580dcf4ee5bfc9e005604b86751128c81d4caef96ef37851d1981288d8b9d6d65005a150d40a0a3b3877d1c3588d0ff277d3ce43d379cb7f27e04d6456029c12c8eb119cd06f9c0ca3ea67a0fea4c078864f259e10df4910dec37ca2d601a7f5935e71451483346ac45d2ddc2e83caba64d030a9ac622ce2596c8268190893decb88a78caf90b048fa2d43cadc1f6352976f85ffba4ec110426496481de0e52346092aaab5814a98051df79b88f65bee47a8cc8c20a92a929ee611e56a2a13ecd29ea93b9bedb8713645d9a26313f4ae1364987a98010f9de648c3b26ad89d6e7d4aeaf7b2668078eeb722d68690e97e620332342eb9dc5f6d50604e678a1938c66427abbd02f8e3415d19e34180e3f445c1f2f19ec55a06c5574f63f6daa1dfb2189261c37a7b75c407a5986d9710ab7f7518596d2b74847ac2053ac11fe06caa2c9fc636f62b724c2d51a5659eb2ef6f5a8ece21801734ad9dde1fa82212131a3d487ef8db69c2de04f2d9945e2805c5b387513d2806cdb38613b78b33ea678901d6983117ae92a9295690cd3287d7d5943f69fb9d473ad630ac7818c9e338d2b655dd68e71a3391478017a18613a5c601615710e6973038fe4ef4beceb7758f4255037a03c18ba51f19f9c876a7a4fa1ccb1b8ea58e8d679f1cda5597f21c7af266e9fb2297e675d4cf3f2f2fb572d92f292b5bed6b19c92e3306148ada3946a6f12da4464777bc9969276920384037d032d99d60c4d4b66d5c9b4469d3200ce6183bccf0ff2167e5096c30e1e94985184ce72d8995eb1a16828aeb9166546517b294e2d6eadd10c4d4b6626e40698d6fe8d5aeb1fc90e68335403f049700cc1d0f480e0834e8efe69766449f663b2a39356e6d081624d6b0c044dcf674b9a2d9d2e466c8b8c1684cd9e5458727cdfe79fe7f0195c0993e598a304fef79b2fada17b2eba9b20d0b4a1cff4d89a695e6847dd6a4323d08ebe512708cd637c8def256dd54afbb2b0fbb93436d03614b3225106320e643b3212f2effb0832159ff181194c7bd00b20a71c917db4274b31fb683f969beca3bd97373b3513e4610fe439201c720cbf10bca43b1a554d83e4c8015359d1a607c6d75aeb1f49b23cc7d2b2beef1cffbe0bfdf747b6b1d465773f5b09b423624044490aaf2aa440e1031d500801064ba96a5c2f97cb5ff673df6b5c1a56e37ab91c0656e37aadbecfe57ad5bc5caecdcb9e2d186f9a18a63130ae140d2c45a3aa71bd6466b0eb05eb11e34ac1b8422e84f63283aa8959d1c9e57ac152aa55aadb6112fef6190ffd3b4cc4d765765b90b4efcc24bb1f8fe6d11e84d5200938eca0140a99e8bf2f00116890c3843f9a5aa8c7fdc0082e81feed998100a20803b389220e05bcb21eae7d5f83a28e4b12fefd149510749d6035ae9707e3f820092b269c5e288ac0fa419a9af93e1a0550a5a892f7a1d214232023f903c4c4e878c0cc8b9973f30da4636226f682a5a894a6e392789acea4333a521f3c656199d171824a417067a273cda852544ae3a001334afc0548a3d83325022313c844643ce185051f74280c3d8f133d4f8b5ad4a2e77d8a33a5ede06343a94e2dbe69f10a7af33e6a11f4c0eca7cff33c6fd3a1e879ef268f5077f7a35d13a4dc7ddbdcfd13d18846d6626c53d19a128d54292a15ad29d188a44a51a5cdbf6c31ca7ed274b3313d943d73b7e94ccf66f31b0638c9793ff7fbfb0bc864f8e641e406653dbcc7679e6422370299c8fdf39248c03ff7c9bdb9dfc84e5d522eaa1475fafe73373ddffbc6f47ca6a7a894665391894fc1a2f1203493ecc50a9b6af5f2a5dfe7ef292af5790f7af3dd6f96ef7b7f961114c7597718a34010e7ef3391fffee3bf9f426765773f9b8826a54a5137d559910b4a10b9af2ee8e984a227143da120e8295081bf70414fa1157bd6889e0784d88faef3197adfd73cf041ef3d057cd02b37d3d125e8fcdd7f8f4924ad4319b50882de7ba68706bf21eeeeb97b5eb86dc24d0beca547ec092f40c4e4d0a30b2458ffe7393252525a51cc9ed77d9521ec7e7db2f498555515fced39607bef2a0ba6879bbeda73cd64c7d2755a773affe7091a29d99a09fa1e7c50497e50c6bab1a307fb7b964b9299844699b778ca19452c86bf86b863a141343001aaabeec53aa41ef167f220fffe088c928d2cb3fbd9bc25f2d5635ae808daca4c0d8bb5e3682f398ee3939c27392487e49077e4905ee6942736c57e4aa416f464ca6a9ca4ce6c3c88f67d96cc3bb5f8e66da26310046d6c22a764b19fd0ca4a26725f3f98d59042efd3a69bbcf499b6b31db51ec94da2e9210f1202c2213189e4db687a80fcb106f23be3781a9fe4704692438e1b4e99ddeeea1917f4d4125ace6b7549799ee7799e87a1e785a83445a55ef6c4cfa6498f44a914e5a4515a12a5d8761841cbbe5ceaa0e7795e8e4c86f64a3f81bfc8444c004b4b32a9924995a2d2924caa64425529ea54420019c2ad9289dc1750a0b70dca60d956c964841e97b69efacc166933cb3ed8cb37c48dd3208be1dafb2b6e90a7792cb5f7743942ecfc3dc7d94be4a845d003f37b9ecdf33c173b3a44e950f43c2dfeddd4e87cb8a52558aa6452a5a854c808403cf2a2fee80106511881e0e872edb8418ea2a19a9690c8053da1a19a969068e4829e48a12694ba4e47063f7f289489dc074ffc1871d227ef3f9006ef376b96b973b6bb5bcefdf3ba8d4bab01ce198339e707c3fc994908622c033fc6efd83b263e050ccdf6da975bbdc4608cb1f78e317e7f161a7c82924d0f809f41dde59c1f0cc30c62fca5e88460994b7d3f1b8de6599de212a64b7bf699d832238a62d71d00878e9314fb61b1e72d91a3a03dda6f8f663a7a429103cd62cfcbd140833c74ba18813122d94cb21722843607ebc0caa9c5371d998c123cfcf65b8f4c46a6c3ce645c9db52093c1be37b8bc7f761129d41212b9a0a79a969068e4829e48340a70478d3f72831c45c006667632504177ef851be4e85766bbdbc4ecc9da1d8ea9491d7e21f881ec0d6cdb7f655bf9b6ef881a46e77e345d7662a9d190d6c201c2079a2b984090b420138621ea792bdd76ad4b1d2ee829c4d26d4d2c7138a185526d36218968fac9c59e2b4841f6423397a0fd3763287ade460c5d2ee849872062aca0020b2230bd500c2135124551a6d5f2645aa451cbc78c0f9a968ce625d2e84f980f4d04a3a279d5945a2d9999cfb51a7c06004a35f80c7d7d34d27cf49bcf78b3b921fbdcd7412987ed4068f1542b954aa1b85cf9df01bb7b14d89ea109b7fc50b03198bb924371297bde300b432ecd44ee83bb2b331e56126c8ccbac8822a020c48b104fd8f7336c371919eede96e772eddbbaa88bbae955af7ad39bb76db5e238f0c6e538b58381c95aced77a06f90be7ae0b3df0c6f53c97e7abbbbc8cb13dd953ce69aa73ce6898a6a44692d73a9973cc98c310bc7163ec796d0c7945d1c28ca36dd9960623661bb3e78d856492046f5c92b42bc868d4d13a9d6bbd6357328f40d9f35e14891c1272d33d62c455afbaef8dc562b1f58eee688d8969b5605a2d187bb2278bdad4a6167dbd5eaf7575adab0b87256800076fdc9578afab1b94417398d07435c4e1e312d962d59e17aff00b56b7d1eeb67697923581396750cc20288ee2385eeba326f33872f2387242382121d77a0808007248c8881c123282c4081224ae75122472a753229320e1c9244898c81ecf09cf8913d7fa8913d9848900e413275ec8274e7c7ee185f285b2bcd6cb32ff9bb92c51e4b24c9151a0508142858a6b5d458bcc82c5799ea7486ed122861631c470adc7a04285b86205fe15e08dbbb138da276800dfe29fe00d6f8b66061c6d71b66871adb7104d17f8bb8d6f4b858a152b58b038cfcfa7450b1860709147dca0c37781313645bad05764b4c57e4c2c3246d91820acc2271b038451588553b8c592384659803468bbeb360f6e366edae01bc4b988bfc1c0f9c62608027b0b4b1b340eb5e7c5f847a834e6b8933dafeb40636e440c347eae64cf5bdaa071345c0b064cba245c7201dad0c26d411b9c4b2672df040ab4f62e9b831939984bc295eee772a57d1fc686361a6d908f7a7012acde4face5336c08f7f8a1abf0c3be9ae6ee2f82365cd33e046d685ac53d4058bda6a7eb306bdf0fbbb0fbecfb988561b8d2e5d04b323e56b10e300efe822cb9d69de15ae20d348873e15ade83313a9c5feb9e64dcd44c86f6a70d02d9200e64837c54c20669376837a436885391c9d2492bf05872349c0cc7b56428b7668aae4ce4bec8438338977d1f9b766a493e844d36c67d8cda1815f83e6315af3056bfcfdfc16a07af3817cec5c600711cf78d9c9cd589551a0428c00ce4a8b1baef732c1b03bf6015af382c0aa0be50d7755dd7fdbac6d6b5ebde57fb24faad28b6da13c7c630ec7ad8803b9264fc0e9b276b6c1d221321c25f5c758da9a1352642519169d9d01a9b9159412e6094b87b10dbcb0f98cd894831b26eedba3566439d775a0432191effbcb37dffc4d7fb5da7b65416ad3b9d23d5a4629954e88bba428161687a40df7468d1209dd3c5080c217e94401504d5150b04df7fc33bf6e5849be31084121fb054300c6bc295adcbb66d358a3a0c419347c8df070179cee3518b21201c72d462b6641658aaa98665425fd4d54a55adb75255ff369b4dc31fcb849e5ed4558bbbbfa82615cbb4d9a826357b9982cc47e299b818815142e3a526c6870ccdab265652d5156bc584b698beaedb745b1dd5acb074b0f78921986be01a5f0daf4689ee8ca8a61a96097d5157dd38c4154c39e79c738a4ad3fc5a086ebfc364035b36dbb66db62dfba637e8fc61a4875c62c08b90e124d3420604b7e5cf26a8cba0e9c9be69908e894fd1dafcf0d2c5f890e1f296332a957de380d0db5bbc41524ce02e7be9692622834cc467e038ecfb8e03bb69d03b27c07f03c1f767a1014f36b1cbb62ddd4c0fb86d1bb86dd9e44162fd29cefbd134adf35c8a0b487075b06d5b33174a0a102935e0c8b1829232834956eca77bd9f3f3b6199ac600b2195f52829262cffb3e8302ae4e05cccd39b927b6cbba57e6f212151a2b28295b07fb7e5855290a95a61e2a4dbfcda6e1efc49eaa14554a51547c3b5d8cc028e9c1d1a8f67d89f191a6a8d489c89ea3928b7497b2b0d09ca07c07e57d35720dfcd5f06afcfd689deed0a852d4a68b60c2fa62c1585b904181a0c8d7580b668dc580b1758dad287a7261bdc4b05029b526c61a7bc1b0e9f1d08ccccaca5c76148221d94cb21d420013e2d49a41a1582f312c56a75fbf47fb51002278f143532b854f9a1afa01ad9523257a641d591530835e61d6560b854a69ad03474c8fad15744751e980865a631aa7088c31c6f8859e4e288ab13ea168e89d506c433883027088c39eb8d51a5912ce16060db2cc71a292b2a2f2fa14a78bd65af323c5c328c6e8a9057b2d277b621c3e832b615cc2e46272f4903db5d202e505fcc57db25461b19fcc83b4811f87cfd0fe3c466f42fe06ec7ed0200f8d1e31144d4f187ee82554564a16f0003c4853c5537cd0be411e7212045b33c90e45f3c905a320d8de935d46863866cf12da8603c70ba7a88c5a7f8ad3c50b002ca891e1b056acaa78855ff00aabf6e4ac749ca4ac942cd64318c5262f8d48f8848e4c344aac17989443d91820772e65493693eca566b439939f7e605337eaba11a9d4692093813550674ffc5ac9c600694f1a7b6822561b5b22d28d6f5ec1e61031da78cb5ae9d1fec58eb1bbd2a399190f43bc60673c0c61848db99957696bdf653bb840dd9ab9623727834ce43eee8cb0f30f36a9da202dfb033b9343d9338faaa8b46a9f4952c986000001000163180000c2400c455118cad24859e30314800e529a5450404c2a8e85236120c6511086510c04510cc7186314310021866a8844032e7bf8335505fb9e62ef882747878a061df430ecb1d6c06d8df3a1aa92efec42a75a8408e97d7600b87624570840152ffa27462fc4d13abb4e4b4bf009d5674d99b98c6b0681fb78858e91336f932b0b11e7e472e6ed0acdf7fcb2b678ac2c257fadadd80592452ce5b1efb776070a772cd5f6979bb7cffdc3de099bf0816cecdf5c53f9e86a28812f1b2c5b9f080a946e439a6c6c4a23563b776fd541169564eecd118abdc25029f80179a8c9c91fc4499b81d002070a5ef1c3d2ebdbaf7321ab73b72e6b09a646383ae9ef48ab3c56acafb48c53b8cf182e08731046c517ab0f134a8a9fcd59c7a312b684ef1a3444e362fdec3f22a626291c7d592b8969498ee89307122f180514d3bb2b980a40c23304353ede388eef8a930fc172d3b43a073538e6c4b4ade923f96467a359833104e3e31d31e18d57f229b104fa2ad6f956bab1fca59b426c4d3d63058150a7ae33513d2b1f92dd4fcc42000763117217379287c4ea4ac099759b44641e88fb33741d4880d861d82c7a045bc9262e99f30822cbaf0bb871ae0e9f452282177b5cabc85aaed2b4750c3111d6595d70c023378747c7d2d5052a9016a5932f8fc2bc972a47e5c6025a51ab104d875d16201aa5f25925070a9732384bb90d5920beceadd4101ed12374e431a759c22d1f92445f530e7cf95c3774cdce7c7873d28504544d3221aa52c60b793d6353d9fa1fdb8dedb70c9c81d4483418e4e622eab46fd2b663fa2618e97940a37dc60f5ce2dd3085e4aa2b30bdfe67ea9c3a3401f005f720dbd900a80d0d3383b25dc30a5a4ccd166a2de5617a8e9023944f8febbc2ebb339880edf1016533eee4403cefb6d1a197f6939c4667e445bc8ee4ff8dfcf2992b32fede5d93ce084a79414a360ffcd665ca60d3f6e4f48e67603dfb033bc300abe418da33fad3088d12073d0a1bcc2c3ca1e3dcce528fbff0e6ed6cf5eb81946baf1bfa74c59130abb3196f6b687683d1bc3a5adba6fb492a97db212458914c022a84a7b013257fd1c57c9cef86cce363906f67ee3ca26fe8d585ca8f674eb3650940df606207a1db18bd42c229a66193441d6f348cc3515a20a5ad8fd17a7599932a3de5c25ca70bb3685e988f6c9426b2446a2daea7ed04cb3e67af5c3dcac0c696bd6084a28ad6d1aaaef06614e9bc7ead3b5ac647835082ded02a13c9e5d3f00e81e06b73a6d81273ebd8a61106f4485b10fe0c036b885693b1fb48562d5d321372e3eea385f3dc44437af59acd1118c7687611ad957bd9fba8f28e1f4cca46612347b42e14116b7a46eb2ab1c018fd7ad1af0db8c6b0702de844fd1465b4798c07b274d400c7a597fa24d404cc14f0aa204fd1f590a65d0b7c88d00f8c2053b3a91b4fda451caa24a6273c58056910c5ae31bf4017fc63406d2fc0ba07ed70d5562eec385c2a5f24c72104438e2168469e45e2ec1bebf23a67492a710bd428b25f0b8e6c50fee020b3fa22554938d3767fc072f28553f8d5b13c198c998ee85900e3354a97b229e81fe3702db53bff61fb6e361ad3c0333034cbf27e719024e3c34b67e029818f8c29b29798c9bcfddb44b2b06f2203cf55f891cb0fce7e9e6fb3f89c7e40326949eb09b90e90af3bde419b2aacb1c87e9156925d50e9ba2e8bcab23ade322defa56c4f862cee5b06dd1fa15e5745f37aaad3f7a033508d9d3747ef8e25657478e2f4a0de737005e98ce2b3522278a41d4f1eed4f628cb4d1a46a391b542b5285e707419e9f2c7878b2364af713383fcb835567f0d576a72a7c9a6f31e555fdcc78e82b87ab2bb17cdb9530c1348a1ce996eab0d62179a3546c41996e807feee07026158831b1f961523e6391eca1e3d64dc1e48d461ae3c83d6f5a26fd55937c6c059237248dd7441f2c88a3b5c1f0489e6af3f775766246e56a4d336aea76b591f95f21e67fbfa23c5893cf5efb7d716c31481fadbc4d5388e3636cbb52631662623754b83e5d69c7965bd4b86e8c366ec4c5676591c7860077449d89120f8ae548ec6fd98c9697a57223fe984430e9596f01c3ce0df540f6a6c3489e89c8df216b1c8a4802f904eadcb097b382a2ce0dbb1cf43ce2db03583ae60228676cb9f118caabc5185cc49858f57178efb80173decd0af181c0c9609dbc56e873a5f567cfb6323d4e74bcbb2eab99fe0bdea1a77493d8fc654d6350546cfa656d2c9af7735b4f9cf7b9d6db93b37e11bba6400fd38f63cb10f6a9cb079ce476acf4b558330da604cea0bcca700da498995e008ba21ec72a3916cd23aa668d80ab67c8922c4c94413d2a9c11eb8c406a5aa708cf194d92066f2c409f32289a3fa2605196cca0cc2d271510caf37149545fbbac1dd16b5067e1b13775d758cfeb3193b6f7677c5b2c33876173f25deb5e12ff4c34d72527f85ee349be0ec3455810b0373bfc2365ee90c54ebbba598dc51b5bb28d6260ff90ea8298bbc751f7443b1154cf062ab24232ff1482971e0e4b017b54c0a1e50fd48c98463829da79c3e3043b00a0f5039dd3dbaf32cc5170f7fad28589a420880be8251f47fa3ece97aa464abe9f0c39a86f84fa7375b1880a896d44c579c9a1136f8a883d7b526deaeaa14390a672117de68a651c70c1b92a22a91d8d9c823f73175a5eb831bfc325a507397073ce988ccefaca4cd681389b082f0ce85298fb45013ec48a52bbda09406dbf1a3ce3c9a7b6ce794d4d94344ef1d505a10c153b51e2652e53be9818e10b53e92994dd2525279ed8eebe002dab370a741ca7f32de747f654aef90f344b74d7e6e38b35f3feec2919351da17e356e34b7cd4e278e80d5c45286b311d8bcbcf4f0be49965f69ee8bd12132b7330646aba40d3d5b044a21044b1bc5cdd6da77e892d3c35ee995ff29fc8704823635fe207211d8fa07c192fe231ef2f49f64ca557ff460bf966002df56dc2ad634e11a7508a6e8a86e0a560691df1bdf57a782927b0e39fda72ffa333306fdd8b2dc099a4b4e6e2ea1cddfc2912e9839a3726100e3d84e776ad265d882fa35820e035744a6283b3897097a0dc61920491baff2be593086a2f1fd29218e922496e7ef1c123c56a06bab3cfe7378b7d38d7fcd6f27389e619958e8d4be3591fb8b7cbdb6ffc8942e709b807edb500804d6fef6b7637a3615ac3a4965c4e4e0f86504286a53a5ad7e81be10cb1f6f43858af320354d91247e5bb22678f349d76090879a3566530f46e30c4b937eecae8f8b73c826b3672b61b5130db4aac266f69f151d9ab2bf30ff002fe6a3a1477a8228ae72b1435e1272969aa1bcc1d42f8b8e731d044f499ba6488f4e7e669e4b3eef3c4c56dba49afc00be2f87d7eed9dbe9b56d7629d7f0ddae34d2169a3a9525d4f980dba203fdb920221918daa6b8a0682769149aa45fa36f32c38b0b1adf71fa4f43d466c774722b2c68de3593da3311b52c7f35664f211a877f982dfee390081478b69b1b5fcff803a6944b02d0745943c6aa51d780cc05541a0cea490c2f80119a136cc5d40113d2c070697ec49f4de0573d43c3da8c353c6154b1a660707c3778df99051b74578d012a5fcc069d3eb0179dc906dd41e4c0945eeb4a1468589ed3718350641f1484deb2324f2441913ebf8562a00631ff1a1c7b76b669de2f14ee654d11932790642e6a2713cf6aba94250b88c73c5f8170bd804f6c2e889c892b41837977ac163ac6459bc646c77cd252ef1ab00b527da957247d3377649c3772262eb80076c99b71f7674b1c563307cd8239aeb83b424a33d0d068e0e6a46ee2980c8b055ff0cff410abafc8a4025b2db3e083eb9d706bb82fb554fdd7673073e4108c32304102725a0e9405e94c0119bba62d4b5a151263cfd61d8884162a7cea125534bcffcf6262fc6819021c6a31c2902c5fa55b77f72c06a3fad64de5599586a0bfaba14eeb267952a521e9cf6aa8d3ba8b3ca9d208fab31aeab66e22377f3669cd7168d469e819683a5cc260bc91c1b8b461d9af8e3ef025b968fcd3bc2e5a0604596aa9e230f1f9d66cc05627d757d609542e284e50c3f83819fa22a113382a7dfc69b658e869455235ccfef4a92fcaf2f4aae4fb3c99d6381e7122fa2611b25d84c8361e71d5bf4918fd8012765a0f1bf159df8697f559a89fc43bb06ea3980109b191ac76bbfbaabec96ab10b9b6da9a2f506472553d13273bb4696dbc7df41f2179a76a339a77360278becb403c0274468977405f1a7b2284b5770ebae56d4740546cbcd59cca3918756aa785ed6153d30a10117f4d9a76a55310d998e882c46abd753337b5cd2c1fca1a3a99225efd0eca498d2ddb4a72e1ee6c5a5469c203404c7c203c4d9d6ca893e720076416d6dca81da43ecff40fcca4b5d8bfeca3011b173ded69221c8f2b8801cf9937a12ba5030d97018dd02c2968d83eb7873189608fcd2109f43ee9d079dc7a7e399a4302a42a81b9a27987f41c2e1d08da35e49ecf2c9fa8704976a49618d7f502b147cf2aef40e9f16ca1eece6d970c7e036e5e9d2550426d116ece138c72751edb032418fc35eefda85362ad86a5e513c87f54fd642c3854455c9555c0e1c0f0e3ade4d6ca16809aae13c38b0584d3abc469054e8cbb57627c416dbb0271da15d3a8e415d078bd862032da5ca53d2016cd80253f1ea4ba47d14fe1e643dda32015bf898685a8edb83a58147945fe62841d9207484c4e802acaf8c6cfdc57a9793412645ccad7e2ddfc89c2022abc3b5570b61ac57eee0467aefe9b7ab070af69889b8f34fb271810eec8aa5821bf900dd87f56e7e07a33e256cac833fafa249a2d61c4e19d69809a0780e8124b2f6362d3c3816cc208c8a3b53dbd901bda7ee416d28128c7a4ebc544cb6cd8ac8eb37d62ebf8a971cbd0950ad64a89cecd12fd9bd6d9dab5cec2d4b87545e67f0d11d032d1147d0f1b8c6c14a89e8848e075dff79cf7b33cca6db105841f5f431a8b43839b65537b01d1b2260498e21d68fe8304c02abe29e0cb6d035165452513516f8308cd0e94a0cc97973e398413f24dd7bdb79609905c9c5fcf3fbf91e02798288339ce2986a2720eb05b67722be9eca0bfefdd4f947d0ed89b29242b9e40dedfa9b32043c234578e5861a3d93fb68af47b521747cf2bb8a7d9b08607e2485b5bb589ce1a740de022b44b6fbe11ac529a69a8865ff7038b40ac0222986fed2b4560073b13c781a3972d71c57a4f01b16a2e7d183353777ffb285fcd47329c65ca5ee96f60d5793c885174b3aa3381a4824eb50279522e18c3c01423be3f9fd2ef7c93cafdbe78d8f2f9888697f46386a9e1c4f8722e10cce8019384b827dcf1594a794170d01365c6820e6f16489969c1205691608e99521f74d23a884ef4be86493aa779c4a1249ba0365b6a3b7e38b7074480b5b3096bb4ace038c3cf94499082963b5943b524f6436cdfb0fd51ac670b5d614edcda503a396e6eb1e4f2005762b540ad44fd6c00ef68083bbc7174434ce3d0841a5d2f9f6309be0a12750c81bf548be73d9550acb077025107a71e764c2b114022b0f0c0f958bedbda34a5d96b211529a1d4ac2c969e584f4527ae54bc9ae21a0867698aef4a15243446a8cfa0454c10bead7be7bae7b0947e5d7585d95bf27fba8bdeaf4b3411498dce5fe1fe3b3c055e62eaf3df4d80a5e9ead0ac30653329940f9b57ff7a63308c08b52c88aa31645e3d856213fe15829250acc33214c94a07906ebaba68f899a4275665dad1b81d0bd64d008d5065a987157fae86fee1e17b8cf52b85b87e7e3c3466d70b7dc44cb6f17b04abc93491f2017df80d06dd344a3ed352c42a37b5c06851fe9f5490ea4c863d6656c4e5426315ae6cc15432086d5bbab256bf410b914f7edbdd2eae7e2735c0ef6ad77afe0a7276d2f3166d6e304eb955d215ffc16a47368394c77ad1c7f0c74fc30c094d0c7f6b79c65c37e22ce21f3ca6551258a7078b65a2a51e0f957555dc57404e5f41430c9649f6382d4cf0b1ec8041dc2ff35030d7f8a7e469aa711c6e3d191b694162e289e90d91d253a0d99bca983f71b15ec1f9daf01089ddb6ec23c26fd3b4ab20ae4ef86a416262d247c136e8bd316a029b10f87d87ab0058901997ce039b15ab95fe4f76fca1be866e57a732fa4035b90e7ff9df26e9595fe54976bffb254a3617a19f89af06fa8d5d38a5188506f4d72b54c194ef1e57e1e10babc8430e7087a3e1a989818277f89c6b127ecf54c8aa0070b908ca2f42eba9a173688d63e7c79b59f0b2202a41af9f6b5e1d855607e2490ea61dd56716bbc589259b348afffc72c346797e0f0f6d6d0685ecfab7afb0ebcb5ddc405f37083b53fd9e101b8fc4c352602bb6aa3eb2a5605b534cc0cc6ec2f23c7ee30040e7770ac76d5ac892984ab4d70b7bd9bc5315ba68d5c1da4709913cd0b4424c8c7006a95e433454942bdac284e59e4275df458dc8280ec095bde72375a5a41100d7dba0532043d03c1a768f05cf67f2a141bdd52bb36f60847e83617c88d675dc0288692b9a3b77c0e089f026f166a8b4b28ce4760d48f6ff50428ba86a46898b756f568279623d0a480ccf62f48f88bf51413fb1d24f665760cf529c246f6a4617ee908ec5e73a04b8d0ea31b4a87e1627e8a1ab36d0440d050890e4ef5da2ed50c1a030620118632b13c0ba5e50a8e0e5c7bc85554414600479828ea9b8120cd9e548028da143caf9da61793031364808efe6231fe252a68b73893e31d3ff30833efd501cbcab2eece2f8e2f22afcd8a5c05d9c9a7a40d359e0f20bb38a0ce40055406613b274629b27e025b85a2da869221ea15e168e889a24fb68b856363070d6410e4c78a45b56a473cba4c64a2d7cae86d33b185dce8d9d4254fef65c54371a352acce43cbe9d472937f8b4c962e0cbe5c0b0e5212bb49a75e35ddb68cb7483767a957a61c6290ff48bf4b6555f3db6184c26c2ea1efd7d1b6966ecb67924066052b867c833ceacdd03cdf1fa30506a3cda07cac329b03896657012a6c8c724cf8eed85520a28f9eb4f7fcddbd1a0ebb2c4e8d1e7a2e6fbdaf80476c70e3f6323e9d402e53d4904f3277d73ba431a48bb8b80adf75a5078528f12c915f91ccfb500dc0f0c2bc16d159b495a12aa9e4e7eeed5b5fe0c48ae438370ab1e0778d9dd8558f84ac11b612667ff7273b9cda4a68397dbbc18c33255086ec2f7947dce0e3ef953e6745023aed41082db68dbcc0b8b539d4868bc57b1b2df56d9c6127643f8eb11c4b8fd87c5be2daa5f1d5fbfac3e72a7ed83091841c75420edcb95a9c796e92ffb5c04fcae86269115544c8b857eb0f7fc29275903376b1f78f02222e694b094f445f4e7da1be7860649a40d9c91bd8df67e056e648ecce09bcbec831133170140a950ba6702a2b402e44ec21dfa1c6552ea4ca47a992300bbe72f18f36f64cd59c0a005941c2fb32ad1c2c62346c145d84b233f5d58532473a08ad39d852522e078bba177edaa7d3a88f2e03ff77c6ac222d7af8ed60d1b007cb274227773bf6861f4eb7d607fd8958ce6d3b8046105f3d8e116726ec234c11d9365d4c0f1fda1e2bcab345f00661bc983f042f0f872edf14c43384046e3ac3ac8e3b979ecdc5d6d023900df3da5b6485edf89269bb319c8cd1bfb5b7f185960ac4b12f17c8c385718be5f2560898fa82763b9eacce1e5a18f7b8a73585d71c04cbe95c34c90cea1c2e733c6428919c9f9078b6b1b206fc72b1666a552174ee755724ca14282048f567e2969a9fcd03d4dfcfc06e1fca65ddc7ab406575e50475a261b1eac3c27e82e210472ed0212c64eb59d1b26e092bd5ada3dbc4805e502ca9bde374eba9d8b9b62131d18f5dd3e57b5e2ae586c74a677089d1557ee5a4162aa6cbe0527651450df62b793c179e8d3ecf341aa5105c72d2171a62aefdb119c7651868c1102208b095179eede0bbba65b591f0f77522a68b5232512e830c4b45905c397bcac5b0c2a7064973a57871876d7524b8820a7a508ee931bd1562377da9940e478d30133950640a9918516f717df208bb61e9adb6f4472346b2b2a5419e142c0734770c5a6525f2c96591535a930d9f79f3dc526132294f0eb2b8409a120ed3628420461e348dd1df4624e0980414a6b8755d6e4ac77c4f29547975a287583213310ef17e0f9659c3479846b70d3a866135f54799733c4633720b8e33327327d3d333728592467c10d0bb8c22a9505103a08f1507f51d04be6fd7a4148412b00729863e2c5170374169eb9a565ecaa2621bf850379f6e34b4f683b5f651f6c162250d6ad1982764f4ccd21741b8eca615b871f243d4b5ec92afd8caa322f1911dec32ff9886458a4acb6b76d9d3b8c1a1b291c6566bd193d4e9f2f16cca5a10955d6dd24ea2b2ad8c00ee7309c0462c78b80eb8e802f49003761960a1f81b7fdabf3b18931b14e9000b5bb4541578d1dd6d42af86472c5d7fd50b04818c589bbb3edf4f97a564eb070f66f87fd14752af71c818140e4b45d97afe72ab5279cd7f47e99574b9b40ac06d5141bcd0216563a627335cb4c26e134b8cfc0ce126e57a69447637085387001d3b1e64d4df6ceff5aa9295e110403787077077a6875abd473a001915d3dda42c80559aeb64bbc72545c109924a89eb51d9f9306d49ca67e521929404b2f604cc6b50f046fc0190af5b70a95571772aa1b1956955ef808b092231647a708c65dd33e828a1347418919b0922af887f8932c112e5e768903efa2b6c12e192321f3ed5d1286cc78fcd8aed16ac7537a7425d4f3a173adf23186a1dbdea5ca4e4ec18cf1897f4ebbce3c9e1926033e7fab1bac9863d4fdd8edf02459edd9e2810c9c0d46d6d2aa461303b608c4d5f0fa4257fa9b4b20f620be416417b3cee264762ff2ccb73a1fdfbf843dd98c1aa1aa5b5ff3fbd79a033d67907792352d0220ff2a41ea7b46f85f402370ca5551530f02d4705c61af5ac602b69adbfb1afb20ab8d642163c7c1468a31563207a6856f828dbb17f8cd624ba1bbc4cd70565636dc71c5f9078ba4cc5cb9cf55c8359403a56d670124c020da93feb7424b0c8f7b336a6fb8948a0d5030259ed7ed61b0112086d5cd58418a38f1625ffb312d0cc35f3ac0e58356bd77578d65904a776ed0cab45b3524744e0a3a11d8db959ff494a29508ec5948dc55e61a86670d494b6ed0db200f3e50674198c949771bb3b31341d8e3e6aa5828e18e9961857ac6341a097c4e0094c87a44de38b8e68d930cf1ada91b3e5b923eeb5567b613c22c5f95cd882478cac32b5018c3eaa3ba0d8b7ac5672d2c05830564d81c6dcbdef0c64f2c6300ebce20b1b5f229acee8a0edee8e37288cac52584145657273f0617919e42257a7121a13c92bf7dba025406d007898f03395bb4355902e398e8175eb4f2c16e3afe26e19ce39ae3f0b5dcc7e0691aa90fbe2e04eaa82bc4c5ae5242b64bddc93c17d26eb7f5ab54a4b9f71148bdc4affc1a0458e21a070738053cd05d53c63f1396309ddeda9c63f365eb8b4fb4536356ae7d3429af6a42605b5664952093955e59e6ae7da3c0b90e5c8973aededc014aa429f2c97dcc632b61bf8f5ad9a1335499f850e092c15e5135e882bfbdf78ba4fee41d0cc8684db0b9d6a4fafb125a8848d3e72aaa5ad03c3a94eeedf72de5bd396b88272d2958b61890f3970d45baa09ac15c2a8a13e571659b147412d267087e1cdfea322ac2a9d6b441692354b25a7f30b589a2714dcc1037a9ccc8068cf27f54f78e8b57b2270a822ed8eeb1cf8d06333382e541036b1f3694d8ae31b9a4b7488a82cd6c17dc53c2145404e5ea24abbc24e6e1f4cff3dd9909ef4093ed48bceb84e037b1472f89e629551b29856fffaacfcdd3acd0a3d2d764a17ab0218e9ccb413e53d56ca545987f41ad383c3e5c2ddf3386cc4a9fa29482ff0728d80c6d570d23ccd44ae3a50edcfc02259943ddd31e76a33a9890643fec64eddac667f1195efefdf466468ec768ec15825887ea6af4174d9583eef852b820c8430f00c7015db82d8092e23a9a6f784e6709d3b8d477d2b5134f3b6c7faeb346854829ad20016cde2fa959113ac82950bb1505f1cccbc8820acfef78bb6fbb796f9cb363d42111e00e38672c7789cdd4241fcc67d0d0d1deb78a1614f0e41ecbc5e1ee8532effb008ddd3ecb1ab7ca8296b8309ba43e8113f133397a81e80a883dc17c9ff4d17b3ccf614a221ca2a9f6449d12da3cc625b8e9eb20fd62dd140208ddd4b5ecfb236e4fe87f2ad8e37b8ec0ecc2ae0e66407aa41656b48f8041671c63f3a7be38632b05f8013b7a262158ee9466c1de891d889423b148ee75cd2b6b28ae0fa6e07505a67ff2a92674958fff0dd5c98fd90d001242f5e34b25b4a5022039074f40781af6541968f35e94d8fdf5e294adc531bc4541decafb1f9164d94208862e9879768a87c33c7cec4afd50476c6011236ba9fa74f7f67ff6e0d769e5143bcb1fbd463382726dc6ca45b0d4ae2397a08068e009c3e90a13c14ceb14a59fc95107b6d67b6b1fd220039da42b97a6bd1739d009fcb500957347fa80a5cd8c3c8d12301b1b4823623d9fb1cd3d1a7df7aaa8469267d38e3f87f3fd9a00318ce11c23743811407deb603d0483516863d143e7f8833f54c579fc67df8aba473e9ee54d410b2b8ccdc3e37baea25c9f5fbfec4bd4fa5725c67aaf53514324fad2351c67ff6bdbc33d45b3be58a1dabd42a5999b3bb2f005709307752ec9c55fcadadff5cf1702d23358d1318b933027551c920e9906c5a0494137fb9eeeff9159f0ddbda3c0b2db714882cb42c51bb26364565280eab6288644aa205097c6064af3dadefeac0cbcb302fed9fc5b8f4242b2958088c822d4c3dd912ad131132c9ee41225541d90053746552a7e811efe14a2691cafed95a0f4b99515edbc3aa972f9329289514a4ad6616a9001f984057b712a538b79dbd61782e96a8b799e52ece352a2ddbb88c513654329e76e14360e77fc237591faeb144cb35790dda68f16881a2a7a2a521574979bc826a630b318034e3a1cf9fb5ee63ae5e23e02aa2da809e6b95caa28b528aabbf3123bdc2c8e4a373e0235bc8a64754467dfaf4e05015b1bea171f434a68bc31cad9b90471a3863f36c128791a110ca80f0abfeacb2d6b89ed8021b25447dbaeb4fb1faced8c3b498aa9b447753ae7ca1a6e4ee54610cdd4f09305f687f962ffaa0e331f4ad565bace2372daad3194c591fa02a90e38baf037c484a80b036d5c5dafd7e73c77b5dfbc5f8dea8c6efd9aec4b457f9379ef68165da1f78020c02dffb95313598d312b61f446824e7b5c94bbef9cd963d368967464fa6400215d8f79d6cb9afde3ae11725fb89af7c1aa9fc29cd199c4de9c06c4346ad80c49776ac43fc1e1a45a86b903f73b950f9b2bd9ef607998811476a97fa420825634cf9d4775a78b0bc85afc8e51a48be0f66c7a4a38b5454aa4744b2895255807a6afdd3bb360b5f7fa552ca38d7af42cdcd5f70c314fe4e4988e6583e51a0ccf28683e910d794e7aa4b8985890d9362c3df064639e457edb1309436b754bcd12e72bf9e0a7405b1aead5d448f273e02c0adaece374a0701a2a69efd423d368dc7588803f409a0faa7d7177b404c2c56014a10613a6150ccb9aa0ef241eccfb85477037a79c1e3b2ea1fc65f0b1969ee90a5d4981c0d1bf607f7f8e0621f5ce2732c0fbb7260b2d34b1073bdce8b099c4d81638ce2080cbf3bab247965cf08850f55a1b4cf319b211bd0cf4ccbf1e46fffbda5943249199403c7034703482911d0f7f3a538a4942807f4fd8a42976f892e2e30fbf3f95cbee572e1e2e2f2f5c6f5f3b3458295adb83237a79e18c1e6d81cda8e15576679d07c34a4209c2fed21a53d22a0efb7e3ed7c3f242b14e44b73be6ae4536d59ea06e64f9a9a2223dd8e47d42ba2fdaed06cb7a034678413f2f97e48a7277f7cd7b758b4156ec562fdea2d8eb57abbb22e2da5e8e2f27371315fb8fc0871844b0b6bc5325f56ab5f7510c6c4966b3ca55ef5a5e9333fafe72c610956416ac1acefca24b98ef7b84fcdf6a3f42f9df5c3d3566bad43974bd49f5feb9025ba5c30bbd3e95c2ed7b3ece79d9fd65a6bad0eb568432d565eb5fac30f4d54d4e64bf83ad456d753a56e4ad72ba90a961c1d9fda0f4ec8ca159aed169486360c75a8ad5e7df9aa4f3dea49d69bacb57f1ac7130c05034e3f9e463b5a97ebed639775bd75b9cc17ae6f71b5ac1dad1dc71fadad19784cd78cac3f53aa7275ad929f493f9f9fbadbf393e7671066b1e8968fd21ff340418eb7e2dd703ddd4ea7d3e96e35de0dd7d3ed74b71aef860beae976422b1226d64ea7633d09172cd6937812e60b12ad1d0971f5f75b54c95556a69dd9999dd5bafad56aa50312ea74e3d2f1a9fdf4ac58e9a1d96eabd54ab7e3adf2af2c9f4c3d8c5d6f48bcea5d2bbc5aad58e68bd6b35a626565d6e71dcbe562b556ab0c3c569a402c9509f442c2025489112ea368f342c28217ecf5e70c8d0d07bc1baea7db91bc1186ca5924e0a552a9542ac5bbe17aba9d4e974ab5e874bbde4ee7678bcbb77c8bea5f3c28bfe55bcc172d2e2ad3b46b51a954af4a896065284268514f644b026f05293b93318387cf86ee56e3dd703ddd4e77abf16eb8a09e6e27f4db3a3f6576e73257667b3a5b4d7733e2dd8c703ddd2e97fa54514af5d7ea76bcfc63d3dd6a27197903f34955b0e458d15db952fb49e95229dd8e974ad58d223f767a979657e942500b701fc59559196cd041e1e9523595eaeddbda4c2ec59c77ac72a5ca39ab724e9940afbf0f33e25d7e8634815a7f9fa6c60608c56b844b0becf5e70c8d0def86ebe97623cf0403e5ad273ce88aac45d182b41a072b8a68359b1151ee07bf8d9b52614e44fdfd086424249489936982640dc3263ee4f83167891913577e40a5e092cf2a0a45942b42657163142a888301cf39a21605ac4a55cae6cf191aa29c4984413a2b4916da0fc022140a8542a18a683523a29cb5a8c7a8962a4744d46a7d2bf52f1ea8bef52df345eb55b9164a025646f3410468aa0a7640e158e002336a111e2cf2df477398229bf7814c5f511ac05c93e9ad75199bc24f9f39d24d6787b0d9f8a3a41e11c1b2310c3d6d1a213feb76d1d89c5c025977c5b921395cae46ae051b0e1b0e68039823078e464b539ed4845b8d5bce961b9acd50285b00f200877a357a2618f5180ded7aec4cd8fdd805d5828cfcf801ec01ece9e82909de08a641d2263d437a868c8c703a740477049104850485723eb92041529b2da5d568b89f909f112040867a7c7aa0f8f8a4bf1c3f251f4abf1dbf21251e4ae92ec80ec94dc72dedd123edd97ab89e4fcfc88c36130aba11e4b3fdb02da1e5a0794e0dbfda8fc88c67e62374e0b673c3f5f0e85162e3b12149733e7243401a30cde9c8a53c3c4346378cd2a51e4b493c47566f58506e3e6e4a7efc08caf1c8e1683b68e9efc66f68676387842684960a094a9576946e3271969373838abc998d9992602dd86386a4c7a3171404125c020c024c71a4a98dd4a6369a0dc8498fad67a8a6c4c79c604ee50ea3edef7afd5fd9e9f447cabadf0c4095d51b02f87c6e4b7a3bbdb4c747cf92604fd009100770c8761ba2f5d0880cdda071a06cf2ebf911b1d9b00dedec1099e1981571bc51d149cd28c5b1b4f46329050cea46553e1d3d4165dde899fe00a63876408cd221375ba347c9508ee00965152b0675fb8ff544ac6e57f978dcd29d5c2ac44828c852da2335425b3202842644db9950a640827035947cf48c94e98e201b4b4bcaba877a8270656a53dae8b9d19887b9f127b69ced2672840c38dbd860d1acb1891d29f38f16a581c9446d2c9b362fc266701617cb266a6f16774389ed0fb6473cbbedfe2d5cecd34f044c29d1d7c6f1139f1e7bc96f77364df879fab95fa8acdb87c81a83ced413a9af1f86611886e187611886e1c384243ee17a42b5eba9d613e5cec6eb57949b9f96fabef832994cd13491b7f94325fadae18bfb05f331a62a865f63421b664cd4d8cc5422b81f64f6a63e21f2b3efc388c1fd8a79c1b8f2e36ad2a4a5ff1326bd5d62d72739dd3e3d66a22e768b8b82f0da58853dad79c2c43ce0ac280638b6d705d2cf2a00928421ab93d57d80e80d642c35eda3081b824b59085da4022272c83cd8c821d13394720f3a04d98a4d89074c682107911e21ff20835ee2c30932f01674428d1dfa28236912720d4d340c39081434937c45bf80c3948c822344546021862e9225fb76fa47be416867051933cdc304398a2e21cfd0a3697905fa67873c040d9dee400642a7990a8e0f681772d2109d429612c30d1d433c1cd03929c8558ce0402044a78791fd1a83fe062aedeb57f076fdda1a7234a407c4483496367aaa4734824f8394d25222dfcfe7032104a0cf97e202efb00c6028fcb40f44961d9a0d8629317e6ebc0560121a0740b0e3c955c192a9484600aee8ee2e40d9ee26987fbd6cae68babb7be89f81c350f8bb6c345f2e63dfbabbff0b87edfe4f65bb3b8c0966c265ec6bd8ccc35c8bc263eeee5e75db2b6f7bf5553f02643bb9ddddff8f6c7f1b25db8f8e0c6df7d79f47b79faddaf5e848cf16773d3a32dbe80c92e8a30c173dbfae278a555c151910f3dfcfc0c69805364b18d95a28648d394d1f8a381c4de13886bfe21c4de17b0cad3ec468802d8b3034ed7f317ddd2f2ac21f7faca610e64a52fe46cf0ba294a7883f7c113f7a8ae14300c34a3fcf2a3bbd7f0d8a0670d041885f3058c42210eacf2b7ba15ee70bf540a8475f1885829508b1f8a13853e244e62aa20d4249a4cd47d692aa04973c56491db287f42169e40f92c750f204df0f9885704249494a494949494231289923544fc06ebd2dbe7e742432893f2a790c1d71da64d23f26798cc86596e7672c321a771ee38d3e8ffd46a411e8b17a644467fb8f554ca216f2183a66197141637a9fc49310511bc036261257af0f9f857ef1519d428b7e8afaf387fac3f7d34b8dc7d091280c6908c9c8f78779978def7f969831b1dbfe3436a11e89c69c3b2a043a3d91fb48e444b8d3039d1e1d89b69f4eb0939f74f83a34c5939f7edae4281a115b3180ad9d137c6c2812e24996ea9e55000029c6f6c78eb1bb07b278c5ebe48637dc00e9f76658cdacc4643e39007ff81995e27ed68e4a719f4536cb996d54da47c51b4740cb83adf8c9ace2d5811817df8bc3378727c7263c8ea378c50b25d4afc31c6a8dff62adffe2bf380ccd7a4f20f1c617a5334a85289a4c26ff1d43b05e7055135f1d58462e4769f024f6d60c15beef93d7ab755c492055fe763bf667f11896b394fe7563ec9fc25f6573dc5d03dbfdba3bc61bbbd8ee18bbdb38be260ac32f13b2c65859189ad8f176c7ac2825de5e55902d6e96a5149eb35bdc2c5970c4adf1057c5f11b4ad06c88ff3da1bbbd83705de3705b6f5cc9f33b06f8abcb7be388524ef7a344423004aca7a5464b72f495614037c75ff459f579b1bf8d6f72b6079e4d8782c039789efdf00e7c065e1fbaf8080c7fc3ff0984bac1e15c1b2fd437099dff8eb3be331b466d97ead984cabd5ae166cd4825dbfd61356265699b016c03f594ae0f171230438a4400611517af0803e8480018f90838e14198c5890d2733446a12204486e862645708e103726290a45c1146e60d4f80df9c1a2a4c32827cb049a4419818e12a44085197527c547103e4c11c2043014b163011e1a32d4705244c0bbf115a6acf0e4062c329010c1e4a7051c379cd41821094d6806153cc04390c9120d2c3cc400ac81f7b392e3c675d0392a72420b3948a10df1411043dc80420c3d600d37ee838634576385600fb315ecacb8520547d1cdca0b316e7c071a664538f890428e2b040588e0ed80420923e45c71c00c3c4b6e906093e202161da4204c20e40702211d24b8f11c4c663666b0e043103708771afe6295c1bfbc60a707193a24a111844950919b04a820e3871d946adca0728118c10e2a3414762488d2e2e4461228b61847ee0f3aeed6080a0bc01c5f4ae35783008ea2184450fbc0eee7061b4025079e294276521c929620a546d21d1cd0bd42e3de568e6b69b030f4b7758cf15f9c9c3f90dffa756c6fbe6f3d6317826b081bbfab0cff5ed7e2c5c1fbe2d233c6c1fb5e53c4ee48b0ab02175001e1b5f1cbf650e2faba32f6c517378b2b630190a3b4a7fbe2dd8f2fbee729849dc40bc3b82eed1bf37eda38faa2c26e71e7fda2c26efc00d8e6aea80deebe60ebf2c965fceb7d7bbf74ddb72cac098331fef0491c620c83b1fbe717f6f0f3db78a81f0d612e3f377ada2d4218de1a7672c54e3867f33ebece038b1ac59f5fe7cc22639d339e41e65c4d34fbe447f163d3e5e7cd3a7ed657252941c83e1b7fc520641fd15f0875d539bfd6b56a518b5aacb5d65a5d1ea3d9377ccd9cff12cd1a9a2f2944c0da446b763671f2c630f6bd503ed8fa2b0cfd5dcd5b6bad1f9aa59fae7bf2f3ba70f20ef1db387a82553fb32902de3879a350d48db3f5139035a634ab76f1e281fdfcd97c71a31fc64b07fef9dd14cd970e4c172f1ef88b37f961dcd40f4f56cafbf8c9d71fbe36cbd0fcf3ca5e3ac8af3f9b2f6d9ee595a99f61af2b33805daddb1a3ef8ad6badffbb56075c9cbc5f27306dfcac357e56adb589e6473fbfcde86b5799e9f56b93cc61b9f3dbfc58bc32f545ad7568623f75ce38578b30b8a10967ed65e912dd732862bb7b083b4bbc2accb67fdd1ef961fb63b19c02c4762f5fff34ecb1c946cfbcc393d999038818bcca93091a3fddaf099a996dfd4de6c9dd8b70db9d2c4f678cab3c551a1335337f72c198763d3a6243d735c41ac3b659409575e06235d55e930d5c9c94e86b5bfb31fe7a8fd9048c9ea884899e0c63284dd5060800b317000018080c8343922ccd62184a721f14800e639a4e4430321305628138200a04c21888411004001000400004010008811086b2583d06756e2760e825ae3f8fd8c05f64e9d8c66054882522c6453257f6ce059871a3c6165f3d907bda8e9a9ec9444c4dbe90e889dffa22971ec194dee73d774602fa2538a6e18b511dc2f48daf92883c6b13da8dce7a4b6a6ea7b7c71971c54ae70de9641ee215b746436fbc2fd3057d1fd1989003a016e7d7997446c50dc5b496c19816952ec38e16fde69089696e5d283dc1086e8c04b8e9c517fe56b8f5f218856ce92297e86b49dbc1cdaf3ce1375c92e6d08bd5fa690e3a0a8cf91f232abb12f58a261f7f37dbf23e807c39a10f4ba7f24469131b8321804d20529539096b8409cbb0e4f4c33a7ad7493106126f20478dac717e218fd340c53f137cfc66a1624d6efad2ef232bbcf97699eb402a57cdcc344220a30acbe9c9272a1d7e706ac56e16965ec7a150b4396dfb2e3a668e953930b365977e42d4b424c920344a83b300195751f439f2470e04d2eb0bb43368efab817a7546d8999ba7720b2f7d2884164896d29530dee997c25868118d85b7e167050b1057b5414bda6e1b964d836a7db43b149f4c62b8f41c36b54eb6b5f84d40873bdd3d127f3da4f4c88ef4a9b8553810ec45cf35a5de576f144ae2be18c2377307c092173f4854adfa35f451b0397c73ce0d1870e9dece27ad6df43172daaa96a06ed7bf2362adf34120eba1ac36af7a0baa9207ce4fdec20e2e9042e34c5034a9eaf099487982537ea7231b7b34b6ee9e6c94689c52c21210a683cf35901ff6c464e2315c78d55c3151bd13cd51d1f64899529538a8a05e41708d67cb225d6114eb8d346a15d6ac111f42176e05c36e3b1a8e55b440b7c616198c5672e95ef014cdc702773602d02de5ab61faab12b4381cca2df8262594b224c48c4ffb5d6b8f412d8c7a7512259fd6f6afa9202f050332abeee87072a5bda60c537b39dea6c084fdefcf1cca8fe171fa7e1b32dfa297cfb48fdaf8ccb922a3b67db7a8d6f52fed0c0f721245785fa609e936c19d9ac263ce4cd19227d9a2776944809ee92dc86b85114eca9e36df55218aa6acd9acd02a6243f48a393c674931637b1bc6eee6c762ffc58c0882e385f5e0ec1317830818e514c2f655e846fcf0898b6d1cadb2d2bf1f24183a6f5667f2b25828c6ec4d949247a3117fbced64f3c72d10d912083707b69ed73c4c57450f2e381c1e284a94d3863f331525570a61da0ee844bc8b147cc8f1aa91292898cd26feb1e8148011a5e3d0cb09cd13fea05593c1ae426b45e302e0985540c814d938d78f6f5608e7c778ef47b8c3707e8ddd3b1ba38af3b0a631c79dd93cf8f0ef98e314e2448759a34ca4e6af97a37afa8dbeb4bea7d130bc244819e40eb8f31a6dc86d5692b239a1c672ae99d397ec8e903972e43306296671837ba2af0fac45c748181e6a249646b6d5639088f16239b745b9e1e2582897026c3c61980e2d43a9125d5ad0ff86c8fa7df4af97d2f8bc2a981f4b9e4cfc4b60cb01f940c97f85d233f349f8305ce1de51b090b790393652d15dd504e886fb1f7badeb32f922ef201e37591187391cde3efdc1282162b1494f37dd1b81184eb357284e31de8355195a6d2b83926f7728425c3eff6379ae960fbbff7373460a6e56d7a714d6497b8a062826d99f2336bb19c2742df84f1927928c9f4ac5190820a40a40c72464466cd9331aea0d2be15fb96add13da50631abcd95c02d48cb1fc66602dc45bc4aea10d29ef81fb16c211fd3d2d9467d6a1bdc70e3b85a0e2405788e26f5a09e7a2969602f5c669bb8fd969daead862d5a2bcd27603c4f8c196f0af0337a6f6da4f83968abf9f54e9d9384bd0c66ed87dd1d70b4fe66f5f32724de99dc048656232b28a9066201f228fae3e5a0bf5dd56dc8c280aa20f62a2c6b8a225ee08f3824cd93d64d33493f429cc90878fbc4d479544b182c8ba0fd927f74c632b2a1a5bf019e7c526ed67bf4cdb3eec80343f2ff7451214271bb90cc2d8ae165e392febe0ec6bd714cdf7ce78b960ea8f78613af46950de141a7f9c3444f8f1a694f176e3b958058105a8a9d81d9abe4c1c173bbf1294b7002424d93f956c10098be32bdf2ee2dbd2a312a1c6e7c0e56b624328b663406b7d392314d8d3d68f7176e78a5c4f8a17dca10e6d5b778cd3cd66d28445e5a5471029d28d44a68ecedab5b66c71fb0d238ece6b8e8edc1f8bae09da135fd4bd90ca897ff7e28e14c91188e631be8a7521ac93850eb9dc03d15455b11cb1e22f78313fbe8947560eb3f04c481141c445ca74cfd4ac8376122afd79831955a88747d4d01a2a270514664d03f13ec9a77255c21748f926ec7729383d048f051b861b41487f37d6d26984e70dceb2dc4500c248205aabee6437b733dc88b7cf74ac199cc8db090c88654a25bbd028dd03ccd2fd1e066e53fd4e4ed2e6d9847a978473ae7819e4869435e9375f68403ca51848dd9f9916a8a24368b4fdad83b32aecb19360c01c04b4b24b118ff68eba890045263a0ca67feff2d66a6302e1450dc4b84271db821d704a95a5e2054db14ab4bcb831d8256aeeca28592d88a050911093c98000a27936054e965b97e99e2e1a4bb367ce7f9d82f22ab834cfbe9afec0389641351dd1bfe53ea35bbbdab710ba6c9275c9ab1030aa1e933921ea89be4c51cc0c99a2763aa628a9e958c5317c953544411fca8ddd140450ac10c8c2f50ece8092e884a02752a6e74b76e153b4d578fed149b9edd338e47a604cc7833a482373fb251cbef4b9141fa3ab84105c22e1644e2cb0774bd049e0813360423e3c82c2325bd15c2148ef5c50635557d1440ac4b5850887459c2c53312544f91e129b29f1f8ea8790ff26d48380ae721a20d2a9194c5a39e54903434f38f4d62e78b2f2165192d7d27266a69687482904bdd5835dc5ecaa5127730932399e8babc4eb4619f94f76d575d699a6d3ea8dadec7790a733a6c97ea829a11a865bc92cff9a41876045914474c2a187280178119c095151ded114d7f15eb40d8f1b24bfcaf0d6718863db1ab9729679cc4d11100a495ccb8e09df8db25b752d39da428b97c58e1754dbd98e90052b248ba482686a90e211b35d3e271e9d75cb68aa9685eca953ae5c617866c14ae7d8a3e75008a84a5b0cf85885c038d3b49270124eb6a484b039ee5d172c9b45493b1a1d60039c3d9b92dc20475d85887e504b307121e22137157aedda7d6c31a2456cc751205dbf6addad3467d879dad27e5557984956fb32ca420a0205a433084cadcf8741850f349990156d6719603f20703f42aa9c8adf7822c724178a6a7edcc1d2a9337a3ab709a149a4838f3ba590bbd181c48932916fd410bcd523a5795fbe0e74447060dcd973b2161a2752c6a906eba24279720e4cf8643914163c24c82503294758f872f32927473c01b98ea6afe960a5d98bb090c0c9954474173fbc4c07be7a2d916523934d74607b4b6a14a89e4ddf41eb29958a61cb621d3b76a32e69faf36b5960bf829a8e2c118ef748089ea9e3abe223db32854b0b14e12f7146755f0b361f36a2c42dd8002ea214fb5a3191c7400f0be4d7b7a111715f6efb12def172d901ee0db97001165fe10ace305ffea941460b5882f8449c73bb74241021899759a68a3681101a11be22f2f23e25c52e00774fbe68973e6225419e8682a4dc82a23a856df4be899cbfff4e871c943bf06332113f95364010a93c1968cb5791989dd845f8e43b1daf9491df7da7e3f1aa0516eda484c3ef12b1bdb77e1c13d3149200ae9e675b55191c846e89010396d033998ba3ef87bed8e895a6d1b908f8756bfa950adab105e216015a76b0237e2c011041c4ffac818379e94bb0e78b0e7ae7dc1800c497650ba87d310e23b50b2663d2dbc2046dd044c170d381842b88743e9ed0a41a9b41336b609595c815602ecb36962ca59144a8a8de5b1c9b44dfd05c57c5871dd026bd549811693198e38b54940dc41ba31a47a33ee81108a9187d16e1db16f0c699d73a94b140f924bd0e0b39b51aa04448090b8507b3d07c20ecdc230d9b83dd63a9c911d950ce2325db947e520d7e0b684ce665cb308150c94367f403845102bfc7645e5f84d88ffed42e1866402a81e5c7e815fd7a5dd780b0da28d57bd75fa236b00304a46727306b018d1e5873f91440584c560f5c2e5baf22ee22a0279fc05c3e6b58604b50b4b2b381ae34c91353db993061809f94f4731728273810c2d0b70b50193493188cc6b5b394befa9094c829e859e6200c4c300ecfaa9a455bc48fc9d120e2fdb6e3379abe1f97d351034bddbf0dc5d0ca533afee1735f421bc02403a69c820c63e98b09db2b647fe703a65f3b9a9f8b3cf3624f5e365526d18a9a35b287d8c18c06661a63dd82b7b0730a5757775a242f46da7943ac6620046e57893f8ee1456c157a5c3af347316616b7a410446cf9b4154db04176d61a3a943722be3a126913d428961b08c97c36a101ca38e319876654c8270f872af00c6058df9f645afa9b9500715b3bf083d9133c50bfee500133285c6f8788a2884dba29fb09a4264adfd10553bf951891571d548fa47bd4ce244a68a448941aaea3d4ebeaa9e8fda5e363c4e4570c058c7b4c95cd85e0c6a0e5ecf1f32a7c863b073440c06e18e7800eaa94152ceef6379e36fab1861f1b40310362b948ee51a498a82bcacee7d200a81f9c92c62a101456d6d1a3d5c01cce60a155e5012c310a4461c5a949e263cb9eff11ec5872469078b1bbb45cf21cd91e2362e44d0682395190a7d61c7361ef8bbf5b4446e4678c8370ddd888b0616b13fef487405392c03a8d6160840a4d83bd1eab7125c057001baccd08b2ed65d97c102863d97c550c4e29461705146b000132f2fb40d2283d7332bd32c912bc68b69c9c00aa4e266b8a48c4d031b28809c0acfa21974572e31c595670faba1dc032d52354a340260ae6445204eccc7bc1899953951cb2f870470a605e6734a11c8fc77413a59f2c6328735693ce2dc23f966594a65eabee4c5510f84414159e59b7fe8fd587a10613284033720cf06c0d1b48922e1bf00480e06f682c4c9ef88f681f59e4f12008b828e64d4945f3c2ae431a761ca17ae0d23e85985a4d2e00aa83d4d12585831c4d5485659caddf588f3a1d211ebed43965f056875ca138a5d39b661da9994c417dcad0b9636ec739f8a6ce2153ae1de9284b9850a3b1dd4c1c281dd2c21d4ec32fa70c89015186a23c54723e76645263539f43229375e9d95125e44b8d53066f77b0678a522643aa9f4574746ca34f6a1c2ad1bcb1988fa4a6f8affc70b22873a0ea08a0aa0070321c93606a42cdb2adc4392cb541bc7833a9d4987764e8f4bc44d2b27510b5f1db819e624ac98346ac66a8c36b9f6398e9b59aea569d480887779a89c16608e7d03649756467dad4d48dc6b913c0e154ba3e31bb210db6c307a12591837a9ae4a5404a39eb4ca8f20dc54cc1297a1d57161209e0ef0d32730035fe9f6eac99df74ffb58a9f211d47d1b4176faa431d7ccf67a68332640ee53b229aa1245acf1b1d90ef585f9c258d838e263014cb907a3ae2e21347ad4cfd9c62f7df3e1d558ed6897368ac76472c449052ce220ae998b3e6cc39a7d97ceb86843923e42aa543c7d1b34e328789a0322d6c4ba740d6ba2a1c288ac8c9f8bef1755dfc09e620ca06d57f42d79e55c5e5d8760417bcac38fca229b26b59e63071d21ddd789165ce91382aa0eb48eb951c540867005ae80e95383323e2c9b1efb58c0ebe6b530ae689437a30c753d60f69fec745b6e3acfe8c87a73a32859ce978d7c42c70ac33214fbf0579eedd3dba75ec588a1759c2c1841487ad651db53463269111cedec0a1fb7b4c64223ddd009a7607e85c959982f059f0e8003beee19d5dce596972b025321e3f43131c032d0c95e6e4b9fcb5983ac2ba3aa91cde177594fb811ae2218abe003b80ff921cce2502b31a30faa4c88d45d4548123b49c270ec726d2a137b427cea1c15d1d469838a59c5b6c600b0192fc68c056657344ae8c8f354f27660a3cc1aa437674341f5ca973c86cc9f2cf63c5a6807987f08313f982fca9753d339638ec599ce3d63b65c4ec884e081cc408612d3dd6c0bd983a077967e0f94a74f06c90e31e40cdbd5f35b091303e082fa49cb3ad4d09cd65203ca8a12e993b4406daa470aab7117674be13e83d6a1df8a0cd5707e81b1233a1396a58c308115e4e33935e03a7007520e24b0e676c773ffa8d611dbe4f07c569904a697dd0e4dbc1c45b33e7308d0df7d5ccc48474719a9a43d66847971bd581c87d92396f0a1a263ca4e5ef629c15f6e6f345c91ad761382dece5f3504f629b648e33c13cbe711086bfb0324d703839743c31280b1df2413c93a498c138892939bf762894cfe409c8313986b36192fcd493646a4b84425b39e3349b1c1a24181f843769b2e374810e9307c1032b2ceed87bf43953e100e3eeb0371dedc901740b46e8612f8dcf138771590c9622a59c3546c1f0529acc7362cdb918567b1a9ca817b43f518ed80baa9e38872e66afa1388f39cea9c7e5180f554a38ca4b783de5d1ab872ef96073e2483983f1e952327aed503a9f119c1dc76730ac09d1f324e0e498c51d737e0dd73edf4c2578221200090c5086465092fbf6610a93f3f4ea4c10b358b5b0b434275f10177611e11f3d6d734e5d3e1f142632e1f460ebe7340fdcbd1ee69868876d4b320d23ea6decf7752735fdb1403a0c199ea631d4c9e8e3be35908a8c1ab23e10c66f6bd99826e44c3561b877a00b21a469e28b79cc1dc2d672fd4d03fd38944470101126e1d945de2eddc1a297ed1c44f604225528544346fbc7d75986fe3d5f0c9fd0ca3eceee67283308428b2a064440fd381c112902ff439acc1ad43034d861218c1f3f633a740019a8449d0f586bd0127ad2da5999b26369a86a951e51ae04896e1180377e3544132de3cd09e8c97221cf579418011571d916de611ece404ddf359c38ee51182490037246791453b560244512552812f546939d1a2232ae119ce70fb3d3d797ca494aa049d5348a69ba50c31683df693a18c9f7f45bf42a1cdece8b6545252666f823e7e5f3f8f7f8493ab362fac229231e680137709a5d281a2dd9ec666c780822551b3101540c63d7e80c5b13abbfb21b4a5762321eec6c71042f5add70682a33e5ac4d1c5c8754ae5f2bec57b1f7eba3f82bcb4d442e50a92b913ad8c13609a8a144747dabf61c141c886980197a5822619c9880fcb5ba7f6da589e6e7481cac5118c9433ce3fb07a4f807a2e3a2c0147e0463c6c52b45c8ef356221b3205f122eebebb97f677e6ae886e3ebd1967a30c5176dea31693c001bfd9a5af4dd61fe6e90e838c6422ad9fe9e7cdf39ceff4c70907633a78d0d18e6cfc69ebe8c8dad5f0ab445700922a2d052a5573c0d27b226a54b87e212ab50c9b46a9762d1101595d4aabde235545109b4a05dc5d35065a5d2527b45355451c9b4469b14434395a0145ab58fe268840a95d682b68a6baca292daa7ade269acb29448bbb68a6bacb252d1aa7d8a47835456226dd316c535968a4a6a491b289246a8acb4766987a21a476594d6aaada21aaaacf4b46a8be21aabac44edda2bae158f96dcc5ba102ff67b312785285c39d030f2f9175586836e170495c5677acf143650665a98fe74a174f17ee348effeacd601d8825b9f5f797d40c139bdf85210affb5278eb8a3b60300cdec89cf94523e60fa69be8913f8d6025c0c1f35a2adac9d320c63b499e5feaed67346e692ebbf9da454c57171406facd13eed1cdf3d059979c0d907b84e70a39b37191ec3b18e8af34ce4bec4b30c1ed91965fe4c2ca3d524171f6c7e99190347a06958b9bd4f4534fc7b58a054264aae87790b82586bebad398b4a4d1052fbe3fc7a675049c4d889827c70f587310d1386afa16a907bee764edc1813834f5096849d90728cbbe34454e642312245c75e11f9fe5616c956b7b9cc40a17cc08b53f040c1f2d7e963877e93822c20c4df90dba8dd4f19c70374582a30f1083fd2037e1c762fddc6e1bf121305092ec07b5e6c9e117488f957c46d83afd9222b560a106a17a15afc1ef25baca61791262582e27aff4f4afe55c1ea6bd1094ca3332bb6ea8b00ce3fc8ee05fe0656f413cdb3bffbbc699beb20c6684a5815e7a82705a2097b3db54692a4f612349e72e58489b0eea937b0a069323cbe31bb4a2b1b78043824bf2cbdea7936d42abe8cd8b2306830195556acace185497a0e03e7c8481d3dd025a6c5900209fbb4450287b6325476c59403a45983726674e8c6ee1970ecd92cd954fc5822728ece1f08e8ea937fb7e7dfef4971a744d90d20a0ab6e8f65d70effdbd355a2028469f53d7d6c941cd4fd9b04822a9db105c351ed8c48c4c61664a3619b69d18e5c660b3b817fb98ded2ebad2c81994a2594e62ec25cf12da1907965c6c3f0dbb5fdb44b203884e9aa379d4a8e83848445fe7ea9fb436e79ad36621b4c25bee731ee0f1f91f697acd9664d9fe8325991e6670b1e57599e7b4654dafea9ddaf60722c425d32cf6435d28123c134895604366622b750142bb010efa8b2cf01d54b6801e492696b57aae7b753a1d31869992061ef33b9fa5e31cb6192a6d20f54242ad324e318d53e7f025bf97990e89eeba50557f69403a6328fe079936b1c566250a40f68d6a20e483fc8dfcd89538230a810e121841f86ccd5142ef6c89c544a6dcfe2257c90e4eb4fd484ec707cfcd811776ca5184f852b78b8d86d5b248613a3f86a7201c4285ce0abd2e8359fb92f766835ecc8106b3e090168a4b8f831c49c58259eed68a28fe74402355f068a4f1c788909ac0a7f72dcdf5634ded31673f24545087ce112eba0b4adb8b50f8e687103b274bc56b1c9b34b9eecf80f83c5a4674d1ac692815b62dc54a56833ed69710412931e68bc682c7e24183779a5ae9bae4aef9d873e25aa5a32501e74264e590a144e059ecea05d1388e43853982b333c76d701da8059d025a070e0441b1dce024cbc6378f0f830e70b0b048c505ac5e1799ff54e0be08861f87f5fa1fe0538e07648b5d63f189be7228b9029fdf11fa07f4fbc84fb4706a2ae094b864f55d9ff23f7cf14f78f6b58da54fbf7f78f52733f6646aef6c8a9c36c90eca03ed42c4dbe8a3a8e0eea5e07a428240301a10ed12f16111e6af8fb45e668556439879c21edd0c9f3ecac4bce0654e49df82a558f19abff7caebf7ae9ace61b3bdf0d5719494e79c2e0828b6270e37b3aebf409339a7067a4e1e93a34e6ce5b47efcca92db76a58d3f64883c645c2f884d6ec575e9238ed970e94e1da421e0464bc8efb9e05afc528421299e085a4b863c701a0a109f6bb54fab33bbec0451549488e04a9f5e256d33471d3d83fa98b268ebd20276c453d129adfc12ff3ef44a625973e0c136dca501c10353fba15309e2589aa396e71396c680eeb1a80399146c661ca8e66aabc655238075ca9c955ba959cd4757d8952cb5073da195a6a42d82dc7eb41d8872320a9b82687a102831c0b24e744022425c30eec6152cfe2a979dad38568bddc8f1334b2a4f63dd4c0b135ae1d8b0c12a7cc48415764f230ec3db7571760a24525e4aa1b8dfe6712d1a01615e01dd1ce9b2c8dc7d48f38aa121e123162fa03ad604dbdb957d7d7aa9bbc4f2ab353d1df959a1b42205c8a2cb748ddf848f5778b26c93ca43bb71946971a19ddaa5b829a9a0f1b9cb6aa1533c8f74ba2e9b3f28f5018fd7e9dba2e218f8308591ab14d773d1326b97bec11478fdf1237ff1f90f3dcf7cbd1c50ffc39181016a3f39a3f524f0fdddbc96b4556421a18c8e7efdcf39dd9ee541871ffd7ebc0cac48501eb305bf9eabf0d8c5c103a4c2ca8ee971fae9c6e914955ed38d38291f288187effafb4da09f66a05fbead543b93730f4a257ed2d283f8affa15be5315d3a9b11b2d000f9e6ef36d5eaa27aea274ba3ed3a1bb7062456d13e7c391902db756ad1e873a85ac4769da5099cac234214fccaa19a114ed62404e5d51a188b17e93629068dd6e4f684e8014ece2da129f2a2229fe1fe05e82950d42b2e25fbefec027ca303ea3fbba15930d815351d7db58fcd4777cb359b5a6ccc93d244f95140c5ec4a39a27f5b8dba29db513eb6663eefe99ae39eee3110148f5f38e017437893fed5a95a73c515430e060762a3ef22dd1b2262cdb6915e6ab4d44484ecbdf7de01d209cd09e3099fe761f7d8c52e8661d8c56e3f61b7340eb3acd18809af6f5a0b65fc106e2c12e5b0ead08d5779955775f6d06bafb15ce1e8dd780d446637c0265861d7ba75ccb2ac1f6d8f75554f4d160c7ff030a350a2b22c0ba75ad6fdf1e3c70f9c8a53592ccbb22c105429515555555555857f5478db8e4faa2a8cf12cfd08d42b1856f121105dc94f15586f2d1f5695e30c01ce0c41104a4a26204147dd452b5fb9ff0ef20ec2bf8eaf1dc360e8da75dd0b7de3ae631fd9b1b0621af61018668fbfe73088dde363f8da750c864034fe76e590e4233b7671b926dbaec706a2b767d885dd63d9e69ecb36deaf0d0c71c699bd72cdbb3eb31a2fd7595ac9b72090a8bba813498cba1728ba869d1275a2db53228c8946a23c9aa35fe068dbb66dc3b790d82e7196d7ae665996951d9b370b12e2ccb9f1c872383bbb770d0cab30048d2fd2ce95b8d003347b7710774d3b3e77bbcf6c87ecee19181b04dae0ccee3210d9dbc3eb63caacc7f6ed38e606661b770cd2ac463b97439c996dda05b3157105048e1cc9ecc8cc959ab16e2b1f386d4fd557d34b587bba4d659b6f2e4e87f137b7878e429258a05f1e4bf70bdc30cebe75f8f7fe02312c93ba5cc36d97f68ce5d8053596e39858bbbae3be9fb21cae6ff771ce90483eb86bf85b0e4958aed1f063e3f4f67b1cf48221a7b11c83217e976f6e6b2cd7b20dcbb16cb3727cc372e5f0e662ec79214f7a57f37edd90e7fdba9a775d202f832e10746dc7f8c2f815882375e07b2b89eced6e97df360b5b96750b0c31cbc260b78121ce0ce92430ce176dc3d7b26fe0c596758fc1f036becc7c6cbfb8c398fb056956b39dc3e0ec8bef2cdddcc6b215f18773731b88fce6bd028c3640471e259c34b681d32918e22963ab190a8c971618feb04e5dd6faaaba3d458fed901787205d553c74882373c84387f138b5e7a70ff930c844c2115ee8a0ef5ff6d1452b1771bf18076ab740cc715fd18e73e8036e20a4c68e3f653e38d2967108d218c73dce123e3e778bbb0666ef3890cb8e6372f796f61f5658917008827f3d10a4bbfc81197acb24ec36ddb763ddb777dd8fd296c31f7d1f6edc6d760318de6bf9c610ec233b976db277d966e538cb7196be5b2bdcca17ba3d97c391488471e8a0d04121103e778c0b8140a07b6e03e1df73211008ff6e206c79a0ec79b7408fe3388ee3b85b47745c87751d083a16330c863f1a778f3387150b58b1706701e37cc98ec110a73608f40e040281405d0702677320d03178cf8134bb2136fec5bfc7e7b88ed4bde38ecfe5ec3867df7275f9f1d338948ea646030c2b51f004589c342cd9e6ab485f1f2f41242d5b360f154edabee61a9a230f1545e48c536b99a5298d60edd460a2458d26509a38e9c8d30449131a341162024e9c28e9e804074e8ae4093011e3aa22bf60a2042895144f903c29f26448532ed02f2ad791e709292d431d799e88a2650c83905a2c81a406940ac49d22157032a4893174edd8c4147aeac8d384cf04982c61b244d5918991f03229c192315a660d28310625c4806275e461528426a434d1d391a789271d7f3bf23491448b3af2345164ca8e3c4dbe703bf2348182d691a709959627d5cca69f4dc3207a469898a515180d33c0a478dbb44931479e26433af234a101a36106184ac753e145c708f358c2e2b3314827c270028c8e3c4e50e171e208ad5101d23003bc75e471a2c9125c471e278800693082234f13439c9841471e2644789a64a1411d799c30414f90061be0c8b304145b4658bfd09187c9918e4eb4e0c4a7e56f8c9346aa99f02cc51ca79c4e58a208cf1242980037114647908612e0c83305121a8e60f95901248cf4bc54d2d3e5312ce5ad53042d3f451a616a0ee58e6c23e594c1363dba906a70fc0dd27696e25bb88a9215455594ac2c66abcaaa6e5355f6ba95eb2c55d176756a53e52a47994813695b1b8fd5906a483daa10216d6fb34d6d27364e1c3b5a4a594b29a594524a29a52ca5b4c63a59ea8c2a78dece8723685aa9f909b46d7b3e48e398d16709867d53c652dbf4413a08693e48cf790a09224dbd5a6c633f3326f598b7e365e645d0f51418daae52b69c28d26cd91166aacf3635936a4ef3176492f30b58740963b4955a4b0990337778408690238cd8aa248c4cb6e83065c23b4d7566013e2e4ba4f8e921974e105ad0538918ddf5fc0d49a4e8790a4cb62a81d228681e29aaf41cd2594d155282b69d632cc9d70823734877d04caaa9a739d0fc5914609bf6edf8b684c12abe54c7e18fade76b0868569381b5e36c0d94b184dd8e20cbd7310b9c7d412d96eabb0e745653fb928d55324eaa59398b3055bb72f8c314e9d46e84a11da74c95c3cc033dab58aa17a76bac4200c658aa973107318364b34ef6e1344d939d2ab6f636e1279bf309350a990d37623c32923019420b2ee89c33e899f5a4f10958f84009268a3001134b3e40c4105198e2444a136070022d8cc05a340155602d2fa865851648e8392df92448321a2421c20441861421c30a24453479828903bc68a284245c51841046984008b58a013051eb87a30ab6e2f8a83160f55416b4ea8465c51426b57289008e1baa2430a84986f0c8e80a060c075cb4e504b7ec696c6635317301479e24aaf490b2573ec2c2eff72c67b1b1ae6116183a063779eb495b2729e149c2488715bd37ab3134fdc5a61bb31ad1b71cfaf006c2d2a16f9f321fda2deb180cdf18630cca3804e9d076ebd8ba080cb9c7e3f01d741cd37acc2420fb3b8e69653c653984aedd02431e72c0df382efc9a844390e6be81be5df3409006e50fccd05c0e79e8eddab94fb7d90dd90db2bf6b60a83d946f0cc15ac6b1dfad6cf31d946d48b7c050cb38b63f9c431cdba4c7d3ac87ac21e5db5b3964799d25962d87958f1eb31c563e02c3207ab41d1fc3a0c4a66b81a3cb2c87503be6a1b94f590e94b6cc72087168afe490043dbafd94ed983dba05ce8e590edbb51fcde5d01e87f628acb3847197c3203dcaddad0576db96b70ddc7e813852c78653db3a8f4bbbe504937660afbe1dbb96493512e7f06a0c8336585673f5761e2590348d8e3c498cd198cc72c05e5560886997af789220d2f56e60772c66a01c0669d039307c73d7c09087d630cee10ca12d8733cc98010000b4b490482c2c2b2bdf371a8944a190e781405dc771186f9ba665d9bd18765d96351ae550288795e82145c372d263a4093db434a37fa41c4e8dbf7296951c4ebd5d44f5166bf8441f8131c28872581b3f641b3f4699d0710ebd6ba52d87f7dc71500e8cd7c0e95ef77b10084476f79ad5cceebef590ef5ee5107bd781dab198f1e8ba6bdf407c99e110643bde8e8376e0ec2dce99edd872780c72a7f85cc64137703606c3bb039cd9c377f6d6b20d76f99bab475c85e7a163f5699c5a135a915e11ec3b8e1583d571458201b3d87ef6b664694cdbccd7db87310cc091084ef0e9ba63bed6f026a6671803cba634c68ad64430ba0699723e115f4f1fc6673ee26d6a354b51043b020dba771cb302ab59f25ebac62cf574ffd7ddf19c893970749758cc52cf94e91e1fb10eb4a4ec4048e78e528cf0a2bb7b5276b0d34bda3b280a2ad875af4c4795fb13da3146da95190ffb7ab780bb87b569bed6171803c9d06f0573dd3d46ebd35dc619eb335fe8bbc74813bbcbe14da9bd5b2c66a9cb568a972d9504bc00dbd0316427e005d8a63b8e6cefdccac3efa1631c483df4854052880349a1d04bcdfd0b712bdc6328143a3db77212275a59f9775196e958f97248e242540c3ac62c851e230d772c0452ef4011e8f10087b803495d0824759f4eea5eead04521a9cb3d4a1dca3ec89f0e7d76bf11e24e0add13dd0371a683eb51ea1a7d83ca3827b51a15a3fb468ad1ddab59ea32cb113c11c9d39059a2d6a77d74f75e653dba7bddbdee1ec80375ddbb5cc307770f6918deab7ba0ec1867282fe20b7dc572045b2f6669f2e11d742aebe11d2465073a32946f80a41ea5f6eee51ab344bb2e5b2e64a6c3e289305566418930f4d6137048c3687aecb678ddddee1e51301373745d9d8d6fb9a85d9ea357907bcc3c2aa7614c99d0e9e9cf94019df2628e8280bb8794179de8f4f72310ebc0d822b08e5e5b66a251be297577289166366e6c6aa1f7cc76d80e51e949083825600638f4eee1e4c594199d9ef299322091f5243b865d1c74c67a425fe8285b5066895a3d4fa8c87ad2f4561370287739f4de1df3c01db26384e93c50ee727871d0cacbc0d0bb9417f4170dc3f6340d2d284d4fe152877847ac5129a633f2b11dc3984903311e6fecb3fa2c61b9ce2c46203ed0329401c78c691a73e3060af07013822139479438d9c162824398b8f32ef3174adf4f3960d335d0663d6e76896db3cafa20fb07ea3c64d74c479663ac219c2e7b90a0a7bbcc1ed854556c660b663d1e7a19b602872d2e5366cafc590222bb9e4acfd72a5d66890ac149cf57c7ecad590dae2e7f812110224488109ae9b0b20f2e2f1146d6d30849d0d576cd2519e0b085cecb1f0a0b47d4faf821c1f218adb304f49336e437040e6fd7fa2fd24cabdde9b54e4064cf3a8110801c9490830230f0b5b5d65a5b596badb50fab0a0c8358c7e8344de7117bcaa4fb5b3fd107e9098655085a464a9e0283b404716863d5afeac62ccd1ad4f439ed0df8c3d229f02ca94245f2f8e0c7880b9afebb98de3ed23a5588fe2e5e427b7c751fe2ef160f7446cb77bed067557531c6beef2f7578633abc3111869ec222f6fc05260e2dc91ceabdd8d3d3ab89478cbcf9616bfc0087b71700062c4f811be86196e4a720d3b448c0a2cbc436d8f0cd92f7d539132383035c1fd2681ad9661b66a9c67ca1efc135a08043dcf4d5b51c9ea52a8568f9fab08a52a820a594720adf176343cc9472ce3967cc174d964ce10116910994a66f91599058f8a68f2aa4043d1f331db347fd626c988291efbb2102441889b13d6548f2d3e3ebf448675774669a0d981ead0823237d99606d3a2911df7743045ac0021eb1ab08231f6178d8000bbe1f375f12392be839e7ac5366d64aa4e7affc9c73d630018ef432e690fa908f92884cfc2cc5cc25e69cb3e79b52ce395f4139e79c3ddf7703c71354baa5e3941f50e922845415e88c51531073238dc5e88d3092021798a5990516731770e4f181922675e4f18110adc50d96e8f01db694a64f528b1b2019c3563dba4c3a922c200a8e5ac040888e53ae3042a21e730c618222518f0d4a8a8ab314c19659b2b7c06f966c0fc2e8d2741a7326e6987a20a4a7bb8440340592b087a4eb714a1417c9ab40ac6386d1cf994957b6724dbd8dbcf5fc81b3ab08335b92a1a97c234cfc8e1418461f1f863834cbfc9a6dece96db69997cfc186e63b03175806b152ca20f20092018e05439c268a9aa8896e21e25bd528708d914ac41aadcd3fd418f315530de3eda7fb1a6305a2ab598ab4484c4c5b3c957468aaaa30febe7f9aa8c77016365559cb21cef2bdc25253f43131417462743a526dd625315090460fb19c4574ecdf8741dfc0bb7263f540bf31bd599bb5599bb56d99d481ee350f0c3bd141220d74acc3d52ccdd22ccdd2320987ee37a6d374e8fb5087c6c79de81824ba956d4407659b955b37316dfdc6b48825a657565846d8f78d1e1a3d340add6377140a852e0edd51288443f792429944ba05922e14f75eee17dcc05087de56fe3d5291477aa4332d67f9441e2987a5de58f24a0eab2fdf52dfe3fb1630d2979b7de3388ee338eede1cc670dc05efef7d4c4c8c0e31312b737381d7f5d8ad3e6198f599f1b8ae1efab2c0f0a6af5fc7286b9f596bf1c02c9e5e4f6c03ec09c5aa25fa9e651dc8b160dc794036e8dd3730f47adbb60dd4ede0eebd3bf62c101f04cac6413bd07a080c419dd759ddb7ae3b668124cbc33656f6a1668777d063631f9e9541214803c3ee5c976f3c2fdbb0dc0a3b168bc566994824da8e6da2ea5ae0edbe55b7fb26ca2109aadb6977bb14638c69a60377b79e74210decc0f0a63b0f7ba0e8dd3d0f77e0745128f4183aae09858e85402d14c2203667c6637bf7d8e110381b87c0d998bc9803bd7760e875778c66351c8fcd036756b31dd47512a3590df7cd9ba5ec33abc15bce5eb29a1596bc32100d442565173fb82cf734ee1a4b6d2000e8109769cf404cd4751c0e411a9b97078274963f304363f9eab8ae63e958583cef5ed005dd7b2fe8de7b7ff0c9ac8ac7eaca53557ddfe5a55d37cb21b6e8748db2386ce3a04e6ebdd32545dd6aa2c7eaaf1e9a6459d3ab4f144e0f979c549a0032c3cde5389c9b7b73ab1ce234de728873736feecdbdb94d5c9c5a9bbbb9f756158e2fc2e610b142645b5d663e58aa1c7ec0a7439bd35688b667b19fec077c6c4e4f4a4e1dd81c269677d0e8a3958b1efa1ebad9ef475fdd586fac36c707760d5fcbdbc5b4156d45bb99087e2e766dbb160211fc60da4aa6ad5ccb36dfc11b9bb392e32c8d7ef3f7e52a0a8540de411ec8038140200f0402812eb063c26d78c3a71cc7711cc7d91c8eb339a125d29791b6399b1211fc009136e72681b55cd834dd69879e5ed9dfecf419e535455d5c76b87109f28472e183955ba07fd933ec2cbf97bbf6ed98068abe81d81b1d8bb86b3e420f5d7afbb66d9924ca35a1dc69c7dfac8fc050b3b07716761cd3e2be897668ebd3ff7d56e85c0e493eba6b5c28d774b87768ac81217751be31047319c3de651b4f036f5c9acb372e9db9b4e76520967b3fd03fd007fabe8fd33e0ef47d9cf6e1952fafacdc02577c803b97d6ce81e10ecd61fc6dc3a36d964239fc426ff48ff4e510634ce21e3a498be75c1af4fb0e040281402010e7c28140dd39307469aee3389759ba71893d3bb83410a92521f4aa631318ad9ba6a8897a58855e53f6168df3945581d1ebb03edf7817b8f12e30cb60625a58f7ef5e764f3bc63430742b0332438734af2d4bfb6671178121e8f138740f1dc7e4bae39898b3b0a6817ee38537bd3dbc697c7c2d04715dc86bae3b976dba87b24d767ce335bef1bab37278e37586b3fb374934ee2d8c089134682861d0f43489a648ccf8029ee7d9424987373a47556d4e42b5cc5255e5d01eaae30e4f15213e5620b174ac8082a70ac5011a1c818216b66881155beca0c20453a01c39c28a9c16ec442ea24b3883a7fcc809ae11664405d6f29b6949cb579a5855f983555306c8d43631ced76889a599c71882818ad691070c5084b47cace88c05312ffcd8c8a2c94e0e0bc61cf32dd2c67c4ba42d32d491083f394d5b5afe842d60276b908f939b955e8759ab2545ca2555446929ab9f2a9ad0f237aa70d252d492278c962de52b9d3cc8aee5e53df96f03554987318ca69db441067699a5cf927caca4102b84b581c5e20aa3282dac433ce7d4821659d02eaaa0b47872c1cc1c2d96c82f6871c4fcd1c2c8125ab0a0046570c1942f542153aa30a130850953880072a901f69a9056c037099562ca111c4c21b253860ebe5ba046606c0a3507d86a027545472a8194287c70edc823e5892af86202d3191c5276d0f3eae922068e1b9020c508195256808f3086cc3301be3f96089c45810b1823e1047824c51438f30135824147a2806f479e23e43881b18e3c4740811163741877309e3335078f11b030e7bd4f0c3c271503775dcc2f30a867a200af74e431820f98c055471e2324c1027b1d798c308465628414d8200c4db0a8234f1651685a250b23c830e0ac234f1654d84a31fe2e3bf2649193c50e1aebc893c50fb01774ce2984b1278c52c4e83072d1b3c318c62a3d1fc3f8e3852bf47cade6f1ec42164d92c0852490d173eee052479e2458d15d479e2430e9b0d4720a0256c510dc91878afa796b8cf45345638c31de070ac6ae401f6453333fe24b7d55615c2f730f3f1bf891f5b1a9fcdc72f335c1a1cb75a131656ec49e793d05768855e650e1a4b94f0cc60bd8669e7b381f3979d00e180d7ae818bda26358ac140855fa47cc41f1004188a67e13779acb5808041dcb34ed755ed37a98b392421021d23d8c5566de4006eec043f4623e7e870d4c590f79d06d56330fca61e893e374d86330d45e55555561523b76ee14d3810fb2f1830fb20cdd1da7eaecb3b9cbb6e17ec0a12830e9602370c32c5187008e1a3766897a07fef0c30f38d4659e47ec4fb6581ab579c42ecd12f51f70a8e611db8659a28e33358fd831b344fddb01a697427c8834a41aefd77fe0a80e27d274b7e1ee9d3a1053c68720da3bf51e7efc0391a6026384c97c90ed1df706cea0b5774debf7063a60467b9f31a3b1b9530621bd81728ae640524d03da7b031a00ba6c127eedd93866a681f72270486b17a3e52b2abd1def40e9edd8b2ae088c8ddfdd63a4321d5a85bbdbc3fd94e9b85556331d7b95f190b2b1eb62b963ebeba0abcb203094f8af321f5aaeb3c4e1eb203036d781365cbef1baba55c5b617c885f28eedf37426e6a0626aec34454901f13dd0661e3f03c3f92c87797c0f8c8d6559a663d2ee957be783bb4d17bdd861ca70ffbeaacadcb95c45fa1d847873f9c72c51ef6196a883c09b59a26efd60eab88739837fbc663db6e32973ee4d9de3bee6e20b75ee35d3c1bd31ed5e0a02efad2aee759660c880b9c70c8c8d4fb34a02f1e89e3528936a40df0eca37def60c0431d8012bdf78ed7594a7b28dcc59a96272818e131f9894725e1e7144b5a1b5f4f636f649aa9c2b9da17c484fc1195530adb99a39acba7e43e0d0abd1fb6676438cb581b8d43aab902210a1e70a833c1dc21424cdd271085388f4344d8f34f37896e469750a62d3bafc607164cfcfd054386a6a6bea31d2d028136dc821b28628a57c4f9743aee51bd2868c35d06fa77206d638b3e56abed0e3ed56fe70a6539ea8cb50e6c852173075692379983232d4bfcb929743a48d1bb186e9d38da6333cd097e9d8f4499bee844db7998fe75839c432875f6b43e0500ed141c5a672946d2d185b4ae9c346fe86f3f6d84e76b2d3c4036529394dd3344d533555d574cb0b8ab21813739e92d65a9f9739a43209c2d9d4319943971f2c1cd91b86c12d0c2995a7f236f446cb832dff83ce70dda78cf77086a6a3a634cac8831edad35318637c7b23c25810c72cd97ff635b4dbaccb21cecee5b0d20ecae15c1902ae977da32d183f220dbdb541a4a9a4eef792d4651ab3849db3e740394d33ccd013a5d669a66ceb07d91af883cc6e5c5aa7cc7c583feb9cf5d347b599bf130ce7ebf4b0d66aed8db6b7395219a936e72d9e33c080a987f752d9eb0293483b644f124b8c0818b5bed67a716500266588e3388ee3388ee338ee21eea1d045a18bb887442bf2de0e8542215128862bcd3d468ee3b81017e28e233b74969687a48f8eb180f523d208248d5840d2e8d9ebe8a5663969c4d2c2321a8d4ecfd27212cbd7d272d2bf16520e492ca310370abf73c746603df791b81148e29ebd722ff5e81f3762197dde18b19c340ab1b0fc7b8865c4711cc7719c887b887b887b887b48141271dc392e74fb90b5acb55ce8a2d045a18b42178d44a350e8218ebb577a6038dbbbe5029f72d103571eb3d0a99168b2268efb4e57408c03637f2bdf0ac78db86c548d44dc472ba2cfb2ae63da8ae87e5cb6099dfb2887a18b42a2635dc771f6a2c9711cc771b143a173222b0a711cc7715c088c2d334e046e0f5d0456b09a259cc399edc08fdca9e7c3813a30786b555193ad2cf243028b2e312b818a1158344d472946e434566fb4f5b1466babb5350139f5d3e76ba4a13e6f230dfd3c46c1d0c7743a9d560a02a141639664a4f9813e244552cc3d4a1d1f63027880e549f4f21124c947fa529368ee5192208d08232fabcc523c46c9382765b549095855cd27c13857555555aad241cde9558c29864861a45d3af244214683d1b163bd4505bb2d4d5bea6b0eaf3feb31f520415f40aace7e81c69e813f64b7b7c00a86a5b642db73c395f900dbe64a67aaf8523fe73f4197995b4e65c4412d50767653eaec98cc326b3f1f4eff2cb97cf2616f33bd6596680b3659d6ad7f965cc080af872d2d5776e9024f3e128c7b0cbc3e8124d28eae2d1b0c2adb3125600538ac78ca84d3f1f43adda6965a28b52a18ce67bf6e419bec36f3d6e763eab14ca34a582ac5c86c47867d081c9666dbd3c79e321dd556ff9ec06a8136d97164d76aba0df61a69aad387228d657d3a0656a06c2af3516f61f35a56f67a51915c58991090b4348f108e34bd13f89e998ef90adad8e3489becd63530cc7cd8ae676095f9b05e2f45074a5baf35fa20dbbe564064db7cbb5b755449a795d16ad904d92047da881da55032efc475beccd31ba58d29a4caa5157a3ea43bf4653eda9055640df3f4314b9f590263677ece9e9eb8ee5469434698f970cecb1861e6bf2ee050eec81d2834d341a78cbd4f5699a518299e3465514a2b3d26d294079eeafc4613525985bed06a630a216ba03fcd7c54a13371ca2a5bae32abf4f56b66b91361e8bf2ee0e9a1dcc97484419a5ee00fb2432977aa96f537a5ae973e3db6ae5956a197c7606dacca3873aa26603a4d8fc52e26945e74e7457590f7aeebba2084e82e0822dd55606c0ff42188a654024d2842b564903f5d14810954655dd3540645259d2a50e6a860b572d02108f0522a23084654936549894419558fb5d6d6cb4ad97a49d14b5ad56a6dad954ed9563bc554556b4d54adae9b651986651986dd9b6598766f96699605338368eb12b380ccb67ed06e05a2ad4bcbca32966cdf11b47569dd1ccabe412e2bd7aa9261a2c8602995d2522aa595d2c2809a7a7a7a7c965c4fc8a0c4da08455a2ba14c5ae544414f4fcf8744b593cc31f5c81e9a230893053b3d3d3d6550197078270a3d3b344062270a654cd38e163d3d3d65c81995094b8ac9d65ae7ac754e6b6b9d94b595921588a6b464e5a56de5a4d49c249db3da3aa5a8769ac8607b6a0fa5734a2ab35a6a42820a151dab4a8f9049c78641a61e2dbb2e7695815992baacac196d5519f76c3d5ae6737bae698770d1450569f40a27e9253d8e59a5ac524a599590842da820410a1e2da650144549a1aa8aaa2caba2c4f0024549a9435152ea1c81a27a8c90054549890416574429420f1186c053061429abb0a20a2a76a6a0282975284a4a1d29254549a963bd294c5475f04969c913cb87c2757b82002fa55aa3d0c2e6ccf8e960ebc6194af30d9efc81186ea02ff35585f1f77d3d4b1d7e58df10613c27ea9099a7eb5595003c5db68eeb32ac5e6769aa3909d76b9603f5eb545653bdaa8f6d7d663aac9f663535b75419e76aba55f52aab996ea7471dd4e96b563365175bb39f46c9a25475ad924843452a688eb5f39ad62c9576e8e9a74fd4a95339b48f3dbdc6669b4a6bccd27c8d9d2a056ca22425e716949294a45b54fb7a99e9f2b57e0a73359f881225cad7449da84ae6a8a25039a6a4514c2868ad94aaa629aa19859a51a61965523154b04e5a0587372997525a44d630291623b688b4711d3952a4c3ebb7de663aee8ecba2b69d6d67ca40993317924b67fa946f75d9ebba8e481bd7755d53e848c1647d429da8a9fe808be9554551d3147688e9554529ad13358981fad463d241659cab2986d0b02448635b58ab8d12258aa5e08ca6b4a729388309d6e5a90f4acb07450598b4af6769c92175e80b14585234ca446b963a45d469b255fd811429366b3a1617b334a969b216154b8ae56349e979cbc70263ce5862583f350a810ad2d8bc94d689f3a1958b520c93bdb54666c9ee9832ce95453267ac93f932bfc40b4cefd12476e6a4b45659ad2ae6c26e9fec98a1ad2a11663ec4052cca15c53e81d2838595b2f30596f354941d3bab902b08d532c15237461a1ad62d101198aa24a806581ec794220a28b03c109e64da14da8693b89ec0f2d70f3ad0344d9313206fa2a889aa2a6a1ac30b7121249a26298d108da6494a23464e5658a6294a13571300cc9826299b98c164890f7ac0c4b50496bf9410c000921840490c252408500029a12849c283eb082c7f218939c0344969c40110304d521a810029e53449694402284d0002aa3a432f2082181dbe481159a4d229bd6004118ad07c2c91485359d7b12f2802d4d0118bc1173e32c7c7ce68cc02650eec8a39341f6a0302bc943c9d2596c8159730808e3f3d4fc595b3fdece4e45c3b50d81c9d24d79319651e104bf3a12d22836396a6113a63f57c9c17672e0174fcd54367ae7c434bcf0d9717e1d5c5d545ecb13d750c793a1363a4e14b6881aecf6aac0641d71aabebabf882e38bfdfc03a6cfe398626c0d2823a6597bf9582858a4c997fe98bc2e39c9ebba9c342965fe4193d3e595da7527994d59f6e9fa744c6ac76a56a7fc839655206a96652c65d7a74b3b5659d74e3ad9aaf9405bcb31c264d9bd998eabda2b6b9db552959a6cae6eb02d51b2042e4a208ebf653209b9acea0bcbe45a3209f1b9965c4f2e27d7926d0965029399b2eb9c096ff6aaf488802546694f167c1d3195530ef1c588dacbe2cba4a7b965b6b4dc68e969c346a4895132c13b4fe88ceda133d4131dbe803a1ecbc941813849455faad3979aa3d2251d5a1fccfa4081f1ce84418c928eb73a54d429a79b281b73ed5031850a3c4d760b5376746ad67e762aa535e0f0b65329ef03753c176dd82134f25345817688b47109216b10a2e7af21db93599ab2023727524ab92db972b6253d7fe5d0990dc986e4cad9906c487afe08112345849036ae180cf1829c08339fb311814597d0e35191540f2d113638a29363640302754c045b233606b6489cf19ed82356e742226b7842672e25f3e542d2f3d5a5c47b7229f1b0f0b09832a177857745a489da1236205c4a30112a6b5c5093936bc9b5c48544dab890b894b8787029893097124f4aadf2f95899f1a84d5f1de918da213adec620dab02f9035cc2253a61a99329648a4c9b1320042cbfa4487f68bf69654e979fb0269633b226b989fdb919ea7ec0b7a82a6c860f39680e2444d433adc96e8b929d9901c9136b622b61d6c39e849f3a6136144546c3a9f0f558235d245e8893493555196cf8c5e525f67d4dad3b38945759c94522927a5524e4ae5a4544a2babcd3296ec08ac8fda95d603995d5fa949ce20a6692b10d3479d35d6479d689c744e5660729a1e5d5ee6e807cb4fb6d6183ae512b0e8126a3f3d31fb58a74c4e3abcd55a3f32d79d9e9f3fb3340f002b7068f9583e5326b4a85854b422ac1fab33654dc7fab1aa5860583ed64fcf1f3a6351b1a8583f16158b8af683824ba7da9c486325151d5f77a64c992d2913669aea7423b36473b4456c0d2fc0a1d5b13a74c60e19d2f3432a2943746618979c3095a0cd744c60b5998e69929395b740eb449afb78ab84ce6c8fb74bac13fb64ca58bb430f30a5e3ab9448833dd2d0cef0113ab4bee8f9f0003ded12213da3b16cf94498f91964c8087351d5a919e5d46284b93ea363a6ea2c51f10abc8176097d999f402b85ddb1506c0f7da9a169b64f9e806506966e5790d3f3980eb0a40680011122f7820606a4d131862b54684530035d0fda4853808e91523a83e8e95e39c0f25e38c0f25e47b07c2402cbc71b6079031095206a2bc50b428c342e1a0d970dee6504cb1869deb106b6815e35e066e8f89797172b26ce5856b652e8cb7ce919c69deb618db652ae9faf5fda72314ba12c74a0193020426486d017401e00bc50cb5744a421f54583d1773b7e3e6649307db902cb87f89ac1ca8d9166d4f118cbbd8a905a4200b002872ead05194668e8f9791a224dcb8d91c6eb780c00f71a62c6bd6430c3bd62f07be580f78241bed70b68b8970b5c027093e8e818b9840800a6820e5f64c730a6a7900ead94eb67465f4222cc0c32b001dcab05a5970b7e43c0f2d8cbbd5840807bada000f72242e35e2a80b9570ab0016a9835c4c4dc1869684c572f9146bc7ee84c95ad94f9323f6de8eba7a57c451ce0c64813d3f1d801626a30000c8d0210e0a534000104c085860c7e8619006821b1ac7c2351c803751cdeb42c468b1166ca38679ade1562a294b79239ac189d94de8ac62a2406188b2bf4dce2d5266f7c42cbd729735bbe92c7f29f7c89cec49d181b8434b5a2e91556343da658c8c0003f39825039a39055cce98b8caf55462c70c0a485d099185aba92c61cd5eb19258af77cd545cfbb030f37042992839e2e9c20c9154a00458e2a34e16304118e18a3092ce450a2e915468e343d04aa2a0b38fc67149d9e3d67bd52da15e059a2d81481784395050e5d9a7a323527a14e71cc22bd024f11a874e42902940574e4290291c65e949c0e71cfc41c3c51885451a83e261714d17266b786f3a5793cffcdcf1fea9b251aba34cd41258d394377741852856c0145d3ef30e4da82094ddf43a070a8940a190b4441e914cd40000000e315002020100a07444291684053b3a8f3031400118ca44c5a4c9648d31c8751100621630c310400000820c68ccc8c908803013772acff60a4b717705e702860c64c1d774800faf1e29c3cac289d3971f2efdd648c5e1cc5e3faa48c1b73c6b13af446abe4c4edaf951f54466929e750179aa0368a46a04304a81a570d16b7f2c0615693d06a0c113a07b5e010aabc3248bd205f0fdcc9372fa6bf73fc768acece3a1a91b8f5e852970c2fce06451004c5be08770cfdeedaaa736adb83341943933c87c7c36d7663f6e7ebf8d8b6a21b85ec93e7d9c370746f26ce9f2c911de068c14cb9c0b67d0fd59a92406f7036fa3094916876e49d9be3ed4b7051e36f61a6e779d92194a5563dd30c8960134fc1d2f3d481cce44539f1a7cf0fa2e92e37dfc93d4e98c02b4c615df789043eff9d9f8734156115f63c5e637c5658cd69e102808a63fc8a607ff53c9707c51928257dcf8123ca977e3098c2f8bf08bc237e751915d6a51421bfbfca8ae1a3b9f703c5fd6fba067d9eda3976e7d42456bb9e5f1d04c9cf13b07a4cf65e79e363d9f1aaa5f30540f4c505d5006b273302c6731074926a3ee4e04d2b7e693ca0dbbf4bd3d9d11b8bbdf9816a305f070de84e4b1cae6c4bf735a0a7835581f351c04b58fe4034f5997a80e78d58267ca7649423e8b9d0a033321b7467e9f033acf0064434f75a25d60a40d4eb944e94852e747ad94ab1a5a254cc7a210e5d8b51cad267db137b4a85924cf484e83d4cb781f6a52402e75252aed1e16b28a1894ef227f65d36e5c78af2215b5101db528842cab0a2d74b6f0ec3732832682db964f452269909c45f2280430af7b7d5a2c2942969de9d874f31b21b93d42ba9988710e625c3c196156760516189fbe3e5178b159d76dbb1575def049a30e7e8bb42c0b47de5b34296631d99f952e2aeadea417dff56a37b8d76c544017f89fcba1094b7384a4eb5b62af44d21fcba8fde9131356c14ff03ab29583a7a9a170c55f5bc7f14adb0b0d179ef2b44c62f508c870616e83e809ee7e80179a744216c4033f3df2ef74c944019f3b669e8a9835276f6d3064dbb3216c4ae51019a3374152f25a2bb85d4bc3437323138cf8fe85f87c7ad433aa93d5630e6f79b92d208e00ba2a7fd0dbc2307e82716a897e50a492f7a166ad07dec3249bd778622a9fc023dd8d6dcd05c4142a5271ea4eabd8af62799dc85a51f2cecdfcdf639d87ae6c3dfeb21d7d3ac343ea77266e77c7326d1215a03e1e726fea8a2e8656a4a6dd2972fa25feea3c5339426c99fddd5ff25e94243dcb0d5aa5e6e6f37b0421ba770fd1702aa148d4e0dc2f0d96f5fa903eb4c0a6625de4b1e74402533afd4d997d23fecf32d45b99ff93405f4db4347c035b3a136c5027b7837f93049437aa9aef429226f514b3bf18df56d17677ee6d333ca733feeab7d128835c276b488af49cfa51be9da158523f69d2aa6ed971014f8257f11a721df5b81086f5f6031e17703d980f773ece24d2a701958e7c6b2f846f6c4e0c2c39668c17c5c4dae63d23160326e0f78136a6f50a5977935a11750e8daa2c4ab75a3663214200d63cc7288394d10b1ca3edd5c21f1240184225818e49ecb76e86932c6e09a40a603fc8ba7c6d0d9c92760741bd84e80981830957d1aeaea091a90d809b16002e70279aad9044a3c4cc0c3ffac0c7df4b2cb3d58eda26248a0ff57377146f70f86dcfded8fd7f8a5989f4907007c920a0efe5b81a420f2ba47cd619565e4495deeffbc959ec41b8f2f777d149c53ea94430d0155765bbafd9bfd174551a4f598c6cb78bb446f98fa64df84e6cbc4f4056e30ced553a7f563a33214fa0796384818ae83ea96594aef8f74855d108565a391b32be66510bd1e18147229ca68ef619f6d24cef3c73ef5a31b7c7fc096412c0415f2ddc4f70f189e0d4fd713394c3ea4ff485d634d1e438bb99f3e924d572372f01ec232fe75f2ab3eb333a43a8cf9c673fe91a1f970da3008f488c50cc13d8cfa2152b183e87c42aab366b3664d95c22c641ded15b6781cd9607610fdeb88f8e4894fd07c880b47c438ae47fd419be13982dabcf34030548971d65a8cb63a9f71ac66735aa9de35d9c27140ac8579cd74d3373607a7f35040bea7c0b450f8a1a1c06996b47a97de315ef47d6cd3b10242ad0f1ed7dc4c82fff9260def637941cc9acda6d2218b5454b71ac7917e965ec107a68ae01b2e5c047b0293aa9f583506a4b560cb73e04b5cdc8b95eeafdf1d539d65a1818d8f1c08693e843508e00d92acdbbb1bdd870773227ea6466c8709354e92428871561c709de4790618ea9e8ce600787288f0b54ec5c1c49b28f4f0386d832676dc0648211e2f8362312967e2ec7d97ba5ccaf3480e1e5df63afdaa66e0d3c1fd960690be7ee92f085e0c14975b7a9c8eeb2d2756a0748c10f73c97e72384660e8917417e46a1d905cae5e85014dcf5a508ccaf08fce879f69b8e2d1120d60820d0707e4a1e099e07184b0d9dd5b5b9dc0b67d77c916bac4f71c1671c020cc42f0abc6daf1a04f9633ada4692d2806dd551a68020eae89d6bed516f5696448fb61ddcdd79a2940490221c0f2c9628f02db6a91b9bc9ecbbd6b7d1c56a604536cd85580de4d006542d19ba3a0268028abc4b722825ba31d02dc8f0da4f79c10aac312804e6bb3165a84026a0253d954be0f0ced31ed39e9439c38f4815f25fc3afd26f066b27309ccd009cca0490a48e99dd1981a7d9fae1276245c69b07ece6274c3318ffac0ac8ebe603a6fe035b3794b5031d92ba2143661ab0037442c2f6c3d0059e42c5016d82f8678ce36aecaa21bb70d099386f22d141286a4cce4b3828ce092aeed0cd226259f3f1108428ee57f2ff57f2b94d468c39ea7ccc0dc782514b319cffe14ffeb4d00e6577c3f07ec247b802d830168dce2ba46088936e38f7f4f39ac630ec34d1d460ab1f21b0ab5f86f28281b6ee63e02b6722645c829621ab140f2df03f9108697da03d191d8bc502990f6edfb5c202293f77e9ecccb0add31d9b6bb09967f34576e58c5b66d84a3e95587b689ca031419cb537b482e01d4789ac81ebfd5cbf1d9055d6292853981b36994a4580c3926e4d19b4cf5a0ea5617c978947fb9b0bb898a43a58cc072875ab1cca1c36517ec035b9888d12f453003083a2002c14f383550f0af750a996a97e5a3ed531585e5c9cf4d452b01aab4ad169d5dbfc77bca3925a40c58c7266b99124753d6b55dc2e937452a001b442858a54a19192f77d8d45951247023c586769788f1575e58a0909865fd6167b448bcb6b0b15d6d40b55f588440e4ba2ffdfb34589bafdd0f5fb9b8be2def4bf5516e5ec6b9107aa2874cedaa001b25e596c56f099ce1f8b07c1c36f6039362101098fc868751fea58b272b1c792182b7a29a3ee79b4082fe1d16005619f960e00468cbf16fb0434936b67f4f15c3f3947ae13991f0d16bc16b450768d86da14938f212fca2c9bb751a3d84107eae538a28493290f1a662dfbe00354b656f67af357f176715e8cf318c70af1865e8b8c1c616d6b96faf7c9fcf51c0f2c12ee6bf1a135a53fcf24174243da05509ad9a4e53c2bdf1af4b5d80b258a861f6527e80695e595bddedd0aafbb13fb08eda8c98f31360b494421413c3ad486b2086b02b92ac8426d85c01eb0091de5b70ea16550ce56db21d9a193de8ed3c169b3894f37766dee87a6fdf9ec393f4a2ca637e37cad55cfd29b53ba317790d79ceeb190640b5e37b84adcfc366e19b71793f2322d4c968c22f9de8fcea36a7b273b35d2a1663ad2e83c62245ffbde6843006c69fa5a6f5b395197aa34754c75f7a876be3bb66a959b3d6707bc3ee917a38b821a030fed4f754637e9d870aefd166d83b148d2fb4a2b97d053a2de83fb8625c71490e2e71dac6538ac395790541ce19c0d6458892f16d54bd2f57057a70c69a1bf00b3536d579b8643a094d57f7c71ca0c5bb84aa78f4db9858e5686a39f1e6fee5281c2556e0c921498b50aa3d26eb0290d64e906c8e6f7faba1b7cb431bc66090c0de3bb467b8f9d1d8c11a38109e49c21bc6f136b6d2a55ddc3ce14188b32f6a014703d1eb62b3191eed7c7c654a44cb53b6a2535535ccb70ed710c01c9cf25f33ac869efb94e5753ddecc321e59323b21c93178c12957ba655341c16b769d7197ea2f2b3eee45164822ee92830577d1ac0dd787704770cc538da6182ef0007d23af89d5077a039da5cca7572a95faf959268d491a5c5276fb085d8848cb50f43952bba3f21780b2400ce4448cbbeaa20e97cd4299a441cf01387d87d153f835689f98dd39e81dae8a4df8af886742829ee6aaf34d6f3800531c66352e210c80231cc9450bc2cf2289a66524b785eca559c85d8340bb5000d6eb77e600f5be8c3cbe4b253a0e483d1c42a07392f5b983291aed1c7c8d52780e684c90ee25b07473ec977e0d0212717267346185ac8bccc70ccec6baadc974911b6f63e32149c213d116863717bf7a29e154565b47976cda49ed33178f86f7f62c98f4759e16af94df737551541554395c0f831f4a1fc5722f6c19e7419fd7121ac9ca5714595929261970702b4acc62d3866745d3695bf7fbf65113fe9f209ad51cbca0b429bfbdb5155b1bf4634f6a182a7ab04ab8e3354c04cca779b63344d471241c5d8ba12681ce0c98b00ca9dfea3182161d02a7a625cd2ebfdef5ad396d859df1bb2534c558ff5138bb9492c56f7052f8a2fe15ffa69a67a7ac95c74ceb5c00273af866c0b708565d8763dbd9908ca40a4412c0f2ffc266eff7e70b0ef09aa84875cd2e7016b482bb2ac33b117bab0b2f05fe7b0330b3a045e40bcd6fc819869e5ed955be72c1b6a3588ba208aa5b706c15ab6a01e6de223c6ad2c1055a8945443c00500f65142c0bbf63578ad5f7eba12253388e2b541de8b059ad71d8d4555dac8261393d40b993b6797ce7c1378c611457af8d158b1a548e7929879646d542a12205fd0151ca500412477737b3db52114efca5713c9f4e8f4cd835c3b47991c63b001c623093cc72b0a68ac94761f33a46f9749530ea2c5d7f5c0a9b8110499b622e604964dd62112168296261714c060acf9c3d6d5035821bf46b33be62ba545d437f80894d33974a0942b6a7a9194ee22fe83b4bea2db655026c85e667ec0e811690f197a90e014f2844f47bdc0b2b9d053b315e96da4b75eeb5889ec7a290270fdc53c094bc8ab29bfc48dc72d181917cb1ac567265a9803247be3471bc28b8b1633035d2817e30778464b1c82e625b0ce82a970f8b379323b8e92abdea45aa2e68d4b00dffe1a5be2282d3acb7633ca1069a61700804d61a8124c8c67d3c6e4e20ae04ca37e01f02f97c6d16d24cdb2a232be619a853b214c962aec462537f4eed9b89ea80087d05b60842cc69579f451dad39481168d5e7416e19ce5c2ea978db3566b47c6a80f913f167e74be097e468d3442e9ee1d98fc9a2d19bb3d12d28c7c0d0489270b78bfe033b442cfe18f407f507fbbaef586e0ef28f76e36c447093ade90e8908f9fa89cb349e89429e41e2e20a0ae713e7be7f21fc12f87ff876608ce03c304b3f6c6be9017a92c08e6501707383257618439fdc4cec47d89aa0ed0918eb6d9d65417c1c691fc05e40803c63eb6f90aa6880779e45323d1f2c549316ba7425e9bd27e041fb1daa522edb38b2cbff27a1101ebc5a3c5f1ecdb37b11e1ac18ba4ff9d9357466b89a20a18aa7d92a11101d9d95c01a5f6fb0c003d4e5642fec19f3dc1effaf3793da0bdf42f19e20d0fdd20969ef0fa5e63c95c07a5d00bba8f820d9b1389b21b4aaac5320d5a572a6cfccb0543136994196705423ecf478301db1440c33372eb402f7bbed09fd3c66dfe6df7aaff3bdcb458f182e32a7f9754fe329506bf478797e0b88f8e494fb52958ea544d36235f049a26bb1a50a5b56503cef0662163755df1dfe134a89767700a9474f4efddb76b19c292de916890d524f46f53cd9fca0cdf4cb0171e9389b1b90bcc242ba4b3211bdc8856ec3473db0c01bd5ee4615f72fca02ce42369655341f2cc6ec4936332749445cb04bbbba6c083a0b19a3f8fc601a9852b86b47063c9016324ec8ca1dde57c0c80341e6198e58659f31a60e337f82501070c0c9d9956af338148b80186483d3e0fda993fc00e30916a19609ce34fe182a81f0074c339a4e4db17cf1bebd946899d834a0af1da39f07f5eaf0510de54728dc0d6f6d60ed6b597551bf0a830f37e52f50fd799edbd87854a6a96f0d4ed39a4b8491f6b0856c85f8f7ec9c966a53227990c02c0871e9d438509138712e80062b84b8031c825275958f0141279a3f102883898ab4558caba420cc1c565c7af45040dff62c1d7ac1b3217a3f60659b08b783ead2f7dadb71e6451f33ed898c7390297f02361f9ac5cb9b142c2c09fdc332aca0129830610601aa39a3a847ba16411184ee51cc62d2c74ab86635cbfdf2dd1beebd139aa36a4852e6e33e3771f7e5a78243a731e426bbe3dc42faeea1abc9a358559764c3c3da37628bd8d95fea20bc804cdacc56035d499bf7482616e35567989c7953ac323175dbfe3ec14657d04029e6e545f0bbfddb97015b2433dc5f4f05f9fff89878daf2854459b90dbfbd815a6da01cbf9505db16f787da89236f5bb15f685af251518cddc1c79184444ef6fb5b23c474c7d1066ec4b34d628d77f028df662a6094def45541639323b325f96c3495739afbcfe805d34b911d9363e3c2fbe27e2508741699899cd05b7b8a0d0af3554a76328b212a894a92d2a20a9a43c8663a260991fd3e6429150a6569b7f5f9f02744d5aa1bf4d8f55045942392cff6ceda1bc0f0c515604d544b28d9ed4a6ed8bb25e904f5be569c94debdc1e6c43555128604551bc012e2fe14b35ae1ce2bb330374b1444a7fae1d900bf2f7424b790c2ee591b1acba8e19c2434576e539f6210afaea775e25b35124e9909753c406b80a353c354c04cc2c73850e398868d1ccdbd9c7a9027052c264ae96696439a7dd8f03f44c306dcd423ceea231379d7960644717cb01d19be51a437c4e34acddde21cb8e215e9aeeb0f05c14238c85a756bc813bb2bf21ffd9488c612f3e4220090f6cd4d5efeef4fb60cbc4b233639f2ae89b3a653f4870116b7e1cca6b3293fea5bdd046660406fa52d75180c79c0c72933c5eef59e7f27fec526f6ff53d9774cc6dc8c7a564d19ca58d5593b034bc02ec0ed2a3d682b73de712072d209c9e95de1bd9d2d303b2cbed20ff35ea70e931034a74884d0218e9bc663a05ce7a8b582b1849c2d07d450df20e7578df2370992b6c299690d662ab67cef12f7cd793c5420b88c4b5aaa5dae0afbb8ce831aaaa719fa74d08541f0132fa1a50e0454fcfa6a6e16a55e1569eed208bd197a11d1a35b6ee9718a870ff22e344f8e974fec87bc62974ee33d1c9c144e2f1898e738265858900de047fd982244f7cca3a39642252c68f068709a24c8da52a0b145c240230f20c1c18cb4a5b41e350b57fb7367557d9edbca5463a187957e76660ec57e1c0b8bb484a530e70a9a0074cf6fa2452695bcfcbf3eb623d72ce74bfd59e181b15df9390ff106dee58a43bf97c119eaa9e49454c8237d0afbe35d4711cb202fc70ec77bdc0710e37537b0b5d7e61ce7f9ba928d4355bb573740b62dc1e41f55b759f4145d305097d9616faece28b02ebec98a53f557f2e5cf7feb36b4722b4c6968d9e3eedbcfdcaa91c670dba061bad41c125bb5259a5bfc1cc04d4a365e4ddb19d0fbcc2db5f51db4ba90b27d1df4497f550ff7437b1ea9a298708735c860c557901773f51536858529df55c81b2a8cd163960a37450614d1c121dd543fc4fc61fdb083ffd910e3d50918dfa47adb1c39ef10754b0abf1988c88233749e2647262418ce815b7a5bce70da5aca971d41bf65322f49283a2b7724f68ca2974ecebf6c15412efcc1b1537bde4ab11adce8eda6c5c65416cac871b693ea38a31425533dbb89196babf3ba94e3a190dcbc2ec63d6c311fd84a905e005ec28534e1b05da2a1d2a3be33c12ad7852f7934a81a15b3aa5e28d6b909965f8e29616ba38bb79f7258529381674983965133610cc1cefc934f361f64896042b0789be998cc4bf49a65e848603a93f9a7e36962e7bfaa4012a78cd5b494297bd9dce29cb609e87406a657c8d4bcc73ba885315e0e179a5461a08aedd039fe78d3719980789ba8c1907141f212c73e88844d3ed54aa15d0da7082a0047eb40d3049c7a16f5cd77e6e828382e24d3c25c726f07866bb573d76d131bc05c1dae0cff2c4fb4816ee77d52ea30d903bcffcfa705d4cc5b332a5daa135714a26831467d38889901c66489ad92d46a2ca805c62a9c3cd90198827bb9a4dc6a88c9fd8888f2fa0b6c06e984337a4f723cfadc8a5bf08c6e381902d3d5fd9e415547713b38cb10480f6eb1bc41a0f0056210a8f13d87c920e23feb7314180c4a2d202d6debe680bfa070dad0cfbe8624343f4276e4f89e037ce9707792e0b8bf7257c4abdf9ee3195aeb834aca683e1a54d6a271f9b32860f3660c29b67926ab4b97e8bb6040ea0b932f35acb5d0c075b5d54cb05274e894cbf54591c3aa527c9d5bfc41581046fbd2b5f5360ee2b7ed4fef3b109617bc4ea9f0f08befb4d063fed31d17dd5aa88465b826734fc52039c1a2af3480f25de0e6cfab2932d1ada0f69c3f2351a46823f8f3d373e4011871e568438ba9d00fcac1a969cc7aadc5df336dba9a0d8f53d6cd6026639d05c1a2443e7659a7052242a60561eaa3c58a30aa8352bec3787997e269c3e31a2804e87e4866d8329af4dbbc3a09274f54026033089a683420a6c567a3c40dbf6821bb39ae81f9e965200eaf339cf97f183254cca1826943a60d28e1eda58425cd21a1770fd3b1024f736fc7933fa8fad1e4492195c323f73ca10f4690c03e9ad6e8a3cd89acd893c7deaaa0c93c65ed90c7ec0fa9fdae75833d8d16a97bc7be20e2f8fe4235f83805dc8b415356e94dd019b6c3c4f29014fe7216c31d7d506bd5ea6ce69a096047f144f36c2987e90d5d4eb09c3a804462f1eab230358574c7ba740f5d7a341764e1b727e5157c7b8846d2bce6aa11c7cdf6668b97f8f9af9e7802cc53469bcea2e748465a952ac3ae707ca3833848429f900e2202ce5f73223fb0a9d2489b95706a74e5b3b0ca990fee2e560d7967d450a3a22c88025310318d7449a93fc3030d160edc057b29fd8786a4369588ddba0400596e01d0f998a458822c1595700a5fd7d85675a806647738f5c76faf242a5e0a7f1e735cf798fb50f1f6335ca85dd371feabb7e55c02d81f0d696b878cc6864d4c5e6dcd6df229d755419bcd64a50ee564acda8b2f62c87d64a9b9562e0efc21860faea822a200391501afe2e789ef20b526c6d89e5670e326899dad4c5dda0b142e332264efa5b61bc91a338a045ef4424a24d77b0a637e4a50442180e911aa6b633b52e913ad31dc2dc7abe92398b7201aac6c68f30c6ba40405d5188e3e45139349a3ce5ef01d3425314e244227f250fd0ec24cf7fff3efad39e2424b93739426495caf4b779ec1e60f7fc29e361ce999720843078d49a926961ef52a9b21780d2e6a86febe1e8efe0c6b398fc41f93d9a89fd512b0548856220814182da490074e7145249ee4b0a9a80e7c2d8ccadd459c90551ab8ec97d49bd951523c047dc714fcc90908310118816f625b6fe74589eefa79db5882bfe142e205413f371819ee123852b28b3b2f649c06e9fe301aa5130f3b3eddbd2b1f033ea916ddb66bfef02058a6f4ea8f150485c3a13955005b7c736d770c43117407026e81ddeb5b662ca29c101fb4252a75a2b9cf5adbc5bb5e07d8ab8c003b4a7527f8e1558b2315217079aa3e7f27e57bfb901d1550d1da12d04bd55e0aff4d2d9e0d05560683de19c45b93c5488c94da4cd413c0e2313bea64254a9a690128f0345e5f3f09bfbf718e964cf52e5bd40a83b881c4a1edfb9f46587f9f8889282bacf5c255da92c056402178ed30cc4ed5ef7f2b0f72d7a8cd745e3a5809708d165f1a9b6d744dbaf5b780cf6286fcce0b7dea7c9a33ccf00aaeae56478a4430dfadd136ace95e106d19191a2232c50e305bd385ec58d45d67f0458582e3867e68993b4369af49acef2fbbf11464b931b80764d84800d5633831d95b6fe3cc0a25e19f059b2db758188867eff1ddd242d75bdfd5d6407ddeba88ecffb28fa2a36afc1a1dd5809559345d772bc00952c4202eab31c5685697b9c0dc26d3dfd67aeac160c435edc7ee138ce0042b6ce886d67c17d3a46b50d5e60a01a54f17fa69c8911a068479c230adb789af33b13f075771ddea9554b13dc9e7e70ef01e8d670d7309c0fba11babc86cab1d3b337b347177a8f6b3a540178553690874f1431919b15dd622a1ccd916dfb09ba2740dd8c16cc8706ce0d7fdadc8031de443f8aee1d061fa0597ce5388b4447f40dd4198dd6fc0afe7908a8c0ca8469c2e7e7c48878374cd8365bc9300ab0f88e0947bdd92df96b25f40f0c09e8e6aed9853a23861ceff516af5d4fb3b082a013009bfd7b13dbf77f9cd736845912192e12c8c7cee0b105ec0fb9ae2ca498db8ab1547edd5b2173732c5e37575be00cc06a74c46a1e8b17e0836a0b121adff0ee9f48d83732e7df9c9522f7e044eab99e01ba77f961597dde4722ef0b87c1ec19bbf5a7b5320bde5f82b9511efae17a6055b13333946d259490443c4e10743210d553f13bf85fbf066d519984379da51787690a8c78049a9f25213242e26168463fb5fb4576d05b495b9c44f86ccac8e0109ea458517802e638a9029586e980124f315c40b4c8a164e3e12a6e1b790700e4f70ec9e264a62427f1728f06e823fa61a860bfd00fd30233b5c72cb03b03e3a85b80367f3384c8e85d7b3ac2c87084886e82460b0585767bbf8e68e6e48d1992b6406f0639fce0c547ccaf3f1a50011805663fca6e4347bc88249ed32d9817292d03764d7253ec5bdbab8792ab8e78c8471537bb9eae50c063745cea103c05a7d1be7fee3be17858988ad119813cea6e349128bd2b0b11d686c9226713153c6e33fb252f3f0feec5a16a6442ceaabbd6f485017f134366008ed86f5b2b5b058876d0c8684a3b531a14a2d160e30dad75f88c1f0712360b3bee9bf4282847633e8637a76e52434b14fdc50abae331f7b03b26fb4932e814b3a16af6b34b912905c04fab54d7fa4b102e55013c433f465cb0716e999e7ed5c958fd3349fd6ff36bfd33213d2d234e667b7dccb696b678562b7265033d7808134b6c3fedfff61cfa9a1d81b943beb808fae00941c8a7479b36e58afa7013af1939632a8e8827587a5336bf4cf0c3147218bcecd8917326ac60922a7921d4c135a23c0eb32238c3537f9eec8315adc6d338c9b4388d21880bd21b850133e219a47b53b72cdb5e1c60ff5206207ea2a5d119c240578ca1cc2ce35845ab9224cfc2fc2bf5c41a64c325d156226b1ced97583558bb16496987163693e33e14cc32898f460e5866c5c1ce11ea1c2fae90d0302b26c7f5c15b400e0b9035e5f0000aeb49cf2a10a08037ccd4754f53a12eb91bf373c0bdf6483a14fc632146158abd60b90172b297aae1a0229c49e18879f8c0fd6b27561c42fa20c7979850fd822d2a0cfc164036d9161aa61adb9e4b29af08ec1e42d13435281512820b273fd0b13833403a5d1b617bac4aa727fad7a5d3002d4dcdb2fa82ea1cae64a4a58b4be6e29b771cd90df591d7874d96613d7b806d9a5a98ce20491295259c4f67db310315f14ef453cb562797ff5be94f64a39d675046f1cc67d5cb8d7a905d681f26f628dccb93961c0c460321f4105551dfe066a6fc5c1c8f592c893b507b15f1fa39b4d7f1a3f628d597f580d5235cb3fd3d4a20b19bba1242e9c1a13f131c2405376ccd0456b8c1be52821270244f7cb71eb9fa7e42d62c43581cde1ccf3a2b8ba9df9e83971c58100b4279a1c58297e9f6f184b82aa2633bbe672a382235e29644f9b9950889fb4d5da3fde1317fd32489ad56e7e01fe8c195c855a835ae7ea88fe3df30493b9000556c4c37a1185334ff4ba8f646fbdfb8c2ff6081a82cd3be8a1484e23fd6e2de1ab8810a490696244ef5d9aef5e285d92521688f36e9814a350f154129cb2253d1dc9a36270be3dade4b6a0acba6d067784a6e301446b9b4b2a7bd9dfa266a916fb5fca3af0c2256cf417b74cb0b982975b9a2d4fb0bec952c92a32122040149816b19b36dabe45b607bc954738a74b76d29ccb3a8e694841a0f0895d65a78650f2b7da1a296bd910bfb76f5acfbd901fac8337d873e97376313d6d3e5cc8bb7f491881bacbcd0e5c7d639281788f2edaa394b64648f4081c35fc53091810034788558b44d860ce8e1823238a032bc16a68af825d0940b1732e110d74c0b49b52d12348c7607b600384874ed6545b2d0134249b84f24243b45a448b511086eca3ac44a2183fdb16d0cb85c32137375b903b2e77abb45b355eb9630058d8dbf144bf243d1b4490b9adc5c9ac02db008da1080a018191bea1a80036a2fe3f7c546e81b8add9b6621e52317635e941738a0ca4556a31d7625043dd8b0154a6089988410ba004ab4df45bb9d21d89d9ee65a196789579689da496e8efea01eab96047c38a050f7980b887be9d6aec06033106788df1eba9a4cd99a87abcffd467692c1fecee086e335e68b3bc7413f7d0b6f5572c55db56281d7374fcac731ff8723eee51f91e199b7011c3a6071cfeabd738eb832e08a5fe5d7d5212ea0de68c2acfdfdfa05634032e3c0439fd9f79a71d78a625bf1268af0e667c15671cfec1d52f2e4922bdd5fe484752a4217d0bdf3b1e9966c1b083f307dcba435ada4184c18a911b806bf6d4f1622b5c4b333177d5c32189439ae0e98fdfe0bcc62da3b66fba1ea26a925afa1a69b4aa1dc3ffbdbae53c2c27b20902afbd248887a2577f81d4642916a2aad7371a6c33e6cb52114c9f8c5b785bd9f1b595fa749854b73cfbbb09ace1c765038c8eaca11d8e7da5dc6552849f19abe8c4746c59a84b111942ee1c50b724dbfa682a7ef15350c4d2ccf1e0dfbd0f62937c36c5f656fe16d9d216c0660ff79b741b3844d46927c6be7175d0d61382d00620cdb13d9a1f1268b4f687b7b009b966dd4c23054b332d35dfeae73ca82d2a4eaf240df9ba99e8eb5b9a0c9663b59084f7b8fe177c4db29bdfa203ac8305c569430ce7df241b6aace3ba11ea35aaa7767f99da0e55a22b6e77b92b4c22038fde6c58683b38dccd8e418d000509d7bfb5d37bea120edae4a8f4bb5b1b691bd0b34a917c6716765c92187f110ff7d55a2e5959f0a861f59de20817c8029ba1908d3310a8989dc57ad6470841599235da7cb9a3430934b263eab504226f6652779b3dd944b1fcb3f5da58df10f99646159a0f8cfa3c6fd8ae221a675515d06e08f3305ba35d4f4776b7260815a783043475ef2aacf3ec014d18bfad13a55cf6d475a74423f5c06ce0152f00e5252b443dd6d1524e7c6f6af60f648df0afee5c54cda289fbfa4d69c93725120779a06aef82bd1b82287d9c5e33be854c19fc9ca34bc634ea5cbcae6417eb10deba04614f728384eadf7077235e6be9d08af9bc331a2bf27723efbd841296af7e91e8e138fed92c3f600d67f80240ca0d945de76769e11e69767f30af14c1f5b74f3beda8f691dea100968da042ae0e32b6c8bc65da1b489f315e0ab4e2ca94c9b70d6b3302dd179799847b0324e07cb223995bb7812604325827dc60e1c963d7a4ac0b8becac5f57663d5fbd89bfc0fad41855917b3a28c9a8dc45cca79fe9463dc2bc11f0c221f7ba9b3ce74b9c2e1d153683ca0187d816267dcbbb798d156b08a5b417b5e56d74268fc931b197f0d6e00b0e91eaa18cacd75c54065e6ba1339a2b37744214f73e38239689571064a48eea297d05790c1047ed1ccacd0ca05391bbcab00910d44ff697e35396293716673796c7009431b31704dd08c44d7486a757ae8712e6703b0d5b9c65a581f5500ace1db9494c934ec2dd50232b42e84a440d15eac6d3ed4e55168122f92654a37430acb1c8b83d1588386454a8430580174aa8afaf3cdc98cc265365c7ddf74771b8420fc1f05dbc867d981c3f51052a7851fe469113aa83838c09f1af6072b16b4b129da9168b0d5d490361890a243e935ccd5a1ea8f100dd883cf60a77d6303ed873df830decac87f2c64341023c18e482860fcb050473a62b910ec856d9b80a1242cdb93072dc047090de0f6b5064d8faf6e74c4f808fcb335c10926c940544f4cca84f3c17071bf22d93d5790ff8edc2ee4aa42989b833d14a5461f4405ee2d1e7d2d0834f8789646fb25b23c3ee512d506a9bd4851c66e12e60f3a733b52ca0791a0e6d2dcc2e4bc6d5440342915b66653b89c4cb9d7ee13c168a8104faf5a0ad617a6eafe063b4db1ba90f55b7a9efa3d15a099f311de8442848952bd7dd23ea16ab2e357fd0a5ba6cba9c5e773bc45104f7e3fce7b30639adeb2c51689c0320d19d710f5b6b7a102a3065547e5a0deb6a0850f52563489c223b61af08efc7eb6818cb58fadb33554defbac334795f7750448ea47a6428423256fb2596d9478ee96517678eb61923c1e762ad3561451d2207105e5e400cc56a05faa67600ba5cb7aaeed67130a3bcf7175e39dc6171bb1e8806bf3697e02c1b476c63b8ab198076cc516a990af1013c3187b1c9f3e0dc42def94a8851939fbbbcbe99854865f2d2eeb75f54354fe04390035f086d0af17e85717f31973a9d4148c0ccf60ff69e3f272a8244565269e4da353afa837f0b8575858b0ec4ef033d72109b8da430c1d3ce3b854fcc69f5fe7c39dba1a1eb9b79554d81d59eecb0fd5d83051f93d724035ed2232d5e3a144ac9e54968e311615d8039ab9aca5938529981afafcf1593c0988976aa2336d0806406791dab5f09d3f7f887ff459968e9ab77dbad9e05c2aca44c6285fc3a768524a2d780b7965cbdd581b89c42b195383dd142cc49bbd86e260a848e10246303f7585bc532defd36d80291b4b3abf34069ce3bf365a1aa18eb8cc1ab6328f48fec535b0275a6168aea0fe96b268bc307f1a24a0b75111ca079e844627981c67be6b551c4a152387110155d2f8ff369a043c57b853a6145c7728cf0c5180c3e81170192dc0d766b347f75041c7cdc4a123ca82eff7d32e186fa8c2980e64b84b66e26c9d4114e531212682f6bc09eb6d3ef342934ec9dddf7ea222335e6691785f67d08c2db41336f2c2236edb8fd44e853eb13d989ce9e07e9501c19aaecd999c0f8729c9bedc805546a10a4e766be182828f567dbe272972b87ae388679c33c9d3cce8012178ea1e67b950761b853483a2486e39346f3372f5ea826ae8cc9d40e611bdbb5208054d5e9db2402a411dd7c779c979582a8a90e72516824554919572d9a549e30c3c634c5fdf40691ef16d5f9545a54a52ba400e6124b8768b392dd3c988abe6c69788f8981957dc678e213bc84537e6ef1e871aa5509a77537b2e65f59b0251bd86bf3bf8b3917ee4a211d7a8d8fb14aa36d9dc896d0814491953f57a3f7d40f4c185aa23366197a7779aabebd7d4143a8ef1b49a1cd970055209b9195f0496620f2541c2831dd1ef51d3f4443cd3d8aedf2ac97de7c764445a38c2d916a7d927ef8c60ec88c81c4c43b608dc86831a17c6e15617b05274cd52a8e72747064c5999bc977c3508d9065d2a19f06977df56adf11c81676122674620d40c8f14515878ecb9766aece8fe4b9c7e57fb0da698a51c6a57d991c4e9d60d72cc2f769b46f316619696d0d8d1cdce0e87fc4c223b7d9f1b3ad069183a58130448e8a095596a88c347b37bcbb94c2b167d5aa39558ec4b4ea15309e129f8deb3074f998e28a9db3ebe1f25664326697b2703149a815030632b0508b838daefc8856708b0d83f028f8faaecd03164499fdb54669de5eb7a8ed5b244c5ee27862f0f9f258edb6bc6fca8470069a35df2dc762c8ccc064926e1f2d47794ce22ef1b88835c73cdb540d951ba4527c66df75c261465cc3d1a1f620df60b26131d936119d40d3c640c8ec89e6b2e66a4f53bd65d7c668d64371e37760cda1afd00e578977147876c04a1fb213b207e855c8000dd8f952e11e564e15967869ec6f0801ccf86d2f0c6654faaa1b4949c4a899fa5499444bffab9872d70da37b5d33012e5a3dcb4f69ced0cd62715aa8d09d2b8b35186a521f9d5397bab1824c71910b2d3c2c6a0efd7abddccaea1dbfcc53ed57cdaecea4179a24a17b6775ccdc81d499f4b846b8e3ff88f6a713ff713434e44e57a393c2019ceb31f1e7d371a89c5e809de9bf7163787d4dfa784b4961ec2320ad6840a514a8c1fb35c45464c00be13abbd1001818c7d22b4dcba364d90c2f9eb0500c698937f30612fbd2b4f40d59795a1ad10f8ec794abf5899a686b0ab384474f35b85b044300021c3188fbd9daadc6be23e46320c3d85463310829251fca75a6d3114b9709b93faf59d8ac3777525fd7c7d1e6342643e047f3dac056e86449c07c914098a0483c2e041e6841926fd3e059bf379e2902682d09eac58a9c37375258caa1834e4b454be8d371ca5bc879eae0a3db918d1552b27382278f890e0003367327dbc811409223d98ab4111aa810c2cc294fb2e284694e48968033c9476480510cd0eee30184262f1d002293b71cfa9a4a8abeebbe4eb2bab440a01d61fe42303a3136433567600d6e33ba8c1aff8e8a1ee0b66d07154b9cfc412e22aef44afc520b0db2a7d46772f1a18f22ca723a1f48eb568088ab5a0931e03f1a429e3da24c1da862ec3cbc7482b75cfa5643d3ba59263ff4c2bb0b98bc994713c6704187e0c66fb8661e213193a5f66517f10bc9e0049d497a8ed3d500478af904f798512caa5aadf3083ea01b35b2c50ac3f6ec0bb2b96190c80ded05d4eed0cb24a9c46fa862deeddb8e8976f84cdc1b953d1bdcff135104e10ced448cdeaa2e4f20fe58d3e4293848825516755963892904ec73365dfec15f33625d31d2995805fc35823aeb3bc8cc0644cc09c6fd22b9b26faa5bc4cda99bb16e95769ece052391951818ce19f0fcc338507f97ad50bcf16ba1be3e84f4d4dfa64148ceb1c6ef18795e84e86a14d9cb16c213baba591a4010c60eb0ad34a2bfac569d13d0c743207192ca2593f4b241742a7a5bfe7fc528787cc0e6e564f866ab45b4e601386677b29d56ad3110457fb6e7d318a43a71e474926ba80aadafe5946db2bbf220a1b11933ddac015f14fc48e0595361b2234af47d34b6350301886096038439425c794cd1db118dcd074bdba19d659990db3df224b4b6b7fb5f636f495665605266979ad853a76dcab90780e4410a5b91f0ac1268020d799651c630b2a1472881a4fad0216d31c8f913fc3aa00508fbc5321b06f0e08d2eb3786fb1bfddc25b4ff12ec9cf506557c85d595a8362e83f49b7569c381a400c55aee76c2001b54bd8d2f404ecff1a0a6df895904e8455ac1fc37b9e8485578416202cdbc49d48c0884a940205b6506c1aa59b0cfb80d56ca02d443945de7792674ade143801c498a97a565a6993df31d5ea4f84ee3ef902110480e1e5aa95f668521c953629a521250a60daa9f48f9331a29acc7afc7dab1020711ec56f20e69a52acddc16413d91d8019f17b0d3a09e39b13511dac9f50cb12a55f0e5b1a36b8556cde6fb679483dbe181c334ac61da4026fa60631d6fe97ff55be40eed45526bda41f231ee3eba7b4dac5064068099f7e0e60eba1870dbbec7e1e4979da2ec4e181e6b520996deed24faf275979a176a07c1a7c9c16cba499748747b60dd9e8e1e41f80f001824e4dcec55bb74fb49902ccee94457b00b02c448ddfe31b003c82ca32548c0207031b3d3c83dccc7609d6f0a129081c9692e5cd85decf7b983136dc0a986823d0e0c6d5b5474f48a86b34b353b1f2f9c0ea260860050215459147a9183a762c0516b32e92613fa25cd9a14bd4298527b5ee4402b9442694170f289f2906684777936a77fceb43163e27f089d89c05634768b49b35a9a243541e0eec42ba443b55762ea35a45feff48a81ad82ae889494d0f7965dfbe97750b3141d15a2815a546a745c847de621135bf5d9fa1241c82cabe66c08fe7e838ffedff3c484da226a901726772d669d0f547d777ba3265ea59897a3cb4accbdcc101733efb979123fb81a877c8af90387ddf5c4cb0ca4325779e719f0a853c169c3fbda5774d280735f3f539852e5fed2b8cfbe117a8f928cfc086504aaa968d5bef189fd0ba4c2d9ad50459af93f5bfb1fdf1ea48a8f59267c4d35a1ece2a289c1023c14622f370b70805b079be5fecd1f132705154f3ea91afca2baecec88374afda625781d93a5622624d70ae97ba8d83d8f4b6e3400cf5417a8b6c6ad360c4f7ff5278075b36a56d0c5c49b813f9866d567cf459db49730b34f7e13f1454f5bae59d9b988bf6c514d8634e2caee291a376e5ede7ae0d2269c25ef7f4dda6615a821b3d98fead1a2789e8a1e994550848bbd05874dbdf592a1436768e13658a5d2c4148e59739c999a7440b4a5eb7ac1eab4a63648050c1a904e40eef99f34de15b47726a2f1aa4534e335f1caa87182821a5c684a25e051af92bc55705b51c2d35e2b4c8e1e6f2029f7c04d04d681d1ec2456665218e31572e149e2a0531b17a23a65396741a7add1221b3d96705357caa322e34ad5945f885285ced3d6db085228ed908d4904f22ca7845002ffa011ad8163386f4b4ce445d0c1ee142e931ef10065f2c70d902e22a6486487ac4e7e684316b4ef642a0d6cc58e41fda5e183341a0b41da6d95fc5c9d796e55fcf6fa45021ef0849197c9adf1732c2495a5c5ebdb9a60994fae163ea9ff63d20f83d56bfec6b95520b3a277f0dbbb72488dc477f2740cad3920904db8b3a66677514ae3b72e09990b3b1674ce028dc0d04cf25d18f38c01c1962e28cfa0a5994a21bec934eee7db4c23729af1159dde88bfc1021a7102944641b981e180ba57ee148cda0e90708266f8230b352a1b3c4782664abd496dc63a3868e6b28c27fe1e830b9a1031992ed9b67363bd3efe5332b8cc0e501e3ee8b18d0c670ef0c5f2477e47077ca415354dbb7eb42a7898b4c10b47a6a4a2a930bac72cd566857c3da190326acbcb036e12174a98de2c0eae59dabddd9b3018d786ab42db2e05ffeb244b6b059b2408d09492c808f4a30193d13028a1e624163df25417aa1ca518bdf3c7fb843dac7f854a7f7c451aaa67a7282d94f923a8ee788d8d9d858a10acd87dd4b8138cbf2d6a009b338978b401fc2a27ddc5329444607e948476dfb00e093bdc3c8139e30e0590b853ec680cdcb6560a141d1f38010f2dad7988fa485a32d43d53ea167b884fd502cf47fa73f32e98bb1db03712581adbf49e88b2c5d861702992a7200df009770170aad2d7a464fe3a35d3c80dcbf2defdb10bf1ebaa3acd30cd61c759e842c9cce3f0cb313e1a14a0d11b4ee381e3f3f22419cf72626e2cf1426c66fb2459c0ef7a348b8abca693248457035f8593f7aa8cab6ae7361898b3e399e804fd5dc3922aa47a4d0ec27b55ec72b0d5ff47150ed83323013066e53f2ce59b9420d49ee30ba7c5974095c0e25d5b252582bd2464967099e5d6fc677d6e3022f61100c6cc79f0bce7d92fa9c8351a1a1c5134e54fed0754f0b4344fca3049085f8e4576d198a9426459fa00f56c1a286dd0e9732f2d3dd239227479b0dce694c20672147c27e54b9be2dd29870d1eb3a6eadf4b82afaaaefd980d0be41549ae2aa96a16bd1afc8f417680041080973431cc9e2002f4e3bb18541f8e8b9daa2964241d08fbf7eebe3dd77d6c54fa918830583548624f5b6618c847502a43a82821d6312ddb237607e5c542eaca8f7d263a4b8fc7d6ca23afb76ed17f1805474a6c1d0f54bb05d5f040d5edb417db4147307d26fa57981b14d363d2f3c84d6e5505e2f161d1deb61d67c9c4ed601bea38628bd51ea754a60c18264797aa425766f88f62a9296091df11910819e89d5119e9178a1cc2b094679a8f8ed76112138ec0a5524787f7c88eb134d29d1155778089dde150f0457cd4c67c16c5ad0320d331da3f4cf524ec9b36465ff7f078e2638dc1099a0866986ad2a793f0307c4a985b4c7dfc7fc168a0b5394a4aae078447b3dd2ab5577adf1377f75eb622b2a997843f287c7efd4b8d90cf73917e725e5f8fd7fb477b4d8d747ce8e3df2532cc61a8ec4230c756b6d3f1f75b55b2d41ef9fc24927f5d6964e9cc40fa9c7fb9ceef696b97709a611c5bbf18951ba95d93e0d7894e05b9ee2218755015c9b0dd2bb9324787aec21664bb414b9f67205c7f532731947da1a0f83ba58f526677a4def113d595c216600b27661e91f5ffaf1e20399a3607bb96c5b87234e829ebe0a567919198a1dbb12bb06b6802bbd575a1393b332b6ce99d4d2cec363141c855072faaf3e04f04582aa576c3a4f6b1fd8aa997405a00573a84196a0d3a06aa090a77cf82987c349b68965222cf079c82325b75b7db25bf27c1bf8a85b9e278d918f53fb506c7558907c70250a1fc86c9f7c5b9e937700dded6d0add821a917c87cb5fda1d93ffa9edf1e962ebff6db12a0c55451b5925e3c89db7f9e6381c993f008ea8a3e83a3ee8b39604902f69ff294096ac555cabfc17f91f717d7b68fb6bf9d4b63905b559978d9ffdb1cc175fdd76ae3eb229881f9a8cd1aa1d3e9cf9359152046f6387f417721ba90e00268c63753d265b963b595f0a9b6523e2a019b17a65695e4485c8ece0a91f8ce732b06783a4ee0b8dee42749ce91af56c0e8b8c0339e7a95e12e6d6397f6045c28cc5273d4b465cf481d03514201c103bc49fd1716b0a8fb0b77a949dd7e00b80d13b0282cc03eba26618fc5c65c3b07840079068b68146ba2d54a854a48aaacb4e31ee40e2489849a787a0987a623f1749b18aa24e2e97b7ba807ae453cf0a32bec28a2bc0551f807c5a189ff684eb7c8e59dccc4338576b32272801fd3296472722032572e70d58e4fe41fc35c27cb543e2f500a90e0f0003bd4816d24f802345a9046ba7e431379448ccd346e7654c51f34fada383bba4f3bcd91363012a84b4eff4001766db0573734f26860b8e77c6d1472b8e7044e004a7473b64f520f482dfea7b9385ad6e308aa2d36b9205b39d369c8ec9d1ba1c2bf3380aed83bf3b3888a817c09314ec47f77bd9882fcb2b4167d795a160e04fc74882b4ccff2349b36a93cd07a72d98c0fded91f8a4364206008abeee7c56caaf3278f4e11d88ccb933174030089f74dd9b1fa7fc1811003b2d77a8d090379596937711ca15208c2cc782b1c45f97820cd573850c82c93076ac38d31e17678eb28425c69b530e52ebc36d939bd842041f8e5919d1499f9c63a6b9d96cf311ee4b30e105f0f164107041b191a51477e74c39cb618b153074761eaa71da6f5aa8590bba907c8c164fdf67b60938fcce5c729d64656431875c09e33c17f60219e45b4f564354e835ad249abc1238971f08ecf404334eba115884bbf680f3a45be83504f100e08bf4424f787c0a1b7005937d24c51b7a5292040e0c3f508279cfc9b40b05280022839c4c5ae0d8ddc46461448f145a2a790202c85eefaa7b313313e700f22b340589652a250242e1659cffc36de298f6b5cccf03e4eb5226d775253cdfca58b4571a246666a996003b05dccb043669b793f74b2b87d6cdf7bffb1b716f26a3ad6e39cefbe9c2c30b23701e189a179fa814ae0e068062a0a5de5e59b8533f5509227e16671c3f88a74730c2b0a178c96b5c3da48170d22be59c20f16328bb59d32db79c602219a6b52c035ffa2f4d629c3a89b851da554794ff385215a7b1f58bfc9876285c48edc07dd2c9c9ed9591d57fbf7d09b1f16f005c59f0fa55af48a39739167dff2cc533a9c5dde31709abb5fe94cfd47708247a73a90d719ec2af3d5b23de063ffbe5ac6058a4f9c99a410689a03d90f367e0e01b634fb0ef6d9a9bbb1854ad6306b8846f07aaf21c927c5f7f6d0d712a75430595d17ad4fa226dccdb09b27ce51aaefa0e82c6fb415e3a449d0d6361cc8dc3971857d34b2bca4448b742b51168ff50b6f92d614dc40fb7b3a1358044d6a5dfc852946415b79ceb4d6092e3956cb6fa402db4fb6e8b0e9b42ef468f27592cd3da1dd35219bb076845119ed0db5683aa9f7ca77ff77428914971c50689f73678172b564e25160c316ca6c1765ee9f99421b74c98926e778e698bd89ed9bbd2224dd07902133bca285ae54fba9fcb7af33a1c9cf1a3456f7684017a0463c72b0665b4f092c08ee84abb0495915735ebf8d1445ea4b52785f995915c5e60a9d4654048c0e9943400fa58067282fe3f84eacfdc304493e427a59728dcd80caca24238f7568d051968152b9f0e8b71631d28cad68fd05f73b31a5005812040da713bb7cbd28f755c24a62a2b9eba05ede232d21087d21453d96da196b192e40c6f5f80af1e26c11e6fd45409f171a19c77b0dd868970e69761026308fe7959f8ce3143413f3a7d0783d3e56a6b55c5d2e0ad01607b9614ea8361887abc7ee46edb43084c85deef27477063f83609860701f4cbb98f1773e446510d1052f787c66b9237a33a3634148063f70c09b5b4f3a79688400f2a5b2521eff169916ba6f44482e822d69e2afdeafea9f298a8d95c19d7d988b931efec06e26d72335facf5ac6b0d3d0e38b24aa04fcfc65f43885403c655c21952d712a8987c4fe623d42080987abcd7f227e44e72953624bede4587f8e458a04f913ae55fc2f7584f17f8b99871feb9424cc06f8c3d248e2c8146479e46165ceba99f8419d4a7de223929d792688baa3f866b9aa94d1f902fb5b11e915ed1396e75742fda224cc6cc2c8b278c71e13f910a2dffca707cb552cc2a1270faf6584111400a10d867f8e1cac684ad936eba3ec8b4bb2ed7a70a7948117d023b289b5f0796b95ae4fa4f310012511358ca02a9d81749f8e6a06e25437d845450d95624150f7b39ea4603d7179c587ba27749094fa519b26486950d6cc579ab77f8e58f4a542048e7235d5b148cc074607058b48b92574d8afe3789f2177ba5ccea42bd51ee4abb004507a3ee39f74ed0fdceba52b450339a335aaa986dd367b089056ff931a7f3e54e6888bddc953ee93885de9b7dfd4391a9d8f8f7c50c1ae29e79f46b61e860680ebe80cc4b703f9434d4b00caae94ce41941f3227796be5c8fe0b4c93688330d7fd3064cde692cfb181072ecec052de8dd0ecdc672289a71da7a2fc0c3ddcb2c174aae982d0b3645b1075d580f9da80c7d637f649f09ca0391b6c746fee76a681aaef543023ed0d07d7e6c782e6533838aa9f4aa4f5a5bcc6216f238f225751ff7cea83284855b2b4b769ad2e92cb31eca9c39f9eb12e3ebf8e00ebf34345eb109291050fd948100fc963d9d2343207b33d04883edde95ba43c7f163c7e664f242bb5a70e41e6069367dd1340a87671ab4d513aaf9a70838e33bbb1cbb64c7b4aeb97e631c52cfde8ece8c548d828665cbb94704f0c9fd90be270fad73a19879e999d5b290e4383c6cc3cb22f31def54760b6aa934d3e494f24d3cd1f85b04053d0e8a4dd956306d68ec2711eb36407dca23889baf42d0e25dde59307e71913ce3b91add8a466fce9686f8ed67a27049eb87cb1fbe47ed1dec51082d900761961a583a89335746f4dd515c863f4b09ae0545df7a335894838365c03d802b897f3a24f09f14bc412df7f6f80763bff59757b101a19830129fc3fcc4d3a754c246484f7355f1e2635d22ebb97aca5a25590131793926299709769ec89518d6706cd5de1346b3da8d01fe8a55251d1717a722387e0b8cfaa71605cccbca9e763e0016fac713faf94a3bc4546599014cb947774466a7a487edfbecb0ec97f7d57485afca920f2c9bf2581893c66883901555e90fb8bb8f34ac3f3fb19829a2917c2bf1425aa4ae8062435aa7f3bdbcf91715b303f710444838b8f1b53b93632d53f55fdf9687e357ef5146d453c5a33b60ce80c42b4b00b800254fb39ed4c51701e1a6fa20fb69975cec68f9b7fa8c4e35bfe8a90a091d5dab04b89bff88657d4eb5c1bca111e26f46d4e1779c63aab42c7724dd6768d827a72c15468009f25f1f608da33e8d76ca0034891e5ae2d275936b9938bddc20447fccf04a237932e9c5ef1451290a45c5dc608565b994e158fc4ff20fda3413cb037213af0ab680b499cd0fb973471d30884e49f1ce09def209f82d312a3a9657686b51c8300de59677a106f2b95056f4aefc6fc2d007e005e28288a6eb7c94b03c2e6e339e9776bf6f8f342b37afbfa162f3a20b74f07716270ae884f141103142d32539e0232a3714c5d29bba32a656e0c1564ae8264ae89aaa96fc01b8d541cbcfa8d3984968d7767f7aab89a6ecf0592a2fd02ac227c6b0942cdb880af13eed5446b9a90c00856468262de6b89bf53c595306851b702284484ad539b9c353d9347d0c65d89f714c4b941bd426fd2471165376f7ccc7982e45797feca06e48c96eb5090e07cad4d02d38e3e8f2ac7a31389cab61d61706e24b92b60116c60aad0a2cef3661836731f37f1e7d14f4e2cceeeb62fe927ab3ab7f90abb04c9f4b892f298f46ee66fab35b26a046972e4e314e341dec7c2462a028cda21e2b084a968cc0b49075b9108c7561e16b949c9aabe4a6f3ad4acda8820dd814d42b173a2c0c139d22671cc50996f21cf1c9072564d2d55a5aea99fe31a70b33a4aa431fb8cd7fc295069685209aca26ecf9e7243c7aa201d13e6eb4c42627981ad2b3acfac86aa151405ead94fcb038951c2af72d272b9b65e4a9bf65d8378df3fd171c3410df249736f4e0eb538d77b11c81f3c93fb4d073bd8f9c4b2d3353d1cfa9b8129c74768e57c8eb817b4ed2e0ddac81fc4d9500ac1a49c9e2fb8843e7a1dcf340e044e4030b0cd3e18d356305a27042f113a0a54972c1e7c7d954f3564acf03e2ad20cee6c1c289549e006a483cb3a213462cfde4c223958a965b53cabbae0254c1f699be69374eab889f891c85818073e4ecee209b981908d751e83213abdbec30cfc643cda91e971168c0b4ca236ff7fbfef234ce81642edd19597e7e5cde2e47bc384d849753112ec40c29de63ce98482276d05b9b03742d4df31d7a914653b07ea682273a880e2a2fac4a16735e230d6e5d2958a64390d7475f4b0c12634db93ab0e89671015d72a3173bdb02421236e862bce398c0eb5f523139206793b4955e1b917b7cc96f615793fed1084673aeb653896c3afb83c357f3e8ae599307301c882ecf67c2b8eb0d92d41b92ca7dee6ebad9c47a0f47a5c604556e26cb9117597e2d084e39c9d01a2b0a5717d0e40d89df9960874a2623760be4d231c8fdc330408bf7c584474d4d316486530ff86eb7cf9e88e8f43ae88f0446120006aa3c5fe08cf3cf98d392c0933ac0914dc20cc6185a00d22c67730801b79fb035eb62034b4cfda99a258bd592d1c91704e710711f18af5b6baee28c909f053614d7f3f08e6bc3d19fbbf7b4ac0f32b60c4494cbfa11765519b7ea44e74a64b42fd752bfd46d4ab092b9c580d041a40b19e9d80d010efabf1b6f13151a8ce664d8b8b5446cbcb0bbc5dfa8e0fd420d38bb7ba3d9696d0801af10d3e0613d56ea6d23899801a2458b17ebd7b21cc6c46bc149f66480f36e47b393c1b1f7b9915f987a82631352414283938465cbe30c360748f5cf308bfd78e675546de02a96ee762f5cf38e041fb483b24b6c5807f94cc6df344eaf59684380a24db1c42d54151a4e70a19d6451ebd78b65d0c51f4fd178fd59674f83033683bc6b00880a362fcbf2fdc9509503c92ac80a3f4f083fad61160976430b6e8266acb96e626caf9e267ba0536d8b3ca51a2d2cadb569f910c77dc0a9b7f42e6054b65ae8f8184aa3bfd57f5acd0af01d56a8db133a1363a1d74b4e6ef3ad276c3aab040dfbee44a61d64c51c403c0613209133806558a19206bdc812aa5a32cf4dee5a97de48e6c470c70e47f81faff854aca86fcd65db0e868981f003a1b56a4fcddd575a9527aa1318997471f7bb0dd9196b96cc50c95aa5a3401258c2b7798382a6612f405447e05c8763eb89cb2a960b7f47d92c5b4c44bf063a514ed1c28129ce215fc18480a74742aa44be41aea863e8bb13fc3e9356ae4d566826f79eb031914da111df9e478ab14bb9cf463bc91412685de86e0ec1c82ccfacd24f6b28cd4f8516e353b5096ebad71136802a60843a07e0eae3c50c34fa692f2d6a0a6a1cc37c4740da38e238482f9205924844978872e653e01025a9145201d7fed5810133cca07651ac04240ba306511b6cac90eae1111821b29ab648e74d15edcc34440f740f0e40301ec4328e61a52ebea700301d947d7fd80446982269c2db18b2c09183d0c035949d74c4c4a5cc493c2a6078f871510b4ad8dd4450c8e09aaafa56e37ce851e502320e42fd6f85cc0098f9bd81315106289431f117a51f34c22b55ebc296e26e8b4deb3ee4f9aef582589928b7cb852eb571a9a42661234d186acf625f1e53c32e00f2fb3a0670506a0890e72af89c1db3fdc117d16a51b6e22217ab307e856f6eeea954c1a8ce69f00472811e56e67ac4d25bb6fe7d7f4895110b97c668d6ad40366ce31e961507a421e66514542d28e0637d412bcf0be221c185df53d0edad5a1e40b00623661d78092b5d4f471f5ea0f96fb497fb46c89382ca08767883f256d62d1b3c41baf1927d85feb1ec415191190fc3174601bbd76ae381db22a778027ea0a4574fdfb0698bfb6146acba63d5bf3accdecb4b26acaba95fd76d61659da656bcea23d7b7336ad6c35b26fcbba996d4b564dd95a676bf7b40c9fcdebb77737629a61053a485df9f0df993363a304656eb5502dc33e44f72bcae6195d50147a1fc02da6fdc3e58e370381a43da89f9b6a73e5bf4aa83f1535f073a26a3d0d190e3a49e0e00602f6c84e961e51136309c64a007a23db0c99d5b7262afcd8406d10b49219d40498fe071c1294bf584c3006535b93ce433e4cd1d64e04ef8b4e8404669da0d7466f4f7357b889c42b05dfd0bd9d7fb61cfbfde0a6f9e18f594303f9c5ce24e5187f57aac5ac68887a9cafd19001bc8931a3e38164d26b8dd943e9204bdd5a29a45f5be0ddc99cc8d935a7e48a0d435fbcdcf36c9ec8922af3e54ce56de34b4a186b7740ad624df08e2df6a6551eae630358970ca6ab0759d7ea9e672643ebe2c0aecb126c5d28205006e2d085c9adb88d8df9d3200ef39467a7e3777cbeb503ff64bc92cc8fd31d216cfbec053a7ef7fb5dcce8adb0d49d1d7ad76c02c4c7026a308e745e40d019750ed60a3e0ed30f30ec90f4abc87c00e4aded8752c951ef8bb8776d6f3792b2b7adf8afcc4da7292bb28ebb0f182b7bf348f51c28f3f8d0e485cb7dd9660c8ea2c6dc2783e27f05ca1b6e2674a3b4ff1ebfe1bb7e2f6d2265922923074a075c074f4e3cde76a84f113500979f226a812cff7b9411d23e8a99b3f261093cad2eab0b1270b44b1d21b553e95442c294128a6397de0af3c5c45b9ec4be7838c8588f09af5da7d5ba8829691924b125d91f5cb3e36ea35dea082a21e1689732da95463b94d16eb4c3a35d922432353225b30d99469349059750bec6532e495cd6d387d2437152524b3828ed94784a4e346adfaa58930559d086f6644bba6cff64c4cad8b7f674e9992323de1aed5cd6db729735b63a41e995d4120e4a3b25274a3c2a25d554524125152ca961493d95d492ee64e46424fb5b143307f525514f4e613aa89bad865f3c97de4973d9776722a9e3d25311d99c5e45b402cea20fcd1c161657e95c562b6383dc78882c31c840224d945dbb52a39d2ea7301ccc46cbf8a74c98ce6df9cd06c381a9edf22f99af27af93f9627223fbab747706a3b9acd6c54bc9ab747989cb9afd452215be2c3a5f3c1290e96887726dd9fe57cba9780acd9c9533b6de96e327f8090d089b0e3870d0fde0b143c710e21884156c5e1b6a34633bedd26997efc00dd12d201a1522af4570b71fb47ff16eab07536938423002d219bbb52b08642a96221bf15750cc9c15a5158f9f58179f2456e6c373f446cb3e4b1a55f9d43fbd0b42a25b20dc6d81728e8296307d2a83a6ffd152108f4bef45f5d8888895f93e2e3d2764fae2bd787796daddd46e85195b6346623bd28cf524b12e62455ae6b38408cf65b1218dc6a6c8fe2a9f24b11aedd3bbb3181020246c20dc9dc574002d8123fbc770d0657fd399cae4f4d34373fae97d4e3f3d1dd9bff4e90d91fd51ce9e3d5311c4935fbc179376f98f885817af25bc9a302232e29550ca884d6a87da41a6a9544a64233e69c6d676f97f3792a82e8b1d19cd18ae5dfe243366a3dd594c47131d03a25b42623ee85c16e3a151df21310417e447f6a7f188eda8655e4ff62f4d94f9eac154184ebbfc3fab7501ab0176c30709a333767b05814c5f3cb3d72e1fed564c9727de7226a475194d97bcc284d16ecb7fc584a9b7e58fd73b7bf17c95c9af9ea3252051a6785bf64b937c61315fce72e541a66d977dd4ca6a5489a74bcf51948955f54589c2189a39a80751a7e8e2d222b249a56e8a6c6961616111d9b8f4be0fbfa82e4f52281e200046d1c430a368e23025a524b251e9543a952eb5bb33d25b36b5667f14145264934aa5445a4e473bd2683412b93c71d47f14d9b8f41cf50f896c463240c8f4e5d2cbfe30d565e968979dc7e4d57b3d7159fac2c5653bda352c04fac0c41006fbc06f846f8adb6619d997dd543c024c84d211f46948fc1414e64fc1dcdf346eda6cddec76b5cbb3ff271539915351ee22889f76dd0f41f9fe17caf7f198ef83a27c5f1cb50bbbb48074017fdf0702817e85ce9fcf7bf82268a61d45c6b980099ccbbbb71e38e2ae870a98c0010980480b58a004273d9abcb0393081c70836000104e787b71f7233edbfd8c48e5e21ba4bb1b4a61e895fcdf8c4dd0469ffe610be6eefc874b3a9695ab49dc321101008b63ec2d726f97830cfbd4ab8053fb23f74dd3ac63c5efe61f00b4b1693a33d440fd11847572214ab17c8ba12c2cf178adf2784472013a01d2d0802ef4802c751440281a371341a81584a53c962129f30b9988307efca65160cb1f8f93107e3388ee3388ef8c3529a4a169308c4f448847a9592b98fe07885c5380f7ca00845dc30451155ac322308020a1d54e083257c5044b8432fe702231401831228200837f4e002101ce1022260228adc38b598a96991c2cded4307b79ca24d1831626b16078fdbfbfdb6bbdbf6f8390dd011d0dc6fb1ac1fdf7bef3dd540daef0fdb9c42208b38549e846cb6765bfd322d06e05e4fbbbbbb6ddbb6677aefbda9cd316fda76c17c00006f506b8537a8a1e20d58a0cf289a68808289078bd0aa7b24cb9bf82a70f57dbff208272e5fe7bb1fbe9f792f398a4e509e1c4f35bca08c2a4f5c524a2da614914d7fb39852dd2ae38a725d117159a2ba57ac9c522b4436fd7d6f2aedee6e9691b4432ef79f88106a194f4420bb01fde2dbb9adfe1a3fdd20e59483d28b0bcabfd8c81fdb8549d2698ee2bdf77eb6d1496b57ff354f39508d2b087e662ae6743576d380ba51f8b0c49ce27b84b4bbbbd38b3fbdf7de27b16dd709c26020771f4404502ef703a0c4e9bdf7deef86cdf43f98d1a50ad2feedeeaeb5ab31c618c78c2a4f1c340569cbf5a662005c2e13001b7a8d2dea33e5802ef75f33fd70f9fee906a46df30519914dffd8f7f66b4400263e4c43fe80665e6e5f775663f7aad1831d3ec510348a2e73e5d691dfdbef94c9658fd0388e2de20f4711fa25ae715b2f3c41993c3e29d00309a23904af686461d4e866b4e0330978cbbf067e7c8a2312097fa2e8460d9fd0a3c787410bda282e08a2e0c3d6f27c600d42d6c900e4fed196775653734fdb2e77e5fef1beee2c3c6bbce55fe3c495d998dcdfb8cd9adb62218aec8fe67bb2f840da07d1fc0120df16fdeadc6ce53a97b5b2e83299dc1f0247200e68f0f997b7fc5f2f479320eda7af0f77ce6720041ae42f8a88210619489597a1cca6d3db80be28220619c88cfa18641073f916b04fc82bcf1a41d3a088a0694a21689a94a621df9f9543d390de9f0582a619df9f8543d388de9fe5cfbaa16942efcfb2a1695035344dd9342befcfbad134a6f7677da06954de9f65a3694e4d03be7fdb02d03e470ab4d70bd5a72c131840f5fea1d40a73d52efb2b136d987d56b6cfa265ec28db178d29d93e8954c9f6534ed97e0995eda394be52da4791d9da3fd957b16f4a317368af17e6cc0b93249d39b47f61fe2803640efd6866a0cca133c73c55260e8e0dffa27b00694bb66fc3eb45376ca563f6431f381a4fb35f986f5ad08b5904e814db65ff66092339e73298228d3a8c68c2dc6068ed72181dddba7182881b1e97c10cd1684b103042b4dc5c060344a3fe303874ab078920b81fe5e501e4b6233b8cedc7106074c84ecb2718980bc89bf5ce5e77c6c5acb92dfb2d668cdbb2cf62ce788180108c90cd885d861db5b71532cd17d9dcaceb5adee8ee8ce5c7cb8bc846c6eee687ee4627a3d6406cd93f1443859b7105d10ad6ae30dec8d8c91865c810d9c8d8c9a83541a62c15c82efbb380d4582c160b87cbd2176664d410f06286929d622aa61662087e28bea6db7e41a1e6567960a461855b2039b85f10530cfa8a41d1eeb6f9763f880a1e90a5c924846ce1683f15319fc1131d79100231212f15e4cde03d7f0cf24158888033a1ca2a5048642934c28146d1f7d7238a21f839a9bce084a2f875682d575e3473cac7a6cc26f3c1511cb453560bcb1e78b8c97090e1c86ce8e480fb91db71848e9e9223254cd56547e94ea7279d9e5c2182eed02944746de5b46e2d5ccb081492643fad1d982abeac1041a7407728917c13a16b2ba765440b87b2922bbaa2ebe74477a06b6be7a482a25a554854bc550c563aab9d5512bc554e8544b5aa78ab18ac745649ac76543c154fc553f1543c156f95e3f1d6d24acf49a3f6512a0a07a81d140fca0930142d4a777272eaa154140e503b2827503c204a0d51aa8852512a4a45a9281d8fb7aa9c4ea06933c9cc31bd488627179ecb1271b4a694905a553d2a29504812a6bde078cbdfc254194d862353dbc5c4ba90d958f284e7b25813d98dec2f32c9a335a504951428a3951cada475b48ed6d14a9298f078246965c2e3ad94d4d20d5a13399d901430144b5fa9e7455d3147497a7a46ab0b8f17eb955268202da489b412eda3956c8eca93a11d159cce0d07cdd11a4ced81a9351e6f7d5149a590b8f2a2f6f07a7ee476e838a2a7e4c890958f08655dd79c0e2de35f9ab09ddb729c0e2c470d868364c268251386b343f657f5dc19cc765b3ceb02a6f6c06ef042274c5d7beb7a12cd1cd319ebdd96e32755e49bc80432633cedfa91cb3a1a3d22f7941c2932244869a2a988ce180ea68a9f24ab4832735024eac3e4d3fb3801a9201c8076403c20275048d26741ba97179ac75ed43b4bc57a312631defa61625dc4947c9c24f9f45c163bb2e4c324df44201008040a4128201244027d205585a9ba33865b93ace26764c67aedf2274d1af558ae5d3a3c767410918768947704a713a466cb299953d8c984a9b81cd38baa9eea6a325f70ac8be9925126cc06ab852a3015a6c2682a2716f345757ece177535aa9c588ca299a3f2a1cad9d2c2c2c2925a532991cd8b2a04ed0567056a09b0357e3ee27812c31735046a0299c2d4d48bd48b97f5ce60bcdbcbbceca0c9146fab47d5d3b3f2d675258d4623d15d452f382fea6885a92f6a6d85a9301c180d86631d4320d8470443f0c395dc015584404cc8fe10e9de8bf1bd185bb3afdf11926c99b85bebd65e6b7138bff172185f8c2fc6f7da1ac617861ad731beee175f7caf5fb7d6bfd0ba756bdd5a6bad75ebd65a6bad75ebd6bab5d65aebd6adb5b649a4ee878157c35ab76edd5ab7d65acb840913263c575de5f5e8a1d3e574ba9ccd91c3d66ef6666b6e1d06186a58b76eddfb3572d3ba756bdd5ab7d64bdb1f91026eb6f6ad75ebd731be8ef175c717e3f302e48adbd3758ef60b11ea552abb79ffca8ad4f78ad7db72fcc4cadcc091fb3f1c5af609e1b21494d249447eff0744bbf832400681c4a736d151f2dd8e645aff90203dfb68b3af896ef9a79827f7631e3dfb729f10ac44eec73b5a36fee849df299ac14f59b99f45bbf8ac56c6bf7cd487ac5f0c8ea02584a228fa58d10ae3879462f9d0cc493d3665b476f9a798321c8efa931e8fe594a929590ed95f8643cbc86ab1264c9434eaef329b93ecae930a4140a6ae5cf6bb735bf6579837775bb8ecca95e5a3945f429f4075a81010ed699da0556bdd5a418429258b22b6745c4aac3945656a64ead21bed62ab915d0ffa8475112b820a2182ea5c161b3205fa44aed1d09e3b8b01d13a81ad55bbb3980ead2070b46e2e8be1a0437b7ea03d680fda8382f688684f4bc7a5844b89ecffb93a25a8d3ae100a0a4aa99492a2daa9a650adab9cd56d855b19b1da41795453a876aa7595b3baad8c58e154ab6a55adaa55b5aad6d50eca83f2944aa5941493e9c43b2d39f55048a070a81c6a091308b4289e1491d39213efd4432181c2a19640e54ca71ee8d4034fbd53efd43b7d8ae24911491149315f01a4a95bfef84cbf0757f2730d6c03e219ff1a7ca69fed493acaa20999ceccb448bdd742665f94db47127a5c1eee462f037000427d4a91eb73898e64bbadbb3f0dd91380667f3f5147ad0fa0cb30dac487dc3e7a446498dc3e7a6a16a9509bec72e88a9fb77fc13ba66e5e6c501c41f1ad68019dc5ffc0053416a9e02dba6965ff14f868021c0541a8573e9ae49a10914376b4f9f35f1564a7becff7680e1ffcce04a039bc6668bf07dfa6c0ef0f7c34e3dc6fe2948b6cbe13e404f2fb4edd78fe3e03134869e86c4537e07f672a62805801f04c81ff3d3e53e09900347fdf294a36110a81a820fb437d47a99bed996a2063cff6ace1ded1d19ef9c14d645711ea55da50a83b77761ec9fd9fb5694edf3a247875b448cf6088474825b9eec1632337cb77cbbbdc19eb5160a10249d12891212d83d1e3288c291a8d420683c70cc67a5b3bdcd3341f11d35859e5c5fcd48ad57fdf1ffa404e30126b4f971cb2a69512153aa9780855ae98544e1f8d86a34322ee618361bb333cf6b08142a36804a2a254a2d56c3ed8a877c6e2b9f9b0edf85059b813ec06998a6f8aa0ff748020411f4d7c54456403a6cc1cd60a16fa8205c3ebc5a86bbb3cc9911db1d62edf71840e2286d8f104c9dd1f3b371e5cfda0e26d854e634b102db71b24372beb4b1038e4161149930aae5d37485c06f3430708fa72e47099cd67e24511a9f0c9df89429d4abcbaecb4f9d9439fb753c8a93ba5e8b3c7cf9db5d65a6bedd9cbd69e3cf24947a5d56c377bf670dacedb29e4d49d529c3de7eec7edbc9db7f376deceddb923cf5ef63f994410fd127767af195c2a956261696169c1b518d1b2d382a4656d59d2c26be9b9d45a8c68c1b5ecb4ecb4ecb4ecb4ecb4ecb42069595b96b4f05a7a2dbd969e4b8d85e5665d57be96db4d929bb5dc29932873e59292573a297b2b2aeb5f1cadd85a1449b22cd1992e0a2f1f75a3fba15bcb24ca9d32f7a633f72a672e57e64465ae5c52f24a27656f451dada83a56d4155bf647953647f52b660e8bff542db7204dbc80ec98ce1446c9ab9c29cc91123ccf96db9dadd2965bcb7f8bf92de6bb886c4e3ff3438a66f06395a295f22689db9b5526043f56979d705c06bacc8ca1ddd6cd12a2f4bbc77ae2470f1e43ec909acc271527e4bfc806b4f608b24d7e1385cd8dee477e31718a30d9145d8a90941e530e269a690753cd6463fd9b70ba20b317baa332592aad66bbb5e06e4b852fb34c196b8a90149dcb626ca4f4f4a4f4a4f4a4f4a43cc194838966dac15433d9726c2aa7941cf6ef4cc9ddd98a8c49c965275f463bd20ea41aa907928d742349d20e4c8f4c8eb191fd53f4d3ef54ccacdc0e4ee7b65837968d05cb46b37040d0c9526574d8a5e46847da815423f540b2916ea133852922a2ce14e6487996a733856992fd47bb1ce9869276b23f58e2916ea4bbb35297fd47243c94d871840e1e7e041952440788cf8a30179069ffb8992f37b73b7bf4164590277ee828724449f75e6c3edc52960a2304523c552b918d8c5a0b4235fe593f483e3c5010a01be805201d10ceb452a2702a201e193b19abc73e483eeb87070a027403bd00f5e1951fdeca8767faf054403810eef4b5f8a2d35141e668010a2f8f82c8067c33466d1746128393636cc0041952e488926f820e181c15a46d819a90dfbbe41ce40780f153bf1b1fed4be2dbf99668f4cb39eb4b52144fdf0e0556cd06be4c66d11cf57fe520bf18b5c76b170c4cae5d3b36181edd4a4289ecef303b1a3dc265303a6078e8967f107248798bfccad2c9fea78f0788ecfff190df8e7583c9aaa165541c9a8879986731ef93b1f99f99a2d9ba75e1d6368d858939808eec9f5317b080d50174d872ea029c2ca0a772d1fc7061cb81a6a2f9e1c29603ed0c40ac880c27e3860cf58c1591e164dc90a19aaf26d9df498f8ea75d30433a8a0c13a495e42e4c139e8e517b4091ebd1049d14bcd06a361f6e3f647f1303d9c9d8ddd9cd7a5bbe7b35b1c178b2ff69c6a82c54374e5ac6ba71d373194b158d42a872c5a4f2a556841f11c40db32f7ec215a94f6525db37adc8f65752d97e890ab964fb23d1bbf80957a43e9476d907c58f2934127db68f2a554ce6ca57b2305566c9e24f124647f667d95c5a584c56ed34735bd6621f636c313131426274313dacf4cb4fcb948ce1bd98328c784b88ee452a7c9ea831b63b8309d22dff21d98b647fd4999247b27f79a6e55592fd57cef4617aac9cc6d86074ede2c9c53c91795c06f3a351213db2ce65303c1a8de9b9339821ba05b343ca694c0f8c8e981e9cb26278ac12b48cbf69b2d44b63d54c568e76f9af4c96cd3c41f67f11a9e0925f422059aa79c33ee105eb6f8498b275194aa3a0af713c92edb2af3259982898e86dd96799afdbb2ef62ced47c268c01ac5a9c318fd9efb19b86c53b6afb43b3d88c8c00299afed2865c8c2195ea2c00ca00291ca000a21564eceefd64ac8eba0c233507185f4c9c973f1faf2ebbc93946d2b29b251ad5b93319b5db92a265374e748fcb6e787c8a96b504d1288c9dcb5a6e0e63bdb31bdd6df9b358ff654992406a3a59249172da3dd606b2f3a1667f9619838209c3c2845199302b4cc834593774cbff4dd608bae57f9a383688019fadaafb7c6c02966c0b94fbddce2cceb6ee8f320eadd8416e1e19acd9eaf8d6a62140d3e01ff95a1e764768c3d06f90eb856e1de351b6a6cd3bf688962290a4cb68387a653db60cb471fba10c149fbc33fbc25e914d0ce05bd2d1d4cecc26719be1d89c9017f4e0f119cea72604099dac7d08f18194db47143bbb2584007d421f855fe33db278a6a50b3524e0a8cdf6c91ac8efa401980b95f07d21f88920187ee2e745b2ecf9107ec0d3e600f347968f7e38d0be2d4ed3d4d02e4c760377169a6e1045922c7962b4eb26b526203fa31c9aa919e187e70cf645f834bc382d4ebbacba81dbb235b48cbfbdc194432b20f1498e3cc45b9350af529097311e292153dfc998c751acc206fce628d6c12f4390a9ddddbc87a3f89b275242a6bd668cfd92dfe479ddaaf7aa30cad716e916fe941c41c67ebe98800cf3e8fb8a7ac50ec8db34bd44c6ef367ad66f8b34cd97f13b103d4b799c3a0f19a7ae43c68e43c6b649c656893d92f1a73e44c6ae23e34f7d47c6e5ccf7acbfa6672927795ba5b36f6b74da537796397c1b86e16e7403297ef8280d6812dada9da5520f206978417ebf201fbffbd0343697d91e6b5a22edc24f9a56775bf83d05edc206a165f0637b3bc001449124cbf2dfde422b20c5d3fa80f18778902999317e2b5a6194c3d3eeda853fc404e99fda5d96c1510c03123cc79012a4fd1483bcd143f68e726884d28026bad3ea0851047f4b8415c265a4b78f5bf6bd7db165a3b73fb60ce54cd9a721dbd33fc69dd9174e7a1fbda3bcff8c94f7d0272c39eab666d5db1a9d7606597ef39c69f732fae518f834d10087e258085f0c724c14d9dd19f8fb19345cf681dff781268d1674f893851ff8cda0f1e1d344762e9d81a17bff1f72d9045403bf07effd3e77ebd62dbe9fbdd7da0ffcbe2f6d9e2fdb967d367f7fcf5402f297e4484ed1b15704c50894239280829cae922c21a7abd1073a068c711c47b006468c9a181e93428c2e2626c838de252461083925c517f848d28271a62685196badb5b606468f070a8b718dfd9a182eb3a4252d69491b0346e76e0c6b6b62d87b8eafacb3d6f6f591c44692412e1e6fe87ef7ded3fdfa2dcf14fcee776ffaa3986158b7d6de247c2097d8078d82df7ee7eeabeffddcd76979efbd3e92ecc82999fdf2c899584a9389e5ff9fa534994a1613cb0b0c920021a7affc79050e3e0882e07ffebec6dfea402941bb917c3ea411212e011cf55b7834a6450d8c182ccca0e1aa8f205f2b84ab12a0c09d85efa7a5dd16ce0b0f646a6b57028e51f0045412b0756c2db68ec3f009fcb98155803dc4eed843ec1d72db1883216cde8c3dc4eed8433cda46bfb40316f71de1ef139384beeffb569205ade5b0dd88c440fc7c5ae6f184e1aef7b3a22b4a81db42d941a6ff2b12fba702dc2b059586a396c3766381480b3198d1434434c5db2a2fd903468b18af3bfb7ffde3704ddc01125cb9aae142af3eb82c7d51408619541a8e5a0edb8d480c88c4ac3ea050e87c01b47e4c3991651593d35e29d0d2841587fde34157135267b0b4eeb1347bb344e08ed8c9d17852030a178c3c79dd99149a46fc942c33e83f34ee8c745a5a4fa3e1cf68e17e8b674a059bc570c68c940693bcaddb020f99b6ee6febb644396511484b9b5123634bb3344b9b01a385cfbfbcf5caa5d034fe02ab107b6ca0e020d3ff958d138c6dbbdb7ea374063c05ca09d916c9edf59a6991426afab8e0adfbe268ca3de049e35c0199a2284b4ce9b9ff8687a096504318866118c2c92cc4a882c47dbf573df4b96d8c572e4b2d4a8328d6a004f1476d0542439f7ee85f2e5b350afa7e720cc5475d00fdfdd1ec4641e3a32e1bcf74862c8266382a9e68588548f4d9e0633a851460fc50d33c4f8ce2071c4d17bc45c30619fab485aae6d0398a3940bf6fe1b2fb42c6230ce4c71465185bccb468b11ac927bf25e020f15143d1574c8b303c59f0336d1e91280732fd5f611b66b0f0c413334d4a3fa39067df166914e3ad9213127c23370468b40008c8f8ef83670ce0c720f3b9c829c00009d02e1a15f20567daf51160858cffd2006f8c8cbf2c4753eccf53a0cc1f266fcf806744179b9436c41f943534128cf13341bcb3264520847a257e3e663779898020085eec1698217f39210e75b7997e8966239f91ecf8219d344667dfd66ddd56e844fd6421464f8ad2a8218117609881b4b41afafa21a645f3806c8cf9426d205374d5e8f7ff7d4a2334bfd1cf858c573568dc7f979565f7e4fbab5048f4d004a23f81c1ffc2300c2f36ddec3347fc447c794216ff75fbb5fd3efbb5f5156cbbee7fd79aee836bde7cfb76dfbe2e5ac1f3c5dfb7e71c506c528220549268c68dbf05978d8d760bbf7ae6ce6aba8563b030c36562a3b851fc9ecb290cf91bc50c82a70566c81f7612520d41da171ba587c87d7fec6ebdad7577777777f7b6eeefeef6dbbb65bc143f156d4d07166733f62d4e672a807f46864f17c59b5ea8140c181072d8a9990100000003170000200c0806c4a2e1344bc3b8580f14000e6186485e4e48184763e124cb61104741c610838c018018640c2142344324007d06a4ae129d84897fe9d6d6f55f91f4d626be913155b8b1ce6a629bc442464b41375f54ffb8626ff16b1419316813f5a496818f553b3cdbee9cd23713470fad90c3efb77d8c14971bdb7caf28e26808beea9bc8b9244bc308718e691c81d32c3c53118ccc8b711fbb4f69d58b2e4417bda629b2f8c678ae57a7acdeee43cf7afda5687304f89bebc4a271502926527d0c55343b35d8c82c48b23beb54b3a74e477d7516d7fed4f512a6e2926981d6e2e660c5d002adb371b3153aa722a6930a0b41136c3a94eefaf69b70e012b6742b38387096a2ed56f6263c00fa701108e3ce49a0477c78ced4a241d98b09be5debab211af212313779de5cce09e6458916c8d60287d909ed5f9c23ea111b30d037ada18f32e7095970d003e90206aabffaedcd7cde3a0fb58b44716e8f4bc347ed6f2a493bf904e11aeffaa1a85c15aa0e7838ec6a9267a788bb90d28a848a6ddd984e9bacf47d7b9685206c0fc2d6e768e5d02ca260cc87d17dad51bd65e528d93e4c46e4fb248ff318c2d57e41ba8a7cb4369b0edb891b63756929552dc2ba4a205b80ab401d065e3f2767cf6cef6737525dc0e79912e14c21f8949c62db2cf975c665165cc60b55286d815eb393e6cf1e4820264f09522de2f5a6ca9c4967a13a8d84b247ecfd5f429b2757e36fa2f0cb6474257592abe885886eb62f72d8897975a42140fa990de2fc14828f82a8115c3fbca8df11e85285eb15b9da11a3e70653f107edc80f2a6afb81cb5bc0f773d811e1fecbb4aec39c055488de0c526ff80814d9c5e2788c514bf4ba9a46a665af5524b551131a81a0f17d629d64b3951d3ad3fe610a5eaf34fd602c687600d0db40f821691245c34aeebea4b066a94ff7d0c04eb668c95e137a581640a07eac4f2ceb5d34f98f802c9a4d5b79a22839a216a98ecd1167e3a63247606f060b594be449ea4dc80e1c2cea72e9f28ab4b457581ae7930e7a6af34a77d76b69aced4422c491198766a45b40bb25d1bbdbd6d2474a6fe83b4dbce64de7974746a3ca5a9c8e74bd5f579d895bc05d47432c407f2926a9885ca7eaf7c2e106827fb5cacb722c8a0e443a57c960580db4a1d9d260b3dfb2bf41d6d2802522b5523f28f8ae742cf867ce46ce4e2841581aba40059adfd64903bbac33f32eb932edbc516b82a849ee74571f8846147c78350894d17c1b64fb9eb30b44a375b907bfd4bb675538a3de71c49a288ffcbc01ac71589b7dc6280f8fc1342be8a28ade8485fb459d892935ac686605486de40152ab21f61f275ceb386ece92b6ee66178a2ec1de83b11135b0dc56e39a850e1249a02370ac431cba016466932efd0d28eba30a1f242f2414338d003da2772815733b9c9b8f4ec74bb7cecc961edbd7625e6efe4dfb94edcc3685608b76834cb6cf7b0dd67efabcdd1d650cd42d73335a2050d870eced607b3c1c2e53764070c9a4080573f665e70e5ae79fe2bc7e2b9ef76b31849b6116096f6adb8d2f26d771d126d89f3fa1537a00bd6dfca33efa72e23bc0b4920075494f445dc42bf7c49f8c9d3bcbc413d777e6e554456d698a612d8c21515364b41b1829d29f621d18d0f533675ff1b0af52cbda5b6b3b6c77def8279850870dd833e2305707dfe6e24e712f0271797a8951c1ab1eeb9bf359e3feabee097e5acea02877acebb41b9871d4fcee47d5d94c7fc196182060e3a0f3d0519c34b14b7bd8a33f26b836a85889a2b1c903afe0a235a720eae4bcacca6c1d4eabaacce3929c81af899087c86f31ed4ef2c116034e3402647720a236758a5a1080ef3b64964c9c91c88f8887b533b44ab8d393b1eef6e36c93d5ec594c9a5856173c46a5d8e220b112bc0e416d897bcc0895aa9b12e5adc3e4ae3d022a3969a5491df064ea52153405d9b738b36d3a1542cc47dca5cb7467ffc28e0a7051e1ffe11b373ac2ce529b0b3928086cbc80b0a7e6035415a20c4823e101bf5eb06fbc36740a071114efc18c90472ec11175be7ab7ea9e0952ba57f27a23ab1fe055c9b9f332ca2286c0f5a9afd02ade44f044cfbe630347149da06d22325ec3fe47a7c1260f317543700365d02c7be4baf5004b0b6bfa7243e5dd45498535e8deeb0dbef70eaab8d67564c2f14a3709b6fd58728827f385e0e8b3441c7252f311a9d24df30348d1eda158db76bc61f28f4cfd55c9a796b2763b5fa55335b24cf1909414aaea1ea16f0172b70afabd6c82ea515b03b6cffc5ed0c1d4a077490f8b7f6f84cab2b59f8afb224c74df5bce73a2a5e2c92a2738989b43c023cde7444fdc3ac7c518e9147d5c4efc08fc882b37227fb412cc933000b6bfc2f405405e80b0ed4c26d5b86ebdf425d6a805bdec9487f6aa427a0d4ea0d9d8fffbea9d40087bb3249e2154548846997d75d07cfffe8f1eb831733d09b60003cb95c0da1d05cfca9d02ccfeb8d56af935c162a03fb47782f66436a8046a6b0c208082124b4200eacb9e5b2674d9b6d2623945ba75d1b5a51043796b8eaf1ea5845cdbd4d4ae63a016141e2bff8f426fdaaa0f948624de2937afb850cbb54dc7ebc9a091c48754dc49d1aeadb8bad68c344aea7cd538ce92cfd37aefe15d68dfa6addec3b657305b669fbe8b619080d4f672f743391fe3761375c8ede592e9932a90d46a625f1a2b686c1bc559a35513237c0d5076fd6a40b5e691bb15b3f9520d76dd2f5e6f7e0177d2b27f9d2d4790c616b3b8c67106b6bb935ae634ca66661f95562985e5d2a95455d69abb505d0257655155387e523c1d7786ae278d56ab37acaeb38f2f6014c259351d88fa84f83518ca8bb8ac958b85263af08fec8b375c8280e3643bb3a676a24145f46b188c5b932486b12f5bcbabac265c21db6c20d4e43e1397af8293be619e8e58ab23638bee3a4a945324fbb7d0bf676b3bd2ba9952788d6646c5d98a882860c8d3a9864fe8bc2cda606f4681ce2a6af4b3f0121815e4968731ae084863372f634aa2b2be8773acaf2cbe9fbb36bee8476a7c5048eda65bb9662c8c74fe15852c4e3eb39cb2dd50af91269e7912ee29d42b0903a1ca5a1de2104474e396c74aa8bd71e9865676c6c46f8b0c31d4460b204b211362aadb5990264b7b26c9f65e65d9ad02105780681680d50284ba00d0d9da50fda4da2167004b220b6701a52e4d2fb2623f3892684a85024f19abd795d98ae9c99cab32794d148c8626700d66b1b5903c582544b54b2951339b9e90119c6420f0e246e8e66f30bc95b6cd2db686b0125f8e8d6fbc4062f772767abdabc290cfb1f40b312f8a64b34001fb1bb7c5e022fc163557918f90a9f9805b07be8871bcc409e9559cae9e77571063371d6cc609b8c84ef08de0ef01c6dcf8bb2642b9b8bba066abbe302185fc1ace67cfb356c3101e09450de709a57bf13af2ef15be51189466821e99221783068c66d273aebbbc623cd92b672fc9b8c8fb49b075b60d0510e74b3e085b6833a02d0efaebc140a8026096bc346a270452d59604c5d903fb5f125a2364aa94675b6073c5fd7ae5de29bc1d2c87eaedaeca5ba7d58af067795156afab7dd639d196f7401537010ff958f9aa0c7336eae1ec93d9be624baf4d2f538d331c876e9a7856bc14bac1f8a8346fd35361443993658df1c24c01262fb8f5d12c20c5881420d38243ab06c040ebaa73285382a83ad4c90bdd35aa946f6697a8e635c905df2e3b5951200b909d8f198dd5fb08486ff942f5105850b6084b2171670764d7d481f524b6556fb16ff46eb904fe1168fd4900f63f00e549874a461465eacd880e521f7d92942a20b9cce99876aaa381cd7c45c3ef364d3b08c71227f277eff2c906319d41486e4b3ccd29507cc88c800d0ed26394f2306dbb2d9d5b52a3a5705f091cb035a38d4a3f5afa77f71b4a938344ff05cf298b0c8f1d36f5421706c99b195d313e414423279d026d0b51e37ebbed04d157dd5f45a4424682c8ba7602505b17f0feb793ae49e245460d82be0ce5cc0a610224993005dae80740efa6005f88a2915c54d15cd120821f59faa283a8be32c2475a915e8046b9deafbb6aa3df99eae346ea80f0c13e2be0e0823515c4a32e89d80525fc3da3c98eb3adf5fefbf807bb3b0eb6b597a78166f8cee979cf4cee9e510a56da6de5b4c688a4b30e0e8a8f7f71f25e7adf61358a335e688b5636f33e3fe737db886badfc6302e77df959c11909f252f7706676d836d3e36223178d657c1945e04f9b515ffe986b64f3231c569d8a4f778f4d2cf81a69a8b53398b1a45fbb6d7f820a20b0676c0bba44e3b647d8cf52afd3b6bd5e4bc36c2e26b0efcae55e91b486ceef4c1fc9486fc431093928a191efd906e66d9b0d18d17e11a35ee8289085e81876327425e9e91c814ed06373731a8a54fa7d1e5b6a6fea49804248b86241057a700a42399c2f019419625b1267ea7952c3ca832b9a95fc33cb61b70f006ff39b9730a44fa3ae91273b4abf33cc7132fc0c5ad05419c22779adbbac7086a82ff6bbc9be41a5adf7e56f46362a8e869d1443e25181c71e958311ae3a9342731849d0b5b1b4d7c8b1108b310ff83b4304f42845523f81bcd22f80ee20b4d54d6cba691b5d6b597bab9065e9d0ea7ee39b6028c08d180a4c9ad6cfbab11444ed2b522597bb8ceb2ace7f8f7d8869ef71e95ea84caebb71de7d7d68213db9012490d78beb86018010bd4157025dcb5e7539e62d37acb8589d2c73f97b84b9cc09a933e539118b7fdfc3387386a780567a7b17589abae80d304b47ec990becedf20d5c8e0627829828866a8973b870acfc414bba9158a3f3342c4f5cc0c7ba1af667b2984abd2f60203c75db58722f6c33900c9646a376874ee90ffc583b34f3b824e083990a60f4c8fdaf61b52d6d08c07bc737b8b143334fb1d0bb3c47bdcafd14e086f5c826f04c0b2a0a6563ded0016485fa22f38467014e85964ae1902839fa8ff49c29a9aeb7a86da628881fc0a92e141c9aa5b842eabf4fba7a7388e9418acc5dbecdbb4816d7299283df4c6292d041a7b8d28e188039ccd5964454c071ec41e2ddd0aaf6458fbf7a74cb9034b956cd98ee853797bea143a262c83cc14766c896b374c088594ce817845ea2cf12c1327e14b2e7aee12fd91f013bed8a772be97944b381d952d3845f26844575d4cf5bc6fca414eaf7d0cfaa2293d7d43564f5baa555b40956d7bc8a0ffdba17539d3addef34bbad6bd6664186f5123c5b5575fcad7ac6321b27443fd02c5e65bd6047f6c34a4da1a7fe1157ddfb46d023eb90b6456f9e234b4baa0de696d259fbdb243303c2b359db9032ef17243cd47cd19542fd8731de6381e68519158170cd30c3a638f499c3ec609ed8d7daf484bee9c5f04b694bbd888d84ece389fe46108e04a5f24c3bd420fb556d272e4b8dd08595c5803571e1fe5042845dbde8160f8affe44c05a4b7af6f71f21749bee5c4c51c551620e313cd665712b18425980b3d00911f36232fa1384223600873353bfb7960e862f70f88f24d38e361b154098d6ba90862d2efb6a678c4e21eb72f4646d519d8776de6769a64d4a57537e1eb892f24858ab31fedf31fc3c4254aec35d19698d2e2b6b13bfed4348536dd5496fab6d6a5951a2a79223679f285685cd19b5c67073146a804b36d3b6267db081963d1a8e51ecdb6213d6985d05a02a826cb02fd0da6a945519f1beccd0f926a8a0cf2b07a27e107e143a6c275373d41a9ac93c22b2fe5622eccec83b851547d90a3896503c70449a40fc22b4982b4981400333232eeeceb257441177541c9613ec3fe96e5208ba089ae61510269f0e2f96bf968e1a273e4831c575973148d5219209d0e45e2aaffebbf14fbc486b8599d650d9562ef422e4a02090a573f1e68c7839abdcf91714412539ab7c75051a33cfd6015dc635d7e34919aca8fa667b2b297a2f1c9c9e5b1dafdf177b23261e4d966e922eb21a3d2142b4e2f98a3c4840949498051f36882f508ea8980c26a0a49fe34856202e00f4e7f77219bb7162861dba908e5c151b9f87181bccb8edc00927295622a836ae248f64c46078ebf216612a5013d424fc534e58ace23f446e8c908f56cdfd9bf3c3325679400cfba54084389ddda4be1b64d51db58aef6fd22c76683979001b1efa4b40bde2060c556a9f63851c8f8aec03770dbbcc141f2be933112f21a64d13388ace00c207b329e22f8d648b37e21c6d51127696fe661c85519198eae7a4dc0d9fc91feb9d3e77745743a06d4e805b4a6159850a6aae02a7150f8f469d59dcc2a2874c9391bfa9cd22d32a951af8140a1466a2c3a8fb1424b2a662761a22958fd616e28cfc6a13c239af11deff0f3e45cdbba7201e46a2b873447327d43d27df0fd65d7ec64af78822d6f791c7fc17dc4785856b434a310115a8f84a63d0e30124d45b76632d8e3d330883935235137155c1226a48935a04d08ad94aec0aa884d5c5895d068544c2edfba98b513d6d6c224013161b2b93baaae1d76578f4021a9326b110e6507516745677177f678afad05f04b70203354afe825b279ac653b4b63d180cced41e21634549118e2b0974cc66311d4e0fcdd5db8c2425115d2546461ff2c77a1aa38c0e92031ad443b5d3bf96896280a0e861d3975479454a1d60f9b146d0d10f4090d4e6c8d65d89d37c83af3f90c29b390cfb6e9ae2888d5e0ed12efd814f9b899f37ddb83a006ce3b067ed618e00d35e2cc1cffbecb12eb2154599b44407d9644d366bbce92827e97b2e73253e235d9ce57237fba7ef1d09a1f5d97a73446dcaa344c8204316a4d8dc37399ce0a40ec3c295a460b129be6ff07f501d8c85071103b3f34b6a4cff9cf2c215ec522b14b9552e4c24069aa4170bfd52d2b5099dae803d83dc7758602287303af15a771be91982e212cb2c85a74fdb228a0b1c630bd6b74c6cce36cc5d999826c4eedd2237bc2cfc0d7af3a9dcff371825695c7a75a7eca99fd2498613253a88e3731e5873b53b14c68614d16c866d676f4e3badbc6cee36993e6ef34b2a88cdb3bbaa2fe6e1eaf16d006c2d0e7eb3ed4467cff67180dad044ab453d7b6acaea54da9530f144d38338b9536e2e92403bb6ba804d5a5fba2dc944436ba09baa71d0a9055a195c4699f2fdb4d4c3705c47c40b0dfd0248769a382176fd418583d57c059cb8a340ade55a5bd007ab8f7a64ba967d254dd2029b3f8b1212afd1cffa1e775117c59f3d3329a8e5b5a79e03b7375599535173be799a159ee43c20f6d86a613629f6b111cc61e21cb53a4c94f0693be37e93a8a1b07bf3093f48941430871034267efccea7d96015067e9819fd5c056e816f44e56745276164db63057f446ce6f2ccc97b42cd210024dcb9417e79d2801c43f1242b96d25b1a59cfd6e9e3f6b025be0ecbee66aa62f9608685b07ab8773aedf4f5383c93fb3a0ea33b0e64c0fbc75203c1c7f017dba7171e0a6bf65d9347dc08f01b49e6a282130a05738a02ad9730709de7a088aaf9d0d442a47ccc202a216a4bf1aa80a67eef0f689db1eb5817b52105d5465205d4f1a788a95ad95da8ae2bf999407fae4bd2bbc0245e8d6f9ee09c5428582b49f3005529f2a4443196faa3b6aedc63810e68d7b0e1a0829440455b9327d3d743580abf91201648ba45f0e6d094a9a9768ce71d232dbdc2a7bc96b76c69a85dc70b5acd6695aed955b260fe2a6bc91c8a1c5b120ca5fac3f92186552881c415e571ce056503ff7a880570b3aa50e427e3a199d75904a48400f53b877399f71d61a3630419c438ff8746038b0ee7dd799df45ad9667dc7ca66696e44e535dab598c8b1cd8445b0cf23922b26443f7f36e1db447ec326f65e5a01d296c072087ac1e5f3503cffb9840cef75e0e8d4219ce22620ebf538d9eb60e8fde7d53d9b11fb5d1e9c796223c094074f7abd879610c225920085645ca009248fef427178bdaa46099c0b4a819539eaf053f7346746103e1f5b1e4547f6cd234ed5fb6891cd34ff0d9979295603adde626a9b700ad39146a0e455881f6755d44812631f384e02ac02b2f1acc1ee1550ba7f1717c25809eccc18724a3ba8dee44aad4437d95438d3bd75219436153aa699979538224e97abbd106fe49e1f14b08996bd8f57f6f8999ecad1eb24f99546760df710adb29cae04be171726a9eca5768fb50085084f4478cb9b759e989440174d897678eb9fb8f5398897ef9cd091c2adec01ed143ca08f8d411306f18fd084412b1c8de63adac9d51807a0efe94a808009a7b9cbf93adb88a3f8dd3c49fcce28aee440c97ad4771f163a9150dd91dc926f3900a04a871f968e24714bc65d1cf7146401403de3dfc3553420c0bc1deb9557aa4cf3abcfd87109900ad12917088405ceb6d3001010b442a0612ba8594c0be73f6cacd2fa62a65ee0977acd3ddb191f4919861428f4f773d73e1a986a66b6deed0affb85798909445779a4120370001f58b818a7182512c230e63b6a87ad29dec9e4dbfa94abc6fe00375464df86fe79c66e5c3a0f5b68ce2d2ead29a57ffde47044318980fe8eaeaee38ff618bcf95d437b9b098fda697bc1a051de60ba9cb1342f648c3b468a672a332389ed6097c0bd5f41b92adb5466d385166b16501d3d94e7c89e87e30a77bb65762c1630a7a7b19f2ee9f1eb7d0599762a758d457b4216c2fdab0f8ca3a3165b7e93c0002462fceb46f95b7c45a97c8dbf496f1a822e2f8a93f8cedd403c11d0ffeb94e0d9f7389be661022308633fb13f18c2184768e3678dcb9ffa3b3f1ebfa7bc11c6ac1002f646de216060b18a231c2c420c0a54cc75fa7ebd67af5e2326ac599507c0df9a8557dafc38f0bac9628e194db2b56dbc6f7dc5d1a0fbef69fa69219363f25b35c82b22d239e72b9af66663cdc447d9cddfb04e7fd554280d01610485d153be62226b0423f04323a49c2d7ea3a03b2bbcca9a82736b43716daa0f3f77fbdab30b24d091ae73e4deef000356c5f4c39e447899710732e287e9637468b7e163c49a495644134eefa46d2441ec26c851e31e7cd219a583b21f670b8587017dd7f084a68a3d7feaae9a99fd744bbca9601b1a4f1767db7f330742a1b8527d0a3226e962b8d257d5a2637fa285c705bc97289de2e92cb481841163593f83d1e162c4da8be21683b1e8b365fa621aebcf1df96c3993456554c6cc14c9ada12fad898660c926991cfb037939cc1cf37ec78adfc0be6676ae6c60648a9908dae38ac7ba9941d5530f4698403c8e209104e65764b2654fc30ef38c3d1f7736e192d307c238c9fda933b8742165518fc9337a93a4f7955853e829a6b35da0714ccf006a50124aa2430d257f10c21d1df092f1d3e6e2fc89e075730c80a5222a92747d2099348fbd307520f22d4d7e317e0061ba145151fcdcb2bc4440a66c0109ea22865fbb3287d21ac35c71477adb95175921ccda30a796b1c24a1b75cd3f131e4ea96caea40b7f5234ddd4173fe4505787e39384edaa4daedc33ef6ad264bb852804bcfa94e9fe87f04bfc8f89b9d5e73d04b82cfdfeffd89edfffdac248797fda49f78cfe4a3b746b17cd85fd76ff43a5e5de59926725740b73b2610c09dadaff4e2a33d4292449159a848cd32196e8acc3cb4a757b78749389ec9e0760f0388899175061744284ca0aa404a82e28696266c105c149ddf970544ebde99906b8c47837a8ba2eae2ecae38fbbf61b39a089e5a1e93417ac55f7e5bb0d670b91269c34e4f0be04678e8ff6cacd2fea85323146ceeac4872be8b69a5e1d443122b2b20a06b710df11b42ab5e0ba2ee80f8786e6e07eb6d597852c3bc449a3b9bf41f9528989441320ccf4780bf08d267d19b60d4bec4413ed142800112173fcd6fd6e334b5c5faa5d3104a60e7573566bcf7145ae063d38dfd4f9870cd0b8d7f534d7cfddb2a49a6d2b4119b0cf02a8a4ed01506ae82eb6d306bf3414074469d81dc7be3b24ddb7910a40263ed6cd96558fc8cfe8484582c7fbce699dddd7bce94892e996c7840838af21771867ef2299fecb875628ce024986c1588a8881b95d9e4fdc4eb931a5fa83677462e37d9a5128f11a310418518b542be1165145bedf40318546a2a02992c361a908518b4b29e976143d88aacdbe10f2c2f611714f034927537b4163d1ae625892247fc436b890e108d93bf39adbaa3446a09528a43ac6ac3f36f086ece07350eeaf9e468baaf4a24f3284482be70d06733f73c07171eac08587a08361a42912e1815c1d5084e55873b73e8902de098d5bf05a0cb2a5897122c994321ce661dc18c4b6c8976843075b550a918f0bc368a617984cfed72e887f775ef9bd20200840e5c9c0fb939d18f68e2862f70d81415c746dffe3772fd096207f9027c6b0e7e57268f0289da62e7cc009f74f480099774c2b6f5e915dff1f7ef3381fd4b1acaf5944db74f82fc1933062770cb838706df53a5731e2d09221b584c9ef08b7541ba36a85100d987debfe0f2eb3b71766320c49e2c3acb225e538590006109e65311e67f00face41b6fb7546cb344e664fb67d91500a8f3330207d9138a5e8c37be400bec0302da62257808b4adf5585b748966f0406b5bdc307f86366e17dab8f72d895d195c42793a79e5567b30a4393da49b3f8bf0216b3af59103473b4d344575f3d5ba7c7a9c39d95ab704c69ab77cb2a9c7fd65e29efbd6172fec7d88c935312862dc0b0dccfacde192a85645b580f8b868e1df684f7a430f10b453db7ee8963ca8773f9b58f4329e0538dd5bcf41b95150ead5ff260ead0cc31839dd3bcf4539d63d582fea7702960c3b47caafbd67791a57d9ae7bda5877dde17aaa4362aed0fd702fc4f61b21838fd307bf0d0c8eb6e2fac6132d472c3643f2da6bac1ede66d5e1a087ed1d98ccfa2590c8467e14a91c8c13a33c0f47fc6bc9ec121702e2a4e30757a44109ac9661ea0d28428943805a941eeb8c337a2bfb7c5cd961563b8dd86b6d4743186252c6950c2834cc9bcd119906779b0a3ac97f1ec282b81a7316c1aa0ba21164b3bb2476b5c4c9eba0e0b7058801e780b96ca04fa4b093d407a69f9ed2ff1a7a96f7ddae4fe4e69a66b60ee20383a9ee47383014b7c292b6427f59e6c89fd5fdb5b76657075406b0258f8b14d6b4573e620d85069f7924e374f109762f05242414d0f6d5b6c75767d4bf98dffccf7c12d43a47c9716b5210a438082c100fe7b3c95a06e8f407a02f019273cda1c4700a204c4819ec8e08bff5c2c190002996d37424b6a8fd71464b29f5096e196cd31a12a57b08c403c099053ceeccf5acf8217ef6e8d06fcc06a52c35c86d573d6169e75a2e8780c19845a17ab8debb6ae6dc6de2c981ff7bbf0ae072a639f396d260abec2f30517f9661f56ada25308f1390b395f0bce3f6c70d87549f8578cf5d7c0a34b8b85bc921edb076f0b7bbcc5a48b6a2822f5aed1072bdc6042f9ac0fdb72f872f27b4ae2943f608f060142edc49ce89ee0002ca42cc28e0d2973275950f0114b3db0f665fa9d6d655a1091471524ac46c873abb884c3775fa45f04853a438d99d3cf8c16a237527f3cfae385e2b8c27cb17b8f2d8ac9464e71a5d54ec8bdc2c06472c31011c7d69a5818612b9f6f5f682226c7a967d7612d74e6f801e6a450464720802d1c65ee5671c6dd5cc5547f31a2a9209e070d04490f41b7d57db48b6f439c6e8b39030b926eec58e11c2cf992358895743f586c7865a07ac73eb8685d41b2820b4663e9c1c3ea0510bdb7b7c3468a30b0f1a199a3726b331ab1b9c52fb588b5ec9b1d7070ca6577d58f60f6ef59f70df9b2ebf6f6ffff8c9637aba2d4b6f96774aa5d7ac6164aace49217bc65e0440ef2802d975043500a3d14819c4a2475fc227226edb277864080963ccdb5a0453914ce529b0c3d582110cbf11b1a93f99e14bff20c82307810c8b8f5c0aca951430ed2c50b4dd1ff9f1991212a828a2d8ce6e378bc1b2d0e320bd4b700747434f7dede482a80433671d89ecfba6f0ea7d7810192763ed0fa518915d4ae419f2bd43f06edba019f7f97329c05a581a02b3e1674f14a4b3f1d52a41d66179075afbe6b9abcc5c8834e0665fb2282b77862f3158502042eb8b37e355c09bdc34b463fdd16197bd9b788b10bcd3dd628e2120431879757e4ff888e4cbc6610b9559b08c4cc26989bb2522096b4a53cd000e1f87c3b909dee8100bb41947fe74c3f2349c7b413983806971c58f82962e018fc30e6851a84584d3db570880f37612e405e068286f9478eea98b67475c84bfba6cf8fe9a395e026ffbeabb15c2e9f2d9cfaa5b9d7f89fd0383be5bdf32349cadb040ec0e5adebb02317142931f6f0562ca9da82829a47310ce00c2eef953819846a3c0d38f5722b13aa6401c39bbfa96b9a5401ce9aa4b0a375e67713502c10baeb1cd2453b0205d67a389a2b20385d15e2cd15e35e64045e243446326c452b687c5b39b043ee8b6a8ad89613d45e9e14a4a5512335a32dc49a7d92e739c04377600769473901937d54c36a71806a0fbdc76ebb03d59494489f65bdc3cafa0f2be6836e2e2141d0475b83caef2fdf718697725e596e306aae785328a1c557702d8d10844878f89685817ef5970a3ce84870eefd41143313894e12255bfc0991ee6860e1f9b2a6060f1d1c030e8857d8ebfdfdf88a54853eb9b26a7a4e901a291e594781185d04ba4f9266284ad14733e10302f697d11d49487cab6dbfb11bcf3ae474b51e8a74624310bdf8239af8f3b41ab67e417ab013003a94e3a87407097480eeb42edc7adadbeebd6d730269e3dc75f2fe29be26df4f4a574473774de63c95e17744a7cb5dbd7e8b6d4666db72f4304c36b0c0fbca007e74ce57fc1d65c2ff779a5a27e19dbe871a6420026c436fafd6397e2a7b4dcd3d826f234413ec9e1c5fc67f092eaf8de4cc194e9db13d2df590c8cdf26e7e6a62df606e978048ebbe2719d73f7229d88cb1d7176dcb4c1b2f1f2bc43c2896c7e9de10f611d77d30d6d7e2cae78636b7c48bedd3d1f37a3427ec0714345bcbfb5a0e11c235c8b56b093f3b7242c844c6521149f420572eb5d608ae3a220794c7040ccecad8a69a4c0fc7a3f233962fee6e3f6218c14b72bc7c7a62586b1904454e87ed54b1fc6af34ecab3e47ae2b3419ae401538b63bdf4fe3b060982327ee133a7866b956976ac38bbb4b6b980f62a4b47d587fd82a32dc3875afd71e20ad0f6c48f4b81b2c287da2d49c8586852b5d6c4f3922a13ab6b277d10668264927b54c47c93a598634d7ca97f188cf539f716fe7869bf31002dcbeb9925c273457b504bdd387768bc4b54bf4cbe3d579d768a68f95e471a0cc3a16e41d31726fb45f1d23cd06acd97be3c9afd5d2df72197d9e98a2eb048c0de4d571a3d8e1c0bcc648e7cf58d9c0b01a6489b3a7f50652470241303a95931e532bdb978f864c7c5e5a432a3f32b52ee8bea31b91ec9d7bfbefaedb194359dc418980cbbdf9dfd190dcb04b216f0b969d57ff1d73a0df9d1bc67bed0a532c1bb38eb46c7cff9da19415f6df91dba142ff1d71443b06ff1d7562b865548c37d2fe9d34db01a5bdffa53ebd9936c4f34422e399cca353537800f7cffd05304d29f6324b15f4a6501cf043c83971482d8a25f30c1953b9611d34016c16477eca3c39b453d4abf7134eb9d3ff7688d06cd3eb68276aeec5a0e7feeb22673d147947d84a8e7bca2e763f663deca5c4dd26c3a44f4fc3a47943313aeb3176b03de10c1910673da26f6c98c577446d414903c3fb34b2f56861f04e32d36abef55c56a1ef0bdc2c51c061ed64e39a38162416fdbe43a9e0e89dbf4a26618d5b40f600bdc5aeb0deba5aabe4231ad913bb9efed466b77b3c95882cea75f7483b7c4445378d45a02b05f738f2e0694a3e320acd81b35be57a73a5a50ad037e4388b87730ef8a93d0d75013d04f57bc027195551350b12173f5536791d71781f3b37788f525af1021c54a1287d33513dce7ef773af3afa9d9bc987686140f792c6fcb5a823dd3025315501a1fa030d11e4f8cc0a425395aa39038dc97e306e75fbfb6ff87b43678596932bc7e9bbdb5eaaa848568f6e13a140128d781a7e1d19625137cff9952ae205e81196212c5afed8e55cd3dbe39f1d12fe7e019774a7c26438abf2cc99fe727535a0ed6b2a8c583c034089ced4c71ac6c890a178899c7f2cb8f64e61b2f384fbfe092a07bafc642297034152b426761e650ddf2acd25908f42891eb17c78d9e57ef2dbd6c844fa72a077a27c677ead90fc3f5b7765b3b1d4e981a01f665a45b8795554a4fc29f8959bf50a12c8a3cd31c9508c27eed78685e111bc6c6dd0e1781abec6771ff331e8d10d7b2477ef5641f05ec4e181cce52dac46b8e5464f2c528f15dd12171a94f1d6c949da2e7c2a56b60a37285efad17e156bd8cf6b0d77fe5cd70457cd0f36164b6c89fbcc7bf021243bf06b1384f3c7f65e55890ea1953a9c35a55098c972a5150cb6e7eede0f3f73b837218a2423cfa3c8ae1947e7f3e7199f2689b75db3652a2aea79fa55a27f19e25a611c77f06e1af03f908967d8f26a86e8c6484010384164826f1236df2609b3d6d1f703dca504d3f38fc02227ae99f87407c333f95a197ee874d8f94e56021bda977ca95f71d2ed21936fb11e62a54bf162b5a26bd91a5aee222bd30a4e6c4b74175a83e558b0ea488b3d6e8d7de7d7f41604f5db1ce4dee29e4be67cbb41f5170c2b148703ab2f7b1b59f38ef20c4b7e819beeed8a044b794441771739b2cd6fc72e308b41b58abe9d20361a7853308fee39cb846d2f228418d4218d52d2de3580bb5e4cdb5fe7c079b6d13810f0bb45b74ab944da3f7db171546e77ad9a1cda250891a817e49f558b31ad0206fa9e9ab09a025c79557069dca36693ef117c5f1250b95fbd31b03de0f33b702328e4f795c0d6755d591c763b7ecb4b841a66fcea4cb5b50a6db25d6fd80be04aa8dc02864dbe58fe69c6007d8acb2a3907a0b2a56f9a246a1ee04e464ee18f67fb176c4d35d1e2f31adefa00bfc5314e96e2d5d2b77575d966af4a5bc048af9afbe94a0302f0df1298da4a2a0b277267af66c9ca26df4100a5f72e01c719a61b489686d36870683f6909f730b4d153ac6bf08ae148bb3d823e9b7c01473759794aa22fea900741b9e14efb7bf8f7068f5843bcc3a95b77291e22fa3787849630cf6f1748d59c070854779d83f756f7b6a801ff3d80efd2f379b7705965f9ffe9012050f30260d26899c4547691bfe497ac046763448498b4c99c34e099a5f01ae3f1d437e495e37774865112bc68c03e138b89254de64800cb228daf313fab3e43a839aea1698c2af98b03ed2d59464c7a724632d02ce903df4ed061a5f6402c80fb59668b2baff3bd6174b85ddf277094c9b7480021781875b618e66ae92702304dd42d4383bc18f2dcb8b2405ec7a9e1750ea23af9520680cc15a1abec3110ded3c441244af7b8d7f468c024d454426508cac2aa0f8bde52be8be2227c6dc0e2d35434d594136ad66d4c6c1499806f043e39bb6fa647d9343e506f118613a92831bd0b4610bad4a0f143580e43ccea055af4d465a5d70b4475107d3e1922d4e763f7c43873dfca3ed75523aa3cc5d6b2f503aaae1e0e1182237c5c77b0c6f859666f9da5271402d2136d8bd54505a09190f6bcf0fe4f97961c517f517ea30e310020abf0a7b80193ade3bfa21847630d0cad0ca492d0a50085c763fe02246a6f60cc01555d4b277cd2961727d40cb68b49e7f4f61dd4f74328d6ddc6dcdc24134b709765e3401218581dcf3d2a0b269241bac71904c8f74620a62f32b76359a6380393ecfb03e8dc5cfa9b133417c88d8b2005aca49a4c3f133cb9bef9680030d5cfd4ad9a92e18aa96a24552f4c541923bdecf8413de172ed25b0552af7ce490a6b968a3187e35130e3b44c75705d7903fabd00cbbe1bf8ec230930e94827cef836c3608e0d934aad9cbf4042e3f7e1befd164dfda69a81179f92c0698e34bc52546d94baba6daf32eeaa9b529fd4bd13c989e39ac7790783f9255820c4ccb820df5410ed87b9bfc8ded859e0f36c04fbadd63f2d7bc602139db1ffc660ff0cb46c053624a443d4b8d8fcb6a6fee31bf158057e2bd085a88529c4f0b25031b08812aa46526a06f1f273f5fd8de9e72a7d57d1643453dc2e9c1f4c4a1a86e2135fddfd572f6ff89a6ecbff3f8c0915c03dba1f7263a46e3498fa00e6c7d88fa13e5b5bb1846623d1b6aa9a8e7a0eab4fb64587d84f7ef5d682f1ed8a1525cac7262f54126dc78da8aaa63fc35cb06fdb0ea604a6fe494b1ec0f2cfcfdeb4784a2f40c73d5c04fc7a9c130e095f9777529db16e52832e5fdab763d41116f6c38b6a6c4532b7d56ffe733f7dda43c1c47a89a8e6b6be9933915c429787080ae548bb0aefa43ced967309a739d797d1a9005fbaa2e2f802dec52c01d5348f1b08c4cd3de4f3a71356546a284fc7f0a5c3416a9746f3bb460d28d2303be8acdcb5838400c0df921404a80500b6457a6db26064103669d26386a32aa3025ccc9514dbe99230a23d063d464a27a9d41713458b402c7a9e48a4839ddcb7f04e1d086ed74f27f4abc1613e8dca364b207496d8fd69011aa685ad26b5c8aaee869e37e3b307a416e81d21ad18df397c8ac04f8f9d868f9a52d900cbbfd3484fbef580ded2f001142913ef9201669a30a85bf505c2173e624b140255368f8410cdc1a09f4499ff3529b9e1388e2f27302d17534ea0362e8c9c4048242bb0236344a444e4f416c0d417f41950838334adb803c314eb49143dad5942482e7fb0c560424682602fd171089b4593851ce7153b943bdb82bc8c7d371c8c785ab2b105ae9e54253ee60541fb06ad7f79c180712845f0f2723a4c24ee30c5b5d65df6d7e8c1f263a956e7aeb22772be2ea256e9c25685e312f1b3e85259c37f297be0923cdca5f9d50b010e5563397ac02b0838479327e5b29edadddc8f392d5f9b77f744af5e0c31f18e7bd6dc9187b371b48a0d86c76a102dca1ec18931d789bd60eb38287ac4685eac03b56a0264bdb89d55813008deb28f653cb56f508501b007e34555fcc207bb9594bab8a20241d3d2dd1b1b9df5ee98613848ad699eb31f54914b4d5a60cb3095b82038042ffa9129a01904955b35ea4c798885334dec5f2b0df3c5e44e3835a0857fe7ee397a238b2063388c9bd436c786603376790d62e593b81a9a5580dac5ea0dcc1503c25029c16cd44d811088f56f9af9cd5bf4e8ff4a7ddb2d6a75d799d46c5dd5102b86f628ee604303ee1f78260dcc7f300ebc2ef6938ac879bb56df2d7d4ee0b4f9d535a7476d1389e5023b6f957c5835964520f39bcf9824bc03a4b476ec443745bd4f472c023a7dbfb6669164186fc56a108060146801714bc2c7cff8c8ebed2c5dba75355f1fd4522f504dc2412701d1b17b4e0f8825f2c09cda1958d7c7115892b39c209894cd2547ef9c4c79341359334c4fe9380c08c860b8973c9605106f081ff296b1e80ffebaaa8b3b34b0680e27128342db9574339fa57c1e45e49ddfa3e5e5d074d5ab3a7706827cd86d1d0786e78fdee8a678e37e104a4dda1574699d9895f2eebca6e785e4977f8cc8650839ee4166c5e10fe3497a4b38c1da5d4d3b80d95c406272b9df26bc20533c2b658d8dab9dc4004525b611caa4443526240cd50dc1a7677a56a97df24998346b574c48828bd1c51c10bebb313703503bf9960873033d3a5ca2b0e067c9e584d8b6a64a17ae19304a88c6b41abd30c82101721471d5412ff3afdc2b4006eb084ee6491494a02a58859a2b95ea220bfdd46c35fb662cdc0b777ae2ee693b1acb0ff722424cda4de91908e6a3bd0a53d495d04b980f3cb05ba40d41e0d415873bdf6c6c3704c3c6a155ce4e85019264548f460f205b151b5a0fae6181c0fc7990a34250004ebbe8f134bcc6b74e9d60b971b5f1a57534c5dc95b49f4d4220c1d23cf5b18319afd0b191f1e1c6b47316b850b883882fa5a4a7a9623a742192684f4443cb127e40bbc37eb49f9c89c93c4f9476945c2cb52116ca3efce43cdd035d1ea924464d53aee28409ac912ab1d4a906ae85dedd406fd15b1766ee937dd1cab1e1fd6ec40eba051aff4371e6a81ed21bf7a7f6abc765edfa990f1335aac71a13a6e7cf719d74a2e56b13141a5d43919d35bdd8d50dd068b18a924c0a700cac852a2b0772aa8f97a9de4bc2061554f79471482284b7255e86b86a2610a35746cdf1681e5c43f65632d2c16abd37685d35a8b7945616d3696297db9b6712e3942e021e0ed64c50c8e87bebb79ca8ae611398a4adfb86a0298f95b525f801544745d02e051102af99800ec31dd9f6d5da72244537b7aca37075be1ea2c4d316da60862ca2ab0e40ef4eaca25f788b9c14e1537240b28351b1f2bd71d13b7b593cdf9b00c14fb295d595f04505007c83a98d3f646e15c2fcc33a078a22986e28d68224921f4c5c0d7fba7a23d88dbe1292ef2b5088d55bfa505ad7f6794c0f0a93af44e822a9a8c21d7d3f100479e527af2925eae9db4dac55aa86793f24e71e9601e47046331594d35390ea2c386ac8f31e45499a4f82ee3d0b0bfbf21e225f9f78e5ba12c65318aeb8ec494a4597fc9f6fffe079c19198b069a4acd71e06ee8a07170ebe26af775f36233a79b7647b0b103abbebb8c434f2dab0f53c9d81d3a9a731089586a7b3fada2bdc837096c0fe208d4e96526590aa400f8c386acdd16b3728bf62003eece326c5dd31e126510c28102632abccb1bee5610420b06cf5b1239a48cad25a191ff91a935c1bcf7c34a3fd8a3a84db91966289f98da944396e395639e8228ef94049cb6dac2da50407ecf0371ba4cb5ce0c2de199b1e23b611872894b1626c41b2907e4982e8326033a20fdd47817995d6cf9a56a120f25736870f60ccec8ff93479d74538a39f745d88420891239ec83462af5fa5c6c41e1e11a1e21223b741f0d1b8813e542be75865a76499f1afcb8a87a365442a54665219e7ec39110d98a6ed107986cecafb30bf0f767fd6c638213fcc047f48e022e8c114296d83e025c2327d6714c3cafa3c16cd14666d98109903ad95c1f1d6607cf760e16ba82e9894686258b662befac1db8c7af704e5ccb5794884aa7d968c08e70906bc2b582773839447d783c45731c685331d9babb336369652058de8d754ed03f532901b47706ea97396e618a4628214cc85d51468b0cd3f3887588d40a9e0c26ae39a50675b9f76e1fa7430bfabd53817eff576d1705ab967c42fdc612dc792447fd978d38e871b26a8ef6607844c5a3da6846f8a81fc710b513b020c6a1463682014ab3035060b8e28a5b26b1a0c6bbf4470631edb0057206c32e411739cd6108c6503c1461009e44b8392c08f9604abed2aca3b3d387f4e5ca55d47f79f0c6e47546aacf33c7a7da21c53a380724ecc2a2ba45f37dde13bda77c367901c5b17d739bcaba09fba13c16b58925234eba92e2bc88a32b877d997d21169ccc867108e098607a66c503fc75b3211a75f2dc6f48070dd34fbdeeda696f658fb9d33b50380d95702e1e2ec30eec79ad7218553384a9eb046f0c15cb7c2843e321ebdd59000d456902080277e0ec701b601cd4ea4667432bbbfb563312bc88492e7b7e4a28872ecd404d401d9955025664248c578d2dc05ad3cb974113c886e795eb4d7c7122759b2c8b644b4f307b647280aef9658f3073483b3ead78bc68a00f1a77e396dec724f78c950ee7502ad6f7c1de3c7107a7611b4cd5848c11bfb741d244e297312d4a8d7df5c0a013f6d9817a8371403f8a3d91eb11a2123a434f75d0c9b4fad131420884967f8eafa8e2f78db8d8115fcd897f07352d64f4988d067a0280335c2f7ed8266026c98d362e10b30d59e8dbf25d59340d10027c2fd49886e4fc2f6e36dfa07a89945c18045f54ad13bd8a3214ffbc2e8fa868bff317122d76a0f50f1ba0e57f978e6b30dcfe74b127c186b18247e3f2487620ac8ccb41b9f02eb6b68a27ac4d3636f3b5c884707977767f06025d23429e3d924e1338de5d8fd7c3b3757d6d612649aae3ed4459c3ef666c1c2c7416e088e4de2413a4edffd1de3fbec813dd730f100ef4d11ecc587fd84d135f52a22bb995ee69ae8132c57daa8e7958320c86b0682e5082dc67e73e1b134f58ea7ad8fc77e7500993e7cc6e970ec2c392e0bbede83be8e430e36dcb6e44df48144a371ad74da2fea479199495d84b7a404ab09888f0b8a7afce17b4fb6cc2996b51475d98863d6b5da6f3a513388c8526719d90fd138cfa8f3449b0372306cbf57dd83cd9f332ea76abf5e15d57a557880402291cfe969f33cb2d612b98c64bb2faa6561a69e92427c64e536c91e4c5b9cb27989a7211e64f762760c7c02b3214daae3f3febe61a99eaeb16ebef8599f92b3f3d95db1c186ea1d388d472d1bed3779336731bcb4620169983ccc7a59436754b6ef5adad79dfcf3498d026f6f793cb9728925821dabadd94ef6bb298781b1092f906fd2e3377dd785874d233c1798927461170556b2c671fefea3a841286643f2ed0dc33412300d3d68a657df3d658a4aaefac09426632db908545aa49b36eb88cc588af920c22731f471c92fcfeb992b4bf7756261de44352e50269a36bc2404c5ce589bd714c806792844c10f44bed91811a085fa40ab77e553078bfca418e1d9830430f57cb6fa7e668f7ba47a144473c100ffb644f5813a820db9f1b76492811d529021bab583d28da1854172137b97e0f426fd5038e8bc433b68cbec006a761afd9dd4bbec69472103fbe2e875ad2a1b035d8791791aa487515ba8261c8ab84bd7e91c4c9ec09627d182d0cfbf53dd4c98f4e7341d9165e772b53a176eb4801b6b6ee60a232c48e2ca70e10960792f9804d842b3e8d04729ab84153fd24c835558b30edb592b6ff7894108d8135a8742f356e6849615a4c2dac593a8ba7a8eeb65c3d93897ec12c4660c110b0eb88d9f841d401f8c953414194e0c730730bdaf757f58fde438c9a746f2a787abaa4d3459a0898318a5f2043fb2e670fb93f916312b776b4fc685f44054826ea53dbbd405138f607b08220097d8b319d92d9daa2b243ae06042cc5170ec4352d8c013541076681efc214522db0503b6b53b1824598d86012a2ac155a61763160f0cbf9c1775e46627062745b522b1a787b350f8e8638f91efb6ac9b5cb1e99a3c548b590af2300cc69989b1e67ba1c5ba8ec9167be3ccfbfc332d7aa74b2df746fa3891103da1ef257febb97104063d7ea470dcadd8681fe14e7f78e34a59cc20263fba1e9558afc40c0a4ab1e16e2dd0d4cdfd0ec53bdf98ec870e12db1e61f755a7ed0b1fe20729fb270f77e626fa93a46df9ccf1e211dc81dc8ede94d98861c72dd5bab05090388140f28789703f2d4d977504387dbf15a563800dc2957797712ac1576c40dec0ce20d94bd7b9a998cf72522af990af175b712f04aadf6eb2205e307861a367411dd2b3e7071dc57bd635777b9e5084377327bfadd4815e8f4f018c94054ead04c60e582056324e07e98ce61db47a7275de985be43bd9eedfa55d18d675deff9fd8a90d4173f46a780fc4557c2cf2455f5cd389035f315cd378f4d25e99002af1ca10381edcfff23d3a72357ae30ac4be496b7bcbbde5de52a624659c0e5d0e240f397ed2d5a09014cad61be3764b579f36981e741c71b36d03724b6ea038e37dcba0063d6cf2a4b35c7c7c4983f237fc836d7d17400636ca84f4e52d6144920715b14763398538335d5c70fd43e77959e5f8f7258bb88dc318cbb09f618948c23c2589884a59c3ddf2d3fcd9d3e0e46970fa80c193a7f3384fa7e26b9a3ae799efaff90e34df79e6bb0f7d4d205896a539444aaac28092e5db10e5ed628cf176fc703e95b1548aa79a22476abd3145433cc93ff2196950163172c43d201d3b1689363f1a94ffc219b74851b462240819adc49f22478c34283f66cb8d5de31b5a6861a34c582b2c16d520f193bfcb53cd9227ff5a5d42486251f8de42d93f4a1f757581ebc44ef3481fb3257bc7276b092e5c2a5f419ca92287f407d9df53ae6a491f199e3a92c70a620f89271271c65f87567198b6fce4140671224175240f7f2c7e50dac1b541f69fae2764ffac8a98d274322cb2674fc89e81913dccc8c89ea5a10d913dd45090fd351d4f69457ef22f494d478301514d47f3c96ec69d484c1de923ce00e886b49535a106b5224f55573cf9ef541e9f224f4555bda156946710675c8b6955ea0cb2bff5b931879a50f6a72d4fd57a6fe9f164414ce1c4134bfad840e421dfbf4f10db88889acd5202831c7611d9e547e983664ce4504a278ec419f9f40b02498392a855d553413449291fbc259af88a3859e3cc6f1e8f087d894d3712c75ff68e9fe2fdfa7bd04ff1e747e3a7f8f4abf96cfc143faaa8caa34a5e3fc518e3f7ab81c21a95008b82650729200209238072042a94c8011553849610fff3ebe383f16ffc52fc2813f10f1d93ed51b0d19a71e3c79aad48d1c75db9f720bb8bc6e2cc16f1d44f897a909b7a917b944d525cbae3d8b5937368557d9b963e6891e411454cc92fe289a251a386c9e4820b0108400ee92b26637e6a34628f2279c49d9fa58cb91a6cdfc1eee4fd6bb4eefc4f5a697068754d35770df6cd11a88a0c7277259806dbc7879ee3d397f4e158c6240f26620f89251771a6bfdf79fadda7df5dfdbed3dfded72fe9e4cf2d63b1572cf67255c5bdf2539371fb4397567a09e85ab30503265bc1b6bc9a81c667c0352e5356a0426809434c01c60eb6e4f84110902042932288c002a24f8c1b365126b2b123d2e7340c9b6eec7bef0971c3f88a55087787098abbe333f5779fa3b29fc97ff439aa2c1f9be8c67e8771bcb7efdf4df7238cd3446b699401b8706569d384509fa24d13b1069ba8f43d1637bce0f75ceb5f90171330c85d648301b870e5d6d260779606a5e326b2ae3bc45339494831c5144b9e78f2823354f289780a890b5ef004248cd881122e957c1b21a628ae349261b2bf152224ecdca1e7da5d98991a6cdfcf719e9098b70ddf2ef3988a2f5f6d3c57b8aed09137cbe69cb3e5b665d9142a5cc9b22d942b9813ac38a1ca046a30e676d1010d981256c024c79b5daa70e3142738911fb315b02b6239741d77d25708719f8d5f7f7e875dd6be9bedf482d04e7a357841c030d2d932d291fd9ab5afcbd20b62678670230eb3efa75b6fbfa4518d2593466db86482dd9820dc7e1bc66dfc2309d75a2cd7c676993d7336152b9612498405114c743aa5647b5921e47292e54527cb973e99eb342a4ea97225cbf726f2dd85055096ee24cb8f5e0d6e9fac64cb533ef81841440d7a7046500b5432c70549d4c08824785144184550c9972bc97ae2bd4d639125879215b1b832851bfa929caa33515c2082b8d9611067e4fb0b220fd9021357f3556be9a2580e9ba58166e5304951fe21fbecc3244559fb20190e9b95b327e5316ef73296fbadf756855639b8aac342f36dfce3beed0bbff063193ed2a7f8da67a459498af2fc2c8b57769d2caf9c92859246c946654fb3c701c96ab51a41be21a9bab7f94997cdcf48b38268302269307639ba8ea7a408e249be094a2a7881f4e4ca1a71dde54d7cee8e1c96e846e7b1ed520431eeabe429ede57f87d37423eb67baa938d74f325e17530d110a1d58a95a0ca2b3ff60c364034cee87b1e91ffcc3261b9a620f74fec13f42a1032bd9b37f110a1d30c9fd1d8131ede0bdf6daf69976d0b48faae811e9be62d34de5be6ab87d8858fb1a366daf7d8e2a47e5e1e611e26a75fbb8afc6e613e20d29755f54d92faab82faa361cdccf6137cc53b1891500c1092a5a3081093d394724610b1588910231902852c9ef97a77ad06901164ec68042100e3e10852356007b82122d2daa98e604d9ac52a3c212ae1297e68d1e902943f9eed2bfce5da364490afdb71fb7e0ca6f818cdbf26b5071e54b25d95bd5acdc3f9d8c579c1fbdf6995f2a221a7229043a11fe1be89fef3ea61bf00f3b3e3bb1f43ea012e943f6b8925679d85b7ef2ceb276723fc7da583dd2a779a0f44e8ff4d139d881f758d969957b38f8b717c431a52d4406449d1387522d0499d24a6b9d38beea8e8d32a16fdf5e907e3bcdb859e74459b6bca32a5ab23c024b96bf81e84332913cfae50781a451dbcb3f127bd09718c874c3fca14efcc36c9f1c4caaf6f95a253b092499481ff247f2e86f2639b46a84dde5a776a0dcafdcce93fbb92a39ec1fa07eb59406dbe747fa682588106764175776074a398852a6714ba678b690a75c1515e04f9f769d59b12d6099f163839376c7eeeef68e31c616b05cf9b1bbbb1fa6bb81c8fd31871c9861c87ec908f0727c1aa7a7a8976172bfc42d4cc165f768d6c8f31be51a2e3566d4628a521c7323f787a41c131313139f34ea60628abe104f6578d20934e34c0b5398d37b410a77768d3a67ec117353268ec5ed729c62454bc60a56587a913173d5aac714cd909bae345952b9a11199bce3a58c0b618a4c6b70ad139e836b8920addccd071376bd1ca708dd208734590b5796408474b2fac574a9095264d9b1de15729cd28413297c90c3527c4d296c28bba74f9fb82d705bbe056e6d30e6642b3fd304c2738352e62fdb28dd64437c19b1056e4eb6b48b1f10331b8944b90c1f68cbd912099fde3e5cf9d1c7fcd0bdb3bfcc3f784b1ef16596d3f22112e5f8344a1e990be4ec32ad6a598eadb2d66dab93029ae5ec0d2d3256871e6ea894ce2ecb6e6891f128dd9680cd493fda6e4eaf3e793f7d0d4d0ede28a6f4531acd3949b307ea49e04ed285f9b99e0e2655042e90c923a437dc90247bfe81be0b147aa8804c69af611a1a464316f7a7fed4972cdb3c1be8fbd74db64c9ed9d23c3ffed43833aeff267d6454f38da3d2c724f278b82e936de739bee6e9609ac0951e79ccf9d2a3f421a51336522553946289ca8d654c2013a58f3867d7282e384224b94b345252a3168c2bd978a86071841a914a163dd9b34da322152ca4647f1ae8a70315fa89eed8e16a841b8c14a1349266c80d111e6ae60cd9db34f7f140e46688e752bfe707334c435f0e85c2b252c6e138b147bfbf3f92249ebaf14efa15febe7d79243613c73b75b9aaf1e1b3f02f3115f3e1cd2f98852fe6337d319e6ae0b0bef4e7f2d53448ffc60ad7afd31988707fd821dc5a69dcca6c946d4c50b8391ec7d30f67c833c41e31fbe3f8de4ff4737cf48baaec8b19c717558d71e28ccb87e4480f7ef25fe1033be92349e4e1241cc62d7d6d0daedb23540aabd1d50776def04064665fb7ef7e9aff7e7047a3fc29b883e2d0a0101a6c3e19cfd773f6c54cf15b1dc47ff94a7e9409692c7746ab50211a4483723fad4283a850a3b40368517b2642eeebbeeeebbe563447126e8eb328f62840eeb7893d3c77b4620a287203119f7ec74f3241b2ca426e29be9e28aae277bbbb6d542f1acb7a9250059693e0042db9df48a76212ae28cafd3e34adf2a6c1768a4d43eabf69075af1113fb592e8a71eea6b1f258a2907faf56fe87c9c1b0ae25854d10f2beda8324d6ce3a77e8b82eb988706fb3bc8dba1d07e8f784ac3dafb23f154864d130f5172040027b85165bfc64ffe8f13e526fbfa38516eb4cf1e27ca0df7dae344b9d9de621cd02bc68972537fc33819c6897ec2a9f8a36afbb07e546dd8343faa326ca2cfbd0f2c37aa346ca2d80401edb7bfc99ec338516eb41114474449230927ab95aa62d3c4421af42135121b29d26011fce42e6f9f827cd9d188e54e83324a2965170fc07a55fd7880fa310af1949492fb7a6fa9f42fa453924a6cc88d7c1e7a905fc488fc238d2265f94130c9f291e0c8972b2d0b7372944ca48e6c4929a594524aee8b2a29e54b88e4d14e60a34c7b63dcecad294606d7bf85883c657af9f2ca8d0c34cd67e1a30ae665d43df77562d30e320a258254387e871c1ff33be07816308e103d4eec4085e36370922837383ec74755e925912ce150c2b214023d25597208dba83570586fa9f4e1832066d148564d76e24abe394e714249464225930665abc1686a29ddf1258b894bbedc691414d9233bcb97afcee2aac56a54d833c8f2e5b712e9df525e69507e0c0be4538c23b5e078f9483c55a44ff271e0d845594ac79d7c2b847695baf6bca295d223a547bedcf1537bb46997a74aaa0a237ddbef8c4ed9b57a190eef2d957ae26f7b225eba5f12ca59a988782aaa7a1555b6e429b993fb4b9e8aaa26e2a77e8f429100f2b7afc64ff2eb17fd94757682a6a5f8355ab7b3fc10a6069981901b905b64b6e9128c08eec4d712c18818fd6735c28dcf8325916a76e9d5f0e5c6d327ce44292b90b7579c894f5b310dc6eef628f31e9098d8944a4afb1d904b1ff332ee0589c9a5336e786bcfa2255cf99e6309d73271e387f3060913536af0ab14eed735f8baf1c32ac4aac1986bce5e8b1e9f524a29a5ee91ba534a638c315e2141be3c98620875cacc6a9aa611f9c9287e52ebfd259ad07751f9fe619d9456596fd3a647b2ef76f53aa5f552234564ab751d56235124c2227df818a30d8d0e2d71911aad4829a7b05126b4e124ec32f76ab09fa3020343c4c1aa55d2a8b0ab9583458e280b57c469b1ac3a3d84d972bb042339176420640e3918e66039d0b821ccd050a334ccfd3478a551197ed212c77e798e1ec7d3603f0785dbe198e09cd8581d21362a7bede3a14f9d92abdaddded3bbbbbbbbbb7bfa0c7abef74722536e8df6adddaede26a6105eb03c7f0a199520887c15bd628f99e7d3a2ed4bad3c6352c8e70d416f5903d6faf2370f88cc6eceb42cfb2a5d74a042abd3c2d583a7aad3107b74a954e79ba27065e630e8a72924f688423c258f006b429e392c954086d4f869c6f935b89366b4564ae58a522dcba846290d9f7f05123ffb82c4ecaef892a7c1f8d2e765962c71263e7d321ab56d9246eacfa8e7756fa494bdb769afebded64e7ada367f9bef79d7d19c6ce9e87bf4dde86ddca637ba41a9d5f3bc0f12b3874da3ffc1fbecbdcf7ef4dae7e42f0c22ec7ee4719e93ed67a4cb1cfdfe36fa365e75b2e821d938bf992f2e0d6783b548236930b68d4ddb48e9bba6a5ac754db2fe4cd9879d3dcdf4b55894678eed65d8d41f126fc266fff38b79ca50d01428ece4d975445ceeedd3f0a65c469666863ef94b19fa0dfa8e063dfc3c92e9937f10f5e78f28690b429a24984685f1a50764b424474c7d50e1f64fcf06fa3959f33c92e7fd9c73e4c5f8d11b7d8c4f63ccd3bbb7f3b3b1067336a0e5aef37ed46572e7ab0d76a1e4913d396209257eb66930eec8fe3b7ee02033ada1c161d41b113a22eeb7cc395e58378c213dfdef94cbd3a7bf83a6532f4fbf41fa2f9f4c9fe8dbeea8d318a9c5a55f3f8cc9f4447f54eb8717f468f52abe81e6aec12879761aacb84b22a6476727d3973d3e528ad4f14b674ca6afe1dad92cda0352996cf4efe8a9367aeeb96f7bf782681cf7d65a128944c2a6fb3f905efb4b7aed49daf639b97e61170691bd1f7da1cca3bfa42facb9761f3d6ff4e564ef33d2e58e7b6e36c8655fab26b5aae157d7da184e7a9ce41e25ecc072d492a3127060255b526c54e7d818c1d9a0cc8d63bf94d9af3601ea532f3648bd5afd34bdd8a0cca129fbfe1c56a66fa4948134cdd967f4edd6dd1f24e6c6fd37e729567e724ecebeb00b83c8f5e917462ddc37bfda60567372fd8c7459fbec0b67964ab2dcc1d2490bc519f9363d9dfc641b3118372a010741d992a24ca7e4ce0643e924c7ef4850e3299c28a65ce3a7f891a6411ca9029f7e91861fa171c32efb7731df4d83140f69307ecc4e310e2d7d6814b622832291e5c19557e450833d73b70fdd120836ca84a756b6b10a1726f63022db0f6f9c501079d8078bfa644fab6c59d97ea72571c68259b2640b62c169940d5f804925d6aeb2cc2f4c1153e0cb4ff681ac806d912d2894ad6522db0f210062e90f6dbcb2fd9048e67068e23eb44194eddb206ad0de40655c0ddab791e565c8d655b6f35f883cf502eb89c31aac6c875e609e7a212a350eab7dabe572bfbdf6e10bb06c3f7c19caf66388792ac61760b147cc16062931ecc430946d0c44d97ef4188a4ead2cc8e4e551caa64ffd7a49cfa6c1d65ee2214ab4afdf1dfb0be32be552453c49291f8c2ce5cb6f292536d540250ebf26b7f6b19010672636f9678e4d13ff34c21e11ca71a8c1d88da595069be8744b7296e4ce611dc9dd1ece588e1fbd1b6896d8c52767ca2ec3767777fe1c3691fbaadf59fd4dd4dfc5da44453a7270694ff59172fdf110d724b1244a55557c9c1855b7a395f9b9008160e7fde8bea74c37f8fd346b7cf75df7a427bd7c87d37d8d8f38a49f5ff214cec5a59fd8e5a7c111d0cbcbc587c4e3ede486755fbb9ac89d342ad480286da24e491374516bd14289b33aa5648365116b356a329142ee771d6fd2a838458ba0dcef2edf69eab3f2e4fe7e8d4ae56994697e6799a24595dc5f7b1a659ab8bb28f7bbf0831bce9e2e308ee362e4bc20200e6b704e9f3c2750833346ec2fd4a0db500822ff0c9be4673fbf1f1c1b69a24c3d20139ba4b693e75b9f06674f83536a40dbac3e0dcedf70ed69308369543e0dd6207d19a3191ee2caa739fb991fd2eca75172fb90c626909fe6fc6970fe4c204f75bf39d9983438bffb361d3f4d0d28cfb73cb81b14bced3438a7f693e7879b93fcd3e0f4589eaffdc0f2fcc9e3e1e631ed4032dd74efe17898aefc3471fbf8c9dfc3a61d463bbcbcf71e4e62ba21bdf7a4f730ce0ba62c3f4dc771c1b48543c254c74ff347b877b0698bd93bf53ebae3a7f9dd475d7e9a9f63ce1f4a6e13e5d0481365f89b9ae6571cbaf8e4b824c7e9e2937d498e9ec2c951553fc5a88a0d14674c598cef3866f32776f159d2607c171f67fdc6c3750d267832f7f645a851a48fff52a551a38fff12f3540cff1fbe04bd48f132e565891cff05083145617ee2707cf8c213beecbcb85e745e5a2f2c97a298aa79e9712123f6d83e66c9d1e54a8e2e567274a992e3bb04c5548c7d454c65b152ec2f726c2c39be0bcc854aa34c307ccc2f7c7c1720971f97978b8faf3c65921f55327c94551645d60e8fcfe963003e7ec35a28f6e080ccf6e3b715ed846e9d1c670c32f7614c23c73fe2481a15737c1c4ff1f8f8611cca31461aae479429711f01007efc3bc323c787e1ab2f7c5d83dcdb1d6830ee3521eeb517f71a10c7bd0c5fc94f1c8e22ee8e0c0e2f8579ca5b2ee0b0621c5e6fe9c8352cd4bca906474dd65c7ee2bedee04af75b996bf9a9c35c8d33bfe377e0f132e024323c0f199ec75bd9f1f84cf265f81cd5cc6792d894c3ccf3f89b99e7f1f279609c2812dff07819308e0ccfe3797c43fc345f866fe68b7edaf105e02b65ffeba7effa69ba626a8c01cb1d10473f716fab4edda9312279dbdb3400bea8d2512ad5d0d080e07fa904d67aaf370637d420674546ca1383b7eea76989335a1ad15bb549e63ecc9ad082120a323744e6ea7dc1e12d95dec3e183231c8235704823bdc515d5daab5eb9a4e6bad28b2cdf95b9cf629c0e171c4a2064f9b5de5b2a75592ca4e97016eb555ba13cdd974a242b3b9ed25eb77a5f67007c52d5f254e6e327eebf0f75945a358b79ccb360c271c386f7d549ddf1d4e9292c86af87beb6d220f7a4af630d722fbf96126738ca93f978aa97287957c9dc7f38d45145e6fe71589222735332f72df864eeb398a77ad544f1c43d87c39a181cd6e4c0210d0e1c82251c823770f8382cdd2c56ba241c5e8efb1306bdc8b907aab0db42dceb7872b9d77e1a15cad88b7b0da851bdd2a8742a86e75e0bead4c79003fcc098fcadba5c6e44dac9dc2af67879aec673df439e029f0342e6a206b9eaa441eec1afeef8890bbd95b97ff9b4579ce1def2e0ce5583dcbb60d7a2bd32f756caed3ef422ee8dc8277d5228864fc6e4775fd8adcac342c7008055eededa2a5c0b1621770f4a913cba8f0f137bc8efba7eecee6fb054ba57a70375fcd47d7c094a913e4e52441edd777f5242ee5e4a0e1273fd139538d39d7cfad47d777ae5ee4f40b97b9bc68d159f7ae24cf736fd1d714f3db93bfd6049a3baee2593aedfd50f65931c96b8efde729fcc2f6c1153279617ad3172773a23774f45ee3e84c0e90726f9a10d58ee3e2492db4ba5083394bb0f8520ca8d4393f7e10aabdcfd0aab063b2cc3d360f72b287929f294f65d08be72e72294bdafb1f2d44bccbe0065af28771a7e29f253f72f314fd558f9a9fbee2596bbb75a6ecc9e862f45b9035f00ea6c2e387208eae4ee5f88c51e32770f43ab51db770f03934671df3d0c3a8df2be7b183a185cb5c1faf5616079cae4bd54e148d5cb77ffc21611c7758931555fbeeba7ae7b2196bb17883c150021f890810412d480883154ddbf50e4291b28624650e18b201c010355f72fc43c15ab50c5155eb080e8094a9a5075ffc290a7687460061243602182085354dd47990eff0000ae0a239e4651d93140dbb265cb19d9a6473c8deaffa1e41a69222c30dab5c7802cfb7fcd967a5aedb476eda5674396bd28377e523f7a4f58afaa5888265245a194de40b3bfe311cfe5c24699d0b6f2f656e6c358c5850f6315f8c328459c92e31b20a63af6f17d28e22900dc6c3f46545813d2c47c08b2f0e1b7f0614947f5531431d52f3f6dbd84dc7d45d85de4f63ae4ac221dd70e8fa7fafbd540b1470cdfdf503412628f97f76761c961960618458c0ce9dec0fcc28725183ebc59472612137bc4c8020e7ff4fd75685c1753bf4b3fcda0c5a6c637d00c62d28f62f8382073c782e1051cde98a71c882583431d2ec470ec8bd57a6f0bf8637029e7c0610db7228aaa52e9d6c0fd5abd4ae06b4416ab60b6d36bdfcc7b3a4455dce1f43b709228373b7ee69304e04fbfc3cccbf032e0243b7ee6a3caf38628a9d8d45ffff45afdd3dfd43f6153ff8ecf51dd683ff3dacf605363530ea7dff137a7df8171a2f4e304e04fdff866e677fc0e8cb3e3673e47e5cd7c43fc647fc757fd64fff445b71f802f7abb3c9584d23f3dc5a621f4a92bc3a69b53864d43b2cffef427fbf6b555db883ee28d1c256bb35c9165594ec7119785fbede928956a686840f0bf542a95a2f771baf236791adcbaf43da18c71c32c96b7b7440d6e575ebeceb50280ae4acd5589331c1691ae382d79fb701302192530b827d45b2a3de7a2abc6614db6ab4e8c1b766b68a8d67bbdaff4dc6afb5aef9d423a361ddf74dcfdf5f2de7b0f8752286f1fd6e4707b65acfeb22bb5b57da974a5c16c68ebdc9eb7e9f8697bfca18e0fe881747c58b797b3f02dc4e4a8f102f356896579eaf49507005f46f465571adc5e7ed950f61367b67796a76a6bd3f15436259eb6cface4ed310e756091b7ff7058aa226fff3a9914797b1d3a79fbede5a98ce5b5e5a929144f5b0b38ac610187353138a431e19006070ec12fe1f04b377058b281c37b5fa55b5bb5951dc84ab64a74b8ee89ae3c95c1aa50de56594cc7932994b7f8c4922d797b6e87e3e17a381f3a34448742e992c58a3dae348ac853a707420e35f8d9d367597edabac840c80cf371ae38b3bde5c1a544985e6950ca0dbbb5bd3296a762b693f1643d994f26a551373256c6ca58192b636540b56220b41cb64e094f28d3c753d28b29e429098478ea6f11f89ce133864fde827448519a7297c8fd4279fbb9f254741ff2d4e9b777a246c1fcf69ea551367e7b2f6ad40abfbd6b69d48def19c4d3f61bcd10187b21180e2f507c3dc91b500ff2f6a5563cf5eb54d7ce8eec893312009f8c491c9f0b195ef7366db2ff527a97bfa5e7dec337be1f36beef24e3a97f7b1d384a2e777bce7e111cbd37c6f6ac0637250d6e1dd69183cbd3e0e67da1f7dcfd90e3bce73ee45c0cf0fe07ee395783dbdb34b7d3286eab95e35838ec3e6ea7c1ededc7396970f338fb9de5381787c3cf1eae3e0d6e5fed6970fb17ceb83c797bced52827db733b8db2bf3d07c5fe66b7dbd98f31e5407edade5a96a738573c6d5f6bcc58797b8bc3cbb9f2f63a6070c34894bd77204fc9583c79bf79d18bde730e94bf5d011dc6912a97971fddba7ca68675ac871ad64235d6fdf594f7b894dc354cc6dca6c5b82349c2a32c8b7945e8a041e4a285241555710a172c944c4050a3a6668566566490bbbbbbbf9c3fe97f22b82198a90dd8288d05553021824cb7c8d805d7c65325df8af0a3a4951aa4df430906c52ad33f1244cbec89dde8ff75c91ecc5220cf6ab512818abe101c3aa544f2005541bf071f8032fd228df2e214209f4cff0892ce280a5c99fe0eef320f48e5dede90a1c095b7b7b6bffec2ec6f83f2694cf277689f4962b041fa43e813a16f435f08fdd2ce8d53ccb0d2c50f83c8b2d6c6d231434a8e53cc8012cdb881193a0bc082453acdba65cc0e29a594d185168cc1c4dfb672100dca237146d2b7e929853c455f7ec7e40f0d1111c95ee129859c89b7e28cbf17f9890133cf66d2a0539cadfce4576ed84c76b27f3369c2e34ab8e0c6294456aa10056529897e1ea07dec60c298a7f18fb2f3ba09dbf3e327a70d66dc884beda4638c9116b592ec3356e5ca9003fd0465e7c950a494eced933dba7435e831e25ed2a0cf59bbc6393f944c241337cd25a164d239cb95f158179868220a17a42ce1c2133390f1c2321404d4337222c560c2ea228d281606cc6310860f0da327cb7740095e10a74ca1499c3285e892e39431865c80c1cd8898886125cb1f3746a60bcae1c788f19343991c76b92653b1bafdb6d3d24b9c0a9f59c61539cbc8c2de8066429e4e4697a065526ca9654ca1af0dca1867dc3278cad899c20b5b864e9dc209dd144f78f507593e29c7296594a0b35aea1531b0d030e49371450c33f2115334b962f4b884114be365a8d68002cc86850d581436ba1a394e218309376e9001e3a2e0e06c9063c2744c3346095a62c8e021c3890f194c66ab2362a1cb8aa4904182da450b77093ab47c962b59acc858962af79b57a709ee6c156a162a5951ab6bc948919f058a5764c180a1cb8a6cf072450c5d16246a00815d961474b70ab5088b7c33585c9456a052a560e191f509005c529c004b9387614100b02cb155b85328ca47ece8a630a4c59e83726140b9e94e0ebce5c62953f09902935c8fb8de1932acd0050f1b49a0e9c278c9ef8f5182ed98e8c6f0993bb9a78ce1ca324a968d3f8612a234a61065c9f2718c407f8e31845c68c1176264f971546dec3ccb342dcbc0b8920b90e394275a398c26198c4c3ac6279ab0c14af55ddcfeef8a5b3f7a3bd4ff98709fdbbea8f21b5ddcb0e63ec506331ca486ec699cd14223d9084c9e35c80a6e7d420a3e5d6c8982125ea0eaaff1d40c0e9e18810b8a5c80461655ff8331e863b58175822d5b38610bac881da4249102253f58801165046068d18191fd13dec214a320c4f934510b307ebcd68d59f694b600e3072a98a8b9c47c1a3905183b903dba8b7065b7d0baa2e427093f49f460e8072b26889da0e8073e4a10010c247ab55aad5470537e69126414305810801003274678620628239278c10d965082580f86708504b606931bf3bc4180001146c04207518e508426394f865a4a48d181220524a61260b48ac856910a1a34a14405424e68c1d067440c725085142b8841123e608c60e4c50f04a610042134b2d8e20c2c1cc8810ea090032e563890c108c8f0c0a032ce2fc92392cc808b225461832e827005500994d04419518c20051742f0a293c20dafe7fea7f11a2da40292d0228d5816af2d4e98c1ce132450a18921bc0802175abd92922b25c8d8364c3011450b647045124ba8028933a8b0411ab0265b4c20d0c42de6d3c0923d242d42ac3488628825086dd15265483599d0832330c1ca1623563d5190c2b8218c3b1434b5a708386062032745a040084530038c2a34018514900005f3074d54991b43900165689e74290a1d4ae459c444c5ec9ef5121f580d11852fb60429814203b8d0c1a2d3a4492b8a0f7a5c33732286aebc829670258c2454394ab028e2b5050b2da2b084247a40bb0cdff61ac8f9251d310a1ca0b6ea29180e877556ca651cc7e170c32016ed96a89c4b5eb27344804414c648628c202ba0f0a1045140810fb298828833785275351f8757bda58f34eeaf6e4f01c713ebfcd2c4419e402ae0a9411932c8c207416cf9a20b297c7240e4440f66005374c352ee292de34dfcf942fcd6f9b734b7c8310a4b147183256294800855a8261a5e3c61c11344473042357990679c724527cf3ca590f2a14f1dad1451cda88aaa9a2be4b305d3fd639222ea8dfb6bf74397c0b8b2eb70cece8d342b06c15654cf067dbab77b4bf194761d23d8b4bfce56c6ac478d639c09e5472f48e79c4cca2e28ebde1ca77ca145963f47f0851439a4c93308d7cb71ca172f9a2f7cbe684d17d4e848da8db08379691f280373bb0e2666ca8f121926ac8906edededde5f08e69edddd72cedaa889c37efaf67df69cb573e359c5ca1652c44ffd7d6b8068868602908b985270659117a4305464e246cd7c33390079766afb4ecb8a44d7de4f32b38153db9daddc6bcfbdf69b74cf06fbb1feac1dfd666e6f56cd6af329879fd8a7b69fd6f0c53aa723c1e23024fefc9821c66c3d24cec8e73e1c86f4a9bfded23f1861340d0b6bb29dd36f882cb9da674eb5ed9bdd880637bcb93d20f333ffeadf34884dfe34674fb5210dbab7bf073010e6541cc6a01c61d4691e32bf0e46b6b22f90943224a5e95a4a4e6052ca72c62b899c8a10a118e433d0fcc832a61423129f4edfe4919a5cd224584df3a8a7fd9c5ad4dedacc66d94fce5afb4162b6d8d4fd0ff6fdedfb779a966556abdc974db9439a44fc5cf93588b4d303d211a14997a71f63bfeb72e775b9590dd91b29659f890a55729c82c64fa6c9710a1a41d994bdac92ed975d3e538641fa41ef3b1a154aa097f9f1f2cd3e4d538644b3c181beadf1d1d027fa3f1aa43ff2d5341ec923614078c78ea04c296d59c587d2f874dd8f4c5959967d67b3b05906dc4133037d69efd7b9bdeffd6834d2344dd3beb5efd770db2cfb7be5cd727266b3903cbcf71ef4ecc7bd941dd732739fccdb577fe0c0032542c3901b4a3d23bcd0c930252f5a39bbcf997539a6c64fd28fff308dea7abaf27c1e3ad52c2bac2b596411acbbc12e4d07c2387d9a538bcc1237f4a03c254f8ff491af1f0924a9fcfc120f6ea9e7ce97ac5ed26a225dfed35aaf32a3c5956fe359861dc8a9b4c38a7ae5fdd340453a57284f4924b3c41e110a3a9900394e794217594736a929fde470c2bc599e722d7d9acfa4b424cf9f4af2fc5ab30fbf61b01a3e7420a11cbaf45613f5693e8c067cbdef94682e585f77cec771032a3b4da5ca95467158ba761ae5d3a88a83c40cd42853fd20a1466d3fb50dcb263c8dea6994f66a54c5d2c94fa3342852601dcbf0748da03013853bff0955ba192fc24ec6e5f743c99cdd59e62a118c19c813b48860cca167cffe364dd329b092c88d9d7344831b76319ec9784fdc8dc0b861f7d5c653f647a70143ca13a8748c44bfe5288c6bb3640914e5861d0bca324b07354aa8ab346a7ed7821b4a26b289a7492967c8f2b3082a71c339635e66ca263a8d92aef9513942e3823542e40c78c80e9a1f36d2fba549ba64d6183b222efdece78730f5b33375354b33c3cf6eeda74c9ffae7776fa4cb52fb7e704aee8358cd33f769473f72c79a93e6476fa4bdb5da3bf5804cedddab3b89a4b9bff69148dc37e3f43943cd8f4671de73d6fbfe1f9cb5a3b724d2ac9f93dd3d6fd4e5646dd30167391d6dcea9cddaf50f1ca6bbf7143b3fca60b961977110526b111f807e826093078a141f267376111f823852a5071edc3002c5589da6194d13df40b1fbccb28cd249c349a4dbab5cb77159b67db6fd0f59295beb653d64998f46d894e11eb2da60d67d261c73a40784c31992910eee1be972fd1e3c25a44ffd1d635bcd8cf410bb61048a3121b153f7621296727ee1ec41ca0dbb5877614a312f03ee88797dafb0f39d7cb1cab28a1ca778b1934734b82d23b3191a74d260bb66761cc9f2223e0471a487e0c003911ada1d4b28406892b8d12463494a894d75b67bcf8f1350267b5bbfe698b972e5cf775c2496465f109d2b37bb0e9b1cd3788ac3a46f9a72b0c971fd11ae9e0d9d4db5bed53a9af9d7fe48a01e9e065f0df66cf0c5f3c99ee9f38d7439e3f1940c8f16bba724f924f919966f6b25f967ee7df4e6f4bc72f3c97df93d61bdeaca809dba78861a687c703d7fdc6e7293bff6f5e3fc9ae1b0cb5101383418df740385013244bec0ac5821b97bdd0a6e8cff0428394eb11264254bb6d10332c39c8e1b9439bbe7cce69c73ced9733690ec334d2c751c772ab83187d2499e4e64dd479920ef3a22ae96ddcdd6f866e8d37cf9db9cf367b823cfdf36233fb7f0069abdfbf1475f100f48d424ccb67d96656fa4946fb6f9a0c2f59f33537f4a224512e929bd3414225f972f66924bf4aecb96fdf6f4cb7ea37fbfedef1773963da52e945ebc012dbbb8d8f446fafbd1df3e9798bbd960d76066d33b6866a8f96143c30e9a196a7e6cdbb6fdd836b9cdf93b7ecc1a218da23433d8d030e9eca060a34cd84000a99f75ddb58f4ff4f9a44f73d2c7f380f0d020edf68e7c32b79106e9d3a6ed7db2bba544e316b1741ae529f1f09006e5a3625ed2288a43839d923b1ba4523eed3ee64e123548bd6f500e794a16f5897eae9fddea55a9054b7bde470f885704a4dfa756fce43e7dc732d627ead550a541fa434532cbd0956ecb03a534f690748cfb65996577a4a59bf9e4be3dd10f82e550e358dd501665fa4ebf95d0a75a7a55a3248af7d6be78406cbb7842ecbca43b541367e8f70784cc5918ab64fa252adc49bbf70f6b62f69e663a4decd30c532816f7e77d1da7c546a48f9ecdc99654bfeb779534929cc771b56e1c37bb59eb73553aa13f83e5ceda2e1b5678ed5a4b231be972ffcf6ca9d7f58a57d5ea4fed7bce8ab1109d2a8a9be6d3f97446777707a393018db559bda497a080d54a72a4b49fd26f7eb7e4720f4e9ab7ef0d770dce3ce9bb94db06650a91bb7e31cbfaeefed4ddab7bad32cbef2a83c42c5db1f62c913d0dd2dc1f8467e7c99c30bf5372eb6f2f4aaeed1a95715f8a6954671bd5bd47faf9b3237df79ee7dd7b3f48cc179b5cb277c9fee28cfb9c4cbfb0cb4164ed499fcb17ceb0663afae869a411fdc2ea24775e4ca793a3a6659566d3eb483042e37631336b43fec2bc4c96e149c9b031353f64ea7eb74fd9cbec94bdf7cd38e186a59cbdf7f2b32f354aca1cf331cb2f6689a3667de43ff2f7de73b2941c27a5ed74a03da7bd8d6f51ea645bbb0bacf4c423e438a50ba2dc452cc7295c0ce59a1ca770c1932d2948ccfdfdd34a963418630fd9403834cad4c51e43e28ce390fb88a770a31322e8c936ba3fb5f1f66cd0b2a5f4ddfd85c85bccdc476f7b9bd6eafbc77dfdb61dc9c37175b5fb57ffb4f76f83c26ddad3df024f638db2f6514ea895460d35aa9f3ebdd228a246d12cb4a8516110327b5f9ffe06147b5cb7d2207ded73d2e7555cc8871af46990fee873290eebae3448dfc3fee3dd60b107617f7941ec6f5faf34aa56e1a468d9e2e98a335d1977fba1b04e7d952d13e32b001ad77374820557b2e5befa9a17a4e6ed399f206bbf36ca3e4ca75cdee2d0484cb6cfc11a44c5e0721f725432a5c2612ea8418ae77432771a84c2d3d327fa355cdc7003da80362ad43a69d0ba1aa4301a44856e98abd574325d0dd2dfbeb943c6e53e7427ae205aa6b03843bfcb727f327dfab54afde94aa5ab50ac0e352a5a6b5d4e3817d784d3e19870ac46edf0703e9c14ee0504f3d4148a71439eaa2afa1c1157b4b2ac965b1d4f4d157d1da8a0c5621da8a0253bb793299e4d9cf84eec11cdc821cd21c7a2ef1fb724ced089395683f4b1dc70bae6fb4f57a7ee6aeeb0562b157dfbfd70d1d220e55899be7f3eccf84beb94041b6542af55ab2687885a28e640b0e9f3f253fdba1d1e3ff5678b567eaa5f05aab04a57454443439d4e51c7ea5a9dcb4ff5b343445c4c080604242404048bd9970fcfce8e8fcf0ecfab734d9dd99aacc9b23a53c7b26ccbe54d77f7a1595434446457a3ae7e9ccf8be42ff7f1980b398fef38cc817ca7ba8f03659c0b713b7ee2e1609c1017f35375e9788be5accae9f8a95d7eaa1fc76abd1471ab1a43447eaadf2614b3e1ab22a2a121a0229f176c8598100c08684768d371f1dc78f9f0ecec6cacf629da565babd4aed6e956b366b3269e43ad231423c21113ea55110c886848024d293454eb4e51d571551e3ff9f8e9e5a7fabd7c3e9e1db9438beaca84c44f6dbaa92e9daa7d47fcd45f049b6e3429591f5514d72680cc242bd384a40e102c16e3f3f253fdb41d1e3ff540648890cf517d547914d2585a4bc710d10bc53e2018f679b9b0c323d3d52fd371f9a933560b86a26c15c3101128143b01c100e0f30ac00e8f9fea4775fc445d3336353460fda8d23e046b919ffab54f5bf9a97e49fb4c3a44d5a51f560dcf2640589241061978c838801165d1d6a7e9682ed7863e8dc84f4d595e0b0715767a4c438934885413d7981ea81c5f3f49278e00bb8b3f4e7ab811d204f06e3e7d3a3d02355139ae711294e00430957fd18912a8784c51cdcfb423cec8c771265b8451864a8826e2042a7f1c47228d26a2a884682288a0720c3601e4dbac8c23ac0eb64802a6c211224381ca484604550f5a1627341847b312a50a1ea87084e844a022d204908f238485a9706802c817621a5186caa609203bff48454d54d3758082d74be598260d26399cfdfd57cb4b6e55cb286747a61b4e457fcba1cc4f28c61142d5435001041f957f2cfca89e1211bf87eef33ee9c4e542491b44f00211255d36d1c7f421f698ff8386e69423f89570481b2820821e675c5b10214a704979bd93784ffa24a3efbc27e192103d048fcac351b2eff0f593f44183e4e129213e6bbdb754faaf3c7864f7765925ce08d1207d482c6820b58099915d895212d93f0735982e5772e572eb2d08b13c6339c5c566628a7bf969724f44707e384303f11576854ab1e8423c15e3c774eac6c78fbfa3e6f8a22ae700020490fa99543510d6def86c649fccb607733c0dce27f5c7f13069d2a7f9a38f7312675a4f40e1629ee27afa34b91b705232cd7e852fc793bebe6fd359f6c5cc4fb2bf30c7156de4e03ee8ca277dc8c572307d2b74f6fd1989b17c31c7da5cbeed6c3c793ea96eb1f14955f4ea963833b915a7a4c169faa2ca52e1d2b741793e8e2fbd7fc8c55e4142b68afca4ccb297fd6994cbcfb7409eb2f1938b7156b82bdccb53b172f33797a7627efeb6b341e994e9e76f3d9dcaf1938bc9e1e6ca330673b1feb8a106e79b3eee4a7359fa341f137171e0122e6dd9f2db2ab26e2bbfe0b8e9e4f97624ad8dcf02f989cb72b17d71b106e7dff8382bcd5de9d3fc5a25cf0f39a24ec5ae556aac53377e7e1dead40a3f6710982cbd9c916e7cb3bbeec1fb7c2872e40ba24121353f6ccca5474bd8286325cfdc3474a1dc3f6d9340fae0240fefa40fa982d8c37d7478f0040c80404516d57c22920be943662b3346525c8add28b32c4c52948d34ab711018098d43b1312a29250e8d7c83327e92f9492d6d7165645ae53834d2acfc586ecc610cc88211372636125f63f5944bec11651177deee1c2d8822c6832576b2eba538d3bfb9135288a92aae75ce1646b0a40822a4608a263484141dd586ab9f7afb0de7a864117736d8651e107ff901c9de16c954e26821c1850a677b213a891f325451fc73543a62a0aa9fa3b2f5dbbe193d201acd5771dd3ed3cd66e375fef64515dd8010396b7eea222e7dcfe6570fc8c4464ad99fceafe6fa4595fcd1ca658be492b4f3c6b89acc91840b245f262155107bc82c251459ca234825a4a44196320759b6e2497eadf7e22ccbb46f5449b5665991223439ab0193adf099a671b848e9b51bafbd2d7d527503c747950d1b5ffa1d6e3c8e124e12e56685bff14960dec647d5fc1b3bacf03770921bbfc2dbb8f12b7c121b0ff3515582791b0f8115fe46e98baa1ba5cf51d9b0f137fec6c6dff8f9376e7c09e3acf0371e07e66d68305ff4938d2ffa497bd9f2fbd149ef92fdcbbb489769bb8ce7c525ce389f60e56c34d246dfd499331422935e7a4048a3cf1b91dea6bdece93799481eb33d20d97c92479adfd4697092f006b4ec79a3278d78c8784203e450b6700f98489639695066306fe36dc07c54c1bc9443d9952ce62799811179c897190f026abdb72465c6636b7029cea0643b0d4a9939c9d2a574295dca966422e556f93a6470e5c71881342dbea76c4cf357f81c150eccdbf81b98b7f1f36dd8f815308e0dfc7e928f13fd04837354392a1f1a35615ec85330af65418d0a22339e06e9278bfc4471e62371d6a3d577a2396d1c679569a66153f6342372e9d28e75c9d13e4d4ddeb40f37971ce7f67514fdb1de1fe2cb8fd0cad6d43d6964ed5b5971bf66a5de6546649ba120f2b07db2d92adb8c95ed775fb624ce580ed32c71c63a4f966c7fba1a15522c3b507a32e9148d4d27d3ce9e6c9dc7bee57ce5ac6cadb7b2b5ae93adf5dea629160f9b6a3c6954c3da987d5bad755783d63e6535ca79669346716f7fba3c05f336f34a819cc2ecdbf6effac9bef6817eb23fbf929fec57fa4d260dda87f9a68e9f6c2ccab6fbce7209104198a4953b21d2b7e7752191dce190fbcb7d469a283b4f9fec0dfb56b6157146bef43c0c45f69efbbc97aff1dce761ee6b3451eec2186424492bbb3cf785dd73ef4bb0a9c337d0cc61179f1ab7200e8d2a7d376d9f8646c9efb77f3de56fdfbefd92a7e6db7f4fd12f5db11fdb7e43117b706ff29e34c259abf3a2a5d3a4a5755aabc13975664d69d639e7dceccbafd67e5215edefb0bdc54970922837f5b94fa2711fb5df7e87fa1c4ec27dfd0d27899264b39ff6db43a03ef7366d9adb679ad894c3f6dcdf6ccffd9cf886fb0ee3d4e71e47fbed735455255bae64be3c65c2c9516d1f555bec31df7b68d08738e3bf7d44a4883e2e00220004650b0433dc4b9a056e6fd3df77798070c852d4027b49b3645a09c5dddaaeb051266c9dee6635d76dbfbbbb3bf976f449d5e873bcbff1304e94c637de8f308e7def71b8ef6ed7797f7112fb9e7defa5cafb4cfd991adbefbcb79fa47b8efbee77b0efbd4dd72e93cd7de4f0908691dc7216f7aadd0e69691185700e7b954354d51de894daeb5583fe328b1b4a2a9b8449209c2837dd5b8c13257cc2bd0e51954408bce29ec34224f9ef308d9ffca39fa40e963a58471a4184132b55f7f6431a2c16fb20e3469557f982c94a659ffbec8eabc1262e640f07a11c73c8e47488dc3021d27a94021b24e619519d5d08af92ff0e1aff196a68a035362aac33d49e7e38ddbb4399230eb5afdf38f490be66ebe30d78ee0f733c201f572b3a7160a3ccac2f75d4404a2957a52c5686e4aaa4a548ae60b2c0acbcd090741779969ff9c41e7d041ac41eb4ade829a0c8fe2d82e8fefd82ec12639b98aae096c93ab30c6719cf08274735f26f29b1870f9538e33ffae46b89e8434a117938024a2b0741d9ea55912238c3d99762aa331b9f653834e2838e2b37eb21c34548f2e5db1a9fbcb90f53e3b3f1c9d1bffc0ef76148a4dfe1c2fc7d12ccdf4ff2c2ea25ddabeca93bbab857f8ce2eeef0f2a4df01e65d7092fb304fc249a2649f64f42fed997218fdcbdf8cfee5337c433b1b9f9c1ee9fee8777019e124516e48eff2494656eb6a7c51e592a322bd3ce96f5e9ef4d993304e940cdfc0bc0bc6b90ff338a37ff91c95f4800ca9f12e1f55a3cf9461530ea31189f4a44f726d987218fd7d0890de05a6c6f7f2ad5cbee827d711839b491ef7c9f269628ffafe463e03d1471052003125cb10a316c05b50f04c913d5a91fdb545f627b2f72a489620a48f5e22f2f0f7168111b2cf1349bc7290fd43e9438317945490fd4d905d6a914547c832a215df3cfa3c1c2895ada6692b3db4aac133ac3c68caf74ef5aa4fdeab2dd6a5486cca24d5689cc6695c7c9ca5b54a51a494520645efd9524a29a5ecf833629347d778f2eca18e49e9751eee5837c29248b660fa0479b609228ff9314b9fe664c5998e33f3bf232eac51a114aad2a9d8fed3a9cce5a720f78c27d31655414c65447e9a9f15bd6045833c35560ef2ac6fd3b255b169fbaa6d2d9e3c3f7379aa8332972492b861f68c1b553da188a96c35a5742a7ac72650ec51dae25ab19a62fe15caf35b93c85347fc34bfcea2ebac5abfb063b387f2eca23c3d5b79aaa38827fa4ba857dc2e66a8b5f27cada59367a8b9f2ec10042e6d27cf9732ca49b1a9336ca2b45747bc561d30b8dcb787836c2bdc3b5183d37f1c4816c92c1de31a9b92b434ffa192e7fce8af06e7675fa586b3feb063da0c4270fdb3ebdf32a51cd8e79c53829e92b16fc246191d36b8f3a54629a534cbb6acca204a29a594669a9669321416a365549a657b20b1522c63da6b55c35dbba28e16f9f6348bf49145c97a90bb0fbb28cba0c499eeedec6891a7329dcc5594b31dd696e18c499ce9be3326b97b67019053e9de7b3a45577eea7e1a2579b6b061de27b3dca27b212f62b9ebe850ee3a16c41e0d1467b2ef5eaedca58ecb965bbbeafaa74f8daadd772ffbd560f7f68cabbd7ccf02f3952b71d6e83b2ddecaddbbf41431fbeebbc8532e5fe405d1161936ddf73e4cd222ddb0adc801b045a8c42cf595518d32a56844000000082314002030140c0885a2c17044204a82601f14800d8fb84a745018c9599253ca18630810100000000000001200003aaa95d21227620bdfd687c68c09d1526edc530ea11ac25d081fb1e4c71f0a01100e03942311808b779d344d14c804ec328cfd03aed81f3d48593b44b4a91a59ff6e2b5e1a12fa4afc0105ea854a8c6b02e09a34f0602bd682a2b7d8f42a4ffdb9c2978a5b9924ce70c7904e2d907d1a86c84400400fa3fca567107b4d50eae6ab5f0c897e027edf8f84db6e4363f84ba938f7f7b76a2b965e4c9fe3976752c161f40da8c17eed6005d6e6e6e329d92a12aca6ca682f2dd2da266ffe301436cbe09fafaae3a8738288ea5322d9892420b7911bc07e2a904b9010c51d97beffeddc2169699c471df7a73eea46d4f4e26abc35568bb4c528b25c8d8515c4d5d8a4b1ad7a0bd8e018ce7aff239dad7f37d95c1537e3561e304ebf05ef3ed8510e26d036945d387ca2d23f1c99d4c22fa345729c3feec327669e5f7443d63644928ed0875ef2104479b6d817f5a7792b0997b22bf4b99485be55d0ac4bbff54923b697f61415ba5fafbc2801f5fc6a403a4017b98ee319a06fd3cb599269183783a7b63d709cc1e0f3bdd872a04838a0ccb1066451cf9afd2e099aa53144ff5e1b586642629c039e77e818eb7cff091e209bcd03aa2ac68cc946d77e5ed1e7e51fa2e44b07b2f6372c9ccfff05b34f36c882a56ac5a7337f2c60b7835116ad422bec7e785e8afcc56ffb407cba19fb4f94042dc6c6a4b69e95c9a13ecfbe2fed320d027bac5c930902b588ea3cc4e02374c71a9261b1417e66c1e5330d5895d44688d811826a39be13c6e08a028ae0f9009f887da067c1c3c920d19dca3de7e39f42e4cf80b39636649ea77f861bd19593a9e375ff7ce05f6c64d4e169fb744f719511dccafb70f21644c6c3e80048f0ef003a65bef5f187c67b17fe1c3a76eaa33090981ad534887ba0e417cfb34bf3f27f807855a3f242e3157533fcd22dd0c6699e631cdcc5d5800e91441ef3bf7f93940f60cd842674c45c80638474759d11ef81da61ce7005b5e63895e1b87500abf58f2421249e4e4a266796bb9217856c8df44b511830f589a744a160564a98614f044d70efbf11d17f54f93e4b7808535a451922048896ed90da188564eb0934e646b891ad7026cdd2b76ede63da9c7d383342333eed9dfc147279f6ed50e996b51ec7594bac3fa71c90d8d7720b8dd124baa1d924266d3320c9a615b39bad49c68fa372eb3352dc30c6cd932839e7813d4e1ab22119466892050b3561058ba45f0e7adaff6a046c11335fdf4309be976148f62d7a57584cc5df76d9e4207e5a88f8fc318557b9fd98a82c7ea6d6ba0f4588ca7ea88759c93484b9f5c1a5023230c06212c42cc0ac6ccca7854fb216332fa84ce73b6c32ea8143a9d761d58cc924b7b447139a2b20f5a25f293f1e78ffa540c998e783ca42e8c7efa5d168f3bf87800959c7cb31eef110c78f6d9d0f9d3af55b36f549529ae198bc58011e475ea2e9fe573548062ef2b68b7e8c950664ac9a4d4f4aa6b3bae37c954ea7883ed0f14bd4358cf98bf2efad40e94fa24107d7740972440519c131a207a04289b6be44d52c42acdf1fee97fa931b591d9ed6406fb738ed3c3e765906c30ca85417d75310f718bfd335c89a7cfa3d9830a86fb0a5fb8450fdff70b12145c46e511064c41046e7a0cbe8da31af8205d9b2121638b3f0c2ebe142cdb8c595b5923974eda3717d87cb83c2a446c6eaa04d3f4e1515b79095f60b27247b63d7a85cb2c93fdede7bb483451a97e82c5431db0cef8f630e78fca24ab66f5d84be7e2c2c3d9dd3ad849bd8479ac0d89a7ea7b64431d47bd8795e5ab1c60f7ac75a08fe97961dc9f82b657634f0b3ee0380ef4dfecfee65b338deea9b122f480a74f9f9c01aa3804202b43e8f6d81094d5383499d431ee3c641e0804255065363695c354b4f95dcb0628cb658490f8e1e8dc46a21fa77b830b50a404534866f97ce813d23280c9b637351674145629991ce7ce709e10fa41e4a63920ed913d97f06a123b28553834a3046b05f6477a76769c92366e0edb796ce727971b4c1351f992cb4dd54e543b8e7e70f8bbd4cbc8b0f0e1b10e95e88f17a4199f7418886bc85766f8f3a23750103d6039fefbe6aa8eafbb0a21b21544194648a9471921c8aedf2a2aa3aa4e34a4cd12c5a2a6a31a4ab5913c116ad98107911ba7eae3d54a9f028c7ed0c214512dfdb1bed499eab982e6046d4c2be001d79026b31742e22f6ca4ab364352cd22a2469f4d1170dd5c4253e70009c316c6e21bbc8e247e5173e42210c9753dcb937af8363629deb9506e678195edb379bc7ac7807f0cd41b4d261b2a92a26c1ee339741639349b450385c43460bd167c193294f51a213024be0091e98a921714a06c540367e2e540b94d500ee1e8d435491688484c177278bf6a9357c1d48f6d7fb5add2b8aac129ad3589b0c5fe4683f674c0a79d93317fb2bd8c753dddd03f29777f2b1db7abdbd79a4b4bca2810481b65ec56b0bbad7d175e771368e04a18155f39fd79b46ff9ba9bdb5328ac423dc5713ecbd7153d18635875872ca489c9bb8d98da4f0465782cb8e5424aba9dece921863139e8b0c096f8591aa5daf15ba35a05cc4db8fef0f9b465a65e80331f0004a0958e5446f061a08285e257564d2f22a947e807ced1176e3d929d51052cf9a7dfe590f108722f3a7d8310fb6b28e921995ce39a1e77930764dfa4314497c3ffa15379ea42f6b302b831f7886ac649d8fcde710cd4a11725ca7bbb6ececce5c67ff15ef42f099eb7f928f050cd3734c5fc5ceecb086e30e54fc3fc95c7fe1645ea132a43bb38ce5fd8f865a9e5ab8436ac387cc20934cc3d602d2d5d8db080f46528bc373572ee5bcaee65c04bd614073a71f34d90f2969e686173d29b3c1a378f1e7bd08da309d63f14e12cf86985f93bb28c4f05ff3ce41f5c2c1bd242d48a00d934314ab58ebd6d5787412e537b3d371d60c2e0d0cef0035890df8e08a3efd73d236484c6b587b4cca46e82241f80edda6aabf6aae2a99af0852abaf63da8d436f2938122253c5eea8a14df4bd31bf08c2d2bb56f436fa89bc1dcc4e9203cb7e6a7c93f871a6c2f7b7580cbb254648beefc0078d9d915dbf16752042dacad979ea9aa61338099a6b573e0f391feb27b85e6b3c2ce74f8ad9bbf23b482bba7a8805fa39964f74bdfd082974ec5e64e7de601580377c1a53c5ebdac4791523ec220306144daefae366626c0bdc1dd376a909ca681a4416c896ccffca3d066b38312d179ae02067edd38a89f9979cf1ff3f06e4a11e04ec1860b10ada1bd60c6e8d080ad10e0fa193077c66d9958a427165203f883a99bdd735009b480bd10d3844a0378453355a1db96b658020fca96ac2a8bf09486145fd1629c026f93f79fe7dd9015e761ee36e0c5edac91a047cf5db3fdc502525a82fb25deea0f2df6dc6bd75e62ec4f52e8c6b66927e3b36e8126768274872ef1154aa83c8fd72af2917216894648afe33e844c4f2be2f332707846b645a8e8fe1843331a4e5c775475d25eabcb4916cfb70422a2e45cc0dcd995b2e1bb96479788d9bbeec5d037b926357ba1e307726cd07d0614377355010f636a764135c7309b437bcd9bb375aa2604433832ad016421fc572d248c8811c790f4c2f6273b08ca319a128948df220ec9dcb6e960be1f8439be1e8978e57db2d749ccc62dc419547f1794e5e39872701fa428783c1870591baba88444cf0e4162e21410a446549a864512a06aec88e584cdc80e70de930f098f4ca1faae61494846e00237f616457e41978bde865d589b8c8dbf0ce0ff56a04b0260d5f3d0d91b9f012ec588b5df5ed4603d411d7d5e1bfea2a9b7ceee8bb38ad5accc66b02b50025bd4448a5da013dabae380c9bf0b6433ae24953aec36b39ca7a9fe048196155e7b4f1c6a8fde22ccb11b6176648bc4adb2e4544f82bfcb2bf98d682826a9401db5bea2aaf49ea23ae20b0d856d47d779df40461224e7fb74259ca9ffe4f50e64c845e962162e47852ed7702835d357730923867bd9dedbfe8c0b38800b72d2ddf0b7cea0fbd3fd4f9bad67dbb827e65eadaebda207276df25033c8cb3aead7039d275507d909ded181b30f3049a124be7bfda4f10d2d3b011874a2c4cc98b40dd3f859354caced28696895aafbbe4bc226cf254d48498963448f65ac357ad4bebdd082f0c872a45d7f4e71aa12810aedb9fef79d0ab02da7a7cb4d6abeb7876d6372addf58835b784afda5836374e9ecbacb89a3384f2086f22ca2a2018776fbe9bc331a4352daf5e4812240f7825344f7b3492b01a32767ef5494ed13b5e8c56f7d928d13af5e5b493d5ccc06c4ec250aea3277501dbd8febaf49c090c5cfb95ad1900d8d1e99e6a840f30a3562d313b422b9e487ab0844cb15d0db2686a8beaaa127fc31a6bc484cf8bf40a2b4c3ac733a6ba0a996435b376657e4513796d697e9162e02e5e336266ee62d841d3696b2f99524423ef97b87cdff17919e70ed03663599ca104a7c85312b1b279ea6413a8f408c2f63fd507a1ec4a3736dc1fc45483a771a1f769261257b37dc1ee291c4a394d7f4cf1b1db83bf1f5d44cf526b64a471e3c2542d8453ce00d000dd4e7afd4c662a418311daf5f435555b1e17f47c6327661cbabcf89bbbb12bc05be3418a7ce6b8fe37de811cff44d92f91559696e1956444e15ebb05c5568f1d7cff6be0360cdea226e82b8d4e698eb30e89c7407a0f93fbd543d5acf7ac50d3453b2917d78e03ff249603efb126ac2f84b22297c5a8cd14e4cdf558421eabb3795b78e089084fa34f43113c9526bd72dfbb8b379c8142cf354f70ab23c863477b37830eb0853ebc8a20331379546abe9b7df1b905bd461958efa091064190ba6485cd7c9fbf9fdf31cec42859aab3d81184b6965ca2ef930f01784faa57b7d2fb3ede0ab0c883b74fc20f6450f2c61515f9038f6ac928801b680a79509bb6fa043272f1cdc66b206a60c22df5a71d2b06da00b495100223a42632a6f6a50aa05711334939b315291315e57c52f7e3f468ea004bf83700f574923e508e0ee9e9458690be77bfbaec87e2b30bcd629c2dab5987875417cb2696671d3227d2d4219dc8ff1241278610f09e0a09dfcc3fa9fc22e7478fb983e4c1244f2aa51bcf9640afed0355632ae2ff52841b7dad4a3a4074724739381aa5096214a9528ea396cc74ba1a1dc632d0207a998a80d021dae3bd952cdce47c42ad5690ad2bd7b24a7fc7df3aca19bb5bafc9b7c28c2fcb1f716d020f42eebb96687798a536a8314b6c3d3e1dae5e8789d109bab4fd853572e855e5c7d75b14d9627c57544eb47977e1333e1a1a2db4499c7c9440e7c023e0ede39b258661bb3c5e49913fc8a129453617d0f95ab224e2c151a3d189589b64020721aa073796a7091d1c5d4c398b91759e1b3b430f0ab9513f05bb990b2bc09ef64904b47c4b03a8c75bedfd3724b358041d5ed038f7c0eec19484ba1d67b9ef3a066462d1c14c616692af919f21fb782b5cc245932f87992e9ccdcaf6cfa0691078288e18b53f64151d5d8bb1452fae521d18e72d070c79088debc6ce3a56ea764aee1a7318e990e286432f1ea04c1093e721810dd3de5c43af99583fb98cdd75dc792a1d74f5b98e7f4d96a1847cf7c88a35f322492d2102cb08cc645d63404f7b134d84ff3cc39f0ca2c3efed9d699903d3b15ad63897d6c245f33ed2a59c4f49c2e146b240bf79695163eddd7df1cba107b45ce10b11b3b36a9aa8106f8262cc0689988d4e38a34c5565134f7545eb40e533eb9ef6573fa381f84a319500f23f80c1f934c00b4a8c8782721451fbbaaaecf48c42b2254ec04ac711cbcd9e26556749d272610fcd132839e8e653ecb68c9d05ad064c86ae4c8249bf6a3516231df6441fac2b75397c9bfba87fb694d3c767d12230b0f8f2768cc923d14c80dbc9b50a1204b4f83845c1c6fd292cd198d1a55f961b73358300c55cc5df519876e9db7b08e365f9f12f11ac61f6fd3cae1b2741b827d0770dc614fab2c320e614b1b8413138dc9d1e50f4bcb9a318d88918102e858a4175e7073a27b757b92f5e4b44c12b78966e1389d74617d6fcceb39e3a02005ce05109eabc50e90e2161d68cfb6d619d386465fd0f06448da41e27cc833f1fa61097430666f70992d43fc8e89323a4de218153bf172cedcec6c3681ffabcbf6342968fd73f7faa2499039722843525b72389b88560831f35820050f53fd75bd9955662888235e187194c91a33df2907a086f7986739898ab4acc31dfd3eeb0d1d7858dc1fd3fc2b89ae2dea3c9758f00ffe96fbc45ec96d632a55a85b47608422981fb11a88ac8bc87dd256fed13820d6b93d4cd8f3e4ece747ea7b99ec6913043724b1966644f4826d24fcbccf4d5ed8d1dcbff61bd16e46938b085dff503acd6b53aeddf8eed5851ca65442f25d29f1493f37e7d80d8e9c2df460d3059fcc26b22e48825c3f09b481febf88f752d29950f59b3609c53638d31a25cb19683c19e14afada09c49ed2bfd82a50437ad66015b1c2c4178cce9249a17d5bd430d3b75e37b67335773603d8db7cfe03b045e9f32c9688de956057885415c2d93ecf07e7497700bc2fc30ba55192bcc187ce1beae747ca5c798c978b28c99739348a49c7e165f46a8c330b9f21e033b796fa1878ca20841d33523e7924afcae722d9c361d413136d4414b58aca21abc7e6bf8801a8a4f57eb5960031e7818359187e0dbea0ee0735dc6f4e0552c84eb5d15cec0ab94acf2ed9b505a3700ab03a6542d32d8f91b405c1013863667c4fd442aacca103ec2933bd8af998d3acfd4a2f4111a23cecb9168b7ff018ee6722f8fbdcb2c51b687de2731617bde026a4427162c5d35b1a10a1a912409722b06eba48ef03a5d41707449f8cc17f9565c8c1d794b03a8b0f5133c7bbd38484630ff2caffc6a7a9d2b4f73bc9dbe3df1bab85b24eadc1c163059d2e765095cc5d305d4709f75c907ff059e5a09d81aa067cc16d8396a314d34efa7092e40d7ef566998780c6b038e38ecf9bae8d37f3efeccee260e8868de904c66dea7a455f81d0b8b550d464922c7ea637343da24b0b219423ebd22ad003bdfbcd04ef4614399b128dbfded3a954232fee6351c1679feeaac685fc6c10e1b18ff3aa2c5f063e2fcf25f7164bccab20f6a6664e817d45166c441ca127305323a9e1bd1cb79955d540f6846b036bd95a067da825a06ea5bf1114c4cc306e450f872035c475cf4e1008e9476306b82412a8eec2417bb655d87bf027ba7036099b66e2051b827cd031a86802adb0db485b8abaa3973aee17c4dfea207d2437cfb07885c7a114700f86243aa108ee71b3aef6b0d2de6e767fb1590375441dfc058ab9630b58ffd3ab865b58b81a1c42eecf7167027fcf5d1962a54c29cd9469d4355187971cee6a0bd948ea81f3fb047abc6d4d8631dd411ee9a50a55287e48cbc9e4aafef76f1003d081707a01b93d7eebf4dc3c46df96232f5476fb6f2e4583fa3e3de4d7a660a934b2f6a43efe6da3f95af74afbdd8954cfad0bc50cdd7059b94fa0795238d5bfafa4144dc063f1aff677c07f1e36c7d3f5bf81040c8a3ceb43a32b0f467a2719a9df80eec8f8a36605dbe8dc0473628c9d7eb2abcd280207401da42c1ab1b22be3ad1f2516be8f43a9128be0817932748243e52ad46ee42b7a88147afefe26b2a20087c3025ede4c32bc334ea6442c76504620f4049ff07aa701c52464d1145e6416acf19d5fafa29454e04272e6e42c73549ea640a267504959d55d3056b08b32345bdc51ab2e79fd86b0280ce914507a40e8e73d665870f0554bf9b1e48ee84efaef19cce168d3b3905da85c67f67be5e8e0a8ac92563d2e9e677a3d51f9c58bfc2ebfac990505e62dc629f1a6e43f9c5beed94b991ef8d8b52d2b54a0e833972c961aa12572678e1bef711f0daf96dedd28ab06f89a5497912de71e81ace02f09d680c8b3bb197991ebc331d1f1e9014ed6dc1d835e9605a77776707d690d48f6b7ab6497a43b037dde0048f89113005bdc39873f0c66842d107cfe9b5c176ccdf40ba685fbf66f2bb33174d8f36e800bee04acff1896534eb25b53747e173c604cbe5ae9c840d5d077586ceeaf2dbf35c15cf4fc2f885e2655f112cf297ba5ef78a9494fd5f021a64feceac0d21a22732812ec9fe6842bdc69323c1a1f939e5d52193bf5ad60bfb3b850c299fb385a12b4859a176bb168efa7b8c724d92924d22cf8eba5d3a95b71d894b4d422c624a0aa44d44d67aab4357f965df25e4dd07c654fd54efc0ed24f8a67fbb0535639bb491cbe6d7840eaf368c5fc50842d74bc20b5eacc0c1732da3a5995b01bfa25ebf7a8854f585f2d7bbf72f02c9225489034ce783731b0d2d3e97e9a137217e5f2671475b470e6f8683f84c6e0162ec9f83fff6a0496f4c4b27807bc80278ccd338d32a39cae6eb3e9be26d9beb038d6c9c45122638d2dbebe1a4d87befbb77d44dc383f659335808a1bf4e4d808a0283291d5a974b02580a6045b449482ea5afc73a39f572e6f4a7d9507cc19f1bc554d2175152c27a62e803dcdb5dce1522b18b3b16ed964040f1bbf8437105cc6d0d21e12e64292b5549955492fcaf28d08f57062765b6048c4106660caf51fe9d97b3f097c5b4519bfec94c7b75d9b062b17a04cc29a9e8a55981a68632e9dec9035e89cd5669d79f04b8ce1b81782a90124e22f89aed4737defa086ccfc71d5158ed551268e6d6b5583af117ad07579369861d72daff68ceed6281dde3e4e8a4901b61cda7819eb1857e8b65743911145b7e147d43f472fda89b5bc766a0b949831533adaeac3a2fb5b94a032a5291609ae82d1a946320655b0fb8e88ee8f0cdd87f9c9bb39a130bda3c361ed0f784316197b6ad89c3d694061ccec7751b7348821bb73534abc4b027c0eaa362f173b55d573ade90dad2cf640edf3df23754168fed47fc60e09407d57c0a00083baa6e3f099370f80e21b6625b05a977d26262ded3be2a1b14457fb1baf0a1252736534589dd3bec32db2e8971abf3d1c0e3676634fe83ccfa06b615a139794bf7e486a38cad22a3cd4fd7dade790ab2440866917951af0b278e02a83b591a0e5a939cb5ba42e06150d6436faf6ffcde6c9dedbfe51212a9dde81d8e9b10b39dfeac3a6ebe890765d687afbdcb1609d6716c2fd5749b4df15f415b177aad2058534de06fa4f4cfbecc583ca0d4c078bd01892dc9ddf02f1da8f4fac082afb6e6ab4410b46980de491df59b391fc0dda730d27d6c0f424bc93927f3efa8ef94871e8b4c41ddb0b7d9f13ba7c3142d8287f67008d9550331ecfabdf4f947a1630477fe885a6b762964eb0cfb7738ddb4b8c3fed5429364dd3e27d4f4393fff0d27cd4acc6c249aa90d2d70ee92e6db277ca773351b5e4dfcbc3fe7d94271e87ddcf38c7504d81c2e3c95ed1d4a4464502edfd093eea9c93a27fcb9b5f8bb14a8d7c62c0996fe4afc5fabb27d068921afe03a3f166d121824102816da11d5a192bf2ff4d094767799b3fdd4b5b007c328d4b8468abee41c82248301777af66c7aed2bf4491f19439cc4032a2f3a01973d4c3a97b7aea7cc5caf2912857f54cfca68f4fa9fd6be0d0d47a91a608909644980128df58221e2f0fb768535eaf760f98c581a39bb2ba939a26f2af3c1aab39382dbb8d2701a8571621d21c62cdf768fa5fe28e409ebadb62fecc3790066b787e6de9c5c408e7afedab80ff88500baea48219bfc1ab829e2f659dfefaa03683757815b0f4318a378a1ac99b22a45d08c9717408476ab37297e79c62f106d33f7ef6c1cfbdf983b0d6e38b23e30cf21501b8b1b4e990e7c549cfeb133a6a807f7e4ab168055a5a078cc7572ac0bc67b24bd3806a9b63d57cd66374bbca3f889bbc573e2486d888a9f3be7b1e9c9a0423154c1fe6c1ce039f3dae5817f29f4a4adf4a9408a9d025d887477d7ae8bedc87ffcd7c6ba144f24243826fdd9db97a2bc098c02aae2c5e40204b600437717d1cd070006f2ecc4847da198be7c246d5598a5a75fec050df9f4ff363e66181662f5722fba4ff957c18986bb61306fd11c9ad21ead7002cee04939bdf9cc96bf00246d5614de4edf77495d4535f48e5b5f889098f53bb6b44e035e9160f16d23b80fac4d87bd70ace363a4904db77ffed5055fa731642ad50cbd583dfbab256a338e441b8185c55220a41e3d5c550c2400b41911a00ad7a214219a341c88ae9bfa6a3daf09606fd43614f37ebdecca71479df3410557c45562d1ae402eb290225fe2fab865d9596b054d1d93740c1ba2f7f3e328d4247a5b43c80173c3127b5af4b2a8531f8a7777a9a2423e7c2b488e85a7f6fc831cde3c668d99f07d2cd9144da7d53823df77258fc830f4180c6a981b9c229a0afbe94be3fcd4d5c9ffbffa9d67ecbb3fd65eaad1773c7bc7fb388abd21b4711e571a46b697bfd478fe0a22eb9b8c720c50eb9b2a3ea340205f51b819442b4ac1a416bfd942989cd64f6f3fa14708e1b02b4b5e1a215b6897423d428b33a99e92548f000ddb5bf33758b4ee81d4c494823eabb620d66ee3e240d69376bcfd24ce3e5cf6ff58277f1b73aa947e36fb52d37b26f508e711b315fc9406a35ef13c0d7c3a1e280bbf38c429271e694d09c6838fe45f1dfba5e4bd8367f452a024ae33927df61a3145f35697c1cc71f0aca468042b456ab238d0bfba41b2d382216be37cbc77ead02b0faa36c75e11bb281c410d4a9ca05f6fc1d8e53c909acb07bdfeeca63180cdde3b71ad4393badbf8482eb5813eb0aa428368f0352d6ecce8b4ebd35fa64e436777e26aa2f2198df5adabc1d9a14b17e4c3a824d2bb6d7e57e42975192dc605ab05b3408b7d6d85fb2120249b596521fe328b96f31de2b8db5bf0d74b5be06e92b1116fd392eb477a1502b549431e093c8edfc64308b7f22bf4ea139540f38c35f91b3eaaba1479df77c1f763c54d4f928981644c278222739625252701a2f9ea1ed8711b11f685d6c35490c451a2ae12466568a4ec73955ad90338b18e11e982b190e783d840e944b40123279bebe01a17e40f289d64725c21934af42f55d575b97aff02f952b39b93c77ae0b700d55e8040b454b9b5e1af6f44904900a5d6ebbab71d7b37aa968dc09526655c75739b232a2c2d18c692dc8c5d9a8b60c2228423c60155762c3012416462e89aeb4d0b47cded59cf1da40e8c5e5e2ff9142dbbe3be03c614555c00d8b2a8095ec9dae6476e4fc9bd0c7746b179f41cebc8740afeed724eab06f6d09b512afd90c861c58c94ddf01b68bfd32b7578ad280ce902c6568fb0ba5a066cb45e72185ef69a81e3b7af485e3660508e515d53e184efc4eaa0f6b9c9451d98b421110314869bff8a62b7ac8268d4b90f041260cef500ca5a0280574950b13694536da0a138e9208136017c9c4eb58757a6a779ab44bbfd1796058d5f4287d003a445110cb03a33211912159063273b6f2c8087d43c23988179effb362c2829d8b42b71dd22a030bb69a31c913d3a64d597163831e7848f6efd711f2d646de5c4cc1bce86c00a6d9cb10da23ac1c3987f7fba1edfac24d666e079b45169b8911074831349423300cf2f221f0501057db6131e2a8d56a151de76c0793e1e9ba8b303aaecd61ebbd0e4323ac02532b98b9b6a13a12b0162d66192bcc746408177a3a9312cea2188f2d181f63810b0f9fdbc59365c774231e68d530c4fbb49b18ccaa954130dd6e9b34cb03dbda40e4a13ddfa32d7706910f3c9a531ce12562c26426e80461e1d179409c1de37370f264e939a986f7d72980252f2e6629860cecda5d9195e595f924987cadca5860e6e78f38209f05d9bb127b71e51fd2586061df0c1486edcf020917853fa97412cf35c57aa52f8257e541418baf812cfbb53136113c7df74fafaf2fa087b5f2dc509abc81f74aabe1f5910c3505ef0260859ac66b730add738824841b74f7205ae672f10a7586235da3611a859de371e2722de2ded9855753c5dab8454dd807fd6f20d5eae76f2b65e9ae04e100590817784b799947db51eda4d749dea95fc24663ff4549bba36b3ff71e54b082d7f2852c2dd916ef27ee7162c54927a3b466c715418ae5a6c3a9ee911debedeaee651c14955758428b467be0209acf36d4bc25f0190c54863d48fe9c3b5221b7817a6806d0774bf77b3ba6c92c6b0a348aeee0ddc840521b97d954bfe5756381b7a80a4e9e1bc508943e289fb377a07dfde65e95be98f547c0915ff71c89204adb5cb64601ca0d6a0298da792ae97da93377023dacd94e0b41a9947a44e6e6bfad9cbec77e79a0fae6f0fbd684c196d8a190d79a81b99829218c127445fd337324d5d0479684ca517ac053de8eed88d2cb352e82aa31ebe04f8d0fe3555a5063d1bda78e8c55c7ee05ac033f7fe904d18e86571e4a3e436c0d3279b96393a8401b9ddd179ec3b263265400802d3e9aad74166fd30e4b06c2a1401bff64cac584305c01b160f85954b5be49d2fa35ed3338eb69b012346a2ffc698f6cfadb909ed4fb7cda971a14f9f071d7583ab1ddaa17062544402659c709fe40b54eb92812b685c9be8542b51a0706f74f2500c778ed932110f8086d27f2417cb76aaf340d8ff0fb979d7a354b912112a9600bec8cf2abe83879b392417113afa0caa363e952bf109467a02ce3e6dd7b243eee4d0a3268ad6996f9b70c80b14b1b2e15963b6d11ca21f30b1dfa07735c3ef9f0e89732eac6be8824059aa70ca34eac0dfe9b4ff5ca357444d3f1b658d5b5c52af349573bd1ac862728e5074b9838c9fd0d3c910e2d45648defaf11550b79c42ae7ff38f694d9b651ace4cb6d01eda0175a72bece2140851acf7ba5996e945b11b8ae463645b1bde9f018b79c27ef016f25702262525da018ef6b9880e4c1e2ef317628fea20dd60ffa8fb51c8fd019f73cbb76c18efb415e867ebc73ad3265ee9b88b9859110b7396a7a7f77139e37b695fcd3aad287b10faea7a60622f7a2ff5a24023fa9cd8707dad830f7a8d08efb03eb4d52e57c9458acdd46b728fa091006497acfd87974e178b3e9845066bdb0c560a698bfcd3d12b39f2560d157bead2cf33f014ef9f5bea14e9a3d43416cf3ef4f6fe05caca1454c40564a60e72b91fa0ef8dd14b3c4120b4a904e366b6bc845f4a72523d5019e4d51aeda79aab818ae059c9b82cb5104f3119a441aafe6ed61fdd4abc8fe394be4b000c38cd4c2d436f96cc0cac15d58ed6c6c0d9ff86fa06a5938f9f3f3c303cdb7c54dc76d204d9929854c287e9a1682bd006eacbef072fce0a3a47d08f9e76f19be3fc0d3054ae30908cbd97b52581a32dd5db3ab9934da6c49db8117e5f39f0a54642194dcc74175dbf9151548c8c04571e24797ed4899b10ca80b00e54cbac370b1a101dc8318b7c693d6b1a00899953a73ce92b80d817560493596c7349d0de4c379fa2a66921063472a883734ffd27a8d4b1647a3421de284c9d99a71afe48a3031b0574398bcd172496983b6f3a400a7b7a0883d0da2245dbd0fe7456ca3f15448cf06da545fa1f1d0932b4922e230c6a275db02c7b90c572f7a4b9002b16527120d0d0550f2f22c65d02ba7168805ad1c89ffd442b8845ba3eee4c12307725b6ec568771a3378c6e11e572639f852f7b0533dc43ec723aba9767b8f95a253ca9aff839c848217f66a0bb81f2657c41a9c48c212c235278b56789034eb3175c3804f0a86ffcf2227c6a9baf3990bc765e2f4fe4a462130059fdca82cc46c1228b406eec329beb0391ba801dc98ad7bea404e9ea71d4a21e0fb13cbcaedd5b9bd0165b44c0fd2b0a3e4f514b28693d3da0c6f7c5e2ae75ad4b10d01fc5e5f127c91f7dc65d14664bf947116f2306d655a14e6b7d4a6e8688b1290080b3216425709dfcb41fb3ee510c89614bd738828cb7b23a4cfeaef404aef945726c44c542518e38b7a3462c86d903b4912eaeecbee1d3f569c3a737363cce0a2b802aef164f830ed053d8636d89c74416a7589e7a4e75c6c8c4fe2e92776fb17071cef5322f502a311068098d40c830ae9d9e4ffa804dc1ea178abd276ff6430c7e821e4c7e48ff8745db2a0d1933c0ea6e196afc9947c0436bb602f6ef09e2fa37dac149557e2947e63e6cfb0288c67008bea0eeca385a87eba57a358ebdb372a44b0be85f4094a762f0c3a2a07033405ac90a14dfd277ef4384ced7a050d06016e746a3225941f97d0d698add4b4feada651da8aa5678720e7a69afafa9da1813fa0cd8541e07ecebcf596ed903f062468eb0329e92a09995cb48d5a32126d70a082eee2d49db874e8802f019dfa9fbaf20e6956c35a6cb67edc068bc5d0d05f3b9a6219d78844ddfddfe5847812092ca533c34126be5eccabed0da0b9a3868cde74b9afa6a9e012108ea6d68970f8e231a53c9772cdda0ea2290405f1cd471b365cc5aac5e200a8a43d4087c1e9f28577061eb07980f9127d38d3360ffd84023bdd2d1860c19f4a673767e3ffc81e38a9a2e145c16c0c09c6382e4b103545c7082d44fdd5d38f89f4c2f3362240b1e5ec1bdfae61c6b89d1e7b92d08160dbaf5c6177e56e6ff9e847068e06399323c12c8c2630f3f064fe66dd3681fc9889c450612edb9379e6f30499a9da1ff7c0695cd2c2192ab9c0a7886f1fce6f78e956595f7b01c62b3b9ed8983061aa8eb533f18099fdacbf5e0ea75d6f1b40e64e5065690dd7b9ced5f31521c30b131228fb3dadc007d0ed45fbc814763afe6e3a0408f05f1f2c5bef98cda02f6163448a7e2fc0047a933d680dbdeeb3e762ca04506ba05f3d7a912216e20a0d40ab96ddf24cc739ba5ddf50a18bcfcd0ec062232ba4276d2ce61fbe8fa7a1f56502e4698f5f4a1607f518c10d11d2ceb8b34653a7df7781fade8ac711772400345fc657ab309eb7e93d5de3f9913da3b58edd92e9f41319cc464e0ecdba8da0b3088dbd23e29aabd27149fd76464e55a7fcf90c3838ad0e43526013705f0a8d185f4cb4431802cbc5adea3f9465a009b8a1194c0d7e41391ac4685aa1fd3db8e4665bea2a34226a74c5cc2b80775946d14ef09319a6ec92fe099193a93d5189e21302e308a9c59fee2a546d8e4982e130efaaee18a0d847e19c15f361ada7e63393bf2424b65ce92a2092781d04b5f21593a8cbc968c5aa668e18242b4430c7e062069ee9e425f0292f142ac4c2ed1cd251cdc756c4da465b55c8dc5fb219c5abc6c8843836dd27c859d4794b6cae2e1b5da4824a30a2b76d7d89256dd824e1056a9ce3e11e9df987bd070fa8b290d6b219492fd84311307c5a0158f257e4772b2c995c94ccdd389cacc041bacb154e173d57b91612dcecc432adffc8459569faab9ee3328c7f8231ff8c33faa26c326d099055bd102f554e7cbc9bc902bc4d92a68f55d62d3e1a85d6dc996c6f9db157052a44dcab866440a92f19bfaed94c82449e0ba4e91a433cf399714f172b03b23da8da7ebc627de0e25df9344e5a43e1c5c07fbaa4680d64a539433dca77a2cc8fee01e472dc82dab74dc03d484475b10f95c1068f5f7da5d107bc1174cbd366894cc5e90aa83be20e6140e2a3918644a31efaa615206d4e428b60dfa3d0069f78aac16788247f9eb7a8f45661f1a31c75d51a58b6178553f320bf1d95bfc1594f3ff6f8c9051a50be13063a7d51bc7291258b55e3dccdd44eabe0aa1b42080cfc2ae5d0fa36c09ea4af0aa4d506d128851319cf40d19ed2b503b8cf66e46eb16ae92ed46fdb23f2208bb93f6c4b10322f4ee9880d0fe66b5d2d7c9447f9c6b183d394f894cb0271f1df42cc13552e81a6a11f688bc2b212a1f715bc78dca49a30a9f97bd93828c8d4be6b97a4c4c52978f4b0aca8a1ad381ae604bc48e76055dc21550cc7d83a990e37b03ef20aef5c0d773542d7bb74342aad6be630153822a0097d12b834a3f2cc67619932a0d3f64b3f0d16a6ee1409a519532a66148fe52b84d9fbdf5cb2e45543810b4438388fb693057c66cb2fc0467bfc2ff6b8a24e0576817443fdf86f7937feb6a9749b0e1fdffb5bbe897e5a796f60a25eade7d1c73e513a4f8f58fc67463244634e602711fb7e3c2ba3f8be55046feee30b1ab00868edc01413162409cfe23c4a86c5b156f96ec9c569923188a474f54a2a1c62309e6d08fadeab48928e27f4fd95188afed65952ea8c92b00cd1aa0f92fe177411f725eda9df2f717a2bf4f75fb22a02d386842847257ef5e3897803cbff2f7c3d816c5722232ba7400c9046235d7c606600194e3abec26accd086239ce5899a902ffd5a74208e7b7abcad065257dd1857d7f0c4a27dc5a8989ffce4e56d847fcde228e4042bd72d627a432c1890a4eaf0033e1505164c481894041b59c2663ad8ad790ccf4466bfc4f10e090d07d9eb428a557a6a3c1f3935194ae0caa81f2e5fd6b74b5a8e23dc1b3789c00f3ff180a50e8b166ed11e748ab6be34ea5dad4a7dd19e35061c7df98a1a972f9a0ca4a791308841e3932867776cf7b9f2e77fe47e7ac9d996ffd92ed0c109ae6b533601a8af112c3cdcef013103e2a2f6dc2611fc5d0a8d7efa9a5ca97000509a436d259b821236499715c7b2e867f99faedbba380d38b1c2aee210d030595c6cf711726d1c1c510cf1a6442b5652a79d1de8641eb8d40978f3efaefa167861b585023b51d20aac15ac8a96e8b6a3054b198a3e37f745c1f43a9067c2dc3a3371567d964123eca171fe209d6ef92ac0d6a0b634c040343b31ddb6eeafccd7fec22c256b8c5d53845c46c8c3e8ba491ee3e5f6066748f7d9a5e061cfd4c31d064906bb71fb27ce1cb5739b7b8722b21b437d1885472a92cdd140646a4e41aedb78805d934b58e37aced6bd394240abb21e7633859c30dd66b7bb5010711592b60ab37f476ac4ef8f69441dc506c42aaca672e9a6ef20c9bef18b1458368d4d4554ef713b419e1c27905f81fce039bf7a5fa746746031d35a94cdfb15595224c8914c198268c6cbd3a0eaf418507b861c8ce1b3ba684a17db41b1fa7884a8ddbb43e282b58dc4a920560bf021b5385376426319b0500ed8389d350bc208ddc7a9c1e8bd11b77c836af7df72c0f4811a593ebe6dd7072eaf206507bbc226bc58c6a2b6d4c7d9f9668a845ee700c3b5a37acb7b400694faa175dbeb6c3a69013ea799e73f149e46810e6843799c24f1f796c543befbd00bfddf1a716be9dcf837ded18b85e42b48a9c0714e97b0450b55596adb5fa8e75b660d7639eee83e1c355b848620f73974f728546488c97531eccd1b2b44a41a201958f346e1d20c34665386ae645a6658242810f865b74e85ae7be3c8c87b07501aaaea90b403d8cd688f4a89d52440048095307a21607c0addb0f3f90c0fbbe406e997ee0442cb6700567b230586b2df3e60df641558b17863205b1c5438d2b07e709b614c0c9d090ff615c22506e17f69023c3aa1fe8c504c3bb88730c4cc39409c144b4d9867d45142411fbb7cb789b6ba59e03ef3c4070e2bda4cbf9e5a8966ee68e258677a9cf376f1b502a4d856ea7a60ba3082a1bff019a8e6620182744adaebc15e4e9d62ccfc55c83f1cdbd78890e7bc6a07d6474187f35391f9864105017d8ccc7286f1a13eec27548e2ca3fd1e6408e453522cc3082ee3fcd1500b3bee54eb18a1483e6ee0ce0219d016a2656a9b53148b384a2127054e1d869eb96225e5eaa90eb68a61da49bf021117ca69e5dbac07ef396d841c18ba8e713a20c0626ea558c29384e1e184772defce8cacc34ff574fdd4cbe609d509c7416a84e68286b9c8c24c95922b6ca0cf49836a5add1660c66888f1654029d9691935ee7d5cb359d1a97da21d85457be6ef2fb85ea0810ae9c6727c406520b345e9ed91c0aa2114688edab76aab94d98114aa72fd8f6d60d9f8ad4537477d0bf8ab65678eb1ad8b47bb9f8ab990d35b38b7b3358229cafe9ff635194d6deefd36ca8c8a4bca6eb4456c1c1753ad2f4dea710ffb7ded4d4613da1b4141e8eae5d6b7c683843a615eeaec095659580228ff78654d884bfc04fdaa559c866dcb4409f7f2036cc41ef1f34bbc3da51e0d59c213fd977cb0a31283acacec51934b42f20ed2dc427e6690e7e12e8fd5896a82ef07be711691a68a76983ef031a61feee1131a683fb27411d364c31bbbe2541515015b5bd958b5c46fb6709b2b4d1f247a3b6062c254f975195557ecd5e8ea810e430aa237591957c5eae5f46e7f1569fd0b0059030f9a5f26f2377c9a3c42954535235c6720fa973318300c4ff5113ec98a0704f43c1216953d0f95150e5b693141092ff9e9b95cf5eabbf578f60fee82646583e5b01674d1233907acf0629e571f359b19c1f2ce2e9853830555705cb27bf6a57873cd9b1c80c783550a42d03a75ce8301c50eb1799089d3a4e5420b89c0da4202313a02bba62f425f3ddc4188f9e9c796c1c317274048a2f466b630b45c037499932fb249a9663d2c375beb0ce54f8d8dd4a5ff90a38d2af3a257be96e216802530c700919534a390ab200eddf32d644c45a7ffa575f702748e5c7938a29b1a0d615cc61ad63e7d113ecef6c0c3ce0424ef3e154eeaf0d347d3809ea10876838c8a9e054e314003557ca88956400ec8e5fbd00eb899df38b1dab99ee9b664ccf6ae1e307346444aa6e261ee83e7be29528b87cc47b62faa3a58d9ef6eaf6befce00d0e6c1f38af6ed531efaeaf3fc09b37d02c149afe821f76ab6e2a88a14da5687d6445e02baeb9c76206ae1c4d17eb4e7988e44012dcd8388ba909312f1e27023b9ce0ddd03cfd7489296a47907a8572a44e6f7793f3061c19366d6a5e8ba9887ace69c8c11de0a5b20a8642bb10592ede55dac0c20860000f9f578d8d15bdd90f3073a504ff30a2b5d21fbcc768f5417033ebba0fba9e7a1ed15532b201ada20e68c1a70f7fa99c6874695cecdce06e36309cab8d3ea56563af41a03c712647d5dfcc0931e9b88e498a0e772996b3182ae7b882c882002ef542e1c48e7f62f8c23ffc35f264bfaca871e1514d92429b394a6c74c8741181c6a942dc6c079ddeb10d44a774b7142ece900f27ec2b4b7ca07e200ec4d74f586c863568fb5ddaceab947b3b5f48c40c9197a9a3c0d02d0cb7ef1a3420aeb3006d12cd6be8a4210686d770a02d92473bf2c3d0ed67330aa747cc2e45f3c25046cd7fe7aa6cbd6fe6944ecc70bb05c1e0833fb1862f3c13e87b8721375430c1c6bdf4be25f79d720d63d0c03060e401aedea088efdb4fb25d0db928ace2f26e300f76460ed264d88a4ac0c2df688122ea7174441ba115efee7a61f86827717d3ebc8acbfe42d9db46795b8f6098b9f9997165be0a3ff550dd78e4d02d8bd30013de88f195ac744f576d81a9f5411c5968284c80a6aa7c2788ab62cd6ea2bf2ace37cf95bd4b437ca5e4600a846dbc2c03ced2119a2419735836a05912d4fd75c306ca2b7878c3dd5ad0837cb9e28ab7092e03111913a08a1c38c078d448d3ce116981d3659fcf771e542206bc5385bb3ac3d19509de0a514e73c794a7d8add10baafb6d8396414b13bd09b9864a065adca1a7d1b8cae7a2630e2fd96e6e3f8caceafed6a803bcc11fcc47b14e9efa8d1abf16f77a4010b1de1ca824c0315b420376c1d05d24c19bf4bc711aa81ff0eec4d4b8c91eca6781fc424c1746aa0bffb7581883066d780d5fc490f01d03e146a302ff70ea563a904e1f17ae751de94e8f9bd6bb77866d92fcf00a8695962d4f119de5a995835b0655f8848b369d9d90b004f2a234f64677d2f4832dc48c3b01704855fb479a22e763f1fc33bb986417a6529c097e979bb626e32fb624cbfbc2251d65065bcdd3564bf41640befca4727345e563c7853b3335955a03898d3fcd66424af30173e0ba270a7b0be949dc5dab8d4f4835fc19e47d706dd4cbef0d5008961a178b671b5994143facb26036cd331edf846abe8a2aaaba76588f267c7bba50089a7e909c66a109773d33025613e7e63084b0894e30a4a130078ae7510ddc097a7b0f838ca7f30efe5bf13dc271484b42e3087aab4e4c4dce05dce78fe5efec600f609aa0dfcfc947c9111f898e30f2cc898e5d75ac739dab1f42c6a1e492453791b18c4268ecbc38b44d9d63ed5b5274a980304f8802eae4ea6be5db9fd822e4856d1ea4e0fb6e2680bb8f3313bedada07fc55b2ca6f83e910430d61c2a6513862c05cd344e9388a67e5dda80293db2dd032170f3c191558091f484d08d3f7d3ac17f3dde9d8d9a8df39e440ec2f84346314dc7d7533c52c1a9ab0107bc45f91663a1b96f0b5aeeccd3c37b69bfdd5e1c76744803bd9b156b679835c6ed37ec99188d1c959cef32b5786debf15502df39269c911c2c08fa89ffce8ff38d1362f75d69935c9c146ebbd9ce48e8f9194f774591c198de42b06a63491ff45367ad8bc9e99e901733186e6c187abc8f82287c336b5e0de58abe40bcc3c021c040cd37c2db79188d0900d8a52177804837e74ed3e0fd341bd6168fcfe00b572c85efe52247fe548ee74cac07905321b0403d6f914a7d1c4cf19e870b381892fc4b7a41e4c753f93c3ac64f7d79826cc35e780ebf2accfa29f32585efe1e94e7d0e9388143394b1ad08def192c973a5df632e616213e93863bd7510102e98b5b217d118c75d34be08c2e27774930e0ee422fe0b6dffab1c982d151699fe67946cedf98beed44464272bd8a1867dc0443e16e87d7a311aff14382b3de13f0c1443d4a0bf0de3bc3c3676c0182017e75ba107407d8bd703269fa12593c5ee099d9b4e3ac0683a90108800c018f8c320eddc8b7e1c16beea9ee8182beb9efafce0808b53023e6c7cbebedc49f7fc4775c16b0b909e6b71b64f96072b329879aec66f8e528cf4e0d0c8e1f892bf20d434d1068b69f99fc02c1f50137720543df6c42e006f25c9efc169099cb9ae6353a8602c542acc8625feeb0d9e6456bbbed7f6705375e070ab33a5ea450d079965878fc811dd125c31e22d0d30210df6c1e74214740bac6ea04789c465840dab260f01df51e32a450f79eca0d562cac45a1bc477f8f061b4197b0ddb4cffe7534eb0975a22274e20709c043456d99c362f38e728bc726d040149c443722a91544f62cffb5af860f78dd91065f37a0725c01bcc2587830e09c1341b842c6334da40a61f883643e8d20f86b1f76a7985fc2a04b51f91fc7014a8816462ee18f34373831bde28b3c8464a3e0fb20366863e59770c662757235026ae780d060f5e8a5cc4139d4a21f30fff7c1a4f8f25aedbc4923e725ce873d29a9c312196de7e510cdc8265770032c543e1904a3388f79ec793d489800ac9dfe8c4f3d29f428541e3a1a0448e5230ea2922075748d16f861807762c531050c9dec243df376c3ff33469d5ad268bf13496a883f1caad2751be61d581cfde194b50beace8c6888b5c52b94a611b1551a28ba21b5ae33aaa986afd8a7e9b6fcbf55f12e0c8481b9c4305fc0aa14e6bb247210e95d8eb1cdeb478d8352bd2ad783d970ebbd758ff32e7671cefaf322ca15e09c452e0bcb9db72b332df812ba87f4eb1acad2fc0886fc744176ab6ff97ba0ef42e4aac921540e060af0b5a3a7cd74325304070b21ff4a000079edb8ee8e0160498564e66929122945af8c406c5c6c97049454a9a2664ae6a6ac0fa4253af92912068fd82ca2dae72ebbe57879e90f3e340c021badff140b0818d58141fbf72ba3552e64726da25dc2ba54f14d1e5a9b635fd6ad8f379418272e123436ba01be5ab9a08263ad5b490513fafe2a1f3beb18a44dac5fa289f1ce22be1b22a16dcd581d71b90693baa2ad93c858e7090c00289319221878d91cd53f0702d2695fe618cb5ab32044f030439d57f2f1aa948aab3f2a8a0bcf618975303ede7be406b54d14dd6ebc6d5b07faa0b0dde1b08ea3bfffd3eb7625f2bcf4e182280857b3d5bebbf4dc6c7c2c8106b86fbcb62053348d3c7ab7165e50415e72e005e910ff91fa2414164c34716c5504efc71d6038f9980cecc46568b44d64e851244e0685ad9222b75847199d508ab0e8a2a01583a20b823fcc142d4d4b29027a16a8be1f5894b5006dd390a2c11b26d4df2ea042e366e06f7e96f266c714d97ca84f4053016fa42a002ea932e5147937fe3476c811d48625f0301b68ea83b2943d2d003b86c1fafe8f2562eb68f5859bf982b3ff1924f19db4f759ed2d867a82fcb772e1e16b814bb9fed1da04c8a21d2c9a35f9622a107053c3e977604448fecfe9ce0805b49fb392b6ff84f7ee7a0f452e7e7ecf4160dea1339ea0a7d801fc2ee207778fdd5e1360b35c841f2e6e4313c41cb3f1556622415a03471d4c6184e7ed558b17dd630186e7bfb33dfa27487aea2d8ce8c9c096af1320ec351a9523bccb8798514eaf5daad84272ae75f2bea880991ce1f772f363966a9510fcf7835fffda0bc800a7081ffff2e940c7893724def78267fc1c3b4901c489c42a68ab6608b020cd42e54a0212b2ffbb2d9300db420bed7c407ecc68ad2ea89db8f536882a451d6875d555c36c0ae5b15a2576014a9e16732675e89201bd2883b870959fce925a5f23a20b7c403cdcd30d0e07527f18681b85bb08b17f67385305432b1c8f9461a15616f6021716545c4bd7efac7b8fa5be4f9652b646e532c77b68b7494b63d30733a7aecc2ead2f99fc9814c38d7228098a573d82300e0b4a8562e1ea150818628d41097b1353467964cc1f88b5f7a9bf955ea511be9883b8c2178781a60065f778f58a1cf944694c1b5c44803b7249b9691b4069e78c4b34be04f08f61ec0a34a368979adebd4cac691b4986454daa96709b5cefb693baa30c0c28379091f6b825ab8f4062d605d37123b1e5dcb2fb08e068441d6cae65bc21c8a562a5110d107d9aaf77ac01573cf11db9330c11415d052ff3fe79329c068633a1226a39ddf48b96a976c782801a877cb06bfcc7445b39c426cf279d7485ebb00bffd8e20efe74e795386ebfe80d9eb3c8e7723ff53a37f1f9cb7e7b877f1316c794497e06c90d993e70f7fafbf2eb32ca9c985264eb0cceed586925712b8a5edcb8b18b6b1d5ed7f1cfad4cf5feb0a99744f91f0b7b6b8041e7ee5277356e823493aff7b39a56b1a855d384b0a02d903c1015f2537a186dde07b1a815ff154604b34f95357bc4c74134fd7fbc7caf2198e6d12e96e49311cda74d105a012ac15485f18f2c3d867104981f801bd907fc10db4792322801a93a78545edf14743ee6e139ad86eb02a387801da9e30959bb38d6eb23e42984080c0238546be7205f60e53c34512d4b65a7f402514b2624cdb4a08afa941d967b655315c5d0d1bd74dd8050757067e0321260836a0925c5deb5480596e9543752f6f2f49adae129b05eeeb5ee2ae6ed2dea001e1af45aa8be83e552f479f4acaef7509b2f52d9e0a9e5a1694186e98874566cdc8468354b23ff88019b45ff7fa241e83320862814b72a22dbf673976d0fe1b00143291d228f293c26b0c211f58a448d61de3b88401206ef1b89ef8afb1ed64ca8dcdaf4d8b0074bb02d04e0877059fe974fbe61e00b24a89dd0d073d3da4c9ee4748ba48c4f3534b6213d279f83f5dedec05b57b2656c1c783630216177e756b5b017129263b019f80817d3aea1656a8408a55a0dfb003129e1cba1940c7df492fad0bba8af530d6c4b3d0311f67dfdac73be2bbc60cfde901fec3c8c8cc7abdbec6ca77d8e73e65581f54313849c08a5e57976c19735c7cb0607e72fba5098231bda4a846d19d6d5fca6f69c44a02b1db0fff538f19e54894f4b25a26bca5a9a1b0293b68664c70010c25019092c554a95bff5bac345f2339f12957f42933bbe72ba284b8ca25ecc0aae47892346d5b3bee4617515848d40439bdc21f4420b45224a1bbdb2f0d2a7d551bdcc8d00db0052345a69074cb31c572c8f1390a4363239992bc7da16507d4fb00c179240189beb5d373a9e817bf8980a37aa3b5fd5a6727c372e04b994df28e831e9c7b8cd84f211f0854c6c697b9fb1b2aa2a45d1e4855216ca166efed930cf14a38243b98a62db521cae244a18bd291aedfc71efec1a71ad0eeeedc13ea1b531e5cf5485ed287f6653b0de9d7ff67c2a6cfb6f7976c870a7aec3518433dea5dcf12632f3da8d43ad91d65501e24e24645c75882a8a9c3eaa9dcfcb8a4292727914f972ab891631e41bc59fea1cd0c13c73680dc5fae926acb74cbb114b456871587ec5368bd5a152e03085d875b920d820dcf5460492b66110fc770d6955425c87d25dd369542e9010e49a0c7b539f5510889a25989ad0d7ecebf0405e22726d39d1dd830f57f63bec57350a6e4e0c9d76749a9bd695861c9a880dc53f8427aa63e7e540198901fecce78c7713296471a03675da85d4a8b44d002d09422a90a3888bfd47ee076765073da583882147a8830d5a6e8600987f5f3de7b3dd047c4f05004ae4330f6a378370191b61bff7b1b3be34133f0790511990371f7e768348fa98a4a01d8ffc8438e4b2f1a835b23f6fad1e214cf2e79f2122b56280139fb3beb52184bce23e1ba015f1cf42d8e73ae31f0c47fd7f559962f47ec32c731e7df6c2437dd4980bff8b160d3fe592254a4c4a2d22a62921b3606b21290ae89dd08040124d0c6617b5fd96db779c89b47cb7e592616e9ee04ecf24272b6388b67ac9408615fde41c1a6720abd0d6092c10d26365d9d97b46e4c1272e613f3bdaf476fba93cbb7d1c0f87574ae0bdec61e86f17fd07ba91dfcf616cb9c8e28e5f805c17a96326404da6961764ece0291c3827a91485e9ac81057790fec288a88ff3753353f3294235cad600c5f7a07ddcb3ef4a4df3f5251de249b339ebe1ccfc0348abeca39acc14fe4a948d91b37b898e1664d5052d48d5bad419f25e5aaf737251990c247e495e823c47e468f0cae2ac70d1fd0981b9559a7fe4ecd73724fbe543f52b12417dfc4d9d4e8b2e6e7b0900a1ce6329a0e2ec33a9cc32b82a66aaf099ddc23858bd4047ff9941caa6676613e82c7d5771c872a4d42e2066ea2806459ba8c836a67b7892a535c8c8b022a650030832538a76745147b770e6c44c7e72268854cee0dca53fb4fb8cf7d25c812783d15f938840b377232fb7849440d1ee59d6a692e4e9d4d83f3114f21ab7ea06c5ad87becf8232ce6b39b6680f51a7a525a4e686e306acb0eddda5d5ff34816a2b1b750e500ab97a07b590277ebdfaa9059dd94a0c2d67b9f053583a50dbd45dff49ce3d494c50324df9bf63784877c41b48384a666670b93fbbefc7bcc87339cda2c20de47edc149adf21e48523f41be0183aecd77465a0ec74578ac5c979db1f8f5e8f533e6be5886fd05e80dbb6f0983bdfe8a1c0c30e50b4db9fda2abdad908d2a83190f018f0ead08e4ebd4a19ba4826a2b07b52a773ff92481b622c6e8bb850b729b8aec35584af16dc385529097e8c36512926b48dff9888319fde1d2aea8f651c6c5c7fabd56f76b775735fd348b2bdf70e5d2489ac3442e64d90d0237927c9832e8bcdb394f1f7a060b17b743f505f0a99e5554e2bd12bc3e53a6b45b913a8120feb74de525438407f905d626f873d9fbdb1453979a684e33a9f88c98ad8c15cd1fbc998de128f43696e06ff39a404ee7228047ca8b44e78797ed3fb2c2aa2ca3346cc6ccd267f243e1664d1f253f143aa9c5805aafa997ac564fc6ca472e0ad52f112ea1b73271202694778948441386fb5b072044dd2fb514ed9b2ddf06bb6f4bf6911c76da46ec46d4f6e536895cb3d3b0350c29fd613844682ca970676dddb4368781d08b836277c4d7b8034b6ed3c23a8ec011009e9d8934f65d07ee50527c08d387000fe28372d48beed8828d217497d7b3db567fb4fabb15394ab8317647b6c06179c0ceef408b68b65a6bd03f0fafda5fa3b613f1fe3975034ac80eb67fd7ea19148c19c1c123b260dc02b1f70d1a90ed345785fa96c3cacf09ba99f0b02963614b58bdd01d3544f1ece73993726723360e0901f20f49a564f7321b51752f707c81ebc650917b877d2a8b3e3d2a886e0bf2b933a715574ba9a3ed92472ed3ca31f180d44cbffc02483a5aeaad2247bae957456f86da6333af3a0ef080992ad69093a04e59bfcee7bc6f63767981e03ecc6c43a7da9a7fc0d16e11aec27900a19e6e80a3ce922615cfe9ca3a4413ae9c8632176f8e7128173a2fa569e024fc7f6ccce87143a3712961f89e5656a11f462a173a4947192c73e5ff3f0570720c4a220bd00ab0cbf9fc5778933ebda07db12d9efd83ad66f21b14fdef6c625db42ccf6a771343278e8fdda3a39dfc6b8f1afff6d1ae9bece8359fe9c98d3c77d9f2362efcf392724aa93fe4b1c2eb1a7d46f69bf4494199d2b2ce6e09ae4e3910c0ea1b7afc7f95771ec9913981d05ba65e7443822974db50218f80c76cd755db65920853e2eca130190929ff1a70264a71d7e8392719b7f265b10216e38f5d56ac4ca42981435488df4e5ed3af324c8ee3f12f99d3bc1d1ad9782556751bbbf308e13019fea3ec9491635de229d61a43535796a379807710a79e4bd9e4b8df730be9d0e9de16e2cdb93582918ba93fea555f0a4bd38061a8e81a4dfb6104127e5753215443ee05d4b1a25e98a63c7923e9a51f8394f1ce0e27b8460d48d19708c5f233bd77f8b64d3496770d0f1dca42f141a639662ad6be3e514e4f65f1a0fe47ad58dbe185abbd0b80a78cb33de07bcb5124d49be88ff21932a4d1dd17edc559110735536ffa2812e7e65e1fcab9f911d2ec373579bdb68ae8129a2e35a937877ea56d685489a3d578213c132a5203d4338209c1df26827134911fff7c2fe81df914abe4f05976797acbde28214274be959b62c14c01fc616286a214b1223af772a865745c102b59dfc20e196a743febff0511868ef278b79d188212bd1faa046b1fdd6f8021bff93e49ff6cd57f78883362fe7d798fe598709d2ed58ed7389b6c07c7befcb5946f2196bb43bfafa83530a0762a3f6d9238ed53342ddf2d6ffb5c7dcbcae1da35338749b221f23a871cd91eed6654dbc7e115bbe59c665b26d4345bb6d10d15b0fb9f7100f492ed8f10e9cc7939f9b9a4c56f913de924ed8ac5416a83ae06013e0580dfb8af301b6e093bf6413341a6d110de53e25ff0bc9dc46fa2c5d903cd026915b1e7bb3ae75d8f82679b17edc14a5305b3740d396b42fdd6d3565a9d65b5d1077d220d05ddba1d68e7114f13f24996b82bd909a08a7e2cf4e4b15c1526489c2005dbc38dec47b52bfeafc4fcc713ab8f56deae1eb2132b0f21c4499839f26f5b791ea6612d88db84d8488dce8f0a76f132ba0dab00782363cef3d081db8cc2c3d01ee7325834596fdde93c833c70c195e3d5ad6efd37214d9119551d127042cb7f06ae3361d9a013fed8c64e82a06b6df98d36eb8bd9fc1ca906c573c78e97e6613489c14597558c6e88992a847a2dd9368d49d26d38ac7bb8db02a834479a16dc46424a6b77a39e34df63d2f88a30ca9153c04ce515349d3803efaf111eb3a5dee0b9260318fba5be67e25165355917cd0a05edb84cd1a975b28ddd1d08c5252bb53ec6c14ea04c1b688f2f9f3f8e79d66c39e84be8a8a03b5fb5db217aa98ab05ccdbb7996ad1aa65109d92f30a0994d9ba16c4b3aa4e861b54fd62008c8b4242068bf93708b562d379c27af5cfeb18fd9b24ad8b5e6b450ef3372ff400196051fb27ccdf5ef09511eba15caae6e066f785ca842ed3445f61ae3aa176f0595160baf2150025f566514758a76f2d573cdee136586bea24259fa5b0a1cccb0895d923b75fa8c6bab98046223bbbf3d13942a80fe539bd9d3f899c6a22988380f45c76b12ddf6ccdca20272e25dd569d12d6a91bc5dc9b408f72e86118b9c2062b0fd1c6bd1464ef0304a1d5ddf01e25650454f2351ec852643e83ab793ecda0ed815d8901625cbc3628523f6a101b1f0b9f4d786e4ce3b924b7a6b10669407f32a466fd93facd3971d55c0cdfcbfdcf944474596307328d8b1141ecbfbd6b12a7d8f9391d452e388a8951d627131d0933b68ed076fa4dfee2c4578c26a8e59db3b61449894b640b760c0063d1192d768c172f5357e3d47957287333145b5ec1821f40763ad68934e29a86dc4c1a677968f5de739583e8e747aba3fa6e47b40c679da52e2f7850bd331b3263c74378851f8d4e0b8e878b92305aaae1162df3330cafdd04c34d9852e4d1c550ac50969db75bd2e18b8ee8c572548c54b694c3b8068d801596a570dac7fba9f09bacd7b9dd53f33c044e74af2a2815844de65326c5286bba84482919b50655ff053c7eff72f47c91631b7b642a74a01fbe21370a62916d7a6ef5b057c697c7f8501039869a8ab14fea2f6b1a037f2b1d265939b9bd70042cc96d9bbdb17c0c7c785b6dfb25bb7e1199ce65d70951a13db0c2ed3c6d3760a3c957ac26c17a87f86e5e9fb5b60b573875f1a389a4a0ccb451d3a37c8a3c17813c6da2d2ae5f687162c98b4afaa47644e76c2e527723ed8a34fc24deacedda4d26c5d9b5905a94a246b8824ed80f562e06cb007805ae074f800a991c715094ce4327aca82c83581ef5cb8e2bd1b3ef3395eef5c4f7711c98678f1928e6b9418b99af104e660a6b97325d68e8afc7ab9d35a789d1c393ac6f6bb0a58e640a5780a42cf9369800e542bf3eb591deff59c77ab20b1918dd5956d80deed939e547cce19a9f81c05ccc9c145b2e60f315c9f6bcb1c7a9b421cb03199fbb74998fc69f1653d2d0783d08adba0af0488f36356633806a4d62122e51d8ef44c7ff4bd23e874736c13e06b8d0ff132bfc77db876592f797e6c89355ae1d4f427c4600e200c09971c515273124fb89c24b838de5fd5cb3330e5047343abeccb3ed7f242d8fe9689fa82a7ae0f06344ab843fe04ec88cc64393216a6dd44e6b59e57b65d53e336fab36236bb9a77c005964ee3350760035b6eac389d3d3fbc6791405bdb3ea69492409217c3db2b64e0a76eab0949153525a5e33e81573dc1d167bcdd5a85bb87dacf9075f64860e03bb9318ff9f582a8619b9f7f19de9fae81f7447cd73ecdb5ab056d951ff2dd0a48b270c27005f064f148bd7d21ce7fa75c4d66f2198d4c346f2d8324ef86b3162162a0a3d6a2366b984422da7b746221de54bd81ce746ec54deea021872cee48adc44466539ef0b8e9e2b84ee5ff9b140f195a5405dcd784c9963df24bd7d28ffd663c4d7140a6014590d24469f139e7ec1570e1c9b816e3f93eda3868c1228f7ab74da3b4eb202f27aa6343d6e591902887f65a1e815452596761622809e387d1da738a427ac07fc55b4d5f0b4abc588306facfc61422dc6384e7bd47344cbba05ee319c7e0d3e1f899a209af2232d195d915b047bad4b4b9ec2e919701123f6f5612e81579ce7972d14755ca87db8c5c6c95a3546d6c2143290a2e9391dff6afcabdca291d16df66ed7ca84c5ca9b3098b9eac3d21d42cc3570dca78e625f474a5e6ee40f6bacc9cb1793072883cca18fe76313235cd43f05f6071ad4eef706f286f2fd5d32d11ea70249ab9ee8919d2d9379cef2f6f6b92646f21a9239379f05299a0f101bfe4d2f2072925b409421881d3d582d43734ef42117f33b59bc0c7a5ff5879ab4ab9dfc0e7b1e20adfd4622d775b4da79483c0f32cbb55603b66bbc0d43df9c59a14e704ddc72da425e241989734f102aaadfa27059112789b6294f99459621c42f3b4a987cd9247a487eb87c9b508f1a6ed3bba4893a74fce513e4ad21acaf5e014f70626156fd5874647a961fcaec244279b35bab569648f1113e1eada0e8b129256ba72c1cb87a263aafa7c6ad73d6d61d45d1d47b12d1ed880591843fd72181118c80eed3b7c0bc55f8b9aab9f8c447045ddc08167f25ed5e79ec259fd2bd6e2d8709f2bdb5143dd0836c782c165fe227c2df77d5d517a05c16f1c6cb9b60590be24c54f4679086efe9b16e86ebce845a696413bd363a8415498dd45f8a21441ada0c367be810b9384bf097a98514f251ad145349e8dcf02d8d6b4a2e8f3ae685a2e6e5835547b8a94fb43bb31928df86f17d3f6d6ca93f75c23f92f95890b6e6597395ba3ab7b6541d30feb1ff855392754b3af1a8176f086e79d2ac46e4b64ad511dc366648c12b608157f21fc106c6d49966e2dba32faa521f2f924fe7e11dd3103d2c496ee2f4f147006570e8bba9512bc1297cab5c1aef8ec866628c56814f507dac8642892aaee1d90f6afb1d9aed0a460abf4df0a0961bff4f30f7cd0559d408b14c7c09c6a74798e2b0f332b475dbd08c78476fa5048ef8388c9e5f84bce6279c03cc907575891d513713e0ad41c8119af0d1f43a005464999325b1c5e071a5655916305490bbdf7472f5dc26e4f8cb9369efe798f268f1990dced1088fa494e3352211c77d06c75c0454ff9bf90b4818497d6b601d0302dccc78cb80cb95a419aea6584558b965fd1ef380607338f0d466540730ab247deaf3ab6bdd981960389959450ed2a294d960c6bcae9a481f4c3a2c66d507438c806ce6e3d0df78ea67b26bb7140ec2d430912681b65855dca6e7162399e6a3667ad66e008fac9ae69585af644b39aa4b61f14f2b51ac3a79618a586098688978081637984b26347725e892034f2f631524c7aebf5d80161f9f27ad8b693ec745ca274804e806d16f3bb5b36189f20536e45c0b5f7b1a89d5a87a2fe2e69ed4b46412d65df84d2180f662239b01fc32080108a066e0fa484c918ee2d417acba0d3534d304c69df6d8edd0588d5c10f67907c75384512a5c0724d420bf32f05a2ee3bdd7e52fcd8e5186454cc832f2c5131102d7d93559ea449aa2e6a0d4105881fbae76f9f32c514b92085708f2c4f607e9b1b8dcd3acd075efbc40f654ff7375780ac7676308b14e827ee92b6d8c3860b36123163772724c77ec9234bd824b0febe876e22d0ef8c2b123e1ce708ea2542652e03831df1f20c58ca25972def0f1e0bdf5b77c7ccf581af5963ddec9923c930a6eb9eefd35cf05d9f010f03dd3f939cb6f5454b0b9ff1e39ceda59e736d02b458d0bd34b4b60ce5ab9b841aea74dc9c17b6e4f67272915b7a095f1e2292a8b9b6130032fa3fbda11a3ddbf7a8ec767d3f3fb43ef0f097a41866af8513560d774f7cfbc40c57b8fde987bc47782e9e0ca6dc55e593d62eb97a4b2014b6888dc0ba1b5929d16872073e575ab0f4dda93e52fc2f13bc0521fee1a6b128340a023eac3e9312f2148b69cdab5d79dd6cf4816c4d52e89c61590e85650af03b92fea4f30240a33eb6eb96c9d1f612e1afe5003ebd8003bd262dc4a4cf7b1d5b4373937d55569fa37c7cef04ea66de24e495cacf05a48f07bdce02a478df1e937bb50a83bb57fda28e8053ac30686926e86709ccb246bbd4978fb47b8f277dcfd5d368407baf0270f236c7d912dd956e8002ae050368a31c8095fa02dfeb16fe5a9fd558fa372e82d3bd35c4f0ed3572b6f64e1190e2129ecbe978e798cae80748cb1b1a658e79d9d510a398295dce30b69f8c5dc4c92cedf18de62e15a97f089c807aa2a54236d22d5e9268ebd1fe7cc77797d8d2db0097e8b435fca8d3f483bc98f5e210057ad66b431b53f2c2f7c6cbe2f959e8d9b1d3b573637ff235623663cef5e921d2fa0ccb532b3e296df9496dc8d601b6135260dad664130bf7ed40d5014855c75e8c90f24dc72740d47fdb36e82cafeb736156057417f4d06db9afd190b20002ab2c8cb1e3ea85dc48e05167b9255d46a5bb9243738ed2b80e441e93b3bb7be30da16c1ea6a66306a62d85530ccbbe9ea4724a6a6775c3cd80252ca5aa3ddddf021d289619e06c6cbdc06e09b5dd44925af7eda44db9452093960b64ac895ec50651246b127e451ec39e48fab165eaccd8f57c5730d523c16a201db32e39ece136971a2de03625522390e47f3b9434f9e7111f60007f0eca737a23636fd5a62647cc7c30e933a75fd2aedb8bcc22a70884b42ba3804d6ccebd94b2e3082fc65f90e3b009b7855fdd3d89d78adc5cc791b8c31086b3449f8b80bf8f47f6e15b12398fbc8d5c6204f63a11f06baee241d0e07ffc78973ebc62bd6b62fee660564bdf7f92820f95ef2dde2d86e79614975d4a27da1a601d63a139156bddced82787350dcb4237da9a0a31b489f76dc18f8fbbb6180b21914c7830fe3c9dbf35642c9e295ac8c64792e08331173e1c4f0cf1e1a42426860bb25bc4d8a689ea427f54bdb59c53fc3598e8cb2b2926edb4a19089f86f9d21b2b8d2779096e26e0b11c895ca33c2f4d32bf0463a7ee7f246e120a3a7508e73cc3d84997393d58d5f1196d31d0f2549f7c820d0214506261d1dc0deaa5668e44420dc73f8712b55a8bdcb9d0a395a1df7ea383a5ac509a9ce74c88849a517fe84ede5c8fcf6b4ad5b508315d3893947be8d042f121c2ba70ca709794f996a46b74fae10c99f9652d9a206b2f29c8729d826ea5cb551a0c0fc2de5ff5235163539354146a2fdb6ca7511eb8bb17c41ce06d559b44260cc3bd075546c3974d05d35cb7c47c67717285b387ae38abbd6511eff0fd1ddc922b907203bf7c47ddbc577000636a9de6f3e42f7c664eac3dab59d13cd1013a5f741d90d9143f3272db0d9664b9ce3a2ff0094748ba876c706ae57c465c5d8a9e3cd0d5dd3ab4576ee092e170be39fd290d5ed8724007da367e26f731c6e8b6ac168e72a843b93adcdd88b767cb7bb8f8d9975a874a4de360a7d61f400f95c8c167214017411117d3f27c57d3ad65ea5aab7d63071cc30e1200739f880dd92f1dcc36fc034e263b65494331ba0bcadad4458fee9933363e9403b62ff9b6429756c4ed64d35c5b573f411ab592a1d38a6ce9e9d60a86902ad312fd47863fcd0f2de3eb8a4f93353c4c734c5daaf904fcc5b5b41de92e9dcb8ffbb936b0a456adce158320b0c6f4ea57bc6d6df14f535902438f7170e1408998d2febe6925ec2f0e1f8549e3bb7e14e7617b2c2ac576d88e3f43269c716538bb5c2bfd724ed68501a5d887b3dc8da643f13f3f55ecf0de3f7aef6436187914fadde5d94e9a1c77e0e38a8b7ac545de2e3fb257533b79ecf053f28f19b919e83f2fdf0389ade862ff165d158e5eb1fa329be62383cd98f4d9b01079ca4862ea872a8bee5880feff3b41f629d102064bf9eed3f2e8fa677955b9f600f9c1a87b57ff248d8cb628331863a7537e0b46fb07e0d1513246dfe4508ce3187009c358b7b0af1798eca17a123ce2aec46296415a6b24efc7b816c2a59699543ee2a6cbf0adb9f4fe6506a71c577d5040fbc266f578e5e2fa926e9bec5b844e7575521e81557c4755584d08b1f812e50acf0f90fb92af088ac765643bdc115e0d2f4b0099c92fdc05c7340343abd61bce670c228c4935818e5a8bb75350122121c92054db0e7f894610263cc621a364439ea40052323b030efb24d8990832450c29beb1b44c029fa71a65a0fdd1f937bbf640424317282288c4d06b76280ae8e44548842c139afa4df32d5c1b8e9b90d933edffcb8bc54c7f900a6308e76bb52fd00f0fb6964bf6ca0069e86a3f44b716ebfe747e9b7e0aa38817d2c2cfba2a12f67b2fb5bacc2be2f4d9494c561171704265165e199512f13bdab942dec4fec11040ce4d9fb97592711b3b38065c3b62d3653e632b5eb8b1c9544df303f7c98d25f5274428347d79a54a90f85f652feacfbabf0049f9d9531c1e80a34c3837083e95fb0b4061fdbc8f285e84bc5cf77fc923c1706016452079979b72b0caf6b0b1f22a72d13e533e70ecd046a388e8883f583a50d9f56e1251d933c4f587e309c9c1ac20ee2d7e2e5479ead4b21792e41b593f5fc2182e35e0f71bcaa83c50e43459379e1efd0a3bebd3a59540afd466ab9a09c0c6aa08055558bb16025f38b218d53938908283ff40c21a72b8f0ae36e7220a3801357dbd0b781eecf0a4b2f8eb5778688339048d10e9c80ec9780c592e963843442254749ac4d2b5f30e1c969d727c8166fcfde8646f8af5e645695ffe4438490a5cfe7e3ed185e6ccb52512ed58db83f92012280c447c3a7020669609023be58debc444e7fcb3d6ef567ad8dede8d5baff76b85a3b2e4d79206e596bf24af4bc564dbd5e1b46cc70aa881394fff8f0d027f8c7c035caf34101561017bdae0975815b58e9b6770ad3cebef52c3dc87b5c3443e443f2454b4b46b3258eaac027e6b2672e94891817629ca3382b2cea8123cc5bab96fad4f6ee776ee4b2462eece0fc890f8c24fdbd2b9559ee12993ae35b334a2c0857657e3d2584a9f6b122c39ffa110991d6c83e1c91a299c8d887bd518499f12b3137440b8877314ebc15d5287d9cff40425962494ba7744737069851271f341ab3e4ded3b78cd018cd22b6bd30c01b4fc000c036adc818aa7c5c34889a6cb0300859dcdef86928058d045797cc74f558356351bd1aba31c5d55b14966f9d87107c0cf89a82dd780d05473ad78561fb8c785f18ba026bb4a0d6e7360297f671b23b0cbe6233fecb347d4cb9e2a7d51073f101fa0f0a8f71182053d94670409ec08b27b212770036e765c6b78ddd745c692482400ba7784b358b399a63bf992c040868f186c1d1df66696f39d09ab10f98da4feaa8d0425d9635f39f2fa925c4ba9eb510dfda3252daecd63cbcf0d9f03f5ac019493658bcdbd5bcf49f64d24086f7868fee67197c9a78831ad57da7292083b80b0e8e5a760973316823624d8281452ace72d84492681a44ebfb2c1030f37e1e1e46d7951f571f24c734f15302ceff9cfd76f6cfe76a3f2a89e420bd3015331ad8bd0140fa7159e5160be6681826a863506facd111c90ac71d54f804e68199cdaff7b7f46b2036bf1dbc20a97f8bdc568d932bb5f72692fbadd2110e6bc78d6eb1b5849690b2cbc1f0d3671e650a3122a45e5c599ca1acbcc1300114e9d13f6a3d6ac6793f51ed22f8171edb608c9297897a37855bc728d39b22d5601102825a85bbb74ea402a71f955e4e6638dfc217f92855f22fb63d9d7cdd6f35414cf9a956a2a178e38cf4ad69e6c490de11907f50a65b5d7b211be6895047dfd72ea8763ad530d8c7efce2ccd86d8013cd439fff66de9b47e91cc9b8c84e9476fb70baec71a458aea1f44294cc7b29f6093eb8efe6cc068811725396cf0985b98a9fd4a4af19edc61c0b2b01ddf885039254ad9e05c1bad073b99f8a70bc30301ced22d9aee71c96376f8c02235eb46290fd0178a4683fa13279346a28d5c7b3fa77f6e63623e4e7fa6881269bb32f010b439be5e9d8c32acce36746b8ac7c1394dd213cd10217c1a736f4c41891b5a38446b7f70ae48313f93fdae5480122540b24ad916ff62d1c31313b01c82cfb12059263606b982c0de15eca705bcf921b072981549f4c178ddbb36eb77ac1171cc4578951c6e219174f7b936d9e2098465f9adcae21128c6ca1d8932df8d48fa2ffede17f2cdf4bea3d45d16f9d781fdc2faf702c54b22c520aa561bc0128a5769966c4e4a7ef3e59143a1c0ef8b7c47e6e460c37ee8e2c7b0b57d95b7b75e980e1392dd306c67cf7b1c8f7c5eac1ff2b6736331303646cc6e58c5b20cc0b612293ceea516e136298e5f7cd5011065942a124d6234eed60c388dd27569cd1e80ca4d7741d24b0a1a25741d3d57dd72196831bb30dc8447a137e5349f66407114c982e8f28a54a325981ab7cf2a82fd16804b2dec8b5f489a3c484318032daf1b719d5b4e7201b2343a740c20bb60da1e1ce6f66b5ffdf3231fac8db88dd86c489924764294a1dd6580a71ad19af11ca69c986d8effe906097abcb9c41287ce7bf09ede62e62a0e4c60714411db8c44a62f510d522f2cb4bc98b01f67492e58d6edc20853171735186933ac8a2fb751ee45132f267bc51f0b9a179354228b5252fcdd8917e11d70d51e2483cb43e2651f10bc6932b261c345e443e72f9f0c3fd337850807e9ea9809823dbc8967017b4373ef8303744e84e4f755b94008f206810a082c708b87ab16519697fe15f2637553ab4a2dc21f3e6db7b181c8337eb86217ca2b06c0696ab8afe64b57a37de48dd4c257d689cb44b88ec6527881483caa45b3481abbb9a76175ec309acdcc6b6745788fd60a01ec960baacd2bd34f653c06e3265d4e7efe8db5f4c1c20a71c77a061423f46afa73c5f00547d90f77bee2e620ad3ddaa8fd56e2520ce8fe25a2f2d0f5edefa311197bac0515a241d16f24c6edbfa1c2d3fd4434bf43390d08fc357de59ee6273caad040da34a340c243f28e1487b1238d6e1fc9ef874a3e4d2d10a2bbfb1eeda1d54c0bf09413e5564117658ee51449b55e104b6d9a781db63776af9ec503a1aff04cf7931db692cdb326efd3bddd5c495846632151279fe6b6faff56f560d07d2d8e7729d6bac048b1a7b6a83c47a45a1e2241461b44c4c99740504d68edb1457828a98c4010b91faf2247fd37387ad89d2c91d74b0d24db760b3310736a88e236119a080a6ba515f155d3deedfbdcc1ee2554c2435e80f37a2f4b3ab9096ce8b93dd0bbc7f57f4e2be1dbca44e70df8c3ebecc284f5c4305d10a7969a00cc9703806215c07db47df66aae01b7637e7c5e8d35c093f0bbd8b47d4ff6c0444485ded441c6ba1d9a43fe991e96390d79ee1192603b1c7ca9a17f05fcd7b921dbfc1896a3c2e1ebc2148ef812daf14e336a96d150640b31af776bca4de320fb379678d19d0c8f7b0ca243dcea94a11ef83a3054b2eadc22b7315963d4d612f4d1c14d92ff4e4e4ff0dd42158c5c309b4c745df488ccef0d798fe45eb71d8e5c72f97c0e26c3ad78fb69c97b50a34b38ef119805255c626d8abac5e8d9f69b04ede5823153a3d06c035330e72b321d1c97e179d49d1041eae3d5057213abe718356324ae3e0cd5b5ddd41b9552904b32061edc46db2724bac7a83afabf8a60fcf269ffe47d4fad13a2969d5314722970fe36645d4c4fbba0cc7b9a17f7e6c5fc4f2b9efe88ff5b45bb24743725f46b78f65d9dd0ae452e20c3d72f22774ea2bd141dd422736b00fc711553fca072b0e4f0894d8ca7e4f75ee2eddeeb3642bb44de7aa6746a1de2ea897ea53ca457adf113456acb781be223d6ddc487d15ef0af6388846ef71629e101365bef144f5b8f5b60ae5126d101c8f6c37c5e8e4d4bb0b059532ce497ded89acb66dcbeaae2a6b626b216e801876512ffbcfa26c63a685d5bcf84ec76280c239064de23effa6d7d9f81e6460393ec9ff3af48afc7f333b14002b16d1fa0ec28a3e4ac4678a36023af30631b6c6fb1721cd27111781a38af62147a9d0c21fd73d2a4b2a08d6c835d75a5171feadb7a09b4d782191a66542313688e0f45acff9a218e27d53fb102c5ae6a3704db156b72190787a5c047a003336d7017aba6b81942223304c8ded8759ed2fa825a1fad2a455951f2e0761cdd7e63813647a5d7cf7f5d03a67657d41975abd4728b36016c1ddf2c13c5ae670d419b77095b6226817bbff3ba0907def87801ff6f0f4f7ca152daa149b9ad4f17e3c09a9892de7634d95a4948e9f693173a08f5dc1c5396f507a98240d8f10433501b43a368169995e3b74a90e08a9ca26423d1007fd4e0c22ed9e3d98a892c9df5d77b1629172c360ef2104f7d6f3c2a872c10d164978ffa8017009c843404917b4ed58b9c0c36050999d2dd7d7fc3fd2143116ebe7ef5c6a69111371f28e2ee64a840fe7f68ab6295aaf6699bd281f1d90d4d0e570fb4165d1709a3a2ca33fad98f8e1a913d588488a74492446ef4a98db2e0426a63e1221be4e7d4a916378d95453424ec1b66a0c8afbe0c3854abb41885a961313e45242a444b614250b86c762ad4e8cc7efc97d8c7f7d8a589e70431829523308f063545e9fa60fd398b1f6305e3a1da2d44ceb51b238f1a37af35066d5b8e0d628923a9b033f93352dfcddb38ab4c9b18fc7f2a06d3c0ac44261b51d0346d4d711c9915993185cddb1c02b6ce070e0f4609bc13285c6b18aee27fc9cb699b8d6918a1c13ca961606fd1bd0a5e684c854fd005543130e2ad37f352ffa85b1f6cdd59acdb3e1c557ec24212e05e904f2e1b28bb0295a1e4e2b5ca54f2b40fbdef4376ba792cd26129b0e0a04f54eb445277c2aeafe27650009e91310b0bcd9aedcef65725730cf87130d06b63546d3c173f415fdbcc43457affefe06d4ea256323cefb0e7abac7a5367313fcd0aef18a54ed12419e1133e125e0be7e5c260ddda960327f3062b166b04d7a2ac80dad25d9fb6cb0782cb57c471f079d8f72163af1076b008d53d8ce11994ac51824adc598ac2931816afe9364ae8630bfd3e7e65bd2d4b81bab9aeb0b16ab2b3fef476dd71ea986c8ade92f0b7cd300d8c3f28a5224846a2896be78597dcddc0989e462cf39acd7d11963beec324ccafbf54ac2321c7333b25362fe0cc1a3b5c5210d5c6aee81d2d360b5635fa63e8af4cbd198c27702cae97af90112b38cdb557545fa97ca97d428d5e3f458a2b0b7ff018a6b07ed08dd5c7e710c9bd9f99323ce6942c2bdf3807c63794958363c3750d0a779fb9d3c8f096f1c958e55dc2cee38d6ad056a578640956ad5d2bfec747bd0c98b8c6dc050017fcdd44d9923d02ae18552265ec4eae73e781f3e27737b6e06b23b9e4d7b54884e180533c814b939820da139b6d2fc594fec2368aad6e9c53c6dc4e6cbc17b253ee9201ed34de5f877af35de118592b17c56890f99130e296fd7d232979822fd55cdf180dc4d38bf65317523de7f1c8977bb9a1ec6076f963f4ff0fbb17fbd0e3209f22146aa242a8c3005aac8709be6b637f4b275eba164d39d2dc8e2588f9c7dc8a0245a75b82536fac2bc8023b579d637824c4e72c31d611a6a54488627cf2d2cc291d3051628ed38c9fd1e079302aba8c58908b9d743aeb5a1b40f65c054132b5b4d276787498c26f2b3f2ec5c88c39cf6aeebd23fd64b089bd16ddd6b288bfd3fb1178859b81085ae8431b7cc2fa4126120824656d84e128aad1ed63fbc15411ea7c2fe2d318181a4081e19d884ecf40262322e73a80d21a8bcda0e4a89b907c17a3327afe6f90c90f1bbdead0e8f3037bc31d0d36dcefb3e6caaca954ddff299f55d3d46cc2b85e6d8ad6e2b60ef5424d6a28702f6fb189ac12ec19b01fd72fe706f6730804e38e47dabe90a22a2bf0c4310e79ab3f7c16a95bc6aa466657ab35a6fc80b3a987156c94588d3d02eed23ca640175004090c0c48122cc10f6596164aff101c944dfc742597bc40db541fb983e74eba808bb5401451da7f20593ca9368c99affcb9c80dd2b06949d791d25ebbbc6ba1672f8d0c9b16721ae1e84ecdd8c3467f224a965a547c663204d6bb31db8cd10d0d159b658babb2037f725c3f5862464eadab29aa2a63db98cfc636df87c26082ec950ccd8753d2b8d78106564e7fed9f60a8d9cad6154845907d0bf6b394b0bdb17eee56326fa5a18d14133e6f81603131503e6d7ebb3fdfe9643ed87432fa2a2fbeb9d88e59fd73e8823dfbdf587f92299c689f216d050f930c78f50025dc915f834e0aee39bcfcefdb0614120a4d5f325981cf7804279bdb3a4251b0a6d5d7713ff86167d4f691d11a9fe07927394285aa514b95a5ff77e5db24f2757b5ad68f810a8c4c0ca41dd6650561e9c2e32145b599dfe0df66c743400bbb50ce454117214cc804b24e89c8e20d8c794b5c049a8a457fdf158abe734c48921faa97701cf3129f33d0ca788076e651900abc966c01b9aa5f64360d50017adcde95de08590086af1691aae18b7fcd3e471976b37fc399a74e5baedda74e7cc1c460ef5ad455d8e3adf1d1494227c4a849ec2525619a33cd6fff032054a974713c98d1a21e7e1bb6844ad39aa5828ab5536bbc225dbc4fc7f3612ac005ce39157f56d9ddcfb50eeadd2b463c311deb01c1fff0ff8c568ccef261dcafde7094075bc12982411c8ecd5d79f0c84fe9a8480b7e960dad43dcde3515f84adba94af21704b3e8bd5648f1ddba31122c7136cc452dda41ad521b149d3ea63e4f6ddb18679a34895e1032a5f2a55b3d4cdba35908a85e706686c8df21b7fcc134485aa581bab5b3adaa08d02356e0b50d34e6bfe0a7d8949252018e5b614e6153f918feec81be0c7f118cc1963bd1375f209d637530c8fd9a4995626079f94f16762aab84f7d8501c8a5aa15eb00f54c01c4a90d32593013594749942ae2b85db168f54998c07ec0c3e5726beb299c932fb8a64740d57e37697d90325cc8bc073b109f469227b97aeace1c5d248b176930d579d7594d9caf01dccd3c97e5b2f0891565976569e594ed04c2feb0d35da7b990ce925730347b5ef2a717dc6aa75daee9e81c463b848e1587793f89f012f27529081dcb25e0e77c63971c537b2e51c45f732f3f72ab89acf352459c27bd7753cd4665f1f914adc8f9607e0311738a09bad64ac507769fc38728a5a91f405c5dbd1c2729609377ddd5319f3e1bbe4a98091f091918c215ec4f01da3202a22a582c7158850d390a3ed04b9bf48b5eb4270c7233d2b02271097a1ec51ce6b5208b6dc65fcb069c05d40314be73b5be2d422eb4b5253d601330d66856d6bc1455fa6fd1c7ddf9a588391cfe4882cbbec9f1fdf9fb9ce2ff3d5ef905094df9bf21e3f06bf191069367c19ea240ae76f85869882379d4b34db300f1a60bc735e274dc9ede7094bbea83b092eb7f3c57ade755288992b3875cf901075d2f053e616dfb4833b3eb1fe15b19388b32606601e3a076601441420c7b71b8d99a18dd934264eb65ff02d4fa29bc339fe673a41aedbc20b87bef7a91302362b1acaf61e33c3cfb84e1e1dd4c6682a970cc0772af9780c54841c48abef611ee548cdc962697a10f3d9700cd739c8821f57b1cad05449fb01f39b98cf3438a6d9fc06212ac687dee19f2d12e623c9b0905a002dd67dcd1a717d35ff7ff3d5f50f08683f19027ddc81963ad5f304f62cb93d07b0531f79b7b40e3c635a4f6917589826c69a5b2bcfe08bed5f030f15f75ca645831b51cd15216ba61a2b6060c35e4313c8b830789db2c99d40b3074d21a3e5619c7449f2c31040a178ac5f1527a13c99f234ff7c2efd777a7a9911d77342d4af33629cbd16443e703247baaf1c26b0d6ab7693c33d901c8d76546fc7267032072f5ae9f4fca1b2d515550780adab09f87af004a8095b2364512e2f1923903f23087f6977c174d62b56d12802642947c96b521a4a941e956cb7c2b8e1741d1d991150aaca782b6229efeb8c03c19b23e88e133f37a42100956e7c6979330a205b9bbe3e150c5d873063e1dfb50d924f63cf143ef0c062fd80b1dac9a2b2ca64dc5b9374e8df22024c18b517c1b0d95cb7e7ecac0e8cbf1d47e7be61efe827bc2b9eb9654ac39d720a1efb9cbea89375ae196ebbc4755e016522475cb3a832e5b1fba6fcc1428d01ed8201fc55b0ab6f2d1d727803f5b52122317731f31733864254f3920727b9d2c80b0b2f9682de9c3aaaee91bdd36d6ead71501e8e2144457e0bc7902ddfa948e5d87f3a8a129dd54ba7003ba5991eb61a08f65929284cf4e9c146952191803ecc076ccb92c38552316183859390c32e7719b7fe25efaebd4d2896340873123f64f317c41c1d80f455b0ef1319a0c21c37e1b63536db48c5fa587532f9f4f71c66cbb68590914fca1cd6c7202bc3f1c08c25868c7fe61a651af5b7cca65facad89c7f7cc54fce3422c79787b756cfa3a071b3d834a91413ebf205bb97cb127e088ddc5c5ecb8f2ddda446cbdbada0b012ed7659de9dce15d15c67bbebb99fab1a0c1a53ef89f31c3f6a90b72fba3641c18c2f08d4d8b985cf517f913fc99060c849bd1caaac2de53f33e8203e833c101032bfc06a6e5e229b617fb11e6626f978f979a50f019dcf0869ea3514198441a72ec326bf5e9a5015033cbc1809ce113e52503339d88513488a704254858cd2aca6b4919295cc4fbf05282ee22ada0ba3321cb158d5a79f7a9e62225512accf351dcf15a12dee1e43ab5b68f53eb2a4cbf7fd79f413162470bd07d322a28265bc0072a33595a3d0bacec3dd0f439807047c35d36f68b000533aba0bd8fec499d43e752d488314e9fa61d59770ac9cf54ab4b913ab3705df26e274a2da809895b2797cc0c7232d62d22ac1daccbdf16ec623da58ee0a6e8fc75299a1c694623952e3ba0ff743ace4d1e25cef8491b5254b332d234a428ef25316c6e0cf0f128a05f6588b3248619868d4ae1ffa3a7ecfabd8fda06abd78347c738315f201d7c1d34b634f3d155a96e6b56c5f961115f2d6cc327eb6069d2ff00d60b4b3d80b8c86f13e01324f7fb932e0cbcd683a4840fa0f448e131bb29926138dc31710acf1cd907630318293c270abd90291f34a47ace5a222d6b03706c03652750bffe749e20c20b855dfa6aa8775a048224019225fd014a9604b58f42fd807db101fe86d92593a80c18d6087d024d81aa06c6aae9a9458ad5094d4f8d92b5e93b880f7b191177cac3b1a00ffb6969c2cbffd552837b16e9454297f99f14f6fe8ab3bae7c016758f446c0a005db03336b4779540931cc22909a94476c77eb1bab3943fbacbf24f2c42dc5699a78e7619f73682c300fc2101eb180f1b8921a221679509fb5266e56404e3ad32b38ad434a7aeb06163fcb3a82ac4e22bef96ba9b40450c418e89832f6a84fa4618e5931462b7c48caddcda39045103d3812afb175b12a6fe7fc97cccc15f259d53e1a55a98d3a5d6738e2984d01d63e8a2402137248f97b2cce2f673662e9b94ff87b66a812d441f4146fb58b68e3009fe533bc29abed5033ef3a3de018436b192750ae85de5355eaef66eee5091fedd02ee309a768ccbf403960fa1c4ce60ef4e8d4cc0012d7e7f278ff0802789e22148be40f1882a96684259dd8588e0070621b8c759619cb3032687f49ddb2d3766d83f73358eab5c9844f8e345a2102b9a5da26a6ddacd48ffb97692645f8b394d5c6c97d70b3ad77b1a540c1e798b78b98fb020c3a198e9a19c3bf76c876098743dba1ffb9289179faf58046a1880d958b33f05c0d85fc30f071bcf34f03ca9054c3cadbdbfece9ee7a75bb1c08789caa7ea5a71024eb037a6ab7b25820d8954d07f11bbd2bd9238a131175632351d7cf1dcfcafde6b716bb93b95090f5c4c59e3d0ebfbede29ef83675aecb9787f700479e659bc89b300e59dcd7c2d922655956ce15e8c4011e05144c86f7bcbbda5dc52ca2465db0b290b640a43b7dbed06430f0c484eb4265a138d46a3214149790176f402ece805d80bb017602fc05e109a69db0b41b617826c369b8de9052328d9926c492693c98c9ea8d4bc8a6a5e4535af9a57cdabe65503a464a556e353abf1a9d56a35a59a22291762492ec4925c88b9107321e6428ca809cbcd85a19b0b43b7dbede6428f0b485a684db4261a8d464312a1b88830f148848947224c84893011260a893355681383429b1814da425b680b6d219368e42594854ba12c5c0a65a12c9485b2d0287c0213bec2a2f0151685aff015bec25708142a597d2df4f95ae8f3b5af7ded6baf141689f9d8277dec933ef6b18f7dec89be890ccded87686e3f4473a3b9d1dc686edff348666868344d34349a261a1a0d8d864643a341a281424303a339a239a281d1c0686034301a219ad9cfd86882666c344133b619db8c6dc636c34463249c91cd2ccdc86696666433b219d98c6cc668e68938f39a299a79cd14cdbc665e33af99d70cd08c1217646a333e32b5191f999a4c4da6265393519a2952231393499289c924c9c46462323199980c914c9317626462646262626264646088898989898989898989892126262626262626262686b58a59c5ac56abd5ca1663a4b592ad9656b2d5d24ab692ad642bd9ca68f524c6eab52a5abd5645abd7eab57aad5e2ba095121930b5950f4c6de5035383a9c1d4606a304aab22363031982498184c124c0c2606138389c110c134b979b9c10cbddc60865e6e2fb797dbcb0da60706c98c17da4bd30beda5e985f6427ba1bdd05e905ea0e0bcc05e8e5e602f472fb017d80bec05f622f432cb51d95e8254b69720954d6553d9543615d38b11195432d5924aa65a52c95432954c255319a99ed050bd8a54af22d54bf552bd542f1590925d3fd3f86400e9e72489b5fcc0889ef5718a883e1cd040cf9fb144062259819ef56f8e8c8e08aa819e6f33994cda11af2de8f932929058ae90a4e7c7705253b922067ab696944e4bd842cf677161d342c8819ef563984d9329cb7e6ca06198513c1a5ca1e7bfe0d37312fad1b3e6e77512aae9f92e04011d79819ee2119811403f56d0b37e3824a4b2859f26a15dff93c48e28e9495344d461e1070a7ad69f5922036d2f3d5fe6c80835050e74fd182634962044d1b3fe2a0989250848f4ac0fe3a476832348d0b3fecb9292bec14f107abe8a0bdb9127b44b13938ad00f96b57814bf2da104cde2d373e44ea167d74ffdbc4e0004859e2b41403050bcd0b3beca115815437ad6470d09ad6c39fb3142157ad6d749622a1c04e9f92945443a06457a9e96c87e8e7042cffae091d18f104730daf53f26b4535317494860164048bbbee7a486ada8829edd92524ee28272416d1f4d48cffab78909e40115ba3e47a3d05baa89277ad6b73e3d306c829e5dbffebc8a18220c3debd320a0142fb400b4eb1f818153f8b94bb021a1ef0a0c03a1243130e9a7496cde5c866e2e43b7dbede6d2e382c4694db4261a8d46436a81425b602d472db096a316580bac05d6026b116a9955165b4b108bad2588c5c66263b1b1d858985a8cd8955b6a68e5961a5ab9addc566e2bb7544f0a09b7425b695aa1ad34add056682bb415da0ad20a94bb025b395a81ad1cadc056602bb015d88ad0ca0cabd85682546c2b412a36159b8a4dc5665b31d2c996644b32994c66f4c4537915a9bc8a545e2a2f152025b9a6e25353f1a9d56a352595221f2a96848a25a162a8182a868a1135016fa8a11b6ae876bbdd503d2824275a13ad8946a3d190a0a468d891861d69988669988669a199b6e9209b0eb2d96c36266d04255b922dc9643299d11395945751caab28e595f24a79a5bc528094acd4527c6a293eb55aada6945224758a259d6249a7d829768a9d62444d586ea7a1db69e876bbdd4e3d27242db4265a138d46a321417101614720ec088481301006c240a199ca0606d9c0209bcd6663028dbcc896644b32994c66f404e67b157dafa2eff5bdbed7f7fa8094ac6a9f4fedf3a9d56a35a5af484c8ee5a41ccb4939966339966399283791b9e5a15b1ebadd6eb75b4632436ba235d168341a12141a0f76e4c18e3c9807f3601ecc139abdcd0bb27941369bcdc6e41909654bb225994c26337a2276afa2ee55d4bdba57f7ea5e1d9012176a9d4fadf3a9d56a35a5ae480d8e25e158128ee1188ee1185193176e78e886876eb7db0df7602430d09a684d341a8d860425860bbb4717768f2eecc22eec0add192be6921473498ac562312297262e35958f4b4de5e35273a9b9d45c6a2e4aaa22bb3e0bdc5144749afd48a197c8548a8ea840cf87e1c848a5e8c708a35dff052634cf892352d0b37e4d1292e7c48f123ddf05273594123da8b5644bb225994c26337a1283e555c4f22a6279b1bc585e2c2f162025326a2c3e35169f5aad5653622992c37a552a465b359534716a17d2208a51178da254d2c441e30916eb8ae3bf4ac5a562bb4e714c11dda051037953dfc531d564d7cf365f05e9d325a514229228edfa5cd8a8097e62b626a62398a832edfab346a937228248829e3fd69be8d38362fa59829ef5c39fd7d542067a7e1010bee2c813f47c9a23307cc5cf123debcf0c098149478ed0b3be4c92189874b110dbf5638a88ee1184582d919d7eb003d9ae0f7364a46b70033dff85090d8401e6411252a744117ad67771521bc20826e859bf654989db7236c4ebe7077a3e8be5c2dac0c0c2da76fd946db24cf64602a65d7fc546b1b723b8c7de767d159f9e6ecbd9ab8b1f263d1ff5f35a02057ad6d7414079081701daf5538ec09c55b730f4056cd73f0d09815bce5e58fc644168d70793c4960023b6eb7f4544479ce89997c8700a64bbbe7764849d709198d03e297e90d0b33e4e423a8259a0e77552d33ef8b90257dbf539b0089a5b72567deede320e7e6c370bdbae5f8f30950044f2c3dd94e06ebbbe2fd1837570e40545cf97228d24f2a63e0d25fbfe238d24bb3e0d2577e5f4f4d0b039170ac00b9db79cbd5020002fb4dd72f6fab94051d0f3c70b4483c98d62d9ca177d709695b316dc74c22dffbbe995fb90eb8c14e63e99dcf519cd9bcb87321de162db771f7f21b5a0886ddf813cc8617ee4c8d2b6ef421e733abad216ae84b1d62a952b5557aae2cd957e70712fbf3dca1bd3106fd9973fcc38d1fed3daf7c175aa68c3047ac4954aa46d71a02eefe1b1af0306240e0f62dbc75af52c9a63c388c73e0d3f82e8f99e9e570f8f7d3b852c6b461520796374c993857eea8ba24767924cb4dc320a3062f6a793ba038923455d2adac2836d59db5ad407ed914e1cf655d43569b46569767a2f6f89eb8c55c87bb98b86f4625e128fc82b6af28caa90ebd4125824d7c1b94a548639cb7a413956c3ec52045d5fee7816654ee22c9b89be3034dddf16f4689160415bce603e1b67cb990a986cef256fd4b793c9ce0fa660c9ceffd192b664b2e56c08b16d541f3b91bb508fb4e52c09a22db7b0e50c092aec2e491df29250da5df8c2fec0d06315a22e8b54ab45aa16a95aa42a944f5fcec4d1512171ec77b4ce8a6d737647f3c01dbea9d839f1fd45d1e315ea68447bacd4c51979cb3ec65aab54ff2cce68bca84f057bac3ba832792354f558bfd03446740c0c4534075bce8c24edb93d3062db2579664ac0b67defc775a68e7cfa268dbaae10be42b4e97e1a81d84cd0abfadcae7b55453953c1175b46b18522f65885ae90bbb8236fd9d79b339237f6bb2498d122652179633fcff4e8bdbc1775d130d2e80975e24c4df73c511ff52a3fa84c33ad3267d95963f96fcd688f16e90a819f17fad3821edaa317b4ed8f57e8e501fd38cb7ee2f8714643b10f6bba698ce8983dce2ac4d524d719af10c7e528d524b5a8caaa513daab4ca0476b4ed57a45ae3ae90eb8c74e80eb94ef5a143eef27ee4cc0817bb0b69ecef966dd7cd18d99a13233ed82e1f6f16c464d7a6245b65cb9991a1fdea72ed7a5cc7c775ea16db7634eaaa43deb29f04a9a8b644e9c8b62d936d6f200fdf79e6091a734187506f1f5f41ba506217c55bf9653ab98bf2c5b63f4b4268cb59d09228b69ca5000bdb2621c5bc950489a32e217196206fd418c81bfb3687c5fa57c92ae43a4c481766ca424db2edd7a15ae4aeae876641baba1ac81613757531dab26f6d6502b4aded5e4bb6fd1e67d928ceaa41d7435d5dcd5b31eaea88205bf66d77dbf63b71fc8e69dbd73ddbfeec68f2c6be6a07631765dbe77c5c67ec68515c67c4473dae33622eb67ddb7da82d674d965432ccc70a274f8c9012d116f7ad50823476aa428605dc317713accfe1f78532af3e9af0fe4c48251552fc6ef84468bce5ec2868ff4b3877aef96e28f35887cb847389b3b83f39115f3eaf9ea00ae77601061432b7ea73cc77c39313f4fdfbd7259cbb06bc2248033d1fccd2ebf2890e216fb85fb158a323ee73ccf7fd388b7bc91bee274c53a2971bd29615f47cef5d4706c5111549307688e1f7f9f505755c9998ef3e46e6fbeebfef3e067f9f384e7afab9e9097fdfffa7f74de22ceee56e55410bb9e00e09c6c69fc32fe72a2995b2e6347e60e3fc7787fa5e85be61b62a94db2594bb251c356b0335158e98fb6cbf9415155dc3fc15b0e503bf077f823a401c8ef9f117aeb210ba73453dfe2f5ca14ea0f7854286ec558f94eebb0f63715543c6d9c505fbe83e25e5bdf6f3615254f2469637f3e767990f0cc1245ace9600b4478a84cded905fc827ecfc2e3f3d76ffcd70d5ddd98de08fde8ff9bf9fe1ea747fe5dd5fe53b850cd9ddcf3dbb174277f7ab1af077dffd8ecf50ee2fec3e77f3fbc4f1033b8bf777a8a7c5af861377a048a22700284b00e894e7295bf66cf939532d214b18ee1d3a878c75b37c4b387a3f8ea96f791aae3cba597e65c51d9e6f965f557187b7a7bc61f9554adce1edba778b90212de1dcd447dde00ba11b145735cc4ffd7c95eb4cea52da98e45883561b397666a0c175f24b20ae1fb4e5af729dd4fbe7e9a00e21b5a72705db87961e2ebb451c3fb0a5bc19e7b3fc0e65f191125353c98612476934ce97a46da379144e5a38994ca49914ce9ab39cccd890b36612d7a186b5d9e37c21bdf411edffaab367bbb3ccee8bfc7bfa96ff23887cd59c8f27933df196e0ccd9412082822660cca0280847688212781c0a124d544891c51748ccbaf02997384cabe52e149a307a0152941e3491c4938204112428821525b002934a052327082202c307342b8af01c1921818213347182295c8167ccd93e85308870f7308ad81e048db78c220c21981879b0b125c771f4528e4ea6faee61e562e24c6a73d6ac950a95c959d3dfb17c50be11353b91592907759c457be4e1db74f4e1bb6e2b0d5d3671bc12413171a6876ee42cb7b67e5f6ff05af9a9b5d29c3df2c0711cd7712f417c95dc2a955c5c6d0da74c627bb9c71fae59d00cf9e0d8dafb73ed9dafaed63b7fec11192df0e843f5b7d65e7bedcd428fdf5799c8524af9b27661ad553ec618632b5ffe04f1df709c5d174ea589533dacf5ef9d4bf7e2b96db53680ed9c9283b1d60fea90f75698b3aec7618cc31a64411d12775cd7751c67af0e5b79c85dedae6184114618dbc7b9658f026c1771376d121ed45a29a547b8b4812bd1201a4491a0404a14091a4483966890524c4a8504fd34d860471e6a369598067a7c2bbe0f6b257afc7fa5a313fc04595a5ac2422908167369a99b5c124b52bc4d4e0d1b41b0584a02042286209a734e3bedb4739a4015f3b9be4086338894554a19ce1f67c96a6b95f3c727111347be7f385f412611ee3fce9a3f564a5c65c5e2072908113f48543ef8814a97408f75fbd7aaa94fa53bc895da9f391b7fe7d5d4aeba7baece504888f1c518630e73d4727476db9682354c251327ac4513c7fefc1b4e2513c7ceb97f98b2297396a5cf6150c7ac52ca9fd70858ba8e76d612f4db7799137a9caf721d57e5408f2aafd38df29cae028578ee6d72c4adf2773088bcfddd3fa6de7a9ba4b6142577f5b4d386dcd350c808b6b532071c3e2420d6da2037d840834b163b3972b4ceb151a3c6d69fd4df864372d816876d858cc066cf772173db84312a2277de2c320d33e4b031a4736c6a5e95fa24d28f3927529e9fa22c1e76d74859f7a7ab4e91df9c150a59d68c5d4fae285c67adf424e58d8b4332bde08e94fd813be8286fa3903ac5ea146ca23fdfa354f26d459db2b83a4bde4b4f12743ae969c7690b396d4ba407094358c211342258c10b1e4c5b384ea88215c2e0220b28708247d296a31c952d057974b28a38788bd21839a5d3d318824d771547106cff990a966c992d672a70c1ce15358fcc3967adb3cefaf9bb698def0f9992476ebd85cc307ea02e2c62acb5bbff4c13f4286f74fe7d7c31c651f0dfbf2210f7b10804fe8e7e17b2be8a2bceceaee77494e79109fb9c25a574f73934fe3e4296b72702cd41077741d293f6c083fd3c645b71fea8da55bc0107204198d0d5d25d451b7ecc40438e9d1a366c9c259d82524ca99ce522851ebf8f09113b6f2dfb4bcaf7affe1541cb97d6feb067bda103cdc98942ee9ee308e6bbd2ced2888923df7f401d52f497b3e64bd0871b3171e6dbe76475afcf85f36de835ce92ff62cc49055aaa88dc698d9073ca1479d02de5ac7eaa73c45be2141722e88f873d8d443e30749e5262296ba53e6bad98884fca022426752e99cd643e8bcd84269d01cd5ef506da6c8d33b2b21b13c2b3288066511021bb8e6e2a8e20d852de502580a40eb48d948d98272a721dfa983eb631d8fbb96744b0edf1b77dfb2cfb968b6ddf664604a56dbfc675ace78916d48177ce19e31c3edafb3e6f6efc1e16abb3e67f18e8defbfd27aebe5ff5a00f3e0ffaa048647fe2aa87fff73cfc3f9cc3f1c344b617fa407727ba11136712ed771627c6386b4a243044296c9c7dc3ec1f93cd852c3bd3233f9b0b09b0b3adf6b99912b16dc31a0ed4e1727e375cd9973316f060cb991258d80ac0d9349bfbbe506e1b9c45bdfc4d10c7171a3babfbecd3dd5d72a79187fd39aba3a74c4fdd77e26aeece4b65172268fc72066d2e94536c7b43395bc1169b0b25d2962002acb8eade7fd5c3b9f79e9e5d771c830b98a101922f72508429f0d4005811833cb8fd8138be902190d0062efc01f2a0621099313dd99f2971c5e6c2d496e00ebaadb8aaa1ee71047b8a34501728d6a8c1ed1a3684f488df067dd6ce531e52f4ede7d0ffc2b9b1eb88359c353d3187b3e60c384ca96cac4883b3e64f31c71322cb9a9106d3ae9fed6dd288f98d46ec76bbdd68f4d07062d29a684d341a8d86044506980c4732c06438920126034c06980c3019846498e5d86408cab1c9109463cbb1e5d8726c394c3218c991e52ce5c87296726439b21c598e2cc728e749ce2ba728e7955394f3ca79e5bc725e3940394a706a393e38b51c1f9c1a4e0da78653c351ca298213c349c289e124e1c4706238319c180e114e9319379ca119379ca119b719b719b719379c1e1c243368339a66d06634cda0cda0cda0cda0cd409a0165066cc6d10cd88ca319b019b019b019b0194233669e57894411b6eec35a68829e9fd22a5968a1e7df18950a134ea0e78faa9a7fd97286822554d0f3ad0d2b36849e5f6be404f9e8f9399c55df060a7a88d0f57d861d2ae01648231b9c559f06202a989034203f548c3005d2bc79dd14ddbc6e8a6e5e37af9bd7cdeb06e84689dbd46e7c6c6a373e36359b9a4dcda6a6745384dac46c926c62364936319b984dcc26664364d3a4cab8d90cc9b8d90cc9b8c9b8c9b8c9b8d9f4d820b137373737373737373737dccd8c9b1937373737374c338cecfa16dc110448f673ad90b51c707059a209aa83cb9633a0259ca0e7bb0f3d1c99819e3fc459f57f0042c207daa7a725ca11ed3268329a64d06434c9a0c9a0c9a0c9a0c940920185ca80c938920193712403260326032603260336db95fefc79a56c301d0484957e5c003463c89662c89662c862c862c862c862183db1c908b2c908b2d96c36261946761c811d4962c2868432139610f218afa218afa218af18af18af18af18404a682d864f2d864fad56ab29c528525bb1a4562ca9156bc55ab1568ca889bdb5866eada1dbed766bf5b49070b4265a138d46a32141b92cd8110b76c482b1602c180bc6129a611b2bc8c60ab2d96c362696914eb6245b92c96432a3275e0cafa2185e4531bc6278c5f08ae1150390925c8bc1a716834fad56ab29c550e483219604432c0986180c31186230c4889a803718866e30044234edba6fd275e4ac4813186487b6a6036cd0d60cd239c0574050bff22be210159125ae80a43c4a54a58878c7bbd06b273187b6fcb1b8029241f1f3041dc0a2ade980a7adf9234b4c5b029037fe32bc3171fcb3fbb730d559105de4991049cc82504a9999e03564a9135901e9deb3ef8943bcefc40902e91e8b43f08fac5185f78f1cda9a5904c2754f84c70b5740b0cd5c386fdb86deb36728b46d38637b86e304f297b46d4389b46738da18811e6d50d70eb5e1accd33621bb4959130d19e1ae6b001043d9f8a5adec81f6d5026ce514264e9aecedd55fee32f23fce5401c0cb2a4aececbe04982ef75e2c8838d5ddf562a542eaaadabb6ca44a9bbbb8f8023729da342a61ef792f34249a9911114469d91aec17cdb9374493a27ba1816ea9cc0425d1226214820b18a23de40406e84ff18218138a6ecf2ac17da984575caa0100af21f957f587c4afefab0f0d7b7245405cca77315d989941388234286c111457250b8268e8983e26e83bce11c1377e36ed336c950fa2cdaf57d2ee1fcc3b8ab15e3da554c7d0957afa50e050d2dfd49442da5d55a3aeba4d3cec93d0d39225fe22cec4b9c656b489d7583c8f25dba38f2f0ed4a29a55cf54ae96be2b8f5ea61ad54fafcf9fc08bf7e7f568225b4ea61d8721644173b6f39eba1ed9185b403ff168ee3a4e4a4949b93527e1d25c57f6f7dfa36c5b57875cee3387c9d7a947294d655e568adf2398baf735cad5c5dd540bf3e1569589f52d75d142cde426b75afb5ba7b751e446aa59cac22eee1e6ac8edd477a394b1d779e92327ffea7a73b5dd1ea94da592ba595660fe967fa2929699cc60fcccf2a417e72b4ef2b5bad7597524aeb55bae3e94ac876caea3a45654d954a385097bce1ce0c34d839f70eb095aee3dd91fbeb43c63aaebc0e4f778e738e5bd5609ffbfbf9cb4107d7b941833b7c03095b56d0f2ef5361230ce24052a49e38bc077555f2a69f57be1ab6b4d0fef3e50d4f05de204072a8038883bca1ef820ef40dcea21fc459758330d0a34cdaf4e50dae33eb8d9b5dffa453aef3c2b2614501dbc757a89cc885cb152d30aa1855145eb0f06205d5f5bf7f02755caff7470cee905cd4baeac13df6b8d85f9faec01ddd7358d82987017d708fffa35ffe4ea30436fe2c3910f4496d781a8930b1b1283fc9a495f4c8a7e1ca2b9dab0e5fae3ab595d24a7da4401d941ea5586bad9592627cb93aada453d2efaa0ffaf36d9d3f4104cc17c7f749044faac57d8a3fd009edb928ed8e3a411ff4fd5333b6fb4ba7ef54faa5d256b9b25252af92bb2f6b28f3cd3d3a0ef441dfdf823d3cac3f410460da813ee8d777f1b91475ce08198c01ae9309cabd0477ccf0387bc514113b675156d156097a00c50324cf2702915ff2ec789e5df63e2a001595415f7e4ce7cff79b208ffbdce77088fd11783cd92e408240f2734cdcfc787651ec98b1bbdff16abb6b411fdcf84307be21c616dffb13df3b690d5da731feef8698d61f71ee98f8be9407ea0063a0e5963cfef3470d628c5fbbcee5b88b2f57fd3dfcab0effcaf1bdf60aa1dbfeecc1bdfd0c7e395cf9670aee9051d821a3d831a3060f579047ceeeb0f8d9f7bcc82013bafec4f6a688d419824cc398571ca0a13ef707901ce800cde6c41df2573c036dff070feff1e770ec9e07afc7dddd131c28c1c406f904074a186167cf87b73b8f823ef053cef3388ed3c1751ee74d2e1ceb58f17be1aa72bfb22bbcba9c77bd3bef73f77be0bf9ffdf3e8be3f9f8235783b8b9c97dad607be972372e7d5980a60e5bf82efbf97cf3d97bacfad6e9d9ebb9fe12a8b3bbc9527eef0f6aa1377782b5c398e73eeebe4b82aa6c00a106152e2136100fe574fbbfec7cd1880fffd040f40645719a394e206b7ed03ede1454531207205932b94600b9ad00cdf3b7800221498e1abc173b039c0891da0d9f5eb43415fd6d8214ee47a6502e7f7f33dcf7a73fef7cdcf753c8fc806ff7b6f825e38d68ff37e95bd5f75deafb067bfef7b6f7e1f17a68048f40eded71dee8ff539098e9e384e1a0e21c10c83e789ef47e0f1bc057bd80528c1435f82415e983cc181124c9ee000c6434126b4f7e090f6f20ede739ee76d5014c71f3b8b3f4e1c8edc7fce9aa2e6c45415f2fc3046a79826a521fec62f63d7e12827568a7d6c1a822fd013ace1758a47cea6e28bbcf19f2fa3a84f29a554dea05f29a556c80c85cc1f1c80c89ef4bfd49cd3fe5cd9e975085e752b7ce7afb8e93614326453a7b43e15750bea5750470dc7b9c23eed5847d9f9af38ff557539e71432bf874f6bad9d735e3d411f5e276f96d09eb1eb8c73ce4fcd2ae9696cc0b6f63f8d5d676641e3f71bf7f14f79037f7516f68ddf77c022dec0cef600b701223d5b4801f64ca59e3b4aa10f0a81427a3e9651d81bf88d3f3b28ab761df9f4e97f33c4b2b393fe0eada00ffbf5bffbb13187af78bf8edf963359a833a2d8370a9f0f2ba67e90bdcfde7b522c21cabe9d10da65ba47229cf714d4e18d730552ee1bb2c1a7e158fd4779fafc5cb872fa2bb9aaf45727ca0919b2312784e21ef7ebe7b7608ffb591c53be4a7903be9437a7cf618a38e6b7dfa75ce7ebcb317ff71db823bfff1772bf43b7b70316573dee7fad624afcc0699f6459537375da04f7b96ea1e5ac47e6e2de1f53209a13714b0b2d875005d31e69341580bd41379531874c22947a10b8cf37049fd0238ded18f81c8d812f41954cf9ee532e20394ed636376518ad1f73b6cabfa003c36b9a9995f0e5bf145f7e10d789e1e5dfe03a322f1f077903f5f2292071d4bc7c0b481d175efec7811f132383219ef89b37d8bccddbbcc13ea2ecb20a0d710fe2700205854fa373188a2f86f7c57cc3fb60885f2604dd76a32efaa22dee29e7fda8f2502295017d511725724adb9c884f4a7077451a5b123b15c520de941451f693db125c11692c0c691228344d52c49469901b6a6118f36ec5b53b735fdd99c1e80710244b830db418a10f25f200c4f856e8f37a9e18222df216f7459e477a00c654a88365823a421d78b0492aec17d69db95b411d614e8d1c6c71c841a9ebbaf0c30fdf823a421b396c80197cff61c8ed03439a7790074d48935041632715bab3fdbee6efd7830f92e9843f960deb82b3c787c3bebfd077ee744ae7fcfa79dd9bf30756554cbe8fefbddfbd047da49e703f30fc21b49c0961c996b326b13d77c697e20f6b10c497fb8cbb9f1b7720ce8f7fc7bbaf7bf02ba803cc5db8caddf75db8429d40afeb72ee72ceb9cb19536b3bcfa07872c217fa7627f286dc1c151c88311e3bd0cb1d3e9d50a71d44360eb90f4cf19d5fd8f18cb10ebcf2189d36ea721a6d712aad3158033dff86be55f2c63873a65985bec1f0de5f85bef337c1107fa6df0632fee8be7f75dc9c73be44d40cdec7294a3a22b2470411df09ccaff30befa08e1cbe0475acbc986ff845f2f7c5105222f08321a447cee2fe85901ad5589ee561f83c465d6e934ea32eaf798b7b4ea5d25ada629bf31a6d739f711109f2e0328eb26557448259f48a641e5efe5494b07313acdff1ee8b805bce9a44f192a24475c32fa2b92d674d88f6e70293fa50219581bce1be26a42eb82df59c4af5a34ebd0c31f59cbcd181cb6a0a23502b960f147ba0ca31539060f53b9e5339983b46c8dc309fc51b8aef813c52c41dccd42d674cb8e59915d51786f77f850734170b342a378cf90cf25011e9929890c6acf8d39dbea5cfc475ec7b5e620a9a4db16453d107df9dde36b5edcab6abee71b6ceb6e1aabbf8a3e1b76df7d150a56867efb3e1eabe94e226b4efd370753fb5f1e7fcd1d033b2f34743fc65509e4edc83dbaebcf953bf7ade7cd50f82430e3dd4ff614855d9f5a78f6bf2d4f72c9d49ae334e27d389ebcc9e59ab4fa9b0f164e23a72e682dbaeb31710b1236fea77e19636f56f38030dceaa2292b727487f8632ffe9f30422cf0904d356fd3aa7b8ba6f39bf3f5fb8fa1ecce10a480645ad00e779253dcadaf854455b55d356e5fced7deeb9e938e8405d59c41fc4755a4a1f0dee670b4817280ef1d982869d1c3966d8c9216fae4a772efbfb6a9c4564e31fa8cb8567be97f17f4b7acc91630040dc358170a02e5004418e5b0e79b3ed7beb62df9f3fc89b7bcb61c91b6b884a083f912f7e19c45bf787b7eee3d006675d262ef08439205da0781283bed8f7a5d4c1e21112ecfbd9dd411d36c89bfb75ddcc61b1a637c319e4acfbfdabee67bf1fceba6f411ddd57779d5ce0fdd3fd9964e2f0c439c42c62d260df27b241fc27710504fcd39fc4212b079c8040811ec39ab62eca85e7becbf0a34497a510892beee767cccdf73d450ecc1f67dddff1efce513219e7cb0679a3fbfb08902ef0efe7e0ae29e43d501728ce2164ebfeed2413da7d77deee76dd0e6dddce066ddd073d9c457c31fef9834595cbbe445f121207ca8910baee87b7baeeb44789847a54a84a654ab5eb78ae7984ec8e982fea5280ccf653392bf5e59494fcb3ba0bf512dfe0acee5121101c9cd5fd3c32714c510112a77b2c3260ba60774f64632cf40a78ca3c92baa4a7550dbef3fbce220780382b88b3acd0d2fb81baf4775a04d2cd14ec2e8b3fba67912efddddbb84b071bd4a54505e4544a0a2945bb942c8e7208bbfbc41ff2a67b24fcf93f202b22a6adee55448f6930e54f608ad8c39e904ee0f7c3755a74f2771f2487dd754f288351d013871bb1e50d21be7d982979335f02b8829da501c8c441c5d4c4c18f31c63269e3ee413187b6f0633c7197435d19902dfcb8e6ecccfde02ddc43c883b3288dcdd3833f316de14f99e01457dd7b9f6a63fa435ff86378f016ee789037f8bbb00767e1cf5d0e75f9e02dfcf853134706240e1e6d6cac81968d717d2cee307bacdfec327fbc355fce62f98cd2c1e2a2e299a897138727ca8933aa4c1a07ea60f9296fa8ac882ae1ae424f1975cd175da222f38d5211c79964a37e9c47f693ee3e65d4a51277a8cb45c43b54e849e42cd4cf24ce42fde94195bcb2236f500f3e41cffd7be5bfcfa8c72b2b726516c91bd457a1f5cf87f99757bd8bcaaf3ceae71223d7493dea274b387f565e4f5d64ea4f5909e7cf047216ea53e10ca29feae58f14c75c79f9aa7006790bf52ee1fcf116ea67cfc431c53984c4b9a122ce22e40deac729c446ad88f3256f50de7738a8542ba81571acefa877a95eba205d2ad100d24594b235e62ca58e8a28256b5c19577636000fa4cbe5513f8b902e17713af116eab9583282d73780443deaa574016dd48f1935611bf5a35c429d79995f89f9d5cf88586682406244b962f9167c1ff5b725fce10323be88ef78e2a7af0a57dee5be0b7d971085527997236fa15ebe4b3897780bf52a28d467973c13e441645f987ff915d5bbfc0a8ca8a22dd4bfaca8444d5ba8775911572b9f52697916954fb5883dec5ef99567992fd4b3a87c4ae5575444d5cb757ea3bc47fd04721dfda89735287187c984e24196354f5935260e2a7e13a7fbaefb7657c3e697f26d5057163b696d48b08708b69494d3d48500897515f3bceff8b1586df05657b37ba20df2a67b1cfef8a4ac40be89030112a7fbcec9ee6ef89037dd8fa7dd7514bf54e26ce0daf156f7b26375524640ba52441fa24061772fa58e27fa6cb1bbcfee3e7170405b62495d2f3c33cf5c3f1bceaa91a2bd1f758a18a413bb939c38f49641e44d37fff42ee440b4e5bd16574086ac1ca0815849f11875a14487d196f72ae20a086ae500954f7d4a0442455b1dea89f078bf126adaeade07d759115de63d4a7422f0e71167757f0a72564785f6baaf1100e94af9ee6d70d77c79abfb4e88a4357637d6a0dd491ca5d2eeba2c76f759ec41de74bfe3602db368ab7b94169fb6ba4fc9e22a7ba038d2d7f6fe3b813f4aa6dd3de8799f431f5ce746f144550faef3b2bb97359db8c314f24a90658de3aff4af6a7376ba68236f6e648b7bce66a76c6eb4d95c0db6beb5f11667a36db60f7adf2667116559935d9d67b91adebaf77fe2e0442bca90373738fd04d8f7479a63e2dcf73183d853b4a9208fd3ae6013b47deeba8be5ad9bb3effd2c97faf16ef956e2c02fbfaa260e2cc65451ca9bd163268e9a8973ffde67d1d6f5a7f2ca2c59f559d4753fc7a5d9f59d559f8af7330e411ebf6d803beebd1f33cef0386d2ab2e4cdfd9a89a32571ee5f79737facd997b5ef6f2965e5debffef83d26b0b95a25a8e3364d1c557d69e48e9154aa989f02a6d3e51636216429f28ecaddd6040c042b8aa0d7270a7ef0847bc5b7a3728b85930d3b34a89ed5b2f1963325843a29dce7a4eed481b8cffdb4b566d318085c518b2a2056c4a2a6ade93fe29c1becd4c831a798481cd064c40dae00bb020d98f048da0d6a800421342d898116150c23f8eba56b63a7468e2b52b69c21614513644daea0492163527a426a91822360dc88d0820652889205944f0871472585cf108a20e10b28b4e8820811b39fa02d7270022f98be58ea9e4c21868a2328e8c0c81354fce035851525206a620942888217590cc11d110099851998400537234f1c810a1e0f411220219c287a4111b6e0f1aa85ed41c8e288c6258113499e8081501541f05c71c3c2a70a2608220751eaed89d110648a08820926989c30451238e0712235084212922a82908e60e2f19a85ed9e6d884654a99e9593f698a3b405ad767581a0a5a8d149a3191245a8b266a7e41e35bede0c36ecd0e0afa12001c5e6b69c2151648590a0942013181815cf9b2d7ff9f286ef8eeed9849dd3679df33be99a52ceae43c997f963b8473cbd265df0cb5e87abb7eedf0f67eda9bac7ac3167577973dfc64f1beecab9bf73bf8602f04257afb9e20eb3c7adc85aca5749f952cac752be2c807b4831a55ff3c554ea48703216f15fbd2d163bd5ee61d7affee97d1f0b91618411c61662f6c43aaebbc8c3b739d103b5470898e0041384b6157798efd59f56212a6c632625d02037e090434e05aa462a6c075d34c1246bd0c891346ad4100238db558605f44e8ed24aafb5941e6196845912f4768fb1418689f66c410a9d5114da169288a2e8a29bf91841d9a3e4624f2ae7e3ea45dec0d7b31d69cfcf587aad3638a5f9313f9f35df2665cfafe1b3e7ef54a933df8dfc6862618fce644f22eae27ebe07b1ef004ec49ab668a8e58dc41b6fa4136459334e39258eaf67cbcfd119637cba3a261b39e8cf4003fd1f40745236fd1b8e367d1daad7d87cd396d2723bb5a9b8aaa1ae886cba439f06fa39f46dd0ffdcc5eae9e90982a9a787871af5f4b460a60421158c7a4b25fc6c394b42942d93d0b4f596b3242cedf99fef7f018904429ccf5fc97a856d3fcf40e3605f07fb3f82f84f9f39ff87bb6a9882dc603f071dac4ecab63f2488dab63f7be6cba7b5c2b69fed5bad427a1e568e8d6d6936c7be0d6b9f6543260d04fefbdd0a48f722c67f1f8b9ab64479454c5b42ee178abc011ff0a64c21b7b754b2897469a38aa047aa8454a3469496f29ef583ef2aef4f61d4757affba476a545f9a704211278e90c41362b28ba31828a124cacf15920083a0e5db4b8decbd5685a889521eff6b8d5c6774ea5dec2ee48d1dbe8ffc6927001814e00714f8abc0b4479ab43d48f7de8e67572115914d19721b86a239c596b3a3d1a8742a18f3821432442322000000b316000020140a87844251144461268bd9011400137c8640563a18894281703045310cca2134ca10c31043060400466654035cb99a614e00da465c4c14929e372189346847385d70d2a3106f7f690846f104821a0e34a4818b5257cde298364f405130cb4424034a1854aaa05c9551094ff155508bfc237806da17942bd0484aee24e35f361123e2f20d0897bd012aa5c2851206b5b088fb9628ab36a8fb5cf8269a6f20170efd1eb826491403174359a319ea36dde5c1240965c6e2d069924471c2e0e44992e4ee82cad442920c8365ad699abb1c49519318de03340fcd0e5d2964dcad21296271df10362d78fac91f47d1e4712a22361947c9a5b67edaee252040dd221f381ac3e09528ef7a53a25a1c4db9b553876c163d23e9cbd1e91dab9584072555751c204e885d998914910375a9f1c12510635283e8dbb3c4ce60d1dcd405674a22309f18948468f42a7d3edc523307f717e9c41998e549b08b4409514583a5aa9073f6cb01df0d05815516161cdf2ab02a8f60529d3063dd486f6a38a84282dd81c5bcd2bd065940ea47e7f6425ae429a2bbe7c7ca0c8b0fba334e4dc5bb3b184d312c31d9220dfcd62ef9d1d01df40f98a26cf5c5bb042355476982dde36bdb047243ce609b588f363010364fcb0917bca532f1291e6215d2e8dc8c06e035e0a3c86dfd5bbd34d281e6560e5a31a6061771413fd0c607d26d319427545d29e4810adb57191f610415b150c0077a2189ad4c6c46e942926365088c67f8a3e11fdccec6302fcb709446ba8366a1a1557df4942a5ce6149da4cb5b40aa960a892f16c76d2acd537f99dc5415c489029361009754f31d3dcee618978921f18831d8b0a0ac778736fa9fb93add5b34600307940ccd98aabe12776e2ac242355dc3d89c804d6ba03d83c9e274d3a3aa56d771718b01557438f10031a64d84e1165ca4fa011877f6f0866412a9eabaa9dc97482ac0a02b52fd9f93d3246faa7cfdffd41aa2d0803ad7e0148997bbb1a6ed281467fe7aa13a2b368e021f9770e11be25f66ff9dac1f61610d353b5f872633a15d454cf005c3d458895a9b21c50485f9bcdafc63a02803405ef2f67e08dc3d7d3e79c607b28e550ce3cd661101e659bdc105b0f1227b490ac4e12ef05467e32b70a79d7d681547025b0900e2ea46705090e14b43eb8b201ff281e67dc4122b2190e0c3872ff85c386a21db69a2c0702670f0fe9ef7a63afda55be57df6c73d9098e81ccb4ba6de55430b5cdf62883bbe264ec59e583f8c38e467f90b5903411741e002bf7cb949173c1f95b8bc77af4066656feb596f5b54fbd1e50253edf458f7b7f1b4b4a9c2ec0a1f12e3e679b2777b5dddc507e7835af505977c782a4482b17764725abf1fb41ca8a5c8ae036ac544f1d624b538e8f6f21fe9a031808163bf3347b12b3cb91c2bb2fea063643d048692a4b02cbddada1e1493e9925b5b859829108da6b44fc8f143d8ad910b707a360a99c4e48e5fce3741856283dc65fbdf521a2e7ff47312cc03e7cfd794d52564d200458bc3475091a819a77233af8f489789eaed8ed9af4362563a1828ec2bc1e9d0ba260cd69f35770b3266051eb97f09ef07cdf12ae745063dd5a998aee0a5bac89867be06eeaf7a2d8e4c235a59657c13226ed5f7a97dc7687b95c907a77037d9ec3d522a00f8dae9625a2aa0b575fbc0498367b1c39690bcee56b00b10df7343fa8c8e11792f7401f89779d348da035fead2c14a02741932b512a612ddfc3666091a7ba902e63ab9bcafc225f29fe90b6d8ce16d8a84c8908e2656a44a8ebd251d48f859a0102690cc7883ebe337a02d294d2ee3d1d2b7335258d3b02f6d4961c676bf01acbd27e92257d3efd7b1bfa87dbf11c7196660828c0cd62f61a024e2421b27741c09ea5f20c67d079c2c83a4e88706dbff2f088c2a1f05689239818ee003819623cfee7931eaaac154706ec6d2b8bd06ee90c202434c7c8c0ec378c1964a7386b8298f1c84a3c5e7020bec63337ff3dc1e5ca4d9e75e0b5da13f8076b00139549b48eccf629f0f6c77711c4474aff939c3e9906c4a86a290e456844a1585a4521fed64de03c4beede1c961f9662b1174b883113e035000372ce396675a33160de25122269136547757b4f8720a8d576b3e797f1838b1ef6434370cc790048adbb1ba260af57f42580d175806629ffd7176965f8b5d9812fd4eadfb47765272221d52112c0f6d5f3ef340ef3824a69b117cbf40930caab25757db423bfde6e8984376a77a6f0fa7db929bfec119570cab1e28a6865cdda156351b325d022a6382a5ffa0af56b5d711595bd6e104595dbb86a503f954fb2436e5fbde518dba3e0840d9c0118a19165478e2b93f375da576b1196aec34e3471a1cda76fbb8c02bce1c91a1365da80df41f2435392976c4018e02e4c145368c718920a1571c15dfacf6d7c99360bc9cd6b793bff41deaa38e5f1cfe0753926102844d44f57396002496f05f58b27d8d10e04f107908aa3a80a7dde6a89a5d01e33805be2c9410ce47c82d4d6328440e4f0b9fe8afb580dae72106bf7c60654d6e0095c00ace894536ea0916a98f621c96dde095bc03137a1b7989c23329bfe011ec75a4acaa8ba19d45537beabbb176eb6c335b2677d4575f93f9c2c6b80db619cbe0cdccdedacce58fa68d54d745009b0902fdc9c1724c48d5c76e250ea1c01540d6e8926f65295da5a3b98f3e0f6e9519694c8d063faacb64b6df063638d8cbd0062e5ab98fa3f955a9287aad10165c59335426a65e7980884788e76e219707086b48fa8d1af9f4e1d988c7c8999b5338443b8362502abb8a5acad04ce3b0896979eac01ab5575c80e365ce33af2fd2dbdaacf877da82d5a2dec838cb6c4a4c820223888b28bfb380440aee03b5cc8552a4f07bb3e54b8af172c3449416b541550812d9d955ba0a694c2c3c7e4d1eb8f88b6be87874ac84f7f85cec46611b7e68d7d14537a226d6e999564881602fcfc6d5585d2eecff45ec1205a459e49ba5322f92860570e83080707bfc26f17954df7c185f52ba14c4597cc5e8b6b2a408a639133d8538cee2ceda65e34d136c42f714ea770e38ebd1a885b8d24ed0db106b40a59ec0b0f36c3444e5e176c902ea8315223bafcdafc702c1c440706affbe93250b94928ee372656def81f4e5a0898e94edeb73eea09e7740028ba73fa26e687a7706d57ce09117a06e2fc4a1970fffc2d36d768b3b6a39e0f800b884b727f3b2cbcb7491ca66740e2237cb9056c512987d10aec392cbb8fac1a59b836ea8463f1de4cfb770f3e7a6a5ad3201b9e2ad5be0b2241eb3fa00e02d117fd47ec58b3191c791ed39803e4a4973402c9c221832179c1d11b6a838586197f1dfeb1f53b657db8ab7ac3b9b455486fcc1e862988afc04196e789f92d7670c40bea9d1ba8c96149c4095d618da78b2186f6068033f0c836d47153139108c2595addc5f6512038b1160fa265612e8eab41ffdd85eb864922a16d89d72f169b700cbd9ae8100fb8ae6c3deba12c165965e5a2c463b8d713452edc8b2e514aa0de8898fd83e263978a96a24888c62abc39c30876abf84f2c88106de87f958aeb77a13805c75be96274b5d7cb3d07a9004e6c307ec3b3ca20b251958d42b695bcbc7f71dd8ff3e9343cc994bb6518030058cc22433ee70789d5e2f9b7ddd98e2a47d5adc08b3e89ef8381bb391534024daddbd552617f69130210927bb342846e78c951929e42ff8b406148d7169cc32b74b9e59e90d01dce58175ac0b5c22a0d6482964bf64965954242cb6bdf3776bba335c670138c51c0ada0ac711d2908520c3367fe2ebc019472a040af6b3d5e62425610afa0f8370f87cc07d9920e746c05ca09aa26524c3bfebe69161b7276ee6ae11ba12366ddc6caa4a303abb462fec373488cd03b7bf91bb865cb8cf319783c9dadacdedba4ee531326e48e62ada005fc8113cd3cd15171a97b518b7d73b4c85c21a57375f9f89486a6aea49aff13fd0dc7452fe7034eb10aee842179221b5076ad26990c21425a754878e2dc31b47b04764a04b22adc70143161a7d3aded8d55ab43f6984560cd8e9fc8b5fbcc317124c71b217b49d1c8aceea41af81a967b88a4ccb3f8c1c35751ab31fb53031d1cc5003481277890c49adf22fd7da4e274256c63813519872e9e64fb829054456d4c1c21494b76da00131c7c9dd5f55012beec60b2f80c349c6edd499a35bc74e1b80372313e0e67c1ed289abe073456b5e6423e9c01cef0ccb89c30107cb404f78a0685d0dee08cc6076198387e60f070bfdd00f09112d2269f03af7d64e0d0e8e4a868c2ee5e91bf32ee9b5af57480e74f0ea253374c74fc972d169084c3b07816a6a2880d82f9090f1ede2add6eb5165f7f281b4f0e00700432f890d297385a3ef027e970f3a7c18c368849876054e3e092b9e086280a65d3abc340401c361e58bc50dd93aada149125708ac2cc6ac74fbdb29aa7294f93c1fc22ce07d0f7b9074c8cd0096762bcea573529393260770efd7ac5523fc092ec1ce1a69c837f8aa864d64ab016d2cb133ce5f9377e4769dc79736e72509ba0b68477b02aca8cca08d7055c3fd3a696e77f0858c70af72c036031eba952103090d9911a7607e6f81c251eb514dc49eb7f92ca18041d5d52caa34ccad49f7878d3b90429ff34baf76fa6b03d87d7f48bd9beae669b62cc4eba0e46e7307d1ab349005aca5270fc3b98d5e82b6d67be84bac0e221d8bcb529fc5fbea8de9db1c968daddbc26421f718b2a8e1c5ccd82927d20f699e0d77dd3bd4f45bce4a4d9a7c2661810932d53a7fd415c8be1fe7b2da3ae366f2daf2f2f548d97328b3da294b7c25e14a8bd6b6aeea3f995e4b80b07e8edab7bed06bae49d12d8be510f94976d54970eb09e70fde69c4a6a7ff7fb9bb7ae310e480965f997fa8fe7abf838375fb18b0d8dc48f5278a538bc0bd97639ae507cd320ec90384c154e73a333e347295bc694169304d876a555415ed5060ba397accddd174b50d323a2a4fd2d2b1972f3de88a678039ffd60ac59506a6101753cbf7ca541d7d574e2cd17e24cf095d0da6931acea81f2cf0419b2e86e1e9a92cd867411f669e5ea273f1361bfc01a00a5ea4b9e09d720cd5383b4d22946e9ad0e05ac8034d127418a0b5b03b80bd32a8a9558ba03d9cc9a0cf383eb35c3547f7da4d8d32f753c993159a4424a5f35142b6c5bc7cd17c2db1d6bfdc95ff2edfbc3b5c7b3d1d020aae6d8c4eba7ca5f7d2b71ab80779fd0752cfe51988fd2f8d44cb31296462e954b185173fa695e7a1976738612610dba1a930236d1914278191a4cbfc73891be0ba4319c9f6afd2d113b4c198f44931abd149a075da42b70aa5dba92047c12b5637af69b61015888e243d5fac407412b51a1a0622a60b6e3652c0ec2779f5567953e4d6a09a6bff3492418a9f15a7326196a6a99d719c014ccadf03de200f9182ea1982dca56ab94460c55918ac9fa8206ca21b1b3127bbff03829083d046523c423188f5939ce6738ade8af8c8cb2b8fe12a2aae94e49c40bf794d2ff42bc4086f2628928e660f87f6e85fb468167a6b0e17aea7a67acaf0b69cf1433b719d4e148cb4e2d6901cdbde917663a6f16837d16de07c5110340878d96a8aa205d2c36802de76d78286395214fd576fdd5e219057dbba0595d0a5da634ea2a304adcd19dd2ef413047f5fe9e51e2df383b3fadf7c09a8dbdc10aa52fe66bf24541b7b76eae706302059bd6dad35de3452e1fe9c893456e0dd6a6c1bd3166b7550ee7113fd1aef781f4c7b45ebc7b5121483a46a8595e0358607c13bd4dbe6293fa1c3f99bcf79c6edb5c3835159e3ebc0c667eac17ba68a4603217b729bd19d2a641d290637234edbeb614eb8892b09511734dc844c25df10977c0e95c9177e35f93a23fe6c9d9bae08b1f245d15e1963bbeae6e5195dfc995aa3f5cc4b1e91f09efcdd43775b67eb37f1d43b9ae5a95b7fc5f32e5d2cd657b469df4f44a57568c5d040101eb998e40cc11fcc0b0874556403b2a971ec3315c1d3f3c30992245299e30580c2089ef0fdc0a92167bc25d4589ae7eb5f8683797fd289a1087a11ffc398dce76c6d4c59172943f7a9a86238199e5e23f8b73232b9cf4d920556e83ef3ee736bf7c9f80130afc42cecd1f3f28f73bbcf19ebba58ad58a83b29050e225fa64224efd67bfa5900824f3eed0227da4359748cf8647b7a396f76c0637c1ab940dfa1a5e94f6bcc60293aba8a6422312f04c1dc9e9a6127fca2a6d2c5c44fb8f999a4b4934c91d41054f784dc7f0ce6c624cf1995585cc70422aea85e34f85024c65a1ec3c86f64efcc91fffc6a9432326353f624c85f7af559a493aefb3d08437e11a865227a58537a2d71a75563fd6f8cef2932a3aede0a0b4ff7c4df4c919abdf6e5e92ee76bf87075e7dbc337d71db7c7c68bfde6a4df29bdef9cd37cd80816b7aca22b68e93aa0dee1f3a69fd8d24b1371e2de6b8444c24d4580a40418914877863c5ba45f6fe452826b07c3c88511d1819a1393226034e244a21d30360328d07cab5ce68b5a304f0b806139cda4a170295a3baaf9122fb3aef7b82f2109dbb237cdb1ccc92a16756600e3586ea6a724022ebbe1ecc6098d1e57e128efce78f6561d583607a87c0f6a0be24e188414e48e549814043d3b2ad2e78939d4358678be194dbf4d6cccf953b71902049d3121ee3beff5082995296ae65fa353f2f65c90cdd2ffbc4eb3e3bd43b42dc44a42510a3388743ea5c208f9de82962cd592161924448c39997e6d9b6259f95c2fb03e25ea306ebc9a8b728642e08469049f9a3746cb76b450fd588cac7718607b271808d8b45bc3d7c25c280a99337d8d42b391a18c8518d232ed18a98b2692500de34a2eeb969207808afe1a800025fc546357d8cbd03c478fefa3a4a35daf1f906e65775f1abc3d5165e02cd43bb5276dec71dfce5f1ce5bd4054872f74fafd3d874e98c988610d9a1526c91f74b5c264166aa513b0e2967d54f8656041dc2b2cc086a171770feb65ab5f7ec620b96fd38da343623d57db50bf93998b8d3210add47073a53cf96f8c36e7ee63b7946e54481c73deaae14ae5e8c45f32539ecfbcc7a803a9af1736b4ffd2972331e7d50745e56c3e238b67dc208f20bfef4f564ba1305417a349481117ff3e33b3bce8b5aa5fee269f1fc020c773f9a7ddd47f6a8424ed98ed8dd10770654a63002bd103a069a92b7a729760f95740b4ed0e76d2706f643bebfe09a9ba6a8295af50d042dff404b9787185471f41cb2114e1b75cc1c7fa461e2434604b36af7aa6ca228594afeafeed95d2d1fdc5d4e2b8d3a5f5f5aa3987d9e6cbe58498aa06107d377014de5ad764a8fde08c622c5be1ed7791e44bc15b6ba02bbaab37f5882e4cb4c195425dbcee11716a27fdd1bb0567adb0451e59e43d9bc2523d5b55a906c26760f44b12903b11a7609766e65d02c87731aa861610b4fc6fa909e76899cd22e3c4c9e174010b2f4f919e57ed3696306e055ad9c91d2c87e0acf20d5b2892f7a1313585846b187d54263a3ed908b3e9e59f8388d798636471351fb989b40766d04f19baf6d7a72e49d08c82037bb91e9ecbccbc7d85bb612802f4b05fb303e66f64617bdfedcdb7b329273716f221dd6463d8ae26022eb315ddce18c3a63dd927a962d86eed27a73a868d33bce7b81d4f05682503d4fffa4fd0299a289a7375eff591d980d51361a31409b1bc95b2292737f6b87a6dcaaaef6664ccc0d205a90f196f5c0e7f4da33dd82b96fc6ed5c6ed21dee7f2d11c135b49fbe4eb674f7ce2b194c131cd2343e293a7bbe46ddf00b1a199b5403ca6fa6e4d28885666bbb50790dd42687d46eadccc4a5580cf2e87b748cc45306f51b3667114c0f3215f1b024a485326d8bd97f3f64b0b3b2d63e3a43a352c022c72615f20831bb985ac90a2463548a06d2d270d87fe9143846de08ec6d463bbf6cb318b734d579239a6b1b9f184fb84f440cbaa589116b7b71521fe005823d5a5ddaa7a6a5cef4eca3cea281bcb1c8a747931bdaeba0108aec06270e86549e1e861352a39d2459c8393baec1c5a5c878e952221c6b7121bc74c89eb0f8c4610f54790355512d784c63df3f32629eb1581e786bf0662844a500afecccff6458e78c55c2f2bf90223be1eb70741eda7007919eae18bc327d00b258f12e3975318b040e8aaa55a31f0280aee196ba818ae59dddef193b1b6eaf5412e225d663706ba75461a4ff7d05419a092d783008d52f79d73138b6b85cca82a88c4fea367cf9454454ede9872f8584da9f630202b616c3f32d6e821a52615bdf0ea51268b6bc580db0e5714618ac827fda773b925e6dabcdbad2fd98cf52d90e9bc7e2524fcf2d2c20d0d4aca4809a4047f576a33d1c84c05ef901812a1da6f42dc206fbe24aee9c6d8314e0ced134010174404c4c6a94eb30555522d4e5fa1206196b26bb288ba7f24a1fe0a8a16114b2bce0fe61854872b919d74a4fcef0891bc92b2293b96f2dd92d88a9c277496215e50521f33de7019fe9a6ce8693ffb0bd4b19a0e46f83a59f6e4a646800528fb089ac3e4cd671fd24364285531ea64bd04eec9584b3ce9a89f5fd2b797b00e7499c017d5ba0df1a48bae429294eb85a597c551f41d188b64953e1cf2d990a0b35e599553d1dd77478ad3fc21a79132c7bc0e6041ca75c319924110ad4602f39a40b93be8e19718036062b411a3fa29c597857c37f45413aa0198fc03e79e2afe198c0ca75889886d9806ebd7c591404c643ac4742b2f684c0aec166330448a674e5502bdd5289eb8b0e04f0b2613eb6c04a20e25ce18fcc37b8a209e8786314c8511121344e44dae2eeed0d553c6af6b65ab9d2abea67f90e3aa135022f455f2326d9ebfd662a2b63cb8413241fab0ea512223cd85d6319f660785107d106b7c70095134cc0bf4e8a04ad5fe98658aa53ea691a2d1eb160d736ebc04b92c8d6947bd4a8031dd28a752da720a1433f26619826671bbff1f45d8f7a4761a53055cf11c320cd58d1c88f0110cc0ba33e12ae821173e244dbc85678773f32d7f03cca1c78f85163f1c35704f405ca015f5ac220d3828a971e2835293dd960a07bd5ec65712aca5a216e1f8e490ab80d6264d47d440ce26d7dc110dc6f552f1d99674609a11a29c3ef38780dcc4fdde462c6d8c04e9c6a16149c4f4684c6263151d4467144de29b638deaff4d975637ce13ad80156acc4e05ddd0f8d1aec3db2146141dd2207088a8092d651410b92b1a538872032462f548ff56a965de3d28649b6c0096032fedf6633608659e01c6c209c9d3b5180e4d3647678a19b843301a8cca7424f9a09624b07374d80cfdc6841abcf93183c9035c9c57d87833602107f27c53c6ba6621fa24fb335ba6eff12eb5ecb29ccff793624104a88fefa0509c4a275a79d59c9bcdd615bee943d8f35c57968a0239d9eba4ca40af723107ee4f589446768abaa9c47019cf4d30e1c0aad47e769678196b604e25e06b6536df0a10cef16120b51f849af239bb885f1fbb8fb1187120e5208fd987404928f545b45077959baa2f116f8213f8cfd1699912e913b73354346a2353d39383412a04b0c17d0c632e7428015c154d9c07721cbb475be6cbea5e22f975d00476c91b22e5603cf41ba55495a9733e70a01a0b609b0305df0dfdeb0e5830241445198a7b281680d566d25dd4c069dcdcef40c350526235ed4152c05402ec14a920da961f78dce848b04773662ce71122ebf620c20642d6b8cc61d702fb7cb80795f229472d4c1ab6b54dda292fb4212571090810ac438d49974a3b9106fbb2b81c402e18cccf44a7014e5ccc40be19309185a3977702b9238dcc4f120e4a9ea5985c49295dcea0b87b19e5bd4666eafc8b1984e7368512b1b2d518111b6c43939871ef10549cf222f178c67ce0cefc8efd0b1e471a4af793cecfe0a764fa6c39793afbfbf6568dfa6bb49ff86c36c30dcfa866ada20988ae6f585c9ed8540ef3d046f5216ba57fc5649f9aaad951695a418e8b3a43fe740419d588c7e3ebb16d6cfbd85780a4c9a1b6eb8692a4ceb4baf762857726264f25f05ec718236c0ec4186c6ec62b9412b2bf0715b9ce6ab313b43f5023cc9ffa1f300ec7042d2c43c65b5a0c8e51f32390e343df1f93ccbed9d37d4142879236a48f1469b3b1b1377f0e4b0d5fed7859a6896091195841f145de136da393057e3040c58073b8ed711549c191091e79e4d59683a981e0fd59655c9eee4fedce1ca6799e05dbafbff9cf17f0d8548c9c841c33509d6be7925a221c1a03fc581150912791fb367f35bb38375603aeb9c38a718a9e3bec0d447539e211a1352f9c2347803e40928438211e1c3d0c53209851d4e189de283f9eeab270c3555a8a2fec6b37448b4b4b2c9767b1c514939e102b54eeb32532f84bd6ab39eff9beaa0bccf1264b3b8252fb4402ffc1d34f6d6f6522f4cf37358265ebbee7a8068c34c39a23b12ff32eec625f1342d7208a4065e51945d1be4231e540fc14361ddb2f6dac12cf81d74b93213a56356af86fb2127b9a4d913a30454412a8c829ac5341a3bd64334a613d41d3bd291ad0c3b0ebd70191e3100a3d38a95443e6e38a0a952a687ae699ed5cf66b1286cf2ddc9649276a89b87ad52eea61d4205cec158272105a14160f89fef56ca4fd8d631722c41e4ff9158b14709859962eb7e5642ed1e0cfffd331b215687283f5d5fc241e16249b3f3062db474d68bf492c4dc8b4150cb6f287c9f3751d16942c5571d44c023c01af645eb3a77566ccfd904f735dbd9000b25f0d3a1eb64df087b170c9c78acd34ddbedffec609036f3fafdf196758b63718daac9d3938eb61e6a6b0c4620f2ce103964ab2729908b8040e54effe63829e9c32be494ca6511ccb69c4af3f0ea7e8037b3958df901b34d2b0d173b46487f32f5e59e22c513d9c9999c212a8d34de69f6fe391c052aa3f3309a0b0aa8ef30046ef5d05506daa12668f4d9025c14937ebedb847b02adf622220053d1fd219532c1dd81204bc43a0c1bae6ae7b76a647bf49490f8eb28f3ee05708b1b535f3660411d4574bf4e65d2958e1605d3f1ba144d01eb1e0712da42dffca41cf4369ad016ee770c57477e8ceccff13e4917006d5dcf184296ae0654e18b3a8d393f1ddaebc762c5a4686f8eb6609307ba86406468ff8a2990a33438ec8a71d8116fdf273d1e0414380d3a9f82998869881432068dfd448a8629e8d0129d9c0933463c3ac946cc669d11e4ba79a63158ca3ca8fa6d09c71b52dc59ca480646922dd81d561cda9f4a2091df870e5e14a83a7c126f6bd9faed435bed6be6be440dd2e345df88a50b692ba475a84f640c5a614cc62aa634a40de248358f0a430494c82c36522a073bce78b236ec43f507e55e2a8d801bd57a9c58fdf45950931bfee192edb0a05b454a5e163c79ab555ed1afee66c7ee24bdd5f9149722ce4538adf5ecdfc786e9747307b0f675a84259771b6e3e64fd75ce1b4983674b2fd08bd4f519eb68fa585943625f4eaa20175ce266bd6f162574be03badffbf260a388b3405bb9037b0f73e66dfac79ba5b15008243af8b6a0822edf5576e886467d2f7c5084d414ebd5208e4efff5c76e89f4aeb62f9598a0ebb2ac1d8f6d9e134c6e389f9e740489e5421de9318532e2e99a65750030de32892ea8c71e919ba84a0dda88ce64850e87c000c1fe4f91b163f71ef705c2ab573c78ca02e48439c1202f3e427050eb80fded52e7dd0f9f6e1c6ca644305adcf186a352b7c9a8bf83ce62566bcd70fef8f7795915033187dc39ffc434953e8938d989dadb924ea33e7fe90d2c898571b52f610c89687f2e56e954b34b27f62246826918b8027532c7e8fc78bfdf4526e33f7a33bab7cbb861dfc9ee41eb331a0da262764860e5a21daaccf46695aa805250cee8d5b493b60e50a58bae7004821fc4a14c2102ee8dbb94bf04a00d25322efc27f08cb8de6ba4c5d0bdf991360fca66ccc4a07fb93460286b2ba75b0d659844348d0fdf54875d35618f576d6f8003ca4202917c20216cde1abb5a622f153c779e346c94bebf7681671f4769e8434788d203cef27ad34073a58163833df14bd287cb67b7e386aa4879d9d65e39530e1a0aea550ba599ddee549b2e5d8f8af339828586a97cb3048bf5eb2e51671dd24130eb7c6b7d73409d7c0ee69e547e25808738e4394259f0dff5a6267cb2fc2d7a8c1aa6714d240828405bad1ec0beb4cf6880a872688935c3f0e52b221f48a2455c76d3b73b2fe1535cde8c456340b5c0c335544abd6191d927c1e72feaa46ef30e3f78683427cc448094d6e47d0cfd2f850ecba4065fc9a7bc044e4c6360066a3356b8afca5292a29982c9af95e0918368d76b64432bf9e684116f57246fa8700059437038d6a5ef56e5d52f7421aced7b6bc4d93eb5b76001d2cce50e106037809ea8ae01dbcd2462eb939642e025ef8f88a7b23baa21f24cca3d1d80e57e627de2fbddc10a40470f440391577f99676ee94e8198e5c4646ae6f587a0c4256dc8439f789984bf729fa1bd46c59dc0f8122dba9d805b033a1d3fc293f1fee6de8f7b17cbb2dc005c4ba508e783ff97184aff8b9c1e93d3a1122149cb6a1693329e8044f6646981a6b7a7be7c92c2e4eb6158eb7b123f23a0a48dda363afb5728bf15cb863b07215c4ca06016227f6da131156a3aa9952899f6fb42d066de2f27cebc5810c077de793c0450494596afb8afd09dd644e98346f3e69b8a0b055fcf0b94f1745d16368f799a37a53054c4362536b301e1054acd37dd88a4e977c84ff8e03ce610907b2cf649b83aba8e1180aff12cd4050c8c8043cb4f9d7dec441563a02ab7abedcbbd7717d9dcf0e0a288379ade000783157af287c77729c242040e6f56e70f6e129380ee998fc4c47a0dd2a383bc930ec16f44b969084dde7e00b852c4db6bb60d3d971d81871fbcc267a8885e529e66dde91fe5f06d82659fb50f1585ae392932de6784b35dd69ebe6ff8f4cb92db1f19557f8c5af162df276f02490da07ce4348cb41a2c3cbdecc2bbfd3a4ea8eb0d0c00485fee4c2bd015a52ccaa0ab798ae4fef8547aab448e9bc38d07f39d493f3cba7d15cec8ffffd544f0696e5e6009c2c26990c4dcba871232835da18f1f031a802d2e193b8d808227900f997332897c49c22d9bbb0e362232a2059c47c4e36451436ca65db0664e92ac1e308bf2391347af43deb0e7f40280ef144cdf7764096936c890733b6779c801ee07bce6d5a126fa37c8ddc154e26e222113a9c403636d4ba6c581b7bac4f138151089867149e6d4c87a2ed32c9033fbf0ca7034e8058065b81980e08f09acc08b452707e1bbd92024aff25e4006612569109a4de2ca6cee1f53443431e411a0af9e2669635a41fb81095afe49ee9849884a8ed77247e70c71dcb684d039c1c076ba3cdb0d2aacf953721b946f16c513a7c0a36c3a95ad97f3621ef27d5c0c7ec16b06c82aec8992cb047ebb64b06d7f3bb2687c5b1f3a51d7d7f556a4441233cf95ef1e75b9c0a5d35fc88b30cc60634a1e388d10707c0008728e39c647b6c5dcdce6d30d68e9939eee7c06d5257cb99fe8e8055a6267763466c29bcd758a525f5e0252fcdca249a9a98c3b901b854141ecdc1ae513050a8bbe2c27cd8673c7d544bf89390f6bcfbf969c8d029cd724519a83596591c38368dae8985e73c9f4f9026b74149aa9d3f797b8c7438d291e6fcd94e759a1f022670d31fa4ca9b7e02ebe156f88df9128c315f853aaa527d99d2c7300e9747616fdc686c30ed9e4d39eca5d9444ef51c7ac884b3301055d0b6500e206df928a562b540986cda8b15e128f0fa5420faaae29b759350ab5db1a2bc9dc125db58fd4c4ac1507875d11cae9ce2b4887aa80e38aa2b6318d8895574c102ed885e1e01347f896b5869e4661b2340f759b47609d059fe4edf1b3ba43152c9a645b617f78f6b7f39770ebc592151e3997d08a77a141e4c7c00cac430580ab336c66133156c4ed52fece5e56f6e299fb2f26d7005b1f78e0a873a36bb0693c603fd7ae2304671f7b50c8d9b5beea55a815d1c57e0add2796b4f91ad9cb2994b12b83a10a3fa1b5490e5d412d05fbf42c89a6d4f37ad545fc198423b9b2e814403fe127a0366f941738fb7b38598fad3283d6c6c71db1b174343d8af7ed2ce7a70ce068a0206a3426eeae85e39d5938949bacc691757e31d4f85ce79ccb5015938dfbc0b2e9c93a26c7c36902b683d3c91e1b7a706740c106caef072cdbb21e91ab32e928bfcaf52d3f521e388319180c54b1683f36878939d593078b58768f7a281610bffce23d124b050065e87a8063c7419c7dbcef5bd48b0fb0d95be3eff58b12c0a2729c18a98fb2d528743129aee36f33baacc88e0bfa68b4f690708f1136e2a08f4b819a49a1df35d151cf07f79830cfd99bc02ccd0b6c6b5c86febc80f35599f5c108b544901004e590eb234cdddbe2b84aaca76589402cf923644523d01b7036be5f48daf7bf8a58c02fa974b3de12a088a2c6d7a0aed9ae5df7fc57f3c878928ff29914fc954a222231004284ed5c8fdce5d2085200cdbb29c3a98ca2480b92f2c8750b2a6c9419c59703ccfcb0f3286ce91c3403bda233018b67056e25da9035ca9c4a621c502530f73f73c972226e49402d767c02d2b091a19dec4650094a542adc3cfc74c0dd153440c4a471165b8d545f4a3d32a3733372c984ebe1a6d3ca558a050b837facc9c872fccabf31544cc8cce0a4c8bf8971fc8354f4d0a26aedb65efc8811884759fb60bee12372a0fc3c486c46036c523f584910024eeff706539f932134058e4271aec090c19b48a7193199b72eea5029ef928b191ec79498daa094261017d52e808781f916fcd04fa4401020130e10f3680c0a1607427144102c30f0b96112047789bb0b187e8c3106b8f3db87f450fd817ab00af7163b35225f75fa472d92d3387c8da793fd1fe503cbf93e45e7f1fe0b1fdb71ec9625725bf619d6b4b8b7045252c550b0acda7da0106968c5f184e426387e2077299e91fe5152afc414fc488c28abf705d96038f15d02ab3901f964b2a2eadf9d435ff45b4b224285c1f673dcba8cb546da605546fafa5e8d68b0c0dd7434d9012c5ae193ee71c30267cf2d39d72e935d43a4387a987ab475e0d925420ca0de80cbe51717aafd5ca81afd7b80180a2617be07074f7e0c588e3fe68cc5f686c747aef86199cbddf3cc9437d1e3c12acda2fa21157a25c3a9efbfbcd19d688f2aac21ae99df9e504d377939f6304e633396d26673a17615895ad0801f96264f4e2941fa00e0f0b21a68a83079198203a590b4a08ca06096f656181a050a0b4be05a991358463b3fa565405f58b47883148eb06607838bf132aa7ac7f1670a1b518009e23b30590356349ab66e3e78210b3b84ec05f3bbe5e2f477611825cd119aa982f2565c426488ab5e58c2b00110fa5e52948c865f08455fa9e7baa75b58cfaa63c775832aafb7bd0afdb6527a50a5974f47e5d39e9b32948420bbf603d51a3d0b6ecc53f951881a26229e85a777111cf72ddd369b687908b3f58269ccfabacba798d895496ffd7b4e396898562d9c6beb66f449b24d4a44cf5d0718ef7488521164d4ee73c9852c5e0a370458fb67f97071ae27b3449253b2f68494886c4db52698ffc21fa2e525fe4a103901723a8af1ae154fe36e68be8466457dec7a61a710d5fadbf0f79e3262921aac98d417b7c79209ff57d82419cb57a7805d641d05e1d4eedfa6cd2243ea171ad12d79c83ca484d8a4f2a39c92d03842abf916fd7660b322ad0dd86cfdb17fec69a6e9fd8db22d7715446b9bcd5157a59b7c3354822b11defd57369d90b057a01b36f84e8e8ec66b855d58db0a02a40ea5bb2865ae67a3e73c067a391ac8eb2e38a8087ed5e6603937d4d036e000b52416d0b552a8d54a5a86d2bb5fe5884570a3920214ab1435565e6718bdd0dd806dfe8e5f16853bcc2534677d41aef8485baa07026523bf06bf9ff163e07be33ee63c1cae9b89ffbac32e6eda1e85514cfea7f4d9349cec3efb01cf272c237aee62ea81d1f6a5eeb65bb3ee08b1c1502e94fa162b4db646ac199cdc95b042c3dafc00fcd82099609add9df6a0369ffc886db6e0cacd1d7716efbe4ad462b510cf5c7d21a09fa5b9b54b00b056e813133c2ae2f0019b2037fa5da9326812565c486728fe95504b51c27818ffcebb89baa82c06e0a29c10c7ec0ded924da886219c1fe65c4db99edf432ab0d2b350392da6464fe6b853e8999e34db071d4ec4fc4cac9c0110ad6e3ce340da8f2f2a478eaee8fa0e76e96ea1151275a2c2d626e61b8d022a4a9e1985f30d699e30eafb05a74904213970a1f41b6feaf2a3199d6b250bad81278b478d7962c601126ee12b9427203d8e10dde1fd380f3f96c441544f0d083e69ea35be64b628dc748ccb1abe11faa5a32dabcb85c3031bf3d95c0d23de78d8f3d2949f0683c684527f9238dc76f81dfb23b88a8c207310608a9bce21a44102dc12d3c817db7245f46b7fa97a32232bd01094da9845445b3392749b160815628904cf33a1b4e62280e0da4497dad2f178893601e182008f2e55ac1a826057573610df5fb46c1bef51445febeb84fc807895ad9fc2492958a9adca691be1b095f51db5bee83ac6aadd685d4111c1344755a88d583c1024e76e4a4888a5155e202673c1ca397eb712c221087f86bf7ae144c5717e88ccf86a6e09d4e4406b991d43445fdc540f2c19b252643d753ac0c7b9161fc6a70f7a68d42ca4bb85a16fa40d15bb01a106b56d1c089fbca724e8d17e7c6eeb3bf15d776401c1d77b556cc0fe82939c613147eedecdf1aeb3e27180c3fc6758ff006944fc65f727d2b16c5abd03ca85238fc9ff51d0bc3e4921250cdd555d26c7e8b55c2098fc53a9acc94963b5617596c81dc1cea5ee0326860fb0e3376913b4801d05b12591bac04c9cde3ee512fd9ae3dbd7e664b4d8468f5818c2bcef41881781190b486ed584fd8698186138ce4b7d8808a12a5a634cb2e66a150f5558fe24ff1132062dc9f7ee0643cf9c50c1fbd60cb5fbcdc61d799e2f093cb32878d40ee47a800fabebb1ff9648f41592978af7aa96bbd00a0c2af5c885f51ec18831764f1de1beb36dd048e31be4c0abfe566e8cb657dc8c35e5a32476ead438cb6192f75fa46d8abd5f1aadfb571df7b34c934899730bc7aa6059452e9a0ac7420a2c2e3642ce22d4db93c3b5eef20b18e3d79fdceea45c8b8387d78c18bd6f1f27fc4712d4cc024f16e4b3073a06fb635fd6ad6e29d4432142d74dd0314ca49cd59631f62b5d23661c3525bb1e401b1d3cd7f60d8db1d630e86010a09f4b7913e539abbf90eb7932d25b31687f83521a5dd62daa4a734109abff64d9948ce71711e1595b8949664732d32f0cc794f709cc4a1b17066de0609aeb2a373c5e03876d7dda595058ea0962bba65819fba90395cec6255e841072380d771b7072d7e715add9a3d2275367bd0d7756e8221b2d84619b574166a0a09b3555d6012bd4384bb51fa44aab003b8a527b05a654ee672ff6d215dc3c3a06d8996f770fa20c95d2d0e8d84aad0fb5937b742e5851a9f3814b6f9740b823a47ab9bb769447d6d09a8b137a7674c20da3df8b7eae64d66aea51ce215644f4decab9b3b61a68ec5e889203ffffb3364b34ceb49f0a57016cab840286ba89b56925a185ac61a4ccec11ef5d3de033a89a1bc0b468b24d2025632593e9b9f13740eb76433ba8aa0989f0d0311691dcec0898fe2c0e0378f9a53c87b81730e1f09b8e990fcf681e3375d7bf5a20b1c009a72e39f9114eb6eb28a8d829393eb651ce1546e83339f209a9cbd7ecb3b41b88f2ec4bf8626b467d4590c05ed39ceab2caae12d596e736796c66866eec4e4bb250599b938071a3aed44d1f38fbc6beb80c701edca74a18392ae33ad0ed9efd8621ebcc891921889e2a5d12638dc6c87eaa0e0e866c388bd732019ad3b3006efa1a8fe0daf077471f065433da949c1862543117e03019048998fe48c8affb991b8b431ebf9cbf597e008b1e14efa319349fb17148a6ef229c67d6e948fcfaadf5de12ca4f23fce808202511534ebb5c717e0476831a038bfd93b340ae9a3116e6083326130fe449c0ab856feb5e079d57f86f6631cfcd3dd231b6cf891ed5a805496b238fec13299fa08149c3aa762bd1035dcbbb0292125a37087c9d976bccf645ee57c797d08948febfe655d68aab693e4378ea64bbbf8e8a3e30f5e03c22e98a92678d53b0a27f7a0f644272a7c883b64fd54bc0fc4c0371aa90db31baeb31bf9b6d3ff61a2910b220abfa1d828220780ba57556e9e843cca7da55802967eb0ab77d4c9b484d888b398a4fe11778f51ee22ff23082205d2f6ed2cfeabddef08994972d1538db2b86cdfb320911dea31de43451be0ff722152dbbd7c6cc8047c07122b286cf7130c087fd3d574eea64804bcbd104fb78e4b08d7dfd74eb9b99ca7dbb379e15587baf28bf9abf88253b57c2d968a858ab73d0ec504223d68a0a78e4619fc7ec109a2ece4f8b4a2854802fa07a67258c0bc75e34875d9e61f1e8a98125712179f644907f70f71d51bad0c91da6ad0667d6da5616432173779796fc06c475436250dd211cd198ababc7d3078686ab535ad2ceb3e39a83743b40be6ac85fad8131a2fde18b6ae749dc1336140dc7bb63d154d4f7dc0fa30ba4320cb739bf01f3ee9b9c15a1a7257b2620032d32ebad1eae05c2aca13e15c28efe78ce0409124d6e25e8d9592c652be89a7e390d553b505476e059aa240fd05f12903f82c4d3a0949f86de6fd7fc389434367eb3bbb8ef13e598ae76a74f29370f090e11c41f04663a2a62a26b289e746aa3c58a786cd7249a00f3ca319f2c6a2c34ce3305d4b14c0d644f31c00ed39481a7ecd08d76989fdee4d101b5e4317abf4f8f7981323f63fba3d48fe62d4c25f717a81573d7ecb72690929d2c51110b31e3f8bd18bd21272d0b0c0b26c6a09d2908d323d98933b7da7c75f21f38ff287d30d157f141339e14e5c39ca450843e0c996af19ecb9c4e8043f80fc9e969e3c828ad805e26ff03fb384367811ad4213bca7cc9f4f1651222fc30315eab7d5ae026f036130ea0743faf4a73fddaac283afeeebc526d496b69a84762b838abcdf3f37010ae5b48ca4eead015c422464569679df3f99f13d1501a60ebd0363d184ef1aafca20965d8acc862020fcf7235da43984e9556ef7715daba40aae8c274dfe49da60dce076b1050892e35e0638f85302c91e08293f377149d6f1f54e3cba04661c85fe6592cc80d565e0931de09799772f9ddd006103f3679358cbaaa5a22ffca0c1a96db577e0325eb9a02036830fc3b5402231f40cde9a71f0b5d803fb5bf4fed05a807e1498fe4f126542ae74080991f9025bd7ee788ae74d54d927e79a171dc8a22ef08a8678f6cb662c65ac00ee53c1bbd7c4d32c14f991160caffd6f55007eb015fd80113b103efa20fe19c06a70b1e5a9006a370409b54a24c081bd5fd051dc418284b34980a8f0b55c3a014ec6f987984201e60d22a3a3e18c4a1380b440566d651a1937ad6896f911c62ec0e924f395fab566cc5559cc9eed290f564dac12e5581b17e087b631e0e34e3693d618a149ccd82e82668fb6edb1a3b384259a00aef5a35cca9122217bbe77d29d4c3183449a1993ffaefece6738e8474b7a289ec6de73165a2385e69dd9866a1e874a1b46e7571ab24bfbb7f94bdadc64ac8a54ad8a66afc73e9a473da17f50b1543f709955e7e2d1b47761f447925c8ad767cd4eb7a0e80e25a0e58ba52ccaee33bc24be8368bd30431805b24333d434d049d56133788ae02ac52124be97106699321379220e58f36f847f82456f6195603d5ea9c72061fdfdea270c0c6f038a6d40066fa4c1679c557dbd4026d38bd50857b9207a0159b69ceb090957843993a9dfcc96b504dc8520f54af71cae726aa533e5796a52965b1120dcee0fd78f80844442e466ca9e8887d4aab039992a2d9d925bf38f6aca2dd2c061901102b99f25486664e02e65339ebf41c80dd74bf08c45dbe7cbb01f94c9efc7141f31a022f2c5d6aa0deefa41d89caa1e579f969e59c30b251b0378c095acba2f0bb021945c6c500a930c294de3aed48e6bb9646cdcf2f2181f85475437caa0c4c525e8741f3aaacab928676a08b842e469b7ffc6ee6f26d4017671f7dd9c1024db8aef2c1a279db7a47862203340f9916841e8ee94c3ed09c152b1e8a916679c6249247e5864d3ca4c4b240ee3bb58fe0d023744b69811e9e3865048354eda1588fa73a89cb11ddf103eb53091732a2b1e97ecb9679c1efb53d216dfd00b8969000faf780bd3a10f8649ced2822631add03164694da5d2a37f379b2c98e0aa4192ad2837b935e0da261a8f50fc74a9981d3ed0fc34e69b2c53bf6fc3e28432858cfe34473d9a336d4a3a530982694fe28b4d3c6addbf850965f23f0240eab20c3c931c66ac4ca6699715224415e3dc6d8788200cf00cd8aca23cd188cbefe297412931ecc0684780152a294795ebf7337d5366081a00944cba5381718289827edcda681c514924c01da5fc8ccc7cb0b988845d7cfe14c0902aae5e7e31d31139fba9901bdeaeb91166cdef01cd656ce6636757d78d3b940f29a73c7762e8d3d998d9499311ccceac99f4f6b5df604735eadaf88df2a15cd06f71ad86812218ace7e0ff73c971e9c614b59ecacb6b9e4e8a72c227abf97700770c0646405b8cc3e59343eec881d39f28a92914975ec578f70e72912246c163aba6f37b69ff3bb094a2635c802cbd2249bc9220a62cc01d0b065c2bef0dc8afeee921dd647cf23f71e52236d2de9044e13d0156ae584a1a5f1d0d8389e4b9d798512142eca9d406392c65b39990cd9fab65ec7c5a269af7f615352dc499250f482181ddd7c8925af06e7b78c19098e2207838c4333fe88f05459de883a3a3ff10a53fa4a740b3960e1e4993327731fca09141688a04a25a3d809ae40299e06636f473da73f16f88ebd4623a39a2ed54f8634678390ac0bfe23f1c1286f00ee6dbe99ca900c184e2e7a983026766333dabe4dceb022e4d6298a18027a798b3f65e4e1c9f43221c416e1f1661cb979986626be13baf3554e14337eafd50b810b40887be4a2db3dd917ec5fe0e014cd8f8c2b52c03d8b3c69fd5a0e400255268c23ecd7fea668111035461ac727aee8aab30602d94e2d1fc1b5b166a44495a5d0d25a97ee3fc7365a9d268386401cd387e02290127c3fdc92ac329ab0770b787e7a53f615e35a890ff297178db836c1bb64ab4c5d8f45916440aeb637610d4cee110724700765be9dcc5d4e897cde7b0e23bcfd949605c945354daefccb32ae72beeb5934e3db45189b1982f50d7fcc03090b84adcde4664813e3cec858dba1fd804412c3dd4b41b5c628539839641a39aa8e0203f5c98420834b5268d55aeffd5590e6f4a6ba506c10d19c335a592827ab13859a31b17312c810455d6a08d50b084479f150156c99c2ca23fea8439785905387d7251896c0051bd3c84f47905cd1a336070842a445f9015c68670ec4e14d12ecd7da64787618b5fb0038cb48b01b4cb7a91c9b8cfc770f3fffaa8683454931fe2e7ca3482fa2875a9d7bc0031f33cebbd297b02579385cd13c96298027a79b900c9ac1b9017951fb9dfaa9ba35a6cd2b0abb269ea5cb090c9f50c253f7a26714313e84282728b994cc79743ff109d473caaeba01c5d6a9292ea2721dfcf5d4b7ce2ace52294fe1b16ae47161c6634f1578defba0eaed1790543247038efe73c059bb64ae44b03d03454f2d89a8727fa2e892a1f5d6b155360cb8238c905a6cf4b39f0bda53a95dfca6e0feecdcbd7dadc8e859825ae931b69e14bbaac05f4bfdfcd9fbe3d3ebfac8f77fcd5860401d6762e289f8d4d867a622d25020247060901bc74d1db1d7b82c146ba4b76d822b01daee67450bb2154d5e75dad9061cafb93e6f098deebaccde8975627a365ec2dbc8a435bec5d1e52ba4f320da7188c9a23783e2d4b486a043ab4d12e8c0d23bef13281b6fc942157d06798f33beefc8f2d8bce39063c178db14a39bf4015ba9bd306ba6e0fd8e73be0bafd7e787ec74f9e6f4c4ca15b415318a77c8c58e1d2f808cdeeee38dc07ec5cb0402123b071c647e63b4de786917045d853aea9e80bbab17655686fa98b0a1b36249106ba0c46576cc45b12926a7d97913e27b79b94d9f2bdee1b2009e292eabf3fa4aa584deacf85ac2fe39a435487ca6824b4f859d9ceff2ea245918b889b64e15d51945fd2d1b2f1d0edce9be04429119a8c0e160d2fae950f120eee8956ac18ccfbef30aa55695fd1612a633b6ec2bd01d411eda9cfdcd84345172dc9db8572c67242927b4ebe04fbc6c8f97803efd8603189a0c56a46e651e40d0f9f701ab988087a2a9d5509ebd06678e3dda3e6748945b85e24c7b0d8bda7ad5e77ecd64b092e06aa832f8794ba2941e5a4e2047643ced7f7574a8bb36f8725c5c4a1b42b41800ca331a4846ca1da0f8d74143c712743035d28d40fe8981101ab640a54e9948b00507ca8e82ea35679f9da93f081f38c2684421a848953f85666e2e51b362dd4ce961261ad636db38191b7bd66e30e8e24617b0a2fb5e82f436957c3008dfdb2d2a225b618b1b35d8c3659270615caa215bd06ab77fc4a33b4df16a5ce9dc0c2ed41492c8842113f6a99eda99e9607916d6f2f4967e8646948b95d1e235cca94e222d9003f12d3fd9a4371a9dddddc5949b3f7a29b995fd002039ac6e79acb58505f70002b5441205443677ef99ddc4afdb27569572e80bd4ad730650b29bca19f15cae193a37b72088af0bd7ee1428751581a1d93fa2073c16c7b94eb6141223fbcc113c3d8e6170ff552904c3d9d64976ca026e01449475632ce6f91379048d413a6d4561945261ea3ada4151d970505161214e7e2446d57288ab30532c2b6c557332ac082e9fed0b2f6d5d81347a415f5f6967a9a1541076989a7e0fc2fd1dae097a7fa0fff67076de89ef0ec0392eb6359a2868fa881d918fae3cb4b921e170115d3fba4a14c201e889b470958767219316046d368fb4eebe92f35c2c6de163c821bcaa265af8c57815cb9f6458ff52526f65228745866ec59c34bd9572145ea22d7e61c00deffa8a5217e0d8df64ddbfa22caf50be2eab3e1057d74d198aaf688fe2d0b80a2019f18b30aecc88e9415dbe1ac63b68c09c72357bb97df336d78d4f4fdbd8bac04823ad9065461edfa21638f6e4671e54ef7856abe615caa8589693611ba798bcc8d2f7f8cc45950077e1d773f6ec28fc77affaa0b49bc2c8a2b6bd0904fe31f071f6622cf91ef5b5c3249d3640eda9dc55f95c0009d4d79c4cf1f97a2d291ccb438e976e1526075cc6ed8ba57097a44df5be4237397deec0815adce3a08961b2576469bf214c2a10aefd238a0660d246bb3bcd4767bce16b6aef438a3e6c78106f21bf260885a378e5dc81bc509216c0900486846f569d0717b251413427c42596166fc460b1c6244803ec69651be3fcb8f5efdbc9d6826babf34f3b0852552e2e63b9b2b178161a364ba2881eccec7d362b128c76f6976c441d65ad8b00a519cad1333ed8542245775890c7db5fc9654271eb257858951d822d93a31682d2f1432aacb66c0b745b7e4ba6390b936cc188416cdfe898966592193a55a32a3be58744bd4151f392b61c62a4471b64eccb4170a915cd52532f4d5f25b529d78c85e152646618b6463552d98593b3c83a180d115c3a2a1caf08c8cbedd246546da4964d4e4ccb99228373260fe6499f92a8a962096676e13043d806206cba2e8dcc7dd938118c4a8d8ad9f886351bf0d79922bb5b6a657dbc289d7545c74336c732ab2629d36e1c315aa26730ed9da783f08020034153f3406bd21d0a681a890e4a92695a18f96c5924bd7fdfb0f1762d83102622d205c74c9d73fb823828921de324ca274dde391a51af618424ad1260c072976f3119f81e6aa99bf99d762c566e3be04e6a9aaf9819e3b221b5bde1ce2ca81427e0cca3dba3f06951f482cb6b87bbb24ea99c1c3584dc896fc38b34c95aac32f223820b9af03f269efef40385683bf50840c5453788a638e9256271f3a99658cb526111299b5c933e2e36c71e1e2eafffec0411c6bc600ff4eb8d2a8c043deb1a638bc11dbb1147b308cc07317d246870654124e8a79473410ab2891529ec96a60612a3488ea658b5dbbae2e170f5b5882340d68d0c708da812774abcede06890f9b3c3d5d58e2415ac17c5966e5ae216bc8cf016c966077b0dff7cee76b8db1c828626f6c515672ab946e4c9bb931d1d39c2e853ebb700514673a8d629bc5fa1a304775cefb008c2c65da391357c49855e882cccd40a3868414f9db852d883ef461d2494b35e09e59beed636615a29b232da1fb7ed3d3a4e51e3c7305292f5cdf779e577bbc354311bb814559c95dad44237aceed448366ba14f5d8c329ac80d5318add2ceed3c03caa336f077064896967995c2d862c420ae53707fa9aa453cc6b27ac60d4a08f49275dca4077e6f36c8db55510dd8eb484eadbdb1e2495f7f298aba57c73e5ded93ced639619442ccd2cca4cd69a728dd172b7267a3452a5d8c316a6e0e24ca7514c93681f83e7a9eb1c8a9bae45a57bd7fdfa017f729830c63f854594ae3b2bb2d5c3c85858c24c0792f8280c2f1bb31388b196af692bc58992c972593b810cd3ecbaf642dc149a2d85f9f90830cadd6a21c447e1d092589d4e10a65c7d4b494c548c2e8bcd5904b1cbd26a93e246c1dcf24c9d460e63669d1621568a19047fb163b8cb5f2199519fcd0524f72e7cfe1b6e043033cdfca024815596a2134ef2d4c2905d28c26ce792b828982f15b3f3083196ab6921c58f82c192593b8d00e6dcba9642cc541a5986edd90860cbdad61662988df3212857bdb97bb992566012ef5b501ef5d96eda5aaecc54c4d74039aa66ef8ab558b9a9281fc139a9f53c2c80dfedb7a067579664af8725db908599ce45f153315f52e62790633563d7428a21a5a3e5327b2a11c6b9f6ad84f8a93b5f0af3f3126294bbd9428a8fc2c125b33a9d40ccb9fa96a298a9185d26dbb308629bb5d526c595c2b9e5993c9d1cc64cbb2d42ac949d5f82f159896390ddd92ec543f1c4a5b29c4b2a8679ed36a2d8668a32287f8564a3feb3e6aa89e2120eb4f69a615935e9239445eddbec238906cd631f471e8699d50ed164baa561c6bad2e8d1ee27ac47f3a07a373d1cb1837fe579927d1a7d456b94c8f32e1d89961cebb2ef68f2b9980cac446bd47bddf3a27ac983335233f3ccc1748bb6efdaffc1508bb3f27cb70f82d1694aa3523eabc4caa58e77cec7391f3c0f63f7291eb95e55a40babc89e6db8bda331736e1d9aa378b1c71cc676aa01b982d7972094da28ecbbc0d3505459f1c51912c8e3f412d162e8ffc8434039ff6fa2347a9272a899db697fec6763ce049adbcdf350a0237200f4fd8f9f23a036023224ab3f0e3dfb2f0498c4375a0ba7aa50ed17d52fcc365e93885d021e06024e199655af86092ee29ea072819473ab914d572bbe3b3fe7fcc6120ee2a8c7529e9b3d90f3181a0305da9349ba609506d0a8fc29714fed17f235d05e77f73a40b3e4b6b6a54c1bcd3d6133e41c6503e86d05f23bb38e1365771897a51c7208e8c8682819d1665281d7cae79e3972e4d16eccd34ab892db244e208df3674a3bf5195c79813ca23cdb399c50237922c3be32876fb5e6bc14b2cd0edab284cf116d699800d87c9ca6141eb45eb40d1da57c59fae13b7dfdf7105b1ac9e20c2091bf22c7143b655757eccec4d3a84c296cb837ee6c2f8f4d5816801235e091a453675c64ac8709330b4f2e41a313493c4ac79697e124d29873c66fdbed8578144d5d1a83d3a46197a56d2d8985caecb23138471473f99a3652fca88d2c9dbd1384b0ceae6921c44fd1d0b2989f88a8b1192fff6eaa195d7f03bd74e801da99e1db2ec65041ba35c20afa7759a3df659b74d5e277c775d6680f71a57475f5ae193eadb115cc45eccd95c94e766df28ce8b236032d9a1251c8671f9600026ce72426b348df02f2a9cf7713c090a54b9767fa6a58b10b5588d91ee8d48c86024f5b3082d0873d061d69a905d89bc9af5dcc54497267dc22c45eed7a9e549cc37bae12d59dab3bcdf0b48daf622c6235ac202319ab92324ecfb71d68d04888223f7bd88489b21d2631ccc57d1694a776d6bd089e2c2da59c092bc284295c61cc66a05373040af9ed8213441bec31e8a44d17c0de3c7f2d71a62a92bbd1d6d07a6fcb6372711d9eb94ad42eaede3787cfda286397328a9869282904d96a4b64ec93797172e18a62eefcec609f40282953146e64e1c3ad31d7bdf86cc21240e35794c430572c23b9ea4935ec5b043f4bd505d4ef5d33f85ac7ab30472ccdc57c0bcc4b65ee7e089628956a3e13aa61c85428317e7b4247136a8a796cc00b8c0ef22ce99752ced4f5616315229d5735c44be9d6b59db3789a952f851b6e469dede1670f4f108ab752120b65f34b132f8a554a92d818e236c11e257704e4c7ee7c7cad2c8eb2c0ebdeebfe7ec51d390c0c1faf62342fc95e9ab26d6b763542c76d3bfee28d9381a409ff9cb1b782863204e4776117ac1101da286f34c848c1fc485d8c9e2f0ddc063c209b6c8497b9526691be02e6539b7f2b80214a4f2fcf74d55863178a90b53dd0a19916051eb6b004a167881219c3daf2d56e9ba20fdb90a16c8fff1a612cb76b65cd719310c8f96afa78d56d57134372061aea52cd08c573efad10d196918fd8708e00797ab88c48f51aa14932e6b14509001a278b89807c4e7a00c5d2923f19b03c5802d4d729f27e58a379a4cf45fd3adf37313d3c8f156d88b4b340b80c4147199373a3a328fbbec8ab01e6f660dc0351121a5332687b91b7701bba012db21784245af04a034323e6adc7ecb0fd82e8ff084a4a8a0b23f3ac3200edb8c2b91dcc0a91f997f93b919bbd3fa553bafdeafaee5fc0d760f3bc67dc01ce5039b757a5ab00aa434e4e3c3d479bda77c5eb6a57bcde928a7b1a9b59e185aa781ff8730d4230796ad392ba32fd79376443c5f6f9561209387c8a4aed4087727aa3dea6da70cdc305c10bba025407d59cd53b23fa6c803bcfd4aa067ca412615b0d106e252d380c818f4e7507523d85e99f1ac103c9ed5180d3c9e87c6f162e0028094f9fe43f4d6aa3b411edf4942ebbe5a7ef41594873c6c70ce0f6f22daa800e5c40b6dee59d47819eab1e399d53f0a03f44476bf7323ae731639e3e616c1ed9af9a8f04e81e87d5e996b34ba39396f37639eb9de1ebb05628994f76c619b9e00eeadc9d6f0a0ff01000981a9e98103ebc01e26c52f702742ab0ffddd11cfae1cbeab89eaa29a5535c78265d92b4ee0033276403aeec1aa5ad93473ab027981cd819809cb7d60232239c2e59d192f3bf6f08625587d6f839a8a5cc27c89600573146ca6a5ad6687b27d2947c8d119be11c15ef49bb0c246131856e9b6292e4b5f22b58773793fc870ce5585b0e1a75cb718f6cf98561bac86d6b923d54835d1ea5884cf2583a925d0805c6726c7e6927ca4009ba6f3c0a3a1431601c1a1a542d2688627dff3e66a969e8106974deb1d2785e6ac36719c3fb614a6249f6fb9686358b02f45052e34145dea76db8712f97052c43b8fd9a21d5a6747dddbdd8e4c89c02347c84d48e7644a637100730cfe20ab8850792fefa476b4fe357fd6ba445e217777a397e468006201279236dd605a19e9b23e6d08a9fb30bd98a35a60389c04d5feec860b4f29164ef14d1737937eb31b842e3171687c49209f5ba08f5d434a9c8b22e6ea9903a1384257c36c07e6135270499a0d685f22aca435affba78edaa39034dc629acdae5085800198881bb288be4e28c3c5adc7e09b2fdccf410977892179b6937dc9e8957c8761af6d236b6d1a22667b6894109382300f1b6502dc47f40e840fe937e8dc55e1c6c34f1acfaeeb0b07834d7f0cfb3aebdcd19c051a8621d48b14be79c54c7980a9f7082d8731e28cc287e7fa0a1211c6eb859591e84731b90ab8658db0f78dd912c49479841cd69ffe4a16b3d7c3848a7810be51bc89e89c98958102722e448975122965b747ca3a6080c474be147ec066df86af900ae9af1708cafa03f7e45ca16f2e6bfea44ceb95d7675d131f586ca46b5de7c00735da79dc9d3304e9db774a1727b92bab33cc6a27c2540574ebaad046740cb7076032b8bd6658df3087f960a2f21924d8d0b224766c7e9b32d29df70c956c16f9763687b377ea1e7b0ea7517e27a97c7af290663d20288b602aea517f9d32b801b028f1e45512428f29995b5028ba91de80d869a1ce215dcdea78e3dbd81612f10e8f1586e917ddec4377832b3e6dc1da2f1466d1f49c25cbd185c5208c31372c82401aaf85542e8807d0d0a19142bd0ca85020046c6f455afafb19382333023192090b082fa39c06ace259e0413eea8d207d51742f73e09c891e47c1b7e01ca7bc2f40538e73d7fff23b48953c96c14e63cd404d353d52e20790b00a485f9193e66bf66eec1fa3da016bb174c45685e3f4716e33302e4af778e2be83be6133d9689191dbdbc060a7dc9e6dbf96acb1ef440473acf0822b021f81f737424c1bef5686a7ca7d07040a6f9bce45910ec73c6598fd1e26baa228aa8dd93e97a3bcdf087447c7114b7ebcf96a782c95896852bc4d1a529bbef4084b2a8380af428dabe10d081e18afd72ab064310fd5ed4dc1495e30fa84d4432e3a93d2e832cd3f88e12782ff99c443c975915f12fb09786a45c1ef74c94d3531ed98f8510585c14ba9e6a12fb6741280a7586d7ffc527782d1ac1172416158ca232f6f85a5acd92bfe9fcd0fb4f20226fa1d7917a1a54ef34177a155444bde004e9a53c6c3dd999bf5d6b6756269dbf9b9bb78227e45e0a9e9d42ba169b55544a6f33941f9fadf72e49bb1f6d4277dd6cfdec1ba24b5d19edad39629c580198fa80527c1a99093583beac72033acb3e8d5a305852a503f6bacbc27404d4da590d63c601d25ca8369b8ff4ac748428f04c6a665109774bd5fc8bc90536a007f20f0983c1ed8bdbdbe317c7b405a02dc51350246c1187486cdedb5360e2d1c9c99764efbdf7965b4a29534a018108eb08f1087efa62caa7136f18a69261c3afd9eccb9bb81ac248955f96937cac3cb3eaff4b2ac6e898e921e406dec17dfdaee922be4af9fa15e05513010261a944b0b58968c2ad9c860ba7baf4494eb1e513a3985714050c513d160c6dadcff2718d5f11966f4879785ca6850647c0f5479224a39fea761f071db173b54fde784ae2c81ce7b91c2403a32b73725c26f49c2b8dc89b238cdcfa128732a3481c4f4d9c79336f3a97360170356e0ab6566b51a84fa562bccba9613b0da458ebd647e2a9ca6264436c0d1b566ce8d6c77cb01fac85018514e8d6a73c71a5f2ab95af4f7be28ae5eb539fae09f68964f9e4ca27775c555fe593375165e439a7ee8b3794c753dd5326943ee5f1550b46b427497dfa435bf5a990cb0cd5a72e9731ddfa94e888d7ad4f8ba85147e58dcb84f146e2d41b9c025c8d4bb2f5f9f61379c379d43ed349fdf99a47483e71e53b2d2442495c3f450e64746ba5200b63d839e4299a13a717bc3a811389e6c850309c40b8d5737807fbaf2692cf17cf3cf2547d18a460d953fe3b8093c7532dcf89abf67155fd5a2dcdb9553ab9f57dc773baa38188831309e8392e23035e4d17125fcd27ceab19c6cead3fc36027b77e9d44c01902028816f9b975a691c45e0ace2386a9af3264c3393423031bc619e86b3f875c269437da377fa40a2615d8d07356ef3abee3325eff74cb65429706327dfd1edaece7a6cf757cc753358749fd0964c1d9f254754d229a438db88c06c210054b9750c3b9d35ebd0de4a9fa5ed8d0738c78d5dc48e7aed33e0c53df0597e5db379c3bb7fefc993b8ec47d5a422ec39e276fe64d8ee49148648f4f2baea490ab28aeaa9144922f99346bea4f9bea751d1856504623be3a7d2d7dfdc8e332f6eb47242e83f2d5f46c02c3d8736b7def8b37285fb45fe4f154dc89465c55bffb624ec4f1548d82ddbacfc553ded1a03c95aab1d4039e427918a67ee9a3483edae3aafade47dd0986a94f9be01cf56fbcc056ee6b6e9f5bbf7d5c866fe4cd8dcb785f3fe2c4faa23c378c37b77e8394c753f5e9479178aa7e579f43c386f3e8d6e7ed3b92f29ef2f3a8fe74e2ab66d5d73ecf88a7ea735703565473bf944fbaca29cfadef0520c9c62fe154c107b63ffacb386f24206f648ecc912f9038f246e6c41dde1bd18d4de4aa1b485822de213f4eef9aeb927e47b0d81ff2193792c0891c28867c8611c3c4df6a609d8917f50f51bfe20a9b011a4d8a3091c2113160c517245cf1039c18b0e0288815dd688a6d6e5a4e5c6d200f5a92e58161ccb0210a3529d8ad1571d57c7eade7fcd5a6f506528055f3a7b67598722920025e693fbf8de09506f68fabe60f35d09df3e74e0acc9fe13627dd5e0b32a946332cab3fbf62d4e49a37d8f825f49eabfd1663721cefb46f53f30e2e05f4215aa5bd66d2fa6547e3c3dd53c07eb94a7b13c8de2ff0c53bb8eeb8cf850882ed17c368df15c1fe0063f094f6d9572fe26a7ec32aedd987dbd08db0c1531a27af0cc221d90fc4db817ae5b3fccaaba4f4934eea97cb70dafb4dd1a763765e1393a24afbeeeb27fdf2ee0bdb759dd7752cdc222ce00a68dfad5b95eff495de8d949875fa9855d2bcf70fab2dcd377d28d94cb46fcf03253704db5a8ce7b84cd71fca538f4269da6fd494d2f1a77c6ec455da9b3ec7719506ba109c634707ba0b1846fb300118a7ad4ccfcf694f5ca569db9662ea5e04bc4a01db08d3d675cad646341abc32bd660285b84a7b46622325aea63dd6d570c308d65cfb70d35cc789ab494fcd6a7a0270026cea01180136a915f7b09961995efb18ee6102ed6f99e3784afb1897f11c4f691de8463cd5cde05d0ef41b86d1305a29a37ce92d8af69cc5fa3997e13ece5332eb68b6ef3eee635ca67bed75745f8f2296fbeebddf6847e3753ff87ae0c953dcbb0e8a7bb75ee92dd6bde3b8cce9068a8fdd4adcca6f5ca5557b99eb80775d2aaab43f75df812ddd7b9cfd12f7dee7e0afdb812d16ac61dece6faef625ee3dee3bae65035dee0ade531dd504d20b09462f2418cdfccc02867ee88784005900036ab51c70090902c4862123a00d6baf158c71d06f6018ec63e2aa021ec19a45777115a6c29e6b1e0ea24430c5c32cab308f147bece777b20c63f9d51e91c0c22afa61dd818361680fc68183feea9f0508d66b2af7829a5590da37e2a27da53a2ea53612a4b1863aee2baa6827a1243875b061bf2ea5fd6a400bcb8da28abe0f1f62c34874e947fab1c8575ff3ec32f4e5ca8d5c451de952ea460b608f46f28b996532cb3aab599665596735cbb24c66d9cb2cabb5d6ac665cf65983a82ccbb22ccbb22c4b6386032b4ebaa616b1d6c2c0c4e88830333d7078366cb8ccf0365e521d1dc530cecd436b81fcea296e86c930ddcd60bb194e0cd3bf4d6f19356f06c93850d7e5954aa2bb7b13b9610be1eeaedd5dbbbbdb2db5767767dd5fd6ddce99fd3de432213b9953a8735a67a79174cf4f0bc8353b071c1c1db848c80d35fb7eb8d6bafe2c3b362a61fb37d9dd75ddedae01ce32bd8ef6dd6ba0df04d1b6dfb427c28a5be94ba5f7dedb9e082b7ece13555c6d09a23df7da73d1f4decb8f9989abee892af9ffa98f315faff7358bfbec7b4f843583f228600f28f27d98c0ce89aad6699ea892efc28445016b65b54480f3c172ece4ca5f0979ba815e754e54dde4d03cb81b05568d2b4376c295317677cc89f1634e045b3af6c9cad27b25afe33aa7753cae3450e6852b3b2342dde40518b2a7e3c2ef600cd1d3b161bd0c3327c5383adde9c9ead8399d4ef76fe6cedc6d72f38b4f3f8961326aacecb3a23b3f3ebad83773e5c740377eecbafefddde629096b2996848dc191ca34cf8865d07aaa1bb20cce49dd5d094bbfd2b02461d9537782df2561519e12f6a48475f78cd8bfee25e119b19ebd77c31e018b568ca3e16aad9ab66dcc1ec7752560f61b8404d941fec9c6e0038909c486e9e00f6de34e1bc7b944c577e9954a281c8e6bddd3b19bc7793aeed96ff74806f6b003ab821c55fca8a08d5f36db35b1f2c5df53f27d469fd367740fb3b9ee6e4a37d777a485849845a5b491454e2f743451005cf367c057b128aa3c4ef92897bc913551e5b228ae2292abfc1b2c8a48d189fce2eb149122120a652d0fb9b16f523a1afe9adaa66d9aa76b1d1f7fdb1de99e56a93a1af938b81827d56ab5b2882c01f17ee01055fe5d37c4533c1cd181050013758e98ac2813595c7e1ae6117762e01df5519e634adc6f28a0aca9a9b1254e05095bf733476288607b726abef6659c9a9f7d1da7e66ff1c6655038a582b3127634ac701d0ddf95b288a76c648d1ab63fae5058b583fdf4e9cfbc63e75ac0eb68f8a2f7e4e955b0b38e26ae3816ffa6d2b2aa499dcc554e40b9146a5be5cbd4d4b9f56ea5c8a57a708b854266e2d4a7bbbb5bc7fcc6abbbe7deca3eeca11b56d8aeeb5dd44c5cee1741b4608b29c628720456d848191a4e50a30b18cc80091aacb05f25b86127d5845e24f41bc771233a3c3d3ed7dde57de8423e646fe8445ee4468ee4afd287fec493aed7140122dec49ca81379503e8c483e8c3ef187e58611e87a1885ae3fc7a2eb46291fc6a39b8874fd159fc434aecb9aeb2f6d6edc50dee45c0f652875ee879207c9f51bca244462d0a4083fc4000543bc48c00aa54fa9074b0831860eb6880215ac50b648704329745dbaae3f87b2e87a288de491747299682501042b98d8c98215cad7caa8288814a02005477cc10a6552cdf50fa7cdf570c612b0c27973ddc369e4faa34e1725d34f7471fd75a8410f0f1445ae7f1bd9808a9c28d0b8feee4a22858d1458b45e70fd635210aebfec71197f892483ebff48a6a8446690444e133254b0a40930881c615473e4a2811455f4ac717d07565cd41517859ac20417f52b1d0d0ac5235e9657e968587c8b159f25dc152deeca8a0e7ceeca0e4e7057fed4d1acbccf1357e5a5cb10e0aa7c4a47a3524f6fea684e7dbaedc2c20d5f70dcee8e6929c6b8dd8d83236ee32009b7ffa9b8fda9981c30b9fd33fd3e725084db8fd2d1340ba5bced6852fa9a92f4e09a5e9aa408e29abed4d198ec5f94f73a1a1419c514aeb5df7534b6760d4d497aa71e377409e3862fd77b1ee37a2f5d26e67ade0d7eb85ed00d8cae1785111a2f8515d5dceeb58ea693451c07c51097e382a06872b99e292e6703165cee65eef6b5a3d9a4a669da07d5008babbdd4344da3d178c00416ecb0b2cc0ae1d697f574861334d0a96161969e42974b5f2e4582c5a540977eb5f48914dcd4ca8b48c19a5f6d5c559b20244874056160e387d5e646b047115b6d6e579bdb3ad7a25a851a58797baebc55364b3088cbf8fd1157368220083fd82c9105106c8e94e17a824d931c2da090a40446beb87eddddfd94042f68e08422277c70e5d71f619080070c9b2628e13ac291285eb0c60b863062478deb4b605073bd7158fefe426e707777ec85cb50b8f2a5fc4a83a12b9f7634d2de40cad085678902f084719b68e2facf8f22ea3892c50b47ceb8fe12c549299714718413c4951b49b972a594524a90abee2e5b7c37c4a1e3fa0d7bb4dc908188bab8213301e386ec84c8398d2e02c4f567ef1d1b376c24d79f9b703d8beb5fedcff547e94ce1fa3f12595cff14cef58f9991e2fafbe0e27a12665c7f20429ab8fe439488c2f5c761c775fd7560e27ad01251a819b2b929bafe9dc3414c08e17ad0911a5c7fef49c283296c28fbff256580eb7e3d2429feba5ef7f05780797492cee10d01e1f24f8079f4d08fd3f3df208477703e615c7e08308ff6e16f00f3685790f7010435ebd3d4ac1fbf32ab2502a00f2d41b297f499c55fb5d26bbff99792f20066a12c0ab4aef2ba39960f15552bdf4795f72a5ffc70d0e187102059f794dafbf629f57877ebbe94e7beeeb78f7b946ffbfe4caf697ffa7c308cf7a52f642b9a07730e7fcf4336ba407cd52e5779445833315f4a7733f88d81fb74cc308c87f279d7b52f3c000c08b8edc2be26ea1a97aba6c8fd992b631d8dafe063c37679cb7b2feca13b94c4615091f0b09f389e53df8bef790f78c5df49780710efe8de7332aee75f5ccfb7b8deb74fb76ce2ca7b6e2b7d21c7d7a278efc3f9b65123b5ab8bfcd5c9a0e662bfade44f090e316afae1a92756b3a76058c2e8b3fbc89f1fc65c6e57c4be5b9ec2be43c3f2c5347008c3608055d8676058ba18f65507ec79c07e08f638b8181bbf84f2e67a7586be1de02f69da7346c30c93bdbbb8f7b18605aca3e92142035c7e02308f268273782abff5d0e12bffd0857b5a79fe1800300f07a27378cfbcc3f4fc8c430e3ab84cf612880ff3ab104cc69608541f5a82d878fe6d53f11bbfd9b66ddb7e76341b577a8ecb1ec02c15d0fbd2774405acaef2baf4f5959e123224aabc8f1f0f51e53dfd5a7e384495f7f3d34185af599b8df9445827ec83540cece1890c0c82fd047b5079ec7b387d7d22f299759a534e1b5f4bf6d833ebf4b56420e803f62a5f411f9e0882bdcafb50fff4a7af1f0195c7bcaf9f977dcad78361bc477d3ea2cafb6de5ab6ffa82308cf72c9f0daef288681e10e01c43340f04700eefbd30aef7a17b0ab8de10d7fb0dc3e17df8e22a62ede032f6f97970f195df4495f7fc28e6f873f0550b07cad02c66594fe53d8a06b6850936b49dc65f8f0851589104115e5268a286651fc52b091c31b9c2c60914a8e087659fd97e65fbb2a3b12aeffb93ce993eed59befa2b9fa3803f3ce57dfd5251e5bdf6c5308cf7fee97095f7d9d75f4880ebfd0a4fd81f3c21e9ca1a97093b49dab84ce840442397e1defb78e432d97b1f91e26ae5bd8fafb842bd67e33def5d0c5eb1f7eed36279efdde532da7b2d5ec43bfa7aefde3fea0cef99431fc2f5a2f74ec4f5defb268277f0f5e47bef357135df7b1b5ff5036c8ffad855db6b2c1fbb4afbedf4318bfb543e66754e5c35abb2f732ef665ee665deaf7c9e1455de635f4b56bf960c6c6940fd958f00f62ca00f2a8ffd0ae8c31341541e7b1f4e5f9f597e9373bd57f9624d54797ffa64f0171ab685fb505eeff9f2059f7000b34c505a638d35d66051b6efddeaab6679cf1df73edc7edebb8ef7cee3bddf78ef39def38b076a40de504f69052dc9598273396849112553b8d9e520254fbc9e5b4fcf6f87d4adfb505e8fd1e905c3edfbb9f711b7ee0be9779dfdd6b587442e6501c9d2cf1ed34046b1a74fa488a76a8d0dcae3aa1a8560181de2eaf4290ed69606cc4ff908c83f1d89ef23cffd9df114efe840df08c678aa37adbb659cf23ed95ab8028b1696942e6ff1439220a42025474a8cb8c8e1c2e6daa09a9ec43e223ab5de7dd0e3039ecb413ec8711b1f1479894f8e6c172f61b0c5d0e5a02d7e6eb581cae5a02d8cbc6c01845f0edac2e672d050d20de56594cb414347414344414359dc94cb41434918934a6c5e0be28a9fbf8d5fb6cd7e376660431b9b3b4a6fcaefc7863aaef497df05c1dec11e5ca0606120aa0b423fd2992b5f87cb787cf9f645ba0b62e6e60d850de5e5e673b186feec67e8cf885cf98532fbe4fc885cb9835f0c2c40e788ef23521d57deeea60e4f020f2c939362b586608d9f2772946002e90a160c3620c3468c35d638a20c964f135cf72f509eea9caec9664e804410900bae3f6391845bba1c8445106ca4cb25dcdfb1ac3fcbbe78e34611a77b76cb8e2797f729e594b15d061394317e339e8a31320cc71863fc1b9f99ce493789d10f01f6322af9b98051f00370f9254697359339a238000aaec9841ff1bcdaf3c7a75bc499dbacd9f36b3f3f7eed8b379d63826e549fbf39bfd688c35c2f3669e4e4938bcb7036879738a588f1e3abc072636c16dec13a78aa8778aa7d47777f00113204071dba1f53ca1b1f02f5ea8e61d812fb7239e80a2d6e18b386fdcb41573411b9b8c288a22b8838e38a12e4c06e4f608115484b0441c76a9783ac20f21958216445cb8a183c0aa3d946dddd9db0dfe5a0161448606f5c0e6a8d31a5b02a5c0e6ab57e6059b81cd44ac271d06a416cd994cb41554881882a9c545f758dadb75661746badb5c65470c6c6557c5373ac0e8ae77b523eaee296b7bc0a970a3b3c3b3d3b3e3badecbd0436bb1c544516414eb80daccbe5a02a82882db9c68a113b462031c21a513f265281c4a21233b3049225922cf18341818a3098b025a19848858f35c9ca2ee42a76d5268a284a09154e005151041854a8800767a03c9d974ed214c276473ab0a52f641ad6cb62aac06e3f9e0692222ca7e33cc0e1b0981919241d5123837850e4c6c4b09e913275ccc4ccd480a7063d3126aed87f9a5cf7aecbebeeee483ca948a4e1aa0a863d5d0efae1c295d87a39e8270b1b6b2f07fdc42404fdfce860584667d28a183150038a1bc6b81076db912bb02a41c8286c44430d139cc06e4968d82d09318c29846102fb977b30851cb80b6c4986295e3d6266b85ad4959783a6387243544b0889cabac1304a196b45a1503546666614aa562cc6181985aa15ec8f4ac9ccac45ede2f28796f9afaac270f93f14aad639232a4619638c911987fca28c324a19b15a7995bd04e337473967c4624c44c5af1d4df42a63ccbe18a594acdd206a8f7266934e9a7118837d5d83aa585baf3546281fad56a418f653466c0717805fb8fc207fbc236e9d473d904e39c4a89f46b06bbab218dc05ffe51553ac0ed1b2bffcdf42656e6ff5d16ab5324db2f538659c5273e1b371516ee9d95b95c0215105768d00aeb76ad730c1f6631b2ac6a6ee101f136cf573a0f538659c92ebba838100973f5ebd8dcb28d3c7904759b0d60876cde43824aedabf6b6ab6ad6bba8677e8a49ad84277b7dd734e5b694caad6fa288fdfff23c8104ff19c53ca19d9ddeefec3531c636ca1a1c3f8524a39235bfc3b461aa2101b24374f8e3563d3e32772190c9b9f99539ef26f480e18e75f688310777777f7d8b1e3f3fb3bd8296e539ccf3746948daa1a552d34f8f7bb063e10ef9110609f5deeba63fc2372b748b10f0195324a10084d61e047157f2a775e209eba5bf4d81ca717c3773799651806f630021605790491c874952bb29e99358b49a1aa0fb921081039b1f82386191452cce5212a638c3d8070a4fcc0f6941245c13046967656ac4a29258d31461c0cc33682a9174f71c472c061082af69c150c2b0686968233ace27faf4282d8f0237ec718a39c2d65fc7aa0ccb0524a29a5945256149219293f00da58d334b08711b0323006714a19a7942bd4860a2d2e2bb8dcf80f54bd7024d6701e6f5e784100ffd24211e832c36584f4150551f4faee88239581e4820b1d4dc491cdf888e1870d4082985052fe86f3b0e03aaeb342cbdfa53be23e3e2a18242041649d31a1f4cb28aa908a82b0711b1b301c4c47131f66001c10bfc67ff258db079be0066a3a994ecdc161d8d777e96ab880d7187d9e08c5960f80ebbc066b882fdf4657c305ee77650e2ec6e364ac1dd8d2cf176c2d18c65ba80545462e5419eda2d1a806fad8b37434d89c347e9109ca8485ed466aa498988e4612c0474639e38a1c82cd116e54ba158c604f2533bc14251d672a230797a3a3890530953c193114db71263016d560d51429ca1350ac2d99e19594749c5706010cc061d127aa9cba3a87479da8925ef2506cc7f9b89a4724ea1cfeb1c855fed6e746d72dd289454ff0cce894706544269e8a47aef22806e7f07f72fd9dd85c07420443867925188b18c63fa58b589483db0040b46199c4e626bb6e09b7c49a50de84625f254f888e6b82d1145bf2e4a4d86642e9b89417b6d1979c2f138a7d953c213aaec9c4ea16536cc933a1745c4a7c9950ecabe409d1714d26565b44195046a4d222ca5c4219115659668b28730965445b3637ac4649396ccb2af771a4b163c6f3a321595191d149f6c5174b44e2f9d17c7ab49faa4d8ef3b8ee59857df731473d8e62dd9c526e1dcb6ba126187d49494b1e8aedb897a42f29a594203b8a2dbdbc251dd704a3a6922727c53614db71a617b6d1979c2f145b7a794b3aae09b6695934953c14db71a6f842b1a597b7a4e39a60f437fa1aa59556fa517e9c9b86bd28a5f4a3fc387f2b6574be10c4c62fddd1bc2627c56a4637aef3b8ce33a59c5456585036502d2e2bb070e3c116b8176e4b3ae22fa157b489aa9af8f202809c148a453d0b42aeebbf824bab155f31a9a5a30112918cba235ef47d1d8d1492cdf888e1870d4082a058930a363c07e5372c3d9bfb1c711effad05ce05ee065fc596a41818d7f917c03c22910dbc438b2bd3d79819146b428aaa9512d84646d20688ac1982db4edd914e4a92146b1155a04aa4d222aa2ea14a443116d922aa2ea14aa4b90b2e7434f45dc0e13a7adc14cf2af26cefcf592a2e7fc63ce24fe7f01d1f4754c4582cbf2bcf4f86644565a5a3018c4ee28b2522f1fc643e3dd90faaa301bcf1371b5836821be36aa3acbadab8eee3efe3589b4a1557dd64c558c462adb3e3dc5c05a78f64d4c295e47a5d0e7219b9bc7001ddce0972e18097c009729920880b25dcee2db838ba1cc40511174ab8004a23a80867686708e772d05091db39c10993255df41225576b2d60c9129e030429710d5d0e52f213a4c4e77290129e7b04112d10615bf84f37bb2d0c729016499783940071fbf92b1864b890e1a2840c1720325cb820c3c565eb96415aecdc015c0e127a72b7ee52bca50f87209e9240806cdf955d09f9ecc7c21716fbfefa2117d940e4ceafa073eebd038ae9344f60a38c1e29859a3b38e1b2681171905fabb5a8546a070628d830941bf637fbd27b1f3b19faebfb888d83a7a4f4540473d001631c74a0a5af8b740d0f3c60cdd1a345a15efa4f86893f4115c3c814c368918a34d11b879431313333b139c90c116cc4c246b67c96b1db87dc92b1f44316da618fd82336cfb20ba8463c25733cd53fb01948ca59591eae3f0e9d433e8a296575525101bbc755f24f27a3141724d38b946fbfe671957c1c9a472fc139e4f711366387616433b9b299b47c1682205f06872149ee7c0e6cc843069a49e4f6fed6e16a47b6b94f768ef81bc679525e59e228bd161aae7361c5646cb3df602dc196f92d35d42ffd0c95c89d604b0dd9cf9fe1b697885cdf41de4efb7e174f75c64cba874706065682f2314a410b723a3cc59e01974179aabd8612e19c85343c2686d2ca653d5f675a9669b43ef6d5cf3eac729fdfcd4329da308efb1cf33a760ce038c3a2e6729fdf8ec33e94e7bcadc3308ee33ebfd857bf76d86f98d018452ee75d1612a309b73e3613a323a684fd44b9a0305b32715c8af7f9750cc3b0ae23aab9a1025aba881c0facb6842fe4185fc831b47039918106971138c597392589a6a0bf95fe6996bd77336ced92cb38ada329d5da7177d8c74e86d26fb14b798a3e977d8f02ae9b21fbec6f1d977df629683da26ccbbeff018ba15be2b80cfb7a309474b1af4348b875bb18987a4fbdfcc6517bb25e9662faec4d29a6aef338ae5cf71b56baa5e64ade4d8ed252cf0d73a8508493f5940eacdc70367ee18dbb276c7ffb50ba6118c6edcdc37b7eb9615f88c21efbba9eda5e33545c7515aca21d460c17977e98ba348bf6a1c9b04872f9e49e69a07eb680fad9b3f618866193c3beda7550d8e67e7a26ae7840cddcafaff7b50e38077dfbf5149ca2cf03caa3acedae7d1886fe6361bb0cec8eb0f172163bf0e25e25dcedb9aedfb7bb1a586e05b92ea3ff0316615c8dcb3efba51956d1afd5963615694f1cf6b4a3c1bab7b17d59a809d1ad8fc5cb424d7c70b14adba77fdaa743e9b8ec335bea3a5bb18e269314c52fca177615977ea459f65996695a5703cbe536d0f338ec75c31642566f581163b30cc5c6779963180fb99a1bb3e560a33fbb272cffc41c7b89a28c615858b94cab1856bda3d9b0af85fe067650587efab6b70f9b73069e027d4bb16ed1e8d6c3d59e7e8bedb88c6e9af7b56e2d346815c4b4b7b17c390b2a8a5c94a7a60c7ead9f3c35b393cbb08dbb3d77363cef4f2ee3bda771d763f94f2ea33dd7198a61f8d9e88637ee7cd6b4a7f437ca980cbb0fb9afa5e3328dd65aebd7faee1a9d5c7b42d8a4e43c29ac942ded0f36df3a5b7fbef6d5e3563d5a6b0b3bb0d837685177fecfb79863ee5d597eedba6bedfe1a5bab9a56b5ae86f95ad38e2676a59f7d3c79ea8627d64e2ec35e9411d3306ccaaf339311d3aa36bffeac367eedd898d4be168dce2c763786fd7cacfb6e6105c33eb98c04801782e04a223703c3da1a98cf97326072319a7b9ca7fca31785ca95df31468b45ec7d7e1d882d356c4f7f7bfa7362fd7db1ae0696dbe0b66d7f7299ae72fdd5638db1d6af58adf1a3bf45ecb7d69ad09373433792238df44b0ddc8c3c956d598e2c6247c7881836ec228a18b9f1bb08dec1f223f6519be07cf614e71ecab05e771f51f6346bbb91399ecac01b5c03c186376e4829bd354dd3b4ec0bff6661f6327b8cc8c5be1de6a5a08f38b97a84413fd71b0ce3ff5d64c31bd7ff4644d58f2d657fa4fd18914bfb092d229bfb5d6e7971f4c2b95b29a6116b7adc863bf29494913d0d0591d081b0cf5b49bc670c1b361437c66f287aa773621b59ff97aa820a140c733852421284872336e4a42b3f4ad936cf69d8c850faf52862e91324573ecd90e4a083af4a2f9f871eeccbdfecc7b94a5afe2a97651986611ea5de17d61d9fde3ad30a0964142fffe6a3090b64822103b9388ee3b8bf410a71992b9a475f8e9340332ee3a346d5b4a894fcf6eeb5af95820e86d603ebedc058350e0c532f81380ec7ad5e282f479fb2116532bf66715c7d1c551cf7dea771cf81284fcdef276c88baf387cc39ffc7f673b250286bb7adfb1ac58e66a3387ce5fd7cf155ad71e5819655fef37bb80c45853aee64d5e67d2878d613db471e52b07f3bee0bff72967bba7d95fb8cfbf8baeb66df0ef3565933a9f01b7ec5486185c415ca8b7cb88eebeeee2d58a1dc66bee45e61d5397e43fc8613b71032daad0423c9755c06cc800e6cc8472e1fa0eb428aae3ba15df41593e44bc13c6a27e11dfd3507abf9fefe5de42a224fa9aeab8760fb6d6098fedaef5cdcfe508b1ed7606696ec485e043ff222389223e5c0e176a5a7a6bc9d033bb1c00d16c821879d036cdde3e3e3838324dd83039f2136e623a647734eca5f1b7997e1de4753ca7903041040fc60c33f0081d33591923dc532dbc6a28565171cb45c37f4442c31ac4ab07aea138261981616e3da40540c9b18f6f4fbdaa673b4104f75371018865922b5a71a1bff9010cf4e919a681499fcf8e4e0f8137fb98690f0d814e9a3366afd18c9e1618720406270308c9389535d434878a48d2c7264d4fa8946624ed21322570f1207c26d908e805aad63a4071e840461187e1d310cc30c9302a2e3ba0e1a5417078b1672cadb603882db69b1314b1d69248da422a2243df12602e104490868c775bc260d26453e491aa76f5e39fc48dd17ef05b6e39c62636fa4ae9593473644bd68e4bb7ce528edd9edd73b1cb72938739cdc7e6e4922d810154acf8b2c093694d73f9cb94d23df039fbea8e44bd9aa9a162a5423100000009315002020100a870463a14096e691ba670714800d7aa248665c19ca634110e5280819640c3286006200c000c00cc9681b04517405c4f52770c5c5f585644baddf942acbccb0d75e5d67335c3a45eabd71e509e999e065f53a75711e547ad16ec522bd23c04148706daa171640d4a757d447bfb17e92516b491c0c96c34f053ddb02908021b1f9a9977bb8d65b58b338df41b07037f02cd94c63209b7630a2299cdee91272018164f99ce3d6345ccf0cd37e8f1480050634c0a7379ee9bc4671212a07cd1ee139bba59622388ccfef8d6f5e45cf4534b37a5b3107014889c9f9781f2d8fcc572cd5c00c65591b151fd9f2bc85a1680b1c3582ae955219878fadce6b7912e6cc5a2ef6c7af6ede59e33d2d5a2fa9a722448e7c7fcaf1b2b721ee3549ca90100245f10215c13f2fdce72e7a335377bdfbe3dbbd3a1f327d52f786a59bdf3cb5975c1aff86a97bc952885d7c1778fce3fb1a87bde3bfa97413fe92cc8fb1327e669c50b46ee07f7a6d10ed3c7308dad2c025521d6867235ce65723ffd4080cb92460976158645b68739704a105d2602de381e51ec952997ad1ae73a85b08da8ccff693e505f18187a62986b9de6ed6f61a987e0868126408250aaa55d2c4428eec7c18a583d6731cb24a7748fbe81b8bbb33e0d88ac463ad6437034ecbda35df0322a039d90a361420e837a3cab23000dfb3015bfdb578b5d1de9323b00f429d535f3c58c825bef37939d5cd27742dcf0bb66694baa25539879c54a100be2abda7a487038150fa28c2ca64fbe9c1b9bd1bc9fdfeee82901287f1a30b7aa62d8d89cffbc61cfcc06391b03b3e273444559b66d21d8b32d28c8ff4f83abdd63ae73510dcd305ab4194794a93fe616295b52efbf4bf0d41f7ec0c7aba47337e2419a0aecdac2644d311408f42cfc0bc3b9f95896a1ac8be14d043877bf6369ed40e9b1fd2a933103351577c4fa258348670ce1a264a3cc8444cc8af453818710bd2e2192e70c1e8b8512e59b0949ce231d79a58f74d780b0c1e010bdc24f8390abd49bd1ba7a07081b77421312438b50d0a834f847e5452f8a17255ede0cd77e013d8269e409e19697ebc95dc5b1e559d69720e55bdca2970c5d3cb840656cd75ea229c6a4c3aa416bf2434961b0f0eb04ba14225df55a300b47c1c98ec5e1da5fdba23d3a1674b449a803d20d1f527688d287a8a79295499f69750526c20f9cfeb2314c5921c2c67db4cf079b01fa53098c870e75591f26d0878d988cf20e314c12be42d9014f3d8b7426c65acf5b94cde6b51fc318090423af44391a71af17fa2fde535cc9b320e3a766c06a039a107da6d787819efd313b296857d571a32276a623b40cbec34924f3c261109ffc999673068f828edbfcbde9ffb9bb540042c0872a51141d89f87f0a69acca7f19dbed93215761599cf9f0756afeff6241139bd27aeea9000785ba1072117dac0a3cf38767e3504f411d306ebcdb07f64fbf27faf30edd57da559e3828f6c731b9f36d048030187d8e496318ad6a2ec2922bcfeb3387d64d72108bda4e1e0a0f91c610079fb0fe69a85cfa468f91614d6774d4a3b766d47ce9f776a373742f486a9db8330d4b390e41b64f3502fae55a5b3586b30fd3fc0a14429fb2ca819c4b3feec653f269fe4a613697339056255fc1893a72a80558418f6b2257f0cc9b22d42dc64ab304ae47b6f595656c366ced6ae3aab86a806fce124b0762b787990629d7286ce0b5266338c8b37bdbc2be6e8d5c3061b31d58ae44f43ccf50233d9bff7b3f2b1a7b0d8309e54f459d0a66d4426927d2065b7b0854e962033a742836ee8feb8888d04a2b2c87ff7920663248affa6d656f470d280142a1e6011a136735ebefc954ec2737cb9dbe5191504c7d3e2f916085e6626d5741d6608319aea0cf3ac1fcb1b5c3cff06c967fc5297ea406691d8e43dd610d25b97fb0f9468c28ba3fef7e404164a92fb30c43e89415f804cd6eec0b3cfd74374558380040228f9e7042119c618d6bb615f21895b49505f4d50253b3a92526ad8520e936535aa9139dd526531304e17ed0e37b78088ae4bb514e71694705e840515fb10c898d8cbab7292b4940095a8d31a5d6739e25be6d646ae1f6a5cb9d06bb547da4c533833c89efe355041fb16cddde85dd945c4b7d634444b58d05e7608a8bc6f1984632e656b7d88d99790c89ad3ab66d34ba06ac01d4d973aa04657b6e26dbbe8336f9dbaf2cc6e0940243bed5d1c848280678a17ed47decbd214abdf39a0f494611c64a3405e0dd8b8d6ecd4b55a2ca176bf384302446bddf34535f18b38e659e7967a0bd6c07a3df644df47a5e02fa380e1cfc3a6914fa730c3c0409d2829bffb46ebe9acb6b5db76afeb3263a0f649e0321d2ea5d39c9c18fc33ef352ea34d74cf37a37ae1b118f269ad96b5ca31ec2ebd12ad31255ec527d091272f3eeb966e0ca013be072b7eb33a76c4a08c223cbf8f4dab85228e49c0c0e17ba1d9b747fa94a5285701ca0f1d0209687eb6c8319f3e25039b1b925345a46f8d9feaf63e78fb82f459c642a98ad84976da813ff090cda9a4a3d3c83f5e65f80f0f81305fb6e9d60e51ace3a2dc69fb00ef9e81869e25d48ef596d19e441a60dddd72d21fa3e7f629dd051effd4cc84959d8b644968b0807cd82cddb5592b09e7ba7ba66b0b19c1a09d41c5fb16aa79bcdad944c5c1a3a8a64155bd3cf4fb71a64957e54f781b2442890476dc50b302aaceeaeca45e7363f81d41e082d2dd35c2c66697a7ab94423e896462cb0b6d491cb9208a12ffec5a7444e9ed970e0c39967d836345c2fc270b09b165c5ffa2e26666560d0eee6fa9ce81991c4b01706c59f5f56d55d355c8f4f0f0d07b1e79bb136edd1c9e2dcb48aab26aace7027a331e7f2f8777037916bf0f2cccd358b047c8c9a447dce8370dabf55a5843e911dd2ec8729e848577a87d69e677690b4967a4048186794c0c3927a7db33badd9b0a6932404f314a0df280044f40226bd780aa34c4e9e737f692e3cb8fc1eeec32bfc2c590f5d0ed065329d6666a9d54919a88f2bd4d007e73564d2538d3ffbbece348593ae4c8edc9db3461f39cdbdf99bcdfc6bc2df1849b104c1c04b8182468fb7663b518399d723d56a96ae69e6072c8675a851810814a9dc9be14da17b256df640d87189fd149ba3e05581eef7d2cc6c3ed22305e75600a05dc439f726430374cc48339f9e24a1ac917b9b41eda5a9311d209551981c801cfff1daa3dabd752682e59087e69cb323dc742a757fd13d4e6907f95670ef555e6e120426f75ea60d58c088c2b8fa849ed98f4a5ae9bf68b25d706da49c8845188139decb611d4a0f134868fa4852e3e05fbc4fca0600d81b5d199f1479f853a3a6658556c686357b72c47508ff42c9c50f588b8cb115a364aa55fea3836a4db0f6af4f6167f5bb907f50658f191f9464112141dce00e8c1d290754d73e17bd3528a8ae555a380318685fd593773bf439ce8df7489138a248a165bab3c549017625616daa3b20205f4b58c4cecf4ee0e248b0fcaed469aeaba46b024fd61e22515190959253fe4ec60add6ea266acc3bbe41fe34f92925a041a6c1f7911230bf06825e352b62ddac8ff2c366115c1a924b485c350f8a82d5e3501d8502fa3336c1442057f5affcb8d43a3fbc2c6d9b51f7f4791786eb7ef6b6be884fa39c9b11b208cfe0a73a03ee070afa294dde7e50da47eaf140733f43cbfb9291c706a64255077fea6da7d2e47cc19fb8a039408da78de5d1d264f92cb689bfb16dd9ea774cfcf2cda9b6178e0965dc7f2f53aebcafa670d2a7a042f36ab0a01c193d9824f0a87a00c5cdae4bb068a8f24dd165afcb17d2f5292b55ad4597fd559b2d188f1d760fbe8adb8dd5495c24c2ba41a4adc2d688347451462197cb6fe4eda75c132cda59a4835960174ea58a7101dd2048313c1734683f2c8897c9b575882a76d92aa85e313cab92a2f03f0562612038ccb8adc1487b27f7e74ece9aeee470fdb3e4fb4e06c95962b390c70621e42cf1eb44b7ef974b0eb4b75bd2522e868cc06c5543b3080e68ad273adfe918d425c3d1f1987e46d6345b3619441f313016658608ae702652110ab756789bf295b2ae1a41fa32a223c3b1cde464c645538815e923670aec92d5073f82427139b4b822d2ea6a1e2df88992090beae77b496142f461b0ccc0cb678b6f840397027a75fd11a3a1bafce08728e999e7ed08760700851d006390c8851ecf4beaaac5c4d59ea5df86c40c331b83f6b1ad799cdef5ffa36d52be71a307ef3e082eec70bc1a67cd981204750c425f901ac7f70bd5382a07ce5c76613c6e60a38411f46a515240ee87bfbe2b2a2a151c5c9bd988ef5c16d273bad6500eac3f473c6c693de163dae371dc18ccca9f84072665eda8c399d02490d7db848b6435ec7f125e3c415e16fe08a9a7ee6ab1d2fb42ed9493b51cc859d80dd4dfde3b628b5a9bce08b459965913f2beb83e094ef477cb2a275c32a24a8f06234a835a21226864f05f360edb1ff49d1839bac47a0da62e36758442d46939178eaaf46550acf8e23eb32ba1c1205d9eae80c1a417def3cb7aa7a1e51f3a0f73527c0b2b62e5de8f5b512597b2508c19518ac2a0306750b5174c84f08c67f02119511830cacf3891095954fa73e6d42d5eed161e61830481e2381780567de22acc550596807056b96c9cbd3c58e0511e67f6756842ad1874e905a5464e8e70f779b2bd54127d854834113d89f5b039a00f5b459b58d2f12b77cd5dee8e0b9cb5a76a574b12649e74c44c4c8c5090023d1847195dd7f5fea47b62f17e76c48792692e6e38fa6d13028458328f184e5338821782eb5af737e839a245181068044778c32ee64b9366e4edcc849fd9c7c195344fdf65aa8b166a0531cada06307149849b727be65efc9b1f9722c1860562763cae7914c3a2e5ccd26091bc5b330901f383091f74ebe7229055c454846f4c7464d43359b72798037cc798a4f9136d22c3cfc31b72f5a5246037599743576cb93b706bda09339f6a7e1e71a142d670efb3622cad9d920022cec465163d9fc70b000856f914738bb07857db28739bfd34501bea530ac7efa2b09cc7d57fb930e73157d4062590777765bed8499f1c595d4fd276be3fdc75bbf5b545c827369eee5e0e72b87546e519572557bf69ef4418c6c1a9097c2047b2637669305eaaa6ebebd62d3a0462e09700e4b0acf42d98261344281653806d20542b0129f281e2c16fe4727083c8a21c62cfbf302da5ea165d24edcd89f2af50ecdcec8310b96aba618314a452e49067f6a52fa3e2822a04590effa43447138686eb647ef7d63bbaa93110b1b742d63a5fda23453fc665e29ae550613b7108ea3a40536c4e2eb43024a5132e7f3cb55fc55dcb7d6030c7daa7398c658f25d5471a330b39b88d22eae43e00150bdc1554005ac787d0e9800e10dc3d210d2ec50397638c189ae0b7858f464c62461f72f80776a15e0370f67e55e5a2e1861d9a8617f58299a8c10c196b28ffa4e0a364c68e65cb8306c601ea1d4cb584b071678b2366a00c902afaca16122fe2bd1b573da1a75ef613b6506a108c7984122c4ce5103d223c3dbb285a69095cc2834b3087d734583e6ce963427a095e5293e81179e67e198b66481122ef9865101d8d677e265a992d0e26d9621a25840daba7064bda4cbe28fd677de9c283e838aca89261c631cff490eb43ca8d32e05ccc3fa248c99ce94fff46a22a54d49bbfe9157f0337fbb936fc77e752d3c414433578321b29c936d35004316aa3ed1a7210d3c50586fcce91ef6f941a02684dfe87a759f740426dafe09d514f7d97d85257423e3fa04ca06ed9f121d9a62be5617dc2960ac63780c22b2c65a60570dd92bd1c7e9e7828a4134d1348002501b3a7597ec788714b6a77b55bad4751050eded5a73b20a57961b497cfa1624cdc70f794fd1fe0310d1f49df38aba313771e5086e0840c1597ca24003bda282295356583c119dd9b26ab6951d289089ef51b9a75c22d819d370de407354320568d907b468da288655de26416d72b8284789adc846b9be260d4d51b3a0108f58dc14271bd60d24da518454cf8070644f063ff4edf8b476af5618cb291203d802ae6c9dacdc6ee7882e20ace9f6f60d90b2f730f1ed2f96db46d810f9310892d2278fb3a9131c1c2402b331b0d6081b5969001eed7bf1ce2ede6573613f5265670d223a107c8715cdf7c17c57504f65b826c9132560f2d5a209c75355842f9930037d62b4674f146bac4d049b93e740b77e232431fd298bf1a54136da5f84808144b3ef5a82e14853498247b9852155746f1ec9e17a7542d81286801413e41c939cd73686bfe736f4bcf39ba1a8c611b2c313fbea4e0ca83787881649c944b5890d3b6ae102d1eee7dca2512452cd4fdd6885aa00eaf74550bbb79f9cdbb2a53258e45d778bedd1049342df9549f7a2f7f5d2dbc0aaa409201668b928fe1841e8d259df21a22e1ff6a21e539630d5d832bab766f7a110b94408aec97bea2d047da6d8f9581d284ae9c62ce67d5931fa2ed6df958d115fca91b46693888995727c225bd6bf0954eb68839dd6a99e4dcd2a2da550d94079058b648c473fbc9a201b790a59f73225f37af4a089d67c81c5e0c9795aa0d199a21b67c69feae0d88760a67a7bcb92b28eb2bbf5761162fe6c1194e009195b239e6eea8d9d3de8d062a86074632fe49691ec3031fd57dcdb9f4bf41a766ff8296179d4e158c4a6d9993419710a3d12eb8673d3c36881a959d6295ab418b44067d113c4d606ad665e26a240b8959d51137ba13d241b90dbd19e4c45e205bf5cba580080814a4880244248bad551fdabf042ed52aa22cdb833baa5522906c043ba855fdf30187184ec686fc2b6b04ab12c79e08895907aa73e0fbc0f06b72bff397a4c6ca828f30f1b8576ccbda917e960afe2ad9a4fa74c647d83fa08b2cec004fb77b6438fa25456cd085d61a5de654eb3c1734e842ef5ea06f792ef90cca376a9edb349f2129dcca188f56777219abd07df066d126f2312e960868215116c2b747b33b5f55469cd56712d9d2c8e459dd2c7673a0beed67730692f59213b1279961c34aa2364e3c588aa0598e51eed95b0db8e53b948f900ff719b20bab47d5851565107f2a824f882af596dc156e37f377a21412417f275e93121255520a44dd5eca5d94441500824beecb2a51b9b3881865f9e628a5426cb320fa0d5ba2ad1170c19b92d0a1a51befce83b4dd99952603653721741e00203cc77fa23c9c224bb2dc4e6a2a18ff6986b7ab01c0f5e22c85b91584b51f636952aa96eaa4dc7e1071dc574b8d3ff977a7ff8ea11c7e835cd69c1922eec701447ea52fa39d1cee4cc2b8255b1159a48be887714d62a7e1038ce5d89900e03719252495ef74c01c11a76ceae51301b75459f12fb30bfc54f9a62172b7327d563a3910a8b1779a8454b3767a5e3267ffa012e4a593c2879c841052a36c906409b2be9ef902309750e9945636cf1a1558747230b772a1d9b8f217604e55d1a7b631441660f92c05ad96aefd785d2f3a2fc72b63be015224b0beff9d358e2920c068ad17dfe64d71dcf085504deda6dae3bc2579d0f7fe23c43c1a387ffb1237e4fe024fd8db5951d03cfa3f0c622a8b2d3f59c54420593958a55b78a951214131020237920040ebc24c49a258040c76d430b67a843cd453fa9c306e4d2418871bb3c89b92e0668ff71d3555e3f9fd1795dbdc97c567fd70eb2d0490e1f7a8c6819e003dcdcc07716bfc9b597bf7c1efb3642c601c38b6b9987fe157121def35fe857c9e1f426d79a1cf402fa34f265db0fb5c4e838a5196604253ecc7b1941a8337efa540e4f8e5fb443e10b02246b01854c5e886fda8892decf33bc40cc920cd3676f0d6b18b7753e27d07699539d829701b55f7656e2410afaee066c4ae8e9616b32bd719739638521752a99b9a18389b9ee19c2dfeb9503a67ada6dca2d8d005e30759118856885f798ba952cf88e87a6c5fd2cc12019d4f08a360e2ddb2e0201042c26dde56b6c5ec7226ca2f495b9ea36cdedc59898276cbc09ef7e04bb28553025dce2c1a4eb471bb63b97a4ff31fd77f7167033a634d53dec14ed2bde963eabafc6cee1f6ef1a19402af38ddc6b8510ec458076692cc17f41c20e71eba8bc18fc9e5723eaeee67df6bcf006ef8647c8ec6ac5374909a07a08f39064f28d81b0ab5df40a9f57030e4d78677e0d041ea2b1b472da643a4e5aeb214d33d02985ee2da8246e5c9d409f3ffcabc1407290aa20caf7be5ef570050aea5581469c1cfb9ced58e38369a40432ca0120850b7e30ede36f915d968083d358b6020236192794ce9b4364c16125169230bb804509b379af006f68ce46f278666e0aa76118610f5ad2ab2f96accd5300b0bdabce7c71ab8afafb6eee01bcddf729c62f79a795e2dfd363aa40233ed6ee8771c12e83c0327935796e399a7fa6143bac876ec07a79d3ceb530ee6849a0fd9e410cd8748104fd87c08650a77c8602400c2f1e692d683cdf8e0c7ae6ad45b85a5b70c7abb8db4722b0f1a804f45f2cc5ffeda481a32639c81a42387c5a9005f02cc85c42c04cc420090126022246e7a5a880d10901f839d4a2575002b2107728d26e8a9b6169251b132d0e636a3bd224a3412b17ae0b23999b41c52e69e92a3f2af812487ffee938ad60a29014e116a028594cabfb088ce0ed5e00f745bbfed1cdc26738f291c1adb3a43f2611387953c4cf76df0f07f898749fa6a76f332fc5fe2358cdef52664705882d65ddacf07115c1bc5c6054f5514f8a71eafd6255ca54178a34a4a42a9475999e85d1d040722f9ce733e33d927281be715fe01737667332565b5c87820a5e9b1617a7f1973b8527a87c4af20010e2f2d5cf5a7fd86358fb38ac0e468e31abd2c921a58f9ef45b3b9ba7888816f2c6e1a991e66b657ee46d528579b08f40e85e11eb8d6f17c5cbdd663196c5422e3ee93f967b48961baa40e805af930a1cbbb023908089a6573da2eee2671297dc3c880b1f109be357ca1b280b1d72796919be8aaa84c4db7a293a4d6a1091ec0d51b29e34e289fd489ec92d8760d553da4a75e764785884a6a7cf6c5337063231292b4dcf5d89765772907601c5fd68c9cea8482330c81472589d474ac870cae071b6e636893918b1c255cb781c6edb667e12c4aff872e8670fed49599e86de772b108c123d02563ea1e2049401989943b6a25b848e711d752ca872d4279a863ed89e2ea66c48ec8acde3ca77779bd4d720272aa8fb1f9e8f61c5027728a2a939f13da6e64e1bfeb0f626f675eaee70f1c15208cb8de98254a5f278daa8f038f23f927d2d1a2ac394c872c7889eb9c472f20efabd20e3cb90350b369001f1fc3039ce6f685fc9e7aca35038708e2a77fa5150227fb1ca24d575a190d6abc33e92d81c18fc3114b990c546b181f74814c78685319f749164bc82b015b721517d9a2b7b9037acf8588d25d3b070aded269e75141be852c1d57e381c07af9f80282e25bb5d620e1c04480dc4ce0eeb0305d7ec8257f3c0342f7e9528febabd936444d94bd030ddb8f554842afd147ce1e32f49d56ddfea8672d5bd12fe346981b6ea90960a2588bca9206028d0145dfee1a5fa1824bbc28f39d59ebdf26efb4ba0d8e1b581e4713eb5649fa66988c1e1c1d50ed3de102a48a47ff6b26e30b97727bb7c1e6608eb56d524d4949bc41fbb68c8f59e986da0782ebbd5fed60a41a919258f4a0219b27bdd92fa68c6b85324f2a372aa90d44e0e5e283c6a8487bbf25a4d1085c1bc2e485b07d42000c2d732d16481e36745eec083563009082ccd81e1a13b6c10ed680d7909bf6283c407ac748d0286ea9c71fb8f0dd0f2d7c3df431799e6d78013e451643b6e7eec60b7060d847aa24207d912800ecaa4bef6dd7b7f2045229f42e2f89343408e622f5e1f94d29eb875d7b0812e4ae5c661812987eb71816d0f9313caeece958229884181ee711db0d01dfef06cc3a5a66cb38fa2643b2cd9f985dc7c2561a07806fe08a63b20fd9caaec16fca7f9d74758148646357973ba157298a394090e3963891be873bf844016f8d42b1aaddd639576132d8d10543dd91838e50cd4c024a39d69fbf877b9d3ac5d00ef806efef055fed18b92eee15bcca19b2ce8fe3c46df301665a4b462bf91ebc2eb915ceb97b9ef832fc6a3665103efb37eb9fad2a84c51f190424f3ed0f3b79b0303b7e60c93b5433896bf199ac3f851de4857758c71ca3d0879b0a95e641f452be899a30115b44fcbf7770c5c23818d74e88663062bec9afce15b6cc3a75b8dff11804f8e946cbf2caa6f3a38ab1400f61a0d5283039c6820fe5f1609d73ee1c93cc68883d0843281265ce447caf95a468f82569a0859cffffeae2b4f96cba951d0782a3aa55c28aafec7867fcd126ee5aa510a99ccd1c92c2f739d5211c93abacf02b21a184e98085c50c50d1b9e6cfa8708476efc0db6238ec80f69970b1849db12446148f75252b542bff3fb1c05173e52656a4658d0ea78e8f1a0f519cafae9d11a2abeb84e02d0537a428e60d753f55c5b2034f554b99d825b0d4d0eafa5856d1fe5b51cfd97979c324a0526aa21f91fe7f3ba103122837712b7e59348a83948a5eb25ec8a6814430bdca6b588cf8aa46c49768e4320b46c1bb36fc980a84d92560ead8e97cdab602ad18e90a772ff171737f214ba2410722da8574dc475c3c77b457c0895eff51b26f48bc6c08f10bb2709a00fa2b16d4dca1398f12008fe37d896ad5461398d24c4e2b4b0373e6562f11ddabf7171695492219920df6bd6a1bca08666cca43867511cc650324660bd1b1d7ef17ce0d1a12fd79636e6b71536a9a1f61a74ffb823366122d002d22a2ccae9aa8a2a1cee444485a78267919241ae8d21b8afb885fc6a6ec7fc3452a55a9f1322f67d9ad14fb4ed5a9a7e24a434560cf0c740b84f2ca8a8b942c2bbdbcfad078be30e68e66a31a9ed65b271f6df3e031f3b0510ab48fd55fc94c79345d755f2cf15cee9cf62014472cbe7e24d4585270cb77efd08e09164efc3d5dffcec21472006af9bf57d59b825f8ec6c0afdb9ba191902dcd62fc34d2b8cc313835da95436d8ba4ab629876b185724a228bcc4be7c43358dfcd0ce39ddd466cf9928915999f792497bec3b6794525aa9c9886e3de305a7a5e489e73e242c3127edf96b8e6138003472a3953f78bfe6772145be80aafb7d306334f622c5fe7982927ea0fcad23a1dd56b1f755016855e874540c46c926c54a4ba64417b28715f7cfc3b43b71fd82dc748c38b00f9bc418a5800977bbd0a6c5f198492c7288033d27d1a89bc5b12a124a8d31288f6fd12f818053c3d2b2e390b545eecb4edeadad1dab11eeaf2738d49fab967263a887a319cb55773dc05632f8531ce46929a06c0b569481b9ca114aef5390755930202d66a4f00f916f6f720ef6d6b0d49b6e65866357a1767b09826a95e4259fc6e98afac70c7eb83faa0b5d66ca8894a1e001ce83242afa0a85190f0c701c354e405198c484c2badf4ac4102e68de384a479e89700f84392ca0ace206a18c2030291efe23edb086dddde00e0ab6070740e04f7bad76a4dbcda2dd49c00b4135efb27278c52b6682ca7cdfcb8e168265b1d7d12a69639002dd3b72d4b1aa32ea4d42320b4b50d5d4084e7318ea04e76212b007353c84c97a7fae72cbc6db7d8d650195cea74ab3af993510c5e420861f21b5782559b8f96ef8a4327a744e96c3f85cbe483c8cde114d5c32b561da04e0c72bb584765d679c350bbe602ceee3ef679fec216f24c3c78c0822316a0fedcb2987cc1d26c3c288153a7a8364ff3dde688f66c8b584f3707e83d7638592486174f08b6031aecd611ca5ea822714b591478de6763795e80122c382f46bf45d9eae108ba467c7b41f985c6c20b8d28d45a6d1bb03a89b046b26c006b98f9c95dda95ca93c654bb2eac801660ea4292858e327d703a7f598947d2191fdd2c2207e4d95209ceae4b10e13dffaaa9efacdd426113b1b9be03bbbd42a9dc3cf66c9ce7578ed613bc27588b162f16e701f582caaab22080b09cd1d704e81fb9765efae8b72041f3314fde505b558dbf105c0c744c2d48e83ae33f164e84262f86ef0ae277e6c8ca1d18b196b0ffc79e5dd90cab28b1cdb9476d0349befc3c8a1fa171a4850489bd72e7e2cc49669d6237603286f48b214102cecc3cd4379d8c9e8775b2e2a30090e6069dfcff903c2acb47e30a810a92618a7a68e669a4526b6820cb5ac239a69abf7c0707cc6e46d6582da0b527bd90a3a82f181c8c3373d04f7ec1dc843142d56b5fde1a3f45e05f06b1c0aaddabfbd83b145b4ec01bdc8ac6fe239c0ec2386bf80c8c801a3d345626227edf6f12207a470cf6ca416ed1511f98c85bfb582b2d241eb6db1773c9f8f6e3fc3705453f421dcf2945987cf49b1f2b7998427aa43a6a2bb5b7136b072d4e4251083419fe215a8b8b9aa57a0535369a82c034f5daa2685fe07e3953703a2e8e7bcadc38c6d28fb997aaba6303da28f65d18486ecdcac51e2b9da750a8fdd67adfc020ac9557a2639106b5e1cdca64e57221cf6b7303d6a9e156c05a116b31032fb74a146096a2cf3b4b09e9ec4808a307db492135e8e8a3b1a2901fdc16c3a57d6b6c840db46b9a317d35893192966dd7130044db8431f2488b215307d7e6eb6eeb8420b77a719f863a7102a84f0416d6a999f662979b5c8a11a007e649cb3514bb4c72ec50ee2c5b7a966ebfd7541d91260ec7dfcd09f789f5a94571728fe4b35a73425ab7683acf207ba1a7f469f0aecf82f4ca50a8f29c75df05fcfbbecbf512ed84e5003a753eb03777bc88cab94649917628b6966e2d3cc60ff663970f3c5413b878b095697da0863134603e055b128900ddbf183e225f672a4aaa12b69f71805ca4d27086a9263798783542f4f41238150946083be3d5a0945bbfac78fff117eb6db9028e6dbaa5801bf8bf92bb3657e4352e7c64b216f907cfb0ea2a35c987e80066975f44164094f90fdf62ad1fad66e98ba2113b4073002347355291e3562dfe2247bf4594458a20e491106a61d7c2d9eca3d90527ac054904907563f41c0a1ba0e05209dc37862f6c3544c9b76e2e2978f38f87b1a4b07fea17876548349ac9b367a183773302d3da047d9c9d7a45dc5d5a940984344fb2ded3cf261c1b8e2ee16a09caf7ed676a8245f9473b9a7867a39827b60d2f7fca8e0356a1020efd3374eee225c5cda8cade8c2243442c290d77e55ab15cfc706aa9c00ff760c451bf75d311e4bafd7e8ecfb6907e1a2f73f4086a06fc6b8588a828a919979230325f52450f4acc9008077fb556485ccd4eb326a2c7947426448af24d6db04e9212ddc9bfd1bf8a1a45649fa93656d3826600384f0c43807b2d0d4845213ba0cba66829a802f3b90f675f1c80aadc64231ad04d8363963b73c027ad962b925b735160b2acd0e623f70f7306cc23b7dc21ee80cb243776950537e3f192ce115e669ce08b98a3443efb018cd32f092aeb452d2bd4680a5cede2d5472c0c46e2dc0e1189628a68c9976f7102b80e464891b4804bdd78177eab763735587ebe6c9dc496c54c0079699497acb6723d203b2a88cc1b4e5c6a29f71ead258f3b335b76de4f74d0b7182434b56cc4208547fae0b2afc7fb09279d2c4e0687551607bc38e15e0a6b6da434c56cfc666f196e79eee82a63df9b131c31182860cd02a99571e188d11c6c47bceac12d62170bc85d9f3860dbabc870c8e1de3b6c11010f0fcb24b8b1bb9c07c8746197c42751b39c56c833f5a7b864e2c18e0f6d3074bf2cebe642f8796ba7476da2d3753fdfbacbc72424fcdc7b8314db6aaf710179ac14aacb66daf2a6edc2dfecd4d24a7163d2bd835f5a47da3e5de44821cc59ebe26244215a2564d1b04440950ef4085d274af615a70e2280a05aba9208fd73af83748d0abf6fe079f280023593779d8e9b732b55adcd68720f28ed880f94b38acc26ac2a70c2b61030a4c06adcf865b2d54decfd2dedec07915b282a34fcaacb123f432e4c165eeeb9bf74cbc597a17e9ceb12b35061b8a6b13dea4791319d154b0e3cb5b67cda4cd670309f4b2429b19c8a1defbd59b221505885ebb95fa6d288d713ad72da6ace15ce7a8008fadb788456631728b9202bafa4bcf5277c44d7cb420ca58aacf7de87b97695b1c465d9068b0737768a06663e37d334e43f9a16ba4e5ea5624f0d9cb34a9d0b128b0a9def6a187c6b6f5f28861f089577d78645f0e65f40acd17c4425147347c5adc0d825c3f4cca3770ab48ad9179dead02ddebb300d56ec7d124eb4788addd2f8ee7a5286532e648dd33c081a13b2eefff1d71cc1ea46383bee52267b84445d9b11d565058eefe446ac29a806eb8353e5b97b0d1cf432a2feed322b209dd442823bad7923c994ed39a150706843dffd28d5bdb91a45626bd6fcf9ac95c690d0b6de99d3f8c02722231de8e69526afaa2b0bc98b7a13788bba6a6195d1c3d21e6d3bbe5014b5a372242ec897b30277b7ef7dab83a109fe0589eefe6f6daa0fc9175296da59b772e03d8947920f22b2af9d302e754a3818ac431c8268d1771885fef8d4df68eb8443cabc28a77f40aea601e497ddf73e2a34ccf9536032e0f4bb866848bfd6a098a45776521bd4a43b3faf5798a2ec06555155dca336ea14caa5282e870cc7b8f32fe0517d6c954991c4d09f6653ed4f370d619f5f93f56f05f8de78ea6b7e68260d0607e5dd8ffc697cdfb1fa4053048995c647456192c1572a857b45dd709308a4d7081dc8a8a042ca412f3ae7a8f92477e6d393c938ff558452d2399d960111586d2cb3724da57451e78ebe564bb0c3ba4f033eb312c22887c83f64d8708fea2e3235718fb84b1d1d9d4fce0c801ba0032a6c061b4ae99e2ecd36aea42927c974774a4ef14982057cc3badd124d93598e6f15a72602137111ef289510a567926eef2d0bf44ac9a3e3d1013bc4288ecf104ec70c9422a8e66dec1a58dd89328059055ee3b95f5c154f63a804fb7baf3517524416853fe391b443a3dd7e280aa9a2579d14aa4341983a02b3109de3ff7c1878a67e5bfe09053844b1ae55707074b31d484ed4f249cd5f8f5acce75fabac3424ef1e9217ca7a8155ee65326b08b9bb79d193d6051b51be23afec932ebca68dea357fa5add2e076b95970eb84aa4b517db44eb711407a003ec3084443828961c82c463086614c8e43493494340550078b8387d018922c9121144585990ad1422394e565caa5c1ac682512888621c9101886f5a1ee23c6e0a0387542370d89d035841508cc68dda8e0713843416392693c185ce5fbebc31671d3f789c078d48613754338caba7ea8e40986662734df589c0de34568a5cc775278fca1daaae6e85e92d95f27d7912b215c89027f36a27302621642378bf0f2fd2abc0fb53e158ebc0915a2bcaa8ead32b806ae2e8a1a7b986ee5fae005fd91f83414aacd05a294bdf6806702651017caf3e073e1a42abaa35060764fed578f0e465c43843f3f0aef287a649f9abff1f9559e564e542853aaf10c5785fa3c803d16575516adde7d2c07d5c21db90ca126c36f06ce0f904d17d1c59bca782b14e32da2c188a58d02656fc4b3d76d54dc16bd57b2664dfd57e15941313cae82f788075ba70a6a4e52c2c78201624c20100a49668c912130841c0851e1224e051eb1407a73900f21041ba161911342d81d388a18c728ccc83901379d22673008414c051801806230189a4c48ca107e8002824c724d37c75c3126ad308099a656ad01693e591b80fab9405568648e165199760a50bc742540a6618693a86e30bc9c6733fb645e0ddc5708d0811978a4383857bc677cfa492a78b131cb55cf22d2565d52bcf6f3ead5c934aba09fac63bb5a4bededadbae57be9f3e8f5663f9e9ff7d2b9482afacb2fa56859e797d3478b9d9ed6a83bb8c4c840beaf10c196fdc55ecf6dd8ecc8091d998ca320bc2fed388e9141361c649305e58a4bc420d2d5bde7344120047ee2789a86f5e0eab41912ae6488e628f5b031f70da8cec1b53ee57d0683201286868c0a1acc529771a91a47a74e4fb8da5b7d06df93ee66bfc63b7f37acb79ed626f0be913596d8c215956f3055d658c0d1f66dc1b18a679ba9e2ed6d2eb7d2770746a555d448ec137dd39da150e88fc62e7b9802b65e72fdd8ad32669ffb7dfc380759b0860f7783aae14006f5b75d14b2df00de84e7161667c1f3898198fbec867acf7b44f1b83e7cfa77ae9f769d0799e3f01aae8b137c3e67c9797452fd0f7f6b7a5f6d6293fafd6cb01a16adfa3d7b4b925fffd2afba294d6bbb9be147943bed3c201bb62e62132b39464370cf450db05b3e77c4f1b7d478d0fd56140366530cf77f1d9044c9bc6a642865692aee8860d7eb42143a62d30d867623ee390ef3b229f50575f1281190b370a259a2c01f7ee84e827884f0161fbc7c0b4ae8d3914c16bc7457728976a362649b18224709681ec33948a2370808ee1d073ca3c102e2488e1d06b98b8e38003f6a4490041328380e062517204abf24cf1a0cefe3011ebf58c528b67b64b8e9368955578fd1183f8b4e4ce544443254490c9dd6c432c32a9774176e02d9456c0ee57132cb1b9026cb4167ad07f71b8dbd61a594db9501ec73a89eea43752dae07ff37a70637ba544b6ba33d5b95479654fef602ccc4bd9a7b670c8a28dd76a252f81b920a540a5cdd6119a1b49d3479ca3360041146698ccb9867c405b65cd72700ef6674a7a3ab7c5e2a99e20d6b2b3cffd03978e8cd0af92d8125d9ed677a6f2e42ba9463bfc585ae97cfa703b8d5a9a3b1d4a7de5e692f01763ed47347f88444f5e3e0bec436f78551ae31706f63e916ec8cc4345e54d92e75d98761e1805cddabda1ad66302676b50e27faf6a4e991a0548b684e67837840591e0b3033e0765612d98372fae12d57695c9378c38245cbb9bf8b07b4b50d6beb0f6702b1200ef6ce70f609eb1f8ce761be6feae4401a6a78da2fb6f3b77317b53f5887503095751af8470b990f92df0be9073dd437af0c312af114774dba29ccdae0b927f5a20b9d950b80a364c9f890df5ac13bf0935c3667408352c4ab758dd73c201045ed8f6dfca8295b07ff95760779c50dff8550f7b73896ed79c666c5f6735231ff92c633d6621447a85e49ec6ccd95613f59f01ac0c60d5ffe0fc527bd339cee114d96c8bbe21837d1cd5c9b7bdd552656a4423c8ee1bd8a138c75f3a8795fb291473649b541ea060dd9135baf7b8a19369f4091e0d7e76d5dda795a6a668310585b6a46d34282f33e892a57ea886e955e921a685fc4f7f9ddde419b63d00ae707266a3056371cba0ce89efd48276e641679c4634ef6668373bcc337077ab5a0c522397e3b759c524eea6ebed5f3b13db1f35ca9e6b216848b8e9ead9536cf3a6c91b3f425def2289059b1aafc916e7ff0a8d2e3aae4fec89f1b4a172d89b9e9eb6210440afdad2569f7d7f21c2683afcc75af7385c508a76757374d95d8d83beca7000d4b9e140926f96ddd6f5c5eb6e8a2584b54f219af8398eb31cd24d148e18fbc459ded231a3dadc036b6a51c18cae86c9a83bf053ae95dc31d4d0ebf18a00dbd80c5c7855caf7a0b52a0245f431040a125a12f0245f865d5f2683923da0030096b9e8351aaabe16b6ff99601b7afba18ce65cbbcf96cd6860ca623affe6893041d46ee2297e50a05d8f79b7ad38c89948ff1df76a70b905a789501ae966184e1e2edfbaa643df5e9b53daee2ee1ff583b8f35a783fb1c214182373720a0c7f8014f54c900f1a2b87061e08781fa5bb5f3407574a4bc63af6ae5949a72766be0bfba512ce6e76e03662491fc8a6b1e91c036043b04a9906c27a6f4a7ae047db142cdd676c4c4a7126c8d37066a9d7794fcb13093c1e7ad7935c7967d1e16bb33bf40d54601072d01277c56d39ef7a1527a9fa398a1cc1cb331476348c4e68f0cee49ee4ff0eeb43e7feee5626e71fb347eb8d913c1674c6c62c57b42ed8358fd87793b24b6a1c7585541c6199350ce074a8f5d60f6cfcbc24d1d02d231ffdc561b29d62b2523c762167192f406486e07f5e76e42221947632ed9d094293563af2ee45289b78c9bf9b3bfbd1c7d2d835dabed21533a0658c18b5adf08a878701d18d36640680d80b439aa2bdf699a67d84ba992705ffdb1ae588b4a59427dc8fa37cd39654e96d4609d4ee7cf75126f8a37979cf3430b361fbd6a80dab546f3ba841d873625add3225a3cac289b42815ec99229e8747531d2f98c4f347e2a9365591cc61021d4e759019edab42dd0f7bff1712a39c3ff25fc15d0a02554f63ce337804e79d5a716b3fbc0548c845273dd0db266730df0d4d41eb14fb8ab6eacc04e3a3f0287bbb6091e1929cfe620179bd0d8dc9c27498f62ce57a429a5b306f84b9dd1371476b21b4ed9cdeda0d6780e733e2d12a266075f3abb19bb3bc0446d248578cc4a38710fd60e81043d6c2b958891d29884b75469e5336598f9887b75429eb022c04fee61274e3986c0ba029a84e2461ed1f5496c387170c99d825e3f566d547e43be7bc566d29651e2487003599a8e866ece62c37813810a52dc043d3f031e676618b9ab99677e2941fed61968878ed8114319634e2965e0101d5f19acc8e795ad5a4cd32e8d9a9992dd52928800e6f17cb8dc8ee652554ea3abe8b04372c26d6e94f7571c6a42aef2a29a0840b8e83bb326d1341c3d8c871422cf2f833f09bda64886b6eeae9aab602ef576baf15e58daf707f89160369401742f7a6ba5b029973ff566b072cc154038b81c31918ad7b982282cf8ffb15254818549cc762ed407cb554664dd3cdffc9fb8711b384b8338efa0e8ae585c30431e93033c85e9745ab5d3dda26df7afde0c74cfcde18a1bcbde9b31b8ad41b4dbad46485262f27685d62d2c4300c647e56815af2616854992933db6a70f6dc6081ad208b92e9aaf5e30d70fa36dd8997da34655409801c0a250153f63e8f505d3a6bec32d775f034257c8bdf0fdc460bd14eaf0b889dd51e90629a3362ed0c9b1a921d456373112ee3b45e27b604c6550e47e87e186d62499c9d974aef915ad452f4687c92c296f5ddc405ad4af3de452677aeaa980626827121482e00e3f29479d83d4885107b0cb3f54d587fbb4214ba4c0042ac592029e5e9b7c4cc32a4860e075beb182159e73c5ed35c2c8108360ffc959e24ebf0b215c9c81450ea6fcb98517fe51410934139691295b43faf03a343862efa22ca279a69b0759790d3243f91e0633f392654e9be7453cdd543426cd0e64a9126ad217d5f95eb32b23dfbcc3ae525c6872e1c8b1e1edd78ec459e66fef8203c4a815a883f0ac7c0b16033b5358deb7a0d43bacd3c59095880e6616b9c24c75bc9e80dcdb885e2cfe85a9dc7f7568cc32b3fa99ae0e885bf47905d39986b66de4641ee050cfdb4416b310b1992fb4ddf1e460bf936e243ba36bb2105c0c35d79edc5fc0ffb34e92f2272e88c7393f8bdabf75a7e2aa3625f21299eb546dba74c497a104f33af4e2615c711e2806a006704621c159be59781883d04f22c42ca628f78935c2d1e95316661a82b02691edaafd523c2656b1510ecd4915ba848bc68ec5682123b2825635d2a60fef877812aa41a600dcf5937f8f19419a14e6db32cf7dcf5d72e5047a53bd4211e5ea9e26c66964de4c4cd2d50ccc4d7be7f7aef4bb2cf53f630d1729878d88b54b5f4c35aa4adfdd2600910a5ed8866df28d405158b00d6a5e76cd4a292bcbc51e752080ef003802edcae3ca273cac9c93c7b829bd96f8e49841ad03a36ed127fa962644304474e9b161964b95e4f9a09494e4362a5a0ca50635141499081c908653d576957d82772a8c2a4a47748cadc673ac0ff9b60aca8aa4bf3ca835697929995d14fce2e42f01228333d39025495e7815ec05338315aec75fd8423b6335d4b62bee4e4199628d0a2c0240c7eb2a2a1d38af6b214e5628bdce780474a8f300dd338c0af2ceb701f7f8656686ac1183e11f7e1538126bcacee36bd8ef4f33cc154e2dc00b8fa60c4f3a0bd42bbf3da581bbeb0930fb6c6a210cc17a437c9c06de72af40183d72379d98c4b71229ae08bea8b35fc866e774858909318af3b27b7fe98c23af7dc172583c47edce7c006b3e658539666e431f2be299eacae699c7c4a962f36264134862373ba94329a397f6a774a3174cca611c7328315269a6de5c17ae61bc5592e0db141428e59f3a622782db0544cf9ba4c806d4c6d74c94ac6cdf84417557a84ab8e6d5b29a3ace13a5c699081837099cba24b1b698571b0d84f5f0420083855edccca8aabc44168a20a5c20e5ad746f9a3738c9c58e1bb1fab48663546da266e0bc9a345a284c9cc065d32689bfc72e24aeb3067a33f31b43a279f882e7fc4874613e312795ab640bc048979df1718aa560528095dfb6d8ececd92fe0f4c239ee0adf7b262addc4fcd7480484167ba02ee11dcc69f178af6695f5533fddbde005fbdd16769d2644fb2b2da8c8e11bb68fbad0fddc4b603f62c15ce06750e3e477d5b2886609c5162888942f5f83488da0650b83c1dc388c1fef11ae56cd4eb72fee37f274df71ffc2dfc97101170302a13a5e398f8d9b3c1a8814c3a5ee475a8814ffc7f8584ce2c50273c8f7faf3d41eb18c9dec337cd5d3a22255027e55f325ec8c231ae744ff16046cadb74eaf7bde703357d81228df3538403256bb3b1073d89ae89f48a69556acad3f26b68939d9539541a0fb8c60824582d594ef05e305d5a86859969a32965dffea9e9e38649d0534fb4df67ef498f8e2cc820703ff244f723298c680f18bff5eb86fe6a6cf991b3693bc0d9a40f4804fcbfe6a54edee768a76c805fda2ba4325b79b20650a463e491a95e83f1ccfcd0142d1f57b33331f437c7af4a36961ce15eaf25108dbdacc335377748c2455af97b523ec8bd02137edb2667275622ce10cd5d5dd28f29810e082c3ee5a6a483a0b79106acdc8b8f15ce811cfe98dae700d543bd9206376040c49409a6a7b794599449b4de4b1d9dc79b7a01410752e07cbebb1c282380b8a44d702d76e2e111a8df5933c32657693c61966ac1f8c437af4b2bb74c8d1380118bd71ef8a219bf6f08771c72b29748a449baf0011817653b6864f48f32e49b6eae05534d526bddb71b2bfb485693192488d7ac1c29b47e6c9fb952aa776aa17929e3e8bcdb2d7fa9993545170644ac114500320311a6376336b52c66b58f21f831ec4d2175c391d3fde689a494c89b3680f6aba714805575d38bd3ffbad5c6e2f05960d8e9f1b00e05f5cacef2b93f59206011967180297623a6aa79ee84991f5e8ae71446917113af4c5a2240344b3991f1f584ee0683e406fc80d6f04884a11f1e8e98f4777168d0d8e740f50e6fe553a8090d505c1c9017e9ca8be4060836ee20b0a67896290201e9f2b129d4d1ef47a0903254cb770849d4d54949075666b321b563f70d15765998823d5302d34e619e7431f4c7480316a7c355ac35c01935169b0ced2a89cad9d16e991f619b59eebcbfe6602cc8b43540113f17e158d5b00d1cc015075ad9fe88d0343c8e76c69ce0bf4720d3806f1a2482baba629a23986453ad73ac198b75f7e29d91229f5503e48e7f0a44e40a184b377b04e2f0300dac8da39991847818c2da07e63b401e51f3c0182afd90e337df150ef32279aabdc2f14c4305466c9c8ca8ffd424324399b68488eeb20d832c72f3d815a708764e5508c6a793134d919e0b3891899e20dee2c0f2e937fa9304a05704d8a15c1f1488c3ab8ba6c5176940041ae38ac9bcb6b15c9fbb849579082da3ddc8c545806283549475e70dde6ea75420a33b46ccfcb6ed29d09e0c1a7914dbc9a66cee8a545a5c64bd0d41dec4a9bc6bda6c30861cb47656334c156e5e82dae3cad16a7eb806a854b91d0025c848e07d8a8b5e1ea883eb5b4005d852093158fc3421b91a47ff2f7ecf11aa946cb73db90dacd9ec8b5463e7c908258f68b3d2aac567e14f197779da4615e4aa1a82698ff3764845d39370c1dbf59a2805cb12a2c7eda1ec5ecff92a004a09b7e20da87838934dab9f2667f6d9c2abd3e8b5731012725807d353ae3d150f60edf6bd6ee40eb1aa4b1b447981ea53732ffc2388d55445b5dee4fe3a8bbea17bbb952a32d15c36acd7229cdf88af99a37db0b867cee65e9c6e3f1dd05d61d94001ff420d8efc59d45f9c8c14f2bb92177465b6d94ab651966e96ace8241d004806d69bae922d74e19f81001747e228bf132593c60ebec5c7a2c5ba56902301a3407de10ce5033405658543143cd425c5da4e425c8fbf876b0d7445efd14b3033763480600c3780edf86d6001cee610ab8e50e042f44aa1aed4917988bb96f45049f5bd13819553a4c29cce2e688890ea55dee39c1efaa3c69b3e421a0e9be495de02ed1e4a2029ed104cacb3be35ff72221f1eae14d5f64d3362b6dbbd42e42edbaf4c250cb38bd408c7094435d0829097bcd8c82676e88b12f060c8fc8cdba3bcb1539e61c82a223493eff5d530488cd7b91d3d68a2246c49111a4bc36e0a6291394b1ebb33d4764f63e80827f15e5abe1e9381a1bd640dcdcc5cb9f7e10f3dac6d93c3d7b58d300972dc0a786bb890b548e7b129e10003aed784e5589bb28c690a8a20cd62cf1df8bd4dd91cbd5acfd4cb6f176de193d65f8d424c277ab1e27eb6ea99492e33dacd8b43d8c3219301a1b221c46049e30b1b825632880034c4963182d4547986286ec9190299d80cf91833a46d97215cca24cb5019a2d448a2d70357c477fcf785e289e335f0e3a6fb4529f7c237eb3daf208fa462687a1ee8f0f90b1f956153961d842332c0832a8965a4786798dc977c99d0a394c43533cf4a98e8c8350ce9bcde96bacfdee21fe85472cf8ffd539eadebd153ec83aa840e10cbe8310488709ad607cbf301dc8741a8ec840c3774b4b371fb596215d40b468d7cd54b2e3c2931b57faef4bc44ccb6df8a4b7412066c3d61516916dc82f1af1f44e109178b75eb30d77938897d6536c4f5cf22ec3c8ddfa72061c9da761e2648b8b1387f1c8e4e9cdad4972b3f57783434c6a2a027ade3d9745071afad7e674049122a5c389286e4caea4e173122455b01d1fc7582afc03ef845ee730a6ad9adeb2867e2f22416581e130c1de2630ac4071a9393335c3e1ce4949d24e6be0e586d66f36407469e900445db7f5461e7f9b95daba0e7214e72052cc4c0f5d702b950b5afc29d574c49d056d76630799737203f05ac6a439ce885f86713703b4d16a58ab489f6281fa1312718963c4937ab58459d80656d7a7f98b7dd5956eaa651434caff2edef7c9872442f7b9e44dd7d1e32ad49e3dfaada55e32e82339859fbda129a9dd1406b27b483cff087c15c259c5198aba78f5b949533f23dc208e5960b77c3aba7d9b510ff2ab3c4aeda6ab53f1f3e1ca3691882a1092934cc0c0c0c7584408143789739e0ba2306734c7b8e71b0d3b595ca6423680b9ea2e08ad076f6b9f8567490c640ff253681f99370ea72f3d9af83b98395231440b4e77152ce0e7514c86404cd888e147c81f60b5d01c8ddf5dbaf8528b3b8ee0570a17366f5100618dd8a1a728dacd4c3393c559709c9e067f15240bc1d7c731dc2e11c7d866d3403c2600d6c242a4a75d6bded6ec6c8cee8d48582c8c0afe2c95866207e5226e885148d6492ecdf82717463e8d11c8b06ff1b1ad62ee723e353a88d97136fffb9fd4f56e08e07e8096da83514737307f751017f1d30ad8dc7c626eb8490d4dd79b38588d0dc0922270bc18198b6ee36526700d2a62a7a1b738e258dd14764109adeec4e2ecb111df84ea810b4573e0ded2fe4c506fcd6090a4da597dd0428d14e70eb399be6e24e1e5b9ea16ba727ace4ef829e91f9d614dbd39be02d38968d5ab94ed0ab9765a4aa09a3e4bf46f49b4de1765776dd224f0a0f4b36238ab17e21cfa1b77d8e07f2c8f54b7703f02d98c3d6e7de6f290287867cdf1d00afd2c93c8025a1374f8ae528b21c143f4726f3a1b1b0e382e7de2c66ef19016305dd98fd01af7042106942f8e48e365937469a9e4a073b14bf50cbabf9a93d568ae42955a1634853bae8f0f7c003148b4995f76f0352f7aca9f14d32e7a5f257757b91e4958868e798927910251d309dedd38d95f9134466b7605077b84c9e3e2839db0efe5acd2529c7dee3af9647021928353552dc198cc11c89c39410c0e7be169035915b887fc72e48c617f2205460c0c0c64bc1f57ebaa89f5af495289bce23b40bf1298788bf821a259e023058c8eab01ee73755215a2d6450fcc64030a289e15ffdf25aacce8d6f809c068583a3b72dd01d91024b1791d9675cbe979c0e40c62b56207d9f7c4f841904fd933d5922e2a89e8d52e8657882460a25d68b6d171aa72f113166f279ce2e5294c326cbe1e02a630217dc0f642455e20eafe1252f3fb6dc4477742eec178c783dd73b97efc16b13da6cc9411b8c7582e910b9fe96adb64f7b82b93b97cb72889a94c84b7f9a3715897f666170783afe161eb1479e2c1239ba2e2f983e7b015c9327392115c440b19959e18870b38df5317c2086603728a41b29ee46877f2793ebb9b7e3005a1f32698553f154a3087e0b953d1ded30aba896bda8ad2032d84c9b1428ffca6f90b40ede151db412eb3614b535d60f391119d315c180efc23989e5be8a0e6e07d3261d18189281112d653a90df30d03e2ba0940bdd4c72e4bd780ce7e5d9cad80b509a52586441894d9eed800f2cc8d876426ecad237af8d4dcc3d01db6d04c88a8b53801e230e603d48d1addeee7e02df0a471a40e260df832f0ec2770ac1580469ebaf99f35eb663d60a1cf317010dc063c9172231e5fc0eda9e87da7bfb9c5b402ec14900dc84afeee6694e0c4ff8fa8d8f502af6f9400106125f5a5a7c63a850e6d1c0302072b9bcb5335aee60df367a39ac616cba664797d9faf0a08d61b83d254314fe6b3e800f9a4566fa21e0fe5dade8fc73916b1d54a2a38bdc4cbb7da4a80d4e90ab43fd42061330fe6c70bf989e325ac99001e8cf21ed9af7dc41f008494d6195bb613230248dd9630ad85586273324d0f3c6c385796a7e5032670ddd26b3839bdbebf9638e60a373bac078d5c9ac753fccb5a03581a9b510028fb16e395e931440adf927866840f25673f770ec17c7ffa5cf905b927be95d3767e1b0e980c671e032555dd6c9fdee681ca0d00e162c2721446bccb6efc554e3044944f07bea5323bd9e42a4944935175dd897e11031a2434dff54f00b56a28bfe70943261fda78dd7fae152ca1113ce61eab88342af2cd8aa12c8e25e823b96edd1fd512cdeb83240c36f0ab11c13be216dd0d838fc2efaf63525f69dfa03df5770aa949b9b9e1e1f64363ab501523219bb31b5483da739ac2fdee2d418fac32686dd3ece5ce7f2163fe9ac4d5c6bfcd8472d6fa8d80f364f6ebf4597f0ada694b9de01d4fed04032e7f5838ccb61bc64ba05f52795fc9171455598e84fbfebddb60567ae2dfbbcebcd6c6524667dbfd8eae53fb5ebb7ad6398be95edb5a27a66d87a09cd2cb6b23d2651b6bcc19fadb636f146ae8b62fa499eb9ce887d5be87c11ed332658eee54f10ce396d682d48697daf6b055dd480be2c21c91aa13dd6d0a414fc847dfd95b6c1896f3918c8aa58a99d5d08b4c6d6a84532b95e9a544b31d06daeba2ee4b107cfd770e2259472a2810c494bf0169a8b6f69a21631e7627c6b87993c0b6604c025bf8b7a545821f897802ae118547f7f130506cae280a0f27d0eea55961ec7b05874c5d3285ff8f40073b96a77b1304f0773e21aa42e4d61d16d423614c1f18d4f5ade667e91cf0581c76aa2dbec3609b92b6199d3736e2ee80f18c782e636aee5ee5d22d4c9fe03dfae389620f32d41125b71b689342df97f19562ac17cdc44e9f4c4efa7751cf9a8c213ebe7c031a31381f5ca0cb5e362a67a14a1c049c18dbd863f07700aa518df8dfcaceac1528ffa0601fbe492b1d30a783ed1a5b016d8ce358a4c890514c0867423f447efee3e198a7dd28dd2b0f9092c1c2e5c22196f77d383ae7f7785fd175c88c409d2fc8aca1227940650dbabaf73f0131054ae89fe9a74a186511e2c8f827b71e6705a9b594ea6e37c7e495b5ad6000b33dc430d7bf72ca48b33470bc1a7e19e48db04e3cda9d631b99bd036252c3a9b185eefadb4a0126527c9e0ecfa609aa489378c18647126a64dc82e9cdb81689a7c90849d150cc2e28c160733b2656e781287316a589c79ec64d692bae4f24cd8e9e1d80f1057cf770cce199fa235e2e99a8b80d32d8fe252064725c763c3ec806b219b37188a9d4bb8431367747b9c7d747fc7249b9c3b8917a47a9ed14da3d16e7f1768fe0ea6b9b571ab47bc9aeaca7cf6ce007d8f6ce95ad2598ee8c6e780d598b4e10a05cfb316c11908f8b2225c319fe41f64239ed36eae875e0cfa44cb89e7a58d8824e2cc51aba1f115098838130f120161c187a67dcd808a2147e0c47b678eb2593b1ebf49e2a55777e0bccc20cf39e6ea03f5937cd07f6cf1feacf7a30f315101c4d660172b437f409c891f71c90ca06027f7fce18c0693e7541ff01f6f5d88bb1915816305db5aebf91aa9270c2dbaa63224478595e5c1cc8c01d2c40d52a030b2441934fb22ed17f96bb3df0b9137487b08ef3eef26a8991e3cca1130062984a9787fbad79bb9ff89a98db2c2c1c7ae26db999663a9fafdd7e8f5c3538700331a302ba0f5368ff3b9794787455bc3c0b75e35e46f0ec31f34a750479d57207c4b232d163987aebbc388316fa521fbbfe6c31c10225cbd197ab860b5586d1d1f37be3a02f56622683535aa80fa53ca34d26b6f53636940271ad362854f544c8d08cd0d2225fead4419c384c4a03773a1444f21ef2c711d936edd4a6f43f76a7910dff85f1ed52902bb0493ee8af861fa9ba6ab39b0cd2d91a0b938b542e31347fba4a5021aaaa9555c40d61da503b5df11467fec30c11d2a27d9290c0bd936377a8c2018b0b8d080a721e4d289056ff025c9501cbae8f000a6efd8baa3797541b74601977c5b00b3353b0fc8b7623438dfd2bdce74816acb6f89dc644bb9b794524a29530a26050b057a05d1e33b561fd702dc614c0437f6ecd07d4ea773ceec6f2a414484ff5fe5aeabe4f74e5fc688d1f7689a793238ee9fc729d337cd3881e977a5d236f3b847b50735ae012f75bf3106782a09dcdd126e1c97ef5202f4043a1c8291dca590df45dd5753237cdcab504609ecd9a7097a8cd1aa5346ea233ead5be7a3e70e8531428f104eab4e28a50b19a88c6fc6fa02c7b263fbbcf1d94da31b703c3d209e4811c2107afc3ad169c5117d36945fb68235af3fd6bbcab0644443ab7aab9093e9591eea224211c52def228a575c443f7682589efcbe9338e47edb03c34483b32258f3ea2c729e9d8c4b7eeffe5d5694dfc7c9020b308c4f7c68f35504cadd1cd213001ce05609e188853e843b5fe580bb392447ff3151c19dfff83cffc93c82f21c1234b10431f28472110254aff004b1b2b6f85c3f8df3e4104c869a3c851ef77ad54014801dcd8b9902103587bca087c45f70223ac67b8e7bd39b431a4bfef979fe538b689b1704dce19ffc9ee90976528360dcd0982eaac68b5d1367884a39bebb8ae13394a40670198a2b1af8e45ed180271720f76a0652e6cb9c874d2bc05d8cf0b5cb51cf4b90901cf3294a38b7b4148243ee6a9e5b7295b2c21d76250b6158de15ac28bb0cecd19df3213f6111e27c28be5f9ea85d9ec7bd1b84851c30fcf81d768527bfc7b03cecca9321ff6157863aec4a8610e27430d3ae810fdbe137f73cf023aa53393fb0c7cf31037a72f32120887229afe67de7d9140cb72abd1271224f5906b3d1cbb2a1a1a17e423c19d0ca32c8c1a0828b373937b2868d5a34af4582d251da66fe8be9f16ffd6a869c60b75eba66fe8e0f09bbf46134c74fc6ad54aba5bf2c481400f33d8d8b6b59ffee5b17f7a2f75aadcbacb77f692eb21166d5ebbaf7baf7defb96c6be2d1a9ba1c57d1a03105effd54da3b9777c32971b892e41b265417a5babb537b39a8b6c845dd6da4badfbd89334981d8ba1adc8946e2f5bec3ef6319ae7927d98af3eb2b558142baf8c791b2d46a3ad283dc562800dabd7ea4e33ea3800b19f014b9af556ab9846612e4be66233c06e5cf4c6944a58707dfabe5580b6c0acad8609f872b163021746a3a1f021a30411c8649171226606478e95c5683414a6259892c0e2c5b5aeef1a4804d9faf81b826c4590298dbab998e1d6b740906d085a6037eed799dcd10dfb12a515d65763a5d3a2965b6e59ee0218751fc87683b2021746eb5c6f862dcbb22ce95adad740311d0cf80c23a834d7d9891e379f34e4524a3146c77ac932d25b4f7a21c5dc6a65b4aee68698775da4829661fd7c6bb90a9a9beff31d87c6b13fff02f32736cdcf346fc26348996f9f1245194adb4c27bc09795271843c9f6e436d330202769f274348e3789e175ce5eef5f05898c2364d077786a4565f4762598d469d52b7119057c85da3b520a170c87ec183f829db469bf7e008e22f78103737a713c7fd0a061144dea0515e936023f27befe17bf02171ed41e918efa7f6a234f7fc499527af0a538f117aa6c8efb90cb5cd0fa4c79866decbb652fca4e49e6555cc8fb48d633a53327d7b6fad556a4f332d947ee59472f326bce6fd134451e4f79250e4557b539a7b4ef8137fe135e131de376145c511f293b244aeda9ba0df1b3581d6311f14e5ee75813b291c210000bc78896914d6f08f801d1dcad3906ab12258beda3a1095e15326d58ab753b6492d46686dd540f0b8ba737aff7ca79fc31111ec1df052d8d603d6e00077bde2e201af794f821a5690dfc7f726e85c3bd036af47dbbc6f82bb5ee1c8d1389e9fa9c238a3b4b1529ff55a810fb9f31ef27be8fef3dd47964f297c18253b9450c6ea32079c4baad5faae649805668151402c44300a98056699315e7e55691e170992218ef410486afc61e527db6cf4048e7586051af9f844211d60a2bf50fa5a4b7f29ddb0ef7096a62c5f30fd926551ed86569f1672be6b21e297adaba486301b114dad8b42b2fb644b870a3fbe8f38583e961585b2d56abc82afe8135bd6af1055dfb22c6beb1cd2a975ef01512ab66d168be410bc51fa30ff342d628959fc856b94b9e0820b2eb8f01249d726231683d528f03888e5c9d032dfce093c0ef2f87e9c056badf58514b1d6f969fe197cdae564b8251665f914c3922516615aadd10abe5be723462da7af3169d9b688f6ad46c5ae816fade571a3256af118f3cd47b5ae0019da0ca39688256a894524bf566cdbace65794eb8da78444fa39bff455b33e8b79b9751b881d2bb6b6ee2576c366b93d251ec3fee8addfa7f3de8c8cd6f5edc5e0cdb0bca4795f60301b6f6b98ad1fd76df3b81990a475aed83e0dcafe99d63da06c9fde870d645f511ed52730f680aea7a4da27a371acbfd7fe940fb11b36dbcd8edec5f092604a988d984bb105d86a8daeed7d9dfef394b81125fe42eb4820f8f22e28b669948030c8152f880bbb317ad25b92c75fa01bf8faf5b17ac3e6ba512c86aa991e372ba633e1cce339df0c985951bbf2af0bbf3acffbc956c374de3672025f5b90fa9d65889b253f62376cb636afa1be657d8dced19a5d0d1e23c8674e6fb04dd35d3d393e108f8b48da26fecc63cb8757637ab2bee75731ebc7027a9690f5f3ac9fd1d3e4bb96816bf31eee046be28fb44e59cd5341b44edd1d1c435bdf5d3f72fcfbf62da29febc7c553ebb38860c7b77e1ac73f5a4434cab248a468fd98f0cd7327936f35440782af85e171336e1e57a36bdeaf6ab7cdd56377b04d036baf702480c58fa08c3f23a418ed4711d203f954cc5bbf31d4ca465ac9d2515fb616ed38df5e575a37fbee6b7d36da66ead880167b96b55062d77d9cf5994665b408bc9ae942d757f2dcf0e3acb7b61a8f9baf83434666c3016be60be519a3e9782ecc202eb973d5489564a3713a5b188d313f277d58fd861388a597623ad9572dc80898af5af631da8f22b8f412d321bda5401a2312f3331ebd24cdf3c8311a9e49391e17a3790a86c5cbb0d8783e15b3e9c0f1b89961b4a4e978b915bfe3c8c10476121152ccad54bc38f991eb5352ee254d9290e9db52d0911c63de3128327d88e55ed26428d396a34e03b96e3a1ef782d17819c63ab57092b9301d5a229160de7a98128c8cbdd5629192d13a95c17aab4629bdb7861d01e5aea728514a6951f66884d8ffa7da0b8c1118ed4711fb403e55fa17ed07cfa74a0fe4532f6fdfbd2f5aa7ac92d629ebf745e3f9d4cb97b41f403ef5b235ace1f914ccc6c19adba48e40ee85f6525a6fbd94d27a6bc5688c90d8c9724606987b1ccd534a2f9e4d9dd26aabb59f0417203710a4c0681cac99ffa23d572914ecff307b5d67d20351bef1cacda48725f2ddb8b798bd15c394524b22d952e9d221f70180c8124b3061811306c8c00223baa673774d1dd2a67b2fad6f3b3e2351a7dde4d7deb7d6b5f6de5b27860941aa1708adb5564a69a59444a294d26a5dcdfa5971c95a31d5d29ec6528c460d129231192bf8e6636891b16569b745beb6d62a7bfa9cf6ddad8471302eac5e587daad1b7d6babea4c98f8d4b9ad820d3aff66231b498f166bc0b9ba145aeb774afc5a8d6af528bd67a49945a5b71adf5568cb3177b8172a7805a6bb5aac906263f439ef4ecc08e14d3a1b0e753cd338c326e4599460b1e748cffef1d1d63bc6141cc183bc8e827d5249a495e67344855d3d38931576567fa1432571af26de33005a7dc40ea265d018026923dd0880b247a600f62d4415a212184134a0821842b399d8838a51c8275451971b057c6182d9411c69e7be1bb129b8192e072f87f6958d9b79ac3db09427f34b2dd2077b2076b28e47745767f59b2bf2bd99f94ecff9eec340edca8942b9f2577b287cb6f4bee64cf29bf2b72277b6ede2ae790e5465d007934d2385a8ffc817de183bdfa7b4f2609f67fefd148c157ff29481c6ba5508637d7df4929a5aca628e2bb298a8e5b4b29a53c511e482320803053a033b1ef9d84a8c2f4e03b0c6f8613183e86305ba7f91ae0f74e2f55705df2a2c751e723cff8c6e9d8f315d75a2501660dad5cedeeaed13640b5060c33261a0edf3761aefe4d0bb5e28b2fae265c674cf8e2fb2713e6ea9f60e05a3ac1c0b5c4d17c3dc1c0b5846bc90ae0ea56c13219a172174a2a6b7af47bd17b381a5c674cb8ce986e4e95c3175f7c6318e0347291e394aa3f3391ba816002a91b2322c0e23e43dce7ca0b2e2d31fa4649805943b97adba6f1002eebd6d210ddddf74d27a8ddab28becc4e7c7951bab4e02c0615e6c5c55cb8bf699bfed34b0a28903e85eeee986ddaad30da866694b7e78227f7c227bef0c1fe91a66dfa854f77b729dec8ec603761c98a608706b079316adcc4e026f7c7987eb383b53e80e8a10c3f73417c0e3bb02ac5601ac9fdcf8992235848215dfa0fd2a533714781956e7264f3174b70874bf965b9713a96763a11e487e507a11f848e18f160c062897b748f52c280c512e803667144e492a990fd3b1572ffe63236e7fc4d00c02f4dd3ee31bae32e317b8cd1ff693ea243266e16badc93b0bd71c12a2df25ba5658bfcdb34d2ca15e887dfdddddd9de5807b8914ab255208d527a397480194dfdf2546f021bf2f45af9d952bf080f6f8f2694a6e3c37ef04b9f829f9d6a12925b50979708a66b8499e9a921f61972eafbb74494907282025a10ff8a4102a0284849a3461c2a453b8c2243c654ae2276063608941c5798801c501862080fb7bda158658c529de85058669d40ce8d505ddb22477980a12f10a7eb955508e803135536315142456054508942050828831b8e927f2c9024404e580044a4c7942112977ff9a1b2b728756b84c2b4f985d850d37f8e6e3480974284a41118480a4a4669814b96109289870640572073fa409a48d1935ba53132b4bdc38c2162976a8dc4025f51e576185899b5b6545082b4d28172f0210a4f06fe7017a2aa211f0c00455952caa2a57a0c81a9c442254557af0ac5055c98111aa2a34f02daa2a2d804e5055b1818a153034d00546881289562a2a3f37504245450639a8a8ece056545454d0650aa2295240c197134c5c2c68c0d6c90f5388c0aa2946b0d2667a3f98e243d014163c2618e7564da1c18f805914b9162b3e854aca0a06a192120493a8a424894ca8a404a192f202959414a8a25ca18a62254a1488042ee5564559820325ef04aa2845fc0a551416ac40158504700855134b50355184cead6ae289aa0926544d44919500f737b5ed3cfeed5faf5c1be6ec9943f4f4f4f4f4fcf030fdfc2841f27e82a03f3f52c9fba149624ff4f1d18127c6d8b18f64ff7623cf861784a706418204a981e78659f4357935b7cca2c984c9a505b6bb9174c73e125bc80b628cf10529f290b891070425098f07fea0f33ef178ee152474c7ded1442f4640023bde8ea03a04c6f8de7b170af6271df290d587ee863046a85940bc87ff607cf039e5813af6dec6182bd5791f63a434d218e39c91c618e78c34469adc31524ae7b4522c11bd9e8c74c052488e901c21393be4f8bc9c1ddecb119223a4f68eb5b6b118b1bcf7360c501d8b39c1d2a17c0e6196e70ddbfb75fb2b319222c6f8628c1d5fd3d15d5f56592dabb9c7cd2d76b78d6f3c60481ae44e9dca2a698d3ea03402d5e8835a835edf55aed46f33ac80cc4af6444eaa9f42d40bd8f456a5934b2906a7478c0c026458dca0524e607721d53fb5376544d89f85170778b142aa1f08b873274dbc09449d5255a84c9112a509282a401497b22a776d1c3780547f2d6115524334a97e676209259e10610514567891ea77929ae1b840543b49b17080550c0d3072756ef84a8c2f240479ee3720400d37e137043a719ffd368e9c51816a3d9ddc3f7a44d58af1030d3142c5109c05af60c3af2ac847c9ed6784bc101e78f8e1b0568c57ff5cafbe6d9e0e86d810b148396f4354b5ecdd6eeccd7563ddbc95716445dc5ae783428e658427a7c1b47addcd6905aee635530bcb7d6ebe6224f8bc0d6293e9df87cb4d0484a958adb2e0f87205ebe5fa9c7c6d1798d57d2ef0b8f745dbd6616cca5dd43c4540249070d17ccb8210fa9545cb59d37a89e95834e8cca10307116a464ecead4552e530d8a891254a9abf59a16b5e0bef67cc4d474e16d3c645870739413ec105786c20364ac7ab793f34a4a3470ec9d76f654b2ec6d7dd427e8f49f9911a4371cd350767e0202a272707cb39784b0e13b2e0687d5b35099ac4b4d138f1c1edb482d2380b9e336ec98b83286bcb414d39807077f3a443a16ce0689c9933e306a274e4e827d1071296a26952fa26ee6f5ac0d42110db349d1bc145f89d24d0099b2a03bae6e56894f5ef4f3e04a2accd778886f84ef55a311a31b2f34c31dd48c4e19d84c0288e0666876608fb84805d1aa0f6785cb6a2d385b4ae5a1604ec9f0101fb673fc0fe9913ecdf4db07f9f7004c0847332b947db946870008a4802fb674cb0ff09c378353d2e1dc09452782ddf9c7ca78442eebf62aa889179814486c54c26942d7921f30285981740b87b421e0f8f874c952191056547643ec88cc88054d0344db3b846d17fbff59837a72ce442dd7f4f1103b0f1050e590f0ad01911d90ff6cf7860809b29c1316e9604fb0aef0027ad1b357f6e3d60e41e19127c3a41c8c2015a30290551220221841042d8719aa29031964a30384213964785c0fedeb58a7b9452bacb4803197f7087ee517a8c1ea5c32740f131ba4b29e394728bb18874975148c622d15d4a29e394536e311699a428257429dfe13b8c1ee39b1b7e891b1097124e182d59aa810968b0f3c27aa1d4726e327c8de2a4d5b2b61d443b5c40542debbaac2bedd775613af051f0d655ef4571894e6b2da603af05a5c5e45ef828ebb237a2ee56addf012194effd750111b6a3474b463b7e47e38c8c98777433779d88a384972c0161631437187c08c2a41b88ba36185ecdfb86e1450f412f3097e5aeff276062e3f40ba9542a613a34e6eb9581c166a840a9f4428ab93131984e94b9e215237d8930d8a5212383614086987dd300a64359b8bbe966f1658cafd51a3636187ac0fe7e84b130dd68ba7635a20205fd11da4c08a39cd4b22e0bd3817f5134488dc7cd8006dc4a32b84e50438eef12713141f064740d04a14ccf8a89123e23264b9c203f19cd64891fb49928b125bfeff164bc29e331410228bf87a101566cc164d0b26f381ef7268ba28b5d13fcb3121bc7fb47a3517669c8fdb1de128f529665980e7c20b971b58103630c0332c40c1f633af069661ad50d677c367e946c40f2d731e66fc09449980c2f97e401ec05ba6f8e5f5090fbadd12807d512aab0567059e258fc555d86b2fffb2e7a0efcc84b82dfc71ff0cb40ccf06bc94b9910dcd1d0703070f068c02cbf695cc008408883fa418b9ac821dbb822fbe378325a64ff1c57b2bf8e1db05d8627c98e247734f9c2789cbf77d249821bc60f98c8fc192f033143d4dc4ca64c087c6a01ee38eeb465406e3c96940049dec0cb5d2479aea22b7117a9029b15899715d85d8201f67fdddded847de153230a4f903bd085113bfede833330400e0a8a91293d02069a50a814ae985431543403400005c3154000200c08860422a158280b1475930f14800f6c7e3e724a3a95c8433990c33088822886818c31c418048c210419856cac2a4ddaed77e002d3ca9268192468c16bc0778ba3764e357165b1fe2f1f67f09cd059263e82185e37c072e21522af91c081d89cd759ddbda08e156428db1d058d8f1ae363e9b1b300465bfee473d97f2b7709e43a875f29c6d2acd3bf211aa8675c13dc6a00f1c2d3accb2df8d1c946a738e1a1f0da05315e3e79aceb34aaee59b71c3abcf9fc86a07c4796dfdf1b3298452ddf6cb1b92af6c2db28d653978342581e4407123b8d79fbd7a708faac3acb7b7df9060ad167bdf98c5f6560dd94b785b9374ed08573adb760fbc29df21052b333661c40d153c698bd0c5f613637871206f0765fe631bc7ca8af2e9c2bc118c3dd2a5405c3f111e36440cef59e7ead4468934c51376b3b1b630b87f9a23096663d9983af612a87eb25f6588d4c639cbf4721bde7e87e96fc03da1e64a9b435c77faa349d71197f0b993c14e9c797c3fab8fa41d492e26fe3c5c0cf76c334e803ba7c833f0a3922c3169c8b3eebc9c80e855a710ce5f782acaf23651f13b52df387af4fb1beb0f1336c4e5d46fe240a3516e1063a219bb978e4530b2536a34a53926f4e31fb93b203929ae1a4b2f9d6ef4be01980b8ded93751237c46ad793d9bdd0a484586cc44ff3c68b2990d31ad61012fd195c018fb1bbdbee13da9ed14551e39088995aa3a246a926a718843d7e54a0c21d1a8d41b3bc7cf5d55a9d06d310888c6a44e15269f32ad6106fd24fa872a801597006954a5378c61337b19140a680d81f783e311b1e58f99113c62ca71f99d3b3124239699f0fe5d52c88d5df28bad76dcae2b9a4f7fdd9feed7ab2443ad4d991da1e3de1b06706e34058386e8edf14e788ffd529297b0dee0821fc79ba68c7632fcd20c755280c238abcaccfe2a7c7c627913c26a1329bc4a90a009fb50a309a02c90351b2d281935b955726e60f4a2552c5ab81eccb7b8930cae7c2c3f2325eb68ba4b6d05fea237de898d8bb68f6b3deed25791bbebc6e91b2638997eb267aac3bba513f5e4f71ebe085e12f3bf48d65122fc308fa5e84ecde1c276638dce782219652743af7494523c4d822f6e9b13dc1a36184eb160e9283ba5fbad13918a339d8e788be3552a455b9def683d295901835883ae79ab926e96a258450df4744486d2c8142529e87338cbf3932b89de844fb2d7f6aad403233455c6ebc8311530acd77331d90eee615a0ced7561547e92a768561b270875e3661020f8fce45dd2ccfc72cb5c8a20900b4aa9f2c9a87141eceae063776793ab7fb46160139049f9c94f68851060d9e927b691020718e1dc82834678c08bace9217e68d748a23cf11197ff3ac73633ffa2938189a744be796531a5d07176087821b73252ee451d2b87328404d502016751860ab5721be5ad2059f40ae70faf3a6ef11d5106c1b561be06c38f651c812533bf6c90ab021fbc624dd6fbf7e503fe1466f81b43cf51d100730177e0b58b9632077eeba839016bc0da24bfd6eeb511af7ccba75b0b5c9b0fe917e19d908110b8073f186a5835e343849a6df2b1c7e2eeabab264ff4ebe2e1d917a7c247074bbee0003eb529f9d88d412a1553e01b34bedc02cc9603c218b1659c07742df6ae5cd33747849b8bd574a4bbddacd000c98b67c12ed9a1027cb0402f19bf0fdcf8a3a176aaf90cf2b1ea9cdf90c6cffaf5047a23c2e295cc6b0b213953c665d12ffd037a5ddea8a689baa9f500f4a06d697d6d1945c551a86af8d50faf690ac6c28aa9ff064025c5754147e100e7c8f29a158ee74a2f5cec53e758d2946d05bf607be09dfecb7420f508bf9554a57093bb7b11e28c98dfb8c9f45015263feea8afbd8ba9857db5b33f1b7fec59a887f78813234f26316f726ffe9a6b92faeb27a10c7a7dc15c1660897970a904bf513de0077bcb582c067254b0a3d839b15a20623001831437c663666bad6c33d117c9195777c1dea832a1dae1d67c2618cb3449b33923fae24d35d59fd93aac69a585a586ffe1dc3cf41514f51eeddedf5c374549f28ae87db19114ff86f735db7d053e1909946f0cc024e35e920747edb3a2ce1d29ac3f06f2f8f55fd593f3df34fd1ef046b463536ddddcab401050a23fa9e04d6a072e979e995dfb4e1f75a96223cb7cba971ff468f78920d2d110ede0a68a3b015b222d54dcdf033d8bd8255047f9c58ae85856d0b55b5adf7b7968919b0d790c2f4215989b5a945a5e94cf67df7620a271df65050651243adc9e0b3bd82a19ebfb1fccb67336007d66ec4bbb8af4c6c23877165a3a543eb39475086bb8fee5038a23664feb2c92ce4cd97e6852534c8f474ac5b929b9bbf131dc9451b22fb352fc12e53ac77e6581a360b30ecc25e7602fb14eae280634494dd618b32e62160cd153dc137151205f77d1ab0963f1978850011cac5afe8027379b261bc94d67283b2fd5584d2642fb43aa8e9c1e1a63e3f88555b8a33fd7a638b5322522e9211b908c4a54433ba83dbd70c4db6fc4eeb1d08c0918985b32c49de32df1b5d70dba16fde2e1da53964ed00df3012dbfe06af34bb10272ad759adfd83f1f527d9b0a87d1ec3c7ca75d27f7b1f7d9872eb513c0f406a9c126090d44c2bd11ae3ddbdfbde150a0cb6e5e981e64651433ec1187c36c37c0d8e54ea5f408b1875db54f84e496fa06b972eb99d88b3e2eaa2d4685a6181163100af2d8af397e9eae34ef7cf62fb32b31d9daac2f4ed2b3015e410d5bc970b757c431d53e0821c972ecb3918efc64d2fe6f63ffcbf957e040dff61263db1fd1a25cd882e2162e25f4d05b29d416a7315eeb9dbeb72b3e6e70a2f9879975a27b17b741624d76f01b4d71c59af61546bad9ef780ade11f60e527aeac77e19b104ccc48b39d440d6d9f068da149fbb639cfd75ac5f976af6bcd53b393f6cc90d3ee80d42bfe03bd7edc4dd2c62ad1288e84628fa6c58048b4e7292f1b4409ffe3d293760c7f186ea28a3aeb05343c35ae66913dc9f46126e4158491bb285f8e190e600b85d39c9a23c243d8fc15707bc48ae41e2c09008565991701a6e180888201b67d8fbf50b03894a3228c5785fc553d1cab2b5ce38e768be69386e15b6335feb37e9dcba6b4f90c1138e3b4a79be99c488ad65e53bb22c74ce51ac1948f5e494e44c6a7ad1a39e96f17ad90e7fb0c57753dce41e132d5a1d332c010d20aea6c878f3af3f6a0defc2efd0aa81793408f9ae18aad4d633220828f7845e2192a639a1321918f9d34831e20bf64b396341fcafc307d37add45c3bf7e189e8da86dff08cda8e6a6910372d2dac7e5bf461911228f067254c80078e0da88f3ff44e1fa25da592f1c2d0a3053b472067fc5be8034968e2f5517bf4c1e933d3b8eaa45602e312a9ec044b5175f93c91c2c2542cfef165572e1ef117ade45c4688a543872d938d49a5056828f6fac91f81336c2a3a200438511be3cf90bec8cf0b2be2ff8dd080fe307635584b86daad928045dc80891d7d75415a7c6eb0b13e6ffac6850762ea31f327962322be113ebb4df678ca8f00d0ae25b367f2c16428b8ecc3e04dadce0257c4fc0869c702c7ad302679e09a4d64efa2d3cc8fc9ad21b718b962bb6f0a094352ce56f1639491dd533d3902ca330a0c544099bb5f5378198d0f3f623956e2bc22b98fc94fc98f82dbdd3d09c078265d61b1d8eb807dd66d877d82dcc8f5829003be60fa8f0bde968c7ed276dc345fdf0232e0f9a25a31ee214a313490ab1117ad46feecd33f758639d712261e9d4265f58d8bdc8d9dc5913774ba5db5fb09e25e2284628f29d03153eaf7d8f770d44898f639fd25e103e2c071a44b8f2933f41939c85ec2052e6c2c2b16e85e05d02d8b793ede2f000ea30aea998fc761fce60bcb47283d5c52c70c85a2c0d2c123a99cc7c024b5813e3c0f9f7330c1d453838e8779c6a6e57f212a17b2efb9cdbc4a57df63613bc975342b07236c95244404958d596bb8b64f7bb2649e80eae7cdbf1bfe9f14dcab959d2783dfb25a6a7556a59ce3bac104d35ef53e186c0b62f6762704d84614a53abf85a537228e82b633e21b9b97e7d5a6c7081db6316c451f55fc26cd2c9c0fe2acc51eb1ce97b5678e0a3ea8f71f5791a2a5d05490c892561b9021f7c5849c95f84cd4f134be3966badd024db0d38b7e46a9168129beb3a955445947d319b78254e5aa00b3ac8cdec1e3f6895dcb6dcfde2bad5934e400932e1590d09bb01d24728607076684b0759e01fbf139ca27a811144eb6578e1bf91fdb9e5267d288032571a7cd0fcd2f3a46005c0e9eba2d4c9587787466aa437488da38e5c3d252c5d4220f5e726ca6c004c0176c5bda32dd0f0a311af71ff269b2c698db7a0c4dd79ea90142f3d012eb325db72278e900ff7d43a5bc39250d18ae424dcaa7703a62f7912eb45dc007ee35cf699d945be5d53648a8978f638b7d88bf69026c5eea5a3b190beb303099a470f3030234b837dee9c4e4892e5fbe2854fbd9f0c07198293c50b14b3ed63e10fc3a4394c7d0c3d4e734cca7a38bcc6decf18cc7966952394708e71fc447eef4de78d743a18f5b0b80d3d629fa652bb5db62ac3118de9a74c0788233a3b53b961926114b1c69d3484e35ac8c3a5eed55df93285def280f94ff35b64b83de2d824b941531484d69704f58ebae8456621460e63123245381f51e6b8dc976ae4182fba588eaee47df153ae8351d8f768d07f0d45aab45c19441d4ab9eeb02e028f37b74c5144490f1254aff419b1fee93932a0295dbedacefde1c683d3a6dad5ecb83db8a6a7b1b989ed26e045a5f6056cbf56eeae8e86dbed655d80401a7885aaaf890b1ae5c1b33174ceaa068a5174c874419a60e4822f0130a82ad9662a85170808f401afb4b03efca5025c20df5db8bb37db30ba22c71e5e4d03032733935d5d405638d72a45becc870e43e3e7264a98083ed755eb03994ae905641c6e36b16de6175b64380b4ef973791e1624f48aca4ab81a623fabedb66ba1bf04a52b02825cdf0fde54dbfd9f3733f3027ce57fd5f7994e71aa2e99be3f1baf26533cce8aa81dd6c76c3edefbc9092fe658fc93e439a77f7455affee7d8289c8922b07b5348ebf316a9bd996fc274b92520ef134fd88d3af4d381c8659ded05ecea4aca364d4720569afc025675c820eb2ec5012f8ba5705409bee3bdc26016a2d3f03f0c089c7c218dd71b481a15bb0b82044b336f4d73aec127ad18b694a8fd5150e490bf296e4293523a3f5e592ca65b238d84ce606efa69f69f2a4b53c1fd12ff8408caf04f362d9a16261a97d737e7ec864b1e390d94259730e0dbfde17235b996fddccc92ecae3677c2b4ca24dcb135b13a563cb8047a6cc04f94a0603f1fe8adaa586dc2e20fbd7a512561b39dc24105956ac65cceca72a1ebae699d942bb4d402b4a119cc128fc8ecf2add127d428b32605a8601491c72df9c3c5f6f3634820ca9485e0b9d1bc5b9fc5bbfc84b38a3216c2d39d0d5070b82993cee9199946438b3365bfdadf2344976270844e4bad8b05da7c3c28290a5d986bd0828ee99becd2abadf6dcf57c57c6fbf294f7a5164b3c1b58f6ed9c71f2da1e2d166c4638863ea7a6173798a89726459e5907222f9c194bb81f955b674dae3e4e9598e7f7e729516214fdbf7265ecab0b59ef740bc7bce67540621c62c12bcbc9bc2862a01224c864fa92b536ba2677505581e7f8e92898de4041899778809e860e5f57e45a42cca607bd239904b9d8bf863298e00574d24711ac3256a2a2cf59185d5480b6c7231bce1753aed32987307d4eee3350b8d1a0d49e07da0f17b8b46119604c8b8654f6e74bf27fb5fadb86b4507ad541a9f189f786c80d6cda458cccc1fb4cb055878265c0c4f9a9a7a01c1b778eb226ce02b3330673060445eac3fc6641595650b1071563101775f36e22641a27d6aca7f201bbb9c33e4f267c95b6a5692ffcdf2c59f408f60acc39174e1ce7ff45db0b0b53f0317f92fa1ec6ad3f5aab3e8571da7933922dba885e85e24ab9a9ca7e0b739ea812e7b5c86ab832dfc7c3a8fba746d0efa2423e96ac05e4ba8dc43b8cec7e4cfdb9c9e7333f086dcf64994af45c848eddbb43f008293c5aee0bdd30567cbf85fa44a33769fa1030a74525586acdbbc7d1d45ffda1cf156e02bb4bea65a23fde0a7bce6bad23de58698d1fa4aa139fab64ed4273f124af51a0ba833e911fe8171cb77dd457daa89469f19fe63c402ee26856bbaf1dea47787c6507e802654768136250ecbe06c2edb093f91e1766fcb1ce9642af51178e67ddbfd099f59bf84d82046f3164efd829e9061be1331c6dcc40d723309ae28ed944249552215f997847b45f872deb967cc1c72ea503c9ea0b55f0beeacff01d0578f69641331e96758304f74cce3c2cde3020684d981daf4221154b143bfbccceb0280533e0b44801d68c3ceb4f264598041804f7e7a4c6583110a8b2e44b4c50c0429f2471e3baf00a81e6e49551c583f17b355265ee34f6861b770d26f103b1499ab706c3a3f159b12736180e59d77ba60cfe5689226648b5604d0430e4b31b2f9ac1007aa0ec021013cc40f7e10ef2627ebfd760cef7240f9b1093872a7f7d3dbc76f189eee6d6dadb4d554da710a60365e86a308bbef7b24bff00d5d30941e86e8ccb3ba0764a3c23f5336c48ee3492e33637ce2353eca2d72eaf0e14c54139537f03ea8f2bba4be5c3f2e5c9294d4a1a600da177cadb0281fa75105edda4461cfa357c63f9414c36d72861cff7aa2d01e6ab2fd9d78621358fb0030790464a0e5b7645d4c7e5657d3c2783e1778019e54b423058972735c6de7f681f00a4191b3e9db61cc5f2beaa07eb23f2fc30be35e41a4a2ed50cf5451cb4e2a581a4c6d59547bcc052837c4e092686b97c326edcf268dca437b88409e66340794e4cd80f45e824ed6c893cd616c6ce4337c742120d7e85f00ae2c37ff487b2fd5b37472e6e39b299d96688d8f5f0e29c4e10cf5c978bd357e97fa151690b95425bd7970e6daeb2af1192ac10c105dc98bfdfefa25a34fd9c6241358034945cfe2127825738d5824229587790a9616183fb42641bbf57f1589a2b02622a807fe2896d2d19c05b1b22edfee7835f1e70ab23935caea1cf14d080bdd624bdbb0f426cb90b1182c7c9405bed433a9362eccaff490d0164cb55a45950a4328aaa85aeb5cc8208cb21a0a80dadd6cf7a52e5d54357c31d8a0c1f547bdf3e9776629fc303aacfbd95bd5a21d8d613bb9e433707436459ea81fbbc9fd850fa83aa7ea6ec1198da8928a5e6ad9fee728293a8f07ea629119cd4a5d060014942fb0550cf58a0cc406cfb48bb19ac32138e025b0d4ba0dc5393b411bc18f5c37bb8dcae29abaeb81581aa079b74b84748f9305153ee0b1d29a9ae97b327839c3eaf0e256590daf972249e058ac8ee325117ba30c43c20799c27aaeac4516fe9bb47e513482f7c0297ef6d244b34ad7440387bfb7aeca9d1277b910f663b9906f592ecc7077fcda7ac2bea49a23403a76ddbfd865ecc8b835ca49337bcb7d34e02653a2566c6cfcaa295cbf890df73c460cb744ff8f5e2572e493693287ca54e9fd895ad38187aaebd9611561e1ca7ba6898bbe5672d502d44cae1b89f4ad56264652fb2093eaf9d05793a7d87ce2d7097792f77e6ad888af555b98ddddfa55481bf2f47649899b43f96cb3245c7e72bffb51246c6a70294f167015f7439d91da48b8364bc84cd2e19190aa4a99c97027c20e5fbc40c6811b3ffb24bd5f249ef0273d01cd576e956fbe671dd32b338d8887cbc0f45b2f882e50be868fdfa80188a487eb21f600c3b8ddfc2e823071a1ae69a63fca924d40648a7d40e5cc3f1e771ea103f5e036d5ea22dc916b82d825db550091a2255b9273c919cec35b693c0b2e275ba15b4951af0644959599b3a8ab535b5c360b88ac88f98ae14fc1e159bd4bd05353b4288859e57f7ba4f04ff3701190023c1e503cbb7afdc7d43cb6403acf063da521987105dbc94b92bb81c409ffd1fcaf4211057a9dbcc908a5f6e9c7c9c5a011592d8003ec7afa951806ef70b306fb50544c8539d57f46b07b3ef2c5f330f0618f2a7c8a6ee2ef5e5bbcc5a10e02efb07cfbc6de3d46cd6e9f999ebbc65cb9ba6af56a3f8204c3984e72dd18f37ac4d114ee8b0ebe8f00c4248d0b201f90f238d332e044ed3d22a4ae305c3a3d642542a9914defe4386259a6a27144079069d5f6cd03fcf9cac4d0cfe7df0d70685c087493f9c34719740eaf41cd4df164b774cd7525b2f80535b6a9e407024847782942e940e72e8b30b6785fca5a210d5734db495497b87f8c1bb8441b10a59acb3036930a8489cde401fad860710fb1c52420f5d4f9313f7343970cb39799104fd432929c44fd7d70769288ba8d15820108d1a1592145614102ff2273866131629e106f60af7c25bc12bb93b2f5252e77fc901d2d5d683911217325271426b18138947aa40dff21b744370dbe6ca06e09deab085ff94a29cfb9492025b5cebdce32cc0b137579512718b40026d9512bad614c4a7171da442caccb3a94541ca4a494c9aca12ea4a48178104d953f3ce354b04c6c990c3460afc61e17260747f3a8cc651341d7549477faf89eebeb074fa52f27002df1d41a1daaf0bf674792d064c756734315347743ba821518041df831252e98c015c90a9839670c48952f914e0d61e3a46e2fef93321f62409532202a433f353549be6d2a8f6f4e3b3832d8a04ea2a84ea2e18740bbdc9e902240a5322b9be4507fb3b225592b52c9c9796145993a5eb1f4a718929d9d1e076ad3b023b155372fa68c62c8c29c97c4535a6644f9b267e71e8b985d0bd887f8ee88768fcd381e28ac65ae0fed96e862051a3a431148a15e1bebccabc9bd860761f654a165b61242af440cd62716fe1e34d821279fbb21cb8853bf33a57747b3dddd66168c513dfbcbdf67e911f0fb46aa7d9ae1911d5a519f260b322eff09cdc2a4218fd815ef350d83a37f9716d84e5d726bedcbbfa05a54350e96eb05e8a02330e03a7fd2593010464bca205cd1c0a62282d2b14cb77acdf7679830dfc1653c1e1436b8ae1f42aebe0370dbe0197cd3e78b343cb6f643ea90933b6f03e466340bba7037e6315de9a15724aaff7c172a20870de0c3aa2a2e04b63ef58806dbc6d4b89fcc3f9e9c7b3181148379e38d0e17c905f6edd2445955722e6c42857bb4f711c2fde06ff60e17c307ac5bd9130e582cad854f0886d2211e4459c238bf42e924d0ea416404cdd0ae08ab11a7e37db33eaa6a201fe803230ef3c6c961b995a8d74fcf4c0feda232de01606915f0a547cfdc1f3b737dc9769e4b0cb01ed8989d015d1bf45bfc84008c6ced1d5e1ca618a84080f8aa818ddab62f0169c1235f965e2c038715b3315f5550294e1ac920a1ebe91a1ebe43bef9fe5bba5b345e2f2e2d19aa19e2feceb151c962d919b07aae3e0d67a65e6954bd28c128df902f73b6c92191af4151220440264e9cc8f0e8daa6869f81c03a8424a830d0450eda53863381d229182435216e17112106725edce5bb2a09eb6199c665d7525ae02eb7ee039f3d95f1c37f359d1a2ab9f7eb053f20b94c8725310edd007b91d94e1b3b1ffda272efb8155c24553a1348668b16fe18f2295ff627e1dcc8b2b146cd2cfa6fdd8b4ce3717806aeac58ab86b18967f74b17d87429dc76952f6313ab4c8f679c71279aa332169b274ba1b4b0d4ae2a851b698246becb77724afacdfc22f622db68177a0feceec76ef084dd7df6d04c515067699cc4fb8562a445e1e4dbb4502c78263604d968a5406235bdec21a60d92c59714be1158713abb758867290fda4d42f32a57a4662fdcc858c95d3a8c721d76436f334d934870c350da57774de6da75460981080497b241071505b5f24b090ee71742acc3e03e12941e434bb7fc8e43070d511e6cea6b36c0a14d67b0cabbaca050839153c479610998cf6b126d836df43f530593beded413514d1a1b89f5a146fc3e0256439de5610000ca372a6ee29b670a670ed1210b1a9f6e044d2203ae18624d5185fd1f3c0598707cbd36df96dd9cebdc9b7d4acc16be91ae82a0877629178f869dc351f587e77d1b2115f6c727e60f0a3953df2dec171180674888a918958c2a28817b1c82cd351295725ebef6875bb3b10f33591aa76830cb33ab37d12266da674edec1e399870ffaa307e883772725508d2b23e5c351a3b425990ff4dd5b8a329663d21ac9397a62f8ed6524a5c350bff700ae6e2758616836bbce295a2fb393662ceae6b09aee5ec5cba6e1eb045aff83510e562c0c2c058ecc1aa72172fe9ff1a33ac9ec691bcde370333a159a2760e3ca1bf23c3c35031f55ad592babff4664cb2f39ad60f3028b146b2e3f5d198de47ace1398d1acd6fdfb6c5af0f65570f61be21e1b79dc4140c3a4524855641988ea7f19fe914b60a3dc80003970e17047e7d4025a8fb98acdc00aaeedc1152ea579cec4b18594561021b683a3223a83ebc4cacc4ca1c232644a1b586452afa557fda1e8701582066c664ce7d4a43377ce5920c225031379fb7c0f1f6ae77074217e992acea28809232ec513e7a83b620fed3684dfcfae4ceeb6f93d93c1d3ea2840d04cc879fd88fc67ab1d4f810a32054b61d0638cdf62c9eaeebf906e927996cdb0158a5e8d693e7246e9a6a6a8fb703e8f20509c734526e5f1d558b4e8013b136dd898e7d0eb09944757dab3b61889b7de5424560c9900e054a6981583039d972560ae40bb9d63fd8ddba594e2e472ac84c16233dce242721101ad9b87253cc2cafd6c9560c12f14926ebccbe220ec24bc5b90145e4a7ace5581bc407014542638274a054fa27181bdfbaf09c77d3e0ef295eab08b18adabf286f42f4947c37eede994653d4b14f01834e5648b206586238a47823e497710e29daba69bd777e496eda64458571321e0b102ea194f703f6b960ed6840c21cb2e9c095779d40fb8abc0d685885073cc356e1d3a6c1e62c088695230496e0fa44fcc697283631066605d9dd96ad6c8f7df7c9aeada56f73fb67b21da231259f61321806742d3f88390d24922a85d0b1da7a2ee587d94030f5910ac84e938e7ca6d68cc8a6d51a9fc945bde1becfd428802b18a452b00a77daf90800e0626d24ccec151db4fa5333df2ab092619db5bf9a40a451662e0c8bfc354543bf393578575b78d677ebc2b026038fb866f89eb36693182bafec4b6aae0ce6910e43fe9f02ce36d641cfaed958d82f32e22fee12c94644401ee9565f6c59ceacff6f0626b79f8c609e3dcd42b1d90b18e23a43fa5e0ad74c9974f714906455cf2337a7140b4fbeb410d77d69ae9b5f206df3e661b9be07904fc3235144edcf075c7c5be78ea221003782092985ce14aa9c3160af98c5671d0e8eb66ffd9e1c3b5e97cbcb2f90dbbcee3d9d9716e106b6259795d0d7f824e45e596956b466ad1218abaea6125b921b0e34a0d7a8f69b90b4971e77ef0d18e6a0a4d7b777a766d9ab233863cc33f9941036bf392860f267bf163948f17c6774a538351adccf1631e0f2357b4eec268667b53246a7df8e3bd882372a96847cb66d343ead66bcd97becf8c85281331a557f0ac8e00f80f7fded6309e30ff8b331c3b8ebb521a0a58247df26a566310785935e20158d219f5c9b0c4f55c11967a8eb402c27e3e24e064a4465dc24232edd3c6e71330298a43ede76f55dc97cd4c94aa333ff75786a748cfe6562e74c8ae2b60adf4834a66fd8089ee62e6d56c872ead7d209e483c364ae23842643dbea8b890993da578edcd39c4bfee157b7f29714ac199cd9912b2a6aeb1e0cf812f1f1426edf771b8a2c2e8fd6f3614652d13d3bbe9a963a611b7635dc0edc16d6082d10aa718047e7fc4d564c6cfeb775804f1d7b1a7c9fe91b1037b8dac870095e11545810dec1e387073c24f691d2cb3fea5a1fae1f0c251dfab508312af973937e35e55e7b5280aa5ed73ae0636f9b799d2c7306462cf3e32df964cb89b3591355f2755662c698d159ecfcc44c450a683e5797935995aecbc18592d39691eb14a5449796769999b0546e3300e69b274e01d87b568e4d00d8001b2e69af65ab1752440e5ee1189171470ca60826369c299efb0003dcdabbfabdf0dddf39f4be1b4b9997f4c9ab611e8c94865fcbdfafcf2855af851ed22507ecf2ab2d4d08bdf03b5bc8ae4c91d426181bbcc8a01ac3abba81c287f5f0d9dbad8e399300fddb09a0a6d98628249128f63ff47f30f0ff3f07b8a2e17f0a966e9d6c9779eac480ff1412c82f1753435317fb09b5a9a39ec1073175611c62b112a6ae8798ba0fbaa913a2b6a2cc0ce71763bfa9a772f337b0948563f659abe44d2f5f842da0e7f1121b222fffc12b73e9de8313f203b3c2b6d6c06862d5b069fab51cf09a54f71e5098726862d736342772a19abcd9757498c1410f5df7f530d9aacc751cf3f3b0ef17c3b2859c439537f13b58cf7e0d117990951688a6377bb3a18eba40110fcd713d904d154c388e9880384152586de8fdc21df23f6bd0a3acce3b76d182bb51b78ed7c6625c82a3619147a300840ba9825c088a1e45ac20f778bf4a33135cda79f2f5f83a46112d305464fb9d19f68ad62c5e61b61dc288af521b3ec1032d28951e8073c7a3e1dd431586809b4f19943e89c3b4534e5bf2da7e37ec362f944af7049346bc8be4f94fd977af2bf477af95351bafb71567239156a06afe7b32d923f01999d4997d88b41c6c64f3f3f06d32f0c96f697e8a674ca262c6b65654d8d3a04cecc482b3e294b3f2f2ca2605615e9bfd02033b1d989219ea231b16b6f1093e4a703467636c1715d13b125ce6c58ced9922bc223e46b28921480823b3f545a8c48a0e1125610c7979febfdd8fa85ad88799f2ac3e71ca2a6cc903de84b51e9faab1eee8f89e6b9befc83ad87c774d6d392a3cf4f54420585f416f4740ec227c8f991ba222257769f223e83435c7bba5aa25438e2c0c75cf70a7386db020f10872f991abab1774d4811c82b567ba9dc40bf940da8a610742768c387eba988e93f44a4420b19f4cbdac2e3b1c64ae5a2c2e97249d157548e8fea8f595529a2629387a5ce4663f0ee8fe7f7b440338bd24d6134dfc3d0476f1c63f0fbe5239223c51ffc00f4366cbb68a1ed3c6309917fbad622c7bf50b9a05dc708bee37679678a023087b63f3d42e3adf4c4b5a755ec7f8e51451f56984c1f9c6f05ee269aafe6e52b561ac6c9138a9ae1741eb803b1371f0e270aea8cd1867022cc4047a30e954243de3f1bb0034c96a161275848324bd9802fcee257f76062c713177a9ea471be5c50f515b89e887bb8dddbb47acdbaf556f6c4ffc255ad6b1cc83c93057ab80cc1c336ab5d13163bac91b4de4ac2fcc7c5f204096e93e033d617cc3ec05daabb43c24d970d6e3287fc506c529c33114190c652ecf254a433b7e69fc162aba7e5b311332ff5f4a0698deed312997a78bf5f8ea9c3dc0f70422fc8cf2d0e4b556d9f3222f3e5e86d07afac1a06de67768d3aa5f0cd50235446d67773c93b4ff03ad5dde359c93ce9e90191e8ac367d7d89164f26bac5bf5d85e75c410bed06f8b569dfbbbdfe9eea97a9112825499ebba22875617f6e6be55e7681afb1df0d94a57d44b3b2a472a3c8b52ad02eb6787adb790845fde8ab38026f3b4140b6e363fa49bbdd6d618670a32051c6112437d834101b1c6db484c02449612605afe0b3af0628d7c5e7d351515f6484c3e1b33923d6c71295ca86e01cd1d828342a8846c74a0856dde411a6b2f7da8cf0333aa63a8af4dbcfd3cea644dd48c22433d3804724fdfa24c2864e65fa50a1791e8fdf36e5b9373d23cd3946f6bb467be8f77d8424c7c27c58a62fef651bd6576597352cad2da25b5bdb828e55fc68e1fdd5facd2674ea3535c1c949ed701da47e76347d0ab3ab9217b9424339f3eaf4e6d918fbc0bc6515fa8d549a77323ca2d391520116c8f2c751bf09e8842f762de745cbf38fba2e6450fb31203e2b8de2460be42c9302e2e03ee2db002241a597fe4de7648cc7a407676cd9de7e215087ef4adde797a9da47b798ae4b6f245b7756a71edf52c17ef1458fcd0709edd700d7ba87e2f814ddb287eb5728163518ebd2c45fc303c74a4a9133343c0a78e204abef84718f3aaf7e90c7caeed600577514ade70148b6bbcf3c73b9804338d3f885db5e1e9d9b0355cbfbfc5cbd9993d3be3cf95ab11b54f69b92890d722156a5f1155bc720a68115e64c0d78e05bf6557150adc82ce35b99eeea2c8c9a61155772dbd35048560bc70295503a9d142f23048cc1a923d06d6b0357e3dd5c3279d79c34c517a0c35791a19286bbd5f7583fa7517c6a8e47beaeb37f8aa1f7e87b76264a2c084268e571118132921b3997bba964f1b13a8b595da74267cc8397b9452425631ed79a7ee0c1da62df1600cb81fdd8717d88c2a548f57f4e0a984687947083f17dc052894ed5eacf1c98b207106c059fc9aba2c57cae711f776a6e66232de8466ddf3de46214abb27a4e652d8345b71f722750df455fbc49dfcf04c2b704d1550d30da1d0762db06ce5ed88735b06b813f88085f8e1123f430b35e0d1773f8d31b57693182df1a615b618afdc88c2d6eb5bcef428e5b3e60166ae22a512bd0e9835893d744f86022074432632fd1f746544afc338d6f82094eeb86622d9891a12a5a88eb997ad3f208700951e5c05b921097081231c6b1497b99a37c36004cb11f3b4c4cf2110f059e18e9055863545df5f7faf1e15bcc9732ae5c8f18e94d7980bb15b858fa687408feadc6f41414ffb2196e984f79e92e27c5f1280bf0998c1c756582a2238d6dc9a60f47f174dae4ea0d34fe2ad0acf1c31c7d10186f8f8bc9d41a976e225e026cf88af8c17dd1df513c4c6b333b4a1557064020e8b3e5974b24a30299acdf2944d395a261a05a7cbc6ef33fafd97a01eebbfcd4cee8fb40244b36d35ab8b5dafd97af001092afe2756e0828c4f13d6e85a7449aaa683fd3203fdca2ae2696c0b1315a5afeb774e3d837fe6fc6af2b360bdaae117cb96b7aa0bb707b7065ee7c30c2a96868b634014a5ecaec2f1038cf0ddf959936eac1de779842bb0a026ec5937a3944ed1af5f0a44326c4b9c28891b50ffcbb4aca0b9657d3aa8f49a71150162940e421607c612fe04178e41bb363b8545865739faccacef0e157c39c6a43004924af0d8940b3a86977a0ee22694fea348c2fd5d1d259a24594dcd6a5c6c8b9f3b61e86384ed7cdb82f4834529a3bdc8c7b40af60b2dd100e8eba9f9bf90a731015b2192db6f63e54c200846c584066f1a2c0287cbb8ec338173632e8b358811e517aedd60808b3782d3e40ae342f1665e31fcb2cfcefc9139de7a5be56c0c167406a27a61b9d559d6788e62e48ad68b94090aa015dcd94d4df34043f47da0b2f81f98d1e487685007c51378a429542301b11ca2f858324518142dc85b97a900662f2d2fa9baeafa552927541c1fee71ac8058582b9390c20f36a9110aeb1671fb60483aeba9595ad70674cca39d840c45bd62b3c920791c1f0c93b216faba3680e601968a0c6aa7ca79631e41f11cb4b4567f8dff5eed82e7e4dfa38e2e7a4c153846946c807c00fa8354f2ed6b9ee85f3c9ce3ea1022d83adeb5151b00a95668685a66f1c548c3a65da26b65733ce130b40a1264bb5c8d0c20cc3afda9d749b0514d8e5f5d3ce7883eb701d4c838f4d873569863d3759139b6f9fe4da70b0409626366eb94667019f2ddf7e7c62d1b0b4b20deae81c23cd0dfec64e2da873968b5b2759453f9744f8b54b5d0b97f607363b53ebcff4fb10332ec262343fab3252b11d7ed01a4ce6a062499aadc73b6c4e2373c11294feb74168c094f6e342120a15ce422d45037bd173a83d70f327f7fc4a16c5f721eb030d9793599a08f00d0b5cf2112f86b50008da282b8dda5ba982aa7cbe075e1a7d6db064da6738cf0cb5aa3b14af23c238e794cd9f8b206c5e580351cd7feddd50531919a6fe91f4b47ee54f771492450afb3a1912e2dad9c4899222d8642a60e351dd1522e284fbf226c769538803dd87d82491c0a891e8218ddd3125a3de1064818783e620a6d85b144b7bd3b9ed62c419a0daa96d30e2bc52c4139f028b3afa059f0d84cb057c8d61bfa4023777bdae6e70eb75f30fd65ae4d47eb74f7fbdad14767d2757b6e3f80189e073c8a219eb0a9437c95fc059deffe339ac27af85e85f524a97a0a4e0f035fd0487b06e12a69083f6962afecb9b01dce0e4c9519b4eca77a1e5d34beaeb679ae51126260d70ec00caa9e1b7820048c92ee1395190658eaa979f7bda3cf42f4d53eb0db8e982c0b227a7d229d28c087c01bbedcef1002f94f298994e8b065627c0247872a8e6c4d008016ad30182e2dcc05dfb7bdbc5200e30dfb93e71a2b479105739cc69b588478702c0aa1cd0866c352e1e844014b9811e35fc27a0186230b861d3d65619aef8fa533210db341da622b67e13e04089e392a35f50a11e9e15e2dd30f95bb3db8cabe6cb0293affd962647586abfa2b6c81c43574b1ae542c340dcb919295efad0ee464114e962ef3eceb140cf3462ed878d90274c79e0eb886f14db026322b6d94c4a6245599c4de93d743700c9bd52f965cc68a7e17a26ddc25f90e2b7cbb9df79605ab5ea5dff36d173f579cb8655bb98ce7bb10ef2b8c4e4bd0ea95025faa8364ed1d917cb6bedc96e6d7094334429fd7f6faba31464a5bd6fa8f10a9a2b189445e5ad4a22076a3c6cd4ac1dbbd7ba192257e359997bdd091357686d0bc8c46d6f6179d412ae14efe4e6b33367ecca2c1d2c6ca488e04bdbcbaa8cf0bbab54aee5bdca4d7e5a1db74c903a6ff67cbad605b0db1dcab6b859f8a290a55ca0fc6263669713e733d99ab1232d8aa7678f54e70ac724c7b057cf8e1166b6bb0b111a4592b011917628bea0fd24490d2616b8b378fccb40d99481e6a0bea6b4f4c117b7628aee6fe66b72b522184a07276ad70a3fd0bbe544c8992fa084fcad68a39f549ec5a8d096d69bf606695f4e2fd22e825778ec05fdeead05588bf803a7d0938fd41f18cdfd3246280dd092efe5b91b965af56816ee3de8a385ca2102b3cf0154a0a0357a78baf4adda3b5990463b7d04d6ffdb2f450239444647b5bf493d60a940e43994bc54512cbd6c60df3f1f536a4bfd6478d2b5656d8e60700340d3a0f48c8d24b7fce0226886c050d515607c9f6213435508fa5eb3c24ae4b1ee2bdabe2a72f811eec7ccd9275639401d7acb6a32690bda00f7bb27b0b712ffd9106e85bc9ee465dd22f3612849adc5a07d892454ca17ea3f543ca6cca10f375569410724c848dd7a49b10644c5d50d100671f20bfe85f0852ab7915a0bc9d29ef342be86a249c348ac81883c236efc6e472f7b2b1d8e4425d523815876bf1f2917c4da9d784a741fb06ecf30048c8013bcf6a911b74630c3508d7202a8cb42c2f198af16ea01b608248886180bc6157831b1cfa2f15c86f514f55e59bda1076c358ef64b6cb41483200a4b9983407d27b30c63d854d1494405079127e5d3f65be46b949c60f6fb48400893f333687138a3307f4951bc5fb7f8372ef38beb41fe7260d70c1f91989736af2616edd38aeec73759d3a4147603bb92c98c681e4bc38036698e2965cf8609548b9130c04cb8283775e6972ec7a1c87cd09f9acb9de0502c59597c5008757532c41322f398c59e3e48f05b35f49c8e57601c6ecd3c4dc042896697a7fd2d8d80269b5e0816412487018f43f85b56baa10effa55abf34e806a4a5e12a808c217bc6382da7aec6ea1682eb547303b06e7a752441f1144f916e5b27fc981bd6a644c04b9c27053a073a949cfb5a275eb5504e68dc5b0639086bab9d3bca5644d67cb64d3816a65a1ff5a40776e826098ee7313f89b05fec2bd50e75b68597135f863a82150d81a509c506f03957062fe75a58d5ceda7a4f34ec54c27b67f26a4a74a871b5f939d87e7e8239903f4ff52144f5d3376c47be174296db1bf8edfb64170645ecff2abf0b09bf9bf143491ec82f5613f75ba1a7466ff49f615692d647ee4a81ed34e98b3dd4445284b4033d8c7c96d3651cba2de5c1960b6c1b68b3614faf124a7e861021a1cdb1d1663d1cf4054690924f6b93c7dddad4a6915908ce4ba7136d86ba2d660ab4dadb7f0f287c34322cce5589e4d4c6a75e907801f97196a5e4b130d0b0a39e4aedc9c993a0c0a6ef8853da816063b57108fdd97aad66dc1398869d15d4f015ca9c1cfae4d5182750517fcdd8a537710d6a764229dc813acb2785914bd7e4e5da20b90731bee857bdbd1e00ac2c184b4cce2ab4507e299852b82b220eee6443293b18ac8dbacb31999784a0f88f13e3c3c85c02d340cb4d8d8210791146040b84553c7230d05e9c10f6358c43f0c94827f7b5563efb9d44321b3da43e5e918b24d029a12df3ab686c3c63d38cd05f58e706b9da300a9deba2b4fd3cb6fa597b6725516faa1e42c298007936eec6e51901ee96d7c90866cb3b50724844bd87bd59402acdb230584e72ab0738fb96e8821873208ca8949b7ed3d8a9dd97d7f889ddbbb24341daaeb67afd3ea27d9311bb7e72e5e7f6b04d26210c49ff4bab0faaf0d5cfd5693c128c55d7b114c923c103bcf6d687ae07c4c9cfaacd4ba32e052aae1f5922d1bc881487147a789647ad4bec7f465f10e83b1b67b2cfd75bca947d0075d4df573b0b974b9426beb9e562959f0ab398aff529d6f5c032124bac9173f306d81507c25d2cd059a781a62f01f7e5f9c9a9b41544feadb8be4624487cd6e97bc857d1ed7663552fcc5c04036cf7ed56f7201605ded04184ba46bfe345348030815e9516cf7b74f81b7f36e3b5eb144713ef944a20de8922dce5a76717aaea487c808febe812fbc8f1f9ec290bad02ccd6365649e835a916f523fb44f0326971f8418e930e8cb9793764131d5bcaecbcf22757a1a10e73c0da3474aa738d783f75b662e04899d1bfa540b26026bead47d6238d6823ed514fef38997ba89d8b263ba2c8b408f4a9426aa4d51aca52d7d7a450a7c77ae9204d3378c58535fc9734595d375a7a02095ff734575d7e7c29c91764f4bb7dc2d94683a4025d8ca1feefd1768e4008fc937596d50120d665988e9a6c1c8aa84655ff71e2dda699fc1d5cd786f4526f51fa2407103deb7071e12057facab99704bd05e015b3a2d00127c02a4420370e2b53ce5e372ecbdfeed86541a6d7b4593570ef19975585c7ee3b923aedf0f8b147bbc5f64ba0a03ab8242f20bd54b413d1ab91fae48c2c7dfbbb36b66b5da05c3418baf761274ba57c2ff29d46c620545797e60e87a70be2bf291a406ba103ea5ec569a0f4fc430445feb1d8848fb9bbdbbd5432536eaac526fcb71762e6aedb3bbe70728bdf71e44c53edd885a8a96955a01083598504a57b44304b51bc30f104db56a5af22f4028ec2785f1664bc038538158e553458c3d7f7d31e93a6322b9eb71d0401718da56b750ec591cff1014d02551c9cae0b20a9f3f6f04596585664c4c4a76253beb857443e6f3f42f95464284ddfaaf4cfd97ffc1bce6773f41abcd1e15bf7f7139430bff5768dad6c9f855a7fe31cee4a41af8b9472d5f41122f56f67783d576e019128328a3124510c018e87eb15d439ed28af668f5ebef3fbc4f28d61aa9051422716558e00a8e2e9a929a890eb5e9be8a68ca303d868462e9827a04d763b8e981705369f5fbbed0201ddcd74fa55164142169b6e181f0945167352cf004b1244ab4ec62c0ed46c6a85d7680b5802c7c049d5de5042750c9d6a2a9848003724f50c79095943e3d7acfd4b7544fd0d5459f2b5efaba1323c002e5638c8a9ccb75e68cbbcb32196bd162889ef9e44cc88d5204c67aee344004bc228283d58d428d07ae2eb9b89559e038c92f2503e6b1d042bd7149b060f19e0c5a0dbc8e6b3180602a0a7aaeb48f752ad1b85eb3bf437cb0bfc439b8cb9ebb41c3bc4e9105ac697aff6a9a5b3a3979100ad7ce15e487422bec4d8768e6455619360be4aaa672e9ed007d054f2bbae6a4e09f82426ba8160b15c628cb647609e405d3e88dcdf73a14cec486c9c542e929bf2386b1f806007c0e46d5e04a7249db06c8271b010640886a8dd55f25a891f6873d4f661c067ed565409c8198018954d8507fe66e9cb752d45cdbb26ba5f76a3f96758e4e72fdec5740c75dee387227affbb27a9f3b0129e67cef080097c27b596e9ec414819b9a183263694c0b66dfa79c64a0fa0ef47dcda51ef9341d547dfd841d9f63575b59da754184a1017c6cb7ab3997dfea94bfb193e3e2f1a9914ff56b122cf30a2daa5fbb61883c9fa2e61762d2c6aef92cf5d517f0e7daf582121394161d31ecadd1e1bd024a1778f878470adfa2ed3090c9d6036c3f005ec18ef8507703d1fa5b2598435b42f9bf51de633577a780b211ccc0ca37abe2836aa20ab7353aab39ad20c87b1797a893f7692c29c6441d2a8c93383084e29c70835ac4ea3ebf87fd242f959dd19d841b6176ad49d2b24c038283f8d9c7069158f3e390da45c71b7d5fd507b675ae32bf5bb5ecf1129dbf0928e89a1b059c8acc476a8493059c2c59185cf74e26028b33872eda5ac663298cc42754219666a8a98276499f35aa9a6a4a3a218b4544cabc1718a5c51cbe2066c85c9d5e0aec1ae545daa93a9fc4cffe7839ffd0b7696a808208e86160e53498291c5c14fed9885650110ac5aaf9706fa2c70618a683e485542c561679b2e56ea8c534c7f718a8ae244bdc536f8a9080b3c1e3f68c8cac64480b71946f64b6346e4d3ee9dcb2bbaeb70c1eb3124d0031ef5d7ad860ecaf1a4723e07f19a313b0aa49873a33e6afc2860c688e4e8f082899d1e95dc65e28a630ec6f3283fd9826e946f7f52679d59aa843f4a52a1882937854c6e447190ecaee0f88b8ef0d70a86982533b4e11d9ff715e5a945042c00d83c30a58702c8515ee0cc33d945c9e5e3bd647506665b808fe2bf028317a0f5b7211562df23898509f8d8f6c4a2029fd10133c55841667fa3017aea2e65b04a153ee5189f41fa4a7536c277cd2a321ec41b92d9a9c0b3b4f48c180cc8783d235c7897d7f1695cd07ab065e9466831317595b4e6ce4a8290c57b2b487694e7840fea10040fe9e4e9cde636efb23c99c4d39066d446ed0ba01bd9191e48b3a96585877599268dc39a0b84f57548a19cb2a6cb87d55e27fe559c0c4817360124bd621c121e330f8dc7868c7a266b195b2ca8bb93cdccaac2ae014ca745a0bf050dd037c5381a06a9de3f2f96c6ce884b808ac1799081463332030c8c41727273ce77153b65b93fdf739487385849273cbf12b94bf1898c93082ea55b5ffb62c46b440125fe06773b9ab26c5aaee1b2fcabcf204fd254c1da9a38c3e92239532832417a204ed8588d4cff2a18d9fca051b5a208f133fadf861414406c7069da4d1f584e264c025ad2e6338888ce024708893f31e5a02796ad8b31d64a1505ee3d21c6dcbe228e0a79129b674f973b2abe33593b88e9c9bca5aef00c013c79da3a5909adcab605c52d422a2709bdc0193dc7e3a4972df4432851818586c240d1a330efe40098be4617a151786aed19113e9d36d3f19567bd8be277582e3ea21e2733b83648f2fad886ac084180195ed4a917a9ce40e75e48e0467043f0bf392c1943767d0541f9f8404e90b0bee994c665af11174272784ba61b7371960dc276cb15fe39befc7d3975ec380c203c7eb33698ef763b229471f3b8f0b623da92072a40cd73632bc3c11fdbd71d626a5aa937a92406710fb83dd4b38b0102714bb6c2eb67e583e5f5063e2b2656d189b7426e5c7f3860b6abbf008ee8192743890fbbd7bfc6bd944bb52b6be24f838012664dc4512d922bc2b56892f5bc0bca78ec5777c0c74a0658e41295bd404a1d1a7e708eae3c06cfded7f08af19e55906f48fa673b1f1aa19c33bae025f49da80093df027ac40df229949bb2126061f8bbad02df753f0cac2ba0f24e6cb6ceae64a674c3b77625ed4ccc0c909993568c4cac081da9a86af6d01ce65c2335569bd3d4e285ec4f23c20baba6e264bf4eb0169a3b1318b6c23e6055a2416435283c0de16dbd747ecd56bbf3a29e0ffadc6bbcbbc03497d012553f50b5fee3d784dfb84698656839cff980d520afe7be77bca575984dfe5ae7729454cfb7d785d2fcccf0a390b8d7a0daea2f801986e51196f396e3ce8f77903a74242456c3f96967a7f2dfbbf1736339d957fd0d464fcc7c49fe0289d8b266517bf5495f44f0927035adfbbfa9c3fc7349ed8c25942309786682bd1877fc7c2064f1a6683d10bdfd2882f178340dfe9c39919f387256341f6800da7cec329a047f4188e52b9a7b3153de75abb72ef741c842e14d84897d931ea82ff1dfd8212caf69e075d6e08d04f82b784cb888ebeb79ee9b6943d61d05a63573867d9a843c6e0dccfe9c71a9203c3fa7fb5d2a9b8dacf5fe20442c6b8a803a04f5cc7ef2b471a25db517ea0878b46fe90d2bc8a34b11d4d8e4607dcd3d7d6ce1ace2ec03b008d3287c4ddebde9647d3f4ea46b0692390d7d2805a76ae1e32e4a6966b1594fca21424c72fa1e7fa3f9b54c68f703183f3a02d8321dee321a47bb7a943de0d6259679308711eeeefea3f4319ab33207924c13cb128444f37a3d820f0548424438c93fd82e7c52223b465f5779db7a2f3fddc418eb88ce4687ce28cb77efe47c3b822a96cc87a03b081c5e1b126f41da0d07a03f0def0b984989d757893040cce013a0fd5375a20989d4907462e6c3a287be12428774ba4c4f60346f0e655ca5794957560e6610dae0fa6c92a482251e54d50f035a5c2566f0a48a11cb9ea3559c4c0737088195b00d6b93eacb87143e37198501142bf91bdb74c52ca94a494016a037f035103566af7dd8a6aade8399b0a8935f56aff6656d0000683e98012f8f7727cf2bc70b6b2ccc1388f9a92c23de0dc70b5566a9f492a0bd174efaf7b1d51a48ebaa77bed2fe5040683111902c6868f402289a4913c8a62c8100a7358cba9f69a71c64b2c934e10779fb652cbc484c46b9e9b696f37558b8b4b8b6afb7ac31aae59b00c766176ba104c2e986d2d6e413bacc5455aa54b292575207ef001b300af40db8cd8542d06c047b011bc7afb36b67ac9eedbecbe8de205c6da293031310000002ec282b3168689c8b498b15688191a6b85c043b010ac029c027c8451804f600343cbee5b2dbb6f710f30ba89601e3c9613bc0336012e0136c224a09193f3598b8b3e6bad95578a3e4967cc13725a5b0da7c9d67c72a5cb203258dea44e25144c443109b0f30e8ee8cd55dc119adecc32343b6c645462ca0e2574b86ccff33c0f8710f811fd606216c43e2f6cefe76331e5cd254e4e4e5cec2768e83f0c724a1916bf1845b6a474f79e4f5048aa43152856f8496b8e667ab37375716eca2aa5943206d4405ff7711ff755e1a8bba77b7b4f263d38e0b10a0da4cc9aecd8514ad9b2e3f4f6afd24dd3c9c9c9dbbbaf069f5442f44abba1d81cd279e105a09983628f050a9ade8f8e8e0e149da276f769db37db31315f4ccc6c6a697b3f63972755775d3884f68671eea890b42ca7009d3e1f02638ca1602991269220b3ffbbb10e158b00cb0d8700cb8c89aeb042db5a5eb85401cbec52055efdff1b59bdfcbd7fb3ecbed40bcc7f77159898ffeea81800fc7747b964f97772c122d362e6bf9bc90ccd7f3713172a5cae6099a7a082145158b181f1f7fecd342dbb0f058c16a4ec222db84cc16375334db94841aa0a151a39ffdd51395fd47f77d4f7d52923c4e43ca756549253607ab294f40314147be8a642a2d56d5d129dce443bc9933573c63cf0b0c30e928aea15a0e5dff6a97826402b085ff3d0bcd38ab98d7494a204735a43a097c33967e77a103492464631a39851cc286614338a2549232525b3462f731c8d56e4b8cfb5ab2a1c850d5394a6284d519aa24434e5089c9b2b69ba4772335a4d445eb94f462be6efe3a27cac22cb07a852a495d56ab795fa7414305eb462fecd489344cd53b3b49e251192f9c3cd6a5a317b9cc73de9ad15f3f7586ad4d433cdcf42eb7ecd2389266be6a78f7acbd9533c1104dad48a59ab1616afbc5a31ff1427a0d00494aa492b41be6b0287c89af96b8200892ecc5cf4adcf3ae68e8f3943dcd940f4a67cc1258384531609002902b13e7ada001f790e6b67a1e7995f42cf00f6d13c33eb40d830bc8fb933a3e779bad1b73e03893844ab42ca4fbdc57b4828870f98549b802083e5453599d4bfa8265fefad0204593ee0799ee7e11002bf1e5c14c4b21aeac596c060302e26668956fb2f390cc3513ddd0aa91e56584ac913572bad4c1ff7719fd4f77465899412a9250ec3701234e3ac138276f776c9b4b4a95a5ceadb9b6939098ec213539c804213359e112d2fb2fbb60728297865adb5b1d58bfdb7f76d14f6668abd29b237454c580b5bc2de2cb1374bf0137e0276026e02560233012fc1bb1e2c2a65f76d0f4494e0244a1290708424ac2db2b6c8da1b9920326db3f75f4c4f96aafd9b69dba665f76d8582886b9914b94e1ef8796eb77406f652fbf46aae922d9b4a95b560cac9c949474271f26e77e2b887420a9c9b2a44a054a1444caa108952ca961da7b4957a95178ca50dcf39679d73ce3a67adbe442b130ba504509c326db3f7552d2e780994ef6f1dfeadb536c7a74688158108433842084ef7ef1bd1b2fb5a765feafbbb4a10fe9d9abebf9dbebf9d602fa6274b4838d9b4ecfea665f7a5ec224dba999480f083238cf8fefeffefef182817929393137ba2cc5c13971371664e4e111717970cc8607949de2e73b8920315781013b2346ddebaaef6cad7eba7a5992fb791af79a5dabf5953cfeedb3a04fe3f0da1a9a989d3d189c118d64e6b952ddae447624b1e39420597c20a56b2c2567c98f228ad6fabcfcbc7f3f17cacf84c491d4df7f6963ce888a2c38a0f32c618e5fbf8f858e101179b3fb129378bfbbc1c433a7c40908627d0f084e4f57abd5e2fa795a573056fd39b5e6eca3ab127ca256a8c472868c8e68849e478e11178777b0ba93a3a3a3118c36ea66d4dbddadfb4ecd21622892451c499f98632f634d926296ad387c4167999e2c564768cfc6206ee413bcd39d37a04cb5c04113cc03bc03ac831985a5ef0e428c9010ef02a27e71733a4b07ac939e7189927cc795badc827f00d9a70924c8b9918f9c58cd80c4d8cfc6246cc0635a0c10c96c860081b1839e79c63c497017872b0926e2118c9634521629004062fa09193f3c5c82f66e020be189f5fcc0822e725b7becdf16218f6322c77cf264480303d599a4eabfd9b695a76df564ac43daaa7e3e0bbeee0966057a4d2238a87cbf63ccff37008819f47245cbb6b595410684abbbbbb7b767b9995c9b8c1c1c9421e4d69777777bbf0828e4ee640558ed81d638c31c69e2dce9d016c03d8e2dce13a7b777777bf75e956b37786669b6ffe9a19dad968d9ce089c5f7b9e5bd6886bd99b6dcd5bef3ad02192076cfe9f708671c8107661c4674d386ddc089230641b02b46c33f224e6f5d2a505e3cf93d2d0a70d5729a51c0b1919ec7279ee1e8a8d8754357c6a0bd86880c0322f4065c30bf1f46490617a31470e06600119c0801660c470c016e70e8e8e2dce1d1d9bebd8f003b61966d8b129c15460997dc78e2d029bcb101c01d5d04fb3b0fc8e007878b86ffe6c34843f2d9b036c12003a400d1bdb0d558d986fd80842c03681181020146d5c18e17016970a48c0c4b1c93c2bb0b9306281ed0294521b628c18c81d67e8ea4c73ad2ea7514569e7339ca142c0776cb1bd9bc0c6830213885a0d1b4d8fcd85112daababba6071876376d0bd00ad8dca15f60730d68c0870fed068c45bb41552366d70c0c7206061a76d859c66e6b1a9ca0fd1127cae899bebbf7449a3ba49d0b87b033f58ed2e9eeeeddd520ac7dbd72c27f24f8ff0f957643f98137bba1ba2625399645d0776bad859a49499d3424944326c9a4ea84a0c98205e184110abb524ec8bd5afadc8934b37984266be6eccdb8c09b02985906459c19147b62f501412914040b82052131d56eeff7b83537b5b366a128ed5cf83e6f07c3aafa691b55a69285b7a6c7f4fe7ec439810d35f4782ca3e2ee94b16f4f6a5f28280a4cda5003d4db29674badde479ead108d2fd54ac1d8139bce4ca716764d0c7ee1a52cb435423f6cccb07633ee1d283b104868031d048122cecc379440f2c603254f10d012d01250ec894cbe6dfdae568aadb54a295d7e64611ff873083dbad75aab94ee26e896488c76dbbffef6ba7d26de5a6bf34c8aac997404e383cc4105030476c9241f5405f3834caa2a18176069adb54c78d76da3f3dc6957c540737f7b0541192d11d28a6a693c8ffd6ec8c68634fb39869c88ddec7ea60deda002a523f6564628a3528ea1d8cf9d9c6aa76accfa67f733eb8452b744b4d09d646176fb5eeaef44aa4bc9447d04aaab65354131d3dbc2cf5a6f4cb5ba3fa599df715a481b53c13559a86532cba4bcd7a9dfd0aa361b9b385b866851ce76eac2e20635e6793b33446fca292484afa1540d05cd9ab9fd73cfdd5e383d2adfdc993b4456dcb10125247a31b401a54364c5b0bbaf46550c30617fed7da037cff75dc9404511d38be13349990a67feffa7b14e661a31f30f012a894a890954b8741a7281b05f371d9f0f9492842d86860b239314d746c5cc3f939e702955b42368ff749178252588b848bc14272931cd93a4f8802a49499229e16e53fa5d8c1ca061a448e80fdaa434ee78d62a354208a68cdd2d65774bd95236f52985d96215bb4cb2664fd92d328c3853764e694b39e594b306a94e39e59440d07edc883f6e748e36dd7d2381841d52bdcd533bd763ccc5bf351dce19b3ec1865945146a9258e84916909a3d08530323d25219c9a477e6be28d03f80ee0f0bb1f1cc0618c39327fe7d2c2ebc24092c29a5d756385d047c4f1ec6205d8f30a21eda22a0133f70f5944e8aab9478cb980848d63388fe1439bad7fec893f8f1a090a0acb2a0bc6df8df7dd78ab2438761853c982b9183cbd2a3e4c05776bab24b87b9505af92e05e61596159c1889c2369e0f8cba82ceb7d8c0d735cf6bc0f045bd840f0fb72e6b81ffc1bc7e5ec792f6c6876f2f4bc2f7319cc21c61c97330bab00b880a19119778b9661e19ccc0a2d583871f59047426d86c6e340d9a08cd9b2973f0ffcbe5f02b062016f9c27f377c3651bdcd2658eebd027cf372b6b21c6f47c6eb408bbf08cd1944746326c6862e88c1d1c335912067e3ff36b96049b25f3a4f193e61a22d10e0435b46656e0324ecfb367252e9716e02837cf3473c7c5713f3cec11a384d29bf8696d0c5ff885ded94c4fc906118b139c8042e20394284d1c80a482172861882aa0e4c007b09727b0a3265350f202e200494cdc40c8d3ab892094c90a17fcd1f1699a5d2aed37d9758baaa5bbdbdd3aa96939d33a19de6affb3fd4e762ecf51feb4f7f0c21a7dc5153e250c4036d950d0b43877ba6d58bd6bbabbe79c405acea8f8125724980a5ddc53e87a8e26cf0cdd1cc31c93a89565fc2e989087d1b76efe9a204560eb76361b7d2bebbe1a81418cc0d6cdad6b6fc061c30db884f4061b76c783ce340eb5d9f58b67b4ba75dbb6f3cf9c54760de82baee8dcb9dadc9d0cb165bb0618a055bb6f567461c4b34571babbcb6eed4707578165f6995ecc73a301c20b6956d5a094fa803333f4cee5809066576b1afa741504bc5b0b7934a5dddddd8d5f606038992dba60219469a804ad5f968e6610081200b3170000100c0805c3712889f338cc391f14000f4682306070402e8f8602814020855118c76110c3300cc0308c42c6288394530c6f00ddded5d1074fe906e1202499bd550f32648c7517ba033b8cc827cc24c476007e39076dc69679ecfb4d7f7a7c298f9158e66e90271f2d34ede20ff509d40e084563dfeb8421c89f3a811732a4b41a89d269ae78b545e3cf3fb039a740d0e49d1789e14120b1bc75242924ca6bce0a2915c4459997ace0038b9868cb85b03d903b3cdb139ea2c4db0e251b7d7e7bd219c637706a44fd4c6315472a19209e3d54f47a1097e48434fc0bfa8d2fc452a123415b6084061652a9014c438f90b45adcbb7308d08ba18ba8d672a165496ff1226f9281ac415bac27053cb0fac803db567b2dc27e49034cd5b3c58292ba62fdcf08bbc08b2d1fca2fb66dda691dd7eea49bb3c5c52626b0e79e2e57df4c3482c17ec049bbc06a9e8a6c7fb695c5c4fb8c0c8c921fa947ef04e9677ade5a2f7a0d4c392b402b05e0a401ce56247fe224d46e11124b746503804294fc52db6823a1d72916652d3548913a2ccd530d2c1df3c05a7cb4a9efa0bcb432f6d962075ddfe0d2d1703299d82bd0f67585f6b78b45c3d2b958ac8d9ef6b77b5a11e422d24b4bb631fc1c8d33a6fc23b8060f4f1566a3a78723767be4df88c7e294e56d80f3aa8950bb9d9a661509a14d2fd80c5c4e8e289d2ebd832dfdceeb3f0db974842f6f075960029e72834ca16417437ea9b569d4e2a17ba734170eba2caea583488d4451c6a15406186f05f3f4a1c22f9732243cfe17ca1c1312561965da4a635babed521655e13ee8aa539870a66b8a128aff9c63586ed2997beb19550b2579efc291c93049c9e31864100b9b3ce101ad151eb13502c3d5199c64fe8c478e703c4ce309635f6d8b36b7b1e6a9ace9604c72798076701a55b19e269637dd0fbaa308a0fed748e2f39d495527317547041d4f8e92a1fab3f1323ada7b45a1c1b305add76bac60ec45e188eb8df047255d1276292fea44c2a6473103fb8b598d30c4abb268f76282f54d57e4351fb426a5018045effd4e12853aaaee6250fd902f5abfbde3ae17efe356fcd78c2042054245a5a8d327629804aaa3987264033537eb04276ed32537db9c0a08b2e38d3799656b31f5f91a103bbd96ec62543d70c96acffad39574fea019f0dcd8b2a54cd0366de30218ca19253c0f1a679f73472ade89767a9691708c1d4d9ea4529adb4352a3dcbb4688672feb0e7eb485c835720cf210abef6ea6b154057974bcf5f0923496882cd5ba0c2858fdb79563a3757e7d71175f82456f3656964adb9c11edbf1d4490a0fdf83c5a38ec91d4dcb4da7e828ecc9ce78bc074bd29999fc3f491893ef9c7c6071c93e1ff2ac0f32597db31041380c3e58812279602e64d6acb7809a3a715374e6412f476f5c2152aaa88733a19ce7dad296e4268b78a53e34ad83a6ac15a17c4d4459aca1f51a0ce46a0f6107f2e51add5e3dadb6242f4ba14417e3f1c59af65c201ac9d81485ce7ce8eba2631783832dfaec494ce7497b870f5ae094121fe623c1715de28fa71c521a033d29a68475c8171e5ee7979a1d6ba4666af16d9589eb975da3d8c6132dd9125a991d725a2484a62381e67354aaf19491dd01ced34a2877349c59967802c57bdf3870e221d0afb0d7f70a876c1588554985b2f7fd9f133eca0d23fdbab7217937386bd44776080b66b37258ff661d0ae6a45da89b3d3ef4557814a9cc369529aa31277b5a277044e3dccf30f7ec441fddac9593221d5bc46f28035a191acda7fa4f40a46d156a4a67d49fc06356362fcf5a4be2b938d02c6b356ee082020a2bb3321ee78eca1234354245ecebb09ad82b0f30ca33887a6b2f2c610ee015eb8d779f7951bd28cb2535b9bd1a3f04f593ce769805e48170a87dbeaad0d7a50579b1e1d377e54d1dfde3c2ffbe5715e2657359dd7caefe57c92d68da4ef145cbab1bdf661dce88733a6d2c0118531432d9fca098bc52b46807ab225deaf942449da63b807f9c6f1403949c64af4b827aecce74f76868a240fb6c2360cbb51e135765835e90e018f714942582b03ba03b16095993b34e42b8d136814969648fd4c136504e028240bc43895a46eef2b791911df25c614b09c6a8b2b0a481641fc9bb191b016fdf452e60958d0dc23068c9c9f141f3fdb56bde21c318db6e544c82c1dcc28e37c38ead5376250b854bf880dcdbcf3b8d52a1ab81ea61b2278517aa32ac7f6ba0588051ccd1a82456307a86b5e28b55a56dbb44510ea4e0b07099b90b0bbd263ec4759e29b9e96ff924a0f7eed8bdd133d011455a52d2758eb12c7b36dfe8f115c93d338449b5bad77f85175d3a5118dbb9f126fbdb763eb0210b4ad357f0847aba190cdae2b6e58a91f8bad5503d0008f8ec252ca8cd8ed45e04adf30511f96f318f96ca743b6493ee6a90a3ce3a037e062c5e486af9a052c20b1ac3418cbb3dda81d3c969c476eb786e1f71746d3a8c74c3cb0b14809edc975b18d0aa9babd33ad8576c342c295cb8d7a124f050babc18862a7123e78e3afc31abde94f6af93362d4039ea954a027c52bd8ef13fc779595828ed6da949bf760fa308e322748771d67aa0d08a8ecb759c50f5de4c9aca3e35fc5a1abc91e250e798ed18b1c1abb1858b1b9ecd04a08911f18dca8e80d53a202cf7977aa36cbf1fb94e9abc1f69cd51f887d6210987c4b7023e973e96baf239c352a75fafaa4b57a88917fe16aa8edf826db82a057e5dc89302d169819713ebbe52f5e91a0b830aa03395c86517a5f94fd1e87796e18879983454d0f756ee3a275d77a2043b2f10765c1efe883fb784558f8d17d12726ce5b69374ef7a10cb2234749b6efc5a6541c515a3b4dd099a3ef7585d0accdc8e9bb5d8f4ed656a6d4c1f19d39521581b5759ff28480161d29ddd96edbdb8b787d4da407532940a9e5b59528cc37ffdd5b49fa60fc35606f537b14342daa2b98e715e7a36cb5e1d48ad56aebd711a422cab2c46d3f90975c65254ea98f78775d2ccac637562b32afb5b6f49ee183b2aea42052fb836379e65d4576ecc723de3cbb65d4e489e064360ee9875dbc2244ce688b31cfa90db192c65beef6ebb21da2494d4038dc46547fe54ec84c086f6c2ff58931a3e0f65d9a570c443790c3a4b00da6983685b3cc9263aaec20916d568b93d693a5c4ef61294624fa6f7864b8aed0f4718b8bc8083bfb38a5d8948b36d4770bb9e1494e6f651963af986b5eca72a00248644577485ba4f30835a4d509bf824d95f45231bc265371e641507012dbe22a46409ed96fa7dc1ad5953831312a0d2421aa070cafda7dbe938ff4f83063ef4c3724fc408955d4f143b8a43bd3de6fc180f68122b52701f0cb7beaf74eb80c11262bb3768e0521583222bc7359e85c02d89e502a3bbdd1a4c189cde9f562985b7ba6ee10ce68807491c7a682e5c9ac981e9dc506986d3315f1fdc19d908294a2bff7178a06168445188966d3e8becc724ae6144a593ac50f078a7b424977e2a003046affa7ce9b942e660e825874c3dc0b03b92a000dcc60ef64618381ee37f5c031e08b95a4cb265c8a837569aed24cc22bdf8e222ad1bd64cbceffd3e1003b6d743d7253064bae35042e57c93483fd544df78135b951d678b4a787ba0a2677e13fc193bd6edf7526f903c20c46dea21447c22b57a0c5f99c72d18886de3a9e67bdc70e0f449656a74e5ceb9c079f40fa18e2d053d88b1c5a2f9b0f695664581d260a9e5409127d864d70840b3008625fab6d5247d0b07ea6e704680857e8125a06cd7d3d49205d3b1a8c8cb297d07865cbdb0c2feba38be54300d033783a0d6927ea8b2e4a1fb16a833cf641288cf5f80f0ad5bbe01b015bca257d7642b30270709c2968606be741e554a572fadb9d29bbde0b6ac72576d446beb82c5e4b29101b43b15fc898447a647d50a3b6becafba14bc86819be05aaaac45af1e5727b31998d45223ace2995a6cb5cece3afbabe58a53eb7d2f2e59a9ce7fca469292b03f3b59637f859dabe5c1ea4fa502367408c6efc4b9a69d0c7dde4a70009beec6057635e2496093bc1bc7599707b9ef7d2e0eb34f6efc2b8383401bf00ecf2ad5e1e81949977df78e65b1c2a90e8f133897c426804db25bca2979df2bc28476a8401d118c6cfd8f63770d6f9a5b06447c340a3d5b395710da5d1e20af8a47a0c4f9c742b768297bf0416f9078970621d6e5191d680477a5780bdb23ad0d239103e08dca0083871c14e2a0423c620ea1f3e3edb31349c2489f8173bfb7e8135a6e5424a2416fb518a10d6755584a0437778de3105b6c41418e3b92bd6fbb4f19bc47d18c0676933122be1fd079e791c50606196bc7668e32fc286ee2dbef9589c530c16825c1b489624934f14237104724b6009b0d179dc59c62c5e77f6fedb487ccd91eaf98037160f885bc82e22f901f2aa44382b0afe6491ffcf97e87a4c765c7a41b5bd7008797d5ae8a4f7fab32faa34ec364710f6385c2c240931d24e7dc9cd2f966c580cb15dcdb5ea09c7d17d4876cf4c99a6493e9aa98d9b6aff2a111612683ef04d93bae774d2d705b782f1847c5783dac578e1bc4d4124312baabe4290fc25a6f7e8e24d452652f8574d650a3bf3aef5faf9691868f370d82dbd5713d548f6482e6c69cd3a83bd8d9396f7ab459bdec14681dcf0488a88392f50840a3f9c83ee8e102fa892890cd5dede2415a689071fb09322504e1dba78e0036770141a58a50052e47ddbab8f8f781e52e1d5000f91878ee78878a492264e2c43b6b81cd2db534bf6dc1606e34e022df133ba45c38519c2ba6f1172375f1e2a0da0ddd785969c1162f67492da147a2633bba27918ce632d5463e119778a14bf365482d74c72954e979d0a596a884dd812fdf5bb9c5b608892761bb22932ebaf32c7b03cdc907beab1ee57edf20494cf1eae2f2dc465db640772961dfd2ae779366b34614249bdb6560fa96ac6548b576f4580b1575fd57396daa68ae56f32dddeccbf2f95adbc0fba0cd3ec1dd6fb5cc82b5cbe03a32c96f0e565f4137d6fd842679f5ec0f39dc90b7bd810313196805b54792dbabdbfef7b65d9b368e639b65a4c5775655a5a8eab600abd39cf7e36c031ba4b0f6239eb562098d98736e01f72f712e06641e9606916ccbe6c9620510b79880c487c11ab92c047e15d8694ae0fe61f5bcb8c290798ad6db1e15943288547f1b89a491c9b2b1fd9f6ae0fd482e56574767e271ced31b258e6875ca192db203cafa58e61d01814941cd26785f9dc86da90070c5b11c3b250a97151e66bec01699702487915b15ea4c061933d79856a3e70aa0f569e9629717234fddbbacb6ff1310dc4b7275e0c86ef5efd8fcc54069d559832dc90485f807657a7c5ad8e5674b6f3f1ae79fb773f92c0451a2ee8d8f4294f61ab41d53ecaa8aa792f0473a671446fffdb3e68055df0669fbb3e5ea3e9b6cedb8a2320a7bfebaa78cc14d5f8c796f370fdc61fc4af5b3d086a298fb697e043d8ba5af7205bad615adf29eb0fd8bed92f633bde07a8109ebefa0a7b526046a75f9b08b36a9b49d801b90b491aea4d9a6138fe7f2cdff6f98d8f3547edbfdbb97e83106174131dfcaee57b6a887b84855ce388a7b104637bba23f386f5f170c61345794f963853e45b4ae94ef8866e554673a3493082e63c67bc8cda97cbca56d4d2725282953d01f5c61219cfe488c8b47c35a62325323e84a38f777fd15d13238eb49c136829b8ee23469f399ca8ff15e0cc3c590ee6b168fadb944c7699da421e203962f3ba2e94a68d91f93875100c87c8443b067b67bbd36880ba2e70500bb52b03fcb3ecbeca68e8210a8575bc23aa81eb10858b19102f0d8cde34f42342ec108de75f34c6694ff17697f7b656f86b59d825af86be3dd76ea805ac8b5c196a1c65c0b63b8e11a452903a1aef6177fda008903ca84ebe43fee61e885bdfa2cae1392c18371ec75a4455b0c601a0af52b0e86aaa0ce24e0a23a4866237bebb989d5a8a5e0f45e0e98fb70d4f61ea93647d887e37e5d200d0c560126b297ba72119f1fe920ddf8899068ecd05a4ea2643cec913c468baea453249247f076506c4e68b1206ab4f85a00646bc8d771832e43e04fbe001a62cb28d80a50126377e1af8ee7c3602a32a6f490ae8022c34422f544d6402ff109fdb5b16ee1194fe18c49173915e62d284b9c15f050eaefa2a3bb04c44ab2e4240dbea951b87cd1994e97176ca37269008d51f246e72745ebe4f218ac9268e600bf0d8bbc542e5a550c7fd7e8f67de6905b8c644eb5d51d84055241095b486b8f167859f79df21a0d8b97621ed17c464204daec9e91928185defae9529560be9e9f6fbbcd1d46369ed0ffc8ce472c56de030a34ac69a5be514a980a4665482f26561fffab4b4f9dd19f5a312ebb72d13c8a6592cf1850f9e6ac20b2543c7626cd3ef513230cd820b468f29a9aeccd8207a7d30e8d464cb74a5c7891c542bb0d26f3be9ff1131af1940c276962464b2638282c9c0b11f8017d47b03c7b534ee75fab7ec7966ca2fc2a300695412df731b440d4ca361523638e5dd254af9d158a52f81a0fdfb5f60813e65331d22b8de45ca2edfd94677b1033f270e2a388aec4d091b973adb98880859771d49b45504dc703a157f8e3284f323a7a04c9aba619e7fb284385a1c89339bf4f813a44e7bd0e37e8ff74bb4ab6a9af96d9140fcfd67e2b77c1f06682426025828a79e9c439021eb568263b8ca78ea8775bd2aba7ec11213dced882ddef06aa6e8f54a034b2485d56c333f8a7ebc20974720dc00d97a495bc4f6032920a4e8c06a7431eda6773414f88b0b6765329c5dbe9c86ecac268b52d61b09621480592f3d6801bae9498577358e758157c06de1a7c6202efbd3f3b6861410cd674edbb9b5b72ecb5abc5ec19210089bac4d57fd29e2582096dbd8c626d3eac454b4608c586860215eebae786ac4e7b799830bef0ee3eaafb787898129b7bf46a3fb7dc9d7d1224aacba83e74e68a6c6403c703c81cbb092121e4809a7212c6da927c0f609d41a4b8df5c799f8027cc59181dc19f231f4d8f954671a95fc11986e775c3ea57a879a2dc58ab5b3f63479d82b3b58867a463a29fa31a3f18c640f2d1d3856d553862c2d40eeeb23fd9cb7b899cd106d5cc6276e6896e32ee60f28aab9aff06368024aac193b4c5e6d928cad94b4ce51f823e09e6d5695fb746cc618d593909b2717aa93955d002df0698eaa3bae9f8b21e06093f3609cf1e5757c4a3a315feb385bccb2162560a15db7a17273d072bf2fbe6fb533569f0f94ed89cb81947494821a6feb0768f3a179cc1a418c16ac17a89c21450e0ed761cd62aafe0e5c3a7ae93a6c29dd059fadcd4c6c6ed12c3a0af2d2136833fd96befbd96bc0344cc2c2805d49d76096e56b5535843592c238c0af5e42d694d2e13a66548135287ac65faaf94cbaa5816430a0d1369c31235d072d134cfaa011150c97bca81f6849fea28701c5ffca85082f9f5fbf50bbb84854ce7cbb292a69b604982ec2be303cbc9c8ae078a204032ad4ef1a31992e1d506059b1f8052c7ff09e456f0477b038f31d24e5a80989a233cfb4f17cdf79a6064c6826b151299c89c0da3f15b45c4db77d4c4a1442cb8daa4d5394f596543ae45a7ffd3c5632c525cffd5c1e32e67ff0086ed5a0c1552d61a8ddabc58ade6627ab9fdff3766228dee17c395437ff89c0bb3098df69508b7c92247428c7a721f5a2dc4b78a9e9b04b394614792c1865278e69d9fdfa44fe6f93d31e27ca31f7bfd08bd9691e04ce11979d78d6988d9c931a0af812f955b789f54463667ad6f5f32d75ff89169562f4bd21cb0347fb1943312fdbd7e04f7070c764b16b8779e8361bd96798ba98b87f3d49b6204748e55f0d5bd2371704717da48cf37129f036012e53a173b880ddadabdba65d98ddd30a56866ea620d8bce485364a761db205b0498a54d448dc3f01db67dcad33db7ddb571d6f262b838a934facc04b75f588f0f01c68f2dc90e42923dbe982a9d52fe7dc537e2727e66416f0cb7366d8b2a416e91add025307aca49bab56c1d552b2fc49cfcd14c6604eeb9f6fa9334c47287eccf7c278e558cd506f33d77d5cdabfd9b45edc4370f327c6a02dab4df39446d7d53d11198a043fca784147ca7b4f34bba0548dbf2e32aafc0cb40f34226cf4cc6a5dd6046d8189b9a014b7e968cc78a399c0a98986248f1a00afc8f0c4feadf60f0122db1c12ed944a10e1e86323c3293143b5ebf965e557878b43987643e16666ac44fe6f12d4e3ed9b2a665cc5b1633c6b3b4f166ecf8ce025bf6c2e24a0d03f4eb6153e6a42acb1f4895b76429f35139db4648640bc72fa2853350e6bcc5d4ad0294a018fa9c9974b513195c358d76377f152de4bb16b06647137f0325a18cc735c4d6da62251bda8af16afd0f638cc7a3222ef710b1a1e46dcd1a6d288a32dfc0601bbd9406d7ebc26fc4577ecb55e8e80e486df3369226a609057216d968705d78ca680b9339be1351a8694c25bbf5edc931847fba5d6030a1df6e17f6874e64dc32a13f99334a2a2c88ceec0de7e86c85765ad85dfa82b1805a4cdb5fae2471e3be39d4ff8abfc28ad9c10450615c1ef41ae9a911f46979b8912e5ec765183e91826525cb5500ce4f145bece46ce2d397afcfc18d5a811baf514a49e83a2075625d180d9befe529b4632325d2f184382813b637233335274b0a6c4f0bc0d1b114e0a960ecc9ee4ae9adc56e7e850a49a4c349d89b1259518a53d666ad0f9148b729b355ac2a939a9b4b270c2f464228114225282da5501ee75fe70e611c3f06f7058f5b9b354f2c09a0418c05dfa32dc9c2398d8747669c46a8cda0c0bfcd665459cb3605c6dac17c7e317cf6410faf31d7099b4d25e2153f4def1287568223680087ee4daee6a05dbc63274240ab75fc69a1979af3a30ad907e89ac869bf10f7be24571fabf1f935cd045bf56f64219f4b78a66a42dceff161f32d6d8eaf864ae47f0ea13b8ad3c5226ca484ada3c66023cd2cba64caa4f483c4466b78802aec950ea5704970b94aff333a7ae4ce7b592ece6d9a235d7c1d173694d17774498fdbc980be75305aa478234b1781a6b870ae365912b7e8e5f025c71816ccb204476698efb1b7b1b051b2a2ff173a301be305ef911bc26af312e86fd4f5e977dc1ec5041c6fc0b36f68ea53f230eb05735533e3426334d4099bf7a3278ff1b129c9ec5f4c14cb12c3f47b660c597bb763e26d8264abcf6feab584d57bf53933050dbef5eef0d3bad4e9e353ad2a2acc3a58ae780ece772a91ebbd4baa012d044cb3d6bf94b854e0c18e9c25c0589063eaf7da0ed4a7b1adee35d3107170d249bea93174ebe9dad9095ae00b441eb501a781c870210abf2fba0f55474474a06a07f09a29d68a436167372fac383a1a1c5328e1cb75313abb32be8ca4663f012e90281102b50075396f2720371a7ad1c8bdd81df3b1cfb18b3b5441a236009dd566bf7bdd963d9ebac9b153eda16ba916820bcb272bbeaa8d05e79a4c82891138713343bd517150510eb1576f8e3aa88129013d0de2784b8725e6325dd9874fb5a35111f944ac5f2793306aaa2077b993808df9815531196958ee63afd996e94494e9ff453a31c50157344c88b5d49214a77bc95858c4967efdce9dde202652aa8d716b77ffe64608c6f92cf90187b415c9e1f238716c003572d41c2188cdfb0293344432fa2a0eb263208736807bfd07287d2216333ca7e8809f1a6a34f7806a8fe33913d382563f3350f1902034d7d557317f30536ba4728b9b3d1793bf4ee85f51f1ec5f5c9c525b8a49747e4a06a17be113e9e2ae25c82a212837094ce78048345d5f799d66b25fe9254de43ec21ba7e45bf4c4ad21f0367e235f6280111383ba5ccd9d03f41bab623b7db3ee3a7e917a59ff1ec24ec858c2b46ca9f198202978f85d08c76fcf712aab2d3669c73f8a0ed34b3a6462e1e4c914601927d26fb3078be50de07c2f6b911d87a88d815f12ff38109f9c9638b91ba3de5e8cc3166095c85b336434fa610a31ae3522f88d83807ce33d8c550b02baa8274284e5e8121b6e7c214d841f43aaa05ab68f575a1824fab8f2350068da5e3079fc1a034e29f268248836f804777a189cf8b3206cb79e871d6e08521278e8c4e6cc8a33c5b5b4148db521671182ff111adbc128f6df02dfc8bc53a39707c8b57727fd804d374b11c4e5ce5865a5e793dd94c5df32d170008e4d4bfa8727396dad24b8aa2ad87f28f4918763e7530c2e885d06868591fe72e31097b5e83f5e522d5981485f5e14d700f7e0e8eb36364b93cc8aad12174cdc0bd0adbb86f3f098047fdea7b4565a9f308be548fa1124f7785641d0887ba2846a3a7a9875064f8111e2a8923c7ddd0f78f9f48fe8181a129d59a95f593423807da7d4b1bbc4c95bfaa8539792b33f58b1441f2c7d6b18a6f8857117c972eb9870ea587147c59bf0be1421552cee1b58ecdec2502646215b1847e1adf9a427516164702f0cfbbcca7037720bc3b5c29c9de0f9ba59210c412ac245415031e8f9e402bc425f1945cfd303efe7ebbb1952e2f85a1f50b2bd8017c7f7a7d65ac167684f4fd78400fab5265c801e2f24480c27cf8f1da6cbf1cabf86c84c3c9cb1452e501c739abf49bb36bedc37ddcc51cb627fa5c4a544fffafd952d7c861217f0dae40daebda19e1f8bdb2a719fe5b3fda0a53589e4898d759f3bd8af08e1ed823a8eb8ac7ef64b259e62e31b03532b6489d694e7af4a1fadb007304a2025818787c1d23ce921507a1e248e75fb282400c8646730c5ef60f6703961ded2be03b0df3e652faca5f4ea06db0451c28bc3de2825e6aeb4ea102169352b9cdb2b6f1e32822e9473c216c56a56d91e003d8b61f8438a89081fde72f6eba3562bec46df7e2fdfd07ee92b81512f0c47fff5069d776f562d2536368de459a2033d40152c2b5bacdae62792e77b5f58e655f322f3ea7c85df2cd0a76e8114be007cb793027d5ed3e585a0b4f25e11d2872913843a25b3262c3515789c88be4fa9c8972c42e01b0448cd64e95a8765fd29c212718ecf532f8a13dcb931c6db4a75c4c47bb0ec95c03cf03f89e303a5e0e257e98e8fce9beea98aff798b2549bb8fc359fc13c7b171311f0d6f9caaf1026fabba8cd269a0dcd28fd8392935d93e1c127f28af287c7cf6f211f1f08ab9765b0501dfc14de6823f5fe28408bdb68fc4ed5904111c090eb18ca35e08c284e29eafa2b26657695c87ae0ed6ca40478b967de0c97e192a6d09f09524400010de24c19abb277c73e8786f62476c5bf1df4b3eeb88031270f0a6aa9b5ac427f39b5ee08829987db9330f2b54c20f5e485953301a030f4bcc611ad29829efdf884b781e5f55bbeed9330643717fe951bac73f38b74c046482baceecb73680fa6ab41afd0004ff1878584dabb6be1e782e1f92e76e2b43cffdca011f6fb19ccc74fb3a50d1350a5798cca81d311d4c017ade9f8acb88cf0db944b448dd9ba927c4d6a2bec37c9012e49e57095d02a3cd93c8ba0d0749c1cce89dfceb14f6d63d999a34a8ffbe44d19b8801bde63cd2f2e821448b42af1817748d7d56fa2dea3770d27248b4905dadbd9abb4e14ce61c2c7622cf5322d4be13af3dca9fa117b52752f564fb1b9e1529bb2eacba9566640fef614f827dcb87ee0f64d3c1a54e64d4998e11cbc10f3be1d3961f50ab8457acc9b5a5fc57dbadff41359f86adab3deaf9f3b43713d5392a14ba1aa2a914d19d0e7760d3596ce6ae949503c5d494dc5efa74b5866ff8d9fc24cce0bebc72ef6b043c08941fdc85433616f86e497c4890f105f506d22d56fcc439474c10cc7f7accae7fe5456f159b563ab97b776a743ffda7d61c7af96e18dc63cf3d1e6b9aa4f5060a3120af4ea9db05456ef202b2f6073f54f86f51543f4f87e473af6f09c0ce5d891b22a960d9654730237cafa82cbb1581ec17a1757798e5523702a80e4077c459677559ac37f971a1f6e5f40c2fa9a26e1eb7d3ea7810bf549c80c792d713c78957600c84050d256e62e233fff329e6dfa7fa4a87d48c95adfd4e5994ec1c5c5881a83f4ed9fb9ff2d8e70c8207ffad4d60b800f47dfab84eea60bcecf3672fae3b3fe291971fd06e2d0ee7476b8265e92bdca732476c4a942bd22d93fcca89d74b7dc8c7a4fae6a163df47f3ee1d623775bd9c8d92d4b5d8c8e4d4952732c12ab395a32302da459b822eb766bbd98bdd6cdc36de9d8497acc0f6403680ee118e012efc07ce1fc2f66b12af48e1b01313301832964aab4ac64794722bfe55c15c5b87bab4059f4454c04984db4d729808aee288369a3e513488c7bceff545aee7f03a0dde961d437138e62aa0eb83c826ddb65bb8af7409e38a1f804ec43fc86b5fdd01812c6315fc0e835e85b165855c43120100fe971ccc1bce00fc8c0cdcb213bcc9024f6e45082e915b998eaceac549226d4de9c81653540fd0a452577554154a794df68192caaa850e9b61b4484bd17ab5cb249f0d088d44b24e82f5e1267072c5bbfd661d6cf86c598f35d4e574ff6ce11a4c5254f31b25bfd4c90ee5af74dd7c0ea14351eb11c7f6495daa800a1164f63632193b8b02677484212f3597b210d3bba2b8823653c711607e5f7f74a7043882abc99df410f20bcb1d0a9261f98009cabaeca074a2330bf2da3cfedd6faa1dee940f1173a42c19e7775dd1230fae12d64baf353e5a2e545d2321a392a26622ddb88c1ee8446e51b54cc3f608154bdcce6668c2f4a0f4a469145c791455444a8aff3f4f7882e444d5e1012a7888fd819c33e2c7f9e15bb46a641b065be21d6e4cb32e81fc40c5717e0a90527e61202bf9b0022a6c00bef67766a3f3f0ef21e0f29468fc8813466e1d1306c102d02d8b69cbed589d93285e3a802213fe02d8e343b4578853de3cbd31ba59fa920b012a8b157106d9c823f9d8c7dcbf190fb4b9fbc1b7bf8be3f132ab0089b3e8c84d73bde2cec91b82b054888f5e8bdbb1dd50538320f1b2040ec02a72eba61cf6373d9473d611a9a20b1d1848eef573d5248de0b82a031ec53c4862aa16f96e04b9788b6d9956c4e5503109315c4e1511a5c8dd5b30d37d6b9a4a265694e5d807cef1930c9c3207c4b1c0e5f653d28a876c29753fc063456709030409c0430ac24c980e9a2b037b9505a4f0999fcc02f1b213891804e2f5b1b4f1b1635602107c8ee1cefc07a6b6fff6b2a99d36b01ae099ef6561d5d996c9ed3bc17c7e2464c66016006fea2da62c18e0280bb15b3606a983d3a3e2143e3026727277668784c872fc1fc76b6a07e6cdf1f6df41acafac5bb76acc394f62af73ea6ce804e5af0f01bd2d396d46dcf087b01f518d658afd9f213e836f751a0f3dac2d8edd53423e36c59a5303f094a41c871d5de43c30f430392237e25a270f393f44efce53efe9d8ebfef4714a1021ecfb8afff750ddb14f092b841d4dc42a51afac9f1f6597f4f1b3ec51bf233a4354c747388878c25af32e1c44263ccad45399a8f1e9c132f506445c5824e2c87082ad09c225b3e0a9b6da4bb0218d19c11c93ed5c2ccfeea75b2e5412c76cff8893da994af1bbc636f389aef9d8796934a3325040e8de0230886cd5200f024189f64b10d918c78c87f5a1c6983c8ea00dc5cd53282c61a9f6f9328f26c83a3d3a734261bf313c984fb29d4300f51a0fd9524939108dcb6d45938068220a434ec5822a0fc181dba163c2ca556cc22cf5c9ffdd9770e52de3fb62158b59e082630108fdfbad373d14141a583b0f1f08303a371fead9ba2d50e5c04aac9569d9d0ab8bd9e97e870773a1e2992098a19c6485030379ee731c8b5a656e1abc2fbcd3c65164ac78cdf0d12a6d057b72fd47f32ab43f8220c2d314bedd3049c4463bd6810cd52f930b1c58a14f6a817c68b9f770e1c67db4ba10524e66ed4b32253cba985e5afd3f08628afb7e8751b748a70a257cd7d6e983de8e4dce212ac3ee218e59f715b11cd6b69e6b785cf44896dfd7bb0c972d1916a5a819f7b11884b4a5159f182640a22664b7e972457368130b9076558c88b53aa9b1b02aa1da01988d970132472e36843013b9995af70311349caa72c49b5c6ac1c6a857902bcb0b40b7975b714522164bbaac6adae8d0b0e809512544cee73dfcc26f16fe37f911cd3145de8abf7756f6595e036acd58aab06a761ad1b973836f784ba9dbca2c304f9f43ed83712b3257f49cede0d73c20b829d38c491e9a71c075325db005396fcd56fa27346708cb77f01a2572c7b07afa20fd9a3fd789349b6646aa34f999a00d911ae64c6593c2bffb9671837dc9a828f4ed0bfebe66fcf1ce896e2869acdfff10047abce586217014baaeb2e6af34a2143313b067de5c53ac378bd73938c96b1124c4db831f6641abcc1e8fa6e276eb37cebdab2b9216c7e5975cd4c60e805e3f50e9f79576b33baf6b950c5bb3f2d503b73a7de4ae4caaa2550e2a3d08c29992db42b6e2ba1187365dfe37e39cc0d753df8de03e0289454f830e80d659a6044d672527dd698a12ec084b7ed74e55a60a47c3999cee94a6409a88bd52a4eb068a782164a0dcc7463862e3df7c986592e41f7faea44729c92dc76c89dde52e9c154e9293ee497c4b04b6ace5f9ef760cdb825441cfb98c6b79a994c90857a60c040d8944d6678e66d9cdc2dde21af9910d5c629cae47cbd5beaeb1e18aa5ee075ebc87d085df784ba6046f541d872a805910d3cd562a8bb47d2751d7dee91f32062d180f4e5c67d9f6272ddfe9d9522d89bcb8a169e75983e3d58f7208ef70054ae636cbf13f247e60cb603a1e9fe3e11731823a851e0d7dc122199556d3ea4688bacc170990f9cc31e09d08b4a4c3a861b43c97fd9591917bc1b4602e1e225055937537e7ab83f6d2d786bfec66d33973310c65115b16a0fd097bae3c01b86411633043fd998699346fad685d24bd982a7309072aba8c112e1565c0dd42e40bd5eac82abf43439200ab87c84d3530f720293620568e62d2eb19fa44be9245dc60a8c03bd79ed82bd376283a1b38629ea02b91a8b5975716f347af14b8842903562117eabe59a1ae0046d71fd445a4cda1d5bc298e79505bb0804504610dd0aceb53f180032174c7c5faf05008f5a3c9b5ad4a63b8be8169c03e6b96fff53b758753f0bb3be00f4786571252a0841fbc689f95588571d4f90a333a8fc45797f2c5165cd620e1f99e92143ccd1fcb5f36e59543f1630d65fe7f74cfb9167907c48f5897984fd85f2e1d0b52cce0f6a3c302b1351d02fc07fc8122824bc0ad729bd82b07f496aca02881a0ebee90760a5342ca7c3aa11ee93981a50ef59459e0cf228a3dd641db2543624aeea4695d614510ea7c41f381c92c6e829097bd622cf08c9afc8d79b73c3df3fa748b759ebe228a119c861af5ccb612a7bdbedaf09631cac8eec51a112486f3f80f8982333dd9869063f997e548396c375e2c836d6b26719930dd9631bba7838b33cdd025d4c01cb3db2d63994fc6c235e219f014f98191337a869599649d37e7e270fe6fb25030b98f065090cec88e47b843ce94294cad36fcefd1f066f0c9685940b8bb01c267f771cdd91c2259674110e18b7ae08b3eca9c718a639eeae6c304b510a6ad3d1d51db939c09139440c0b57d3d15b49487beb1e578e9f2f0c844ab7078c418129fc5a20770203ae49c4820c45e152ba0d079ddc4c9e86861c85ab006df949d7707c98e6c82590f3d244131c1a446c030a863a855d20d8594d07ab75cb8ad72e533c545317924dbe388abf96296798686d5d0c94d69175119c5a5d66724783cf100b6c2f18620d04f0c109f4fad0f69b261d43c9330c9e9a3cd01c6a4bb5b1ad38dc269edfb558856dbbdb967b4b299394015108eb079208dbbf97a761ccb016c24a72db9293ae59b5ea49b824264a8ee8be21de334444e671f8198e7e67d59e9bf77724e70973046916d2840da98d2f5e842c0dc3f15c2c9d33c3da7fd092525df8793f3e1c4f0697ea425551ce4901792c7d0269c48d86fc889694e431390e47c3390de7d19c9c1450ea73be07877cc84852e8792f6638da6d4ee387130d39e9ce448977843796b7879d92f99ce6b42ef45043ce83a78ce6fd5198e64bc9601829a0ee61a454b0af179023264a8ee8523232619782c1d2a4904ee3bc4c88a3459cef910e4b9b30fbbc582c05441386a00c1929a04e4606cbb88c8cccffb89e61edb6221937a2d1a43ecff6795866d2e89cd22bd1c91829a02e0c53b054f82cfdb34f7b38a5bdc8a89311e6273368f4b79970de9bea6bbcb9610adf69429a1b1cedcdb8d9d90959da86068d90a55bb34f7bd1745a8c219878a1feb68b940a373b1c6d12ad48eb6b74545f2c3d7d30037b42969e4b9fbe533569a6cdfce68bd249d2077942969e4a334f53146e45c85acda683249b0e926c4b464c484a3241d68320261c1d2101718404c411526d880b242417359014b9a0d15e682f2278217aa1bd88e085e8856604a48591d782a567119ff6254e3a697fe2e493ae42f5e54344e890c6719c938e337a0b1aa21983be3f5d719eefddfb1ed5537d398f2aca249d4795c3313de56ebef4a61bed2a701ea24c1ed76192fe4e73520553f692822953a160ca5aa6cc25fbd0c394899587294bed3065f60453768b7498329409a60ce730653432416ebef4161c790a37323418055e9baae24c766951bddc3cbd08c9d06014786daa8a33d9a545f522438351e0b529191a5cd4a27a71c9559cb9b9f95ca1e792852c3d6d33308590a5539885da7eadc74e864eda98612de4e63f8d6fc6d05f2c5d6386755e8532daf5dd08b919318bd0d3df1e3d96ee99810208599a6786b510fd379f1ec5faca4eb2348dd9c7d23366200b16e318160139cd69409ea4944bc7d1bc25cee331394fc8c44bc2d649968ecd7466b87b8dc3cf8808edd428e43fd432844fbf46dfc0e3ff6a0c6827028e7623d08bedcbcca4c42af36e8429836962ca564c4c590c93297b5962ca544598b21625a6cc8569ca3211a62c95c494cd0c61cac4255356954c990c1253668f98b28b9b32dc04e74b7792028e7e1c7cad4c4d659716d54bcc0a065f2b5353f85a9998951642e433d30ff3a2ca2e1a0319031a277c9c101cbb5a92117d6df5b5545ff447966ec1d2ae194bb3987d1a63006f6fb48e735c7de99a19cd794fb589361a671a318519999815cc8b8ac64e9ee122a32515c28081a82fc7450b178b513f8e01aad349136ba92ced628613bd440208e6271e70252f35ca14543fd4dbaee659adb7f99b9feff373a3467b6d09c7d474bb8e5614f8a08d1e224293d8d025cf66a3431b0865fb8339cfd6698a84da6c2e59f502b38a61dafef98928cee0e08c548ad7d0bff91b6896d9cdd7e8a19aafa1a38e9a9f331cf0ec1f87d80ce7f553207806ad6f0e9306fd9a1a8dbe49f545bfb3afe79c81a3e78c018a9ee4365faa2f1c5393d313194c1dff1ee2761a4c987b0e4747af4dd80f7289411ab146e37188c8edc183c54a01d91afde210111cc30bb3bbd117a9a6d342587fb51090a58788b8e024eb690be152936a69c6708b832adb3f3fe1a5ed0fded4a454c069a554f8c779c00e265187442c58b018431aed34220f52440817fc709e8ff5de7ab721a2e508c2b9be9086d49c3c6ab9fec6cf4d189b2e3b78147f0dbe462d42555106badfd22ee434a81bc586dcdae3357f792de7b5d80c72996f485db8480179ef22a582ddf9490662e446ddbdf66a3f32a24ef4a9a5875c8836711a41ee1dbf5acebbebe43c4d9ce7c94aefc48c312751461306e41e5913423205649f4ca9605bda8f9c863feb8abf52db8eb119d4b8394c1d6abbfb79f831ed165d23b2d34268be45f35ec47b8688dcc7e1673694e61ecd18f4c157a75be28b14d087b197939f646ff9107d721a4e5d76f83ec68f62eed184cd7c4278420ac8de7b6bf41011aa7325b3f4a5cd18f43bfd291c4fb24a874c1f066c022197176983b0f06afaa4fd467b92dbea6b298993ee4940c8f44b97e23c5dce79ecb58eb4e9eb5cc9fe351a67f11ee1268cc25ec03801fc349db01830620c716b3b6ce1aad197565ff4ef517d7d9a3ad59931688c222d6ab5a31f8c8e7e303a4232e24a4a72c908e23a3a7a217ab9e145e8e58617a117a217da101648482c6614b1a0d1725238e5a470ca3d01198d8cc69db0d3746814c21b4fd97d5731d597f3a8944cd279543827bdab3d2c15d3f62fddb669164a65befc554a260f8d32499cf3d09cd32c140bbd825ea156502bb40a7da254a6ac0a3a854aa151281514ca94a1de9fe6a6ec1bc24148c5547b2e52ad49a6874d3fe5c3a61ffeb0e9834036fd16146cfa2e29d8f45f54b0e9ab8e1ce6049bbeb8c3a63fc3c3a6ef196d7a7330c1a63a6cfaab22179fa34dbf0594f13c6f14d21aaf11eb06b1e915b2e9df15e86b74746913467fe0f86ed24e9a30fadaa927f44121ecb4109b967e9b11e384567ffb26a5c2cdbea34daa118a36424a011006208523f7134a4901d11ccd1979ade63cd71a0520bcd14344ece3f03322df775a86ee514f71b5e7daea8bbedfa55da3fd06d38f4c197ae01df33dc4bd12674338bccc9d119f480f71c3bc1f99b2fcfe4ec494a9dedf8798b297f77723ae03cfc19481efef3898b2d06fe036983299f7f71a7811a7c194c1bcbfcfc065306531efefb5294321617de9b71458ef0fb6b48d26670cfa2c54cc0a469c91b9a9106c7179516554cc0a469c91b9a89815cc4beb555a0891cfacf5d9a5a5f5a910bca39016abfb1a9dbb114f187d163e9d2bb98c6d1a7d6b33067dac6fd235e224b54d13665f5434663927cc5ea05e1ff65ab866dd6531b375e6333a290c8d382313f3126ba9e34b6dc621e0849c245931ce39286eadadb9a5a441a5b3369a747ba5614bb9815d9f5e00081cf1847da3585fde83557fffe56be3526f4cb3f1ab668fea317e95c6f3d57dd673be5cf4d79797a333b3e30c2eccbed1739cf4aeebecaacefb1a37d23991f7b46ade3badc87b862a0e05db7b07e24747c8c1f6de917c88f3ccdb1168db7bafcd1b12806cef3dc96dde6367de7b87c479ca308b4cbcf72e0f76b04b8ab3ed233bc779baf7ee7bdee726ec318a80e3e3dcd165ce39e70d9c53e6348c5302faeb06bbd03d3a6b8b8f75d370a9fbd0346b7bfa538c1539a43ddfe9d19eefb1182b32fd89a34b0063b5e776de571c0bfad9a1833ae930954992cb90a78cc1b5439fd9991325d6f36a5cc1c0091076e8c4072e29d3e65ae5708adb89ed73225cb59cdc6097ae27569ea0538047b0f2d4edc0ca139a8308fed95ff4993d6f4e8e9cd03c18a8bedae09bf3856b0c88b039e16c9756afd13d1a7d6c97fc723e252ee552249d87f431e63879976c4f656cdfd84e895adaf7514b9e2ce1983439e5a43c5db1a05047abb539385bc410ee82c2e568df20f912398fffa54dd288a677cbd284dd20f2bd0f4e579528a37dbf068f387ca38278cf90d78cdc4719794fcedd470d719e1a0fccbe8f4252642989f3dc47e1bc2e091346f64c953c76de79bbcb111137b227b55336a9535adffaf8d8f8f1eaf383739af5be3747169cdc41a9d75aab57af5e6bad3705e4591d3be8d81a73e81e9403576bad15a76387d7afb5d6ea1e110b6cb59edd71d2fec3d0b2b8ca60cb1f90e33d29e0767cbc67a8d28cd8f67f7a863edc144f6cfb3974246dfb2cec9022b7edbb60bff35ace336f4f9eb6f5c0bc4d51dbb6fe4a97ded75174d2d6cf05986359df1bf1f456f06f5c396973edc9a93936cf1c276d0d198f6199b3adb54a6f27b555f4c748c8fee52a9c3ab320d39fd4075c7b6c2e8a9be410bf6a02765a5be7384527678971cc9ea9bc67aa25236176dfd1d2fbf93f4ed66e9c73ce39e79c73ce39e79c73d259272ad7577d300499e4e164a5630f1f391e3e7cf4c8f1f0b1b3b3b3e3a3478e470f1f3c7cc45c9fc342530b3917722fc4f0801d3971498e47938f253d66709e252cec7431005970b22eed126f1df2037638595790fd01f9897b9ee775ddf7751d7e107fdf87bd2ec74281434f0cea72e870efcaaeebbaee765d776dd759dbd52e4847e7b9252e05892c74b5ebbace76d74aa1c42e777675b9a0bb2b1dfe96052777b87f69adadf6eddbb76f77b080b3af83851dd75aab63c7d8fac1ddc005e5c0e1dc9d62db03a6b552e07699f1feddd44d714309b5a65b446ea2ba7b49b310b9cc3b7fada94fc3aee3d573571d63872c43dd314cdc9e3ab644a6f47580b3f9e74690ed2728e886ed27a8d56ab5826ed87e6e04fd0489214e81cd8698c3c6938d6c6bb536ce3ee1b9506cc1fd5d70fd42d7bd40a9bb7f0b2f388f6397bbdce59a58bfe042937f0b2ebce02dbce0bfaa7e03a7233b1d730491b616702f20712106244f486e18ed32bb76cd39416bd0779f4347d755a70f03fd201d95565a697d8a6f9c7036fda01c3a2aa65e50a5dd6863f471722ef19493a99cb7a6a75dcedbae8f83d6f0afdfa24add21c5905de65dae766d1a020cf50a7594a17b1974eaf71077cd84553bd24cb276f6be5f9a09ab0fd690a60e70f7d5745bbf549cb09a9ab7a5fa21fbd34722d66ad5b4be66c44eb67ea6e883ad9aff713c653532d687a91697ac7a8159c5c8cc8834ac9a29b3b9c1793d5f2f680d9bd6fb83367aa43af45b535669c49ff9f977ca647e7e3765313fdfc31f6aca54b254cb94a564a1ea65ca3ed92a466666ca68a8c61376a371cd13e64f69abd5fa9b026a51ca6ab55adfb269b56c5aad1a9af9a25fa3599ad609a32fea197d3b6fc260f4615e346ac2e8ab343861f4b30e278cbe8b4e4d18fd16dde292b5ea056615233353b54f58cb71adce59adcee124c5e494d11af7e9e778415f53467980bf946dfa93f67c5fcad8f4317dcdff30a6742c1dbcb7de3b529df9f676f7a6e8844d7b04d05afc5ffddeea0b7460a3260a14a9f6de4e3db767ffa1357ce44175eedf9f4d191d6598b0fbd72f2c49e6314489e87d4a43fdedfeb3ebe21c976b97b9ccfbba9093d703ad2697d6f01af6f5d1d122ab291135aaaffb9fa63427efe3a1dac3a30a8d40b21d53902d8e1ee124c06fd6c000cee233314d15c61f724991aa8d567b5c52a91771ea9d28939429234d59cbce38d70de4b2da2a0f686de23c78ca76306514a91601896d7f525c5623b6c518e34c916a4fc538678ae43b26e2f212c6398be27f496e8b432ee7c5e12d2c5e162c421b8f352dc8e564a2d35d1edc425cc6197acc747cb30606706a885cdf31ad512912ad5147a7519d174c191edd041366df0ad5da63b3586ddbfa527d59a7d55a3a4d64caf508876389333896592c45a751a496d16da30fb9bebf0ffb3b48125b6c2bb6782c7f53db599129357e7dd1af2e46144d1e7ac424fde7eff01ecae42f676a7272cae57cbecd1091d4d7afe95e869965923e1f0193875e71d29f7513f2c8e0689a9efff93974802008d6dba580525d1743c657597afe6026a385e03cd642f4a7707070c2a6b029cc61fb87b4290b9bb211b3cfc3aa1798550c0d8b9502a2e9bad4d573b3f4e4c10c6b2143adafa138c466ff238bf538ba868e3a5a8f8343d37dded8c2d1b726a36f104d93ea6c9ec5d273079548d71ffe2a42e96a3461ae64c27472592a90edce537b98a47fc8d201c862d86aa580ba676900dcdc10e9c22e741a48362c2d9b7d5ac8cde39b1bcf49e5a4ea61fbab8ca6cc73626914344bfb78e318b2f4ceecd39ec8a2e626a5028914af0dea2cf31aa1f5c7e5e8c080e578038e5067e82e3dd039841d8608b9fca77f71d8e120db07bd1068a605d9ce6a69e03c94dadbe570fa148b4b38ff7a63686fe7612f44795e0537d6d649d4fe6ead5dad5eadb8d6af5654ad60ad61ad780c27ec8ede3399b84a0a60a586ad1c59a1b9fda1f7ac2265537b69e795d807576912fb503db60dc2625c05905d024a67537234409d28544a37d0946ea8a1beeca964c312946c78a22ad9b0c4a612e06129e9e9dbd34927294d36fd90d20f02040b7c00828a1f90a830da34076c023ae4de15154fb16012ae139b3ed8e598367dd0c3489b7eb9209b7ecd005028b02d271ddf2097d8c732dcb3564c6b4e025a836efb4e84436a05fd417fec1a0291cb7067eb3404b4469885dc690691e797fff3e9fc32b62976d5e9a1135a83eeea4e2eb7515a8b7adc7dc3c9fa426419ac8fcf587bb228d626de44a9b662ed99332c568c6bb5b5a8ebfc55b854977686f2f5a769d8535713e8d29bb4b06d9d3486d9b42990152daa4f892aa57ad6f9df0b7010c7472ecee03c4274c87dd6e9734441a6b8d66ac70f3cd125484baa825c8a732c67d36e2102b406dd733ea1a19374a45e03908590204b285ab2040992950a87fca4a65498323be94f57191b9d7289b77f7ed7ecf1990b410657b67f68c42e736219788c7191100ba8c4ed9e5249ba1ba58508af9b0293ae157e1cc358c42b9c05093f854f3e8649bc22f18a6c6112aff00ae710e31ce22c463607324184688f577815c324c6b8d6161140d51448d488e6560851d9b48a2056a0d89c0d5f2b4e9d0b4d69f2b95171e5464592d0c82ebf45c5905dba7c364502d479a266870471324b08eccd084f6891100b0595b8dd532a4977a3b410e17553602c5060f9ac14a71b165c1356a4e86339126229825b542c7193a09fb104a1c208dbee80cb2b232a2458062fb8300898267cb83191e58685044b906226c442946f4c1081895aeb8aa72b9ed8ae60c2b477a0df35d9a12b7e20a678b8c938d643e2ca7f45912b86d02b90ec1541329327b475e551bca2e876c5100eec8dc90aacb85da1e276c5c9ed4a12b72bb8db124fd86e577270bb12e476a5e87685e8e9a6040f505a37294f372b9cdcac68ca01ce8a252b5a9164450cf26d091b622d1fc02cd1d59e4a3614d974664f251b50b0a9cd9e4a3608e59cee924d3fec90eca954436d53a51a8e6a30aa98ee39961cd873c25c70a382e806e5c9e90665891b9425486e508adca004b94149c10d8a0f2c84c828091529090ded1267b962d3f7bbe72dcbd3265a6271b624a49b949b14da4d8a9055aab2846e3a61d302e0b4aaec646b09434a424df654125ab2cb959250923d95848c2809cd60cbeca92404a402548c50a95141daf346c56887a08a2ab84a5115da9eb72a4254eced4909b91aaa89ad4a68c2747b5a4aba4f48bb0c9f58609f76c8542451e6963d6f4f441e95a75d86dbe78d8a1395262a43c054923889e2b4e72d0ad3bc4531326f516cb0876cfaa102f0066f556c7bdeaa2c4dc1ed3224a7cc60d30f6702a65ca9e2c7007aa842ca9eb72a9a549144985bda25ae22c9a68fab303225c99eb729467669a7dca08a1b6cfab68a229b5ad1840f119b395772b032440542f4e0869c18d40049114e401061e403279008220a9a0caa283282055c70c4861d825032831e9694b850322ac6039f9886a327641004a4213d44f18149450f35e0218b0d9288c284d2aec0086a444a947c600849134a1525351cc1c41529b89b5d51c9a5586b5312da021bcd8f789500ad69091224380208151a62708225e81002259c95a51e0c59d540d9b06bbd01f5f96e050e8494c08a113e80c414330d1061e5042128a2c4105a70914c293ee0839108969eb821211aa14452901fa620a1e216615464690deb013f025a1b2870de760caa2ffa535f13574520815c5a8adf5aeb8df7c14e871be85a20dbdae5dd24b95d4e52970dd6302645ae6f5338c8d067bbbaf7ddd9a28ce9463d9e281d62ba515fda5ddf8ea8b186988c623f158d7555c7428aee799e47d617c6f7825dd7e5fafabeeffbbeefb34aa86008ade3a53474b29ec0fa6ababb1ce532fca9ae63a046b58a615e51a34a9f00e78c3969d7759f75ba47007affde069a1f62204ba9cfdad2bd3727ad2ddd78e79cce82ec6f44bd18c4a310877aed1d433c6798e70883014925dbbf5fae7615a3a8f7de70baaa43a9d9ce6d6bad9406569882b0e7adca955d622b4a1bef79b372642897b6d69ff3592c6ec85389891f7b561640e86933a004295390f6bc4d319a428229449b46c94549b2a7520d444a4255366a4f25a1256c9a13e03d3857335cbbb62652804d50f0d084096609d36c9a39ef66a00d67117bdea0780a8254a3b6264905f05d6a600b69e2a248f67eee7ab4e7ed891ffb6e2772233f7222ff4171144991f52207e24110c0c2e2f4c4c94ee308379e301ba3397912eb2ba774e0faa23af4097d18211aa605993edde1c308c9443f9cc7fb59690d172d8563b5f18485ded2fd8f8f4d5a1c21c1a9ebc0391221cf1bd3959b14449b7e7da48d37cdf9d8dd13b537c5c21deb8bf2d8a904c0ccecdbd4027466b50ba92ea9510250b77c61d392d66a067037fdbb7d6327571bec26a534dba680e81327bdef3475c24d4e4c6813ea94f321aa9d36a9da29f7e443418c9062a0463ec2509fd6926a4f7eefd394a8bebc77d15448fb18407d8a91ecd277f81e90fc8462d99f26d2c9e57232395196edda7f38e9bd0e94d2897472b9c4489cc7775793fad96487df758fa72c66779fa7eceeee774c59b83b8a94d2d3490f04443242f8b4bb33ed30cc4fb28a2877efde979e61643a1f778bdd8db8fa70d29bc149efe9d194a18c28900e0586a91c2902d0b0c1a713f63dd8a3d61a73e454a794f92454d44388a828c55222d790f5459f1a25a0de3bcee0c28cd69cf48a3899834bc290ca81fbf9297daa2fef5523fe3c522127bdbf34ec6818d27be4442eec2835a2359ae3f9dea339fa448558d8f180165ea83d2e0fb6842d230edf2d8e64a349f5f9a3600aa3c06d8f6eefddc892169d002a6eaf573b2db501de18830d15111216581bdb8eb69b02c8fa9051f8d49eecaf8ab3f88e4a024993c4090d2cb961683202bc30f8df711ec0bf8ed6d67107522441599b838b2a01cd3ac8c15a6b734c4e54bf8cc189a2b0ca5c67d4e98913d51c111f70a23d9db4474445988000c4b8b3f6da5c77ad4d01f993601a854dc259da4d3b5b579ba2ab75b6d6ca87ae468f70485d2dccd1b00d4b0ff565b7bdf26eefed94a5de2bebf61ebff774ca5cde7b9fb296707b8f9d0c9b64cffb49763f77e7a2e984dd6fd13e61f753da4ed8fd5083fb3e4acf09dbd762ec79e1be43b061b63f6a583d72b7bcf72a9db58b9e31c436feee418ce344c6f87fbce5533904efa32e8fed79ff69eb24fdec5b3c6717db37e6054378c1be9d0562db8e16e536881915e492ecec5b1b8443236b71169ff4c692f491c2e725880f4ce023b4447571b70370ff49dddf1f066a84cfd26e8a448d7214090133c9cc05096ab461c86e7328302a776db706c5b5793243dc1a25620744dc1a2a97044a097bc397c122d4183896387fd37bec697197b17defb63859b264a118b8bb66050b43cd0ab7846114edd8aaf58ab5d6526aed51a64fe4aeb65a5b22db76d89588a9d63c06454c506b453c60ade7bfca17e8c0ee2e78479b79bcc7df7d3796e1d5b929dfc763d6a2bfeabdf7de39b71d7bd87d570840962c59f6b576bf2d8666edcf04c9f67faaad6e6940e1503627940d85431d15005b8ab24d278ac00165db31b507dde319561c26b2b52193138ed8ce13563f2bc9f47faafd7bbb1f6398b86600fea30526d3b63501e2bf60d7cd1d4efadbd8194bfbb7077bb615e80a1270edfa931ec0fe06761d80dd30d4918e3a80bc0903b5404ec925be273062c48811206eb7db4d081754f1863cbf5c552595869a4e5c9c3db3d73d2a072736d18f299354bbdbd75c5d801c397204024e7dc81d3972640231a707612dcd7170a13f532b28a80a96debfa31ef787834d2f110ebdebf82509c9936a16bbda16bdefbdb6da3ad25c076eabb92186709b03c15d02337781304f5c14d223d86cb05433f29e7b743da494bad7faeeb55a5befed707c3be6a42bc4a12ac8938c0a41a0d63b496918a6c4540a68d524cb607799574ed25ac5fcbbc585e3db39952a0544e627197c41bdd8faf2f2f2e274cab49434882e7b8ea504767d1168c26aa5b54eafa59c618fa50abb8e7669c2e83d3a42714ca5fd31a520cf3fb2f7a88ef708a906d2e0298c106d89b1d80f936c7fae72764d4a69ad2287318c27eec8bc767656e3ec6e9e60cefbddbdf7defbb3feacb3b357dc39edb5f5a7bd0f8411234662b6de8ac4ad8ecbf36fad623fb68458b5ef341603aa57fefae94b793ed596fee7fc94edb42d250d1fb35da28d51f6fddbd4dfd62693ff04afc6d99eb64e529b1d6e76a7bd9b64f755a326acfb1db5079caf8e1505cceebe9c4d9b8e55069bbe905d5e106c2127872ed18d15797e7985ecad9603407e89504248bc7da74128e23634c8f4457fd1afab5cb64eae4424793a9d75deeabf03cd6d4c1fdcb5ae6ed5e7e7363d729e92863a9ffa0f4d2108ba1e14411004c38cc1d66ce21c669cc39c45114f19564a2ae256b3c9cc8834ac9a964d11355b92cc8c48c3aa69d9c41c09d1830fe79fa01b1914c3ff4850c4319f1d12c987f34fd08d0c8ae17f2428e298cf0e197e1efd0fe79fa01b1914c3ff4850c4319f9d1b4138b4cd5cdee3f2143eec752d31d3cf7bd2e573830b1d8718859f61428f3ca02bcc2b9cc3958c1c666a9482901a754d20d520d71e9d190673e8f0d11f09c65c3e1a8c3d0c864e2c868c19413a72bc88b9c8988861e8c462c898b17302ecc50b183ab1183266ecd0c8c9c989e11caec829235b226ee196eb059913cb89e11caec2bcc2395c91b31087d879b093b8669027e4d1c307a55121f07dd0a81025ea615d24cee12acc2b9cc315ae3d44bc8a53b7c7e546d04fcc07bf0b1457e00a83ab2cc3b82e61106c724008c0094ed0e5f106439d948bd812533ad7572a647251dc0a3b0dbaf2177d72d79ba155883fc4557f1b749930f08be7c178decaf3623c4fc6f3663c4ff43c1acf53bd7c2a1a0a43574945bca8d96466441a564dcba6889a2d496646a461d5b46c628e84781921cd8834ac9a96cd8d1046484733220daba6657393ca214389a80e2415a234918655d3b2b9c1a13a509a48c3aa69d9dce0845e8a0033616e03933481fad8f89932ef85fa721e1f4eba0bcbda1a6b5bd6da587b632d8eb56fadb6d6458b1b2055b1dc6716c63518b730b6c1f806631c8c1f638df137fafcd87052f471f1559c9969d9dce0bc1eed7803ef67d5b0b8c1793db270b518eb57b1e7b152401e763d489302c235569339b129fbeed5f78ef7b2b8d7756f8b7b5ddc6bc2bd23e9248dd1b442fc7b86492eb1cdb7469c451634a209e4ebc509393018a91c2d5cc8b4686182c62e5c681c92e19cb255257f82aa0e1e0a4cd2ff9b3c2d8414f82649dfc32f070643271643c68c70c7c76ad2457f0843271643c68c9d98cfce092ad78b173074623164ccd8a1915d279ca0138b2163c60e0d1e185d12bfb3ef2d300c16c690316387064f8f8f2b87cc5b6cbdcb98b14383a7c70785540ef15b2f3dc47016eb8cefdbf93e1adfc7f37d3ddfe7f37d287c9fecfbbc9174c9c01d8c6960cc83710fc63e18a380b10c632fac91ca41c3c658c68c70c7d208adf7580fbdce85823929208f465875ab27f4893b947d41412ee97fef7d0a08f3a482e6f6c61878522b8047e48087dd6d5056c3460d019042007ebc70bb26cc27b414ac6103002904e0a70b772ac7ccf3ead7d1a21092b58788d7f2e1878742977ff92163171dce187476f5b7c14aeefcdc08355da23826b9f481b167aa1b779ca4b02672b6a749276b4a05927cb1bb97eff8be63c9806dc7a0cba864ec99897a16aa9901000000003316000020100a05c46291304db23410f60614800e699656604a3a978743410ea3300a8218cc18030000c8004346a666689b2000228525aa7ef313485fe33b5340618297600f33ab2a64c2f2124576e4bc01084e6858b026d59e14d8d17ad6215575516aa7e8773a8b56db47bd5c1fb18c7082ba55b6530bb57194904ae5d6562b2e832f086dba15c5cb400b429b6f45518417b00a420cb8fa5481e7f0ebd1d23e655bd18171fb8337c34b2850f900933211a3f0c433480b85be7050cf91af6f866a7e635d0bb32a4fd5f5d3b9b983c5b01ad2888583c9f8a3eeaae7956cc57c7285b06d12b1071bd98199912cd4936eeff50cd8c3dbac20b145107a3ad06dc530a6c9bcaa90659922e535c88a0237fad187aefa2e3f74354f1e0b599485195853d044b9ceac465222642b33dafe6f2c0520e822faabb76179e41c2415feb8b25713c0b601491c34bca5b6189bc8f8b229e515633d737ae6b8f1d01fb3fe91a56c1a898886418f45c5a63630bece88ab22499e44ffea518773ca8d00eeb19f17d6c5f3ea4e88bc095b358b32ebe99214129c320a81b1e6282c138dc0ab2433a72b38386eae7b239c0927f95d81b604ab7ba3792c571a2a2e7b9d610858d9e67adb26305e374f545a1254b80463591bd20fe1dfc7769a38b1b64b46a7be52d114cc116c61ac5ae3bffa3cdfeec2d5d251cd9d0d45a67905701a4e432e8885b4edbd16b2d8dabc02aea78db8d24baf18e855f2d6d2061e915d9394fbab5c448dbf1368d27e46ca2a1a3ee68ffb0ce5e3c85e928ddd781615c129ad9e4c92927d532ed35afdf19400e3df46fc05ee00589d8d85b93571eee553230f007dc6fa3f70ff1ffd6f78a7147b30f14a46fcfc0ab4ecc22f6c6006f1b172e2a73cdfc596684bde6ef9d9a933aa6d7efb86945d2762620e645603a687c0201947842304cf094d613951b2841d550f3873e97c784013d4b8f75f8a0b5c73d9a338a03842d558cb3fa0324453a67a8bc8332af5a3977364c9b1fdb6195916f490bc8a335992dfb743f1f976ea22649c4794de1f7674fdd215ada1d31a8312da4b6f739bf53475191c02ba7b8c297358d6ecd938fefdaced74fbb69edb4dd652151450f5afc650e7c448a4594655f3a83cdecf651ebdc5ed791de4b243a95e9ed75788ecdeaa6c1cf4be24aabc37c7093558d9f7217b2e69997c08a052dc1aad1c501fe164f02f4cb67bc79faf4240fe0e7b2b38e2943291b9d30f1c6d7a4b9828a471d7285fe6a9ec16d5b08e4744ba9509e94ebb80ae9f6c16f810ec975194216bdc1150e21d8192da208dc72a3d1758cca479d5e55228e0e1f3ed7537aad6df1ae7aa224a89a63a0d341282529c4b356a586e99facfb0cd04fb670ca1e30eb36c314f39ab7c7f4659ccb0cba9994b6d1211e50d2c4dd8bda09439b0f4f77c1dd3ca60b9a9f3d5c67e722ad97f7342d2438eb0b2472a89370de5c65509def23a32678f5df2f85880ce7c502ba5054ff363dc64f2f8388116cc3e89827ff8066baaabb01d76fcfafeb600a06ce1e670a503314e78bd3072170a5bae8d970f6e2b76b52e21a75134cee050befbf12b0242d99463a07fd9a5daccbad96fca9d75655b3e0ed3a5e8db327c205ba66bff52369706fffce370546972d4e6b764161f45460628943a3abf0d4d916a14918bc21ea6e8c4249a8765efc098a3aac88591d1cf8bfbddc46565dc206f1e4d45ab44916ea71e183712ac3df1497ce4f94eb47c4c8be79a44697d3d24354795f9b2cfa4caeafd83e5581c6321e59f44b06b83974972f05d4b0f04d7ef3de83f69df8a6d90009fdf5021f5453504d6a15822cd9c5e84ba927661ee99125a666e050ea2b9e481aa9098e1c55bb6bc3b10777f73da7effaa008882f36ba123d86a34b5441ccd290553b8fda54013345f8bb7a0021930bee62a4f000365227c5628734d03531c6ebdbbc9c8c0bbe579bd63c4a3921a601ca0b7da3f6c24dee811f6b026c023ce80bece56c768ccde79de55e98dd6d464108ac8e1d71007c182d83709b193189410ddfdef9847a74bf1745bd9ff0e5ee155691d6af947fb21ab343593c46a79306c2aaa820745ba4c63a152bb1e90de5ffd775107bd263572f1190456429a238717de6a00e3ea51d32ea5eba4d430864525fc6fc6997a38dd376047989efc1e911c0856b01e1f5531fb5bc1b33319a0372cdb08e53dc8e595ad6309a11dc6b7b37661f57fe9697a17da30fa904e7dfe94fad664ff2ca0a2650ce1d5910e4a992a2648169bdf504f342a47b0f5f613bd4409703268734d4709e934a3c24e82c6c704c30a9294c638c40436448d4f2903a17a2f8424a414f398a68eb133eb157284a571a71d3ecb9f254234afd9100ade41cee1ba6e4945a967747d19897c058afcb8d274b592a48156708d81c7ef48aa26998fb0a637b2661a082631f05803afd4e2547373ecee6e89564df1a4ef0cef896bc0806be9bba018c31688c4b517091c050bfda6cbea0be6fe87dd69e0c7729f069f515045f7bad7c389d91283edb13212cee07784be2bd5d7136c97c375995de5d65414800e9e815b6a308f5e02eef0940032640776d26fe40f673555c7e57493ef34e8287637713dec686437837a278e1f53835ad0841362bd74e2fb57a09bb34ed09da174814559bfa4ed265f68280a869d382ccc13fd2980c6c90c4f332e1d08314589a58fed603120387f84b9188a3032388484d0c6ea2b0407dede2f063f4d49a5ab9982d456f199e91d84607291afab40734d913d95f8b1764de0c23365cc35b871d8caf3e9b6864f84ceac15bf743aab4ee94af032867868396550db8a2d1557dbfcd416824f0ce14ec60a40717600562e37a20c81c5d89d1f1de378e1d247d4d427c379810a1aa36104654bf97f7789a21cd30426f5ffdf35b72c5bec65bd5104edd6956d4526c4c8b4828ca0ac56e423ad1026c86a6c8a2a8bab8d9310f609c4b700107afca28c828592bf9fb63d77ec0e6e53841760c1f5b8c3d4a6660887b726d6a39975f66250fbddb9f0d531024221a33c5f9654eda28711e73805662512376e217472ca8820523b0fb1ee987e5af9a90c6d1579abaf06eedca3872be4f8b6e6e4ae5e09c8cc1a09f4736e482aabbbf714a2c1564408fa6612e316562f1b455cedce6e4f85c39b827dae73ed13f927624d8bd4055ee45e927daf2ac7a6f8d7efda264b18b4680256b88e0c94adf7091de0b7cb1dbd29f16eb5bdbce1e9bdef2ea28125a780fd9494827a6819c500bb3aa2c486476e131572fe017474ffd7137d353d08150d10465eb62751b0eb3b8b381cb24afe273d0eae791400addaf56d07346fbe04b4ae08d7f02c5eed2757851ce8232f4bd8ef2ea500c59af90c69835b1fe2bf0d2290aa3e05157ea7bc6f271d692f31b274978d6cacfb4f6c38c16a259dcf82d1b711cf728b980c20a6582e2efda07a4be0a30952e21235f34c22e78d53e5b45a35bc6235f33383677252ae5d1be4f39e5cb49313724594121bfa9157161bb19552620baf15fe0bbc7ecb5811d18fbbb9779af3f42bcd029e1195a162c7bedc7f1f5f5e45acd941700d8fa597cc9a0e3e1ce7a4e26faf2dcf3073cd314966f4ca54ddc475f0ddc5c704550e0647dd1bd5222bb0af596471e2e31445c5cc700ed817c93eaadd9a66c34ed8239664291520a004f398afb63bee1f3fa53d06678346f908cdc0a3ae101a140888a2a1e25666f9719b9f3ba13d48eec65ab7d5396784e334521c4882f086e0222c4b66bcc4e773c6aacd5f1d0165faf6c71e552d3af60f1572d1970850a866fd933b5bc34a86c732fd844929bec4c59bf4201afcd7a16a1b24944715524ada3fc7fcaae8cbe73497907d8ff8757a2334e7ad21e8f6ff34bb08cdb9dad791aca25f63f49e364589b3c7df874ac10afdb15df288fa93ee3cd10e8906c6a778e9c26b67b3b2eaedbd299956807e2e44e143be145034d718cbd8e188e23f5f3ac47ceca273d2c91039bad6404121d6d20d26deb1115d08816d4810b2c569bc9da5dd2610dbf492458c08edae49c22617e0b65f5e917f4014cfb16446c13ec7f5ff5ff6acbd79bc4cfe39a9d697bf5b0e15818593ec75a4a1411f5165f4db48261aa6b98f917d51fa356ac469d8ab88a7b86423626eed9f085dddab881739e9e0abd73fc565c84e57edaa0a57d05e327a353b9aed847d6e3419a1e879aeb6961b492391d0d6213662efbacd9b5c8969f554cd791dc642096b8bb1790f153c7719d5e2c2347880fdd1b6ff6672ffbbcafa8d0a3e90084cddee7d12e4f8f5aba4e3c37b754ac132448941f8580bdebeedc07d4dec9b4e36d00bbfcc12aff9abb531e70278ec5231737979284ef3e9f90cb1e6c85ccfc08820173f34f01ad16c35bea00f35945dfda8983dc18d1ff4d4dd68f3906a71ea12db7d0f8c0f65e2c630d821c8c14807772721110b2af832fbb115005b0232aa22f321483a6ed8513a1f9195ea83be1fa741b31074c60e9cb9df217cfe4b614cc52b7f86896ad3de02dc0f884ad70304e26c1c6889c5bd01968a59c9ca87703443fbe8f0aaf6f8a11b25b3edb6bc19ea6aa906b2b895803624ba6da252a083f641100f78c7d8c709c43432117fef2020b8376988c45cc933da20769d13151393861de8c4567c085e19d0a773751813f946697618197768e25b6b0c59913691751cc862606e5dc07ab9183a1e76575f63fa007474fa80820c58ab68e59215fb3e4103c5ad3dd2799f90de554472848660f6df903caf109500b48d08ba9ad6d5333a008cc3feca40a81b35e800b85086d737d50514f26105e45b37f1689be0fbd73530e7eb67ce7a809dca1a190504e80bcd833948c636e629e33a35292c97085ae17f946446f4df85bd65ff0e83e7c7343c8a3dd4602cacfaca5277a0329454445c1a6b05e776264dcb46f29438db91056115328e5387d93b9b003209f0e9c20ae84a1d93c9a5d9593069f6dbfdb846057f3da6ac1a79b046b7b7eff6bd70e27989e7bc118a39552d502df565fdc5f904f5f5a1cd030d3a58d0f174b80d99a1cbe01e65ca4d085a11629531d4890d1584cff862bed9a459c9271ec7216a1baa06b8510e97db59d838e46a7dfe59c0004d2d666d803597bacc9ffda18d0f20f8fef0e52d0b59c9d2636b1ddcd2e6597c9b7508d40496890907ab3771d8f68525434925b1d5b54135581c312c6c13ba56d51c5af545d2732c882099be5993e8edb0af79aa42b3ee602d95d02c3b41e0cfdcd3ddfce24feeab3504a1e95c261eb665520a888a2dda77cb73d9b16001261ea2bc46033a64ef16dd0414617120ba251f6cadc5dd5ebf2e04f6b5d43b33bf3aee2b8a7fa3ed2237255ed060d4eae6e6f03121b1dce42ab9d1a377bab1bcb75af7513332081a83b9de27c4febe85b36e645901017cb3b0b7721ef66ddaa5368782be4fdfbaaa75cfa9d90e3433298012b0a73b17ad25216524049cc6d224f68d7336812621df33811ad0ca8ca8031810775912308d006872a7fb9d6b6f22bc563ee35f9a29e932001a9fcb0350063b70be1a4f150ff75fa99d730291790d0f02310e1d1f8d7358a53f47093e00cdf3523d94000fc639d8c9e907a025e13aa3c80cf95eed0851d163612c910d99274f7ae770227d3784132e3c9b0a61ba3314eae00032766171a43d0c39177d0491636b390be13ca9c04c2a1abb3f7c7ac9d9a6bfd83745ed71e5dd99371869758c719eb136fa8cf9440c6da0742e9f3ea3097f329f01c9e7dd02f909a11d78f3d91bfd546d9a1739ae7b6297cf3e260d5ede74fbf0593bb259fb85cec28a8ccad465e4094034b0ca4ee39c6621cd1a4ba6cf3d7b76d85733d551f2c2d0ea9cceea8d8365a2e35ff595d57b462d5c2ee279fb6576bcc6a1d86560e89cffc262b7e042382e21bef3b32be047922c7339112fe849c34d9fc6651c3bff1d43a1b0d17126ddd92333a24a0e681df04e96a6f1cab19be4be998bf5d267ff1179acb781f22e9876e754dcfa7920cf845304b411d49c22f35462d749cca48c27be687d2a678f1a963e6b730619697d56f98cbf3511e4805f3229b45d644717310fd79377a20115d8c216b8da8ec69f15a99f6579d7385b50fbcc8c1c047f8500eccf10a5f461421fc11e5add369f08b65a88d5042eb754a8b7cf0c35f2ce4a494405e76e118f4b8f8128dd7dc6add7d2d1d8a7bbe6e92b0d38da3c85d573cd491be48cc729107917e3e83ee36bcc34bef0b21d94492895c7cd7871caeb7dfb4c389d63e89bf59be0d3f00ef1996113ddc32506ea3a5849b518a6f9a8672f614582e6e301d58e73f673aa57858fd416c900e02ad897aa1004edb2f489726941588d3ca4499b6c40cc41631b6554960f409968f9fe9c6b8d76516a483edb4af2c90f7532f9736068725543abd52365d89e11912990a53c8ca35179ead562bcc6510e968920b05debf37bab0c7348d7076fc30a1b2482ac9902ccb56f0428e9faff468c4b07ea6f54c1e7d623346d83c975a81d4d53b67fb7bc539e9c6995bbfd0abdceff336f71e5296d19228859702bcdecc204eec7a8c70a59e54290ce606f590ee0a005e9ffaceac8dd77ed75c94950191607e2bc440335646fcb9d840a617110b9250fec5306018d11077192dda29b40694d075a88ef16380515c072e9ff07135b450801375c2519db163bb53586950771cedea293041eb3a18d4d67c431365dbbc93d33a7082c6d171d0a96c1d141a6b2e624ba43f2c29ecce6b1429f0501d69407bf4c42b0a962f3ab60af0c4004a5affecde5c41a8ddb24d6fbb108b2c14d237b855847bfacb7bab3a44c4b1d8778bfe99b206d1f92275b7ac1780c05df5b7094bd2fb10a71bbae8f1df95d6fb0b94f546dc3fe4ec74b37d8323aee155f24374bd58b1062c886b5ad2f37987848714fa1aa47cab33e27f567e067e9299e539bb61bc414190d5aa3526cd7009f110a8d5b86bed2c823516a9a52f2a57a5bd07a4515d042787cc4d9b1631f2ffd1e620a3c18082dd1fe67d12bb3da48f9337042710432de39b7a41d4425da69062e841c6cfde9e66afc945a3194c5b4dc20fe6539924a1b32edd82039aefb8ec2433e67b7e84a024949388310f4b5f29c2d95d74ad5eb8c263405c36f3155cf5fb39f4bf097cb0e09b6ba5944081643ca9cbfa7a712e8e60298552fd7c13490075f2b510f0a224340d7588c72d02926994028f4b34fa13a27e597d0d0a8f5fc9d766b375ed7487102d80e317af6f2c67668914bdc6486504b98ef8a415cde46c87ee97dfb7cb50bd41664f91292ccb1ec32d29815540e397b1f2896f996f73dda5c373245aee097073385643379345f26b0ac28b0e9784b4ab2ef76f948b504cddc49c03bff6b4402efb656b9114fed2f1fc7756c016c5944013c0c6925b421792c9530469a5525a0cf442c7429d5498e1f3f8e80c1599b789c1bb42894316555209e0167b4f0aedd7722f50a770ca50b317a50381a4791a1bb86600addcd452c7ff9cfc401c7a36c3a2392257c379a6ed30a4132f1b77f894939ddb7fc01c984de6980a673b4f9fc77da7eb1ab801553e02bc14b4d211f7f855ff7fdba3210975f8435b60431fbfc72380c0ea9981baa3974b5a1848dc1c4003e2ff20cfb45875e1d0447f37a169b0c5c6cf9aa50bb142c17e9a99d2d8b3298122da0318af7250318fe6f0e4430269edefcabac5d0c978768cade96919c757a85d85c7f49c54b10fadd31f36b04bf55c2404156a902c01b4298855e282a1f0d04e9618dd4ecb3c43dd62fe0def4b9dff3a9143878a482eb2754e80edcecb53a38a0fbe595d4bd39a6c894ae3b9fd17bfc3d69b3c825b4c854ab29018ba7c0ead79b013df538add320b4bca0d78c21fbc51a1b49915c1c154b9c2ae5122e06c3454ac25af494bda923ac2c370952b8888324d3386a50040215f812df795d4f4245212b9a351a6de85af2cf79b4ec8abcea12dab84f0ffa4188d205cdd0201f40dd244e45e4b48c8c0db61c7db2d6eaca52ba224c88b328a3290bc0e997d75a2f792fff7971a8c91c06c12fcb6212a081d0b3d599208a45eea177863617219b59768f3b19acf94db3633c2cda048554c4b5a5d7223b664771a9a04a2a59f04046d52770de699f1a41be2fecbddf47c4b0e399d3b78e12adaa8a638029d09ba2562acb4d9cce12c1f6020f851488351a591b522e2de9237db92c1520ed95e2f9b474c3403d6878cbe9353e7228552f5f9829b849afc092078508702145155850c0b203a7ddc14caa95d2c9c07fc249ce1386a2243b72042c2964137e897ae50c0cfd3509b71326927da919d1d69287fe22c99889f71d9461e369dbcde0e10e049e09b2fe78373707daf9a1c14e97035977a89969b71b6499c2d04b6689e94e0450a6bff1c645cf905fe1887ed778cb00f8182f87489010e7dc5cdc6a74203ada157ded23ec6ec3ff4d196f2d7e7f607c05e82cc09de57be5ea09f6ffacdc0b97fab017bb38bcb2ca876b64770b48fdfd9f579bcfee89164c114e8455f4775b4acd9b83a45fd7ecd981b00de0d9ae221051190178ffb2819a27ac7e48a7b67a3e4b0075eb06ce643a78f87855b10c9ed78ca7eb0b54009b967eb7deba8cb6258abba626de6c688b3cafa86ecf6d0c9722cbcd79e863da490973c519ddd5aac169fa0e50fdd6de300e160d016eddf7ae4fc116dff30dec13892e087d378207ef022c07478653e0af684cc4e29d1e76ae37c93eb3f670acdd34cb39e3b24414517ecacc5670214ad0c245b479a3f28e73a9be1d90e5ec4c0387a8bd15444e95da1ccaaa660d2bdb08816f77170364c0ee862b2a53b93e3a6efa234f36be071209801227e655162c9f3494213fa2d6472f17e191f2253f00257f29e2e55c3d1292bb3f02d5b0bf917da2609714154a47b7ea91a5420c6f82addc98cf4f3be6091c82870b2e9db7653dc0237f8829d3da0770dfc28d258f247740f348c26d3b8f24a044782491f9c423c9497aeb22b12cc6e2eb71632461e698358868f8814c582a6f2b2ca8660f7d1bc0524a1597dc9a9957f46af8cbd8a50bab6be486cf4e0270d86813ae34aa03fa9d9d6d0fc121f4751b577fccf72848d5f2c00e6e337bce2c4604b759b07449876ce2d5c34900f50958ea592c3e544e398db4e11550b5b948c71a558656bfed7dccc65337960e66a64d093de4e00457f625973a8f336007a72e1ae122135e3c2d42b88efb35f9b729e90e09036bef7435aa250aff389fe264504e5130649d25ea14504a871785a4c04683c1ed243dc0be4e16f24b566b2304c949e833b04b36ce39e7e6cb18f96c5a1c9b91f20266fd1836ffcf531b921c3cdc9f3f3706a453a4aa5fbb17dcc797e22d1226557627d8a77c32f25981084738aef8d38f6c378c78620d0ece7c90b4aa5604dd0e4981c3c9cff06c0b3eac2f9c8e5d4c5d7f2e308b1444cf2fb571826dd623af62d287b54d9121e89b753f2a8ffc7c402be80f62ac4f6223729107c4012f9c68391242734404b0b04666e03537b543163fa264c6df8eefba4088b88844ddc9eec12e5563c8aec92014eedd89878cd2796718c0882635a94eaef8f2ba7312e889883629e7324e8e8852f892f2d8bbf0ff4aaecdc3bb3f6ab3651847c72ede029f16423afb16104cadf94deea6ee678de07aeb6a031fec10494157288d51448010ddc4986500c2c963f52b1445183e6e380fbfa80a0dc1612b80e73fc26f01ccc21d6f3406b326f9e23abb32f0931bf5081420bf5461a28b1938c02a6739b7a463f27287102bdb1089bfc7caa2c8f8c55e58a985f59744803c55bb9e49a957b02505bcb45491eb67ed61829c20d5c502708e7ac57d6a807f30b51819a882325923446d8f8cf11abe568dce916882c4961357d266526a2e9c787ebb9e951e062901fc011d3d913a2b211bd147e6a8bce41c0f05870af88787b46819967c692f6e00d7bdc70794a19408b1586e8094bb9044746366572eab56db06cd8856c02e95a8f13f0c317296fec411fd5510a52f2a725b8382947dcd1a011d6936886def74dc7515ca3c4857faf75d89abf61a3cf1412bd78daba14e68484052a840e5a574f9a9a0383cf06e29c2be951fc0ed5a521da71b2a02d0c166b8fcf0a11a82eed0a516c4499945729797ad3a3c9f75ee3407675f60abbdb0580b9083db8b58917c3559b4361a5aed15ef3b9099934f370c1367b02bd4cec032f1a1638b5271bfc3c0fe0808434d88d0772c42e91c12fff84aa81e0787570828378650bee4baab8cbb0c6644755fcd36741c6bff23f205ace232c781fad1ff4dca07476f5d52638a67197cd6f35707f12158c5a2029ae30182860956499966a7465b25d5af4b3cad7ce2883cd69519924fb7810b7aeb9cb9b404d653a5e0c6c00ddf104ca0b72e3980ef13c6e0edd699990f9016312c2c29000cfbece585384152fcec76f6b3365c0d0f780aaba897eda5734978982c98a4f066c1512e0c76897194c238d1be8d6af7d1fa9f9f499e19372acaa326503ce39c45b716e933c693a4ac31e6ad7a923c320376a785d558e46d6842b84d0a3b2aafc8e90b957a7294a9bc17247b2825e2a7712c07451ad7483954a0a76b597d160763c01fcb3106a801ccf8a961637948553ec976c2d029b651bda608b014a5a3f21f553906188d80542780cbb7650a4d50b15240084ebbabe722ba2c20a0e2a2e2e630a2577db50ff2a9daa30ad90260913dade7d0a797abdad4cf0ee4df60d597661e864b15b8f47ae784a77d6127e3dab2674a8dc876d0547a62eb60cd0de1c6c552a4262bd9b7e97b08f6a289050268e21c31a01fcd42e9266bb249a82142626eafa1075cca9f870347329f178064967ba2d35aa965e9517c7a5fafd62ce3173e28b689467e5d87a5a976079628bef05a4498e850a040a1235228685473c8b21be348c3d4b84cc804711242dcfff38e9fa1b14aa40163c984c8a1965d65a488d44381ae36056f3b4b931226a4419aa6d6489aa6d6409a26d640da26d6282d30b6552aed26d6a8099aa431a2f07d950a0d682cb596aa362875975114b92a7e29d1e4184f3c262c0a8ea74e2413c74c97b22989ca8882ee6ecd31718ed574fb8ec59c7bb2cf08edca5104618ddb025a593cc71864033835e77aa8a953036d22d9e41424358d7703a42537ad9c340de2db02bacfaadba4ea52f5058ca67716f83fd5abebdf742032aedb4dd70d265acd25d82fd6ae779b023bacdfc043d5da09ccd315a9e757c7ede270186bb4cba183c6e94faf1e2a70e29608762e4e9253aa20db962c5c7fdb2c1963e03179d0dfadfca958e5f4f7e83d60b5d3a852a7dcf5c07c65e3edf3f8877fdbf4bf3e109860f85dc5d0d0ad174e650aadea526538da9ca4c8595eb01d40629cd7d1c1f46c6dea9984556531d27480e71a96f51411714ad74d0f22d0a00573205151422f3839a357e938e0404b337738b0f5076e43ed8c116e1a3acda3faefcb01e53dbdb026b202949ed135f16dd21fba60040779e33d29bb6680a5ccc06e6dc6b7016de4f4209ab4f2dfe656dd93584d8590ec647eb829a185e71f2d4305eda166a3ca53fc86f198f44f61bf33e0a39bf1c1771b0ec9998e1bfc8d0b0e27669981db3c7bec630313d194589e9687ce3b3c233e66408ec043c4da429f4203623a060d6bd3a79d0189076e23ec63623c40e23d852ea2203334128a35d8109d4703e4cb91c18189a1c9fc6e673f679270e6b97afa1347b96387c18bba0d64201236bc61495744a2f96f3cca521106f43a91fd40c6b07917e52af7f6aa92182968f3f085fe8d53d47291e2255be0e78a7fd22a35e4d56481203113079b7bf7670842309a5d01f6ecb368f73e965489762eaa3a0ff90aac34539bb1a2905b81852c5aa8b724ccbd8ac9284c3d93ee157f2d27889c2ad4fd1e1b5c1e0a90c0a2b4c12068811892c64a79e13701ba4bbebb6b144c4225613a116e13a162c373c58c0660650291c98f3c11b8a960ee98611179214840026c29b7ce52264740d983abb468c26d6e74102868886f4d165504e651f6d350ce9b67685e1ecabe9bb1ddeaa47f0bcd55c422d60e82d847d43a1614cd501c3f4e4e60a01705cd598a7c6df93e67331363fe4a93769ecc8888d57b694d74632f30a3d911185d61acdb053abd858d210886c454c18a767904308b5357f5cb8eba1bf4f5a583f8a83471bfb96993f84f34cef3601ab075fc68942ef68f06fdc18630eaf5f57df16dde8bc6eac1b4992efbabf06a893710c9a9ced1ac0731c4354763df695940199d114d7ee2c42d324344e132daa2e3c47e1d1bb6ccab33529827a817b1059666170bcf48392cffeb41813231fdcdbaaadf5872c2a4eed2a8d94fff4f2cc4ba6cc2057d86119f842b0287fc229de0ce4ab083fa6513ba2734a3bd7f056760741cf685295cf8a8857294cd84410498e9be92eaa3278f6794585e1695df25c7a1e5a02937e1c74cfcd8bc0300d40262ad6ff9b97452a946f8c901b8b97ad5818c8667379d4e60a2708eb95dd5faf7982b3a6677db5b515c14dbff6b6dfd678056bf6af3e5db2a883ea962923fedd978aed53971ac38e75a8c04833c417321798759defb57c75fa234e3a68a97dc5186429408e4d6b2d544a659350359650b1b6c1cb36be39ed62e1699128ad4b67063adb3b0a2fb8e93ac2d4584d0b5934cf4dd12d9e2069f326e44918ac0f85537a208c2c614314a025fd0b9085e472a62f1e780c0c4d15c5eea4f2d6ce32e039c4b750f82264a4e196c2818d1753fb5ede4c6861e71209095591777a34062f9309673343b1d49b0db7724cb6fd3a57773c3ecdab379c3849e458babe9614e2864712194dd9bf61a6ee14ff663180b75078d73737cdc7d0e081dbdded96ee46965d0c77233c32e638db632806ca15fcec6779f9a0f4d389bc1fc2930258f0a730c7cfdf152df42f2f4b4db151ffa4830a5263b339201fe0140ade9eae5a888d5cd0887223e82b7883d55cfed5cd374ff923da3799607177a88974df4b0e952d90804b43e49a9581921ec66af43afd701df1254dcdefe6362c8e1112fed6b60aaabc7b10fa45a202fd3c4a0513e804674e65cc3ff62275ccce75278517aac4c2afb4afd2f105a8efdc6ecc19860597006e68a941753e098ddfeb65516eea7a90e15f02e2598e84fe4e15aa92a29e9a217a5858ce2a46e913ba216e3fb82af598bef8a7ea3cf78ebabbb8b4d63e6aaa01d9b03183f3e01136ec1782c813b4bc0f1d2eba4e25d30252120af8c3398074e0c39641ded5d7b1bbb0c9fa60c1130a8145e83391f60aff9231272d9f5219a1cd9524e9c3a8c62ffd5068046d124db4da64668654a134e066538931f2a71cafa0632720fbe09c2097eedffdc61a2e8ab00b0079c7d4cf5f7ec3195f9245f28dce775b0a3f27825c1a67707c0264c340cd121d5a1e5c852fa1b9d6f1b37302ddb503efdf61c1b7da415af0bb2764a21c7d8bc6cf9fdcee1f4af5f69bf69ce7f2423d8d366d79164214301f7c7f3c2524d37fede06198994163fa916f88cb4de5fe88893a453982cd5c4bf099c01cb0840db437cbc9d63ec9c41d209ce11a08224f37f09f258bdc77bd4659808d329903b23af567aa767530efec76b10dbc4a23d210376c826f75122682fecfc961b50d723e3ff49439834a6a3d88b1987c3dd3557a26fc4f22a456b3a79fe2a3c4a0bb2ecc06ecea10e049260b4b90a22cf19e0aa4914c61fcead1226106471f2a0169cb238c297565017841946c7d8b52de0a7fff32f31d949a68802e80a9241d3eef7c5db85caa0e201a74166d1c2443e9bd8545f7ab6827dde30a723c437d077d93830d36f27b467c957e72688c75ea62a7fbc0dd20559e07914eab0e26d77a44506b1622b387a8a6756e854592d34383bfee3988e909d4172a8c1c0865490c0aa1131351bd68d1a75e9acb531f96fd34513062a0754b60dd4448635843d5e0ac1f5ca76dfdc28a096d65090bcbdac6804e4f7079b9b361ebead3b7d672405fba7ec2eab803c521e06031cedda8bde5fd69f615f92144029653af2660357b98f74ac6f856fcf5e0330490b8d04aefff36e610278cd9b87bafa83a085aae3098661f3edc050681e0be8c6b4a73812c0ad5de933c007cb229bba5fd4e1373977040c0159018c1d1f6232cd3129a4ae5468616a7457cd45d0656c57883c4a44578e4b18dfb5964f39cb228137eeadeba9cf5652611b565d4c0f61424346d4b59b8642b97e8e042734ab8a5caf6a79c4ccef61510e014550f1472a272ab31fa31361a4e00d338fe4baab249366ac088548d66cd8e1c76e8c03d4e1c61d8ed54108ddcef0b7b1b92d912f3d4fdd265472484d3d50a07635bcb7b1b834c562dc821a210cd8da6f06003a3ceb67db727c5043ba4384a5cdf9b44564e2cf24a87f61884f0ce211cbc68dddf0ee4bd05ea73bb8d6d9bbd7935fe450ecb4f3e755286fd4577502fc1a8a3f12f49ffe10066e3a94571bdec0a40ad0155b1f7c29063876e802b5686a6ce25477a6a112d0d3acb952b2ed2ff02ca73b67cfcdeddb71bb9ae173b2f91bf4c075e684fe7ba6a539e1be4dc7914a515d3c578f111fd9d5c1873b322931949bc31d8967a0203a97c1583f0db3623d54b0ebeaa8b89498cc19162db66a0fce29d42692aa729a9feae7fa9b1deb39b24bf931c219f614d0bf794a19d2f6b5a22ffd4363887dceb75b1f76d93011916def63fabaa9fad1392351e9708036c25d8ebbfe3afbdc166716c85474db7ce67c2228c2227519dd53f261d001cbfa3993d6e9f28ef57abcf8951c31b0f47083f4d367fc4e69cd107be376b483b18c9f67b3cf90b6a4b1b968e2ba887c7473dbe84bda6998c578ea36779ac1ccb8dd559c1c13c04e81eaf0b11d69d0ad2d337048ae2fd20187a24df1f6e7641a184b7092b3510343564db0d499f02f346679e354504889cd24839a5baef8c683cf1e965cae9967fd7a99068beaa9e44017f635cae62e89e8be8c521defb1c0cd04ea2fc4ba222b8bf643e44cb8d1d7d8be4634711e1a91d7c2efa2b9bce3d2be497c6877239861a02a7b0fb4f9850d933ee9732f08c9031e7652d3e86e6f052b1f778445684b8cdb014c2a8d4c55c6ce7b10f839648d4f24679ba6d2c228768a44e6fdd4ef5f4834b33b6ded6e1dcb0d342f0f41a34d5144158e04a8ec3a7892e88cd380de172fb2cae444aead990984b480411b5aa1b0a1cc05e61bb19d8a9abf66615dd5e7ae4b9a04a581b64c1173ad27b65766d0e01be66878c2f08ba1bd5005c429d7a5764ea2538281dd1040e4e08371a45413e4d328b27f60759e09f52e813feed83bb1fbcdbb916acf633be04aa0fd6817d27658858b5e39f7796cef12e513ec2b375d6e5739a58cf8b6ed7241bf823448cacd365f089cfbbfc60bfd670e43b73cd4562da72180c3e4b270ac254240165d826297d8b7a21473939a20f63c6c0b68f7a59d54f4e0e19eb22f16a3a13e54624ad44fa1980f366c627c3c1744190bfb82d68d0e1b1f3ca791e120152610b11b10944668a0f5dc62b204944d76f5d3ce73abe91afca30a084a7bf301ede2bec7a72a5940d222965993ddb744924307caebc50d3601713bbe882f75b90cde0b98dc9d8c3ed6d64d4c30bca9f827f905e0b9e1207d0a4f1aa11b5ecf4463070e0e006e8000eaad028a966de5597679fcbdab61d2599cc8dd26fcadc933998807262d4188093662b54e650000b19e65cb0b545136d3afa34239fb9ed04993dc216ef20512218fa1b6c271175e4dbfa3d70b42f652b72a5e64e5124c8469e589a2df77293ea42b41a2b804c1e8ec6a20f644e91035d4f55c84df384c8d8264518342f42db22d813e83d1de46a54042f4d7cbbe3a2b50fe9842e21420e116bd9803e82f3b0173cf77264d24cc5b33b2c8ec6ebf336439273f63d90865899acd07e42f4d9665d859429ea02dbb3a15c130cfad5ddf7470764e801fea05745a9ecb45c8025924a9499da36b110594527ebfecc25fe95fbb8b975dc45e697e50732ea6138684e0895c7ee33d9c7a2dcd9f48e84f8d8eeafe07cfdaa490587617a626a3b0ddf04e1f38d47e66d729b1ec6aeec016a7098a36a7822ce8c1b5bddb8c08c59011fe9dcdc2f8e6990cfadc18da5e9b9e423d13bba0c39233e2a1497ca23537c1b7d409b52b7c2b2daa8e6bea8caec24531f1b366e802f3139769a80d82f7f3914ed441701d15a8082a517605015bd075d01c712ae1d6904fac0b82d03b36004c1f9f9f24baecea77bd1ed7982aa6f72305f73b6007dfd1f1909d3901b5081a56a35fe1091f1f61fa59064ead481848ecd9a85d6996d0012f61be3392b100d2722becabd168aa33c7aa2141e910a4221134167e2f5fda8ea18d6575f5666c17476fdb2b4996b4dfaf6b584cdf65626ba5e884bb8be4faa89a75bf143328d0f05c01aa4c2cf3768e8d40434ab24c132729f42896dd5b8e9270f5a45afb22db5d7e2b53f80b65c4de76209eab8984d96ef655d818ab18096842f2f4ba69bd7daa42571739c774ddb6851514d8824aaa3eb2f814fa1cfc7ae3561b660a32e0ca9bd9d94d06fbff48be3e106496d31c29f7227ace4164caec0a5ab87fa08f19adebae544cb83e83727a76a693e0fd272f4cfa9c6b6e1234f6e1c5501efcfc845410342b7e03b9c48db63482c697ceea952efb3fe489c39dc11a44ec6f8303ce8cd53ca9b643ff9c0389b774b71936d511286b5e119f95d92bc37595a10ad9dcb28fd601939a8c1dee3907a874a2d49197b09d4361de42147b05204f408608717f5eb27b44b245c25e6c412fd7e131b13b3f0a01cece171863b39b06e265b6ebd36cc622d56e809eb862835e9164b5665e6f5e130f0245b97b98f92d562cd81ef23d87b2b741bb1e8c058b40c40f69ad1afcac231411d84cefa26c822d5aeb9e9c7a19e9a9d9682cdbe100726db0785b13f96d3db74c841c5702b085d0b2c3ff858bfbfbcbb78cf88fd6899668e7b46131bec9784fef9c6abd56a609bec44ca14397076940c3a10a4004644919aad91b7bddfd2b2c41866b734defc12b6f3fea91fd3241d19b59d4056ed94225d27fbbac27118e1d63353db60886ad8ffcf7c647780ae04a11a03a924924554e8a81a0cce0b98536d88813e31bac4df6bb8208826d0d799547d14b439985fd51a51f9c94423ef0edf24c45c6242ed7728dfb35927b4e2ff34fd2766c031180bc14de35156572c41d87e20e36f0e39f4d841afb01c880bee1d0b301c1819b84641e8adffbe773570d383a6ac3480c818448a5501bdf0d7420175a7b3cd283721d8996a19731d102d19a25793e46f454d33778449e3cf62b57d2933f83fc4a068f728963643f8f524a5dc62574921d33baa91ca56828a586500c78219d45a9a877adefa268487f807e0f5fc690cbbc0cf95cb7983f3faf5b0c2a5bbb624e6d3f274129e53f7b5acaff2df1491928c54b88439b60b5c67ac884daa960887d871d160d75bbc524b3bc2074bc07b73dcdcd7768c425170c395b7556aa8b31d95c7f44bba56676f24219a253d72c86941020261b674dc18f109a2e896361b3c6df79630adc9ffc4794285ae5fe72bdacbbe1fe040d0d3de0cbfc320b6389fd2da194609531b0662aff7de4f482e2a29aa3e1d611b24f166cb2f8d4863934425811a07e851bbecb1abf6b7e0d5412d2ffc6be0ea4b2251a0fe69ba043ed7a6845248e0c6780f30e3243936a4b85fc03498f648d23a3f18d4122685e57d38bacd777ef6b14f37782fdc60c8931a6361355ed13a9eb30bb6f9c9af81b2488adb7b42c637c63730ba236a63680ca98c1f888da16cc667c63b9837988245cbd677c26f21bcf095cd4fd107a2d10d06080d5a75f66fbf6983e9a41d9e070a8b12b77d5502b310d73e8ab3ac824d4f0c41d344d61eaed07da5d01066acfb3163185ebd5e001734fec1cfc72373807efa43666aa6af27121839b2e9edec44279d8e6bbf09761541d2fb4ea4ceaf1398f40cd284d591b4200a6e4eff178fab38214adb281e5442ea632e624437217c3dd2c83f77634f28cbe141ca11d97026771c7052d9dbd7342d8e15a6a544ae1d869362cc99bfe017d4d973ee03b6e04c01505acca670f62f4a74bbad85e52ff95d425a0f2e3eaf77adac610561313cd26fc35f12b7d958a48baa29a7116b153cda4120d3476b0531b3ce3542ac14017e154ed7130e486fae1d42fc96dde8aec82610cfe99eb5a36839f832efca4da8cd0a06d76a420291a05f9304edaab9f401a6d66a44a6661112c1f927e650870d8c9f512367a49767fd647ab2da43c07bc71767f95afc629b5bd9b1580568d6636e35aef82449af5c5e89ec79cfb4f72ef47ab3b7b5445a7c957ad8a05c46a672bda4f387103ad761f08565b53a9d56c5ead36956035832daf1383f589eec771f1094c7392bdc37ca0fa3f3e6c8dcda5315187f7281394ce73ba72d954fae898241748b0b93f75be6c601468f9dc24669721b777ee511e5fd46aaf7f636373381ea8a8c36e1227887c2d489c4eb6da5814667f0cc3a3ca3024b466fa5a02cec57044af4c9361e6b80f022fbbf702d10d5399a6be8eb626dc05d74daa2bee0c5aeb7440c0c57d767351163c8374a15bea88d7a43e344ef7b062ebde1530150c5ab3b95dfeb37bf03431e6d6da4dd096e6a354bb50334de6560a04b5e482bc690b9998fdfac631424f7ade0018a82c23f71983561804428172760eec5936232b2036f4f222f8785b9adfdaf76faa25a98260e18888c31c98f1f29e9e72fb54594af3c10e69ba850a3f9c1fd05279e90f31c395b4f8870b42025d01fe2b1520d2855835bf9a212ea158b8c752253fa40716ee707e9af324b67f0a1bf89554b4a97d5e84c15061d331423307f4c44c950ee971bbf77d41b25187912a38944d451a9b51fac944980fba30fffdf92e90ce71ee54c4587915968fe53ff96ffc3e708b7ee747fa3e154345e6b89248ea52b936d3f1204bfce8688f59baff70925f81ebe70fa59842338d0aad88781a935b461e72c2c887c3dfb082b12191463110985bfdc5a3b0a7f6379519975b88931344c45cc825fb94cde72200898f9ff2f92327dd5aba2aa02be7301ef12c8d3e1561c3c223c179ac8435563bc633b003d56a5c659cb18a2a4bfc78bcfc8395adb39662c8940d35e348b3561f06d50ab5c88f4497c127ab8b508731a4742c0a4057fb24c13e358f25afdb65881ae4782d7cf95e6875ccb05c27db8e0e632ecda84165ca2708b2883682d978d7f4674e42652243af77b81a835e7070532de2d2c9d2d06e463df974a876bec58b4d0626a3d2d4fb7424f6570149ce99e993f6a95676fd9623db36f05ebda22890433e0c4924c30cd94292cca5a594d3964ab10a7f112a2a852e3008d12d2f91d1a661d1caffc0297d373b9e85447c241cf950006b308864c1416625b93f36dc911ed542f613f6e43f815680270649814d5d5436522d1d9504488442791c2ff02a484a62562547c445cd750b507965288a45d7c4fdeff65f6087d9359ae5fd60e2c0d7bd82f29dba9ea5de5b2f9e972af0ac51e1a6e2c4a3b8f095d55fda8dffa55e9e4337340aebbb726b598fb295868588aebca619b8b49b9007bb8b7de3569519ad123dee79d2d909839689e05be411001dd1a053de36106fce4540ea80a5af750b4a275b088859e464d35c8e5904231e66bbb84c6a98395704f38755578e8f45614a70c838b060cee55e06113bd53a1b6f6566a9564dd51c42112d5681b9280ca4b2f633da3e7c6b329f51bfa328eacae93900d01409067a2edb45a3c94665f67f064c741b3743e34abb9f20b1a690cd31e94d70a6d95853bc0a7618085c094225a078b2e233636c6852ad80b15d0285c9d42e285216f9c1bfe8923a183c5002abc467dd1546c5776b76d1bda302dd21e260608ae4002d06ac1dc69100540db4cba71175977cc1117d1e6b5d20df612221d916f5679af7064ea489cfed893c63692164a0e394787bb880fcb8002773cb1f0d401fdadffc237e58a54e00bd4a291183bf401d0339b901fa6766b4987faa7136eab949e3933795ef5d07c48760c8248610e706772066894687763e9875e5992fc4430a0f272bab107ebae0f03386552264ff698a3d3fb391e27ee4757ad6121020466fda2186a84c4470ab93bc455f366060009a9e7362b092a539a6b28bc08100fb0dfe236c154239beee6171eba545f8aeb0a5d7cfc8b193c125be504b4f31db44300c71f945522a238a403f081c7d845dc85b2567641a46c3220b8c336880104dd83abad87343520e87571d7366a21d4e8835bbabe52174a89d207ef623980adb972a2ea029b48aa90b8e6520be13af9d7165c64b54df05453df10c55ac42496da6721416c2a189e2a4a3fb313fd7b963bf1dd043f448f2afdbbbb5f9457739e16c4c3844f4913a84e90ec2acff6076d6b6d5da7ad6f6a31302b8698fb4db8f53cc905f59e809dc73d6efe4d9db56c6910eabfe71da3cfad98023bcff758d7aaf6a3c6c65c4e41e7eeb18078e7e5462110b22963b2a2c03327a90209261f2b86558c6d23be99f89f3e6f72c9936120ef4f7a49c27ff0e86c0c37def549121b6ac672cc7d899a34cdb69f9a4a6c9ee613366296840bcae0748c4e538aba5be172d196211871d44d9818c769228b2fc9004819e8a2a9becca5885415dd21eac757cf9bbf8e14ac06585287163273c6f655a1d1b22d444ccb4ab02d385006ba7a01bf42872b6ddf67f14bd615c80b4b184e79f00783f07e093d18ff64cff38fb5a5b1cef995d03ecc4541ecfc2cce1c8c04921e1b132bdc09146292f841ab20e806c11c8f416f0683f33db3c9ab1b5b321d6087cb1d1ea04cca2aecc57bd39ec93eb2e9dd052d1d28896240af35f782b15593b3d120ed9d4fa97de476822ca0a36db82035a355770b2912afc2284bcc3283d84f1796332eae95fcdcecc6fcab732310246f059a42455cea98eb0b605e2f01537c0164066546d220ecf9dbba608e0c7b3d2c93e8852aea320d318743fc014a20eb37532502b157a15919d445c28504a739a968c721e23e59f0c21d63535e25e46cc49275a1a45729b1e37ba5c22524fb8e318e0fd2d079b92214db5df303cb67e223edc0436843576836b92c92d5586a4178f8d7da5eb00cbc2c4379ff3876090c8466dc283fea02c44e95e95b831348c644b3df810c281aa5119242a7abb29050ee6f9b00907aec6901e9d3c25038a73ca0b001bb9f403ca3140a5ba5be3b36a35b90d8b87081cdd0d120d6a732593429a781d1fd8f6f333484285c62ef36694243df992535143c31e8404e676f6adc984e0ffeaa15cc9260146119a653e75d09180367dc3ea7cb92b909a5342a3c223864662b64e765463f704a9af443ee5545051344f62d7d26acb0f76e1ab96ace76bc4969974a978c3e3c3abb650d7f9f0780dec9525ad4e03c74f179203471eb367d7e0c78e90b1f51d0255bc6dc8214ec0e08aaf354d84da3eed74d26c4b9c4d9b6e2daaf53ccd8202412fd4b520dc567fe10ec3c01b39cd568cacedfdfd0e2e6fa17015a0030f54458cea51ff4018ded972fb1150812582e1c8b86e7c27143ff22147989d1a7bb1168618ab095ede8754d8fb883cbe9d127dcee05efac9b890bc419d15a41a3964773ed8f579f03528f41be762c704150dcc73e352865bd95337e42fff172573ab73ab143a07fd59c44796b930d99b32a2caec52d3b209f3f5c161896bd8a3a69a3507ed21a585b5e0aa03578b3554cf122df641231a67a6cf350732000581c9e7594aa86a40849033e4686f41725c8044f16a844dde41ab12735c2fbe0854d41846c66c2ce23c747c64d9bbbbbd21a7149ab55f57300d5bc846eb27e1e89b7bb987b1b8bf13cafdbde4d27e39051c7060ea028e596e66f4fa1dfd1b6fedcab23776637cca6399a6608924cd66f47828376bb0e88a8e4051971f600fe5d166530a9b9304d67a3d42126b3e287dbef5b3a403bf8510792d69e1ffe4e5ab983a93d2521413901fb0b30d2151c6f840a821c6edf9f2144d3ca165b36d0fd1c949e01e5e86f734f6b789aa277141744a94fba601770ff624e88bfa6209f765cfa6f0e6830f6458236c64374e3a53789c9359b061747bc321690726e4b8b270adf49d6763d07ae7b5f1fdf6c8a79aaf99bbfb530e5346fd3fe453b606fabdc888c173098140ebdc1ec26e1586543453c5fa2480ecca80a60aba4671d44ca2c5d91e737359ed43b58b3e48ad4681f8f459a92637cc4270161bb13679659f180064f58aaa3f1052f228fbcd6337e22ab2f37344497234e7b12cdf40f0a73c6068d1694218c5d88bf0274e53eb743abd112070974a50aa837e04645dc239333e382e6c1da7204c70214f3edb5e8e7943114384c8102904dbcaecfc3a378c96e7ead5510249ddbf6fb1a9a8c9ec5e428e137b6c03ce2a607d58720eba1b412f6a1a97b1fa04c13636efa63552bade6b186369c0bcae2399aaf64134c1675470a3efdfc535384ce4b01b11923e3a31e3f1fbd163572196ae40fd9f9c2c685f072c5f82b8c441aecfbba36aaae9f63a98d80dba83bc7be5d8929339e0e2f1dda0a3ce8cd4abc83e7684f882a163dad62e8634977358ce7084931717b21adb1f43cc9139855cff5488a23094aeb76a784549bb768bc6ede602f56e405d0cda531fdaea06855384ade398dc6e4dd5bcf4c1b4338616548d4e86bce1e962492e68aad9399dae6693043156a68d925d173529983f0222a0237634465ad148bf1429f67d3cc8d16adda7960e58e70579b8c57888f1a5064752c96f870b6283e673a6276d9737f3fb3cd5b2ad5935705daaf0588edda7a636e8777d5a965e04c83e2e84c5f4dd637d6af3f136634d4265c253a8b85b67c90c3c03f70c1fa26e543a6d360410ac119ae8bba20be5975e79bf2d729f71c4ba96a92d25eebe895494febe00a9b7017b01347b7d9d8951fdfed890de3362c3ea6f7c32f659cca299a929903ed4925955297658c0d2e4ff456b255ab608291365d52c31b3507ef1c41338450698df70c68d0e6e1212c291088faa61bc491e232107715117ba45202af8567da607b799e13dc08547ed4dd865e7a1269cf880ad3032d7d7a5d7fe004f1322ba683ccc933b829aed15f8de473632516d382c29f5e4b29f2abcb2fa5480a4d30c39470931ff0df0fbd3a5bae0107141adfedd4b25603c62e33f5caefd04183f5758fc0a38cdc4cd2916010b6aec1ccc8b2be86d5e98ab978e4457d84367d73e8e5eb8ebfc0c5b2dc69bbed1ea17c6b5f40c1474280dd7e878c5f7f3c982d5292e22945bf57eea00577f8a2ed817043d8bd39a77e6eb7405f1976dce2be96b3b8ab99f8c05e87a9f977b42218f7e1291211ff9055b267ab812f5aa6b9ce738282e90608b121b874605a733f364750dc12e3f21bba78007e8152d094e96b149909ff2520e65d7edea30ee4683e3eff3b32d14b3fa93013053bd198e93d820a0d52271617c74202272e13e314103fe46235513c905000a22cf7e46524cb64f69472ea1b8e790a4d6a94c2cb04e6080340b1a255f478d44b4855d41899751aa6eb7f7e4288df6eb6c7ad66215118463ae54be37c1fed71f44457b7ada3a42b2fda48d713d1558efb12fa7f447b56db4e919737f25bd48f04bc69e984d2d678158ce4cec69e579720f2598355d89663a72369111daffd41e0e058249264f36296d0c1b882272dadacc627295b3859b19bef0b431ddfc620cc077d87530b6a7fe80c65eacf7887e015ad1a08c62a111458921ce1f9bdf54b470c5396cd5344c73319e9c06f8ba0183461e9b86f9a3c1a9a221205400a5d5b19e372b12f8e0a4e1ba154ff42af19500f9658c310b97f90c2c2688a72a9d58447131a373a690b452d5272175aa9be24c7e29c9f5202e11317d49f7e33c5c4bf9173fade3e8e4ada8e4ef0ff709df5ef6af6bd994d4455f3bfcbc86bbf3f6c292bd27ec277c75d8b7bec52955ad9eedd0c74a6e9dc8ee76b2c0448a2504dbd36ddf7a1d997056d81eced568916c9de36ddaf872dc175b737445168fead9fe3f0ce43f58a403dd0730a658a765a26f15cc0f754b2df64f05a010b8712f768905015bf651830404e8da98bffb20b4f248502a9084a2164dda1abc92889b00990b953350afcc07c0a5c16f0bb4bd22c184ce436f889722be037f2cd6f7a1f31c24ec21fd9a42b34a2651f8b3d43cb100ee7faa2f827e2f624d85d8259e38f4b2ff72768d118d7de231815a34902aca60756372c07ea89c9a4589f90f34a017f81903b5983d9dd09e757e39dd8aa035c0e2ed566897672f858e4c04e57b89d2533e7608ae61ac89c635c18289713630eaf1e099a9c014a8ab909aa3370c951d490347957f07574d8cdaa6bafe41a85d1e1c87f4c3e96732d1c21a1508a1f88806c2e028c040bd3aabac4a100966f93e301a4f7a6d66309340e01ebe92bd5445ca12b70e66e7f93b0113608f8539c1f2b0143a4f743b762927c33490ea75fb9c9360d1f56884d85b910590e8b2a2685e490d52bc32a37aa6c905744c7904c3d86444404521bd1f73a704d02425d1a7f010aaf36a894e484394a90b509298fe85c847c34854265f37c9c7e457179cc550fc16735c2a833edd80d5107f162739a48416bee10273678a657cfd781971d764478a68ec5c54c3bf93d5d3ae29f69d10db044eca97b94ff17467f3ed20f2eb678792b23a7e49b1d701e18ad5321d70b0cdfa06bb839830dd9d0d86b372dbb4dac0bab4304bc4b865b17ed060b0a624355fa2fd3eb3cabd0b8e4a830fc02bfd2bbe4dd9dc8431fa398280c9c5a0d615b14ab846ab560b35ab3e221468340c447844510df47007931e7c3f53d0d2e274110793c64f4952f8c9b08d44bdb53b5a8aef86a899381b2496fd4657aca65cb88fe5d84656578c02fd8c3c01ef850a625a13bf8e570cc1af029b99771df6497c79cc0795d0cd411c081e68f7d16b06e2288ca417d55f9eda3a7e33233684e6fbff0af89582a7d4b3beabbbe9a26030a4a02954690bce3ce9395468822f13701b4b43141e079106dd19f9e89d77358d671c0e9f5a00f61830630d29749d672cf6e1cc072dae82b793a161e58ea3db1502bcca269a672f8357415915b620b85bf614eadf6a1c6ef9b273d0f090455e26f739b1693ff126fc342a78306d8732e974ccfd7be523fa4991b8700184b4eda952f58e25a61285c1dfffd23d591e00957abed956fa4c5953fcc5402c828cbeeb04396a782c7367851e4ecf8aabc9642b6d87de300135cd55b06c49dccd961c23a20825f27c9d0e23e3ac7d489e9f09cc0d3e94c8d8925219db6696520b27b6708f7aa7a66c95ff312ac18674bed3a900282e3cf984d8be193b0acc81a8ba5bf40278466984b71261a0ddc971d575fd936697bc9652d492c355964b6495e6fad063018178092c6993dc6d9d961e57a0f980aa3bad0d87db877fd62748812a159331ea7b25faff50a1429e82722129ae2ef920754914e8204523f2fe8712477f5695adc82443f785c1af0cdd7d831452db8dc9eef210ec63bf13e4ccb9b20abbfde956e22c654724b7e3932a4253693b2c0810edb689f880c005e01c4cb9244bb5bf713684015c45f22584f9b9eb463f576c84394c382d3d843861976c4d8341ee3f237a55f84fe66e052fd80a58612f0161037569d569868debc0dd7b5e5741ff62acdd6085df447f1765922408be75b3b10977ef20d44802c433611828c5bc7139d3cf445a958d70d9984798dee377e5c730bf9183ea8efdc7a88bf89902e8c75289233f5acd88b67d4e19bc02c0ab9aeb16f3287d780f934f06c34644b5c36aca9fd54ad1ff1240f0cfc6779b64229be90c519e0523f9f00225b9ab8ad113e8314581d165f49eefb8e311196a79013e5745e8442903c173b31fb43c30db69f4fd2206dc979bc4b99698d49ed382902399eb51ae52340db8eef2a47b0802764387709a0722ad436db0b82377fa9ee442132b713a28158c2f1a802a54f1ce3036a95d39ca3f5a481b65b2b77d5f5e7d486138afdfbd8aa707d9f4148eb19fcb9270923bda206df160bdc6d7309a595ec20c41dfcb1df5e859888c9b063e09268b449b63d74e0002da0979fa8b0d8c1c151d81c6b80ce7a47f4786cbee7e43879faeaece3f9ebb5ae227cd0dd7de793280d9c1400a0bc67ec1414c89bd048df0772b548e21c6bb6c48a8d22bbc13bbcbe598ca3a89ee8ef691c888eae2ba3e1daf763e73b608cd9970df2652237b608e9b88fdea59ce80f0b98f51bb4c3825fb2fcedb7ba5097f0613f4b0dbc88a4ef404ebe93bbbbbe7845b9fc36a7da2d8f9db13ad4587d313fa5aadd011257dd8afe21283bba91ba3a55e9ce506e52bb36a7ae7db894b5a636b8096abcab391b041b1dbeb10413688723726993d0271bee16626cddac53b0eb2e63fb2a5ca0d52aa8e1641c178c82e9e6a8de0b5359581a1984445bce500a042913bc84493198e6882d024d0b2b3aeb8c6cd21ec881716083767235a562947f247cc7df641b90e086bbcf8365ef2f7c2fa944faffdeb356c65cae2af9983927b9cad2b365e8fd1ae35f140d07b7a8116d7f5184afab5af9d0a92b35b094a560cf709df3efbadeb79ca545bcf1dbe3e887ac8e49ae0f2c5bdd22dbaec18e6a3d3b86e4689c0d9185f630fcbe4c4459eca769e282107f9eb8416b4ba2245c29ef6d8d8ef8609bfd433cb1fc8acd155fa20e51a314ba60af3ebcaa438c76ab1663ccb56f88a7351becb3cf3a655cee946651130bc97c4c1f6c7ca047b05c767d6baece44ede02bb878760aecfb96f92346fc3c07e77261ccb06723e367219f64826087ced50274bf88750d0b8d289d8f722ecc100ab49c340f0e3d4bfcc267ed43a6f308de97fc3244dbd716d06a1441fdc59c70b29888745b6fec3ba3368f6d41dd0702330c0952b116f34039b999aa5c61a580765db596603160e95783e564fa0e356b0daca46b6bb9855bb11f60cec6f793da292c1a2bf67bea01a2f505817f74de797d361fd8a6e08bc5bbcd3cd7e3dc3d0a293f9030dec41bedf9f7740eada331c51e56bc40422d91d45b55760583bbc6f6935ada15ba1e19999276678a3e8cb2e47562ed66fc3cd2af817cf96fe32229027e3582bdc3e76bac19ca5b21821278383a5cc5a1c0ca5b8a0c378b0c5b1f3bab15b8bdacbde6027c061c5fa1b6c55b738f4e37e7dcfcf875069ae028e541e4055a3ca17122e31adf74567899154f8986c9a1b91af310ed63c0c5f7f51259751bed25c4527c6c178ee582152a9211889dbc4158878ea4b489e878299efab641dac29b7a8012d58a3b44bdc37d85052f1cb868d0c99e3ca72178e9e4638ab1e070a25c5f8b92ae71f7db59081dfa74d11360bceb74b3ec9c25f8031b933d3362beca2499a70e9d23dbd84478a649a4fb2f9aec26ea9f1f8f9807252c325f92485027ff2a4d466d7c72dac691d077756a84f58a193abc82e726151235c47026a9939555f4050b29a0e922e5ebcc8a5379895d24678a35c092d1e037b833b25bdfa43d62f6295a15c38e6745acf048ded25dec2b1907e24652d1c87531300fe06ccc85c7a5525c73da4454918fac9d00bcf9eca24473d3c57cffebdf796724b295392320f0583056905e14a351ba2b65dab98784dd6332115cd6b48b245f690246bce38d791acedda8381f1f2020363572c09739b333be350c6ce0ae6f6228a2e2e76059320377efb85d15e81b5eddaabf9ee5853df1deb0c0eafab8123631c5c005e441c934ed0e5454bc8f29d569e448add1562b80382781e8820f43d654576643e5df854f139f2b1d1c0d2c6643e3ed7a7c78787931559c2b22255c88ad83a9aac48119eac48f915f9016540a6982b2b7f03a67a55e39e40e907b410624ab67bf792bdf0c4766d82027eb6bb0c88d0763d018ba7ec8523dbb5e6a93fc28a2bc9623490c57a70990e4e3c8c3d653a5851bb3d653bcc608bf8c876606daabf1b53c1a6493c506b888228ee55c803c61908432c820d60bc016f9237f020c652b58771184e72f5d33e097aa3f0240e755059188aa693fe00558326041c370798edaaab7e1ba26b2a54e623c9a6c526b459b1016d3e1bcfa6d373da7036d7c6eaf9e1885fe6f36e10a0803be69cf032949c553ff981fb750563a676dff3039639434e06d498edcd39a9aeda298e5320de246fe076eab8e39c321b983a6c02300cde246f50b57f024212b3be8f922bbc43e7f4cab5fdb657d15129fc764dffffdf99b0555b6aefb529f87efa4425ef25b125577888ea91078d19324e31313a30c1c078115d5eb4842c2be0e7751973d7d67790ce199f3e7d3e39a74c08e80aeefea4ead557c9cf516f6bad3fe4b9fe10acb03d96152a55c1aeacb5d6e29b47ddf1d4f5fad597c48e72ff801de9ea4ba16efa525a7c94a6af565b6bb5d65a2761c59f35151189b42ec6e0e7e950af509bc37137c654428c458d0ac9158a86663569384072855f785a019f12c9396538ed6232bd20491b663dbd86b37ae3cb72772557dc6281ad294a0ef7f5ebe008a84d57e0386b2f677a252e49952664f93ed1b23ad87f6fad5d6b93b0fec3bc421c2210db54872bfbda0f7b8dfb922bb539f35477b0fdfa0b45eaad12a86c8a8fd6ae2cb12a84b5d55a6badb521c6d55a6badadb76a6d5e8c12845584d53e61432b386ba98ad3565faaeab4b53acf1c5e8f8f68dae87c772aecaaa70dee6ace77a73de6dedb815d752663380ea7ee6aaf113fb840c1128324b50edd0a94fac1c357f235e50180283ea684af4f0416d605277769a5f31d5727eceb7d60cee047e212aabe7ef3dd5871ce186315ecbe240a960c9f8bd0850a85b3da245e4c29bdda6a809a4ef545f174aaa61391289e6ec560099cbe565f8b49a81c360561d174b2d604af6a4bb72893585d5b0d70f7ab9933b1e8bdb5d63953ad07aaaef4da2a1629f2428f69726d356075ad5ac37421565bebb773b0f60b31b6b5566bad2d42c45f684517f80934e87ed8849ba835f4ba8c4fd0157fd7da5d93d07be94f8ec39723e7ea84cde9cce94b69e5aeeb4baa60b77d241bda3a73701a4a09cee9c9d5cba5f0fbce7bbf85969d27a6bab3646ac1c2143e4520405b4062bb9d265ef4366f4e77e6cd0aba13f38079cb34f814316f9465a558cbc100c27643a50a6858a2e88c7e82f8b00bac9dc27f21c6a1b8abfec2218c435114ed16e7cceb1833117fa148001b848ac42ad7d362e8d5e7db7407476ca5a936b4b450832ae8027677777728dcddddddf70773e63589825a9aecb59c45d55a14d68ac2218c21930096d06109d3dec25a4b566badb5b5d67a646bb528db02f77da1b6e3fd1bdbca8cdbea0e6ab0b63af41a505bab4d33478bb6e4aa870136a743f149c8bde905b962f5cd9b4c6158801176d574a58534751092ab0ab08ce244d9692db06b28f6f8c62ffc52e8c68a39b0eff5d4178adc0e385b12cf194a82357c50e3a81a34f872389bc0d9918e151c01468ad1c089637bea87cd931ef594e183880db3e677844c944ffd33cc9a672db5a676a477cd1c3bffe3599fa2a1a7fe5666d153bbd14af350f58cd173c649c65471da4b62cbc14e619a368c92a360921ce59a665c6b156901f8c156ec291b7264d79a1b438aea98321984b66b9510f5baaecb53895a4ead4e256a1e0776e0081ecbe7d2246c6969d1b3bcdd18ddd8706c379c1a0e0d6786138453e2bc707c940ce134f1706c8073e40b7740d9e1c48eda8ea139e39aba6cf0a09a4551f568511b8e77b8de41dbe113922b1f1afac8951311259138b01b3db6478bd2b0754b8bcbcb0bc8035f1817910863803cae3edd30b9a1cd9831ded45c04f286f6326e35377b196cb4572a235bed658c5ec656a309cd60477cec0c35f9094282a77424cc6d077ec998d35e4744848424eac8d82177ee1debf66680361ee0103842dd98c6e7d224a4a966734657554d25a42a62a24cb5bd5229ddbe51c7e8851c056193ad6a970d1ec21598399d1f224bae1c0909bf308231e2eaf6f4e8c137da943640363f36319b964d8fa35c733641db6d8438b21def956aa6424255836943355309cd998eb4713dc036671c0fd58090948e727d83980829dd31e78a93d1cbf82d69ce6471a3275ccd236a3b4778e001c8a3e3380000c0a589bb8c51c7f6324d405d9b334e9b05952f1f98a36c7064f5af9f957187cd513b6a9d8e6de6c836445433d54c35f324d5cc97541e69e3c234907643bb61726fee3067316dbbb6375f0d43147ef09df0bbf0cca44eccc8e9677836676eea44aa843cc6fe0c002b638ecd514473e6943365ced8706d82eb6d38c7c8513484ab87850f2b375088024166a23e017ce03877cc48e7cc005442543543ba9ae3ec68e454496c6486aea3d69f4a88876af643c863078c9270356bb61aae8633f29aeb35587398661c7958c0d4319ae0fad40dad47eb657a14e9f172548f1d26ca7bc07c07c6aa99904b87361a91a1678c3953a68ccb9041e650317fc8d02ba08da163740e153953e448317398b4eb1ca41c2a3951e41ccd1c2eda758e51ce949ca21c293347cccc1125078a9c27660e5bd2ac61b15de7dc9418ddd03e35c28e8c45a36215dbb58b15dbf58b2adbf54bd2760de38aedda84c5760d93c576dd8192d711478a11678a39e33ac688438592db769ca339e3da8e3851e0509933aec1110769ce7430ce3963d21a466b182fa4a842b85bf48b5105d36e218d6812e7369570b17d2ac9c1768da3c514c1392d63e461c688a3474ec7ca68648606b9d1080ba56306c99138463d5a9f7a1b526bcfe68c97403fad9e1e2fafd12962a28a08ed10d403e6353a42eca87d4a87c891d02746c323756253d6b259201781ead3546274e3145353aaca0bb88e6647e511d051ec0876f43a12ba80ebc875043b8a1d011d9547b323a1193762375c40e3c6cf0da01b486ec46aca1bb16d47235acb1855b397716d55b457cd6eb6bd52dd8c54b69ddf955c4d2747db758ce68cebc4ecca9863e4283dde30b9119784ab39046dbbde51db31b4c366e3b299d910f114ce1197713d3444448484a49ac518a266c281f584ab1ab01bb039438157678b6844b3a5320908294654041b2a62926750e055f42a8a1501159545b3225a1193ed3acf88b120b840b0c1da19a76c75d6398340c4510ec2cb513e20b8f0ad0103c1b5ed684486fe461ddb9c714d63d4a9e930d1a1e9fc38ca7537ea008d95e374a77fc76b748e26cac76a3a417a219fd67962a25c07c92ab4df2ab76dbb72a498365c83630ed298c38d352ab66b19a6cba93acd69d73a3f9e9200ec658c74625e93b51322dad08cc9f61945289c4e82b6132433ca10d2769d63cb21724f02b04fd9f844811d01fa2991ccb6db04d16c846a417ba562126548351b55422ee3da94491b970ac215de2b9235db41ea8a57c33e8d3b3ab0e48e9aa35cdf40129e07f2c0dafb3eef9b954000d5ae1b3313de98a100794da601316bb2124cd072d24e4eca4959e4a48fa8c8567eaaab614219b23f1a0e18efec1bbcf6a90e668270d5bd5e2f4324d3bca67bb9e010d2efd319ca4c7dda756662a6f487324161ca1ac459c171aae63e124f28ecbbafe4b182208ee5887cf9415e33f39aaaab8ef1567f2009afedfbe542780ea4e98e2475afb1f371142c09f77938994e6b71401e9ad06c56e6ee53fa6e4e6a8ec220903c82436a5e03ee389935a00f10489e92a3cc14e803c6409f4c05f4b102f4e9c01e9004db35d872115c7fb74f81b22933044cb24124b6eb1ba8397285c355b681ac4f65231b662370e753d9f63217eb0077b83a77a7c12120908ea89299661bb7bb8c892e114f5ddacbb88bdb11520aba2131fab11da9f970ac19c7fa54b671360338ca350edaa7be1f9771fd2109b27d42461f93db37a4f411713bd9c6b16288c8b639936ddb6d20adbbc2f3fce5a8a9931c35f5d3a7ff9486409dc6a97fb55ce5b877ca5191ce170ae3f3f16160ea8bafe5858b28bec0f86060c0006990a3bc749437198192d7e0f8e183e64047a75fc03a3cbd0a738d968dc8b38c63e76ecc54cc1baef3cc6bb2cd5146cc9a1c65a23c4fe98c6cef5ea9ee476b7bf7a3db61bbfeee47f7c3cb49198bed3adf5c04d799f6a92e0653860a238cbb2499b61d6bdcbd8cb2ed533e655e60c0da6c24dccfd3998a99a7d018d152562e49e9f64616d6d18d5eebb5f6f678eace5ea69c395a5ef3da6f488c7e6c476a3e9746e42a7daa7b5da5ddbd669ffabe25da8f1a8f0dec31da0e12b975afabb45dfb93dfada3ded3e92b137c7547fca0c47f68396bd7defb83120e843d65310c09320489984486269eb0cd600405066435f8b4b6d8196ac11d12a57c191f82b020803d653140d92b7bca58557ee070dc8460801a7bca6408b2c33d65ac283f6031145d2a7dd7b6524a2b9d73acd5ce39735770bffbbc1250782141fc8cbf6a47dff5dedb81253c0957db5b4190844aa270573ecb23485fbb0292a0370a57bfb6a3dd2cd3ae70faabb63bf47b0350137b1506c1b2411647943584764f19ab0825b21aa6f09b49b05e9081084ddab4a78c5502960cdbc6c01e31644a118f6dcdc0e713299587214b4821a20ee5e03a1c2a722186cc24a438091ef68111443c79810d8aa4982207d7610f449852097f4f194b48085264ac20f80026dc206045b37d0814198bb5bd64b520c5a6008a2adf4552ede289fa03b5c2b26086cf010f132e9c151ce7ee516cd7a7a193298f21d0e89309e7c0842392b9e0dae39eb21c7ad8df9eb21c9cc0a006e13a64a2caef00916471701d5218aef02ea0a8628110b90d0da07121742b0110187a94b03daec30925e98db0aa5899ebb0a84ee13af449fa249454a940ae437a03ebc312aec3266a0d684812359e3a9cda3427e0cda04935a64143ecfc920c92501a9b9a62b007a70fa47029643c4eec95a9090a643c48ec95c944c40b424f06340b9e1db6c9c4730250f41e1aaae079a126048b178440d14248124d644292ec95e97f64427a3071211302db2bd31099901b4c26934c48eba44d26dd850c062a7b654ac29d08f1121942714f190c3e502930ac0006227507185e782141aad8af148468af4c9b9a64418e3069942cc811599024dbdb5316a4c95ed17848789368051fb6688194a529a50f46e8a01a274133c41f01a48b2dba5006440bd7a113b1ef9e322055ea1535eb62245ce9d14505e1d41fa0e8e43141125868fb8e30620680b19d9d1d166a38b129ed6a10c4169b6eaa0f40036b10c46c53ad001d545f2b5e19369d5ab423c460a2fd39eadb78048ae7ccd4930687465523f7585e5894c70bebfdeb7fad2f2ccb0a57efda4ff5f5d96c5325250aa3300bf27861dd2570fe8549b8c2383fa97fb597cb7965ea1ac49b1ecb9cf6ebd71b314088a085166c58b2e47fce3967bd5c14fffff572dc5d827d3a71c17297e396d8bedab7f68696afb5d6faeff706d5f26b192b6365ac8c95b132d62adfd6fab67b64da82dc9f1bbb31a09fbc633fcb71b9fc9858dacc7e5f3973f4e43297b9cc652e33cbabd62f63ad92c6c4577eb5d7e7deea5b2eac2506431f9a275738625ffedc162b6f0cf672dc92afff49eaa54b624b9c8282824e414141b715b65ab3c542794ff906d559f8d5cbf594655996e525738be3ee0f502c75cb12568a41b9bc28f89f73ce592f7793e0efe999b204872553065f83bdf72e21018773ee283509e946d0238a40a4419c416c894344195cc424620c3060280d12794421220c6290906a9175922163c6bd948a4066504aefa5540442e369ccc8406633a514546b2bae29317b32a3d2f2e4a87c72a4f4c45a6bed5b6addb9275c17d6dacbd9e76e59bfde5aedb65feb13226625a5b314e41387a45adb459dfd987c2811512ae5307bcd9444176a9d893f2835f9107d882d882c883b39e8828ba5120794d2600b2d94b2c0a2564aafa895d22b28a5b5527ac5bf3b5ea256536801d33fd6c1ab31a14f5b7294fb3fd0a7ecfd18ec550734aa8382d808ccedd08642aa57dc8ed7586cde24978ef25c6efbb5ac86c15e9417e8a3b940c9ac0c94793cc5e243bb40b40b44bb40b40b44bb40b467797db4b7dd5af0ab155a9f760a1a7d57adb5d6ffd713a9d6a89591cc0c746140db7350500eda0ec34a506858b0943eafd70be673cbb1dab357cfd3fad61744bfb2fc62df0f4fb1f47c658e7d658e7d658e7d658e7de557b2b4bed2b9d8ebdbc92c25fed1d3246c39cae7fcffff7a5db7c7518e6db767cf797fd8259bb4a7b6487e5dd68866fe0ec6a129d378b7fa6f6fe5e87fad5fb3e702e5b55d1ba16177c4d32b6ce6f825180c0683d16a6918be0ef9c4d1503c99e60fb1edef3dcf5e7d27ebfaf1d8d5f9c78dbdebc6dee537f62ebfb177ddd8bb621c9977aecf85dd97ebc66eec633796634bee6bce39e79cb6e6384d5ff2246f6a27ba31c2b776697b87f42f1c96a7e5287fd6bffed5e3f765c4a394ce49e99cf4b45f73f86ba03e844a633f497302d4bb8031b6b103164511460b31bf4e317b5609e9a7acbd712b427a39181c7e39c15009b14b152e37172a5ca608a9769162e5734172a112521d45cbe985f740f6ca4463fbce5efdeb163383172e47e2e94549e8621452ed3205e673290aa99e2e525c88421ae331a7d3e9b43deaaf4f59f25f1e6c7fbd5e2e515ea79a5fb8891cb6d6f15973666a6fd25a6badd35a6db5b5d67aad15d7279d6653f01c57e2a041695398f1ebf57afd7d8539137194bb3a17cef78567b727b6044baab970ed531906eb6059c05e9ff296623d40444a9fd9119a87494f8906303a7d85d3afbd6e3ee6b4e5328863bfae1bef500d96619f7ad7bb326cbb9eefc222ac1f77631d0bfeffff1febb7fa2dc6985afd42b2371b74396b3fe7d722f7f0d15cff03b5a4e964cd1c5cc5b1dfdd6fcb517e6968aee771549370721c37e4a9db7a19d7b5e401fa11b34b309bf4b2482e4b3463d5ec72d5ec6a7dca43f2925cded2eb078c27d60344a4b49ed110d945a7aff89c01419d3f7acdade1de99a33cbb66db75767dea592c96a39442ea34aff95e2bf0eefffffffffffffbffffffffffffffffffffffd7ffffffffffb7ffff5f6ba59386c608611f3667a6feea4adecd70ae1c87ff6ff9ffc3f0ffdafeffdebf37e79c6974144d33e6a2ac70eb6d06757a25e0b8b736969aa8542cda0d62ca6624000000c3160000200c08060362a130cfb238d1e30314000f5f8e42665234198aa3911c88410c444114c4106308218610629041062944781200a66b106998a0cfb0760d36a965da1d79ded4c0cf1d695314f9eadbab9b2220492bcb0827111d7182e37e5de3b6223578e14854886b79cf2837c43c9cbd9bf5900a92cc98f1fcf24afcd7e505169c0545cab9317ad917106f9af5c39dada00a903290315f738b46736d7ef65678ac262c50a920b60c4690ce98084d34234e0026e20268c48e7ed97478226534cba823044513ef9e469c9f280a1aedb916e0cb15c54708375adc94cbd26e859aef58353c0c19406bf4c31cc2a4aea64638a44249b510bb3726f794d90a2079f840ce47c65a74bf838b6a44f82dd64f11a030c336325902de43c01bea6b264d2c6064bc0770976bc46a0014bea237c527c37f33498a015762010edd342e4f9e3bd528c6292bda1201952d1aa9447dfee94012d5a835222e4aee6133dbe82d9ef0ae453e83e8e149bd9c093084a3b02119a6840de353d6af5c8e91dc8bafd4924609fe15911f2e1689878c96fc0a390f5efc4dac66edc2877b879ed05418a0c67868f9f090d7649c236a0898b1dfa37fcc43ed7162c8bca32b4c5ec07575c1d448bd12520f72b216a3511a3bdb7986a317e5a9db1427a417c23e68092f24357d3e07c94b9334b399ad2f230cfaad2e96213db3e1d0d5252f79c0183d9182f5e167b42a43b630f5e5b56bc9a103a6e92dd560194344c44f83d3859941c4d113c6e5960367a8b6f7496ee5f20fdf5fbd2146a26da95cae37a397069b23a61995b90adc3a69a85aa47cbb5d5b964029285c824e3da25196b533135ca4b0cda4f14209d90c76594c49bae8924d5542b2b587c4f92cf5a0f57556398deda45d6301dd1469e47f5fd8e968c039236e05aa4193b9009b000a924b088971e6feeae07c84686ce9986df79ac9428e66d4e01ef2fa2579106d52456860673cee31d7a69102bab530012101d58341cbb4da0195482d7b71481f26c5eb5304274f726dc9ec14a4c9d7cd6c2cc8ed5a1c7655ccc3cd6fa866b3d795824037a12f08516e11ea7bb3e4590019fdd48db052f97b68b364d7b29c6067fb93f5d4ce8e07619b25612c0ce14550e7676622e902c4d57e798bc16bcc27e3f564d2e581d7897cd01480432037958318016080e1293d8b3573896b9d1b023557a08d08dbb3e11be4c29c8cd1eb7cf78acbc453ec6f208b44b831f36748779bf659c04cd102e2b1a47039496c3cf96bc908c991f0c96b5c2913b6e5336f15832abefa3b89dff178aee487c904b7ea0baed5219968e2a299c7706bb0af6f71b391bcb89f600eb931c70ea07539b87277ad9adde299ec232c6f480daf82c78236a6fd9b2d9ad9e250c2406b2bc42a29690c4d9748e039dc26d4af165439920d870bc4f684c256f935830ae88d98af1ed8cc7272560a171b9636acaed372c26bcdfa1be9198e08bd777d6dd4a8e04970faafb3e073ff49fc8dc6abb65f1aa451b7e05b43b73b887cc2f88762c59fb52b4d63bb4fb42638fd9b923bf414d4aae3d043a769124ad2aabd7c968b340e7baadb1e1bca1128f9ad8f45290e9d560c020be3180fb4e432e4b346c88c7ecdbabc07945eaca725c15c8b28154eb50666d2580265b3840fd5f2204078ddb6a05e76e2a4c8fc232e185b3e7bf608e826e4bdf8d70a7b9ad65b4a30a6ddd64a6a98fc99aa767e6c41cc3cb5921e9887740bbb5b6700853aad4c1ba4d5200e5decafb59a1c0c4368ac46de3f81645a8b48d2b16fea6bc98473b50caaefce3d911ae8df2596e213d8e50677db3274afbbe53d5a9a52c9a115a2dc322fec864350ab140fb455d49fef96d7c651c66b4b834634ba699c364a2b0e560e0f5596527248bc6cfbad12d3470258158896927b0088d5a6e2a7b487bcc38062a85a764c1080aa4521a68fdcd6e132471ddf2a5df7187d09c481ab222f3a3d73f0a557ace79b842305dac0207bf0dc976b82ad0bf85c47c3fa361ec41c634081826cbabb013cb423800315eb353f4cb393023e1c4280c12f0c8cf29b805a63c29510d4f66765f9e124de41caf2d92d753dbcfe81c60bc415f754bcbb8b98b0275b67b36f0736147a3dcc221d05a17d0e73025fcf0c6fc09aa436d109e8f33ac605ae4266655668135573f341bf9c08a4dc6abac76513d44e82b17dc01c29d33a8f345a6fa27ed5a9b99a00e0c624febcc7c1a89e51f91fa23293528cd762b87db1a74521c29c01510f057c09c53d04f0ae39a283373a243a4578e2cafe7ec5bcafda8ee2152b3b4c0dad88399edc3d9260ead46336e7a91b7e9dda19dde1eb610eb76af07985164db65ac64c93579ae8f0306bc8bd426f92896967c7e49a12b93ec6bd6f0504583bef23fd8ad70129c77161bc49e5a04e13c5c1c067eed3249e89e3513a66e082cd1c1f57e65f22aca68d47afc0a5a5f65d24a8f76c238bd720be69e952eb73772f3b37a52c71df7133720a463985c151a0225c97d8d685e637110f4ad40be92e656a7f3267d84949700b04a3a8c8381cd5c8b684fb24da2224c0f837fd654fa6c18cb15b9a95d065c992d885b508e0e3d328578026f7ea0a0896cafd7cbacd365150190a3205d88201d0e6a2424ea47c53c5f53d69309e0a9f9b22f50d0c34ddc2aa323fccefc8d4a6dfdba8a7cc403125200993c16ee82da893de7c9b5ae36d236dd7f0d56d03ae1c4f2bdc0976006397c98eab21db6f7b89110e010fd1a70fcddfd9c6cc05dbca368fbe601236bdb4307380a3918894d787804178b52b9e3c7ff7e0a0139610c85291d31975cae90992589e322cd3f85e3a7dc1bb43ad6d14e8ef7bad5c9b65668fbeb4d7c8ccab1d093bd3e4684508e2cc6405ba3ebc10665e758cad42a55f9df3107708b3d4ca691528438ee7f351baf91c9f7432c1cb29f333295e7c98dd773c4b028f4224c4c89c169d9f2e46e240948e7e03396c598f864892900aca20985914e13eb95324a0265e806a17e817953948baf6009c160469bd53e629750ee2a287e8a659aded2616e50193c6695cb8804a8da5d8072e86302223043d700d87fd4d15d173e16a311a07ac4eb5e558f9662c2ae1bbc2d1ecd54dd65deec61b1b5877df82aac14588277dfba6d0ff205d15aaa28974bf1dee6a7edb0075fe202c2162e72bc80dd16deb25940cf6f290e4e193384a2ce5570b1278eb7b08167145e0489e180782d21c8aff5f72f10f75ae006b6c8807c60e9b6d2ce8f738d5fee512b5c620b81b5d9c3471546bc7e9c7370842986b020965ae7550eb4b8fc94677e4bfb1dd81710d0895acbbdade093c7c7bd7501ad71ce457551df3ba28f32ba25fb9ee11fd0af66c8187fdaaaeebebb5013057f590c5a6335556fa91a5fdd73c2555109a283a9a67376c20a7aed2350321ed221dec5975f30ef22835d9196cb65cfd6e324cbd21e098611285807320b883e35edc4c74621786210af4ae0be3c273d0c24104a0574615e1f49fb7709f544e350f74ea00d5718ab5110b54da29e506ad5fc521c09a8e624ac5387de1510bea7fd9548f56700c0e3160b8d454181cc5224c389e1982514d0a582578cae5ef89bb78b4e4895b7b87514c7a9d69fd87a904a4484cf5da1125d68070d84e84e2989ebe54abf7245813c4350c3f37d1eb23697c4909259a9f310c3251cb31ef798b3e8a1fd23019e7ac0e3b0e1daaf0e32407ac55010b790849c8190dd6c3d22d40f4094885894f65784e4a3db14849f6ad938da0ada973eedb0e10d6fcbee6807515097ff110bc1580d1cc68e99bde51b4480bd94b82150e4611412206b991b386e1f720c278971aa1b1771b71b2fd81500665ef24dc06133254b62fa9261ee103fc686fe8642d09051aa73d9b00410caac413aeef83e7f736404506c91a19b0d12ab144f1a7502267ed44587fc94db2911a307c1490395b7e00fd7b005f6e1b540415d730bf6452f308252ba8c7a75fcf0e227142f90445079deaf79b7b89810ba003b10b02a4939f4c377fcacee1019ace032a0b3b65862001661fe8940273114f1b2890e7c49f53c258e376d56baebb5ca0f7af81143e37009cd65093ca5ef9af9fe7c867d62fd7acce50c0d02a3a0ef434792882824b89a51df443635bc762a0d94ba080adfa02d31ebf4655778ea43fc6c2cd8a974f7d0790ca139f40971613b4e7c96b3b833103d38d1a6eb3025f86b4d50744dffca90586e4aac75c0e46c9d48861ee1764fa3243dea3703237e4fe8ed76ce5f523a00097a17c7c536ac3c9a4583000706cd861d6d83e6a3d5e05e4ee7140cf6f0cb403b2a09c0c7e5a9a90976298c0d0da662e296b49ad9d5c3b504c0642cad5ad6dffdb7e0416843a043b90e02111eaf22b86af89316c2148b6a5c430ee1c65254b64f313d44ee5120de3e109633202ccac6e002e7230b3bfd822c0ceede8f5ca60599dff8140ba49e5237a37d3a8b1a675a3e1fdbf2e9d69854ef2d57a9aeac5bc6879f468f53cba75f2630e9c2557f1b950342db0bcbd5645cd4b2f1751c2cf69ae7afcd72a0375183d24a2c6b7939663ecd1a1d73a46160f11f95b349ec43e4334af8eca20f32b50815921044826d4ef1fbddb41bd17fe336f86fb3c00dd08496134d0b0ad835ebf272ef822d41cb2c31764cdcb33393f4d0d378b4b5cba234a0f8c7cf652e667a9490d39639b2de64c4309cdf5b1dc2cda01146a3aea3329234f8102937716d67b037630f006475ea40a6761da6b05ea069ecdf5771531573c85ed8adcaa8897b31ef08d5cbc84e248ea4669d1e7211568ccdd1e1626b91bf5ed1d0b38aa68cbe595cab7c773941e4f8d2083a299cb6066a966144950268937b6fc44c76c619fe2adcedcd8894157114d2b91867f32c5707362a48996ed9a4939bbdf73051a3f9355c40f379cd95134f18060e65a9699bc13eae468dec56b1f697438b08b0413da48387464826e0c22f27ab61c4c1d13c3ca87b4b59df0aff48082e89c159cfc4f23f06c339b8280478fc6ff10ef4fe305d22478442c91cc80f96cc15f2a22f4dbe726876ab22e176f52867efb2ac2b8b964f34dd6721c52a149077783534a8926b81b0f7ba7d4b274f5046929bb9a0b18b36f4e055e0e3648b2816dfc1bb933c5223cf90f1fdf057fc280f9475b6f43f61b50e112cc7b7ea064632e92c17c668575dbb5f3d10997c69214e75f6f34a8cd6375cac6842940504487da09fa934a50b89128769e85688b0db8120445175ec5739c3a55ac2c0a700411ab3ed47ae2bd8c910c65e536e92e837a7b1cbb39fbc43e5e64e6f82cd3622c644f53f4421e07ecd6e6119f5ac4840e05865034d509af309ceb8cde204e9011d8db5265760a56ac6ef334286cd9d7b79f3b0ae6b48874a68a8da7454b0a3d5a8643a4fdbe07d04ca623f9412ad27ffc08041761d53cc513b4219d52f1942270ebb1cce9d076775419d9d0b1170db66cb507ecce0d51e44c7d6004172663548e7ca808aff13b6f2b4df3d6629557877f23430afc2a016672aa24cfa96c775bbd539ebecc8ebf5438fc87c2940e7ee2cb4293cc51eef16a41a39e8e516d79eb1360db6a7374f1d5088541795e631a91bfff3c11f01184b364fa27e073e42643b40340e993674bfadbd42a9c1a9c1f1ef424691ff8e546f3dee714295351b40f5d69c0c4cf746c21c81b0e9be2fd35e2079bd5e8ffe8cdd25f9064648757d191f9fad277d23d5632973542c56b5db5772e5712a397eb46fd4b99cf108738b017923063066cfb2895915a178716c8d91ea1645b4f62dabb6cc76490ac611da26f037def42dea5d9e7793e93efada58cbef2f74227f9becffec4dd97930c8833cfa934ad49842458a20e91711ffa0f986a408c80b20c750e5846c829cd6f22943cce614f84967dc73278b5acfb11dba27303e85df540a16ff1d448febec126a4581159287c693dd86b8537496f29b9ca2835c444ec66b924df2c1338161c38892fb3645785b849793b9e5458c76800103faca28ea455ac142c227990ded222cab1f89c5f45fcd5137d75695900c46acbe818bbb1937008939f2efd826c7cc1e66b4650d8ac08be5b091d4bdc1bb98e892dc5e6c9347ea52e4ce88c7784fc28900933c4f117f651edcbb0dd1dd868ccd5b8db69d8387d8e688245b580659fd33c1b34277ec44fc7e7b9337c263958df0d888297e9d39134e60b5ea577d72d0fb9f61d9945dd344924914760aa76138c4397ee2ff569a4de6f6f03cd34720c6589f85b776e3970d1ac544b90de7505b39735e1cd4fc0a45aa4dd195d64eb272265661bfab4c6634c9aabe59041dff0a609f7397b7e9a134091aef07fb9b1c33e8f8c1698ea34f36a09ebe4dae1fbcdc060074f1444fabb997683c8ab622acbc29041531f720d693a0375e0bfeb24e301e38c43bec17cb7d46ce16ab4a93b37da05c88464e30fa27d72a16d50c1df71c445922d49d98abacdb0b28b9b9bb520deeefcaae830c9343ba228f388ecf9459ac147a8b562cdaf7fd275b514696f5f20526d3f06fa518499b6fe5a7959732d41080e256245e451a6bd38c6ab5f7ec197ec0a0a4a213e9ebb5ae00e1f52da279d5778bf7960faa4f58a8700caf6f851b2f51739319d2cbe7539f5006d29d76f9c1040d175c27f573bfe020b6069676af464d1ea2637bcd4b6ba86d8e5547c63c1fd50ef19e2c7d092e3015c4cc3ff1dd06c817ea577d147ced41f3f2c66c2ed7a498b72917d4bcf731d86acab5e0f9627ec836a86294e59d8991a11efae35cae3f47aaa14a2aee0cd598f7a237bc9d257ddd0fcccc16df244488e0b98e968d263f806aa23d9597ea4aff0404c9383c471bbb1adbd205d95c6fa513dd8fe5d90dfcf28d00032b75a2357e4bb9df9732ef4fdeb7f07cb2c225d9d21d2f5b2f42039d91b4aee0194a2366ce952c4cff3a058c4d6425f1f951370a5e7d6fcde8d05604ef07af8ccdcd5dc3391a3c107a53e49983c1459461963e22d209da6fcc20c45929f7b00e9ea590a7576e1477f5b155fb632ecc5042563b6d8f7ceeec3d2bd79bc7f746cd721926d46232778fa61fdd13995bc6a2ef3d1d880e409db8f0e01cf6d9956a3622edf8eaa1f1d8097b40839d5edfdcfe1f014b3f0a3a3b1f10a0f19dd99fc9bc9496e83b19b0d79f7f8c76fd293e78418efcab615faa73fbacf2b86fd6fde327d236b2fff39f3ff43cd528a86576a227b7a8e665a6fe3d10105d03465b0d579a505a513f197097037abca7b746aa601a13701971213183c396a9a2490438edcc20ab6e7973729feeb727721f00800d36ccd0a9608c45859e1d237c56f819208fec5a9ad55b84dab2cf31f272b3e2b52b4ecd9497cdb1afb747fe105a5d38d4697e994d65c84317e252b7ac7ed9131cd969f5e509938b558f3e9a5d241f053050ff703d43c75a866764cf60d446671ee665396a7d987b3f5017bba134edf08fb7a4719aa26d51a9f0a075fe4274d6d3c00a1f4adcf6ecc37b20019b9e7cdeeb6a6cbbb0887d556b94d226df1d66d798f6471e43285da4467120e577edc0fb6db13b537e7147a853db9555edbc0314c4110c9962317b1fc4f6e6b2b25da433e1319f5f21491621abe1c7d7987c9cef799363b70886021de10e98240ea35802777fa3f2e74b77c60e633d9a12131d49a97e8ccdafc7fbbdcc778d242a79e1ad08eea24ca030d8693560780266e10aadc4b7942acd4491810d2acbbb569c9d1b163f117b5c86c19ad4983920691a3a5b83ecfb90d92feb485259606071b534361befb03f72b33fd1a06ed61b1fb275d8312a6fa720b95de2483360e99818eb10eacd7f43b75210c42d20b7107575049b0054dd7f51e8f59952d0cb240732f729640e5ef65a6bd77ed25aba6983a20bb41888f5a5fa51f33634cdef32ed59dec5bcf1cbabb741f434c722005013fbc8d92f04349b9e0dd8b2bf251d6ea5e8eed1dd4ebe2231508b8e99367364ef7d58faa2cc88c1aefc9d2d7f897d79df4c31e052ee12153b84824b8507858d8338fc3d9af374821b66d3517ad0cea34ca23388b51fedcd2fef83a1ae8ec24d3278d0f5baf5182683f4dbd8d4383097199cef5ccf63770bc1fcde1d8c051f9f05683be5150e89bbe36d8d89e9c3e9d17ed873473351ed5445fdb38805e099fbb27159f69361ea47315bc25eebab625e80db04e986a6f197cd27cb7754d693606fee0d9db0750b6978f0f1ac60f5223f15571b8ac0f133614c6adf978d274a88682a913014d46dd9f069b5b78868a5d45086a0c7495f20e3ea4743902a356b49e20ada961edb9d9260b8f5e81bd0f2abab3469585a25f769a1b6717d4208a97ee65bc2c657ffbe0678690d242a7d46e772d3d75e781519d9831d66a6272aff57c6e809c2c12c770c7b1d5441fc6450b9a44b229b6e19d73e3d29fe8b28465b518463b8fa802a09672a1eb2be233808ab38ed6e0f139e99177c2109963b2ac18571184412ea15ce60c17c6f5699514bde99b07c7b157c0fd4284ee94d915f1ebb12fc440976cffcc5857be102e187d457c629f91810ed29285d3b2d40cf8fac8a7a3d3a8a6e14cbd04f45f257e095a3a1118ce4f79a5166408378c0be1a6af557ab1597dc556ddbb10e867292b069e0b3ee798e595f998c766b305238f25d2835e66a4b2cc1cce4e0b869e6ba3db8584d3a16f94c94e340c3c3d36e6460b21210cb12c710c78651fcac7b1c3f7d44cd2c3c8a35f795b7935068f343933fd869127ca14909c38b9868668b689c1c0e3da14699e5c44a025945d1cc315cda3596c75ca6734578c3c977deef3a60c46318966b338061ec7d613a7360845d010c9168bf15af343101e8964cfb8530c7dbefd1d68a6638c7f9d3246dd92bc2e0f0559810ea332f80c36f505a67eae996554f2a6a19800d43207bb3b7b965eb95c815e48aaf5782d34420898fd8de8f6a54ca094758a3fc881123ed74f508a60efbece707a202b15bdf6af1dd074238856e9e9166d202253a6d0824739f35f19951ccb8301d483cb5d6f3280915e7a63e90ed91681d6de6866161167ed122038848802757f57f5c8ae4cf51589f1cc73d6da925fed017a645aaa2c2518416af2263fc0b54467a6942a790d22473c99490fcf445336d632b9c0e5ee8448148791352b417e6e6c9d145ed29b0178218b227322d9eb46982878496400c8e4433d2b8dec04edbe1d36971955c1be12a0004ddbc9fe446b3a35eacf986f3c9a7b652b6e05091a49aee4ece2b08cb7040584c4df798e68dab564b136b334f2bcc715483962b691d66d265e3d965af89bb299bb1fc70dcb92e7ba1cf1639bd20e017ce16678a4517490b23aeb301349bb7da0907e653c4507e1c209cb197366ac8e75a47790f1eaee9ccee61024ea7f58dbfd1ca5d9d322374eb9d441f216d6d7dbf5d392b65bf993900d2f501b40174964e41aa7f64673ff39ae8ef438adf11240e2480a00794b3756e8808bca95e49f516770507d0c19a87538176b9eacf38236361204fa08fd0110e3ff3a34326999fe2fd176fd16477f0c5faeeff6a4ec24fc02fb4d3d5937eae9b8e1a931c9d04e7974025b6943dfc8a4370ecaa4fab3e627693438b376720478e24af70f371a8f59a49287c5c0135671d4b7c2cc3ec556cf7a142688c9b8769b8ec5b80f55abd1627bde9574aafe06b5b1bd6df42ed3e83f1d50365afff1d21cb05217fed45d733a0df10b0f5c6c74f4eb6e4e9403b977520177c5aca18678d9729ebc2170fb3c10ef647db8c1510c11531eddc82281216119692ea5e9966f93ff1d95b22e22e5180e8ced2d7ce535a375852fadde88bc6e1d93368ee7c93b99b87256fd4f8ccf570c25ca9b439bb6c4bd3faf3a9bc141a20d406e9351a5df19d3eae4b4f88bb22c708c74629950ce13e05514c6002f2ca67273308a558017068233f1a7630979510d68306fe9c13ad473458f63b931b69aeb5af68d7512de1306fffa7b504c3df5d51dd839caf5b163a799d8adbd2f497119558133563e110771d112fd30190102592e6167eaa351497006cc4f705ef35382b38a91129cbd3de0b8223a0613e4f6e854a22d463559e9d342c8ee17b9c806104808059b62ee6917918db9e2bfb18b0cb3b8d620e3f7110520459d287277f6305e5f6dfa855f5ab0b3204c7c49fa6adc21150eb16301f24342908b21be4e0ee1ee2872940b89b3b94100432f1308d843a67e2d507ba8645c6be037bd8a57e51d60dce3959aa6446b3a922d28a0c1427d36a5544f78a9f76861165b10f689fa10adeb729f482becd6307fba543eb8f30e02525a3462d99a3fe36531a1c508f335c32e805d04efc737300b29388f629f4168a21b38e6828381c164a2b965605435c33499d5022230fb3ee0f7591ed2f3bb23060fe54e322ecf7d5479fcb0e447f0d0f15e4f8e6c4d504069132e227b3fa04c2122f37c3d252531a460743e878fa173202123b944781df48a386ded217daf436f4045b1e1db3e8421f52926823f0403ffc4e4efe6be437a48843e101137cb68f5e3075e12f503c1d469a20f0690a7a6a1109bd00315a7848e69516840097d6589a498ae0d912799d40a5b08018fe4f2c71ada10aed529b18db139b7dc8d1cf06fd9b2b61c0cf189801846b3bc4cd0ae1c3c7f2e1b793f243d97b4328b54c543a5c2a9d47e4a9aa94cf977bac4e02f1fc553fadff13e09cde9604c887c24882874f95d7dfe6d3529e8ba1447017d6c40d27390ba79f3f51f8569ed8fef1a27e684d1770de93e0336b443e28f52b28e3f292aea51d4c3576ac3347473f6258b1757027099d18569b58da50609d20d48821530817247785b2e14a4ee5e27991cee7a0f445b425e9623057626b96c82f9c99e6b602af651c8b1ee759be895e627d10ae19fe1360b6b5fac494e2920f46feb9973bfc0857421d967e239ec8bbdf3dd5d4957b4c62f28f2ea41a1d79b89ca86a90e854f9b42383a2be28944463239ff36aba092bbf915f3d26ec0c4df01878a1ea52a6e9184338f8fd2335d6ddbb0fe8c7cbb840ae5a3f0dec520823513e20775460e832bbdf6feaea8184183c7ef935efbb96a742835fd7117ddd4f6444f11e990e7e6ebf3ce131cb8fbca9ea28f89cc6383d4e92842ee8a180e4c6acb9b5b8e00ec283b04c74004fb4c50f9f720a6dad100692d8136806ff52d6378b311c7d13615a5c0954443a627cf3b65c07012fb0fc0814ffef9f0a2c4ac98e8a712c2d9db1a053d5f29bd9a383916fd6583be4f18e11eac973eaf7871ef74f8fbadb9591cdb9cb623be084eae802223ec7563bf1f3c21d04b3916d570a93392bef08d54c02ad3062a4596e4f6ccad9410b3c43901ea0513d1c8a01c051eb0ffecd87e160038aafbf39491e181188e5bd2090f56b0967027279fb76e65b728a504634030398df096854071115234caecc856dc272150edf355fe241bdd5c0a9191157ca5ccab297772b862b00181f01b914cfa97d813bcd3c8ba50242d86d4f462258c32fbdcc0528916a34e8f48aa7737f898f4b7e72f1574698aaa625ddcb973f8f555bdb5efa8e1f84045a6d98fb14e894d2a04a589331ab503a541b53426564a73719a99682283268e34dd3125ba872a508ca6742bdd8c42b495b93388646194fb4c81b7780869ded94182ccd106489ca5f753274713b99c339a141794b8726a8db78d35a154ecf41481f998213c28108e01c488880c4d00de62558e03a8dcbb0c432071d4abcdaae88d1b9cc06ddc02854917c3d887f7e0474946e77e98ee18283d7c0451bc11cc9c13537a173cfeac6ad6b4bf8b663284d4a2264ffb5ac39797a57150b7e3f020a104af6882d435c9741688a4210dc8884ae3a1eb5689f2557a4c4afab6b1c4f315df838f019c6781ba2217d4e5db00f8146c25eb59ac9225355586eeeb98e0e748e32bb34bfcbc44464a47c502037cd1871ca7071c7af40dc5363f9a48e9699645467a388474ec2ad6175ca0308a1e48198682526519f49124049761b3db7f02df11350fc5c06c182aa7f5c64c348c2794d0d9d081184a0b4e42231a1bd76295414e80f2c78f1b2fee28adc36b91661fe2f9788e6a3538ff8f340aaaed2befeb6f0d4ef5ab1d832c7c841ae4c5542b255e40f3c194cd6e19167bed5b9f6c56be4ab5cd0f3b228654776e70ecfb91ac9ff09bd9b59cb5531b1922b0a423353f110601421197ee89385dc1d2a9f6a18863d3449c6f27e258a388b82c05da1566972127222f381e694e800b6a393b93108b26f0e260c08b83589be8167bad783c2b4596a5718411fcc6231772b39c86886a7c0c458ae6725356d6fd752cd57a95a40afcbdba4a104b6078f2c67388bb7cb45eaf2270be26d141d5b5188a85171c25c97ca87683072fb29445b588148353da427cc4b672f8a8cd1b3eeaa82160c903fd059408b420f6f6dcf85d4d9574d67e8508265b16f713db49ddaa25757c0a15cb888b1fa11d0088ab91a59391630f8745807de6134dda9392d799c13041406ab382ec9513043dfea5abeacc09f6e353d475084b1c5367fba70c53c831abf64c2f26cf0a99c1d4a5154d68403381121922458101c30717fc9d4664260e63378009e370af2245e3b9baf003b1c415d2132791c7890b7252c6e5588bbcf2db35a49df70a7f210c4c48cce847242970b3f539b627571adb22af78c3c0f0924ddfb4a72418c7c6331a0b37f2c4344086428ec85e4440ea178afcc807981974ef5593ded94d2987c90df51b581b6aa908f6025bf6d9c8088350883ac48a9f6b9d849e0e11bd843ffc76a4d0e05035c23ec97448999c283bbadd9c6ad05f77ad0f7b97849e454220a8688923d4510f1e8b172de636578a6149a8b46070c121de6f8a82005d39904ea8aa6f7a3833805077e3dc9cbd4e49a290b78ac8118775968669a2414b58c5ebed8f69275217f0252ae56682e9cd80169713cc3591fd212f27a1a015af3038e7c0938c86e80d481558e77976b80c525411facd21c2c8217a604b616beaf449f471a35956bd737ccb1cd0e349ebd76b5f14262d331074a42ff46ca52895d6e0253c3c06d3952118650262362208d96b3689c40893ef3c4ba62f1321c0a84bf1c93287ac1ecd3d744d7096467e6daaa29b15ea8e52156a9cb931abe16bd653b20f258d328ef0a5bc33d25efd05b4f09a16c7e262d0b584086e1099d971d22b442dba3faab0ccf218827f7115651fb42b41d3449b7197dc082c4145ee30f246b3b639f5e624eb2fe06280ff7cdca41124d69b7379b9331a2c6534051ea30cd180013305783bbd09848d05e6746461e1746487d5413a694167e4d1007ed7817d3fb3eb0b14cc9da74ec9858bfcb3c8dd1620863fd7143ffe1ea82628de1248e1d5f91f0380483320a2d04fc480b0640f68843b0955ebfd4cdedc866a0a9ef8d66f45687c68b5b3c9912e029cc396ccab83a8121597bcf14244a27fe90992eee39f301182e719f5ef48d4f1b03fa97cc55acdfa4cbef4ab030a82def94fb81302505304489fe0040dfd36e2634e518deb4a6d4152e1c154f01a96c2b5432c5e2e872dd14cc8a45b714f5662617d0b29a66bb645acc452ce3ec7b0120bd63e3bbe6625a9a1d85889f715fc8fe2589a9cccd8238e6998d969a2829f7b90de1c39d24b5aae0bc34906c8c767af04b9bd66f019e2192f56673b431df35978b31a82e5d936435fe887e861f377476f78d2369991b0a24b56b2fd6dad3f864d8dc9fe0c8e3770d5dfc1b260ecb2f6591bcf622dd0b0727bedc70b8ecc63db169cfef85d439515f0a44cc94317284a8a4aab82673a26c38280011c0353f02ce6b71ab26d122db0d939b047caf696a07bc9c90549154866c4db4ade787fce580cb14cad460f4b58891d16a49eb3e3c3053811e2a29db69e021c0a9f0b71cc11d0180000acdf900362bf8b730ba2300de28c2251938207a570e07ac7cd452342661c99ec2a795be5609e3322141c8915577ae427b8c20830d3d75683c6917596089ea9ff29a89a9e087278984ee90d1272257503e2dd99b489857f2e85807ec92a2be988b8126eba0ebd9a8c5be258d0c146b8fa2ef240b764e3e945e16182c392634bf8d8163f1795c04884bb04891782d6acaa7c38ec76c14c0e0210536aa2ef626f40239a3d69c8d82b7bb46e06809502d502c97812edc4d3c99b327f770c03019bdf67c7c096b988d961219a4984cfcd7924f61d783ff7c7a511b0da7aa4ce15aaf5e54a29172beec59c55f48ebf50538e0f416a69e0d9e0b6bb3395fb1f096f35aa6a6b392727e15c59a90e48f03236e58030bc39e1a56c561f920598929af1356298ce59253c512414b8a0c14459f7e7fe6f09cc69f330f2774eb91e25fbcbe1e3682ed8d5260ffe230d9efccd002ed7d5bd6b2750ba8588f200033ef3b567896a0463e7b0284f1ac542185ef95a1ba5d860984fb8ba656897db85527f16f8f237b6044ddbe5b35f6af09940e1f4ebe726ac50709c2f00b0cc6bde786a904ca95181cf6a87619cfa53785e4fd2e192179a4a2cb75bc9755c9cb1271680c42eed60bd272ce62fef0be8032e080b13e2e696d19d80bdc2167af48deb60bdae6d85a3d9b7dcfdba225c488294fc6503d6f85ad33d708e5b71e10593b0ca031c34a4553c688075ca530c04e8e8358a71c4091235f26f80169fd04388ffca3f36367fe600d8e81a41eb06824548ab2ab1e866ae32b07a306aa0a0076973d359cc3e29c7f3860135f48e8c57d35461294723c171c30403144df5e860d044c3b30a7d1c61dc205002ea804f34dfec2b070c9389eb38456eadfb5eae820258d7262073860e93118f3f4650b2a19c2ebd0264977f110da5c627287c65bf913153f1b0ff4f3d31ffd469f07e43cf09f5342aaa91ac9090ecbd6cd6166263b2405120a3f1ab5374f3322c3de49886812f66c6689ad57f74d3b97922e128cdeac3cb324b1f2e44dd159e6b252cca680ed7630930b47f2dbe8015ec593f714717875eed94070f4e815cc50a57205939c7fe52b8a2a4be12988c2e257e240c2d886d7a2ca11f8afd06a02d4224deeae336c2a8d7c1b4a30d415008ab9ab728856a3da218edf1e962332c75beb57b282a08b7caee9c796911f5e61c2e961000e3335293441037f4d918b19a2a6cc1fb9172176c315c7bf7b3bfd7803b61e17aeb1283fdab28533096a5b55112dcb965cbde3ce74daeb298f046b3a8341108483b6322cc2bef10ad872431d8faa1978ba68afd461a7014fe459c310a460e4491113303e661c61f6dfc6f58721f9b8bbfd0aab01a368b7c76d4cb5cd8d71e90bde3643c9a64c5fe64cdb8d44d96acbf865b4d07f1b995d1380a511afc40a82ff3345875b5ec95696e37db7b346d67bcb1cf986ff9c55704ef387042ceb7cc3a39da8bff90becf570c6f9f49a4b8fcfedbf516cf955703c64e1b84eb80e479d927bdb7a0fce7ca08d388f9671ea83edadee2bd567e7ece648f1ba8c3efac414b5622aed906fd0c2e2d3b0cae0c82b47ccbe7d9e79ffd19898fc71471ce478e9f88b70ad643a3014c8bfba89e1f0d17f53da89a134976711c0f34178c8a6d9f21db33f024455e8f1083b34a373186814878148b4add8d20b2b5c0857528d85005fec6cf6b6c64b5843ec4d0141b36f09d845948732623a0586446aa2e5ace25b3ee4d31f97c572647072ac98ee83a510eabe024f7aa94bd2479c9cd1e95d34caf726960861a80f83df97e7807c7bcfc094680ac46a1d4c78e5fb8489d7c1800720144708cf77262a277fe18facac3e6ac1e9fb0c7e7ea3a9305b416ea6851fc208a7eaf450bd0dca28f087757a7306e7be21f0660192e4a1a71719826964cbd6cfed4f56a4c2c2d687433501232034a9585c48136c1bea78e8e1cd556209bd2cf833b9428e3ef42d1494c102aa5e4e3290385be7fcf909c28874e50f2e172b1f2fa01d12064f1df256dcbeba2f6599fef68b86f2d78fff9301825617498540e21948752f363bddddac9a004655febf52f47210e6a61ef6f4090e86dd9bb6910316ec5a0148a1e08a3d37200fab621e8822a1dd0d98538e427374636e41fb194e37fb3952de15dc1edab5b5a892d590fe2fcf8dcf11e1a96ac7fb76c05312a2c57edac8853966a1f7ea90f33ac6e317d9e582d004f2f173d84130d15a394359fe689b6aa3e8c592f0cb97c6af50e6a44b5c57efc12e41acf2b1dc40656df44df57058cbff0a2332a39ab4e16b97dafbbc4bf6d969911ab77cb12884867753153936984e2df25af6dc28cda3a7e96137695c8867d644e48e7acc0fd9f762da0864f9ad308c43288edd647d498621ab448845764b11222b3ebaea13f4ecb5164ed16957e6261023bd7708ade9a1c190067e0f979c3d78e10b4bc5965d4c4909c0269c9973de6cc06eb4e901982409bd7464727f38fe7974e42b9a3c931c94d7bc0ad0687557465472643ed2250d00cc0bd015f4fc714622324888d2d41837d1cf3d6944941f9dfbb29249b39571f86ed03397970fec16e2d307778b692cdbbe603f997590117d03e7a10bb7f36fb1350862d08a7ccd3c71385d7233d1895d47499f9fdcb54d2af66e9547329f70d8ab0a246169896e6ff0700aaa8d1f64f6c485ee299c77133b3647466706e2ead2c5800f2542064eb307f828c7563b32ccb906a00994da6a68a959151b5372610107d43cc0257c99981dacd791e07a5587fecd59c98310a399e88cb3e3665874ad05728c322c9c6f229ceb1dc287840594ba4dddddd07252acee3d4656ce2a19cff216f43eb9cba5bcd9b6ff84567472dcea2070299497f4ee676e82df490d0178d460d8c1271d5858bd3a9138e8c452ec9e08f704e5ccc56deb02b4ed76ee42b89c37e5ee579a669c79bd6498298c78ac564d045d2c4e9169305076b8dace073788f05d5fb174c6ce86e5e9c86ba25bf7f2c4f52a02e997f3107d4704ba07e0b3dc88db1f81cd7844c14509c5d9faa41508f0bf9127e8414e70a16e4615e3c20e4d176869fe2ff1c16ed2bcdefda195d9054a0da9c41c2bbcbd3043edb802cde6c084bf4305c5ffdcd8baa47156d114df3c14afb68223fd7bb004c4debab20ccd1bda8bea77726ebc7ff74d6449e92f86599b2bb76477526f6faf401b685940630d012c1466317265d3eca514e81a2c4f9893531cd2912bb931cc1a1977f555bdc306b72a1aacc943f352f66f63c951b74521d4d2739760275506490091e2118948b09c4313b3297ba597f02b1b8e2da2a851b1d5fdf4366887232b7c0fd525aedb5d26ce32664a25822a220901dedc20d36a6cc6e35d09689b095836313326ab9b073a70f50bb6801e8a3183da54703d2229446a4e015b82d9745c547c5b2f7636a0e407074910fd000e1cdd63df82f994691cf94cc2d331bf41dbb30942056c797f5934cb65c0f4de690884c10683790620d124909ae68a59f9fbb248a7c53eb777d68280745f86f94ca465b5e6f911f8a3f18ac36279dfe14cc4f48bfa2ebd636aeaf188a516eaf0392348fe98915468757287607cb2a0bc0a8483a1b2cd0411875db46bac1517286908709b01c74c5f62d33a0d1c0fce0a8f93aa33d0b90c2b66d2deb069088b87a01dd016c95de02668f1e8975c5d5fe16d911c41256fdfd1c436e6ef8fa2e339da3fe204b7b7a3bec1c0d51b220d341bf5f735179320071c3951868b42cbba9e35fd896683f9663121f5681c80ca79cf71c032fe89385de50c1abc6d0f78380f7931f6ff52a3ee45c293495317295153cee4314e2b322d27f0f365ff12f1cf24e31a4d9d73e209669c5a5b13f3a3ceea54113041882d01c0ec146c1cd99b81907c6f34c53ada5a730b8729defa16182034ecb872f2d953f613ccf9d8df70bef5bbfdcd5191a638f8fd980a1d59847ba6487a67af2595228000992d8054447526a7b1da60269a9ef33edd99efc24535044c2bb83ca77abcf3f5e28ab90842eda5237537157f4e00e7a816fe3157ba7ad6febcf5b731be87e7c6b0532ff4388bd0a504652b9a59402f78f2786b64729401acd0b363d95784e066e411cb4beb70afaab7c33b32e1ec699107c0680ae43da57864fe977f59f6b131baf452c0f0938d4ed96239d5a7c37fb56be4977e34c1fcadd995bf044710106143d9d2ab04b9a14a5489332662cdb838386efecc39a2b661bd722bf7a68360c53691d64cf81c8f3a31bcacc2d3050db0606c821b4ec6d184cc3a7f52a7e295ca4190f56bc72df673d8d62479f6a3dda179b6f4dda75b73a3e267978201e2f81ab9bd36409f0ec7fff849db2d74b88b846f8d8e9f6efcf63e8caa7eb8c14c85148edf4a1565337521b547fbce0d74d6d30688bfaf6bcec280ab6be9dbedc2b8de249d4903695c25b738d34288cac3b3f527c462c1ae84d04421426f48c54b669623b0c1c369f946fc3281a4a92eeaa4e5f7261945c7aa5bec35431d27b7836b9c79352af865ee5f9a717851c4c0a4e3740677ed1499d2589a93b182712d62aefb0cbc0bba0902b744dbc8a30b726b9905cdc2d5629be408267d5a7a95feb6efa0f8d4824fc2516982ff3c1bb6883beb574c113c06b6a384a76d218a09834857054894061a1719dfd36203f0b3d3a7d9646dbc45f9ce2a2264d85c0b26ce0314abfc4d317ee4a25495be5b98b593ea6ca0384ad032aa36687562018564d07f975ffecfa409a6b76edfeb2d15d660f4414d9b54b67c5ea5efd173198fee12e415cec427f38bc1e012aec1784b98d048b756f60fb050b9d18e8f1cc1628ef4511d3d6484422486c7befbdf79632a524652e0880087608dbafb4188bf52b4f5bebd50cf42419086642af1e9d396fea839d6d3b9b116e551e2dd62ead482bd2625a9156c4628de1c70ee10b4477d48a6e7d2dc6ad71dbd9a12f6ef16c3bb2668ab7fb2ce87565382778e31b14ef36cebff11c388e60ca9de11093e7c6779b27d936490691f8353c176a70e1c4b78c7fea0fb7543db63b5b5edefa59136ed52b86b8c5e284885bdf93ac885b2b5f2b0a6cfac11ba00c18038e59ecd68f011cb59c5b1f061c33a35b5f058ed9935bff051c3d1be0a8eddcfa2970d4e1028e2914388a77cc828c701338ce2ab7bea7c56efd126884d717c11ac01670b42ce0c844b7be05c746726becd69c5b6db881644de728619776535b057247c726c7b49bfa0d236a24e2ad3f9fc89a571fe1167fcd7eec2c8ea6dcca465d34bfca9aeceb332b61976472ebf7126e69a38e26eca409935b9f97dcea799ee7799ee7799ee7799ec7711fce977cecc8ba750618a2234ca86741b01f2b8e4c2555dc712e096a57dd36d2fc8ecd1d049038ead71d8d051a39539f411d208bc5d46d2e1c2d0d3480aa22e6052267a4106e7df9f5506f2a4b0eec0c2ff323ebd6bab1cb179645276bc2627d95156c16d4f52b87a356df850c3b76ac6a5fbf63dca2c2dcb2859d5f0ffe2ddbb84d1359cc7062aa98b5f90144d6c85bc154b3707d55e649b855b3ac63ec7af9e9a3aec22e1d4e811ab7beebecb04b6713424111e811a35bdf79b8e5ddfa8e845b52280543b7c2d8d537f533d6f83024dcaa47527047afa2e08e53c9ad2cfb338032a04cb58b7edd5e316c80a04eca74251f3b7dec7c4de3160d57b2a8fdfc70522c6aefd28565996be281cdbe7ebfa659ed87e6c3e7833f276a1af7340c84d52e21e2d55a7b1a0dc88f5e69ff828695464dc554036d733705d9c0dddd3329dbdddd413953a97c7737994addedeeeeee52631a776d645df92e7b524a3739af87e311de1ad967194b8ba6691bd7795ec76d1a0d5a4aa6d6dcb51bb4bb97a07c252e6c7762b12da613aa85250bb3ef4c87ec3b43b968db1665ca1abb92b241358ded162b241b2f9a46fa5e3cb1c323a741f7792a9826305550a8d395a30c5ac920192483826c7cc0322b5c2905d9047904794607e3601b4c8329216796703b7529642311205d5977a8843403a68409070e2ad14bc856873c58a481e29286138a9ce109654291359282da066699a665286bf3a00dcd9a340f47cb1a5a05d1c0b279c6844d984d3d3afa096bd72de3470840120941d2094372ca19364bac8d9c6119246b64e709715d4905dbc651ce8c39e7acdf95bbf55b6be76aadd56958bfb78da394eb06b2bd511fb02a9d734e4a014ab9aee39e40e79ca6214c94e3cc9841a573ce299bcee03afd48a4959515ea99b6e8a4cc388d509ed3d3e5d606a428c406daf8d0fcb0c187dbcc21719bbbbdc915fd1f1be0174216115147ddaeca1ae9d3e3853cc91d2e770be793e982d87c22c693f9048923c856873af86385c099593247d2c22cdb6aea4f3913de0e511cf80d858e769e046d68a6214cee28d66bb5e3922cf787b4d6dd655410eb0af1c1948dd8905e8143da35572057fc6030ffd015b79333fc2619f4f4e7751f89b4e291565656be5bf1a6c9892954e3e6c69a9453b24a6975295bcacd5e6faebbb3c2336de33a4dfb41e77da415cbb2719da7b164174ac9e2581bcb2a4001496c9aacb92ba4aca5237d92eaa0abb50ccbd2b267b1582c8dd55dcbb22c168bd52c164bd6c82ccc98734e3ae9b77ffbb4c1d299606eded16c886a9d48e9cc64adb2e6dab892857a773bafeb9a78c0114ab033042b1c218d2d6c60e80a13e450010a584ca1a233a7150046d8810d84687044ca111c474e6022c58a24908183fa62821262d8fa4aa12798f80fa494b2bbbbbb5b4ad951f49c7376ccdda35002d6f15aa9534abd86c17328f56e27f86c2948414a29535290d24ebe411475b08458dc299917fa769315b23ee901e40cff012eff013a0553bacabd327fce396bfd39bb25d316c14abb534a69a669dbb67ddea7831b41e9129775a01ed70e75a897ff634a3ffadd8aadee2c2c1d4bf5d9adacd0b9428576d7c162f1a0a171da32ff378822e5296746b5cc08dbd438ebea94ba942d654a0aac716becee6e59bb80a209aeeb68fb740f7db6d3766fa73d532e61487da4b904289a705a336de334aeeb3caff33c8ffb702814a9d4cbdcc0a2e16193c30f20d39abc8ea53ed243d14ff80e354175222ba2e994008a4e869ac9cbf914f0cdc40b2fb494690b77774745b13638d52e1715c5a2442a566b54147bba338a355d54145b4245b12d77b2a0a2587b5151ec0a2a8a255d5414fba1a258efa2a2d8eece2896db5051ace6a1a2d8eca2a2d87a51512cbda828d62f2a8aed8b8a62f9bed820f54b7777777ea194d27677199aacbb3b066e875a86866a4a695935467b7ba5d90a6a26a59453ecec205494062a2d412ba5a6d05a5b3a8ec5eb3cada7e7dacffb70e4b75d217dd69330524d49a1e4043bc7eeee96dfa07b5435064b4bc974da993a2cca9fd505a51aa3a96a8c97bb7baa8bd494eeee171bac7a99dd30dd8d235fb6ec0e7b660c7756dd29fdd93fabbbbbbbbbbbbbbbbbbbbbd359fb27ad3ee711a55750b9004ef330a88d9bba2e3703bf7d5229d43ddd921576babbbbbbbb67a0bc716ff1dcdddd1dc65772865ffc5855d8f923ebe56ad98d0e86860848a7f23cd3a2bb31636edc90424578401ba9eba283762788baa7ab81995cd597f5bb88ebdfa652a7791364b1b7e3bc09aedcce23ddcef326f8ddeef326e8dd8ee44db0bbdd8a3741ee762c9e06ca9b096eb763f126a865b72b7913acb7339dbc09ba7813e4dba5bc09cedba95e5e4833ac72a6fe98dd0a82eb2f0750c33104f3e5c25c8f555772eb066d9e4e6221f130f83c430a294c5abcac12ed9a3a4674a6ce7c92ca3165d101404c866ab7845b525bc011f33292ef388ef449238e44e27e4ec9b18591182daa903e8e19c9652e7ae61de7117172e334ca91c48e1368e6dcf91348d6d42965deccedb9efda69cdb48df3de46ce80a92b71f06f200f2eff0f931499054605560b57de7e168e93e7eaacbc5d196dad13885d02f899414df8a7136e11b5289424a5cb3fa5704b0aa9c0c8e59f5366ac526ff19bf8532890b93ccea13b4311cc211b4ea0957012f59437fc1fbb38f102a229f482a0a15319a732582d4b3e65d894e9f483924f9fcae84a48b07d1a3a0d8571148590129d3b85c298d272a5900bb0e082265052510dc29ddf656190a18571832d0c2e0c306e18597861bc3e2555944c41c912ac92335894eca0e411c1d4833bbf3bb980062ef071714116291b2f2a98163362601293c4e7460bb0f81644112a69810c4ab6900143e8ceef66485d2904060ceefc8e0630baa8010c2c60542f22299b420806eb6147e80b29570a891113c3480c2358211f981018af2b85c0c811821d0975e1054a490f0409fc4020737e38d2ddf37e982376bcdd34a434e6f4df7e72dcb7fff0eefb3d50c86d79df1fc4f31048070661b12f07fe00043864e5d7af209d2f42b0724ce2fe004b30dbaf69d6a652df1cd72da6cf399de7c8e43e1cdf8e2079bd5eafd7ebe5eeee99bb4ff7e93eb97e384e5f7ed37dba4f7726dc64fa74c77167c2ce849d091307270e7cba4f67820307f9671359336fe3808cce6af4c7979a69210d0d65d3d0f007d110c939e79c734e36c2ca99ce6852a91e9b1c760022e4072082a8a2c9ed1f32591b3318192dcb61ae45bab6b7a7831c9a185c9133fdd3fd0676b510e9a0b1c96107204184fcdcfe207c32ccca8bd673202483293268c2954231902283a2ab5d292403a226423878d2ec93ddd9eba1395410a1878a2f501154a2e2c727af14718bdf358ff0ac3f992b385ffd9a666d6a1a99468c60f9fb5d359c4545b2cad13522abb38845ce62afa1a12a5b1ced308d34cdb6a908967fe4e19a50aecc2ca26e24678a58ec1f3a3a1955f13a1aaac23a4336cc1cd7069943c685c37489cd4ee0305d930962bb66d11447b6e2f6fb096e6b9ab55dd4cc93d9967cac1672d5cf028d6910b361ce560e4632874c42b0e304b201cb64224a9d700b09bb684f3f2781bdaa707b09bb74bad7143f9042af26dc42dd7eb642caede727ece29b7eea730888885be3b4c174d25bf4049a36589135fca828b43b3f681ba2912b2a39238d4b50e9d2ea74c91bfe3106e5923723e9f2cbb9a37ff496873ea66822457967e8638a2189c3c6952cf5e58d9472559ff0c410b270e7bb6cf56b1efdbef3ceaff67bd13d8bedb9535a6ba629e1607286ebbccf7e9fcb1e1625129e09521e1c7a8445f92b9f0f976fa56551764b138b2c2d2d25972876a44bae7c0a449750264074090a3551f4874559324df0f4e168a80fc75d4e2e2e2ea6528b8b0b8b7571715971217d2e2e2e95d640d2a6949040e5ad8d74491efca0083c35e8a24a10b07023ff877411e9c2083390c216445ea8c2106ea0d8d112b922b7aa16b7f5b7c5ae9e9bd66b9335a78729961a27b8331c2deb52c18886874d0e3fe04857f7fc04a8a11c7effa8711a75fa038bfcdca6813c409b1ce40cce131c40c861eec091389846cef017a9557452e6767bb777977c986071eef04aee0081c4c14bc819fe7fca048b394a3871248a229148b45d71e50a51082cf9d82e256bfaf96790ae171d97675273c5df8da91539238918c17d3f7dcd7de2483d00c6176fe5ca9e41d58a1bf860fee00ad6b51652c0bbd34f07a7949d054158c3c9b5716510c29073bb958d45b46183d826406a0c39c353d81fe59329777039573e8b45a6d101643bf4510559a14cd4174113f46ba8f2211341fd2c0c434543ad572eb0e1ffc1cf6a9ab622356a29989791f535d54d0d776858526a5a95f56b4bd79a65b5be4dbbbb3b1dfb9d525adfbb35be5de649cf6ef5ae97de51041e520f33cfea7bcd341357439aced403cb6fea819d2f594af94dd1a449932692d67e29a59452326dda9469cd26b7eade7740b7d79cdd119558d561b1d69c4b8f28959152f19cbbdd3498e704a90e679c71487358ac5558ac242c10654619e8472cd6ac496bfe3643a7e231162b8372fed6dcd6bd018027a7b9adfe7410129ea076b9d1945b7f864ec422883325a80ae29282aa20f469781a4226b4172058eeb1ddec391c2d9d72ebd71c16b7cfa8705c16c4aed54b5e977419718b4a29baf5b329dc62b9f53335b82585ae00baf5b3fad911b76515885ba3e7d0297509b76a1658dcb132a94d3c76abe83ec4eb452c5623a80e8bf55de5830c9579794341950f338880cef0f246c505fb1ae221bab5c7c832ec8e93e765b875e36b11911b1a680899e88938c847bdaa14e41812972e6c5361b1c6fae787c53a5f0989d4479d84c51bfff5bbe706d83d2c3ed84858ac2b3f8f3a668a9962a6975c3be8d441a767b0a7b0589f898a885441a851c845bdaa4fe4a67636b32ce6e7881ad9544151bb6cf8fa6dd4aed5d7ef29dc0abf7e07f194d855797a55bff4939b77cb6288f9ae3d1d16b59c189c7a34a3d265439f8fed6643dbc6719ce77ddf87930d653ed6868f05bf03c1d4779345b26420187344e5a84a1666316b9fb0b0a89eb418b57c38191423292fd9f7cdb2efa613a2274325354a1f4e3605c592a7374d251f2bc37732802edfcd933c81df170cc7242e08aabe3b79503e1c284660983d3931c17e3ca86e96b058a518c17cc9c766df654f5c8a58ac4f6490e141107c9b068b640833282c5697cfc776b51c16eb9b9660b3ef5e5e542a18980a8623910b7e06ba7061b3b7e9cc098b609811b1584b3e16e663309231c4c4c4a8542ad54b4c8c8d940b2ae6642ac5c4c4b4c4b0d898186262626270903ccc6c0055416c6082be0d4fe46605aa82acde7ff5446ee4178486f79009cfc9b9a1e169c8444349e348ce8dc74c61b90393e772ef479ed3abfa1ceb557d982476d462f56900b5a15ed5ef7a4e16d218824b6900e54d8c5b443c1b40791382012f6ac0e3216be41dbdc9737e0178741bf0e40c7fcbe380cbeb008d470401bc21355e113b3c2378781e2880e451808dc4af837bd5a37a548fea51d51100220490430789343fc7a703774711dca906a85d35625488185284111e38e20348d0b03ae0496ebdee117c6545c2ed4feea8489038c01c50b0e384713d506eff844131aa5264cd1c426911941a41a907283d82d20f508a04a5497c3b10b9944e968dd5528f03870f83ab1eb594dbcf59fb2f8a2c567552836a500d5ac00e3fd9953f039431e1162be0c361960e56578427c5ce081c680c87db3f817a2ee116ff07904842091084600926688c1ec5688c0e31c487e37239647d3de6583918c8f5c0ccc08e5ccf93bc1510468605148ff08ef870e81ff1e1380efcf54d1d1292c875676fc6238288211e0e1f0f3f7fc8d783e987f4aa886fc7172cfdfa43b038bf88cf07fd212cceef5893858325592c168b61483ea630d52b2288f87c10f1f5c0c11bf2f910c222e1957c2cea2b7d61b92426d4954a6c3e2653a8714990d26006b367af3e836a1316bbce3a435e42410662b19987399570a784fc0e049e10dc12ef0c816732b24b782713acbe097bddfe4cd3accd72b865c3edcf74d8e5523aee75845b3e0222392468a2043a45b8172b0c2be5f6a762f0e3fef2324b710f43f63007900d62a228d891eb716722738431e4a432adcc2a7e79abbf92583daa55989959a4e00d3f1c500e98656d4019d02bd1afc48793396179121ad63ee90a76cc62b50aaf3ad3b99d19b9fde306d4490f04251fcb340cb9b09a666d2a25b246531244e0e89558e020d7c325d1b81f6ead843ee4d59e146654580cd2421fd4cbeb63fa7eae0947e4853ee42d82c21971ab0b7d4edf5ca8cac22cc63fb120fe6227dc63f6e4b6bf3277f7a1cba173900f87b78db9560782b54bb3fe6a9709c65f32fe5a8940ae737474e4801e34f0e592d0b0a42b58ff1aea118bfd9d822b85b65072e90f174ab89e7e2e0933a94747c62cd334ff994b6e3f0f39beb093a1f06084c579441bbafd40b4218d288bc91a3103d27edaa56934cc30615bf0cfa4a994a8c684f14f3dea551bc18c803460fe88dc0446066f8235dcf0f3b1ea8209b780fa61fd845d5c0fff8c3dd4a427d8f9fa067c38d4b91e0e66248a9d3a0cf8708076ea118c652609c28f7fe44cffc9891eebd1ed9fcff5706bbb40ccf95d3de21667393ab516a9d5895a4d50eb4ead4fd40a45ad517c3b10b9b51e75f7b4ab1b96b2dd3d4d78fc3c4ba0a353641671c29b3bb62b7f062d589e8ca5872e14b1286fe94a274c38e3723d61b81cce40c54acbd32e549801f52994bde291bd3a15b1327c3da86e5021fff4aa5fc5c46e54b6a3ad8aaca1ff04145178d3881427f876985378d997004f81e1d7837bb5cb14ce1c8ea75da7aee17cc919fefe6e9ac093dcaae1ca0c682a99b00c68c2c031ec84713ded3a8d96eb7199c4377daf987f76bcb9f3e164402c36f3db343361b1b320165bd6707ad38fdee59f769d422e49a88523d7c321d703b2c08e19d0ec0ca85d26f083f848b9a04e0830955a0cc052001e76c74a0d014834df4a468610649154415837a6afd7c7143211c44dbdcd3de156d7dac32e59468c8329e196700b880beae79a60c1e4f67343dc4add7ecec992dbcf117145953affd42e6e7741f30c35b8fddf862787965b605dc6dd5322b7ea0a748ca6d173ddc03e457730accbc8a4523435df5a93e641c1594ead5371100730ea071264e87eb7ff87a0db0f8410fd3cabe99bd5aee76759160e3534afa9d7c9b2f9c1a2e99512cba509760108c2ab0e800becf3e35023d5f4e79c93d54fd3fffd62bf344aa3e4635931b063ea8adc9aa10f79e7abe6cbebcf63076e653fc87f1916b766c8a1e7f023f4420b7303fd1c4051e0ca75f3aa29085eb99492e306f695230ccb836408b76a4bde2c7bdf994654d9cb23151cb59657fa5996652f44d67837aba0f6847d9f39fe73c77f88bf12fe4644728a60052f48a1c40b393be29134520006157c100423b54788b435eb328d2cb2e28969cdb0028acb6f13c5653612aae20942553c39a39ba72cea91f348bc27587f740ead36376a83b6f7e0db366cc36dc57c4dbae8cf70ece62adbb999a7dc34fa2f27fa0d9668285b2e152f5fe82a76964073821147d06bd3f3d28522aeb9ab7450f5f067558f31bbda955f8f22d74319832fb8c7d4a9bb6fd7dd87f0ae4c373d97eec36ec1e5cc4829a5edb5560ec339e7ac3ddeb394d6fba3097632a4e64edd72b46968c6d6444a8b182d785c6d081ed764816238d2b4f041796e7bd2f576ced063912b380e4179eefc3679761a41ef1094e7f6f7c8e1a366666e8d9427d325aea93d4b3f0b2f617859c3cee77a8c784c161ce6e5510a4a9133f359ee0442e805f7e00bd3a1ca7f5e7abddbe110de4df9e00616b6bb7d3cc22f0d8150e930faed91c7ed70884be4ca20660eaac4648199ca1a79a9cb95ebfd9d6acecb57a503df0e59ce5cbf1db7cfc96c490e06b53c53f3d29f4c7fb2f419463b51c86363e0b13e4eea6a34911787b79b1e33b3f3af7cc10e5e5b6577a8edbcba4deb364d88767d4ff2daae8c326806feb16bb2ade32c68a71683171120bd178e40e5c38d356e483f6f76bc1bd2eff88d8ef74e68375306c0ff03e70d7f41fc86143a5182951beff9a67e7f5e2865009c7638c6ad4f860e2e7d49c664f66cda4543c36289228f717d0797ca312ecd42a7ae7952ac568aa61b4e1bb8fe0d4e2361ccf298230d8b075801fae90056ee68ce39e9b3107df4f5e5131e778646cce6e191302ca6ee8f9d3d5a181eb14162a8585649086d0515f8e45c29f4454c7ef1e4ca2f9c5c323aef56ac84056cceced1c54f2069348110e28821393489980889dcc801104d2c5e6a78cf39c1eea757ef09d47f44fd567f8742b0080e11063184c5e93d7ba6fb9c21365b8a20e93977eecf4ebb8438dab940e4d8e0f24f1d6e15e0f2c35c61b56f7996cf7ef6cc1ea01efb92630656c9356ad78f9e654ca276d9cf7104bbf2f6c7096444fd23664f4167912777da4c62be107f4db3369572561876fc1c67d81f800842086ed52394d09e7bb9535f954755c31b58f467812fb2e8fe3f7e6097f48470cbe31e59f4d545f3034410430c51828929d7b72bd43374dde537fe34536d2fafffb7e0fa1577bce13a1877d4719dc7f57ab39bfd8b106afd12cc6ed482db15c2ad96ebda15c22d16216312b7be102036ed356b53a9176ba66d5cf7edf02540a35708b748d741bf42b8f57915ec2b845bdead205f21dceaae7fa709e116771ddcae675f6f168e49c8f8c6160d317c30c5c8018b31832b06ec4a2131787e9270a970319ca0516ca166da26464ebd1d8e49742626582971a05eef46bdd3153685a27fd2b420ca4d9d66a4fa99a771cbbdfb5dd2edbc33d20f2cd25fb90c0211048bf4fbd52bfa32fb97af9964eed0c2693471d80ee98cf28590931576e497f30eb9a24fcdb894f2e052fa19e89222fd090a008714bd1b37381c53296b4f55d85116e508d1dcf32779cb738eedd2d3a74fffd965e34da747fdf7925d2ebff2920d907a962f8142da6523fc967064f18a25e4d54a38eab824fa85234d8a575dc8d12dd428fde657d78445972f825ed2b0e3e41795f445a9d7a29ae6b16bc688524a297dd6ebd2d7c1adedd2a7895dfa3c726057dfd0d7b25657d8a50fc411ea437f56f82bd2f5bbbbbb7b2c4efba24dcd2074fedd4ae90beb9a9cf1b1dd0e2fd0c96ec5aab4564a0355b225a5c89d59596badb5d65a6badb552d60da00f323b85b44ba68865d185b9c236d330c649a4135d7b2c952023fab3fc75f8e7e0ff03c9f5dfc1a7bf690b9746fcaa47786931a4007ef1be50a714865d397e64583a78d8f4e7c0ad98dbff23889bb8607e1df47091c5ea397bd0b41d5fb0df83a6f5e783bf9fb97a5de18186c669a5ddd47469beda434fd648fcfef9e898434dce683da69c993f81e81491bd2aa269d9e7039433a7edf3c122c5f92c5294cfdce7c3c4e248e4f2e7c3869687540fb657f371c66d4a8de49f0f2dd4e4e4b89dd64ce3483594617682ae2bf91489ddda34e5fde8d5090576a4a93f5af9349a666d2a35b2ee0dacd7c1ad792b8dcb74effe3fa52b06b9aaeffe0cca5eb9ff66bbfe4b97ac5a48c3626d178f26a635acbf8c159952f36f60c5c23b9fe6c99d777e0ede1c854e76d261ee1bd0f6f3b3f9500ff9d0d63133e1553f3be9c21eeb0f0b4b2c40c1c7e5f0aa9fe537aef3be6f0722b7e5654b285942f71f57822a83cbb9485acc2d22169fb0a8b3c3ad9635dce5ee9f13464b3fa59097506642430ef2c24a87b1eb7168c1ca9a134cd6c4648d77fb0876e4a87093cb125aead5da6599f6e1d87a7474743f1cfe719fe012ecf679a714d891eba1a20aa232d978d39b5c541cfa98dee553eff2f2c6460aa8573c80fe6ec5b21419f18e8e4e91518b77faf973328723bfee9c02a40a827a9777099998b170069dba2b954caf9d130ad5d950f2e16c130576e4a8141295c2ad29540d6e4d5843b94d4fcf9f6a17ea5d5cb40872d5cc45d2458768caab9d7793db9b60cced5cfa646fcfa6d731121a76ac4b34cdda096b5825a161b3275dc1d61b525820d706e3d5ac4b2a93ac2e8979f51fd1f06091460333a028d871838139b018da80178715ec5891dcfe1f2c9ea8b0406a1259e35dcc0d9456baf2ab58492445952b89a44022802b898c4cb92f001d5ec9c79e5e56876651cc53bfe4b3c1b4cf68e012d2aba27aa4ad78407047b89711c7e3f1f4aa9ff4b2abc6d32e2e09cfd57284e04d098be28f9c699e22b2c4db0c855d9c135e9942aea74fa8f790078fabe36725f4c2940d47133744023b72af29ec588f604ab8e5ae94c7bd321b6434a0f1eabd71451e694ca1005ec9c7fa977c9460801a54830e5083826a908f2c66532fb2c455f6735944400e397c385a0358be88b9c645c2de9697dff22befbdaffc348027bf7bfad6670b68c2218b2dc18e14d674a8576d02b91ee250bbb8245c0f25bafda635eca9094b7fb83573fbe912a64c4ee04481f36702f54aeefc8d8fc9c45916046640bd0aea80a2587072e8d2031639189784ebe9d1e3c3a1efc3bbd1c12bf9d80424e0c399b0a964a22ed7c32acac102ab00ef45099677e8e1e10184168ae537fde9510bf09aeeccaff48535b158e588c5f92830a5f58a73e48cebebb1809aa0a01d1e0f4f72eb7b4982e51f33a0704a0630604703bc252cf24f013e202f68d8917f1888c73f1ee358cce3c11b3d76a53c9d4089cbf42e06e28270a872e56575366379159ddb4f8a82f5c2711ab92428580e3d666a57ca7400b6e1108b072ecc9f355226e8e1e8c8014747470fe8e17a58d3869835d64869b877cee4258dd01faac3e2ccb2678fe192d0b05c12d73825b7b9254646428c8c8ca6928e84861dbd1e1aba9d059980867ad5cf3cc42434ac3fe90a96bf9b4b28c0272b74c3336e7f5701cfb91ee61f06c5cbb2631bc03c78f24d603d6a95ffccb9acc324c1e530cb61f1c68f1d99a8e67cb144d3ac4da5fe45d1015ec9c7762626d8719ea4b0577e47858d7bb916380b2a5993db0f38aa4723977375b8555970c42d29840449904d7d0f7c932d61816e16e355bfa659ebc3c907d3a3de86371843214916433159c3dfafbd38bb8274b93ceac72d053211afda25e418d07074c972585ca4ac6bc86c07d2850a37d38f2e3faec8310392a3cb3d19b12397e34054b69c76f112eee6907f4c43b0f5c70d0663576afb39456153e05645cef433b851d9a819570a6571e4d2eac5cf14d4b74be8f263ea47db2b2d9b0cf400cf4e20904d20cf24399038fa3b9c5fdcfe131436082f88afc7765fceb0fca83fbdff3861a6e7b0654f386a2004be1edb9d309a5ef19f4c6087010cececcc9d086cafedb5bd2420c4942953e6ce8d13ec4c407e010083d59e7642f08f65a0cf324d023fd80c7819f870a86bda905e35ff0001a119713d9a91d1edef2ce079cd91630576dc8ab6a2ade8f6901b46f8c3d313d6c3f93fed6221747c3eb61ba23ca8348d77653d0ad18c08000000000315002028100a87c482c170304da34c963e14800e759a487e5017cba3498ec3308a320619630801800000c6008cd8cc360080e85b2b3e8732c3ec08812613a49c3f277e24820f651d113044100c731677f1bba6edb188ec9343d758c4950055718ecf91657a5674016730ef00c4f96a0fb0a94ba10280a078eea6b411a1e506e246e1c536b83037806bdb685ffe0bffb95459a70fe71e7d142dcd72c51c6335687b70f7aa7d9c047a6a78b9a7daf1130e9a6c68c87fb170bab4c26bd8de201caedc40bf786b83b283d052a7ed034d86f7e1b6a094fe9608296de5c5540355c1d483af38b60b76b63c98a4d0136359fd365e0f9aa119b168accc94e3b84f34664c3f370eb060bb191df3733beaa947bc960e23afc5db3f1b062b0a89cd270c8ce797eeac3ef5703fc9fc4f75a0f7db6685ed10eb60538e433c383ab59b5bac81f5f695cb7826ba32b13084b733ea6de73e65a30008eb3031fb7aaaa77fded3905a66fc4206f869602461e73ddda35d7656841b4264cab69ae95057a8d596e8c9bf2674312a6d572e4625ff66312a327414a30203e66254327958312a1a034fcedc490a887e5b755b9821355eab323ad088ccc35ba2e9d8a5005cea64d6e8c5cd22bf206420c21a1a1de97e358a60927a0528e9c5947b25fbd9bd0922f144db0f8227c54c130aa82b8a853b55a293dd180240d76f39bd2364f48f3012bc4093298ada69636254603e9fa6090cf0d969765bae039b370ce50c6d83bd3a96765964c7720d8c41e5dd190a3fb29b9b5c049e3dc4b071fa7ad89ce27a0abf24e1b2c923d63269cf3b4845a9bd5196aef2365b166bd5e2ba4d6abf2e0d3feb97a91b06725b3fa83b5074b9596e09817408562d46744157a70809925c73ebd3c5ff275c3f811eadca761d92038da520b8406790549243efba54b1696856c87253772891221879372daa83c6ef5c229be72e1aa2e10b109cbcabba58c30d10607b0ac1eb39af1e38af793d90cf8d25c55e99d7aa15c94f4c40e75cd64528cc0b2d2d6f45b9e1a8876dd3542d39d97c30428a7ca85313c95cc39764b946287c98454011df46078e9bb6acafa905cc3de2948ef388eb4070b6148734470802d0b9c9d9bb0941eb253fb0f30f72726e88aff2a91506b6b9f73b7e2d9ffd9d0a3306467ad0a00fa7c948d4700a88a8f09d3e034d4701a44a5b89cf3af4ec0532f8cb8dea130117c9573c5e8ffcc3cdeee628bae84b2ac8a79a340713c6a74134639bc4e6d063ac51ad9054111d716a01870bac72cf6e4cf33a8b4c2c4edde9ea74da0ecc2a9402c0d56acc09f7dbeeeadb57692cfc780023c21729ae7efca2955447dfb137de4dc6ad68038f4a65bba919f71d1471d879b25aacbd6def3ce261fa69e4e0ead5912fde497a8a2778233f389127709547997bf1997f6058c2e9fed79d1240eaf22d4942477447c40548b789365522d62bda5370ded4e242fd5343530a782f9650a87abdd1cbab4c27d2e6f851e27fdbf9c3ef1f0be6c99b00e9805ac96286c3ac14b83b99e0c834377a8dfabf7a74df5c03cd79bf9c1a9cf4f85782a1e8736a0ce04bd38b6a261674aaad0dae2346d2e14d200258e64b0cd5f99e899e3233096da2ee90f95fc10eba0553d0705acd8f372677982d374515d222321843969cf870499e2f9508859386f50a91babbcc5e523470d8131d36786b1caded0b81bdb886f5c0f6fd1a888a09892c75f02608b27a6ec0da54ce7ee9bcd98d5ab180ac9034341d6216ccd03882b17f30a0b46211558768930373baa89009ea16a8a81d40a7b27fd5450cd8d7a2559667452595910bb86468542f86d477c19207c0947ae19da951e2cc8e0fea55598e10ccd77fa8a2d8277a656ccffaed93db58c51d80c4344a91bdb5e6e283a6e1b8abec4f4f8f4bdfb871ece76fc35996a3bf7a39a74b8166bc28be7add3042e30b40428fa163a8b921d42addb052a2423870a92b03f710e1db2766e3ab7b07be95729fc56695608a2c7b1cee479e3f33082a0f5fb5d69d5382074f5812104aadeb6d0b076c481d14924223c0edf03b662d7e8ac68617262f0efa3198acc18e55821ab162101ab7ee9596bf29af5ce083d2ddac762772b6e05dd84e261e6358c26c205a22e3d51cd3fb60f5bbeb4ca7d7f2d4221b50ef8ba8976f0e3f4bcc09b0e4e85827ff05df45ee8e0b9aed92bfe04bbe1ef797a0aec8b5a6f9d57c82f7b70f130bafd5e44c97834056e8120b0f2009baf8a6576f5266486e8356dc7338686a8a34019634bcf1b23cb4acd2f991800a206a99b4ca9b9ac59c1e81b940fd13e2b65302cdb5d84d7c0ad7511e44b4f6f186f5df2827bc8725069822e7658ca1c906666101e40819afa2350da1fb1f2fcba4681fc9a21093ea53b7233984350e88e5dcf8a237d7238503388c699d43740210591db4e16277efe240440c527da935de23ae4f10035f98f1ed4d488e951a4c8f290ba33524cf3b652f3ed8301145dc4a69bcd8f84bc773a5f1cc420db28661377c915eb14964ab765b0b576dce83c5a8499f42d71e9bf30410b397e9f58bc368a0fc16dfe240e83e7fab88a09703cbb4011ed4f8b035fa715825b0b89e8cfb7429d48153fd68ee2aff9b2448bef3b18b098aaaaa431080d96275bc0a3b5c4d701a5713f3007c22d400d4d5d6be285dfd85ede19778622f64ef98f6b2e697b8c099c1950cf8e37a9a5922affe4040c66596308306524fd9fd251ed39f73fd2518a700b644de8a6b2e7e74652d7c95ad25d57ff48ff686cc300e4df3d4d8a785d50e76a296d52fd3af69935f08b7a5ed0ee723dbcd9248f4dbd125bca7dc834aee396108a292ae37970e4efe29d42996b0278b8b2ea0e3b7d192022733070dca909e939668101899a70fa6501db925d8bd40ed087e9e4bea8727aef859f05252158786f33d7a7a3bc1eba18c6f5a769394b707b88e855b59efd366b05c5cd0815dac5707047fc6e8a58bb689fa282c77bdb50289d3583b5582284e7bca069c74c28a386c3ed4271abae2b100cefa4ef591bfa9082295a90ec377602ac6bd8b22998524392816b9fe3020250caddb2c9b39611caf09c6ae84fd0c92d3be3d4c84e79b08e3ecbd66827660319f55cd424c31d5f1c642ee1f0ada8745f025770dd6cbfc80cd2756b3d719c2c4a7a1b26c28f1981c72fdd3a13dd8a1af79daae5c4be9119400a29fd1032c50f1afb1de8340ffaf445e9c08c5fcfe33168e93483c1e23f77a48868daac8362fa88ad8fe86aac8ed289f3bc0019e6fd0c0f4dca30b1dda791c23bd7d084448fdc7a6a818d5fbf4bb90f4710af14bec38638d99759aee80060f6237d3107f9edfaf3539a8758337549310028207c7bcd00aae42f3a342a0f1c2f0f6c372095345be3fdf6dacf1c1fd2827b84a188fcdcdcaf9eb3e18f9e46f26f84bccea60c4f192204b55bda5f925e64a18f1eb653155750f52bfa409f59ff05cb561c49423a01e5e843021e943e0f529b9329d5a13182b742138b879ed4831aa8f1b70feafe814f9eb30d9ecb8ea5606cabffbed47f8e9a2e09db7594162c5e8cd03bf20d7b2850982b6dd9f96349c7348a5f72a137592c0ceffb77da08fa5ef90b13b7b6b1307b6b690bc3b9902ea3e9cf1c26fa4da02dc35172242d442e87b81d800e098a915b57bd431d85fc0c0a25fce4cb689f3cabe2d7235ccfadf1c289bd0052b8c8efda51176f9608109a9bd81a6b85d71ad401d5af2e0ae91e15f9d9d0cc48c31dd7a26f94639bcd5b20694e0456250ee5b400b7ff13849521e878599457877f4ba109eb4820b5fdd541dd133c6b34a6d28bcb3352f9e25c169536067a459c885f38e4842f4cc08c0ed81bda85840a4958861dd4a8da97f339ee7783c1411e868c847d29af0235ffe83fd0c8311e48e93ee66d9f26cb4dba630ab0475dcb393e51319c5b37bfd93bf6a899e088777584290797bee2ec27e3b476aba279a7e2f6ae0ecbb317c24e2205c3a8c5e5f365d486e7c9979da26702eef5c8506908f487f0da58bf7738261c147be3b58957c2f323d2224e83d43f0864384ba8efe7c77ba445d60da51bb069500f7c992855fffe95132161b81ca858e2d5d9aaa7f770e0bce33d4a45b8892614cc358ef44b71da6820713ec635155dda610a109deb529505937a4da7e18beaa17d21ecd49498860a57fdfa347eeb894ede8c86e3915610a1cd2143234813b3f11e23e13fce3828f974ca8e94076c5fb782e8d7094e9231a702ed97cdf71f92fe96ebaa25adb48a18449535ecf14b9e8ca25443f9e2bcd8f161ec9c322751235de3444f99a6b5de2c5afb1d12b33b850ee7ba0b4c1dec6513040cc8e72c8d5bd696a1bc20b7e36c158a58394df4386b7ece3df10c227bccb27bdf2d255ca6bdf130856131dbfecef8645c6f7c92222f0ac25929585bcd5764fa06d9a576125e20cf3331773e31b52986ff73e547e8d5faa68e5dbbbe0fa9a046fb80d73fb83b8b4f8133989658c240941ba385cf1a7fde02423ba05159aeb9402f3ea2f18ed6052b0d66ce476fb3a7ce10ab0396b39c69dbca9476c58cabb74c0d8f996a23cee556c29413e80e3c92f10cd9781bcd0a81fa25bfd012691cb9e34e48ced980b957263357e4a73118da1e39dffd594cb6be0bd6a002ffae49e55ba93de95daa84673b5ca9819dc19afc736617b65d07d1b85aa7dfa192cf6e87ce5c7fc5cceea73edc24f76622b845919b785a5acca03dd9ed86b18337f8471c1c61be02837680f908d67be66a970941cb088ee20bf318a674642abc16b90be6989443fe3a0fb3c97dd80adfdd8a0aa6af04be9f92cc98500ee5d0a43a4b8807b8e6898249cb963bbf66eaa7e58d520abafe19e0f5c98c1db3613871f5a96c71d82fe8caaee34d9f8d79b1d48aa8feb0ddb8ca6ed99f839fc5ab709de07f76fbd4dd6f8a0af9d0f48d4b1eb3ab8aa7e18784c3fe1f4f08d88bf54f775c348badc940e16630c308bee20d856273d236b36883fdf3fdf4af16db4c8e12470b6485d0e77366176d77799cb72998015c263cd1d7ea91221a041a8bf4ce05690cd22580417c1891c8be0e08717a21dcdfdfd7bbc48d3bc4b847cc0015c7027a8b59712dccc7e04088807105df466299529cf8cc7d93f544362a4c08e4cca37245986d82de1c62a7a74dbdc79af5ae36b04f0e96538f83059bbe5198427369f713ede2250d23f122489dd4e81c4d52dc2aa74eefc2d03c7e68ccde065f07f08d63be5c3b073fe4c40cd046f714e59dbcb71c51052e17a69d0c5c4639dab3528c08bfedfb44c0469bc9a039e31482a2d062261293ab32c03e97b3f01721eebd8a0acfff9b64b3d7ced06140feb8465abb2e76e8798010ce5f7a013eb31ac45063d4966d85131d5988b8025826bc1f9f1128dd6b6fe8eed7ab1cba88288fc1e1786f623d5e71ea4a95a8a1b08468c92525635449ef1746a63580c77253f2e0a813540e910e0a8bf7309333f699c27a031ed7193cb3a682e72fdd73a222aca2ef47f78cf669b1497f681f147136e9383480d47a26468523d09b5d79a1da7b188ad44ec7917791ce5eb44636b24058d8bbb703e0d4cf21d42283afba440e34315a47fccadee6aa82dec192b8af85cd12bb139a0e1542365c68d22197d361ca7a8da1850b8f4ede1292a50eb13378d09b5488ee73033cd235c0a1edf787ba868e139e207933f1097b1cf12e4e33c335287cb4723ee88818c317b06fe6f48806b3031f4ffde5f431fc65ff745bb66f6f18025371ef6fa2e69c5abaa041465f5cc2f17080162f1ebf96da6cd318a73026c5662e313f0d6adba007d892e109a0110df65e8426ba498ff763dca68456e94b8213e977700aff1c39d42b6e2ddda367ed732ca39cfe1b1abb549a3c89020134381726ae1f05e8831182c318a85beecd628885325cc6c987f9020831c80649ae2e0bf63ca12e2924de6b70c7472a4686e1a3806b4956b937a1db37e9b316865b6d80cfcd4c78cde5be952a6741b44f9c03331dc8e5831a9be060dc75ed0c336105fb412529783bd6ca5639c353e9c6f258d0aa9044cd174e0f276e0da22b046847d89ea9aaab73b1addb233ba2958208d6a0d80a42f522491d5c44cffd7ef57cb317a637d9d000c6d824bb5cef071d1ee07af3627b19a700ec744701c0dfe2a0fbd56358a2f41f9681336b15971d0ba130ea9e81d432dbddb274ec6a64b3b28178ba95bf36bedc3fae0308c40a44116c48cffa777bc794966267858448fa055a85daf10240162c846be75efc034c6c46020a08788d306b35a079cbc2c7eca8843702401544c2afcd371e9277573b5c288c09a263661c33650d108e7a88cf8232a9fa303c9897c94b630f45a0c6e5625532872269280fda2f0e28bdbfdbaa74702461bf064444c20d0134c1c97c5b4f32e82fe7d1c7da05c59f8755e0683c8b9335447c4ec41eb6d16e04e6ae906530985d667498de747955738ff5effeb78e302742c94bf0c4dc3cdb301d2fcfdae13ebdf2edba162bc35c9d095994e634e642a92c1f20467ef3e672d67f03b365f4e5b1a5d28b00c46d67b8a0f04eeb10d92262ba963d80ea159f719962ca458bbeb8f738fe3dd8240dafb96c066a3adaa88e8c77acde80a4d12f45b8ff6dce0db391900a5efda584fea0521618f6a4fcbda7ed2f4e1a34608d61d083c786fa1b980968ee1bec582e040177629b5ed8976200503a3c72ed0bf02786bc8175432bf7a44733f5169d8d08dfd46ee2ca4ce06e4a077db5bf00262b024610f02dd5433be49abb7f00c601ce382e832b53716448ea4483b9ba3fea29b659b2b4c0ce0b9c7ba9e457368670341b5383a4da72d2beef8f060c04d79401835ea9cbea1e35c9aa823c52920a5496bd843881f3ad1df5b10883aca080a5b39cfdd9446bbbc2c11c2befce3801f0a7736cc8a58ea2296cb2424ea44603c20908ae1a66d5ce37273a0dfa0d4c327ba710ad0386eb11c9d3874a1609b0b41c3537ec69880b0d38a106915eb718542261a91d6d488e34167231869a59988a50eeecc040ff01476775088b27e521ddf1d413137e540db294b4e972847ba4d4f60c59fdb46bd6c1d59b78fe933aeeab2fd4e04c70ffffd2764ee72fceb6c7c45b4ba323562e334bfd8849b7b6a3bd4101c9ec2227498e04e88d55dcd745d9a539b5b17105635eddc0a7f3b2f5a91bf1c3241e2cc5ed99578246a9dfa5f2245292f6f8cdcbce1a635b727247381698df56329add3cabed229fd0dbc16a23ce6b1e2d1f9da9bdd05df90c589f6792061488901f17be21d1ddc3fe6b2ff5cf26ae7b3114232e8eb57a5b6fa2485d5238ba0aa626c94ede4650c6dee2682410b2ad58806d7f0e485554f95f8a4a3214028a0cc7828d688ed21011ba945517096521dcb0c949ca085b0efc71df1f3ec509b8a794bf00bd452beb0642e0648d42e92166f5b6c4fb4164a43233a6e5647a183db5bfd8b1c9340746d2b9909d2e36c1886faa9a7de8eb477dccaa12c7c5d2ac5ab1407aae77f5622adb96ae4366219ceae1d805ce7798e684ebf01f5cb1d8d4acfaa2ff0622ef687ee77fcf601b3c53165779440fab60a1a53a5cb85fb550664c462229fc2f434e22eb114fee28cb7cb2dcad7039c194af553ccfe84d501f318b9085ba51a189c58a72723ef96ef6784aef4bf00d15aee7105a9e107e817d4ebe55ba807e2fc8e5d2fde99be267015d100710c5faca70c74c0ea4c184795ae31dce2b1dc0d7e5a7cd1396dd13059c4a5dc7d942a654509a15c949e515a0b096fda1545f1fc1362be60d081c88f40b9953ff6c9f4c45121760ef0f09a99fc02a38b6cf95c677996788f6a816b5c2dd03e736d378e9789266832939af426aed1ee257fe792121b8567438203be8d28c6326da8d6d5523e4911c598c2c389c3e93cb8c6a516d76685a49a8f4164f18a7ac8ec9604e45fcec0b3467a298cfd4b42159ae9a530302cb7ff81303f024c90d9cabfac4ba5651c9521383111d45551ada446ee24a356e575a7b1dbc1162272c34136efc981233fdfd1e4096a5fd08364166d7644657a1fd6f54cf80eefaccffa07c2058e7042f43b4591b8c88076217836378d78bda8cfe281bd2f693d02e2531f80e0b00c81b036a35b9d492eb511d236fa917e3bc71ea6fd8313c3f8ac89763241d1ee36061743c558d0c92dee902862aeaeee79deecebe8ca1b81c5902c604882c81bd1d9e1c0b9efb5cc1f1e41311aa408fa2b33a9e8fdb77fd070d3ff6691903ac446cc51c9079b0f3306a75151a05e1b8012610622b4232a415fd628fdf36fd69037094b6732cb3451cb6272cb30894b6aa24b4c9cd74d0138ae2e646c123fac574211293b9a7773981c071b5a4d934d3e437348025e9cde1673a3eb995cfc53d315a6588696ce76c13955d051f53f5b9b8a9f342ddd0384f107dcc47429cd45f495ca7aba4153c9c6a0f75139ded8eefa6946c0d868c31d5bfb7f8f96d8b448820b72c48bcdbee6462c2f7eded583bdf691c693048cb361016e31a715f53e56d4e202c6e7132066b98b95d49da6d2d3c9a0f46f61b4d41da64a91597cc2e67a3f68e984b962716c67d1553def65a0981bac67fc8f2891a06fc7f6a19231fb6d6f9de0d85163168a577e8b4d2016166866f001f0cc36dafe875dbc293ca9475780c47398c4a96908dacb71006ceccd1e3e5fe7c24e3b3066604e26764d02b35b83b113e908743632eca9f1f2e412c4d7e70dc9335a092228dcc1c72b69fdeb6befd150de59a91f0ab5d02ff5df36e4a73e7b5add347e737b5a8da3ac4e7f3c3d18c6e1df9390daa7b11c5b89f567eff1d9e722ac0f9548e5b18282df034e1d335a201df24b617d67be244a0155866877409f81189acb066074ff3fa8f1b92ae284fe2c59b2a461eb96c6f1661deb58c34aacb13eb1c534d67212984bb755b7512a6111e3e47bfef77392441bff30057ee31baed7926fbd416bc62a6c56207f1d88d7799ccf51c897e8206d36e18d353a25e8cb7aa980f8c29102322339376e763e997627a394c20e19d8df5251d6fedeef78afd79ff26c9c7459f61840719b753db50537bcfec117095804486588607508de5a1d6dc0d81e168895070dbd24f3c46d7d720f90339ad5ba215acd93fd982426a1db061c11048c8b31b21e47f79e8884d8db2123451a5c9f02402fa1eb806661ea4382faddcadf77fafee48cfa646f1506df63748e0e813c32c3cc709865cd6f80d631621adb6953f4d14d495df2648a329fa2e8a6cfb18a816237ed8b825f05fdf2da064440cf8e578217a0a66c68714a208b370a7edbb3ea7a957b9d463c40dde5ea60d0dedd81cd9fd84632a2234adda951ed28bb2c3cb6f0af9f201e89e66fa5be69027fc5fe0db7c43600b90fe5adf95f36415c62f88e89a9139f0c664e6c2ee54274e46b09797b921807011a9d93901e1f5c25811d78d3085966ae56548eab9f0bc7ed5811d1c6b56e7fe2d81ed86c25ed257a181b3aaaf59c0099d75eb6d75049c88d7b9dbc1e371ad0f6fa6490112dc9da3be5fba9919187440bd07fcf0e0bfe9486bb68e864215789c03d409f565b58e9e2ec9bfdeec95cac9d6f9482c899fef97406c1615d550c4a49563bfa10da0e671b557ebea37f598f2e0aaa9d5ab4a87ec1e6014f02023a890bc8c0c7eed67641bf2e1c9e9582d101ed981fc6cef525d0b24e267e41e107a9d5f15552941eaf061fde98bae27d3e79405b3a0d33d6185d3a304fee4c9ac810fca4211264fb081d49b449d01e05f9230dcbe7581c1fbc0dba749392176a2869a58308bb3abb1e5c7395d91949c4444eeb367cfba51752216cf150e4754c3279c83c698356f8b94e99cb412636ee3374acf887c87b7a2812e5cdad14d689081ac086279ef89e736388b174350e62375d20383600d9120308c92c82bba51ebdffefcb227cccdc170ba45311a5a48d15ee6ebd10e332afab890dd8228c918f16cf4afce4414399694899246c5122cb878113f5d18eb72c0202d00803f8826b9a907d72701ac82b7938a843d76b1401cb2203248c8cd79918cd893898044b7fada26546ec4dd9f92ab353dac79295ba6d33d6a70bc1ca51c491c177a2d8a40eaa3acd3e75e93b35e37b3c9bfd34a95330ad8452b51dcc5f4d3bb0a5ed1832465b0bd909d0c94621331c5a11e9885244ecec70100c79e0bcf35a0d66f1aaf27c921c12e26690e4962322b4941b89cb00601e0560b9c654fe1f76035f44ed0069a573a2c39073700b9ed83d6024d797f7fac4ab3b31e7ede82af5e5e2af9df037fa9a614eba7afe6281847ca64e141dd14fb7a586b91d5d25c3fad8b3d172c49168e412daf8ea2b50ace6e1075cec81a24c9cbf6a025d04b00f1c39cc534981246238eb931c022d7810ea35334bfd0fa4d14c66d9bd9816bd816c54dfcabae86bd2f855621d4dcc88b7f6716730ef1a02268db8eb9b6871963bb064306313f7f417266f14e65e3e1a42d536c55f9289c98f4efc320b03eb7312f7d0da20e6f5a57ad712712ac80bf78c54d17ca15ba0e69d675d0b0d1f302fa8aee07ee045e94a9dc830ff1ebf30873f5d537d2f115d488af4e35dee144562bafd405057b0fce0e3c644796969c2f0c175b224b39d7237c5efb494c59fad1e4f23367e90961a794203f621db2fde107a437c53d62c82db7157552383c6dc9d86c34c1f880d9deebe03aab44a94f5d03b49bc20ebe3ab0e9eb8c995b076847f1d9ea46583a6e36e0fb94477a57ba58675141605a0cd7fcf834acbeaf274ef1ec10627a0d4562428c12cc8eee8d6243e3a002d157358a94c7550c0bbf7c045d8f760c8dc5ad8062d26ddd3d3a7e662136a82c6a74c734114291223f4e5c6e68a16afd98a85a0e427de68502eea31e65f20cde6d289fafc30acce9ca5ac842e7a475a90ac6dacbe44d0873e1a6f52fd68ddff6950d1b07ac9ec45c8ee8da904dbba36ef68921ecab33404f6a06f51a3a1c66382c447b5c8f315bd33ea4421aa457559ad1e7f890153bb8a9c927c72619b8588a0f64b4b9077533fa813ec02ea42ba47dd505d307bcb905783fb748fc372cd7b249db6bf0f702ab774dc7ecfe6026a49339aae0e6521e2becf82f17c44f51cb24e9fadb5bcf136dad2bbb888455a6382e7639ec91e783b587a58806e12d0e97e82fd3427762a42cf55ad84592dc6975e744f89cc479c058cd2433ca6912cad00f9216ea668c3a430446bd0ebb2296f493192a069af039ea980a6de85860c06ead8c915547905220762cf6ada0846221dae2791f13df457d4deda0cc0f743a188c66f67e937f57356324ebdb6541c96f691ca3f2b51c500df456cd348cff3818d8efd59788d66696cf47a708e9d0d2f403afc3087d891dbb4af5bd2d290d8101b500ee5e0c3287c9fd2adf47369501330c807c518f00db89b9c5d84eda35a951617dbe07cfdd97c90e2c11229e44024db1b26621ef1141a91f790142aedff06681a3fe3ddbd6c6c4477e96eba282514cf8042594720192039f60ccc7403553f0f455b227605e09111d51981a045947092e2596f71e267ab5220b94b45cb8e01265573e44e26782f01cd86c6eff449a4e174fd0e70bdea3cb9a9954512b14369546b16fe710e75355050205307d168de037d1087f02d3680a564b6a61b883c2fdde02e242e6058e98862f7c4ed56fe16ee25a45f4e027c8916179ec3e7854312906afedcaee0f9f0d0170107419a0250f29eef0da24fdfa95c428e7955b4adc391f120bc0e74da520edaece9a6c403aa3a13ed669e3ebb337aca92ef0d975428168d4c5b691a0ef1683d93276513b17d202ce214347f25d8c9c6ca2661ba3fb6a9ed037de237111f56d6b4d772f33ccb1beabb0b00a14a55c97273212414a2f30b227f256e5af02182989202300ffcb71bb14ebc771383240fa601e58a2789612d52e676209acaab330d1104398356f478ec710f81ec05cc238352715754a2e7a967b7d48b3cb667ff7ab3c6e02ddb0c236e98e11d8e14bee374900abc3f70f69130976366e9a1f6bde2bca10aa89ff124f43e557b6d2dd2aaf008a0a5e3cac73277f6408375762e701732a2ec69b565edea2da1f40f96ecae9de1428396fb03929c680a7b072446735825796d55ea21d0e13dc354a91ce4ee82df2408b0c40dd7145d0c19d7326e8b849272078d2936836a2f4a39c8f0e08127f95712941481206b6f23ce189a7c7cc647574f12ddaecd629ba049758e1bae75fd0b243299dfe4035f5ade0b755a9c4a58831d7196148d80d7bd471884317f42c6bb3555076eadfc5ffbd9f2f1d5a98cd349971630d9a9d5a7a0bb788a0cee15ef88113d77a2d5f6e6ae4a76f847cf7bfb448d714ff1ec86486b5d8d724b5256d63f879c9807ff114f909be5962a6998e3807728f42ef68c26ac4eb7852d28ed1c9b6a4be44a91a6b437c841f01399d43fba2bafaee63f2931e444cdf273fe2c1b61e16348ceac934d40004f96a221e1d7355ee760101655346ec1f78958cac63ef4e7a247f4f0d750ec579cb4db61bc5375c4d009c38778fa901150b179ad331de77b417e24bd0cfb0528da171897730afc01b9055078f798935cbcf5e4c1d2b142788d968a5c303ffbd4e0903990d2af5580783dbe6aa9f0a69c72734bbc22023102d3efd08014accfb580949ae8569d6fe9b3e73988941a57d56566e10f0ad5b17cd75cca5561c0ee8a5848cdbffd541fc1a4b2b792e8a3110fdb1f55d241a1119cb14b781064587630c433e3fd78c8ba893ea93ef28cbc0599a4c5cc854f0838d7d5d3fb8e66abf9fcf8ad28dd02b08813a8687cc366bc57897b49d96ec006954736454f6f6bd5b1b2d09f0dfe9fc4489f7c2e952ee1acef2baf00a5af7658f138e820d7d91d7b295ea0de83ef76cf2059bb4b431d8d86e44cb87c0b844772145bcdb1c4d5dfa0d20ba9e1f89e223ee3c2d83c5a6836be17dcdf362dbc0da8f6089bed3c0ff0cbb0bae0422659fd969aed3b0d40be7887e96f28ac5e4c47b06b4652ce564585789506a9f40158b89185135d4b9f0bb27d083ab10b0e5d8f404725b415918ff2611dca5d1401efa5b02b1e980ab8f013b3cf7aedfd814dba131b480d0755eea8786138d44bad6d5dc9dbe9424e9ee91ce43ec6da5cdde8e44a44d77350fc222b3742952a310c042a3abd39675a6004a2e68520ecd870b30930ab1fdc50b3c8deb1f6be4d6c0500dd646221d3435f8141d3c36f6558afc0f95380b5310aeb359d58f1af3e4415de90349b981f5eb56779d58adac1fce3911a0a7a207b9b04e20eac9233eed1a0bf792067c16cf16d1ac0868690e19a10891b0040176ee2b87789e0dc0125e18c0f22add8e5708f825a95005f184e4225669d0080951bf058803e4ff4408ad004dd005fafa8e81212ba05271f61db0b119490090e8b9f19f1423c2b6109dfcc135e794ddf677efc466ee8431201c9eb23fd3c2e915aa878278c881195cfa354765fd9e99bf0886afb2556e3c304bb2a62224f06c4a6a12a1c117496ea460d2377888bb92f21cebce48b9a2e8b0af3c0c7119191f2aabf04de5acdcbec412509e11f46468db8303f9bc3482d484f11a7317cf7849b985a93a8e3dbd34bf8b013ca1adeb236839fab5f6cdd6da21c57a1d12759770a9897c9dcaf89d33584f565a744daaf8494d5bb461d00c04aaefa958d716d121890bbad8ee489023a9cd46758fed35bbfe076c0d3cd32d92db911b67e5e8b556a39c697b4c46555c8a388fcf589b44f2f9303a40a4a1830de572e257f0c8ea30acee6b67113beee6c76b12ba8db48b1242ca90213395b0793c69ec23f0bc7c0a0e85d61c2913219838ce331f3ba5225409e34d7960a951ee2dc9b23b87afd81773df7898e992fb34b8890aac0b39f5603de5c50b457e108f5499eb66171b13c98a9c60320688f98823303fdf0ac12faccb0416ab6a532ec9dbe99afdaf5f8221f73f252f04e493345fbc8984187ea2ae39857db698b8d993a1cc1f311d0b932309306f56db87939d8f33d94dc0d8ecb59fead430985bbc1d28941c9447314afcff4d02b70b0adabeaf89b1fc5ce191cd37025ca43121c046c6c7427b6f9a3aa8e723f703a986edad1843707b675f42523cca9f2d15dc04c38c9c3bea9278f3673f329eff2de7d03242eb72e7813ff2e5d68e9e5be0d242aca9de0cd3f95a382d91d14829aa1a517a9a4530673cc4d7d5927253baa81a4a074b4ed8501d09cc1a6c7d071f0c26b8581512e52b22790288b08e25cb935bc5157b8fa5040367a71ec9c823bd19eaafc863a382e38f606e74c7e58f6092b0c63fdd9426fa4b1f2fa1ec59dcf30b9071c4913a137063233902eecaf96ab1d51925af6743e86529b691db6e0aa7fed6b9d296c015288565b1cc68e66fc8ef80cd25cf5cb426aa90770a3b21c96da75ed528ad6f62bab91e7e05535f792117dffe0c80914659bb12e2d07968f5254cca6aa41d54ccd78d68cbf87b76ac7e4ccdad9b36e98275992e4d2bd0ce355910de901fa0efb3c187d0f5d34f06befd1e094abfaafc56d014cfc5ce55f78e0aac90cb3ecf451e60b3642824a9dd3b4fd5a55abf150a22a3cd7e05cdec80838c5a02c1eb6fc8f7b515b086b1bc6b396226c9488470f579604988e1de5f623c5b1689b593c145276dcce0106326245812e7e992508e27822d9118501802bf2c3d23bd16e500ef024344be0e8702988f77e47e9b47576fd732095765279901fa5c6edeef38b6ffa8c04321f0e1c11c09eb248b0e5dba6c7d98730a252e320e5cde0df0a3092e5bb0e88ef2a1930202f3af359bfe5bd1a7b2bc42fdac357c3dc3326cee0afe54c11675e04931c296e80e07ec43c3aeeef711a5776d07db4a70df4af1008ef35d519ea6c23c9b1449b87fea7ca6d898abbfae571ea507bdb8c2ba05dd24c319beb9b729a146a29999609ef00b760829cdc747e3c41284b7eb6f007509b1d17d24c37b9ec4286ae7bc4d75a218dab39ede8630a29fc2dbad7cf4518bd0206fcd41d3c30cc980ea7089ee58e8bc1f305fe160ef5ce98f57b1485862a002e92618c5c567272079bc7c86e4d68f595d765a267b618f2245563bbd62f01843fa0f1473fe0fa7603f2271a7c72af3b54a274aab4eebf592d547e3af8ff834d03153ab1863f0fb0b0a9dc8ab5196d2f445de9f733d4051d1c425d0754aaa879b57b4a84d34fe6006e4644630260dfbae7abe94a4f3cbd234d9744d873182aa2f087ebf2ef3f7579fa64a5b8b44198ce32d7b1e592c3f959391cdb286dc2d4ef3d008a1817bab25f8a0962019e52a09da8ae48a66e9ad69ff563f43323e141333878a017915ce14d2cb778275ce76db7c2985e9f24f82e3c2590e1dd49de17167b3eaa22006f9574ab2dd9ec162fd598cb2918026ac85881d5e0f4209dbad0fb54a5a7e589d658f7d6011c9a9054a66b4595e0c0d8ec0bfcd8f97bbd25b62812c3c2613bb93248625b003ec12eabc0258c8db8407a4bc06f774f0e31d8a1a45d5f283bd44af7d6aa6a413e810515a91afd628d53a873d7bad87fc48db8a6df18f28368a6c92cb4d16e1a552603a3bc2a3d7166c10b83dec56249230a4503dfb3141a783d42d1c04f9e9968db8a818443309a1080cf35a6075332cacd81727728b0859ce34a31361a7d64613a008851e5f0cdfb566685523ed57ab635dbc56ad9b1f055a4dd238830f2b26840a45ca5b4b6eb94d5805d03c65d6beeb374563ac6b2513e27ae4cbfa3a965ca27af76134ebc60c1b0cf7b3fa5a5fe6f900b3e6e8b349e023e72069ec2bb43cd64d47761c1e6806f8ea079ffab6e741d05e6ddf8d8361663886bec969b3aa2716bef8d407784317908fa71e59ac3d12bc36e7cb7abdaba648de0fda178577ad34c3a77b2e07c6e01b3f32beda58831f8170ae33125ccb1c65f047c8a9fc40c495f9aefdf49b076f580767cf0843a458df4a3db28c7eef1c30727525acc2211849be9ad20ed18a60f4227bac0843ed525e01e54d703cb5f20049a92b9648def68949203167d8c105f056e45a9975e69217bc9a813a1451bbdc93a262069da759958f147d1caae211d82ad5a2c17caf6b53893007669b1d835da4f0c686d9275930e81d2eb83f76677799e285ee9f4785285f0e6bb04fc5e2cc0e92dbd6a87068566ff9171111e77429d16c80865bc01364c87e3345e8d7d26e2415683c27c8f06041ff5005c8fff40f999d24e073682cc65c3b49d0d75dc15316c18e703c5fee920e2ea8a8028833aea02e09206a032a1cc3dc0531ffd8caa2f6c95e18b6ae6d45a14d95307bc72b039934c517082028515d6f51cc9258a01a74e00bb80c28ead8e619545072896474714f3b930e658a9385c7f89d277a7a97603833fc0eb3b272a8fef7ffd1c3901bf3e96792a2fa5558dc65b99d5726da79396a9c19e325f383f29f6d1faf0793b790b43442e121e0847a22c373ff773b12df553cf3cb64920dc071c609e44bec0284c0a47b7edf296de4ca9c6dcd5f21387fced3151b3516230869701c4982b4b6dc99f8fcb2f34949dcda5657a536590478b8ec411c7522298f7fd83d44d3c68405b6e87e99711b6ac7c656b3a8458aa8891e30b48fec44086027739d7fb9c08af48fa7cd58bcbe5045e4170c98957712ed20fcc31eceb89902178a8f04ef101a588a5c4b3a5abfd92cbc6945bcd5749bc7131d60c85e6e44cb33d9e0a7b45fadfa44b2f9c62a640de2436bc0162838bc3503207464ecc5c7c12290bf2869a8381e4f42e22399f50deb6a5f803292fea1c5561a68bb46a234ea7eb0b7297b4189b0a3df72ce700eb692b1ff8f181570b8b1757dfd00a517cb8c94453f524bd3fffe97fb1567c580f51692fbea4ef7b891c3af6b1f9e19bf6b1162c4136d19186860f5954f9d42e3177edc5d080b688fd7806792db6a384f460571454a787575e0af763b5fe1c3dc0524df261f2cf12637b6a1362924b63e2c35fe8a4cc5addd204ab824065529654112268865d26df99469f74bd327db719f233fc5f7a42d3a0655945f95a3f83f61d16c3a54f92cfc4cba71b29033dfe4af3ed800c858159edd6c154016ccfc1fa65c8af346dfbc9cb06d4330d1717bba84092bac6b4c4f7255354f377a24e62eb0b8d947697384e3c0fa827001cfb5260cd01d446015e62571e4fefbaf362ad53b6629ae01c58f7f939b74cea5208c74f7019a018f5191b11494853e4a23d11b4ba6e125c41671d6509837eaf193e894cca9b61ad98a913909695f222225c3fbd598ae4453e4cc589d775629d0083c4b74793a4d09ac937c7c121c8a3720d7a776915e3625180f2c956b5510b72a21e977354f25c59bcf86f2923f84e4588ac5fbe941e2f647832607fd3ff144b114533e681edd0b2a5a767c7d9a6ef2dc946dab056dbdcb5bdb24d55da66dd2a2ffae75921311c54be38ae50f68b723d58acbc8d16c6c382934ca53009afa1b5924500744e2bf2eb2a5de8af7f66c4913de38a74327c1154d70642d3e4cef9af03c8a8f7091a1b49ab6236fbb693e5541e2e701700cc5154bcee55d079e17bba097be68b5a7f7cec49abbca5698b0a206118967aaa55718042e40ac08babe5723d449ce95bce2b2ba98554e591787052e2b0ac4b5322002b1d6a3352db2b608a3908690254f53b1ab01c8b0795d67e59bc02888766abdebc8359c9c0a03141ab902c532b78303f83acdb2d7783bd78e9deb7c3273f17c219ccceabf06c7490a6c3ece304f6e6c8ec6786f217830e6ec8a3e937fadac60ea14cb61dbf3f6388b10b026d3cbaa3162f521e5fba23fc5150c91252194787a5a923f401e0821a46aa5b717885be8923714f8fedbaf7af321022759e1337a37ca9206727fee989cb09397a896718c4aab0d0c17cd0c8087b3d727cb4c8278dc4ad81234fb41f1ea8bd1bdd3df5e1c775ec122a39dc25b4ec64cf4878978f1a879b95ed98670668edd1e0258661aa9b5017ea2c12d3a7459b2286f51b026e98cd35e9ef3861a5bc63b9b67e94e4cbffb3e69acbcd0023d284eeaf7dd274ca3a0b7a34cda8eb5e2f4649d49d2a5bfaf3186faac4c3745ef0ccf8024f04128f25f42d538cb582136239889879888718c3eca2ca699ac403aecbf28b5ae1e4a3243b7ce613bfd3c2d3e4d6a9b8544fcd2428339e4328b39f2d322eff4475ea9b871f97213f24c95425494bf579ba444865af0ff3f63246a0a62aa750176112a6ae4c041cb95753d942f0fe1e72bdb693e061a1e424b5d0d9ee17827ea409b0679c584904400ca29ed7fbd86253a819787f1322de8fef215b52ceca202a058bf73509f082252f19b8dea1f8ae425beb70708360fa5697a9daac2a8b922be74c3cdf2346a68a6723b3f387b3c877812f362f8e3e5b5ec48e91d627dab65bea8b7f1b7b89bc7083db903924780f4d854a04791f64bcd13094108b1906bf74156da3b87855a1c13e83c26af8589d4a7aada83faed5e3e9e002edf877cfd18bdf37f9db3f8e82b9f08edba0cc4abf94d514ddcf87fead0ae88faad64ba0cee424e5f63677452bc8ae1781172c8216cf28613d52015a9da31f1af9b02e7d6d1123fb466c57e03203646c78586f459fee105b7b042943073560bba155b75426f8a08c460f7c1df0661ba9ec9cca02419ae39855c0c928142963b8efbf9557d901bbf575b48544a13175e5668b2c0e2f5d6cde18f1a9b57aa8186e02e9bc4a07af451ffb0eb2a11a17cd0705ab6f666b9064dcca994cf2457d591c950d5af331ae97f4067e7187058192c091e1cadfb3dbb6ecf07e22c85533bebed76da67f4201e8a246010a15f09a00730d7a0e5ead37aaacb15128264bd920a21b05d4279b96c199681b7180201da02eee5c34b526064259fbb4f5f83ce46c0f2c10edbdee8441fe83af4e516d08deef07440f2fe240bdc7b8912267763f10f18ca2d05d6b301675299543541516d9dfd0bd20100e7248dee2b96c6e6745906fdce11122a8e3c3e3ed7c76d70f2b41a017bff3a179201f88a41a359b4a8c2079b5f438807c1208ecc3fc8105fb03b508645464f753abc58459f664c97414e4bd414dab091db7257fee3cf44ebc700e20a0ea909b6834b55a1ac7835c8fe37cdadae060501be3bf70b3b9e3a6c1e826df024c70a50666f6001453bbef41b06f3f96fd4805b836276d2f0694c5475f834dd6084a44c9eb358467ee6510f379cdf8958677d174365bca37a0e54da260b742298b3310cdfbc553be2c0140ee5ce7a41a0aa41aed2dc38dff7c2caf1dfd5eaa093fbdff10233f37ded5295c20d77c7c5926c852021e4a47023e5fc8ef0dff0f4429bbfed45b3f960fae8e85e666d931adc7e2a0f424b1d202d933e4a24128050356e79d092a77989a137284385d48d81b34b9ae48f1d56a46976f7c5ab555be2b195cf251ce01f1dbc3adcfdbd4b0f2a56a2d4cfe7be41ffd9a3e027510b8c76e69bcf60f3b79820b6776f6a59ef744e3331f3293fe11501143c19788205c5d0018509aece0c9b7a6b53595a28f1ffc223f1eb7329079d57cc0befd099e1e0f131a3d1c2cc92a399ce2b73630713f2c636e6bed3c07198d579b40c2b3c86486658d2ce71cae20c57ee732b459e289d533a1caedb04f7d1be4b8c1dc3e308c3d3f1850e32607f4208427167674039572c5ba4034063a15ab19a9d2638c8885706d2b83d0c8e698ae2efaa2822bd94d6dc8999f05f62c16c511fd37e498af63bbd6ee5c3e4b78757fff58740789a7025f1039541d6da369702528303d6230f93b815289a7816ec0a1601c3e162f9bcdc68c64204176eaa337da561780e4469fd569d718b218510cfb201b8d7613dc28c92057b926c385505aeafeca460b351a5467a3f308ffde6da53ab9e2aea4fb2c2071407500cdc19c143a819408821940b5a5a947fbd3bc31d8308152536ef94e141b35c329f933dd3a4a4684aa7c27f79b5b7d77a9a764989bddf83103ea7cca14284139492643c2ab75d02bb19b0217d5d53c689b0a84298cf9b5e5641bbea0013455a995027effe40b310a1642d21cd079dcd3955a6537642bfc1a59d5a9ebce90bb372d8c41fef73b44ab60f42fee1ff7075573fe952d390804150a340a40526d83bb9b418db62954bd9faefcdc4e85528ba2b20f27df118ae90d9108de7e70c6b1132aad5275aaebd0d805c0de2a1563288a6b9bbc7d151f2d13ae4eb1e6be1b535855cfcf8749b38c43170bf4ce608afb3fc4ce88cadb8ebe0416a75c756c286cd2d64f9fa0c309e43e1bea59b1022b14363dee1622350a9bf811bcb9562e4df906c9d5ff0f4fbd9eef3d935ef555a7f75a463cfc302878078df6b7511eefaa3a1ba5f6a91253919b2537b3dd89551defab3be9cdede704c0a1d89d74565063592de0c9c093148054cd9f79e1907b88a30e9e88cc491c696038a9ba74737c2636663e1a3f8618723aa24ba869cdfdfacde0a6cb2716cfa9dc401a12a07aa244a102819f0bc7cde099924ac68733e583922d773ffe4083fa6e4d4985106f6c884a309b90d899458738ee8454881dd6ae44237d1a1ea1aa9cc28e5d59ea886f6347007a9e277e5568df4ff80567f88db5c26b37ab4d864e6534fd9cd05af432b8ce3baeef8dba36b137b3df67fe09ecd25f9e48eb616217693f7f1d1f9af758a0c936e9bc7b8c21b4887b6ba42fb8956bee2329208a2aae90c8fa60777d04f61d1335a7023324d5d8ab039c23a4aa54d51202b36a1e80d4a8c4163c396d17805ce6ba6521510668cc6222fc8dcb9d64d09827bb0d36453d5374785ba5ea0e68a6daa1d298b250e2c025be291c9027c169c502bf868be167e6b974bd01b091b83d0813cfd406a539fa8c2d506dbac10f6cdf306d68fa0a237c723b1b1335b5502aad4c9e4b38801b03e9b09b45e1b1478bd5c5a53dd2bdbb0b3359168263dc0ec98253629513223175745cf10c3a62a10b359c917264476a59c6d11c8ceee9110f82804e8bed24cf3a3ed4e48fcaa2c95872db47a046bb03e103ed70cbc423686a117719595e876f8b6c91d799883d3718e52b114bd1ef1a79dde12c8d0f91f0c3cb4f0f21f7212a90cbea2f336260e60d244da7e154ce838bf016db871c8b73f695a3459c5e3f5f44a418ca2ce841b55b280de511fa2da1ad01bbe97780d2750f26776836b64942c1c6a925a573dab9967acaa3e3fb8aa2eb3012df5d497b6a7829898a659183d3279c625f4fc2f11f558df2f65588abf22e2f389c0b3430da87d6ed5af82aecc2f11beccc15e437294641c6c3b9ad16dd5ed880b9228a52aa3da816ea910dc0c55769fe647dc52e8e7c80023144df49c648656250a94dbe0a71a20d22cf6eda3e5615854811819c75d08f0829e47b4c6b255e0472960afdf8d69ef5d7762c7a2628f43e7c70e661d4d3eeb475ec1ed00caf0db4f54413dc57a5a8bdf1c1fd56611dfa33e4fac84752ff45ea610fceede5997c2f0d0b2e2fe6cc4b97392b2571951308ea7b971b360b88b409b53c38dea89715427f32ff9c7334450ab38529c4793cef6e240279d369e7a5ac765bdbca5465ae7933687c28995ded5bf05c537b3f5a210059c7be7b4e3cb51535802696586bb55741d48332127ea9c4e3a5df3b7843cc88ff3cc2fe3b22e784ef93a1f0543da35d7dbe4a90431d366812bf001146141d58170f83b1ae957b01d2cb188936401f279c28ac722f11650fba88215ce1aca765c2ad27dad1b82a15c3ae54cc201e293113f6654fc29d7935ecee1fa9e287bd89524337090dd7a212805fe6d2a471a14986afba8178086990af9bcb318149165fe26322a1d3c1223909d44cf44be92d1896036c6706004b6b5e2ee23b1eac96d817b2252d613d0f7f5b40517aef0b420902504893acaa08bdc0ec442d024adc0cdc9ff8dff31c4e5d2d27492c4a1a1e5470067cbe05072f741bf7d389c048a580df792abc00ba5d8af735ca1b2a337257b0318bb0dfa377f8522ce42d52af438b5f043d2113bf83f9637f413a7dffb59a5cf2a8a38fd445257ddfd41c65dc34104ec22e4138ad6ac1c370546f0621a53ef4ef4cae3e68f31cf71799fe21efa65757a4a786a5da75c4f3ff3f0e979cdad01a93bc959ca6fcbe056bc88cbb07201c8e6a723dfed545f386f4f06e10172089bc33013a4e981e6ad197138608fda49bf79b575eeba516e31ebdf1b993721e3a8905dfdaab10842393c087bd1cf5926afcd7968e938f90b33785c9b062113453046f54b4cbe9cb17f337a308e958e2c32f148137c912ed8528ecb27014be7b9809a574fc095ea4560ec36e6fb78539b398771a83b73ae9c55605203d987f7c77e1120a849f52f74390949f515080d0b5f303e1b784d63b212b938540db1ff25f0697b774855888f0c61ee5ea0fc22e97b691e0f6c540e87c1db22d947d77082ca9470145d40ff40fe326ee7d2c0142d7b4787a6b7685eb360e775a4bad525c6426a84c8e16804d118b54476d50da4315aa6c881430fd697d83af800d915bec6df03e389dfd6be0dd0f114809ed518b260507452e89b8661b74842b5cc16692b9bb9beb1db9a03fc9e751a8cec0ac8e72eb609d3df5ea5e3438c02e3f5581124544b69679a0220118389b204dfa142c90d0b7bdd98b1f06a5cb8e3ceebeb085e0519f2666fcbb9d3d9598f9ef263b53b6b648cdbd6cf7fb649dec001abf55ad210a24279f3da3ff50eb9583a1553f9e7a4e1ac99d0d8a61ee62909fa3b9432c97b7db351c38e7afb2bb0f5e2354a9abacc33bd5359e39c030b54d8970001336bca8c6410b1e39c9395e26444477bfbe0c83637997f0b7c95cc184d2c09b6fa515c221e3d46a9af69714801c94b471f0caecf729d26d49f523ffa012b804961079508c1e7fa7ebebf61d4ddd9ddb592fb94ff5589ee46491d52698cf5ca629fa839200871f2a5bbb9d77c52b38090ba561439cf9cf998675c8d7c970dc40b7dcd92679e1c32d84561240b0359c9e4676f720e611079702769bcd6f113040ffa13b237af8100c0ffbe11a72803355c2fda39c3440f192b9a7402ec326b8b42415026b449eff19b4c03959fe60eff820928f1abd978aeea7d590d6fdc5078cae5e5999ef2d2be62fb874f142a8dc171c786426fab5749e59c9ad4be8cef71d018594728d7b4fbfc0bc252e1c2f2989f5c47fba32beb2ff1af56c1bd1ff5708c5db840bc9d4663a0c562579af818e0c348e5509ac2cb00581ccd3242541a58b328d2ffa7bd784128ae69c509fad88000d4f4166b7727aeaa14664b41d046b15c08e7acee223253fcd300bb6f38260d6e46239d2be854d99cecb9899453e566737034d4dca35414a840397d2ee92e81266baf63b4be051e9bedea2356462cf4c72bf5d7a9a3af803a0c96f55da8db109d4922b845f9090dffc0c68faf834cd25b6bf2a4d84bdda807feae09c94a951ab77671cb5a296405af9c62c1a184c0185332a2e17148ebb3c5998acee843da9667f114fbc46bb45647ede1df2578edf22782cf87c1b79cd6ea287c26512a20754b28a7ac93f1668045c85eec62ac07998775267c1bced7ac90d988eb21f9b0903ae890967886047a235372079c117c6e052eb13da748e1fe444ff6267d208e0b8b7f6cc295ab63628e800634aeedfcd19d3831d715e503ec995a6e3ce779ad69f26b028317b0cf56245355d6fd2ca518cd180a4df7507f01b093c07a1b0705c1d493ee900fd5a3b899a33de981f7f305fec4e4ca1d84f8d2987ab715683bfa6ed794b4ceac0c646241b519ebfe03b151b3191ad587db2dfc8fe42e2383ffc963e3c75721613ffee97e305ca08fde6ed1383447a73d3efc371eb1f7ccd3c58351f864e6f837339add24cf3b40abf5fb279cc931c6df84c7e8f38c3844689a8b91f64db132db09cce3a95b09aa44231db2779a2d0b965ea286f77cb27378f4f2de0f3f760c42c4032b408722c625a1c7f9880bceacc6f2c259e968b2a3b064ef6a4b2ab19ae46eff71628229b51b22f7ea131b389cef76086ab43ad4a6c5b149e9ca1273ce17f1db93f607c04d7461e8051da322b41f56cf7e01df004d4110d0c2e463068283fb4815431d669a19f21368d00afdeeee1abbbd46efe7518909d6090fd71646ef65accb57ab204212ce9f79d12521e372a0a72831b0ace0ee4a999e321652fdc6993d344613d394de2e4f28f19528f6dcddb314e9f9b7aec1085aecbe47d97880bb7e33bfaf383cbfbbdb0e287d50ee9a17dba9cd746dc2023542a366c225badbc4019f6895bfb0e30cc8cfb4cbb18bff0c0c617773b74de8a782d480a45e1ad6e6e6da055dc107e1e16b1ab7764572f397ac86851dac8a229d7041c543be2f117408e2dfabaa99b744d1e7ab708ec00ddb4c9f1f97451d3dac81cdee9e801fbe21f8300316e2d47bd35768e2c51288c48f45c0dcb2bb08551880b320ab75331bf7c20f460b6d74e2a6a9ac563449812014c84cb95f2a55aa66dbe6980fb9d705ef6eac727e065e715bfebb39940f00e40ab7c16ab8448bdcd2f466e035d069469bde52c57209ffdadeb6a0710ac0cb0b8a5b117233c03987838540b828df0e446529dcaff717824a3719366ea1fe6834d9a6ff71a29e7b8c2e56804af9877ed57ef2fcb52099dea802e8f02412459cb976be951f3da28356192f62c6d947c11b82c7e5d9dbd3d5a48a9b7e9dfb90bb274cefac83e6e577920ee1828024c3f593d0b802a71b40c7b8c6ceeedb4d9d12783261f657246dce6332aeaf33c2f190ecc81ac4677b235218402b7e66b4397ec80c45fc2c94f3e6c35aceb34c7baa0a84562dd4778c3f9ed1248a9f7e6d36f105d1cee894a19ffb1a2b63d03062e8d3c6ea4899a2094ce121545a2a864adc23eb1a6e4f27e392e968123ca71a0e0b7a0efadf81ba573cd6a2c23f7da8065a67979e6d55d8e69442080bd67b7750f4226ea80df50f890ed1bbe187246d4a8ca96f484fb780d990c3c446d0c1cfe66463448eb4981622caf001cb2d4d1e7f4c3e9c8c44b3b8415650f89f1a9f79e66e550fb073977a42209b887c4fc9f400b0e6e656d9aad835303aa81d6d04ec0be6eb335736164e74953370d79ee853e88ccdb8a70657a570f344bb74ec190017f44c8c6436302a72a644e868e5a40b2119b14d8bf7c6f554861eff1c4db392f4f1b100a4c88868464bc8b71888353029a4b194a21772e56db33108a2603e416266ebc56cb16c49d8bd939e8de77999fd8700bbadadce447ee31e0cc33b66e720c9ab693384d4c816a311271fbd6381738a3503140acd69227d18a28988e9cd646d03684c933ce14d88af8c0c8e322d1655460c09631403d01063b24127e7cf850e27a4f73ae7d915a13985ed4252f1b51153866589745173d031dd233c77519943c01c02c3703d948eb8f6d964bc8de05c7a4077f18027ef5c1116daf3fa788bd058c8473ed2a679f93db5d5cad9439ee26a74cb77dc9e0c735f87519eac266ed76ea2dbd67e30da310adb93bfc41e931dd94c4d7ce374f0f5e219dbba9d76559c43cd450d68838808f03c40c5d40095faa63fe545fc1951c35e6224cdf83f7f2737fec6d63af93d2c0313767b4af4932007d337d01e95215bb4dc2f704bbd869c297693b60e3c81b43e0f9007b4b0a6e241083de00f236f4a1986b1d30708d1e924cede02315c7acdf2c7b8718550e192c18370c2d054e74ba546a71a11a89b816a99d370915ce899e3cc5d1cd341bd2a6288255ab42fd82532a956c5672105db889ada3cab6c783decf5b621619984112e0dee377160a19b268890c2ceb87abcc829aa8871dd5b3d9e0ac6ba03c39f0096b2bf5d61a812c8585a8544e78f6a237c7dc44262e9c73c2cedda12e9963ae49d52bdedf5daef7d363a960f4f88baecad24e3f128f32c4e04a442b1148d35935329f1281eaed65ea5e61022f7f66b861593226579bac5426743c692a4e64f1bc0c5d0de12cc4289bab0b95a48b72708a207b2c1665ebd7caab8fa214c367e17410214f8ee9b81a5a78099c66d6da2a4c7f54b1155655e5c42e30246818bab9f303798533cb0062e10038bc84c3f477f80577d90a8ffbd00492ba7c8ee0cfa01fbba6b4bef5a64aa9e6bc84fff9eb65fb591f9eb6744452c9bebe592ac4eec521673979562105a4ef7a790d46c1b670cb07f41394a11f28227e3f214b423e65303837b377f6b2c7763e6f99ec69a1a7d96175e05a02ae8bc993cf33acc6d39ee3ef88591577c2873bcb6ec9e917353a45878246836bc9eee05d28c05340039e843330687ec2915306cc4bf38d4863919f482688452add304c8ed025c20d7e27fea8d8bbb8136269e185b6a463978619661109de6fe6f94f9bdd47981e9388395b984aa0720ba547d0c216719ccbb08da52314543f439f7ef1cedb35becfd4d27af415d8cfd40d160c9bdd54192f385479ac37538488334e2d4a82277004193b60e83be1a7fad8b2d7d9ce1b30223d6c37fce5d6c382f7e1a085f7cbef9df608c4b013483337df86b149a09295ce3db20dfd04e89edb999f907390154c48375e608c37027b0537b26c8098872660e3311a35a300ee3bc74bdccc512487e0f7906046ed14093d368ca2aaf9e9b1f9b54e5960186becadc7f67ca10aecef39b206abde3a571250084be3b3b4349a813e4fbacf5d0590cf8b8e1604d6bc456eeb2bd147764a98e7f1618674fa4c3d048390bad6db5c3c9ac6a0abecbd2564a50a46d51b2e2603a57a8cbd723b6a680c51ff9f031ebc1f1b4843249281dcc37788cc1113def04b5b41e12b40ab39fb7d01bcd71e68521fcf0f867e34552b11761180e1cf821b49871a015b59a9c0a053102e36c9b6a510e47cc157929a94097d10a71ba6d4106daaa595e5b37e33a61ec260f1bc73b53734edf4029851692f3aa69976130da0ac304e0c0075796e411b54fac6f74b357849576cefbdd1d784374f267ef335af13ff03ba86592e4f61dbd521987e97ec31a9c7370a8499efce2208a5dfcf73906daed796c5c80304f7559df4e022bdfece7ac6a60c5c9db235fff1eb09ad849764ae7285aa5e7239f843b627f7d02850bd2b2ff5eb294067e171967117feb30f5d94f34a72f87648c07a925847fff5246131b3f7888020da07422193396e1accc6dbaf21e055da443af14f4fe8b77badaf7ca97dfd37b979da4dbbc07d8fa16e3dc9fe012081684fc346291bdd6fb5d979c9e041942164ad3818aebc26ae175b5cc5ad5ba5720cb02a29fe580a264e9a1664fb12a7ad0e8d040b1f91dae7bf3b6458e4ef43cf265ba77e08bba10bc7a5fe9497725547749fa92126d77a69a2b35ed4ac211c67ee3172559f285e1efe89091a803746fe4ab02b29298f31a867d9b1069659708f20896ed067bbe8d09d50fde573780070792579950c3a8854b5b17b3ed919181eaf9f74ccc0ddcdcfa8b8c2bd7d6e9fe50f75057dfcd2abd743a6f104b023171b6dc8ab472545f1eb94856846015e618264c4551b0a3e69b168d07b62e8bcce2e5be8125fac7d3876503ee653212b655727f6aabe8b9abeb39dcebe268170d1265ccc1d93a374498ded30e2d25b7178afea3181180a49cf256edbb883d6d47ff2cf99249dafd15a99e3419b6035de68a18a104fa90702c7100d88c91e72f3f4971507cb063a9a4febc544151b3e104b3386e5551ef7d81911d3ec9f6ce760e4efccd959f0a5d24720e48b0dc5e42288f4a2f86eec07fdaf9d52bf65c7641348db80293a0204e670bfbb003a3e6b2c944aef6c0a1dbc47d617232d2bb2cde2d75c24d90723a7ffc5657c46da49ce1e4bce3b01bc2a2bd9385e1ba940a2415b7626135f229f3ced5bae0c3d6b56e2ad1dbc97ad99d6ce4daa7f35c313bd3657b5bf1a6119b990d78ec31f5cfafd03ecb83a43768e1c1d9b5ec68ff7550a05cbd893c60a9f072617426436f29cfb87b50011d3d9b424b1a03a6f7c384f8c4fdd92f13b87df27545ed70029d202b53b0bb84773d6ee79bd4f3b4b007c5d2d1b80a6432a4e4a41f58f157f0590080179b42e213ccf68678d09c5e3afb8b652115748f4189103a2a4f988c7fd7fe9f2f3c5a5b1bc8ee7aa03a593dbb6ef1865a459d27d4e948a283a6d881dabfe1d916054a1ceabfe2621f8f3c849b1149d1069b979b2380030e40bc6c5060e6bbad5e342625cdfaebb0c738fbaafbe6c4641ec1efcafa3e5fd6a9469f1e7907eceaa2954d8dc72fc1f91384f4529059550f9a07d8250e692b9c02ca12bebb8951bb547af725b375ba2e4080213f805a7739df35473cb5b547e9e7246bcb62859dec662e5a609c36e9ff6e7e9e7ff440b61000c53e41fac18d0535c490e14a8074f43fa8ae70508a5f0d97d3f164228c7101492a51e9f3a4ae4d451684f65a42c0c90270a78cc4bc931500a0555f2d90bd828b20a8b8f65e1665f49337d6c67341ebfbd3781d5ee8e97a46a55981312ff8e028b031d01c20552c85e1a29fdd95ae07207174269e432908543db36c9e6780e8b6271dba0ceee655b30ee2662704fa2f586c643fd7a361ba277338a37edf5c9f269d032961451c16cb2acaecfc9385f3cfb53d19c5138abfb2c06f33daff4c500f8e1ee42312f0590eea7c3bd5a9618f953c8a79c866ffa5e09854c2c3799134aa98e713dcb56a85b95cc04963233693da45fe26f47b79a0900d48ad3a84e449106a074c779a5ac8f49dcb4b26b0358d979962542ebe3adddaf003e647188542de18eee23695fd6af0e719caa6cdfce70bc129fd9cbd476a86dd30bfc844cf7fdf33505621301d5732c4ea75831853dda7325ac9e81da2eded032473b86ba0c65e182918942cc2e7784559991a012c7fdbf8b2b81523685526bb885e8e00e39985bf30ece110ee797bf416f6b9b57c47b451931f23133126f52ea4b40ea3621ecae263eea15221df2578c81c9120f9e2a25f73656aa97f89cdef486f438c4c046ac89d372797225964fff4f9d29f11d967a6aaa93f5a8f6669044bb0b923432505273a2d41ce3761d1fb152dacabdab72fb2f45853353933afc3f57945aea27ab9669080d97d6f10440c93e905547e3aa728f0f3c2ca2360616dcd035620debd7ed2230d498664770d75325db41f7a13f25d4655edb8a63c51f8737664765209db6b346735230c7eef40b0e2c66bbb289f54808e18f4694ae0450ae9111618087047d7b10f5226dbe8523f656367b96482dd4cdecde8d5dedfb9aad8620678e9ec0cf605fbda5a13480bd203701d9fb76bd6ffb12b85e62a87be441995060954dc224949936c22c391dacc16d1f85c68d12faff4106e7869b21de2bd3e858c7b475da49b729a2792e976c058c3e42c3daa40520113e3aafdd040ac4292e2de116bb7f85831d2f9f87ae7309cb50abadcb5cc82b24ad58c7582b9103366edbd8fe8e13446ac9c2e8947c3f4d3f2dd6a71f8a811d563ea242950d58def1998bff7529b09f7e28e1915ff3be5211cd7fdcb5660c66bb148a0fc23a48e58def7f7ff755a392368543c44f0ae8d0ece9d4f1a95020199e55eb28de41110d8a34969938c0daff49225798825d933dd44ed03085956b05d96293663fe8b2d9ed39b3e4268665722d02fa764da91aae7881a7d0d71c290aec9868cdc6f250518dcbff2f78906efd93844a16f4f21cb609d49ee94b5edba14fbf4064b016ecb1ad2a97fc3fa5a66223810e89f8b58e180acdcff804aa6037cd2942a7b5dab22110ad43e94a8c6b9ac4cb106487d9d4a85876d364518c37acf86fe3c2fa4ad5aad40a8e76b1845bcd746f78e2d2804a1e32a281faa1762bc8835bb28ad0288619c7642555be628fc90ea5d0dbd03a68766334fd2152321b6ae12d4f1285f7e14af5f7514a62fa6fe121379089ff46ed594cefddb28893c1f0fa478a9895692885af9bb4bcc69a83d75bd36b247186841ae2089d88cc5a2db6c6457099d85f0d88048b6b9e7b9d082e5c5e1063b5829bcae9bd874b305efc14a0e6ba8b33624dbece780d9905b78b43ca0049b26ab0fb7400bafb34270adea74daf2bbed257c3de88c9cf4ef9b7efac4915c0ec50a19aaf42da35f77d3b697bee84cf59ac2f14e0e6cfde61e114162205e487d7195fa8e8557e007b912b600c67d6f1e8584950a7753dcc94b183775f26a58236a12bfe8cb3963ccbd836519d641e6118a48374b28cf9259ea236715fae60316f35ca242ac7c742724157da13d31279a21897cfa6e30ea6b46b1130d27ab5d86178fc3a89e85cfccbdbc50441abee6cdbe09ddcb3f3b932f5b4900be0d8a891372af4e3f28594e03c43777f347767380e0c7be970688d7be075751ac0bd3b47ec28bd89f49bc402c6f8a5e30f0318346c03ea58f67c59200c5a351da479ea795d76d0767b87e7f8591292efcdf5061f733a9998111363867f9ef867421c98457e7dd33eae77035c01e9db6d9401d8c903083b26692b6d3a3d20e4ff5c7684bb5059405d1996d9b6f7de724b295392323008a107bb073554b941067b5501bba602d29f18c764dda89c94600d19d9460f18292f24604213c45a2d2145481b3d42a07cc8c2008c94262b1c7055f658263e9863822257a6d6009923c3962686c041c58044125b25294d7a0a48e8c164882174ccc8a0260728b24d05e464b1e9b0840926305b8e2841831b36496382b0a3463a1423483133fc30274f921b12246831a64b1492305ebee89046ea21410f97113c89c1818c9b1fa2c2e07c64b1790375023415909202d2ebc8d0058e193226608a414dbe21062b254b9a0011c59910442191018a951bb6dce991a487343d405d35ed609708a5d3aeb395fed71fbbbbbbbbfb7dbffed71fbb96ecdeccbdce59e4defdc084124210f1a3082e4a10c96351b65d8b908ea702328a38468ce0c9861ecc0c9901b9a111d3c317a523662480a6cc0e363a46b210319339682122e6081a9612305609123200c509967c6192a50829163cf12427a44c12932392cc08246822f7a469099136702830470a6a8a1534418458aa1e51ea04c1e48a898b171866204001c60e99293d3b5cb165a4a473e4cb1d25a4aa5cb1647ae010c40c0e629c4800664893004aa966ce9981cc7288a6dbd20c9cb3871e6cd8336b581198d954e384943cb386c92a1fb309444e9eaa998c259adc66a00d1dc603290b96a6590bf486a55928edeca4e733f6c83288e8a14e0b3d2713387fc80331471eaa924e19434bae8e41ff8be81bc952485c0968993e0d0daa9cf2734066983decc0f0db1b63d957b0e13d9da351761846353448c1fd652c9ee07ef73ca45d18760ccfdf3e0d61dd7b3b2aa53a4e9094d2399dc21d340b29c17687b52cf0e898dbd60e9b02083b01a6c34806c3c8e8ae5033a5a20e1e1df3a7227947ff3cc154d6319701c3a863ee7908091e8d4418aa7345e977b740c023b0200b47cb0861b455b3ec18defca4b8bb53e9ee2ee59116af158c44581209e5f6f9f9212222924d35e0ed580c497de8071ca3769a10508d9586cae4ee71c0766f7964db2bedeeeeee18e6111528554aabc3ae3c9263a6bbec1180b27d80b22b4d1e9101b1bbfb03e4cdbe28a5dddddd67eab79431ead49ea1b6bbb7a39607b79549ca39a4526f1eee5422a0e7a9d16a6d753a77408117f94ff1ff00b463c8bfddf96853ca1c6dd27236eac202b7204b6beb47eb387d291a3c2511b6769dad6b2aad469c802faaed8cfa457f13b9888ae0172fb2c443bb852a6716f0e7768cfa812c6354caaed4da4ad9501769cf5e878b87e6ac672fab2b67604fd9daa0673fbb7ced238f7c7c98405934e24b4446c979e3ded606d5c7e5d3d3d3d3d3939494949494941414545454545454541919a0a0a0a0a0a0a0a0a4a4a2a2a2a2a2a2a2a29e9e9e9e9e9e9ea0a0a0a0a0a2a25c0629292929292929292929a932d4e6555e7b7a7a7a7a72a8a8a8a8a8a89965ee5bcfeeee9edddd3dbbbb7fceee46024a799ba224870fb01f6c988a243c525baeaaf29ad7fad6b7acacb99447999b2f871899b65adb62709b0b148ca23a9127942b1c142f382853f2633e1a8a2d779e3c8699ca1fbf68cefa9fd4c92d636cb09a94ea505b95d7fa963597ce00c96388c3bd18bfae4c46e3beae601e1cdc8bf1ebf5b331cd692018b4c49586ca1c8c0b8a30e2822e3f248f442fa2d76fe04a5a19939b77aa732928d9ae9a9ae0aa20e9aa0c196354e8cc39e79c73ce39e7124e53b82a48b2c4556932e79cf3279c40e10c0ae76c91258ec9092693aa15e1140a278b70b6c0e394e5f4c6894a01534c5813c05119f394e777c0d494c7508a6d0927a54896382940bc2c71525ca01da54e143ab82869a28c8962e5324d1b45c9898459e2a2c4c0345e5b144857e2a4dc703630389b54104b8e2c512261ca5296b829b52c5f886519e5476e6589935227cf0fc754997aa4145f2610542b3565894bc2942449921e9228e52e4b5c9220149704485e52471e51c9e244e5490e54945031a22484ca0c545e9892e74e7962bc594e713385893c9f4e2103aa102202299c98ed4e3730f4d352ad13ed8018b94e4b4e439a9c7e38d18008f16eaffbe128403b4bb606356137a7c9047806312dea03d3cba7e98a368db93fb8a61b6eb25d20dc0cb5149e9110cf92147a829a8c0435e10a8584384b5c938f7e8b87b210a3e24a9c362b7254e6e5b2e20a92dcaf84faf02e2b42536c5786e02b356426af70a4f9ca0f6c854e9c575bb9caad222c5ac02ef0815b5ce042cba1162c5e442e3854542e2830d57481f8a1c4274e09903c5e5c123cd993c4c923a59ea42acf17470ce4dbb12b4bb02680b3d254a59625ae0a2d4b1b9d5cb3c45991e24979e2ac40c99deb180be09c53a6ac0881a4ad0cb102c4abe07962421953c589285992b654b9caf34169bb664a9a009847797b11bdd20c60d7634a9027707c10c2c44491590f209c344942e2091fc0b06962a7ea695961311365b12801635f2f6b75f5430a6eaf8f05b9c9a3acbb1384772d8e51038646cb43a60d980c8049c14d863a7bba3859219c0c81a434693068c84217d10f4cf258646f007f84e8eeee3943f67b6ef94540f9307fa2dcfdb18e4d993c2a923366ee2792a14889e4071da37f8a62479c72f7673b4226771f6992bb95fb4891dc1f0295935e4bcb5d8474277ab3c91917c0a84dcea0f103531bc5204f519e2d153ce091661773d0922b5ba1cc1838c1630c833cb855f080e96de6790224c915ee890df704c99322990608caf1d5ae2ce22e2a72c0f3e96bbaf7abfde5f2290b27b85fcc9867ecdd3eae1b9e65d46a1fa4300b93393619ece9b2a90f06f2a89fe60a93330a9338129ca1d168b499adddb708357a4a56e4b61850823fd65a70d213fc05fd16ac047f21a9447077eccd4106dfa78939ed88947f7e96ea84133a46b309b9b36209176642c7e8081da3325b1d1da31fc25210a163f46153d87bef2b4c07529e011dacc25a1eb95869b656c4309a7598f231adb55624b9c230abff018efa228c50829ca1436265d9b1171c2cf3e8ca13d78548eedced2a9a545fbed0bcf8b7a0f10377cbc1ddd3cbf4ef98b76c1051baa3e6d774ff29be3a56813c5aa1f34844248ffc2f7e853d0694451a6481c9c1a391919cd13c5a906aa0fca0cdf0f368415629c18136c3a293fa2d4c1fce48c19a39694970fe749086b2e5e1c8fe734eff9f1df50736e2c8e03b4c876cc883d6fbbb98e37e4b1cb22f7398023cd481ff7c1b306a747f0f1b9aa251065f830f266c7c2945719c1ffa7c0dff8175ef03db5173d87d779d08a3a5c1073b187d25f49f00aef03a028f328f3a6479a87bfab2136f641c1d63a4118208343ac610ee5863231985c1406214850d609a820052258a1369e60a9a354d44a12182cbac1f47bf08fd44577834a28dd0b822b8c828b24ce84fa1637886491c173ab97f26b951c718fa5cd4b23779442ae1041c22ccd0ce6b0fb86497b60809abb664d9f3ea91c414448e0e3b4c250135e7a94a902d409ad082040df2a6c41b20779878c18c9408a839d3250923d404010496f25f52be94f2af942f6b20bd8f3b6948483a8a2cb843e50d8522148ae6f78e9a43d87d01d797f6667a5b648007774fdf0333cf4ecc41df8ae1f440cd39a810f0fbfb19dcc1de2fe907f827fdac65b4f8235b1b7cb2df832d7131e9670d566a671d2d4c52d8ab47d742770f01dab82ec26099bd7eeb00fb5dc02848aa1c2d5e1fd307f48119a04c11b4998f881ff7e83cff5e1b1e6fb6ef8d821dd8d0663d6508deeb79365e17e801766a1d939fef7d29bfefa56c79cf654b2e87a038de4f1cb1275ed007fe3cbe50134cd0663fbfb3a2d77f893f59de7039e451deaa5adda5e99016c1e5836ab28526450508b7a576ef802d297cdde0cf5e1722de94b193644e12df9c2544884833c316372f3c7b30f1810316951de01051a61651072aabcd9b2d3480df9b20e78dd5d50e6cd2e0547022883962de8c892a22e5c03102c3105651801099cd1f3554a1d38588317582cce65f3db8e2a870b93cd9e49a8b194de5f945385c9d2c7138ac2c234b9c54557e06b8b2df2bc5b17e771756b3fbcb0dc22278dc51b38b442dbea81d5bbe204b5c16201997e52acb2d532d52783202b2d482ab652d352d495acee49bcfa46e2d5ef2fc9e166bfefc992407bbad65b0e02fe67cf9013dc04e9d8ec93ceea8597e2f3140feacdd7a4a6ca23db848c790e2121f4ee4df5f83c30e6ec61d9bd25b3668cea1c395edeb70f5cfbf17e3d7eb3f1693c946a41cf675648b931a927bea8714903c67672da594524a252ccc41bf1b36bae854722424992c16fb7fbda64c7219932ac965601a8d46a3fa68f8f3d8b7cecd0a60b052a2872b38787ccce6f7ada758701929f40b39afb79cba1f6c2d0b4b9567dbf343f722055198d1d244c7ea69e6e287102172a64429e247eb4d6755ddda80372c3fdeb4eefbf43ce5d1abd65aebacb5d6eaf265d3bcefb5564a29a594d2ec1f15af7eb7d62b652da55dd775b441eab603e795aab565633ef87dd3bbf7de0b48c8de19afb5bae7bc2536a02bb1bc4e0720893543b07a77e7acd55a6bfb736bbf595bf23b527568d9f0afe085b9c85f9deeab7301091fa4c491ee8a41544bfc30b9e72a020bde9eb2a3f57e78be3a3f4c7572ff0f93cba859fda23feb878976a7b2aa2dcb0b7a78d35372555589c59566d42db97fb42981200d616e545bb15a450c5a3299ed3c04c8a36e215d2ffcc2d42d40f2a8c12f84b9c82093cbf8a1922ffaefc52053100f78fca172c510e6870a6472d19564064fd94135803de5477da858bd2b927eb10432e566029bb48c9f33fd43553b97e783bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb7ba54e29a5b28a129c94bad08367659254f248bed7847e1dd87d201bf0fb3ecff3b2b2eaa5aab5de5afdf6fdbeeffbda51fb300b6418a5792aad8f359dd67ae5b7b3145b25bf9696f16cad36df65c8598de2b1355b9333a4add9da550265d108d67283dee77d569fe779754f962ffade9aadb90cab646b456ccdf33ccfea4350f67def3ab1d8dacdda3a654fb0e64501bb6911d0bd9c49b50432566fb5a963dead65aa9a5cc72a12f52a779bdc5fabfa00fdf5e6322c09e40b3533676db8619c95a3aab99b69cd5535b2cc5d037391675247e77724f78f08c8ed2277e2b764b32e956eb1ba3ba5e28fb4e5400bbaeb22d32aad76d6ab4f29adb67adeb352aa846343c35d658d4439c534c0ec3929a5b9a2d8105e0e470412382290e08ca023a5e5b36e52cc0c649ebf002c4d9a804289130a9298cd34382f28c8b3874895964903d2e35be4e1448a21f4bbc8c39f477f0fdb90148740a05f1f02fd2e8ac045e02404ffae2f827e2a0ec99733fa7226b1833639b594c78e1e20cad4cacc7ad094247923850a9496abd90b36b871c2d9a68e28c2004f9a3c9112032509a55947a91446c78ae61bc9608021f8351473805f413126fbc46e8c54e353c8de57d858e479de73505dd440a441234fd1750517758cd9bdbd5df75e67bf7e153d40f31573d8a7f6a9e873caf6a95fa31d0c631dbb5660d4539e2f7d6c37a3765df7b3b3d10df9cf0cab130a970265d1fc398f9092832d4d6c7172c1690c9c3225404114b53864a8d0d836243011a68920739a4842c9163b6214279092924a9275840d09524a49420ab8d49cbc19f3e5470e77a46690322741324886040389468a142f17d18be85d41412f17d18be85dae77b56c107d517871885d5785516c85900f983e48ab6b127dc764155d42e0eb0a35c1f259b440189ab568d1b2f14a847c781111c99b7ca12578bc15b87061416841adf56b78fd50c807fcad1b5e7ef93018cc021715100dc1602d58bc84602b54b8603058102c05100c0683c1bab726ccec4df104ce4672c30602cb16e56c323b22b484a5900f58ce293600dcf3a294664a1780031132392b385335cc1acf13244c809be1853b33da44a64a73327d0d3a864fa62ecaa10252a22a379599a6256ab95f0e04fc8e31e441f78092fba5bf609165bc1aa420c3e4f932ccccddbdfe6c51910652c76074aca18c30728f2037548172e58a6dce0e0368eae1072b314bbc0499f9d7f0e7e0e62f827f0d0e3a469daba72c71574df238b3c45d19a1383457b8ab21573ff248af9e3c7dcd9d1358ddac9eb2c45935b10ac26a29ce03405071041dabdcb54d400055e4cc1215ab1a9d2bdc9a335eb250c1ad7982b3a2c2ad61825bb354249c6ed8d0d81c615303813df36479e4dc86a689dbd03c3de1e9a92c7fcbf4b202a8e20b4ed126a9cd9035b5353fac7259e2acb084e8c0edbbc5f96e57555767aebc5c61c9f32f0a4c5434f46092545e24550872d5b6049e6a1ba90f28204fb92c714fb73cd22c9faa3c31b909bafce052822f52da7009e202225db214e18c0082168e53891c926c2ab742688150dfe278d121076b9074ac5cc5b0254929c8921733dcd40801c2c48b1e4fcfc5c0151c1e6eb08a13040c1a1093e5ce114cf4687933eb9721f513bd1465353890f523d126acfbb1252ebaaee3e992b9e1d264861ff43c91550649880b2e3ce1a3073531ccba5b87b0a51c5ceb1f5b8298725b03f16f201d638852e958d3386b79de70f88bfeda1016ee9c3467e0ff80410133f093e62cfc0ceee000c5219739849e85e2908b4310985d9cc6ccc08740f82df0c3870088a3f535ba6d3e9bc017f05402ade05166d9a82dcbe632e4ecce2cb9d70449e344f6a75286645385ea89161ec2a4c9cdfc678803e3fb9d7b9ba9bca3b33f76fa7de278b38b1726f3bc4dd99a5a1f289389e38eba0203aeb8c487137f70051b9f3874df13e7907cc51b2cd4c02802c0a203932d46ee3825cddaa9d419428e1bac129860d65bdeb86942c3f261862f3d96aacc81a2e70528aef6cc7a0d9eb9451dd63dad550936e4e28d591b924121f8e76d4e4d1bb6c9a34ec165cc289d9505da807fdabc7fd6faa792d77ef614c58c3c0624bc0a8359e26e535dc3ad4a3de29604889b0e34dc7e84899a1375c66588ea72c69b4895be6ecbd979b574524ae9ab566abdeb5bc1efc379667b3fa7d3d0bbf8e66a54ccf5d3da6579a55eadf54aedd7855ff5f1698929789895cbe14f817aa51f9d357f81a7528d7a5f7f1f3843a02c59b4c4f9b356abd572a8c91b70f080630c0ebf59abd96e0781015fb5dee95d57ebeeb5564addc579dddda9d38e7da1bbbbbb175e093275dd9c77acb5b6bbf5a7cfce03f2ea9db5d6da4a6bfde93fab7f8d964e6df5eadf025bd70c28a5d7121520650a781c9e3f2ac0a7f5d3ea00e71c4029ae4f2b45d70a836c08ba54480f36008485280b29a58059c8a54328320bcfb637079c61952ffaafe84a0107fbcf4ed21a62e0000f366112a8da0b64bbce765dd7d91b7a140c813670edcbef00284bea816147e9b75a0e6885de793235a07f389ffa749f40735c7c2358fe6cb9eb2ae116951d496f1adce20e658281e0380e189bf121b04b2a09aaa63d544c53a88660a172c17bc04059e2ca642d515586aa4c1477e2ded9d9dbc18a62301c095326881becca730663279c0c6631a69fc02d5c3d822bc8124726089f8387b2c491b1a19fe015762a112c64556dc03f48cc3b38e84693b0ab09fd2189a58e837196b8246a6d1b63677ea53206ab684cd56b4c531e5f38cf57ec3a1520c7576cb2d3509316e79018a20048f863ff9777d9414df61f3377f7183253ea1213e5420c9adcefaf263146322c081ee9d7ec92687242643793fdef0bd91f87d1217b9828b27bcc7d66771ef03881fbf164aaca9c594883122ba73745b8d87c4e91a556161837ed0d1193f5cb4cbf8b748921873c2f5cc5808259f780ca12e785244b3e7245666de1e4c6a14ceea459cb46a02d86737465073343f618d91d0c9657ad2fcf94c923d158e4250b00b9ff1e41241f71822f53359a8632aa0f3a84ec756ee005cb5fc84c6985c5fa05cecb52bbc812776b936996382f45f25824d301f43cd905566863ce1bb0fcf1e69941d3ee641758bec494314029675099801d63e8b5d6da95d24a432da094337a724029a5f2279d555ef568c5ee2d06d8f7de6b75d0bdf7608be9ee22a5b7e5817ff75ded6aad5fa9538133a41e4e50a4d6da065b1d7875d0fa0569cd016cd1b3fda7eb6e58efb5b4eb5ab8b55e28f8d3f4deb71d7b1729754add52da8596deaed6d9ff5dcfaebb5b9c3256bb956c770dfefc68fcc0dd0d5a4b573080edaef781d6d7689a67cb0134d3b2b842eb77dc5ce5917d0b820fd2d0b6a83cb21f8ad3be77611d2c4b9a7b84935201bd61388f5db6597a0efd710eff9f39f1cf07314c76ccff47a419ec993fef816e4aa3ad608009e67047b73890ab036ab62d0700c9a3f99f07329d35f49603686efdbc073a03bd0a9e81c4ebe5f9541c3f90ebec6fbe37ffce3c7d760c5b6137f7c0b3bef9c007a548c666ddbec3c22ce50cefca1975043ff01da4d45a6a4350bc1dcbaf2cd8b31ff9074fcf50aa7b457aa62ae725cbad894a13a6a5224b4886d48628d124fa832601c15307e7effb64cbc607733c1d9b949615a76372c6cc60f7b834b9fc7d9d3c4a2ca4229452c9a35f7d30fb61c7b078702bfcef46fdaffe77a3d6cf51ffabff5de0044b9c1aac5cff4b739b58f4679c96216754e2a2ae6606df8f5f966f670cefe5d3ea4a1dc313a7d58cd1a7b34d916c61930979441f8907fcf3747c0feb5b980dfb0ecb6147fb7d551ceac0bebf15737c5ffffbefeb875f7fac387ec28e6161fbdf929fcff13dadb0ef670b023f4f1f3f951e6cc4196956758cd2cf60082cb3cc33532a8b28d84348a4c4593a7591859e3a4819c1bcc33b90220838042576953042b8059760021478e2c153868226ec23a7c79c3554c8d1e5910e7940db5daac0421e7be4163900ce6eb1e78d5045552e0c435187a4ca81b9dddf90652178049796545459f1562c193195eebdde9d39dc6b8412b703bba7a1f84d11c12358951bac924d4da5efb662c99dee902df7bbc8595b683f0c6f68a15c5187b56517398cc277035f6070f8170606f75f98f7b28392bb1b443914bf9b3c0a3f08090ebf45560ea53c0a451a3f1efc6ed9bbd696e990cda3cca54c671511118e8e75177d9e27f0c8531c2becede099bb1f8972ff0978d61c5ff13ba32c4e13725f4414caa8732976e96cea17fdb73b35733fc549a50c76a9c9fddddf1de446ddc7e77af7e77617e8e20b5e7c7d7c7cbe46e31810fef08fd8bab9855bada69203cae1dc4feea99b6c4dc5068ab64fb479e2f852e1924152f4992dd8f8340c7156d885e14b292385d7ebcbba320ba96716c658844e0c6166e5c68b53bc0a972dc896c2364f90dbd6bee106d9dcbe4471fb12c5e7b5fcf6ff7a20cb64fa893aac0b1bf0bd711f76dffb6be67af9fec23e71ec96805ec0e3ac33afbf68a57cad77ad282555a62e7acd71889145343bd98d68080b188c82b5218147d94d76933388ac6d088bb50580f64400685976b336d92d00b4185904b87db77c55d4c2fe2f0782e2f7de83de1e3cf3f77d8dced1d90d004b9655d454d472cf7c637a2390f79ef7dd5c84c12848aa9ca3befdfacae171005879945403c0923364b9df7e154749b50106797e51f9fea8e24dee1f659ee233c9a33a78fc98f297cb3d002c79d4f5c70160e55e61e6f1990870b33180b2687449cb338b2e2f963d59f6bc1d36e36f458167c6dd385c465fec12c7974f2c2693750da9767d40b196039a2ed70705bd4b941dfb011273622e07bd379b4e2e2b481c5f29c411379eaed3b176a2630b451b28da3ed156abd56a1836f38f0fac36f3d8b91b36bc17e3d72b965b2fa52cb79072ab69b9464fa42b8eb24f1c6359599f0c1fec18f8a1288f3eb14677ee5e8c73afbc0794dd385c4a22f825bada098f33ebf5423fde1f5f2f51e8de156277102c8641ed0307bcfe8e857d01e0bd758e3df248ebebf3a9adaf2ffd13c77bbd734b1ca7f7fa1ff1e53197a6d2accda41f272dc528a98064d58f122bfc5166d5c1f3a39cfa51de9080c4c7387f3f6239661ac9f8112f4c051ef9bab536ec2d96937596a66aad2ab090bb6f21cfef7237ea88656ae732a13993e70164d781d24af92e65d7759d483bf6168c3a6459be9f90a90c4f8aa3b5f62fcc7f94df89567c504a29bf8a52c72b4b89db0527a7b0654348df27922d0a4a6967fbd08e517a6150a318a637c4d5d27f59158e0fe498eb3d2d8a21edb8e11d3ce2dbdd2e7ce1b0825eeb768c5619deaf25ef5ba427b25e17621f2c3cba327dd0a7526f1fdae940f2661093d052a748d1ddddb33675ccbb4d29c5e923070b35e19076c1b26332a43be6eca795078e0ff26c15a80a93070b58789cb42c4778b90925dcc1a3c4caf25b52f243c0c1810634906446457fa7e071029940e480731e00b421d4047fd0774ad972b69c342fb121d484ba8b362736eceede5147ca1d4c4e650a43ca600da9b595da2af404bbb0cc2826338a49f1081e3f4b29be5cb86350b090112ce48390111ceb98101376b1e809eef7c9e3cc4b5ae4d1c2ccda7beff781a0949e8f1b3cca313be8bbb0741f3a1c8cf7fb71e1d07584997eeddcddeb77eedea2f445859c083909c20136dd9d52774a9b767717a1b3911c8922d52772e1d8a5e1a5945e7ac34b6f882fbda1cfcf8fecd2f08698ca2ea5452efc72bd88f0a5b4c8855fae1711bef4862efc72bd88f0a5b4c8855fae17117e5d1ade1053ca8245cb860b63a24b6f882fbd21a5b14b6f78e90d2fbd21a5521e49aa9ba206b08892ec76a7b456dc5dd093df6cbf40f6621904ddfd6bb8130931e1f9f221ca924868099e18c8f5fac9fdb2cb2e8e1be416e92d5b3da0a4f2edd422b9e145e2791f18bafff8f80835c1f37f2690a4f1e50e14d4c2e184757daa4d1dd42e970a15534590eb67858a152b56b88252ac58018457ac58f1b3c2a7b562c50a018034e039bb8580c0a053bff288525ac7a82cacd5d24ec80a1e71785b362ed34b68090b59c1e3fd5ea1d01206c3b005c2d00ca4b456cb06fe5068e927f6d3b2511433fa696d40941f6320a014296ab5d6da58a6412982807050505050100b71d4616d5808100445f0ce7659d5a0c6b5dfb9a494de77c3cb170c43e9e3f3f373a76004a038a8342db8453554686a060000008315000020100c0785228150240b3449341f14800d688448725a3817088349120331886120430c31c600038c318620a68866040ac2cb2a4f58a0c6577eaacf1456c86ab36bdcee196e327066d1fd3f2d678400c09673cf990a7cf9ba9a487ad6524ea082995338d0845702491e399fc7f2d8738a09afd71299c7ee88e8533f16e0dc03b28a7743032e55c9bd1f293da27ac9eca73e0a20baf8a5366f4649ad4478661e3f59950d99487de1013d824353b12785b37349c06c700bf612c0b038d532b04c77eeb666a31afaf7e220ee8abe77fb3c8c74cf0f3f5af043a78d1fa541dec3af6030f75c6abf5047934bd2e48333f8dec202b38562692d2c5ccfc19ab5fb7b12d6ad4d7107b7fbc81d8a51b802afdcb1c24bb7c71747c41125ba190aa29d79f0f331c5c120ef5f45b01b20c738f575c6a5d41fdd00e5e34013e72e60516f937e9dd6a643862100e6953822c0082b30c94d96b4e0d69471c6ac2eb447f8fd1ea8d8194a14bc478a817d9b1f1dce741e044a0f0219278d4c0f2e9f0d77db16d23ce114782073b540d27675abf3c13f3dd6121e68119fdd5c081a24f86a4197216b02f0077674ac37a3631e35b88b55fc684b7695642e93249ca35f48358d9f31d75b31b2882d5f0e45db76095c52b8f399ceb80a314752cf21a73fd45ce3e9254b7941364a8945a0ab15638967752f452410ce4dcd4851072de7bb6e75db86fa16609e61572e6f3b4a4a1455dd73703961f30b2a5b1f9d89fd589b70f90304503f8088e8ba088beb32f9087e18ae6aa12a25781c4ca50410558ce6aa5ef62eabc545b6ce7d5e6ac59a14190538b8978703e7f93fd4f295f14d95538186b361f094a0bde6164abad740332ade36e72fc34b416bd23e7a0aea0138bb88963a89a659b95db3c983d6e45528b51ba863359f0dfb7cad806e22fdd49ea5ebfbaaf786be054aab30527d2c6fec3f5ee080e8b9e7acde7f56620ca965ce0cdff62fd68924ea2c6d6d5bedaedaf6aef0c99172cccc20778bd2ae3a28a26e553458877d2e9710af1f7790581733ae519127363920af82b6830b0fbee7330236b3c260235ddf187a307f5d85b1602d6f0cbf0727604fa8a572d5c14aedc16a6e0994490bd6004df2b31b46759b4bff6f35975e70bcbaccf41901956e7f4ff5560556e34cf79baaceeffa8dfdc26e13b2ee3440813688e26e2da4b4fe372832df2f69b8df361c491c6be38aa96d348a53b1873d9b7c70af90f388cb07eb96a9e16136aa8cdb0044ff5005df0a84a94eb51e9d10720e512542839f457c630becf0258f32093aadcda10ce26f9d7a130c2408770dd4f6d716a2a01da71f69705f8872d98252e06091e53320002322eceda70432988ac1cdbc5adae7a6dade8eb56c71ebc9e7024e7b6fb1d37616395f0eccb2b8311aaeafcbbcc2ed168eef9dee270e78b636f277c4abc219c31793c48614937492b0b70d6566a7cd6fdb0a2902fb49f4953dee05dc56094c56919a7dd64bc1c74edada02ef79870b3a517245358ef806ee908d77d2bc140b3e4210e9e51f96dab3f8914103f1066e47f6495bb96494e4dc39ed3f4d73586350bd08d5cb0abea2d87530ac267b9c6f2a54268d4f9e18ac0032f1cbcb557f3c0bc9a14a9a8fd160d09c1dc53a878ead479ca3b9c7e0edd3c28795ea4d34ae78a1facef3027a8817c2aa1a2d924694f40dba108e69b15d7f95615510abc412bcd4318c5c68210513de4a31ba2b8aa1d2f2ae3c3a95741f1853b38ad05386d005ce234aec3f37f2091ced49f7b442ad156789989576c4086742caff4660e330b456ab29b6660d76c1435b9709f90ee870f401b172191d1ae7d1552ac79027cb4876e90c3511ee384c9044ae4d34f5ca615977c1f53aa1891a290d4e83e8587176a820b95ec1cad3cc33fd72c59f5f087b33a3d727f49b26d42107cb19aac523a7fe324364d9cf2f384173e5b1ccc6f981b90d8b2a227e652ee91541fc2e8bdc507d28e43a78519b6abe39c33c2fd8ee4ef0ab2fb7322a6c93170561b46337069eef040a3968b6f51adc4e03ad23bccbdafd60d8327bca71506fa470fc9014f1ed4f8ffdc4b1568ed9a4e2aa6234ee922a618b66a4589a2232ca77a30aef982504f31343906799ae341d17a2bad9e119a3220971a1ca416b2cb868444a9646876a7af88826ec8a389a488d837eb630dce24a0e11874910a25ede4514acb1991dbf4a222bb60351aaa4771781c3c11cc87d8cf6cab6302a697a62d12e3d38e24e82fba5b146245a9c809343b09ca008e0e21bcc97dee537e66fa4d8d9141ac44e23db70bf58f95bcf902a251443223a1f91eb883e817b37909d2f5d3cb39076a4b3ae7f50ab1d30c10d774f098b79f7cc0016ab64ee7886741f913dfa7130a0d81958a84b227fe282a17572f89b67c60e42c462442b034980635af0719081ab4edaf7dc733cb9900f43f78388c6235022fae9fa5420dcceca71f45ac5c839748f51230df18cac00d6697399acf95d19e5e8ee52da93801092a4133ba80cf56fe47a22de6a44a6b4a6130e2f932859dd71cb0375b8c0f99ea492537fb194fee6b8b1593e2e7d0435baf0572a51c482053a14b57b1946df43d39c5b7aff19d64b0ec584587d4d2cc30f8425242a4633ccf485593f1810215602e9822984c269dc2eb3a01074b7e7ee1f11e873206e0a8c87c8e14e060a6107b608a3ce9725a349153fbb1e02ef90c714f11e654f692866d4bc3c1b3dd5fd897a978f476ef7fe303cba4b8a0e8b284ff02481a99da0fcca1576e04f11c4442de5e6db7d3e642b85d225e034ce990520e23a92b5310ae3e3a2c3af6e9646b26698b1c521bfe37efdf4b27e282e4244195030f3194c87b9afed9d19daee2c854d7cdc48c3537c1dd0e5c35b2e971743bca3a254ec892807788634427e4a0b6abb988831c61bdee992a805d7d8353873211a0127ec390757eea70bb89c6468d8f902622b1f921408d04135046760f49696061c42bdb9ba3b7ad051db957aaf42d9a008fa9920ecfb9320b67460e334ef8f2de94d88681a1aaba98ac2382cd0b0a1603466a7c336a4a3dc725081fe4713ce355cb0d171ddf34097a0f1eb9efa7bf3620a770935f08fa470635af017e3436481020c139ac2c2e11aef774d58c26ee4d5909159818b6d8149613fdd954f45f0d4314135ddbaf0ab92d0e2b70e7fe3821d73d2c9bf9cf6cd1887b3c0499dd91d33e29ed8142a50a5b8d10d7a2064eef0982c03efceef4bbc0ae4f832f9a8e505dd95decbd088baf729dfd24e83b6e7508b32dd1b597123d1595f07ebf509116f385a115a3170caa015638817d83c3a188c1561638d98f95a0e48f89c140e76aaa1d29784262d44ddb2e5a84bea48ab4577d11ce6215dba22406cb54fd51d42294acaf5241236b55c13fe4d374d11e0eea6ba2887cc3e8a754a9c03ce9aee4a5b3bb03b108f075edeeda83a2ecd9445f806924e0c3b69a417d1b7cd0e8b954d2009cc411d22174225e54a1302371b4ded746e3459ca8db47058b90013a06b34893b8b9f3dc6edd32c8a0583dc7618bdd45a633d169071b7dd0f6b7cea9272c01f5af7ce511ae0973587144ece6df1267f941bff3b7ebf5ad4ce941bb81801e659c2940ac4ff9ae52474bcc0a80171b57f71a7702cc06b6226e254e675ea895a43fe3737bd77d7675393ba5a5a16a601234f1c1087efa4e5a08bb992050152cbe56cfa900125078769f9307428be3070598deb7e78d96203280ee66683797ca2671dd74212cf7a62fa27005bad561ed55b1df116e0fe6c5795e06ac90d90786776e22b0de99fbdfd0e342c0de1dea6929d91fd091f3b5f22f8dcd8ef02784ef5a9bb3517bad76aafa0c7c7eb17cbe804590ad0eceb7e993abea2378f41cd2ffcf25836bb28123d4827c86a5c254493e0cb52e86b8d459b0b6d9a45e97173f3020b2cf9ded8619ff33e4156474044aeb1ed7b1a0364d74cd93332e2de997335f0ba024991b8b1aefce3e414e92e113bce70c7b8f51aecc165a0c40d4029ab9241b1873c9f99070e2942cf2ba74423c98e95f5adb8f9edf323628bbd69a53da1f591c9cc3c3d13b1a1690f0afbd269263c95eace072fbc2e477f8ee7ad012fb2f9c1dbd72eebe7128cca4e44350d8c22f33a58ddece4fe0f01b428515f499893171a3e477d88f4fe203a1214d31d3b160fbb2b71404cd93d8dabc58dd2264dabfe037cebd05dadbdbf4a9ee614dbdee1d87c3134a13a298729766ef8fbf05a5f7ad33cef8e47a991d9579d69f60adf2abfceed2377ee32eb736ca48a35803f42f82e0def51550c78609dc3090a6706f4d3a4ba4ea164008dbf94e5d80312de05c41e5e227557aa8cececa80ce8a4929c6be6bf7707319abc2e0c1db5470e3458544aca1a47694b5231f11a4c545e6acf2e80cb4c83e77d1a3b2658b4dd2cbbe1fb0f204423fe51e9dff8752ea9a3a3bf7de1190a1bc5d6f5c33939d96f413e2f5ce2833881725e96138019b5a1a484199a31af34d27fb0c9c0fbce9f6960842333aa0b337a1b7aeb511a462b2ddecaa77cb716709593b11ff16e7731c58c7a8c0bf074fde0111e86525053b61a96efa4c2fb82989f809bd51b5870b14593c43241ce31586b48728d783f3624046805e39e5b112a293bfd5f9713fd4e7104ec3540f40c3984da38b83f36a4d590c4962ccf5c55814042584e99995341e14b2602210f1aaf5355c4fb4e735fc781e0093f81f4009aa7bc13a93f8190723b094637de2ddd0d477e5184299411a346c92039b4aaa3572eaf26ce3262d4d623d63b4af94976d3e21a09b28d118d26fef97581cec497c27cb5d176572a5722f012e78c0556ce883a1f655ba857c5c45ffd198b4b6c3580c7e9b2b86e4275fbdceb5c70613598e94e3105092aba8486ec5d916bac11105541134768a00b09088a796f2ed83b301fe3cea20e045a540f73b25faa0228415fb6fa05ebc64b6f78ba702b4d3c945b8a27d88e08aaccc6600f9aec041a87a493a8666d59fda240d6b26f8a0db0952f17f9665b102b129577a9ef6bbfc6925a9393fafdfbcbcd611c0aa88176bc25ded635e5a67fc08c26c08826d9bada4f8df1fa5ace3db0a9df1c4092ed04fac8d165d3b62bf790c381e5d04280d670ccce6029e20d9febed3432ab1e7fc813c3a6506dc31588482abaaefda8aba7edbf3a201897b1b054299fadd24180c03e5fc2811754f949877d073e52cec76a6069a0a4d0554e20e0e378215d1d45e4b65ecd621ec2970366321b2b12972db2fc6d53c59f0298f76811b74000288575b55c246abe43c270244a5340ee66d0eb073aa788ac24a75024dfc2c1ba3ac61bab3de48b45b164267746e1869e17cb5490733c7c14429934128b04b2207f9db3747d5bd2f3424d7ae5e93aeba9abc610c509d30369e80cbca2c5b5a0256849c8d5a468fbb00ecc6265c2068dceeea4af1e77f2163e10e3f000b4a1bc1b69376d362643080f659b7a6c3980142b7914c867caa6173272b06872a2b2e66b591fd51fae1edc80df46d2a41d487f51043aa83c21e4205095161f201ae725e439aeed4216913e784387432f1ccbf508265cda7379040f52dfe1b5f404259e30c0d8d111e2d25e86352211b8669bb657935fe2619a181419681ae5d2d2f4b4794a4bae9c51c1974b5be3142c88edbb33a841d83e8549d52a01943f8c69551ef6f50bb92606cc83842494ef39c5b43c26c4cab00471070a28e0619ab6e6f7b3fcbc4d51545a306c51077df04ccd01542e0f361c83201f8c6e803219f2011f43150a682d350adefa8ab46652ce51dc4ed9e96915d092659b5ed201a8dd1510ec849f8b21d4d895a738c43c48d6599498a83703b0e6da0af34d9f27706c50ef3f2aa9ec9dd83f9c43b0fccbeeab96bfd5ba69b29c5dc10043495b4673ff466d4fab3a951c191f897b42a33a442175c431ddab9771797d083ea42f2268f4e106b5b5ccbf1cc563ef4df4ce4ce961967985701466c74777a7b940dfbebc287946284c631b7734ea6e6ca6b542e1a3293d8ac04aed7c68009a7cca872f7bd54e865a5b1369c2b9972293aa3a8a3dde3c376110beb0979b64d636dbd2e54bbde914a9aaa3d8e3cd731306e10b7bb949666db34ddfbca4d646b18dbd3c543a47cc2a4f42eec414030781a97c86a4ce99a7ed70ae9a6e399879acd23636c8566fd42453bdb11db7d7f4ea3fa8055961f39e169812d7a4a2e0bc6d52c8ac9d0dccb6827b5f47100aef4e90dc3bfb229d4f9c9a06e3104f9ba915b5cedbc30e1709f7b15578e297b7ac0fba390778be7ed6d6edb5de12d8bb7fcc0b828db602bb7d1e771c80a4dee2cd8e5ec190c0637898713080c2db7fa3082863e4ac1cbb2a048621dbe1d8418421c45d668155308c5dfdba63b7d791553b84343e85fe5ca4f2730fbd3ada081667aa3b761e4f1763d0ac05974a124eb27a6d6713267e517e85ff049c640b07c7857d3baa91cd9ac8b5c502d8d015c3255d22cab39558874ab7579bffeb05a8546420332809f769f17ec19fa10b4703162ddd3ea5edbabcc0af705ad3622bfb2a797e8000e0bc29d566f896a1949442629b7381b8e23964a6a4f3cc9e343d9973487e9829f95fd345e974b9d74cb99c12f6153144d34524a5a3222650a350ce827a95d26b4c4a87da48f24989e716f5896052520e14ca00b2586ad4c662a934825a28f67a13b49492797396a7ab03ed7acefa90264094aaf0e6505a8e078cadd17c6dcca0641d06ea9787a58dce04f33ee5f834641e06066b63a38a7e380a0c70426b705c361999b000da57491a9911663337e670f77cc8c231e38024d5c8c931a397f4c3201652148717a688a5fea52ea0d6b935079768ec1c5de0d774cac679bc66126374fc0a2c830d2c7e222fc8d4e9800c5e391c6ee75c15097b6262cfd7d1551484ba9ac6cb3e983ec8a7e79c98cd63f8a19f4088b79603c78e8f2f63d5d3f02d9384161a939c4189b733828e51b3c97892718605ba382bb0f88c8842938f0f573707f216084138d34562d154125719a75cd22e66e4db66ad01cd3e73c89f41bcac2cb9231ac8307432e6862069a98e672f2349adf5937f2ede612a17e3104843b94ec989eee1ade855145539fe0f193922f121e22769f02f1b40587a6f03690b2d953d04b55073e420568974494361ec4ce05364813266f28e54cb29f73f9dcbf2cb20c63abeb3d17201524507894d0d44dd1a42f4a9edbb7fb3fa5b54643a14c7eaf1235255e64e7bed64d259b6d71adadc3898f9a1c5a3ac371e6c28d17afd114b98966adb1da5568d6a19330f69ab212e326cd841a11af525de67eae007f3d42a302e0b01ada2a8467d8beda396826ffbfd8532728c52a5204a87e5e94c88a9f1cf52f616848a68141dfe9fee76c057b43475110a8eb20712ab56b6c61dfd957009042850722a98617e4805d71517cd5d189c6dd013c749cb11c677aca1e05e8ab3e9b2433de4e0673d07e12e04be6d91d6842e9ed3161cd75043c096f7146480ed305af8fc8f5af60098fdbcc4f9c022d33ba362f88642b315c2435e3b900de536d7b4cf1790b7b02da9505562f7ae7409e91671f9fd1df8a4fa37660ec1707af8115bbdaf2fa75b7845f6b47f2ca0efb6e100346e457570ca1798cdfb6dea9a4dfa3b6ed15e1faf50c79282dde944c9592b1c0eede09d85677df573cc5f1182721e45fbd8b302cacfc4e2582866213e2ec423de67ca53c438862000455da92aea009d798eead54c01bc06dd691bec0565d0f164a5873b131b3a830632f615f5eb6e50f4a27efc24142531433a9b76795606105d7f8e1958fcdae25db8541890ac4613995a5b54d306ca2c43b6a411d39633f230ddcb886453d11d08b542f3679210fb3436451ad972a0c7b54fd1bde75bcd34009b6c8f8cc0bd2738022ea0a3f114dfbc65dda9334bb44cb429c1d8162f76d35a7c4f063e7489959c5b386acb3c0a4d9deb78be1a5f9c40eaf11e05efec6ef42fbf4530f8fd77cd5cd14cdc330a94a206373aaa2fa2809af6b1e4125283551855c3dea9a766a7be20d15963b342dbc2746d3a4e25b966e53bd5f1254b6a8fc000eb452f5d0a5548daa5f22db2244d200187e02532c45c4af7d5831d49317310fefad4f10ea480b33889d2da7aa9c49c746144046be6a326569e11c115e9e1c0ab1bcf59cbb801469be52232a6c963117840c6c8c5f5ec90d57fa061af454b39a431ac0e2e2ae5db4ece2b998542dfad1963e58ef388a5c817e115121c226b9d7168ac4b94f1530431317fd468ca272377356e3a1af6751ec1edefc3e6ddddd9e12183c3618b27027d062c746bd6de70d0594f13d77e84ac5e873bc201c8140fa15854b00e06a8eea158e6b4af4bf8a6650e70db8349b4fc147c76da87f8ec95a8347a91b35e1077cbcbe7eb2cc93d164eee8bde828bd747c93e732c0f5aa9893758b514b19436ded16208e16edeedf988210f6756d7edd8ac2a88c724b244e025340b5e1673f21eb14a7e6954eb4788d143cfc9f98cdef7497c225347e1cc466af246912c05c3a892ba096279758c185a0735a84b7cbc6cb483986013cb9a1fab1a6bc391f640f2f4a93a0e33cb572969bd93642a05552791df4ef52ebcdd55a57f55ab09ff6584ca09fcfb4ede4c279663dc8a72d1f200eba1f5b458eae441e0ab9ec9d49385e754d467b6e0520b95865ded70b72b56c670134c411bc9c97d6c083fdf2bad4384ebc20a1285194c8f3e83db1fa51eabbc6fe69d933655abc1b5f30a801da1ada91802cd0c338450c3c7fc32696866079910a1d279ddd0517f0930d9dc81f66d0ff6948e3879f6952773dce8d8b656b866412e18524d3f4be42394c8d4a107bf1f6591dc45e018ca59e057502091dfbfb6f0467b0cf2009f6fc2c27c41b910afd0208e9aa2345ac563ca8a534a2beed02887ed8b61682c1ee07eb22ae6258132b55350882f3f3c08958b1d01a77c31f59fa8a25ec0552d60c0f5d063c5fd4d7af07fd11615c542193b524a710e354440363fd23a031f25225879a8226855790124489224e978678eb60f066ecbe8f86de6fa344369a8e625cefdb687b687c6afe5bbd38bcffc3f50ce0ad557c6fd674a7d853cff8f76dfd8dd8a497f0288046705dda55d5525fc2a42a3004ede9247606ad4334eed270307b3a9b792a225e48c38f08d9a2ec1bf99c4c5d96ee84aca24d440629db04753ef2861290e9aef79e7cc4eb4b28622711247d272650299f69220e1f3614680617435437bcf09d77a03d6e0ea73d007aef1d15491ec894090605713e2a907d67fd76795ea0117af7fd0d5051de6df3fbd7bf083f03bc53c55456ee34e29dc202413c320cc130cfe089714df46dd1f41f6e26a6e740eeb4cf19fb809743e85f83f5465121dd720d1d3eb688f4534098f2c8f7e4afd585ff21cd558165deb4cddaf19ceaed8a8368384317e8cd047128def36191856dfe66c10e083c91666390885a8862f17b0ce5f4b97a3923c18c7066c91656fdb051d7afa972fb936c24500ee6b12ae9a2252e36eac19d3bc1011ffa44f47b23d854666480672417a046d3f4134b0188430958f6c03702f22704b0fa7f8ee2b0b9aab4b249d662411ec5e0f76694929322b9219510b9252e263bc043cad751aa163aec6db6c67dd60a02e45cc3bfe9dd3fad9c36af9f85097b7b4c5507c55a887827d3c17a9c8e9171a1697717afc9b263dfea11d42bb0b40fcb86c5b0e0341bdc8cfaacfc6750fcacc111ca6a35634a41def1538f57ae3526b05286c34eb959ab42d95db96987219a9376b2b261853586a0682248326736b3665aa01ce456af5976a83351dd28e46b5a6780754278c8a40afb1e5503f48252c30ea2675ae84966c7bb43a4612cce3ca4e67650e965280c5a7d98f84b28843070b944c20d1a1e572c64bbe50711a23e58d29c921872e815befc40fa89ca50726ea75d5919a68779045d40cdab5751ab87c045f88863a7523f0d26ac06f5ce0254eb16a123b6870f9df7d76f7d8deb541c339bb6f8f3e839b1d9878e958afec35a2267d57a402f67b1a24f310a96ae61416a5ff09b9a76506e9b1694ad4917176eed7175ba461eca9276e570de22082493ae3ab6aa8165441751894c7c46e8eec3b9e746e985c17bc32456f17e2db55b089733c1caa8284ae1e70ed0c9e259faa95cb26c1ea50a689fa81a7210138191d1b3f5f9fa75e31b1574660944cae414f3114cfc117c221ef38d4e201c91396a591836fe09af07c943aa21ed0c82a1c1e32fe1e9b39acdd30027d6ae45ee6823a865f53ccd4ca506233103bdb5897f1e9f5cd58041d4e8b5c831ec624bb0e339ad3bce10223b3bbbc62cd8108d492762fda6f84fa36214935a81435c91bd1713208c18859acb086e90e6f25ca4e70ecefe3069e30b64181b338c4101ac520838a5346026e0c7ecc5141a884b08150b7187c04a889ad51404b021be55a78ad1deb8e13b30dc338d5b1257a5c63ec013b1ad15332528c1ecb1e22fd668826a2d294ff3b23dc4a9cb095609c435015789b251c0131994f05a0d45c9221a0cc0ddff6374591872d754e7be80dc764d63909a4f096444fff9c3abfd78e2bff9c22d233d16cf6e21edefbf5e523c7a2515636a24f9030f3f64bd28b6cdcfe8f3ce929d7166c209c6e88f6b428641ced15f95dce4d272cb11b60847bd4656297656ca0a35877c56265925f77448492e17ab8229960526638b330e885338654790fb21eb5b31d9b77c690487bf87bdffea7694bbbf902494ff19040a841fb7979315063fb3e18a82609fb0c293a661cdbfe2fb8808b0459b8a00518c4cfe9e4b3316742b21c3b155644685f840c7140385f31119e96996d49c18b32fe4832b0f73669787f531531e0fa58d3f5854bfda7bd18173724a970440de6fe1b96f79a3d208cf8b7c14161602a48db4dafb2bcf3388be883056b2d11571053794fd4338318d4a011e8c3cd1e407feee5f0a8a50d00033353919906d8de7a288b9183a018e79a2cfb928cb7ecdf753d762a829b9921f033b3ef734ca57b26c73e4714319c95399514871c1bb0a994a3a622218bcef286a5cc039fb59832a33f898a4c9f3440d864215ed2d244ab87c0c9882422662cd3a26b9b78ec7d1200cbb1ecba4581a0658584bfc4fba05cb4a2c620839d3ab24d670f0ee66ff95ccfa1ae536c59c5d75e9334cf7d759ff5b459c51a2d004a21e72bdb516613210e6b2283961c74e0b9967231c2e41b04589bdb2f3eb414bb19ead66a762e2ea5c2a9bd3828547aeac9acf3994f3abcd94e39aa4e6a2fdbbbb280012ff8de44efdcafe80c10183b89fad29a1e73bb711cf57eec549ae031434639eec7c4345ebfc21c5e4390fadaced33cc6e37ee7874299caf04e1b4cb9f41727e66bd64b2cd79167ec5903c84a133ef6acd684d1a09095654c6de1e3903b9b89c75fcbcda07476233c071b9b0b42a868e3860b3889e9f42df19822bbbbf9bf7f5dfc582d2fe2c90eec92db00c0065dd8b360ac14a322762416d8a9fb626adfb075d38fdd83342964a0d219bb85cf8aec1d32fa09cc1ce188ebe4a0eb36ef32415c8a79485b5d5a88f66fa7f1c8cdda7bdc9a4c0466f94cd03e01d281e804f201af9172a988eec80a1365eca487087cc468f0b23a8f1eaa86b49895e4ec6cef34fd85b14ec47c696aa1f91c4324ff0f40b729171ab0c300188ae5fc40f2a11c5f0db0e27d2ff15640aa33b7d475168a197d60b95f53035badbd12fdd27055ce33297dd8b7b52080b6cec73589fd681133a1712f888d0fde06dacd2c6633ba13e72aaace66fad9cd75f795327002ff9405136c66e6243229a0823eef137d0f6713229f8166b03141172f412f73cfb52cbd4f1c81d42647e6e55537c74b6da6237af2dbf01233b00dd170c83192757b4f25900a8d355c3dae44c27ddcc64d4394b0300be6ff0f36c42e4daefe271c652b65433846dce1a6d4259412d2ae3f4f4da1f257db50eed741a76536d1cb53e87b787e6c4ed122b46635b16704ca1575422befd275c0858478bb0cdae2369675459fbe5fc621c34da175d422adc7edf059867235811638f906a6f68281fd0080d002d13f0938f8e4bba8e56f6b7298bff1e453d527c35d2b1f122eec8f24c05a73307b5a43ddfde52a67225485399477391c7f1425e24236fce61bb9741b10ff49dc1d233f56ee7cbdb18621e03e2f9a0c7bb2d490f91a5223c552c03cad55e5efb466911be559ce3133b0455200d6a4c86f4a01b8365923c11effb8316eae9cbf6bc44f1e5f4805d0b1c5b8d9ecceb2c90dfdc5aaf0d114d29c631a5349ba8ec29fb8353f0d8066ce2fde03b4bceb2982e0ed01200040c902b1b8e6d642de1bb8e6d9babad3bb7cd22e185f16de41d66aa3d5fd02ec5616adfd2f0d08bbf6dbca729e50f5cfbe30b617c81c035042dfaf6398539c61152262d05bfd804624e2ac8cfbe9e2d6438b8f34b3d3a2f8470e71ceea4a4f4e703999d9e4fd0b648641b443efbe9a64ad9da701a7ba164a70b9de290c595284a6c0c2ad94d49cf3649184bc1e83793775ea89919ffc2f9cfb4022f9dc93329865901ed23a08a44f40b94b144e066577043e008978e4fc0491804b84985ceff3ca146e4e5b89ff578c5de00d82f8a83e71320a620ddcca1e31409607c072646b42132387459351684d769060607c60958727594eca22dc851281d32e90adb1a90d5ec46820690694f6ea5cdd4b19e0bddfac86a94ab21dc5bf0fa9ae098594f9ccaa5f80f66a8de770d9717440dff300ab6a02e0bf8ace1669e966a25c7b44a2d6beaac7d45c1a9ff062cd69f3d7e5ac8f7177da67613b4e17d621dc5db1c214fbf11f4ae9450e9fff5083cd20170e9c40066aee1fd462fc2ec13dcd22246031c10314d949ce3bbf3d69e437631884655bb1229125b5351c8f0a497d5fd176e62f12d1d4d84823d36046b5926d2b3c2da7d8a3a1c379f38fef931a11d93302d2a834bd4ce0fb6bcae148f70aca29636221bcebf4706d1747460a0445068a6485a4f41cb4d436830aee8292ecf4d25e8764d33996c43b606a2f39c1a55046868f33cbdbe4f31c5c5b2ddbf0e532483965e44548f8855d493dd82a369a0f2f20c7d617569c8e95994a1f53f54d05382d599347fa71de652368743bb44c8862306dbd5636d1fd2dfe11294febb9624299205fd29d57cac3af3052687445b65a792bb154332c355c0423f00504fb6f49f5491dc3b0496bd40f1cc90e00aa1f08139dd9b8dd1f29d741917f99f0c09eeb63dafbf318a3cde0ce32e8ce08b073b058acce6c16228809b7ed18a28e2509f4de65668b2980d093181a6f0c49db5c8e434f567904fe6b0f8c7ce95b9804c59f509320410137cd5d46674a04df90ed9b619f6a424628849d891686817258a4317274e2dd673fa3cfc78a0545c674588dbe93d73bdd61ca9683be04e98b30da1103abd2fa1813ccc3772ffd86c40c78b53076423139e0fc2a464eb2e6ce1996ccd745dbe34c3ab604151ad4798ee6bc56b28f6b4070de4314c2b657e89b55e6e63661ce284d705ebde85e5244bef31ac23438861369a5cb6d6e1471103e6d3acddd0d4a068414b83bf950dbd4e177626c80cbc028d94991a7a456100b8cde4fb43356a4d1a35227d0026632e32ca8fc95b3ce8484471f2df24ff00a05c821e98e97420c224bbd77248c19377c9ebdad2b391609cbb7522811b458fa11f3bed7f25815f72d07edb6f04007f8d175d0bc4cf0589fdefdfe43f9c25cdc605ff80b9df84eb955c5a1b43e759235efad0cbd8f12d537c90c9d63594f74ee54c5987686774419cc2357c978322a65a972522a5b98c7289befd739af2fa7a988fe2edd52769be73aae58d86f83152b62896a96c602251cb2893356f7e158345fcb30d6257f9fea83959be38263988b7daeb921569cd6ec085eede9f0163d8dbc0f346fe025215a1563e5b8c4bcee4355fb084619106c21bc4b1369435b972d239a9eb576155300057583486153da09e2932fc44efabd320e057c3bd08a5c608455f2831213eadfae94b826be99b8997d5e63a4adc8aaac56b9496cb207863e6480044fac5a09d25acb03e4dec4d69b8028221a7a517c273ea3534e8f8ea22edc2d7249e0ecba83d45507434669ce384b518d3094def8a82aa20aad6a0c3e5ea044dd54e835a39d7e1854d4007fab35028296d1bf29f6214c44a402a1101bdc669365f8c481fbf1c7c8236677afea1b8f681e408123fdce7078052a00390d1ed64b14949f86154f8a3b668ebadafec821935882d315dd6f634545e7ebe69cba4b34b2747a36db4fb6eb7e1679a6d42630a82ade974bf5c8ba06119a895a88c3fd7e77703f12801c74ad7de4a0b44340035641e7f6b98b5e2b6ff52c15e85196b1f5dc22076014280a65d48072a6344948685696466585ce3e6d71e4733123cd5a968134a2f21f146738910b11e593305d9e1ae4fc2b65efbce1dfb381e8f5abcf1e0af75e0f62f7db5b13fc7754bf1fd5a2b620b4b7f711b9a25c216fb99513388d4275ccbac45605aa825984eb7a0adf8fc65b4b049648d5c8a77c289a0797cd535ebb9aae4bddc9dda9a6018ceedf79ffdef7bba816b165dfa9edc34f05ed964bbe6b05e1d514ad5a72ccfa21b52dc253693d54f15a218c032bf0616edd3144aa32cfe6840db0b9774a970d3b95e5343781a27bf6faa2623012c0dbc9bfcdf1c7b526d95d8866c2fa9065f23bbd5a5b400a0575f303f6c72cd57f05375fda1df0cb12e0dab12690b5a808c12332d46749b28f655be792748b0429335aa16109f3a56ee3aa983af1b0dc4074036f7bb8af57b17efe0dffccdd435acafed5ae8f7ec3104e6cbbbc991d4dfddd24cb0d9eee73d32576810168a0433a96041b985e1a7f2cb09f391d37121e52eee690ea1a6386be24ad689918685952b28c217a30d1cd25ee03c805d8ed909cde87e37a83e2ee882fb038603dd0682df9bf2ac6d1a5ba4ef2d31d1432e46a2a6e58c50173561800a2c4ae08451d2398464d48ecd8fd7e35a9f9f672487ea9e213cbf1c00d13e2954dc950c9a544d162bbc0e43eb63f69e80293a7fc6c1c433219eb3ca2129cb33373ad3998ee976201939d2f3147eba3ee63ed417edbc2b59c38f8fa5e837e51d54b3f3c4595914f4da8141e970aa1aa1f3a722e16eef67d4878df086565f1a19cbb5f6caaf5411f4f256d09ab4d7fa20e31eddaf9935dfbb7a2a85ed3ae6d7c968a7fc7e1d82f3afd59caeb829ed2d68f81457e8379e8295fc4f8055e86ec493b02f7eadd075042e2de0375a0a4a6c6e076ad3e16326abc7ffc59438a8de3cc26c07f8e94283ded29f0b59b30a0085e0cfaad0d5b0921e2d3e0df4e76a7921985267b1f08da159780c3101c515c4ec24892165b004b7ae0f4d18be6467463a28fb09ab78c2dcfca1df145cfc0d4e94bd0a7c7877cdca874dccc90ef6fab7136a56ce3b88274facba5d865512f76e8825282688832ae7ab5e18ff451010851b6ee49b3a5c0de32532bd23985d403572c59a553c0900555e2d6a3d388b5e72c139f6b7f945d79b3208e2ddc07aa1ca84d93488ee3db7a2a69489cb0c960386d995b2f91f5de5aaff980c636fe8c023fecb7af1ce4e4539b8bab5b13671a6d7403ac6eedc5f3606b84b698a1ee60a0c85726f5241e28ec1956baa527fac40eb30ea58b26304b169732937b4ef4586f54376438aad7cc33e6343296de33ba19d10d967cf760a0051ee2164abb90a75e47f42f17481aeedf10b2212cae43398124038bd3cb60c2e91d589b0229a69f744f2813694539e610b4e28181b2021a7d5d6a865a40a2bd807ce59de91542dff2b7e879e1b28cc76c5bb7629ca859fde98776c81a222876c1895350e653f2dded483f12eadffb9fa46fa1f841804e2648e33fc6df083745ffe52ca696ea3220a167ef7214864431469e1481914b9334441fa001866e4253d0f97b66d22fd629f72fa26dcb526805506ac893bc44c255d2c0271979a05072b4a7f65db64d1840f08fe0ac4dde9717625a5011cd57763676f199495b6bf103e232ed1c3370888efb6b77ef539182e2e471899bdac40704a60b907ab93c21c0cc4ca74e28f11488b6508722ff62f0e98c5f4eeb3377a64a09e3aa40e55ebff000ceb64809453f489150805b67815688f18dea23442954b822e9646aab855ea8161a6656bf4b616d88f588f53c0138ee8498064e098862bd6ed4fdd7e297056ecf6e5807b5ac5fe0425a81257a285725f7fb829adeece93fc4d74289f083be283e7373e0fbaef29d527531b00e0005d56f48f99c3085875cd95d80dd079f1f23a9b2b2d0105c86a3bdd9d60aed039aad32e836c47f1dfd807aff0a85dc63f38905cb3297a16067f882aa089afbeb5a014e368e21652ff996f9a423dae97ca96400d9d9953c10f014b38ffeb6db21e55ea626ab41e23c0afdc7bddaefcccdf35aa961e8d5ef210ec55e28a7d945b3096a97d22cf15b864c855caf1d599eab8dc6e086f41c864c3b894f599759fa915eccf42405909810c083fcb88179faf6ba87b2fefecff7e3ace1bc73b14ee85e7d90a98cf4d275f10104e2bf4dfb8ab675621666c0366a0f0e10ea85dca23edfcda8cffe630ebcb4b71e835bef7bd00e2653dff53a944d6792e2a2e22e53b41abea34c50d1612a87ff48bfb12ba18905d44848e69119b85d76f98cd7f5094b677706fcaf56251904814bd53bbbe7c485778924b7d821f75112495cd606cdd12421d682108b8e89ab88af27a748190c4415a5c12c9c56858c5440fc757d7a64f2543f1c632748ed093204c1ffcd12b61b472bade2d4bb7241efa11fd057eae32537787694bffd918118e444d0ac17883f67ce2b02f47e49716acd619f0074fb82fe6a7ebf7a13ab38c6e9c298d6360b58c8dc4b992f52385a571f5180bef61c4263c40cb8ee1e8e50cc1b222767cafe565b969cea8aa5fbe10bf0c27a9ec7670f52d44906dcda705ac00690854d614f09364fafa7da3134a304df319c04baca0ea45843f3c375c2fb122852c25cb9407a09c83e618d7af187cde45c7d8044629660c4edeadc9c80b5114d529b3d4db7327abc9d9a5543ffddc119c35460a02a94406c79e1f3c8a6dbd152d8eb08b0ad1e521dab71c049b09dccada219cbc415491d19210a3a4b101fcc2356669fd97bcd58002e52b3a8eec79b08efd971ae3a86131b8c211891b08453ea21fe53601b9cf496325a9bdf836598e77c96b323daf80c302101774e10a529f93facbba20a4392d9c78d8e099f7e128a854fc565197bc6690eb7ab4106af1ea97acc076f3df847a22c1cb79cb7c6b5a8a8c4ef672dd16d38aab153550aee09ec7400043fa6eabfe5ae9ee8e7160b2b0821fce24e00fcc25ad59b348c6c8448198c31a0e2db942787669de4eb9e5483df61b2e0d1781acb4188f34a6525a52fb0a14787b8fc4dd4bed0caf64aa8000c4ea5669b110a523e03079e231e6bdfccdbd9b25032594e4da34b72cb3f2b48a91bb1b834c5d74c92e2d18e6910e75233975415f994a7d05de92d67dd67744168e88ec5a4e7ac7f57c83811872d20d54da39e801c9fd1a158a3fa7d7c826643b46815f15df99e499e383382273011a19186bd746889de593097aeb1c9280a25c6744367c210e43f6b141f2fdd7171fc0f88413f19be9488d04ffb2d8537726290daa9de6b8d530aefea644df6511786fc01815be1c6ed88986cf843b485430d8126e36dab843e312bac6f66aa4c80951144b9f4e3e4a5142c866e43bb6e258926c98efcb30fc8b550bb5510e04a1986c8004753ae862e96b3c54a6d09953d869e8d5941dcc98d4b60d564852bb1db420c24b9f9306bb3491bee399b4f718b447c9dd5df5aa8076158e73319c79e92cc12fb96135a48293606b42283801a454ce18bc24ad1185508f631e4454442a83a38bf7d6dfca2508cda28f071f6cca7a52911654ebfc3c0ffbbe13979e6e843a8b24ea99d448e500df960c3fc9e848bb4ba91d3eafa440bcdd545121e82b98f8d1088aada9d5b4a2b05a327f61e2c9354def6a107201b315f11f4e809e45bb31f127975c0538554280ff8938f9da125c0dde7a0b733edc9cb0526ac2b5cf4f95a0877bdc3126ab4d1228558c5a98d96eebf7b776109148a82d034f1b27784f8b0452b138cc79d6c889e51d5b532db338185fd3b4062ac62dd478bea59413d4b19b5c67e2a6f88ee0ff9c7f0e8e8c121e3e3c828a3e21fc42744b6940d58cfd99bedaff64e0ddc2a29a7a564795a6b17bd54c9268cd6436310a6cc4dce51b132a7c895ce8cd4199dd066f818715a9d5a2f936358c760227fd59157270b3f2ebbd3e3ebeac38f8629ad7c6ae277dfdaa2793899b98bd57744ca5380c85d63f00f2c3ef76adec20c4419184b684d1883ed5b776e4082611a46d283787d44d97880988181b567d593aeabc2a1fe0685eabd34ced6f31f5a99f6bf84cb552c9225f8f9d77b2db6eeca2185ed9bd89f364effef87b9f6520bd212d14499bbaecbddb2c438d35f45474d473a924c79f0f5d22965f1c734b1da99e4112d0767c7ac414b50e5c4fa9de8e9cebb9cd5dea89158267508aa34b4e2341d9b7f5a3ecd868bca1db261e2c162f2305a78f3e3da938997d61e918358ee947951a4bb66cafb6e8d91c5a4fe2db8bd8ef1d74d6b46c9bc8b66848f955a0a9f66efb29b2e25d6dbe6b4ae9cbf4a9fb775a539c1cfbdb53b4eda9f2fe037076948f8e14664b883dbbd56bcb56af8bffbd7cc76645ca98abdd163d40fa19964dd148edba3ebbf78f5f38450a36b191b7fff82039510208a1c104dc6741f0c439c1af59c3e74badec882f5f2f15897526007bcb52883214bcff27b6f049cacff8d00dfecd4526395a2ccb4d4d78c1848e5a4a5c6becc3a58020198b201cba34dc91281638073c1e110f0a6f3f66dcd7c502cc8596ac8cd22cc01eb9079c820d58d2f09a63d0b7e84ac70540280da7918cd261f178175fc3a9239a232909223fe0765c63a02df1067a56ce2f449d924b683752cb339a6b15135a9be2da115bf901087b71350aad5cd7014eaa14b9f48471a34714251ab1de0c9dbda472f70cc3f81b9592574daff8b072354a84e3ade662e104ce3dd00b3affea9c76a55ed32245bc56d8ec4eff1d51226a635b0d10e351cb3fee0359eab9542271874ed7614e320b24e8775070f8683bfcc3aaf8879e956dae5cf344124dce594e6caaacdad9a0cd4b6dd1da42ee1eac32b55525ac435e8044a401e587db7426a23fb4d21a42ca4e571d5274e4f6f164d46ad1dc2c39eabd9a8d8f865f0fbab845da9d1ea942df7c55ab28991f3a8dfc159fa1783709be984cf132a5dc2e4985018435257cb70a09b921c16c6a14bc6a531995d970ecf0276e0bad8d3661a7080d7c16b8e9d59b1a89c70ea3dda3caab1f3907f9108e19bb8d4833ee279b182b1b35980e1a6baacc174f4082ac7eacca37ac1f1eb25507c67182a54042e3d62c8d5d5605f1c53610b353e8c7c80a8f7bdb2b168f3bced2e74953b06cb9d079e540c435917e11c998be058ae8508de9d2fa1720282171adf5fcc3b54e274eaae7c7d991ca88999f3b15ec52d1680c0bd3696d9e619ad993d83bb04b5c65ea3d0b8e81c8a4ae7dde73d02a4ac36b5dbf27f3ad2337b16d289d148286a8991b461b0d526461f97182d9b65b826cac50d866788d1bd08f0289546289dc24a94193aaa3a8e48aea140582822d9040079b988f7e880dd6ea757f0afc01d869947a1141a34eeaf97613b47ab6f8599f7d546d0a53261e68f7abe49d0481d61e6e2e941b20e5e3422d6ea7e29be83e1e45a84a1bbdccfee1015541674dacc0fd8f33913222a532e0a93a8d63181ce3c0e07fa314550c77f4bdf8c2c8ffedf385dbe9bcc508cb7286c06a2747e3064eeb4abe5f90588d0213bc9270087caed9b9948cdd180978f123a8e2350a5b2ad4cb4c96cdf556dbf2e8b8a42851068a093c25bf87e37d7d53c1904061006b5258a4ca04215e8a0359eb2b6eb9b14f3d0e0dd35ae44959b888a986cbb1c3d47782b0db787e57f28bb0486cb980f8c41bc37a2ccf67f2a5d575fb36e02287d28be2fbd26a6b82abbc3e93ffc94e8d66d206d7f3adc4beaf1f3a82b588d76a02d1155aabfb15b7e8ffae1ae58d5487261f1d3919b8e138aad15fbe250a651bf4ee9731f433faf9028eb792d48071b1813465845861d33c620c9b91ba8875a247171fea50d1db9c1c5d81ca3273cc06df4ec4b5df104ed80cbcebdc5e869e91d4f6ccd553cbfa92aec936b1a751fc7fdb2d639fa65c4d9a89336fe3970a4cc333c44ea0142dd46215c37629d2922e7760c5ccc044e0f9085db34727fbbd99e330f822a648058c3d289a123a8ee0ef4d25f7bf6562b73a8138a83d9e5ac7c49c348970e75f6c977c426702161a1d87417b867f404a51e380a1eab8b4e6a311574b952a178bae2bded67d91bddca50956981d38cbdaf701c0e91896172e0343e9cda8dd3eb865808ed47a651d080cfcb5aaefd374b988154729227883d4368a0638261ab9170b362e3d48209ab448ed0211236d60d1cac6ddb9f1bcb02d8f3a3a1f48d4b6fb63129a185accc8f3c00ceb9e75e10fb1f4ec20abc8db152139a61b742581e2ef1fb48265129f6e81f4155581511980497caacf363cb07ea3b6d55de76d1073bb875d439d7725daeef16e24c124dff1d19fe4ccd417839827d4d0f0210ba03729e4d5eddb5529d7e8565bf2a33c414c9721241d700891952a01aefe758cbd9d08ac58ccf7cf2c6f7e121644449ac8a595f782c78c0163dac5d66181d8480caba8ca101beaac79971ed767d4908137460a12ba8fb285c08606da23903768b558c24ba77cb73fc3f796da10397b43149923c8274e32bee48cba583a6323086a63e0669e98378b35349525d5c66d17f2d07754f73b96f0f7e3785e2c9e55bee63d9d667ccfa5576706238834ebe045a1ad54aa5599b7db83f4fa59592a6b03f1bfcf5c2e47b5933f2b04f394a67c8fdba8768cf9722769513100c88ac64568ddc9d6339f7990310cfad188c6db6153f3b99a3ce49e8dd70b451ea43bc7ea47b2d4df921286d93c273458e13f358d96a6e82fb1b57d2dfab3fd8399ce1b2be26f54a080ab44228af12da20ac457d6104ab40a543644828bc8c152de5bd6309596943045b4a1d9e571e1ef9bbd525e53e929e97e7f00418fd2dc919428d0fb2e18fdde45ef935ee35c29d3002de6b514a0ea0141383af61d3d91dc12cdbcc2e084822c0aa03251f30683c48dcadb474bf02e09babc613e5b0a651a625a1935a99b95b9ff0b24e3d167813ff0094d29177b7224c90fd10e05fbb07cd6852f511cee5731db0fba4a73cbcdfa4e28900d087843e3741dfe928f2d4330c89831a2ee5959d5a553e5ee2fb04ff2e2372241b642e7dfd30e9e3a1f55142255c1a0c535ab570b3b473fba54841d7232a06cbfc920080f806848e66e944ebe430a1eb5b5f9af8541f90b35d86975cf3a0f906ea9bc47d808d3134789f74a3af67d58889a35af45a6f47d847c0f5ca8f2a8d37ed6e1c71b6d2462adf6176ed615bef7cb2e9228414767acf7ae9f692510d10621ddb4cf10ca243c1b206f11b34ffd429e953fd0b099cd0a8cd57374c86be40d024778235ff8996b809283c2b9476b0be43b4c3812035591a95b65a4aa7f0187fd526d8844adbd0f369323cb0201355631fd80b5f6065d8bde05442ff3fd488a18353298ef199c2e8bf206db21141fbe4a1fbda1a05127057d4822a6c463ed2bcb9be1e6b247b38f62658b4c48ed6a41f843f9f20f1caf8a163a712cf40c41ff063404424e20f43097a38889f0bd1c54824c81c6364291da4846ffabc210c80bf3d0feec2d5814b1de0eabbd20421c4508a889852b7149ce6603bdb26587cfdd40e79b1bf7de17414812d049945a987bb71f62998469476e95578a6d3c482c8bd4f3065b1d048c0223d0bda0f0889d60870fc6e8c0709a3ed63fc5007a15a3a77013900e5b064315a6414e637ba8ac386c4d6b56e8f1c88c5bae37b274fcf5f24fba07ec1734e46132e54f5833c72eed213121bc3c8ad3e025e87f0802538aba838885a9a67b8f6946197f16f2cb1afb0f58931d363365cf5b3ee1147a9742395331fe00f16b4581692e4270a5fbcdbf65aaff2e2a8e8dcc1c7d0478e9a15b0b9cf260246e7b3d6f4ae0a92e995b63b99528eec95822f35927526fed3bcb95945457d7a4ce0fc1771d2dc005971013dd0b586b1a9de2df37202e11fc22961e33dab166d51da355bc3722db9f862110a142738a4bf5bc9cba70a52627ee69d9fef5077d4d12773d47e9585cf7158778e9334cbb6412f8c98b166eb090140749906adf96efcee61b723ba47dd9435bba180709cd783bfb25b8d02eca30a49c2bd7c045c5c26e83d1b4d124f8ce3faf87fafa070dde3052ce785bcfd53d6d7c2e80d73f6f6da55f2414b65b0a57a86e08a1ef84e07d699655bf04c5c3082aa94c5cb02ba3acb2c9e7f833170f6f9f8525977cb6d48ea49f43228966d140570e4d3fb90c0e02995f206d5fbc162914017e06a14cbf613ac5cbb9dfa0e9285ebbc6b3b655e5b5c2b8914ae1421502a2dbcf28ee7a32848ffbffc7474cdb440ac02f92208449af08659aa57f978251a023588889f5f408a430ad9e3991bc60d8f5f85d2a279a87480e3ebee5e0cf3240cb7c13f8ea692ebf1d30b5500e41ec68cfe30f0e5d835fce1acf213998f84544389d6f60b8e494c89240779b18c2b7b8696c03888d98b670c1c9ee82187be37a117af94b82e85ef5a1b172a14b510b1bb13310b4edbe70b2961682d287fc3f13af9d1f570e09883679dbf6b9295880b9156957868141e3f523458bfee00e377b8007ff2050d88c8423829dd723c15f68c165882e14c5777a88573b7568006c4596f28be31746aa9f99f4f40bf322657f2cd9f32567bbec1430baa29b75f4198b12cfadd228001f77a47b0e60f25e1f581cd93e13cb7827c8117a191caf0703ae2f2d05bf900cd7a38aa4b4637de4c047a7d8e2d3a3b3c29a1df015a897b3a01e58ad3440529b01900c00a92894d38426e2199ba56644bd4bb3ad4695d6bca7c67dc3a77d63ea11470b56a14a78334317b7360b97659126ffe6d6b838cd9e0edc12d64050bc7c576a701958f04c6fba5bf4c2d9122a3a65125bcb9295b2b22a68f9c5ae9c91f52dc0122061fb1f72300badc42b114c71c90524ff8d8e5bbe5439ae45fb0dad56aa1aee4ed721693da52ce256c41d3d9fc48f158e25adcabd1e4f2014f92b8f1dc5e613c94e540566035955ac597a751dbc715f9833e3210e6c628e9a8c7bc301c1a8c2dbda6a41540c27d8899516b899e0f06b5463681ec3fc546078af783deed9eeb1555b5233b22021c192a21ba18f3581fc177e9928a2476197df9e4c0373ee7d4f0820b4fd3225a5c01d5d8fb9af90c2388a3423820f33c9e6dd62746f47f3dd6eb32eae770f569267686b43e39cef2532dc0e1de63363e337512152fb5ab03f84bd1214c7dc1bc6464ac8f93a4bcc40448719eea43337f7d6f38308c1faa3b48f9ed2249313988a5373cef7da8fe74dd40a8411fbe8f993d3ae06a0d179b2e3d7cd0f74f80a4c2b9efbd668b2dd1c95a5a1b02abf63e8c90b48fd55d207dd32a15a1201f0028452296c05161a7d2d149c47762f81cec8e28f359d06a2d0dd7a0f0becb67b130bc1ba110b69d7f475b90cf216fbe477b97db9fe7b05411f2ddec46d75bee1a7bbb168bb14c20e56b9cd21c2cd599dfff0e090c77dcceca4d5e59c4b3498beb28f7c865621747c71e337b1b78b2ff0648deee4fb018d5c3ceba5154a6be8c23a1598bcba88a9a56bfefc437ba44dfa8cfe841109c590217936f78fb3917cc93dd09a269b2e103dfe80cfcf937c12f18a4101259da936d9d0014648a8695f462efdc7c24c0a586327348fae49eb6ac0c42909c252f6c539c96addf141c97e22395155a80a48e5a0e2236bcc80733b26f614664f7ca94f9b877364a9bcc1145a512f792ae6268db94bf3714d4244bf835732689fd6ae474035638949744780a437e1b95e3ea6ac7eb7bbdf3453493b9d659a143a56259fcf36e8e9dd9a2cc3c654c9a98440baba50d0c0c97f1b5ab57168763a92ba046796823e6799e3c3bf20267fc1c91e118cdeb2976a79ea5daa46960fa575ee4448e45094d39a64900370e47d5f48aac9f4885efe2b18b3c3cb4279e1ff38fb4233d813970c39d4fd14087301244df6db2221b75cf91bfb4fe74fe4219178c2cc21ed20282983f69ceb47326c2ce6094d8a7da92813c5b676d8d59c14d283383399388488830fbdaf9515096b43ebb99027ad65b3622a25c79a5b5b7cedc4d771e8b5b139ea11a94fcf195e6774a3013835829163bbf2bbd6fcad717ad2a5dd63ab8b90e6fd2e1cd745c29f444b8704d614d71bc75cd069c780fa1551be3975b88db3f2cb1c32b9bef94cef74a7882b2b27e8c15dd5f586524fefe5732ff299def957127fee18a517cfda7fcbe29391f6445757d8011ef01ce2ab5f82e88b279f012c451911956b85f28bd872b5b1f1cabb34a3527e12d03cc787f0faebc3ed1a28da3dbb2cbecb757a98d82a6da049cd81d8075eb0634477cc72bc59d9882cd6b426a14c55268b449abd5134537c972db51c6cd741bc772c03d3076b540ad471c621c4e0964a54ac1c3e5978b760518c615720bf740f9a9c716c53d3c1a013ac38935c42d14e5876bf407aa806cd5d4e10292b54e979b61be99c850fbcdd182d5c3c9f4b6cdc911afe1d0fe4bb1e211a8622bd156753cb46cbc6e44a13a91572cd37c2a3be3a403a7e2d38ff29819f3f530a34ce58ce99600091f3d62801650a3e310996c0e3fcf660f26ea7f421c0d14ca55df5bb354a9f5f21a146286e944caffe7d4884ccaa92f3b38cd43a2bbd454fb11f1b1413c47cd64951878984c4f0edff65836d11ef0713f69ae1bd47bf0aef9a4474983ed0ff1054281114d1718c2fb3bd6e1626e94c4567f674daaef8da22caf118d43f93622b00102f8f2de03562e553020bf7b1b1e5ad2bb895563d359ea26a1b939f96e22615dfc18a8407fed4092eb7daf1991d6df5056f65a0ca054dda3438a50104ac2e3179cfbbaa1a11743eecee57a713fcc5e15395b355c1dcd5762a962e34a04af46f4b37993effd5d409d82508001a4f2418032d5d0bfce8458a3bcf9d4a16b98480ae45634554920de56ee160aa78d75b008902d00cc1db4c15121dbd9c02b6c06385336e19dd5666216f694fe56cc7f9da5fc2c41e0f4e547328e240de004cabf72b327da494d68a082d74b81c4076686148ba70dadf0f940ef246c9d1d53558a44dd9a7cc2de1e6ba160273da1f321937c1389e8d864d2f469ec942d73e6acecd199ba69c3dd67a5b63188a840b2f6195332d8b743f76d12e09bbb32bf7d7eff723d45fcb667c436b8ffb41687b533c2bcfa3934f6bf9b7302fa2454d24cb4fd2c09ac3a27e07e00b4092e43a483e66b4fd390aa2e920ed005cb9f22e03f311139433e1474a10a20c0be1620e02e1da4707810feef0669f120d95808d81c241aebef6480806bcffd390bf60077119fdafd9485c00fe62687d5185ee2dc37e9f530bb9c085158f62c4bd14014422440a6afff208671de5cc19d53351ce526cdfd1388874be8c045ecb8dd59d2ee105e83002482258c1461eb56810ce4988952c782ec256434c911ef478740f7a3e312a4a2533aadd16800d33371ff5f437b0202183220286c17cc9331514688c5631bbf3bd540173383580068429e8902e8490fffbd1f0e40a6d93e095d8169eb9be46cd75ab702d00372d7a34e6bb01077f58269cd4d3307aa0296d89b7e309b780a3f886200ccb138702fd9fb15a00b0ae44281831a591bd35e68aefeb4fb363a20e4991b9c2d68bd2413bc57e8652dc68937e7a9507ac3246c93980c1023351c1a03e6502de70cd246db06103a6719fe40cabd34291ad40d605cb86e0a2bb4c338e18a910c810167633e83a13133db7625e199ad14b61053c1a7600c9b40e537511504c04f7f2b2103146a590ba2abcb1d1c8e8f11960a8128d8cb16e01325171f90f4a87a7b47cf6718e0804b0cdfdb73982c7bef3d0ce4e439381b73b46ca47dbbde66ad4b76f1b818629efdf90fdf5c33d4b854c8c95b70f6b02bca126e64730ffb33cc5fc00382fcee92fd93ac100e86a919f093c41bfac37475171fb1189141a3edaab879fed084d38e8cf1ad73620783c74a92206a69dd8c7559e719c095c49a31a474924b373def310345aa9f142f35e32e9fd548c3c83d1d6b3c5434b9d685b5c7088cd559205ba89bc9c72cca55a06aae8eece119ce8e92ed172547ef479b1ceb0b770f93f1f99958c8d8822ca2b4fc34c14501a2930c2bc55eb87776243814cfb4cf7f9510bf3588d86df9eed3c06d744cecb16a7e227db7e8c0a1bb8393f5475f84a2ab6657407e3eed5a7541b336fb1fe1d30eaef3e3b0951ce726d19de97ac2a00bd76b5b8e7b9059b51544cb315609c77e749597ac8af107d4344aef87c034a2db0212fa7dad5b41ff214a17624c675d910902bd5b2620a4163789a0a554df23e82654c7d913d6088f8dc5f9b634018ef030741e149e3a07c551ecc69f860b81243469e5d1228e737e753ca22dfa1ba282918e814d1dd4c46c7f3d5303bf1f7551c174d09c1b5da4c3b65cc4bf435d63aa9ac2cffb2b783c64b4aa78eb1045b72f5b261434039cf030e6be75c90494f219d1368f29771d7c6c7481d5d30931daeedb4b0d178055435326abf57cc79f27efb6e7fe48d674ddb23c4269755bcb52522490dac96f931631f4aa30f4c7880e3a016ae1dd07a78db6370bc03ed230fd0731fa9ed5c406b441506435a837cad0bf908c47ea80ab8d1854396cb1d7a17aedbdb5d041a21a829ea3bd18141beabec1078a5d4861be2a5df7523423251e79137a4ad5ccc0754ebfae23a07fa5e7bacf934e775b2406d475a1d38f61a5eb3e504e6475fe1b3532e939e2206e7907e422d27b292ea26b3eb71fa4a4b5d81dddab3c9c31136eb1759fecc12adc39c5592fb6b7dafd027fb373d41a8c52f7f1044860d1aa82198fac2dffb6b1c168e3fb28143270b97411fd2016fc56c80c11592212bc5244e4161f7994462456eaff8bad7ac3862a90bfeb934d9ed5d6fd9f0302c6a5bef4ee8bbe477fb810c59fc7fc88107d2d461f142c934493d8c71836c55d528c72608f29e61c72eabdfd6c661ca332c5f7a4c5b8c33bec37c58fcf264b2f9acac74805d6daa6881e56a29f9c89bb8f8e2e95030e2f584c2dd5d7214b5b034507a5b50876ab177ce3bee9db080c81a8d83774f29fbadc18522443bca35ef5e5cb4de2fc242796615d872e534a479f60271a217ea55e7c6768409282a6c0ce2f4ee4300ad8beca034e874bbb541d0f1a75c8bca82e686d56a4f74e4ad59961d6bd21283bdc3baa5b6095af2422dade3e8358dbd22a472098b2cf78915e937c4d2b56f506ebe0beb2846e273f513191534d967614f26259507afbe2b91735f941e6b5438856858699bb4be9472e93ee473cc9f5992998477770cf51cc4551fc1c6544299b28a528e053fe2ea3cc3e2422b80a2fff9411f68ff25ac051759cd935dbe2a376af541e4eeb6ff00fe7528fcd93cb3bbbe61eea1b315fd3cd056f2c0986604f1c69a3b68521c1b4446709c2bfbde64aada314013cb05f5475828da9d930ae8fc059f863f6da704679f3fda2f3af39c0aae18ed17c60deb78c247440cb89c9904fb2e4371927eb48a4448bacb09de28d0c90ad35042413b4fd9ccf85f90ac06294925b407d084d95e5d99a2887e632015e557533a59b310e4a502bf63a590882e9f4aa981a2f533e7e779990decc8615db9eaf3f4ec9ca14ec9efd45384cdf17759c7bc7397f8d90f147a633c62e947ca8ebdd836118db7d0f87ec9b8c2302682742eebadffca7b68c1dd70b118140eb692029f48268dd4bd2f2beaec04c4285660c6199fd3d958f88174b0ef309a55d8637341f238e2ef6105be858970d90cdeb85dddd45b3bbc1bb15ae5b4657a3d4bd249878cf5cddad9fad9d360e36aa19948075c00d463445102b0a4b22720b319c441ad4542cd54ea476b709e08d5656ede3944a45040bb0c45aa9d7eafa5aa7b245a748bdd00743c67fe1380cc2af187eac5b2086b5628b88e2e9dd0d151124d14445812d5a5d6ba973a2cf8c91aa54f770bc452ca4fb037ac99e8a5830965d690e0ad946a98196a8665b4a6af312b5fbd1c80d5591f999dbe1f1b07e79abbef3978cb8b4d7f31c9ebcc6067f07f5a70034ad4ae8671cbd0b024ceddd3d6d6790fdcd36498e6ae67f19a3ec26224242b64c3225197c087d08a108e0ccd3d4d366cde8b3cc37ecc27afce50b62303cf5d8439a67113297b29beeb5dd7b510945a4b4a909961ad64bdbeb86076b4c310f998d1a7ce9853bb425f5211b5d9c0f6aadb5d6999c9c1c9a99275250617b410db9499167cf895b9e1d8b4fdc229b585368ad29a57be27c2913e99ce5622577736f96c596b56d725b8be3aed0d81281dc931535ec52413fe7176a5eb5a2aaa60bfdfc541f8d8f677e39dbdac0a38688258c49d3575810af2ee7bc33ecdb11e2bc8caf897d3c34828630c86e791b0e6117bbaeebfc41f086c3aea634cd350de50d61a9baa1baf140d6f702b4029341dd99711af0050dfd6840ea34d0effa5e744fe811e86f3ce477fde4e1108208f210830ef89df30b7bfcfa8edf2f947d637dac6783ff721f0cb21b99db1315035146a20d125913021c64e658301c2087a0f56d5151878b24949f7de1b660e9312f8c53907e2fba0a4004197cc13828bfbc93976f5c39bd62ce5bb13dd58d0e69087ddc183fe7898af2a697c3e345591380034490b920d43e65a1ae0fc60101d41843eaeecc7b57fa101ccde51736dddf4d71cd5e524ad9b54bbaed4ad3b8465123b8db0c6e94536837cf52064db634ead21b325232c2b448b0ac122d5a92b0202921e5dc3c2899ad199a9ab67cb72f7ba0a9a989cacbb98e819b9742d6f6105ac3420dc1596946a7b0d19d7dac25a9bfc532f39717c629cf5b9e3d8220e8965565f7090b751d6490636c3d984b8d64b36ab8becfc0a8dcdd97975a59a5503718cf34b8c95cf3c2ed352294f3e0334e4ebf50db7c4832d9fce43169eadbe6daf4bef6b676e67ac86f4eb7084e0fc8cd25d75cd3e6b866907e51f3ea67de635847376545d9beb1a50349295214284fe6f43aaffc16aa6a5de8772e2985946e38afcc252fa586f3c9535a6bd7b973389f3cb38fa9e4e7a7fa7979a4d4e4e50704ce241fb694baaea4399be9ee8a1aa6529b37bdcc0b857afbfdb6bdbfd047dcd2ed96dc34a56e10fcb4a8af536ddda5a7595918eded326a4a0cf68fcbdb9796f428d7a3398fbc365fec720cfb82fafb53fd7c7bffccd0a46a177a6730e843d5b48430c8ad60c9a575f70eef46625da8aacb85febae16e68ed9c47fa5b1e90eef1f5a61ba5f253fda82c177a210cceaf6af921428a74442a917755b468f91d0c4a974b04479b5f5e78f3976fdd11732a7138c7dca55afd859796ba2fbbbb7bb1b5dac2b0dd3c8b6654527af427cf630de69c17634d8d1ac7ecbb74fce57bf398733fa8a7fe189d34f4d7338b46e577efe5fd85d262b78684fbd7257f4a6fa0fe62b309344db32cb7d8f2994365dd983e3f70cef682f4c7680324e8f2186d82581ea3cdfc4276d58ffdebb71caaf9fd801d6d406bf90aed728d7a932f1e192fa7d7fe25d77fa07efac62dbd76a9d05e60aa2ace859ed33cbac671d6c57de6f12fe7c39ff5c679aa1be1c9b9934f3fc5d74e278e5f4369ccf90f9ff827f7e13f711f3fe7f9c4df3c8fffb2b81e4b4a15b4bccc47295268f2dab66dde3357e3f2382ff4890fe4839df3e9dc8701f6e91bd763713ef233e7381fcf3cf99b0724a8adfcfe3e114098f2f1e367aeed07947daa1becd37dfac5f558ce65bef1679eb6f143a1a7fc9bb74ddf20c8e1a92feda18d79f169d409daefd17c3dd268535318e775dc5e32b012854aadd504b5bd917ee8264dba0913dd648821a00c514411eb32429150620ea252cfd9910a13993ee72271d12e789bb014a49254924a4b52690ecda12586a4913492524619a5d1d30f29d72289cace46bf4f6851863ab5e8cdf6c8cd6fdba991ca338c92121a0b0dfd74a121643b109ec8f56cb48940b33d01f2057fe1d95f98a14fcf0ea49e9efd04438ca15008821c9e3d72cf46798aeeddb4cf1e90ea2701cf0e44752301cf9e80e7af9b9e9d39ced315c5c4ba13542a33186078fafd80e1a96bd97235eaff582c35fc7facd253bfb01cb42da49eb9c659f3341bb5451aa6672e3dcc33afb31cd367f8c8fd4c0ff9e50c4fbf1f333c75ad6ef2a401fe2016677d3ff36bcad6147c463bcda082fc8257f1e58c2adab0cf30551528b9064b0062cb5baefad1502175cc358db70df99b9e363df6f9e5a8b7bef6417d7f3f501f5fe8da0582134e385154c4a2a888225e8ac0c2d36a6a6a6ab2fc869c3c608209269898989af0d284238e38a2871e58f420851452ecb0038b1d90929292a4489142c482a8796593269a7869e2ca952b482081840e3ab0d0a10b5d78e9c210863004233c214a145144c1420450a040a15145155570af0d0985249248c208238cb882e515b37b27eae58a1a847bf60f48400212acb0c20a6ef69572594ad40b166a10fee625454b6859028b059650d2509126b45cc26084da0e64f9855d5fc82e6434d5c7d82fa7dfb59615b25b73adb889e134dd4ca54a60167437496080b6cbcc2c83c8cc15d076c1baddb0434644eb636bab309512ece593e5b28da821cd7f736358f996bcdd2755bf35e463b4e91af4c3a0cbe3af8da0c523d4b880eed46fe54dcbb6cdc3cda3af79db675edd7ecda39f79db6734e36c446e6ad6766d28eed48f728ee3504f9d8bd146f3328fba1633ec8bd186d6589fd257f6692d2b2ecdf7fb9917e7e4e10ce7210df5b04b65597ff6851e8d67713dd8755d9bb74354356fae27d3b48f3248bd6e5a1efbec91cd2e796389032d524a3d045799872f7e6f7edd65c5228295f36d0ac6550122a8750570ee8bd106f3b9db0732e8dd441bacc6e5d372ea31d7d3534a399bb0cebccdfb23be4051e5d2b0bbbbcddebc629f913690be734a39a574669ecdfcf125a7046d537c6c1748e2888d9c253956aef000a5e003acc1ad4c1cea96a00ed2228dd19090201f37d4d063878e1b3f4afae9a72dd470a73c71f2040a92230cce189f793604ce4dc2e02c6234898608c1c1870d35f0d881c306cf4e8c1b9066ee954b2231b8320a83445ab25c6152b25285ca126a8665df2ed9c1baea067fe6a1d0ca26ebd2882c92199147e6901b3187265167692ce067aec550a9190e19758d7e3764615a62702791df3f500fa55bd1af0814c4df5f10f93f74e07216bfea96fcf2922181eccb20fe1f2e8f5c9435de29d0625cb187d17bf9eb5547d9d4248339ee0301d920fe193e4a1e9ad0e212093717950d64c6459d6780cf98537f00467b125d51d6581e6370ef4bbae5eecdcc93c3b6cb6f264f12b8966971c6e56d04a707e677e6d3356c6f603fbdcf8537d7fc019b9661d49af28a33b210042f9d4aee4786a71c6394dc09fb82f053264c2dcba24d2d9f9427951b2dcef01688e6f1dea09b17675c9be665e06b8f8a019c6ffe00ee7b40dcc9a1fe582d0f14c4f442338466b06b1e91e655d66c2e838afa63630ce1748b86dd33c6fdc8f0976bd9a661ad794cb217d98b1734600d65668c3bd12f086b17132dd2a81e302326316118e63e91528c52a9024df58021eb4493199963ae5ae70fdae781b9e6fb1e1d41f51c56489a0211941419420633380857b00049127e2085084433588a275620c49617b0a0072c336888804a1048a868a20a4fcce09a26943cf8510ad315df04d247294d3c799b8f52988ef8ea122ff943a39fca467cea3e310ad9645451a530196149bf3ca15f2f8809295b30c412a867a84893e16c1e5dcb5c4b714dcbaa54a7c759799535f7433d738bfbf1c06318d074dadb1f75fe0192231a07e38dc9acd3db21aad4391a2e97bbfef5a35d946a795b3968e51d681abd894717d5b6bad553448a2165bf74a9996ec6532cbad44c37e329b9b56c41a56bb25d7eb79cf1fe5241ac6bdbcdc4231e00bc008394ec960d33d6f78bb20604cc2e5a903dad6bbb922c01b3b4f64df388366d3754f36aae5bfd85dd77c6f5b4df8821470c8f591bd76339c66d1a9723866fc7ac5e18ed9b07136368d7bc9818437bcba8a25a1e19a4d6b749cbda34548c1135ec9ed2484a92100d49256905ca132345380b63a13265899222a25d5aa52328478c0809daa1e3e60595294b9434d192d2111469444b962a549a2c61225cc4b414e56891ec91214278ece89c50f78bc1e04de784b835a12151a36bccb15b75a3f9d3c0de40a34e356f4fa34e9dd2b40c9a85213d6a9d132af751241834f9654ab50e894a5ddbe58da9947d52c9d7280525cdcab0b130a4cb8e721e328e68234129ddc6caa85fd8a1be13ffe988daceda974df141f3966faa9ffa96d7b71a0b1384106263d184a6b1ec392deba2eb3cdc81dffd2e2ab4cb67f22ac5a9da31d1a63d94df22e25c2ea5774ca8d2b5b9cca770c84feb4b459b6e3f0da1da68dad6e720e12b9ad6393366da56513ebcc804515f58a4502d6852b54b7533b50b8277ab1ec4cc8c0c142a005ed80d22069721966b1023738c7e33d328d48c754d992744bf52292506a9104a6666983a9927d4a5ca49dd1364922a0fa5aa102ef3841ae3c6ea12e3c61491c61e697695506751d441c0b7eb883a1786519fd3ebd05269449da58132f8a15ce897bb215df5535dbc7a7caf420d6945bdc8a8427eeb1ce705cd5749c781f254f2ab41e35d3c15e7d105d5bfbbdbaba775e7cde0a0e2f886a8ed3a3ca431ec5ca2be90f6f7c9480503370f14dd276a2d2a342621563097c9e5d30372a36ff463aefd6cfc80a6cbf83f1cf889dda0f1e966d1cc7f6cd3e5994794c570713566c71998676118cd328c2f66a6f344bf6d9b4c984867b22e05e044ed1db42d0f97c8a2310676c909c0894a599bb3a545a794ccdcf3d41fb5a4fc624d428b128749fb32b1bc3d20de4670cef9bc63e9b7b1664eec99e351c4e447ce0305c9970ebed00cea3fb6e9f90b89a8f3c0e447ce07c9182caf21f41ddb0b41f0ecd70f8b8d31f23cc92f08ff353474f57233691468bc727be52683f04b4aa34e7fd6c200b21f5a514746ecedfe66cffc79831ff46cd766df98d12656c9ddb8c10e2465479b58449bd3b2a6e5d79cdab5cd8d88dabcba68d816067b731d1195a30e75d630ca747940bf1c432407e118612c5f1e44ff03fd4b00e2ca4b1fa16f8e067e49afcb9a345c2b75d0e68d1e1a9a93799d977bf65aabde417f6a77bfd047aa5ab16d71736eebc3f042d4a9ce0e80a8e3c2e225e514a685f3f4ce777a8cafd3e99d53d7bae9311c9d934e8f9974a3d4b79d9376d43786f39da74937fa0191a11df58de17ca7cc3cc5b8666d5346e6a3d1a6fb42ec69cc1772e0395f87f162b4a1dec2db68433de571b4a1cec2eb6843fdc5857aa58ea2f344378fbe90e79cb36aa87e3ae5c231a78e612a8f866bd8a1502d6fd931d682a6dae53e93ebb99cdba1eee6a18f9cae8139758bebb93090f3a18d07e27c725fdbfc76f230c66f1ea67e6bf19b8700f84d00bf79585b6c9c6bdec273f15202f8751600589b5f47c5f8f5534dfd7e21c7c3994fc9fd5c4d4d4d587e36463190f3ada5861e3c7030c8d75e3eafbd3e1b3a18e4d09d41a6ab2b3eb8663b54f160706da0c120db88a90f7d8af7755df3db43158d2a27483f108de7d9a191d31dadcb53d5af20fdd607143d7ee0cd47a3435df781e1415d0f378d055573ccdb84bc755d5b04dbcada92a9d7a8534a2388056d8fb57cea111392f5906e21682728a0a861b57cdb64d0cb2fb47a72d176e23629a47a92492eed49c8aebc9c62cb23e726a1f168fe0a591e01a911d65a6badd9c6383db8863dcbb2ec8717e7e12e07355c234718276726f5ed982799183c625046914b8cf3f2b1150ee551a4f247466ac8579efbab592342542c28c69484966f9c75330de04211f5f8693954eca34335b47c792410fb3603edcf3af7b7c749e86d4b09f9abeb15db66ddd0cc10bee88f93fa9c2fbc183749d48dc11744d46e4954f7afebb268ed101c71c4113328df932fa6ba6179e69a0bbde69687ad67ae611ce792f34179272f6af2e45c8dd3873ab98f4eba7821ddb6faa950a713a5274a4f74a3dbb66d1b4737e77ab81a2906793f8f1fe59d3ccaa0c5a0e5f12dae46e6965b9ae6d1398f6e34745a2c790b31d03d9074909dc1964e635dd3eb94aa06c8d6e554653dd9b64fc7945ee70eaee1af3171b0121da5b5d6afa919aee994a83158892c46df9917d27cd6dd43bebf30dbb7da02176b0b0b31b8fe6e36045afca0a8518a14455e436d0cc6a6a6a62be20038b0031f747004490d6a108458852646b00491c4105de881e9a347169a4fa4f1289343659721aa524a29a5a4226758aedc95be7bc33838c86ec6e5c660506b98b7fbb59cd77565ceec960bfd7ae116f431a3d3773a8fac0cb647e7b731287d8300e53b1ed4b0eb9c2da719a719940c8495b18fb3458672390f8331dae98cdb58f6cb67d3fc726cdb36f789bf7d2ace8136b79cbbb1b9e5db6771ec855bd06fe691dbcd9c60f4ba6474e88ff2147a67ecd8b163cb10559e93ebb1badbb2acde295fb0d65afed39a9663d1e693ed21f5cbf2fa86047e5e3dd7e7fdfcda051acaf72d6b72be807d1e9e5b45b944b936512894e619f93088cba4177a0d3f2be6c9a8a2fac9bb5cf39327f4d30b9a7f7dbd8285a139e7856ce535e79199c69c8f3635edda5c5896652920be763114ce2f0cc33c73a10faaafcd29b78f81b0302e277f5dce23b34d46872a9dbfab4ad3f88e0d2fa25e4e7d078f1e35f8c41b7ce01024a46f72a8b7c768c97bddf02a7a2af78eefbc8a51e26c64967996383d62640b0931c618230efd43df8cf46c1d2999d9228ea56465233d2b913814cb87b40e75454a943ea49cc313991f136190fd08753f4e6942cb870de51b4a1ff12a0aafbceb3e904a8bcac70008f536137679bbc1061e12d23555188ca8eb9a93269299999971f60a1b607a746bc90a7539fe3c09957d9d3ce917b650796aeb64fa0b4c55e8e3ca0967233ef34ece82db44fa3691387b856ba6cfa57dd239b84b37d323cf25fa19a72c99459857464690cc2b3fdd479090214398b5947e7df9e055e41e744e1c3b74f06a3a2871e804e556010b740a6ac54fbfa8f5edd2122339e5a0451acd72f99665c588a08737311ef17e61e7f2e3d52523e2b091ace12fb530bcff8960fb0bd648e2e488a99561e30a4a94f87e82916f05c07cbb4c0c62008323abb9a5c5185165e6d24365d23bc9a5a8c3c42bece3222fa897c745a20b6ae6ce943d4ea7f263a368d32ed3828ab951f6599b530fc8a27669e9db271b855cb439e76d1283ed58921ab2d1c643ece6ad1506db3b26753aaf0a224e276baa2c155e49efb84cbed706df0b836fdf27bcea8854444847a2ef9076786818499c586b37ed5e30b8d4bb89e1139f69685a685b9820689126642c5566bc891263de704dcf3ac592bc2a538e1084a56722068b64cdf44d2aea91bb8568b9a8b9481671105ba6cff842bfde5c6f5462cdf424252566fae9dd961a5ffaee111253a912a5fb92d262de23b94b6e9c4c0f2353917bd7d53afd064969adb1db0b22da70103ffd26460ee3ec8ce9343e4a9122c987dd474c8aeaa1b0683d48d1f21aaa93a951e244f9fd6079d8813efe6d7d20d7e4203354c31d25bcf4f505449df8d2461434789523dd460b95b1e4c063870e1c3830387d7a0d0cce2984c119ada03bfcdc12fc5c15fcdc40ac9941d166b6cb8d322509afa89225db64fac47d72f9f43d9a484796fcf4357224dc6c98d37df02adc70e0d59cd7b59b656959b63da65fd6d20f0783d3614041ed8963fac4269d978312676d106ba6cf65f2d3b1b93df8e974ae107ece4d126da6f36f122068ccccccaafd6250b459df40d4e1df0dc49d9c180cf60e1c3418dca225b2d6dce6d6fdc3c9e7b7447ce4b746fc6d1183322ca8614c6af7893c6c0812c2ee433c9e70c3a16347c665de19739fa67d8b84419ecc8b7b844156498f4fe577c343ca2499b4f16f9a1d641c1c5c43237176c49a8d1d37106d3020c8a0a873f2e81bc8e118ebe3a01689ac91943aca2362b2435d6b2a29f5991dbaaeebbaaedf0bf3930780686343d648a7b5d3beb0738f483759b0ec152623e93cc4e096786d5318ac79cec22047d9a3a5366e40d09d911809e3ae4fa60675fa1e491c393454852a43831a0afd468e062dbc794b0bd70b83f68136703a508a323865665033df90823e8ec2c9cca0ae7314249943b4e176f74262242c731bfb2acb81a653b73e19555455f6ddc096eb914152978f1889716411d748afb5ebdc41f0e6e6480e49a22b6ac8455e7a0a5c8f52ae9044f5b5c8e53ed1c81146229d95508f52b46479b9e5a53391742ee255e632dc8c78253597d49b5a56f685d8961f50a84f3a0c2858a6f555b2322429addd90c489338686baa734462b1fabc8a1a018bc6383571247e6106ba48be0250a5efa255b303f39d475a1b2aff41e5cb3be54affcc62c72e3192e68bdebe2e2e22e5b48faeadadc2c3f9d7858c37cb5441ff6925d8279dbe43ab9ace5ed9594b759b410ad92eaed94c1e622069b3d2662b0e72687b4d4708b5a783b8e161e0eae69d7aa6b354fa37a291717afb5562fa4eff2753d78f48783b7680b35641ee2232b8308af56d253dec3c5db9728ea506fdf1da2cee5edcbc3cab09c2ed52b5d966f170fe316162fde8e4307e3b4700ce5cdf9a6b9ef74315ef8a7bc1e1955a04ecfc27b59226944e23011d7ac27f1235d914a441ad9264f185cdfbc85b247eb2dbcd5c23543bc24da308936395818442b8387648a068e2d59ae705c42a2e48912c6111a5a4e1eb9f0098b922752a4406aadb753bbbbbbf2a7012802be23113109df3836b1a65f3811553afb8b6fd7b183478fa26faf81573ef1697c4c0a179268517acc0b53db4ca6796fe0e6428ff96e5f482983429f65df22e155dc235ed83ef1e9d728a8dd337e478b0643beb3327a6767bb9ddf9dcec70e0d1b4af8751d3ba85c89e2d77bd460c30d5154f9f5a095b5b6e0d75333512cd1d0e0d9d911d241d3103f6841082b4b55c42778a8226507528ca089234cd11bdba9942b6b786cf903a41b1441ba019191e35819ec38a29c32858a1716c67a6497107c19dac163e88a0f7ebd061b8eac90f4eb3e78257fa55c41f2eb41bc82f9950245945f1fb24492fd86575b0415bfbffee21ac187315ed8a103c794756a344f10e3fa10e352042c0850a109235c01e999999931678c2ffa02119458025604233160295b7ec05b6ae60a49b6c8600b915f81168b5e074d7ebf201943a49747c443ce0ccc8be88c2cf32ec73c8a834acaf0ab6ec9d429fd9a0a9a365d220134bad514edce23d90be9df3098c51012c46096658e2d6a8f360bafc28d712212581669ca56d924a5a565da2b5ab67af242106734a08a2c0c9ebc38438b5a4b4f6e3a602ec0be1f5052cade5c5472db23961227566992654c850b4c9f655cb0e233c7a163e9b3cf9c8795cf32b781717646e672e3a3cc33127ce61add2eefa6ee73e6dadc4670b455cc53612eb44f9c3098790ff587229f81f2fe7ec81c6bb24bac9317671cbdf82cf31bf628e391b347fae68591e9337fc19e75f8e233e73d6230f36e0b95b32ca39e650eae8cf8996b99e699c69bdcb68f6ed907c4471c14da7a779452c66618a0a8eb71a56c2925cdbef5ddb02fd72365fca4f442ea34b6cb762267a811e9053d936f7e5a3410739348135a8bf90be6575def07ea5f1cf3eae5bb157bb916c3a8d38b7eaa8b5e583e7cd19cbea830ccc1a7fef2a9b0ef077c5ab11697f70355fda585b7cf5c0ecc2f7ef1ae162f15bb5e342cc394248e75246b2ebf288beaa8eb734d430d6dd4591deadbb90c8c731f1212281fe39d00664094e5db2f244bdf7e615ea37c75ce498c7330301e83f952f1a1caafbf20d960e8a3948f48499ebcf66d74f3cff3621c86175e50d1741d8cbbe07a605c7828e3303032309e0a06c6c157b90c8cca4527e32e641c46e5c26554debe0c97030646064625e30246e663230c765dd7c9b8e072742e1300ae068c07ed77305f1863636473f1aa858745950b173dd817eeb7e8626262d38d44525c0dfec20ec62fcfc98171ee0b853e5471eee231ce82eb89f954dcf7033ee7dc6e5c8c6b9ca7798cd77932f810e3a962dcc523832edd1719e43e55ccf703be8ba07e989c68b3309f2a487f8cff40719d331183d459703962bcfb82ecc3f800b81a305fcc57b359472f4ebbfae221a5270f9b3a753f4295a7d493883a3f16cbbbdca77e55e9a49ff6cb5b7890fd163d855721e79b5320ceab536f240dc5fd2c151f9c3ce6d5ab5f5efc137783f3ea91eb66aae7ad44e2acd2ca68a5842a79fad56530aa2ece4864803a8f71ea7c24eab8701dcea96b1ce732de792ebcfdcae588712ea6f3388fdc4f8c73cec32e3c368af1b84890fdeee3609c89ec6c1b756a00c950b4c3d5586d862d726e00ae061329c2d932ecd2625e5ca6510d2036c2202dc22075984f86a21ab2d1531a53845740310e63c405c62b77230686676bce679b4a504326e2232fbe01bdf83a4d79e57eb01b2ffb55c9da46394f1bd35f8e79d74719e430bf3e7a01e0af167f3917a95f1b14f552e21cc39c47b6f0e2a7bcb063e1f98b17ba605949a7ced4997af59a28dad0de21d65087810a9e3aea0b6b099e7a48e9c77dcc4818b42c670b64909178e56f792b59ada4f4964a45bf1ff0637cfdb0528a35836b29c12c0804104038e10a45145144112970c1898adad990a2a961ab33de3d188c314bd4231c85c1e5290c2e8ec6087836c033bb4d6c19246a285d4a22c6d92b49ba23f5caaf25a5e4d1757228d62c7599691c4d68e19af8389c186290ee60903d8672a989983fec899ab5155e8572e8957815caa45fefa39f3e9560405713273dc0fc92d715ff924c6c8065af5223920f4e3e22f9b0e497def2094496a74630af8d8afc651919511a312a4fd9c7c39707840a43bc5a621c4d736db90a0f3ea393d800eb5e0f7940b899b03872a88f68279a095914853f22daaccb2562cd7a1343520a6924b9208d48a5f8a11c6299442ac93c96d8a7ba8a5c97115e75d49138913acb845289087639fffea0512dbc9ada8759a10275120617492b915692a4920c22a8611fe1958aa78ab7a934156f5f4dea498e14a979b984c165d7d803d21bd27c288918dc2b356c251fb454a6fc7a53e115c7a89344d4f981a2395806d96f6f25bc5ad264251383bbc4e07692230c22f197528989c5692ab26689a8b35d9059f8f5b8494e2cd154244e03116bd675f0eb5484f856fa264233fdfac6b51223ea7afcb08ffc7a67e155d8479e0a4dd2b22e3dec6f24bce24f25bf9f220693f08a885794a5106bd6a9409fa8ac858eabf8954abf2e895a2e611a5e59e45712e129bcdaaf122fefbf36c90aafc27e42b704b1661da3d2a57252146d5f8614d4500e5d69a20d1b7cedb47137e754e2e7ec9aa8d3a7d6a045890fe9cb1c5143f6e9a91cd6d7f14f775e015ddf8cf585cb1caff01b05ddc26fd3af0562cdbafc7830b82ce74975437a7b372fb99e1b186c0689449b75a1b54ed4e9a60f37daf017065d208340aa1b1e9f667aa037438419e6af4f54d44c179abd4255eda11c52f5f7033ed166d929a28e64e297b7430783d7b724ea0c1101ddbbaed6214aeb9c1b462424935fdf116d9cd4908f48244994c8cf27fe1328b28618bd077b3d188c7328630230598badb8451b0b74df2c1e3d5c9ca086db5b9ef416bb25dd8a6f390562951b1827c7860944193b1646d4a16e5955cbb17c8765594e78ab27865dbe9c37833b9647ce46fca823a5b03427a7c39c1caee9a813df0606b718232aef30287b30c839d1a66d6090769188df8a800f0df0eb3611c7477c1175f697082124c1f2bb21dab4911ae62ce190810b4419a08fa863795fb922bffdc54d0c7065d844181b65070601d68dac1db448a339ad89e1f2566906e0e35c25a5655a98f5e85e5ca555b9c8a1d82a491c183a1c2d3006b04c2e72281603181cd99af9ee44f9f436d477aae1691e4f5fd25c275167fae9dba55d8a28770ef9396939e7bb4a279f1ee628a13eca600fe701d9cd0b5b5aabb449619092904fd04fea2ad5da75ab54b44634787664920a441b6ce8e0c138bd44ac8853442c3c8b2fc69acbfb8b31acf9bdb8494151716e78782fda48d77648f28dac911e6de4cdfc68a8a82d65a6a8ec4745d84650c394dc995d44db46109932bbc7b8e920bfbf2500d1c347ee068a0692892786687ca8d8b9c9a1028848eb151f5061830fbb296e6213665ebe904285114ec9d2829597017829bd6aa1e9a5775998f0d23dc92a4a9962cb33dd9ce761266853816d7bed98846f1644e15b04397437934acd2c121fa6c2992c0cadb2e0032d90e099675650250475671894528a24f099e974c1ee96a0ead0644a50d935d4ee2e6a654b6959444c305fe95a733d2b5fb4d750ddeaa3fda804aed594450c15cd0800000100d313000028100c878322a16038225486bdfb14800c939e48704c9948b32488610819438801c6004080000000880cd4700009dd20dca2aa5afa9afca0dd75e59634311931015bdbe0da8ffd5215f448bff39d24ca1de2a9232d4b5e224fe7ebbf0d414e6c57963438b4a7342de4c6c136bfb2093a2c4bd95b402357b3f6373c8663a0e351e7b3e2f822c041d8fa5c9020c13cbeaafcae21b08aae16a6ddc85bc7f6a055fedc919be326a1b3e62de1d1e8c1c1e23e0dd005b07274150f5e025a5336a71f083388aa2454d400ef55497b83cf7ff99d349b5d07bac35e2db77ff33ca77aa92ca7bb9b9e2d61fe3749a7aa7842742d7215b3ae6f11899708283f6b0a7cc59646de20bc494ac9624abb362bbf8a1091610d143fb624c877978618aab294c8dec23edac1ea9c6e900115f27c93156b8e96aa442dbe90c481029742adadd125e84da761aacafd3b199f307160bc978c1df85c80c2b2ed318ef84370544d4f208b37aac1e51a3d90394c997a696042ef0dbe1c6a9ac5342df35bb9ca6c552c062c17be53f5976ba150ab9066830ba7e7c09a5f86389fcfa65e5fed146058db8fa3132ca8110bfc6c771300cb2762f9cf43fc80fc2d5f040149e52c7ec24287026f79c8bfdb3949ce2a856f825af5e2f490cfb8a3f91db3bd2e10a54dee28460eac90f597f70d241c4dccdd4825acb3cb2b98ad90db77d1a41aa013c92a2a720d50e44ec56bfec673d1f3ec3278c305aee30f888f925d51c2469b5e1324e0c748b42cc45745770c4d6c79d5918c9b860b01e411b84f8c21390376b0518c872920b5fb35944b6130d7d4be525d01397730a074dc2ad603f7e73f971ac5012789159af73f7212c94a6db576975379a7ea03d9b9be2a2cf5898b043473315571883682f6dace4eaaa1c12eb5e798f615712a7619fc3b754c0a578be9a8a0ab7aee676247f2334c58a01d971503fefcf0b40d80c29cf5fd32a1e0d67919b544b47242d21e65ed4fdbb30d66b924421a52513a613156f7873c42f9adc157d34f64aa51ac629281f42f4aa920fb6d2c6ab40d23cd412a8be4066419d4c3ed17efe37a4177a9e9a15c7a93e611f82fd2fd42fd368af78a74c39b2e5299b1b354a43a4872b925b16e6abb4ce24d6f918c9176105bd0b75bcd6056517444140fe0ccccbf15271e946784d176db4d9988239f6dad8a20f30c14fc208e28b71334417cd67a085ef505844761ab08e8ae2c249a6f76876a7628c4a30c41bb85a0740538c2d3154649755010c427715435fa0cdc5673d4acf1f18dc894efe9bd0c86cceddcd925d61cdd930c7e92e8dffb199466439a76425dc7264836414168a60d7c7c460b526a6c9e63893c384b6927406aabef866a8fe261a89653d27134ccc90213c1de69f165ccff639c3645879196f542a8e8234c228487e89e13af1f09657661acb8d3db0cb6f01ba890c171f650b9f9150bbceab715a7838505ae82f0e0db7f5edbef5fe7a3f1b3b43336220dbf2b34aaf3bca7ab03dd47ca78bbd82f1aa0aa180e720294a6b412dc5462c43d78d6d2826550b21d74ca34a493251e630fe9a02f8fabd0df615386c7a2c5401e8c561e0a18c010e5de6987b712a0632c2413e8e755fa8cb5f0fd91e69c09c0c9139ebd4f5fe2d10f512195741192d1b240f46f183180e7461db0c06783e29ed9297b622f84e427eff4ac0e6834152d2d9f1c4d38f1262347aa43a971ba173ec279556def4501cbfb1174a368b208552b9c932c70e362334d30e1e18e2abf0dca142d845ab254d86b8102306ed2a38a94f93803c84702832fa181dd429b9b3c5d90b19763e869c695a1e908d4caaa7535361f510e3954804d37665c95e7fab493f15351c3d9d4abbdee89d0825e349c464f1bee58e753c8ff809464b1fbb97d7d04a7df629bff53e330f4814bbceb0f6a9099bfce1fbe89e7a7191d2cb376f9523ff21c256d255d86528c9a711d9834c57e0084aa1aee62fba297c141f94542af17d16e034d67f852b40bf5e987f3d60c9d57a80c04ea4871020afaa6571462f0d578e7bf63ff15b037241998d29598b780d7dca44d408cac5074203adb43c233be80eb1716c808ff357697687ff94ea145558827171d496c72eb686c2729f53f625eb23985161c86699671b5a4a9f9fb5e223daa4f3b958f176f36d015b0ccb49386f213640c2236169e12417b96a98ffda00c0480fa9c37b9c5abd0be3e7d150f597a92303bd5ca4e44643a3c784ce4e4a0e03e16bc4cbc9934f47379a857edf7db0f2cba00641430ae557cceb1904b144a79ff96dc7980aaffb59868cc876f8e6f7f66e3c6677963b4ce66cbad0af1f602c92342e8cc271956b07997de2bc57cf15a5b10d38f4a07ecefc56834e861408a5d49331409c942199bd23ef4dceb31eb46dce3a3d80a5c3658898f48ba87825019957a0df597187eb94311f8bdcfd900f201d26e95987b5729d33cb2d962ba87696385f8e581643698c3cd340c1acc2297d60c310e01cd432ccc5aa09d07432f5d7873921004a23b0f79a74dc57ad1d25bfdaf46784a07f99250f295b8979b9f53f44160be349eef72fad770be7f9f2f29c6af739dbfc56215dd9200b984cba500c0f0970af738e8269daf51804e2cc4276c6816b3dbd7289c11b31558a0f1ce2828d3e57b3116a08a1420bd3720aab6f192c3b79fd048b236bb6d939468eb40a42bf3fc1729cdb13ed4adb5cd07a20b000692215101c69044aaaae9be6059419bde47b36c59e3adaaacf2847bbcc53b40c49a1ceebf3e41f0a6f860b96e5781cdd77ed13a17c514c79fd63e0efdfade5b7e42966bf01b26b66241c420648c963efbd2c77cfc23537b8129238a52662238df54fe86d034d148ace6a6fca08cfd93c727180f7e4746e31bfc996fbb716f50405cdf73cb3cf3fabbd903188d004082a4abf015834262147446efe8d8dd6604c167014089af7ce42e8f72c0e469e2e7397e7cac04bec763e0ac3ca010981426de769763aaa5a7f754341404c95de448d6f17bc28bd529ee73b778a71e8afca0690dc21437540eab81d154c54f3864f4bc4633baccb8cf5ef24660674fe1eb1d957ecd918dab6ebeb9d7329ab46ac0a68c235b17a907b1fbedc7bfe0612dc48896c3df126f31e2dd72bc09d37a00aff8d34371961281ff161864414cff36a8c30df6734fdcc5c6d584cfd570db31650548b8e3921d810c7515fc38959797d35d05f8907e7a589fdb66cf93dccde7015eea4b477bad37a7915dddf57bf30fa41dc0383ae21b8d6b8a626600da36929df5fea8ade354f6c33f03bf5c700b5fd100662b02dc896f80628802c6180713432b30fffdcd6d09229190db25b9a1dc2155185ef204f7dfdbc40ad3e34117b38b751eea17601dd9f532ecee32c969dc776681b82e572593b141f8c5ae3d5c53cca0ba3d3a9a929fdc2f1b9df3c90fe3ac3f89dcadc915c96012a471d30445606cc0541accc1fec4c553ae757eb41904b1aed5972404b1cb7f313023492201124624c1b555aebd6560270f6ec8bdcf40459695636107c71b07d2d33544b90fe6ac6334021edb7a745cbb0cdb283ac2a3412f6db9b3964ed648f4026a0268bd043cf1d1e30fe31cb8e01f3ea1a79c9ed6647dc716c7e12d79b6529c615ef26e32c0e0b1166acd27914d86e486bed0d58483b50260b346662b33684b5f457bcbba8b641a06b43c91da667ab9d8bbe8372b36552eca1ad4181bbcd31fdc68f6858944a9a44facecd3d4d84d92a74fc128235a588eb5ce2ccd1d99bb55b487e7157089a3dba512e155abfa965ab709720cc41f4d37a80b2265372131e7d3e33440673fd712afb30b1adc156bc7b76613277366f0dac9b384b8576e25db4090468a168d7ee5c6428ec8347623a966b7864383a8cc1b89029881f57d082b8aed7bfc98520cb0a0c028546be03a96e43452b2e9765ac6002d3974b8918a83a9a7e81c4a325f4b6cd81591b71332f4a618c2779b4888b5d57252e01873c42eed7d6f97790915faf5dd4f6baced960713605bea04ba10e9dfa1875e25c8055d0a624d6a8c2d678d552a7c2011f07889875b186834f34e828664173c91e3ff911e0e468923c7f3f16bdcc972625d31d2951a9da9b774e52a8ea50de478a2fca306fe0714ce62cd930a4af170a960f1bab12f2b32bc4ec8402bb2a3ff715dbee0da5195e3693ab80ffe2e48d70045621e38b251be0d694c0ac52c743a4c8466ec9869208249fdf927da41419449c0d10ad8dc4856a6ab61cf3c4f3530aca118c9da9f75b8467b4d274923091f1ec907c5faff87e8440caafbde12ea7738dac5fc2083286ad184275ef0115dea24c90d27a3e7952da82228069d10f5a7b54490993201b56a965404ca77d150ac2cbeb8965357e918f2e44d5bbde7b6c1a436c5c176a0d8798c6ee032c994a5bc013b63ec44a497df795e9be5e6a93973c1778e87b0dee153ba3111c76f7fddbf51eb3e4296e2b0774626986094b46f119beb9bc0b98f58dd7a28ad4558a6bbc16b26d1949a4f20ecbaba5ffae23fde5c84edbd99d8be066ae45358a39789de03320a4b5385ceb3a994c6fecc5d216ddd60222932135ed734ddd9dc94a4c2cf6595949b866f9009589d5f04f227144f334280aad7ef35f911fdd5fcb3509f00300d0e8b8ed767205d194523c0981162ef2f68b7585f09b350beb5081c554fc3fffaefb62616658df3e2fe20b90cd20a0ec921eb92a7a40feb741c3b62af3d7212572626f0ec2822ba98556ebda4633595b8283617ad44c12a34ea36893e13beda9034d41baa6131e34ab519824078c529143c7cce69adb32fac5c1c4d8ade68d5ec54afb464adb9ebf8c62ee00ac756c8622cfab0bd9e33c20e9e456d8e199c46a3196dd3fde8b20b48f484e796e996233725151694477ea6759355246321e0a417748ca8298a7de89318249937a9c666320628ca5e6cf41f3f70e80327a851d8c87115eabf70f08880f36bace5d1349afe81f7ac53ebcf5bfa6d9a7d70e1e21d555adf9abb0e69992563df9e4676f5dfda19af52fb4116c3708ba05df8e94fff2a25228b67123cff8cc27322ccda8613309ffd6bc7ad4fc19458d4aa3c1090acb97be405b6884096d8a1db76f1ddf6c25e6950c773dc305b8000fa12677824e889f7780c3f58d5e06d31d59000e69bc80cd3159d0cec246217cca0c789e89c18563fa7f5ddb8f2f3afa23f3cdc3d747da7f585e55636f31c440d6f98c0745af4b8f979fdf1233c1c3e4f6090518f8fe8a1f8969e9fbdaebef4c42988a183dfeaeaabb0c6d6b81225020b24c1dc024292d089152f929f78ac38c558532dc11aa61cac20a42422ceda7801731512b2aced2719568fabd0ca9b50d03f4c2d857ae6e594cd02be71c933e390a1e2606aee9c11964bd0c664cd7fc1d1188daf8cf8c06f9b4687dc6c0d55fc69d46e3b14b44803b900210151fc5558af6a7c0d6e598d93f4c646416f02bd6578997d715d2e65e4e3752857beca974f1b455d29fea33103d81d57ce727946558c824e0bc1a7892862f21f4d3b68f34135caf6ff28657b763e09882a0ed6abbd850920c100243bd933824e38274056813eb4920ae0d6f36d75dc0e1057ac4715498c75fef8d07b96fb01b247f5cbaf374082fb1771530932f0ae8f37e3297f52d9eada46ff62878d0f64f980330232c20ad2fb4e019c6194aa0f488905a4abcccc39720d975399c72f9fc4410a424302d223ba79b42496b423c70c195144aa39852505affc30c7cc256666453b99267036a9a424fb2539077833ea2a51249dea5e18d563149f6f1a318baf83cf1865b70862142a830106c7d50947ade7ccccd2a6dd6e5a7cbec346c77d2c8d8ec129cd2e95c0223573155a33755b79c3563325f7864e499dc417e7b1e7d9658cf1b592ac3cc696c919654c065cb9665105887b96fb82d74b0d3292c827cead6353f256d147547742048249ca7ef427c41e07681733244c80a215df82578f6111384fc41704d8c07069487266ea50cdde1ac85f58bba9519eb58df750caedafe526add6fc524b407f7871e2270b1a99cb9b8db9ab0e729419a7af3e43dc87a939cec01af8ade59ab03255375adbd05e84bc890e5161181f9451275ad96246097488203191e17f4411f1abf5f27b80ad747c05069095a27f868e4cf942cfc66b43521c470375540e77c16818f97cacdd9e3e98f855b19b823ee9706fd4b500c3cf93d89847b59f7eaf4a42dfce519b4f89a7c351712c1a90f2fb6c9d67c3f82b55b0a2c4163b025d47502a386fad84057858353843b360e183301bfc89682888706025b9f6b7299716d1f848a4fb5f9b7432dd908ffe227868f69760423137a550bed1954f534a2f30f4cecaeefb354a013b04f2270fca28f78e5758675418028521af78453fafb9498d12b3b215f7360ac9e67b3e505b4a80d49d364c9fa498704c90aaa7676fc1f921be80c5cbfe9d4494a98e751111f241db28fed0818722f0fbc4964db64680e80b204b7a2afc78348627e8478d32e959d1c82c50b38074b1ab75e36cdd173984a2fbb01099571668760fa0222fd0fbc85dce25eac6054e80a731d609998a9f20c5f2b45382e6621eeb9f4dcd96d1703e5dcb2127ce3acb1cf292fe33f5d782e521807d9e015e2b28b2c508a7b4829b4e9aec6762ecf3c615d6807150a5a6c29b54769ab35c8b141c94c2ab40f1023294cc8625c1628c3549542d747f609a6d59b798f93c1b6a462291c0f6ed14148b12f268d105b0eab2e9903e8d11a3978710ac0283e5eb6266f66fb9d83be825a448f10e23cce8bc492cf69ad98bf2cef0eaf142aa6900e25b54d3c3dc08891d1d3b42f7154b1dc2ec01a27460c7ed43fe52613b394ba8bf64012c69fece2da9d2de1ebdf37123818494b43962b94f447282a46cba10294b04dd63958aa0581582a40caea7ecfc1d84be1facc52fd564f0e74f6a324c6e2eba40c3e8426c8de38c65d7995ab04f6ace39e0918c93532a754bfe2c2774c24c7a2ca1d87bb33e99141864136b61bc14d72a384289cba06bc219300949f31a9a778f62f1f60983132ee894025e765542fe0fb40b1ac8d2994c3cae368ae172408883e6b2f6edf79a28082cf49a4b01352ba9a9c3c4e15d6fa5a75cadf0c03811a5872102c20c25a93fab976e68432e53fb3ec9816bb8d2b4c34f17897ebe7839157e91a48910d45af96b8b873c9308d45250b2b6110a3d7b68e9476ca7b0751c2c1d09b18187a9677469cc8c347b510a82b806a5e7a07c6ab840765ef470c1f241a8980e58592168e6d5a930b2a75b3c6cac3d502590fc1604934891885e22177e6f0e7dbf1dc58638740f0a99498ed0c09378bb2e2409e649494e3bbbede9cefad5605a71f165ae02cb95fd8c429f11c90f833588e3196887739a7a601b79f8a88e217889e9d9ebec8d78300efefdcd366c66ee8e2a4f04cca85f655411b0d462aedf983382a3102bde20cbd557d6111474348762a2cce94880c38bf375f3082eb411f98b195319a38e54b95b30ab67cd0992672973f5b8e5daf3a18f8920f4759550ec60dfe6686ae5c493307dd27b859ccbb435460fabc324c0661d7c3962c166df6a8e7ee57d24cce03cf7e3f91b022f9341a5edcd92429fa660f0cab7df49f410bcd49607eb570bfeb076450060a2fc2868317eb8dce322c4139f6af4a74aa924e150d22237a40e7077e5c6be92b35bc36f4330d18008a3f8e1f4401fc8947e13b550e456253145378ab31b860f6d55bdf18f85ecf427a501fd6a072ea811045d3b7d64c71c2044848c54e90ee0bfd57e769b9edf13b942b5dc9c87d8b26bbc388529714b13377879787174c11fc9a4c52ad2e8c8297d538570cd80129c05bb09fcf20c7f16bb1bb8b13574a968191d49bd9922f133f0585d2d28cce49a3e8e093d1807cd2fe6847bbc3dfc2544a0778135cddc975b4c2a446c1f1541aa6e7c14bd95ad45eab1ac7b7556c593a1e963db893bba114f47ec834268f52ebc9ec5446d9d482526a817a4040121983b1d5b341c18f0548b77043d05d2c1da7dc2bb293b6a78870b7bb13a4c5b6d1ff8cea38e8fa0aa2e58545d9fbe079886d86efcc914635d6232ce5cef98366c512bc44f19f10990313084c030a1680706077b0323cc3b7754e66b5c97f8a89a1017e52bc1eef54914d890a66db1445fe2a498cb468765560e13020d1e203e07b6c22dc0b9f5e4171692cf93c598243e755bace0bf4c7dba93ca43beaaffcfc766dec37207f124261707f29a3c7f69f2b63f4bbe648b546b646873ba2a6050c62555f9b90442996325927c12809383b6e3593a63e57ce7f4e144813ea4583de201ea1a0c4191bc9e6ce7e144c9bcca616656ddba1ba6b22352b4437a7e0530600c387ee178f170ed68914c09d6cda4bd9cd0d3095a1c04f552b6d5e6a9ece4ceb8a73653a0d6312382e90e475a82011dc000c24c3cf6e2a77809c13994a153e61b5b5fd2c212acdea1dd3e60d66bf0dad8bbd67102df47a894bbcf9c9edf8241bb2d41e5926601a5ddf9a077fd99a94f90ab62a772f23bc7b5f4cb4cea20b5d5bf174330cb854be6030f0de0f861a9685b52260c8971318188391fd878370499864dc085553f72894f62d43ee0ea2968a40e4d2706e14e1d58fb20086bacba6065df12d25f975aed98f1d8426e42342b0a7d72898b1afcadf221a04b4e3ec25810535e754fa859233020d18c8f5b698abc9c724c8df9aa89f13ecdd7246c168bf0ccb6ecc72f1770ab3caeacbfea6ef7688b372b37fbd5299b4a7597ceee1a8c28a6d579f145024359c3fc818427abc7b00fc2bfd0484cf64e553bd5960ac927d99dafb1df50671ece236ab00aa95865e5a846247bb2f9785b8a98a12d315aa0f3e8aa27df2bc78c8b14a5451f07d0ff14a2cd2f7aa05d4056d83355108ef23039faee12ce65999607792389c47a59a854f80fedd2e0e8bff06985308825fc0542532a37bb8b6f4b42a2d03de6fbaaf2828550f835e4d25965dd6be4e4e3086e8dbf4926a9d35207efd0b8869ceceb6c954aad219d6cf0bb5074a32e4004ee10f141be7daaab594a6a54da68a5294945d618d7ae114869429a26f114712f317b76db41d706ed46387b4e98a4efc8f8726d11576c01978dbcefa04d89ea3af844abbd565a5a7049ebd874cf55afccbd604b37b9c1b6d351ddd38536e123ca122f6ca7501e3f615bfaa851f4ad4420f7b5e233ce2be4355908950e14d0c340edf7e86a9538acb1d95863fee10a9e8ffa3e3467418da2c29753d5d44ad1a1c2508603f9ee45488a64495835114d0bc8052cb1136db9408d7012c16f26b0714f6b3386dfe427da4d91410d060db25be14bbca4a9266eefa61a925e1f2c76c41e750c6853fc1bacffdd19fee4df57c4f6262d42acffb3b4f99e87cb8a5967f48358755ae2ee4959278ec6fd1b88a4af4e1f3b3d88fefa36dc9e69f7493af129de185308c37f617c20ca7709486f2ad6f861d9eba24a182d31d42da77de924f812116f7ae5ca1e0937ccab6e294df5735573156ad6408f0ffb5f2cc522f8aa2e45d26f1a3056f0617f7a9f0c2630eabe235f784f52d1a34b324283994750831e47057c471e58c71bd6ac7f98f80ca55a971a44561a1e0353c9004a69290d6f1afd31ded80ac9973679765436a0b5293c66b99a3365777d9374f9f57c3052ee43060a88652a1878974c0a580576b0b54630a1348b903cff8876b868092046c2604adda5bd2596698511354b5de38320ab68770b8bafef16839c3c103b23bf4031673021fae0ca1e51919e5ee771da6f61a3e53c8a1e40437e22c2ea24421f919dfba8439a9b342469924e0513d5345ba5c48692f8c97f5d7c27017d606aa5208c75d71fda27c0899787b80fa4cbf22bf0a845ba5eb23505669d311eb0b73d38a1cce49b790dfe5815f450a017f43e5b18d8ca716a24ff0a8942c5037c35e7d2bf9ba06900463a0bef179b41c1a8e2f8cb0042860a6d8dcd559f9e32563b64d2a7bf884207f0ceeaaeb989269a17817f00fab2f82a12e22a82e7bc5469504119c333b038140ca7e661e2c6bd2a1afd13a3f274ec57d5f6eba29640dd0ffd58d84f2abce33b853f67423f71418964d0304ce320eb258c6b4caa2a02109b9db6fa85acfe862cc417e1398eb77419975ff470ede78b70390824737e595141689d46b42ff0897c1d2bc39261417620a84c1a1ef37c23c23a81b0063aa9e3bcdcceedf3a92c303d83e5db4c831dedbf0c6a453c4e319d499c5b5472a8e3f943f70f15a69f6a03cf1ef5cd58091bada4d477b9cda5967b05e43ef11710ce3f2f22b9d0c00055b1ef3286734539dc24ebfc3fc5b15319f7d4e429ff34a9e675c7b9e53e0f5ad0854ae2a8940681c5bfe93ecf5109b77c23e9a1a66a32762343e5772359b7b8f0045a11e9827b6602631ac77748c1d72cbcb3341ee8acdc82c3ee932909098031c0453d850fcd91720d6a44b25c300da5d260edd8b9c89ad1c4703cf85765a9038dac7c75351b6c8fb300f6cfea754e0eeaa69f5628191f80e9e9c57095c6a50f5e3ceb59b80d2e03a92dd3de0e682d8392b1e86db2eb6d35a5226b82edd21a5b2cc130b38210660c916db844fbcd8820b617a23d26a7cdfc029df26f3828aabd37e234b1d487b60acaf5416b1903a93fda8508676d0d4e11b42c749d3d2792b112193f47d6edee08acb7d57278db26033c4f468ec11e1cc491455703e50b3a9866356c1b4380200630b3904c84055bd05fce3cf857bf9383d35327dde33e8880c76f2cc7fa224a1d79c8cb82ca398d7501f107684bbaf541488e2d36beeafaae53b6b994df740b2576b2077c34cde0900c4ae56d1b3b3cc0a17c318b0951f5431c2ba3ea04cacbcb7dcb403b24d2a86fbc9fd9a8d60554fa9b4ec494608cd1e16b880b104579c006e1aa461580926dab98571cdf09e2784016d79086695bcc72f9fbcc6014c275567834db7c6dd1cb9dcffc53ad71e30ead1101227918c297af27d32afc20e7cf886b29097881b720fa847ca6038cacfd89d4c2edd2546886b10da2d1e79d8e196d0ea4a4cb3f3db04629afc1a239ded3d1ea5e52c87931e44479f0b8bc0b8edc86e280d3684a3706950558aeee4f0d2de26c1574dc399fc351f4838f184704f5be7500f9a3ac542a518c1c448db572d0516c0346b8d5a88ca276cafc39f08838a80b43bd4f0ce58ed642a5e3092dd21b0be6bbde0680e6091c440ee1a29bb9030b451701afa4ea1de2d6b498320b01462e9ac2aa8214ae50998cc7a8e6a933bdd2886b3fd0499d56119a2b8021ae2c4911bff58ca5f621b29c8d8f14c8697eec5883c714fe39bfd57a5ef69c4f2606e3f5820fc0ab038e5c9bf393a205b95af00d4e9c802d7e58d1c2d5de40e1eb71e724936fe05f7ef8757ee27589c2096704da24226463d8c2702c75998f02bb670e4b97e60ca2d5153161198810ed155e9e1a94acb7c8b1f131acbbbb0ffa1f0910d65bdde8f20d6e3e2937e9537a6a0bbc23215f440872499a5b3d481c4687915ad4369e1ad030cc3098da7ed86730ed94e0dea377d0d20ea1e61ecf0673284bf9be8e94b177538da82c8fc56ca6f59060ca90e5800251925e4c602bd5c86a5ade989fe0fbd799798964e797287bf221deaf78fa886d20271d7c086b2b7b02a57cf049fbfa7929a1b003f255560fda98d81e4e156b20560ba2a97aaae1bd16493df92c3deddf134d201bd860f0e19be6b3df3c2db1207a84b66e148854e0e478e6753f8cb5268fac16dd7a2f14e2ac4a6435a164b59ccd7c9b337e22ca6241e7d7c838262637142db4348d0ab16ea4d010a7d698f9dbceff1a85d07630357f24a02f7b3e2569c4fde6bd657e9be6e84d70470b79aa3e03f1096256bc26507f2a4d9ea7dada5dd4501ae2354d20d9c2c1b68521fd89acb8af3a3cef2d9575e0bb73899043112a3e3ecfcb4927ff01413f73a938defba4f6a33e28af0e7d29af972f45dd82ab8866a7bbe80b15562c99378b45397db9783eee4d4caa18eafc1c6457d11c5934a447c387f156cbd71873c9e3cc9b7bd3e6cfbf145f5e063c2f1a91c2212f169264728f51f527c899344d2973d02ff40debe4dafa3e22a389b915fff9459b51d37687fd7a9a2f1f8510f6cd90b3520883354141300816ef89a0ad239a824ef6c52fe076224d6df8b82505af9d01a6c0ebdac69f3db2748d22a18002b18d5b04d6457143576569f52ef8d411d6694de45c43b2fc4e65db9f8131096206b507f86640e96fd9feadf1806c20a99d87420b8a266e90c99461e0bedbc3de8191fab0db9d07d31d86ffb4980f21fd350a7937b268bbbed13e9605cc12f8726a477808e4377c82d7fec691cd1fbdb3b50da92b2c0cf12520427d8491bec34b691adb84eb35166e3247cbd759b48e93794d11bdea48b55ebd2f182fce5748183444dbe42309a03a3b5bf8aa3396788be17a1185d962bbbaede645834c59ae3a520244679bbf9433f448bbc80c0c6cf4bb2edf71443a7172f912aa449e8adf312333830285214b1a859a50f93764fbfedebe61e9cc0dad6950b9c40b00cfccf042efa2516e5999ed28ef911c14e95a68a3f6ec096522887a54a31761126661093096238caa687a161dffc49d1d1add938d02c965619d727aa615f33dcb1891864e683a93f217d81a30566d19e83b9864a409a0c5c9b81b44666d8ab28530687684a8e129b0a6e9fc4448f8bfe68cfd148f5334c68e9fa7bce78b2a5977ce5af226a773542d61b02d6a24d4e79106991e0bc6c2deb28218130a9785f37eaa8e1b8e087a98f08af9f6829d06f6ae6264167034cced50033ee4b0033a373c2fddd0eacf6d54af7f25997d3137c472fd1d1f4f7bec90879facb4b4321f4db2bca9a1753e9aa583cbe9a97e818e9ba06fee5abd8e357155e68c05dac3df669aa234a6798adccdfaec4527e9d21a427a94d797f28c2609a5acdc2aaf551540ddd8970e470584cfe9c2a297d27b9804ee4215939ad10db5f98bf742457f31f38925f1c97b403df1483e719331c0f900e9a07fd4c2949afc1351d0c9c3dc3051600a33aebe93943ae4ad0a670e240c4bccfb877747509c65c1fc71731b46b40eaa5ad4418b0e6614a23bf7d97806a8cc3d00f7ebad179853583c9e4eb6945a59c012e94bf8908c7b65b37944fbb60a4c955b00a89d0b146e7f4780f816cba918463a830d0e6cdfaabebd3fad8172d696601beea0ec4fe2085a4f252a297a5c148216d04923201cebd1b63c08e05acf6c348217cdb9b03ee8f264bc0829c2d61bab0c6c60535a432f3c57b721db3242cb1975623ae6b526926c2f640ea93feb2db8c4b5370717f1bbb34e9108275fb8aca7be9f510d757def7175e797c19bae7c522905499af8a6ba40ac0bee1283402f2c4390649820509174a3a641c9702729308a640850f2b2190140f1bdf93f1d77f6992ec9df1dcb6f98d3ddad4a1d8ecc2374b376ad242640fa44ad8055afb5e4f4ebb46347153625f25f632c0577020fe34a9de2e0d8b170aa1089cad3603cb276f505d54192e06f47d3867e129dda47451011a31703449d34574de13a255521cadd1c4bfd6b03ee32d1cb2d53a57a379ce8d57e134e533f7d4083b8f208884043953742f65dbae71b9b7cb2c8841afde4136ff3a05b41847c14462a305648b9ae3cc6335d768d2f4a58e4b61a566aec01380899504f86f9d8a5eeda62f4efe752ce97c42bd4504a953ee3db391c108be246c3c2d35384c4c2446df2da46542a971158a48ba89e41476b17d0b2563bc9ebe8f1a8ea35882a6f12b48089b5117f1682d3747844aded066437a2da21e80ac935c8515b899b6143d4b919486d0f870af541b90773b719e6e791020f6624d8058d8d48befa0c544ecad1bad516e1003ee47249d253a54830aa64364f0438c3ae0476e01bd420b7949a451fce86aa1b815cd00b3a22a71231ca539cc808450c0f2d73fb64b2644153c761995612185ed0f6bdc968210b1f3aba0e8a747f7fcde99898ac59b3507b2893c76fa836b004d2b153b9de8e764ed065255a378dc2423cc63bb45154a739cdcc4dd27901e16bba2077287efda7850853f4d31c438627491b74925771399761c15aa81c221009cae40ea973828e6f5eff60c4605b73b9084e0b7fed2eb09b5e9af220eda1d0c0dcd3e0289e005c2a506d955246581d6e24c59127220ee5b95f70d12e1b7c823a439e0a0f3ecf90306582efbc631d9bfbfb0ccaa93842a5f3bffe4406d34aa21e7092c813a8226f0ec1f2ac2a60fe9bb368fde756c17249ca822faf7958c4c2a0a2e7aa6642b64979cedf778f1be3ba433ceeddc4aa7531a0b7dc549552bef13deacce9a21a039f54b7fa92e1b8f1d00d35acb5b1cfab5d47560941d99724806651f5390ef98c0971f696ed444b23616984681874155f510d006c74bf731145032e145369e6c01858c78b045ae961993b2a559e9853aee9426c1bcf4b4fcef8224185c6887469e37004eb423edbdc64423730398224cf9c6c3fa4621a782401e0f018ee7fe9f59651e3cb80d323250f9e0ab3073c11d558cc1b3418cd38bddd10fc111fc165c5012e2d3d3cf76ffb5a0f991f6aed59a51c23a5d50d61da37bef0ddab11d0ba14098644377dc7f781897b3e1d10d9999d9a26d01c4a3f0a4b8713d2f88a0b44feb119167153d68f08f95c6ce93acd5bc4042152fa28e4a7aaff15158c6c0f58a45aa726db498efb15a01062ef2119541f382df9bc2f95add708b6c59be9e495a6f0b922a0c2f449b5a843aa213d092123222d7eaa6e8a4f8d132785784e1babdc832d029f25c3b799ec6564bcfe972e1b2abdd6717a8e7f32247e865385d533d80ae1a4b24ea0b4eb75caf450c146669985b8e09c8da860a69930b6aba7651f5f86c224d89dbf2d9e24847411ad1ba8a3d7c89d82fcfbb7c3b81d4a14a24108aa2986c83f25fc8d487556d1282667af3b67d8bd6c58de879200553ea1ff8bfdbbccf9c7537918950c746bb9025f7a104393c2823c35149371df2063a16e02dd24f6f5eaa35481368774af4876b900727e29ef5421cf8991953eaff2d512930dc85c2288014d64baf596966a47abe493b08212f4a2a2067617f57630cc6790db8af62b33ad8672c5827696b71cf327aa27e52012292d87d1c19a4d6e0064bdd07721ab85979fc8bb186a660954eb2e6761dc056c25157c225fb6093d41fbcb5bc11a14f33246ceb37b6d60031cf65b12e78048f736f6aeffa0f282c3fe6b0fed65071e546d3c4235ee74a1bbd89de5307917ee24f37f38c401478e455ecb1850be990d948d077cc9d7b97f0f73b2bd25e9759bf5b801f2d919f11c05c6e4a35ca8493375c48df9ae4b8b74c4ccc60e55b5f44130320096d1c2017e99836318199d1308a7e786c8b65247e0a11b0748b5011e6f6f6bfca61eea0ddebdd555e70f74b9ca8c817bd5295a5442c8ab361049a80b63c5a2afa3047458c02be25cc71c94c88d56c1db60bb8f203197bbb2bc64c3e9ad640510683f13061ae3287e27c86d2a9ebe560402d298f043a31909e876c37a40a90cabae6e12576d153281645d62a7b22e13089f0ecabf716921ad3559251219aa989c795d23408e80c0be2dd370231a8a2f663fa29d00d69e450716888721b9a1853e619429f428d91e1361fb947c7d9477bab43194f08a4cca44dcee216d992d2efd37c5e775b4ac11b5fa047649ff1eddb0baa0b220698915e160bb335df9dca2529b0d6772b80ae276fc009754cf12009c0b41803893b761a5075309be86df7d367ce0f9c2cafd0b61e3cd7c29c1934b754116cd6eb03a939bd51821b2adc8fa73e50647798f810c0781c14e912b524d81255f5d7a8332a70a7bf32f16325c6b8f418231c1b67feb80363ebec70101d5b0f04793405493ea3e24957f562ee3f3fd18a0621dbab9cf2f95239a35b6416b4ce49891370ba487b224bf90f066f44d91968410455e51a86c48e5c3a21130955f654f781ebe623d42035bc29abd3009627c35540d888d51c20746d6046d124978cf04a6a785956ce93f34b2a581e668cff6e118870ea0912b44446ca6291a08d86cd58a9a9c209792a1f9c04410869a2464403d84e689ad457603edd8a56c7ba0eab152d0ae0e9adb8a359891032046b6675b59054b26d1b0c676998d3c09975b4d3117583263430f4e91009f73a5224c3213fe3bfe62ad6818d844f3f0a1829a998c036f0874a39a08d1e5b2dd073b0f1675a39f617d32b97f2f0df645eb43b4327eda0bb1381403c85851e65f7b2aabd2295c240b2ad6195834a62d42a0e09f107a4fec0bbea5ce8efef655b682e276241c26018991a98c0a44ffc2aec630a703444d33b588bacfccd7c8d0126481e76ecef415708abaa003e83b73ee8b375ca68262db7b35d60998fcff72cae7e90f182c1bf3c5e3b7686998654531261d427d6546732f96216daf152371e3c568d363ec653f4f58b5446037bc21c54ac25672c5cfaab63c811c8dc292db6ab15dcbea2a1258cf97e1031e01f7a898924a85ddba330b4fb9b134a4422804f289362aa7032dc807f9361d83451762699b0a92084bbf771d45cf95354f69112332793153612b9e66cb10c29a89b9d993b35d7aa32c3d364cfcfc000468e7a2137602fd8067a470dc59613432e26b36ef7e1245c7c4027f723e89ea6622cf86379d8f2993241aeb619834b3897ef8f0fc90d12e4612eb6fbbff8daa62676d0cf4cd269fa6b09f73be5535950a9278d315dea5bcffd52e6aa02679332faec28a628bc2309302131e458e204fc72c9d5a3c46f522c8f4038f62fa192a053bbd02227ad22d94fafe8a8627c35fae8244b7355bf35f9b0b4c390b448b22c1f3555bebac01d130c423759bfc4f95b5aa9433bbf0a6adf324cf3008b95baa3b848340bce7e0f706833905cf349991356e43a6766f3c4746112ec9bfec48666c550aec4d1513c6291786cede340bb1b8a61b1962788b2ee7f4c696744ea949aaa725bb5c1d2d5442ae4c646091183602e00c8b64ef9bd7baa8ea9289a1040fb244450d151e3ba01802ee8c5a1e03b6626609cc1e990cd119818d560c8bfb06fdc17deb30d95bd3417e4be48cdd71866bfdad7431ccf2a40e81cba08d1946a09010964a63e85afe0967eb1ad9694121220c1ac7419d52f83671aff58dfb3c468d76928e31bcfe4dbd7f04165bf376236b097874190bf2d62b21225ba8dce7db31599433bad3c0b5c1fd1354080e7e1f26f379f38c5f821f6d0c895fb3c93786343fb198496b59e10a62d1faf8f8436d205397b6ac114da5982e643a7d0b01643db680f80739796d04f24b0b857a0cffe96c75a6b23e43395871b2c296f208d758e87abb0b83625e9a0b30daa1b30c8c5bc5804a4876281bcb1080c8eae6c0cbed246608d903bfcd7234f1d0f5d67c4cf2fc00fdd63d22e69fa5adda2a5d214c343c8565d083dcee660ce5c1ef136badf974beed9fc52fbb9fea274c95f18674191199a90c00b002676d002dd1fd65fd103c904c31d4ad8b242499026e261abe18b15108ec927ff49297484c314b73632153adff2f3d68e1af0ca02f32a976a86342b24e7205b8ac224ac8a1d6dc30951c194b4e8ede3edc08bc0fb4609d72b3339acf978491252a03310a247107ff8b941b7b28d28fff1ff749e660d656400dafe74aabf33c5cdb7bee4b4ce27dbf3230a670a0284714701d12d521d18f2cf03a12bd63a23a257a11066e47a2d59196a0b8a400793a49b44c0a7c080eb6f89be459577eba0b6443d939222ae1cfbaedfde529e29823511510addb965fa234c70f8afea8284424709c11453d3123ba7a4a9603dec4c04526a13209c2da5449bd2edd3c35b1538029d5ba66fb2921c7c6f542ff98a25f36a06594ee2710816a24fd419f351b98e75a22df0d793f551d02ae6a1e49409b0324d2c6f39ad1f142fb74e568683cf2ee837333baa8d8bf536b4dd88d45f8c5f5ce41da8121020390519726aea9f4b63152ca297df2856c7f217c50ce1ea541670fd4be67888da967e5f49210dcc462839f85602985b3809660df419cf087f646afc13d7a77a115acf311106872ae3bcb1c51b0d2dfbe63a8d89decd4e350cdf7f4d90edc3a4c3b4acfea511000d80f18d3038bd279ae9ae524d1698371e8e6bb51dafe9d9e1c8488105ef6b88462a393d4d50a8146b5e96c5381e375686cb1c7361414bec70f52946528bb7cbb70f24eaab53449bcc544bd834f5a095ad460956a43e2eb5692d36b6abac6c2dad43b959ac54249a60f65052071bb9cfe5373cd33fff10289955d2ea408d7f4dea057e09a45be85eefc64dcbd318c3c3779f2bd15d0ba2d224cc65809266e6e24315a6c026ce85fac08b832e0c940960dc1a42829b082d8eece068d140f40b508297c3099e46d58432cb05f053f39f47964bf49a7fb180b295b1c1296a4cae882264f14c02343359ae25146da83535795b975bd463b490fbf1cf368a7b4c88cb31976cede440b73f9fb3bc1a0da179ca2eca780ee2943a09baf430b68ab96be90f610e06e27e17a6603d1233783e23d610eee0904e60ff08e9fb134a578c6bfc753d99af2c9d616f6f011dec2664f906644075910b0b24a64b91248cf8f1e74ab86632ce5e931bdae8e7800eefbf343e06c9ddf31d3c7e116b87efb05b6696917868d87c526fad9df18cd0d1009a047bece30b3c085beb11b18f3548666f8457f70b8d6013471599e5e842aae7bfae7b5da21801a5b9779a7c52d63393c6d461d68491b54d008099bde48d155f8eb3f21b811764bdd56d3218b9ca61ff01b069ba2e08908a367d690b832e3228cc3abe601170cf513a26a415d513f737e432cd61f4a39335287de55fedd311962258e897c6049f8c96413ad7eeeb2ab3b0cd858e9ad58573f7905238f5cd58ff7b943885b5f7bbbb41b1b189e1020ff20defc1870e8619464276957b50c7307e6da36b450aebdc9d443746484b62bab617e8e996313c49a724886ba421d2b9e8b4d0e0c2889ec439f7d3733f36cb8d4f88fae6197149914328afd1df4db630845abdfc9fee51388df999fc8bde6294aa8de2b29deb17fa0b2050bbdf50522efc3739e4bb9a1fd441e2525b80c0592ecd30f89f834012d7bc9ebe11b49eec5418a580e190f2c3f6a1105ecf149663367a164e08c5852162bc97e13dab8572018bf43208d7aaa8e51a4b05beeed320e02b13824182530a777e7764f5a97490a695bb92de37b41c941cb7081deac6173a1967e1662ab1a2eb39747b75721e5fb7107e8ef59e5b75abd64d21aad5fc8b245d2505ed0ad000009314780f96c17171d319bcf618cb2263a744d64cb6f1f8fb9ed1af66256bfbb59d36340bf710535b2061617ff219348b6a2c34376c7c94832b9a8f03ce5117519303a7539082791e2fc9bcc50195a9a609855ed54f116f0808a2e75ead8406bc69561b0af7c3881dbb1422a3bf9e335a4b4daf87abf1d357c755376e98c1d1615e9293ac3a3728753b7094014c600e860d6902eca79b39b17e5854112f032c0e547ae97ba65a683f5550a68c91854a10d4011c251eb6426b6d359ff3a5a0c5424fa6f9ad03a5eaa7df6760abcb58f7b8dec90e7591f56fdac7392843798c84ed0f80a89b45f111af6fd99303fa335d0feecd06721fb3a9340a82c286003b0e760861cb123652d7e8a307b6b9a1152816594f5952c46c3cf6b4bd4510a1a327227d7da3c699f1304710c0c6b6929dba5707309be35426bf5c377870bbd2e05355ba4f5bf1bc82c576d80cbc88c224a4c8f9d8ef2da83c18d86d4f682cc8c4aef882c79bc9694d6c36497482db17c7e0e1b5583fe51d51988ff9b49b2fd832ba40d3105a667ebeb4e8225beacfbf5089d07990f8724e747abf11777c86ce5a19fc96249758055d229094f04899ac9ca174b615886d2ab212a7d9f7b045d60b18a202b89ed72b26ff4bc2fc88a6ee1d759ab103059e81208c64fc6b28d540bd63ac93d92a4debc79bfabfad162d36aa33074c1a66ed1e155f571248754f983ce712301f79651316210305497fcdaf9301645149ec0381e5b884bf01b185f8f7bf453324d94ee38f9b848b25544a7a85bc26c9028f50d5a15f6c2cd85a79b722aa98f563357362ee3c3a0d3bd5596401a8fa054c14d8405ebd15b23e1790c3028482cf4cfba0c0ab18ea85c0ead888671b8ef08b9a9a4f2e616a18e6ee53e9b91cddadcf679f3da49e55e44c905b8a592da4f381d733fccb37ed741e57ceb760b68451337feb1d1705a3c06e028d83de6578591e7bf1490ca336856196906da2988faa4a71d31d8d38c2ebb429a1a1dbe4677f95ab502103e0d79aa9b35aa36eb5d920f6596f88c78d2bc55366a1c8479731420619c590b15e5f67fb936ae28d59517be5fb362948143ea8d2ed91dde93117ba4873eedd118ea6cd58582b430177d1e0327d9ad0188f19a559b0fe5b6d63c53c4d70b7d0d9215043200cd13de09533a0cc65630694bef53a54bc86243ac32a26d58d00b1058b67e8ccfab8acb84d28dfe781468c23ed7f48563e959860ae1637e3d8c05d83c49c18f715a51a02ea959a1f4dc763abc6abcf3648a979a70232a2a95194f8478569faeb466d390fbf80fd8502207127e12193302a804703bf2a79fa83dc00d97d7c4ca70776462eef8a18700abd86347f613f6b1c79e928af998a0560d90613dad4f02a1d6dbd87d6aebbee3e0822303d94d3a9c398fef23db76a78c0f5ea965a4de04f83626aa68e17ebbfcd4c051b6f57f9ef6f891ab3bb3058cefced88435c8b46b8b245edc016e68150a81c9912ef98f09aa7a2361d01944e2a091e983659fa8d0ac491173f62d141541e6ec1fddc8fcd190e3d0f49b172320a37be1c028e7c02b8c117f411b8bfde7d6a688384cc2c0d82eee3cd637b36c18cf1068db6c423440af4810316e2135ca90710a1b2c61d84aca23e30d0817422f509bd2bdccef8af5d3659137a47b1765585759720e04557dc50fba0382149cefb80655700c189e42bbc5b9831afa6c6e8da92550906cb8a9a52446859c529ad1185c3e722030aab8c4077fe3d775a921b3ddcd1123370bf9c39306d3a061e654ec5ab3457bb1eac9bb0a37bdae5f3c4bb4188a2930c699de830d654e7b9ad790f2ef9677ec8c6d76e80e41696125f2410277b23e0db01f54f1fdc0660e261fd80ffa0226f1f7fce0c002c17b8aac47415a0250c2ac5e2ee2b0ead36df990294bdf5b6e98a097f7a9f97b9e7659fb5e029c00a3ae1e882a088f1b4e5672fa2a86958c849bdf7795b0efb861129db7f6bd10da332e4b19710ae1bd463678251c23e41df0970e6e871c0f8d79d5b9c5da373fd8776d8282d6148379447c349f0be2f927e8cd54ceac2d9dbc6918a3250b894c6059cbd865ce146713282ad08001bb0cb60a2b9455c12f953fad4882b50c4e0d9c41b301699d8bd3d2082b7106704f3991fc36b2dbaa654eb4b93f4ec88c14434ffbc1d6197552b6c7319b97ce1e1ecaf04a3da801033c5742e2c8b90cab9a1c88cdb83a74376754c6913cdb4e6ba1e5c3eeb95b198c1c463d2e0564e2f4476498c4dd3a715819ae53c26aaf39a6639292c6946a3abef53dd00af70ef4286b0dd4c0b1ca4df56eaff74a013b00a2afb17284bac55bb3fe7e8c1dd50e3758a784e502c89329f1c2ade75c3436854a11c408aabee8000616c826901cf4749570f9a2b873f6af37495f2b96b67b9a16fbba9338b5ad8b326c8750a90fa1ad85c0617375b90f24f42c79f76a3a561c0b2c91bfa9e42be5530abb2a20abeb6d3b5896aaa23d74b90675cb2f8ea71e5f15d0a8c9239ab92c73ad8d5d90a5b4210a4d00f2d842304e0f8353cbf26163a06f7bf6dbdfadb093db4808b6b180a8a2236af29c135f2684f30ce94944106884f4971d9e3a0bbcd94e765be971be7e776c8774cf306d3f6ff67bde158b2dfcf83700c3ab7811ef47bce42f3f922f62f8a21a0ce3ee3a98ab05c61cd95f52c10f75c6ffbf5812a92caf8e057a588ffdea961dbf03bb6148c665498d62ba6a41ba5dcceb59a3de9e3f53f7368668419dd1b357dab446196380168d9885314a80f66838f6fa7751ab875e0b600435de0b9e7ce704b116ba084d375170c898eb9c407f7fac24dd9a9f4f2341429e2e3306c2d2b1f45caece0cb9addd4fa570932d0827ea2772465c37d3f34bd1a5dd4a94b4479a9db3c78b57b9a82a2d6b551b558021d3946bba4496de500d575133975440518689fc81dc62c33d0cb89fcf078cd689c5a1e9c3c728c9de2b5789bb5dc3e54b458e421ae901598bd020de6a994e71bb2e9d0c24f22463037d333351899920759d024e2a29132e7964fd165606a8022fa144e3a0ae4626cba516b565a1133e0075c6a1d5faa95835c70c431dc4cb4325e02aab408801a13f7b90fc8e9d6f0d3c2522181c398fccad31280c01579b4e9b586d2dffa835228813323df12b34ea728a5e8ee2bc0f1c25a531e05caed6a3528db5e2fb4ad1fd7411733a619e720101c2fd3b879c05d6afe2840968576389dd97d48dd85da5a60001dd3803c8ad495352a82dc92b7d177d7c139e01efa7f069c3930810f9e516698c9b89c19ba6362fe3c0748e43f0a458f0c73b6c0a76298ac840ea10b75e5d9cf2a1c6baa2e15349edfa81818a130f8dcd70a9a8475bff0a4357a967f570a921795a4fe22273608a1f0b6baf2e7d1edae37d58d4bec7e60c64e89b1a554844c722ceaa6c781ab6555e44efe97e84ac90688f05751f3120e7de3898a9f161461b865255929e57dcad4aec46e51ae7cf035268d44543ab225b5e92b77b7c6eaddcde6433d94c10d7ac31121381ac595ee9b2686233691cdf7489c6275bd12e9b8a88966e881680bb45c56aadffea28b48378c4f1bf14be31b6d39a8f713b498490d6be8790585d11a6d23b98c5b2b63c8e3868ed72464b97f7cb406348f5d3905a18e27a4831fd910a203c82f30ff996f03272ff1feb101281d4518b12a44aec059d28370ef631b61952366117f0d8953da4c73181b179439c7d1764a21343dc8df110095ef75460ef8c17b2f6f43c1186b5765d612ed4e830ec19e321f6bf973c526e389da2be0f45d30a5895541f484570cc49e822fc31e2a66671412c966cd1b2cb28903adfa432c183f339bc2665c7f95168be0e433052f995976c8f56dd7f0bb646fec8388816fc2928da41f1bca71cea451efaae07c3509046c6d74856da14e839a49cae0484e8f66a3fd00bee7accd377f6d1887ffb669f0fc47a4aadcd6bdcc6cd09e7bd874c14ff6631d91b2854face6ef973dd7769fbd8c07a2507de2502cb8e6fddfe3b6dba20dc9dd0830216ee14395ce932a343bb63e7f3113eb25b5a62076ef8dec8fede3447de3ae6c7c345bcb192a1994d4425224c136f47f9d3f0c03e21305145181ba58eeb6d115dfdd0be9343dcef98d0aa6e168ed1d6d9fbc09e9c2e9834c72da6cba38b9e6051d30012b341ef6bd78abda27afd4500e34684a7e2f8d2955a7e732732f08610e99b8389e61dfc3d21c9fbe5c2c7ab13a9581813a9c625ee224ed4ac8b11fa563aeccce5faf7157d4d51588f64fca317eafcbec11f3f3ba73b749fd09791f8f5c69eb21d43c04e55048b667ac33c73df02f3d86c8bf875391a6b5e807707662920a552e54661a989c1da8d83099f9662d8198b76344cf996aba9fa16daba661a65c78684af8bae9ca3d319c097dd1b7a87553eb896b49ed52b433e131b4a7900ec2f21d01c580cf5478517867a775e6aab0dd09ee14bf375a09e964526c60372bea1d459b55ef6390661fb49642b16bfc07a86dbafaa6f5fe84d9297e9dbadd0b11b2702fc3dc50039f912fef82f805bd549bd0c87d2ead5123471e37db69d68401abca5a036b225ad8dd0279141c0f3a54681f24c0c5688c2dd1ac4cca7953c7ef8031997773b060b513109c333080d721dc34397748d3aba7009f13823e664ffebbe5b5ede58c20b90eb0a3b601545198054d47bddc4c4d7785e418e67fd6b78f05e3b4db10eb018c56622babb8644900a489a4bfac4f709ca78bb10ca1a6c3baca61d88f976a3916aec3181bbf06304cd5257d85722dffd136ce378da08eaaedb0a6b2644440a259809f624284edcdc3638aab745d09573706187b5246de89de87e95367de112f24e8e342a4c52126373459c20f3d3b87089653279fbabf23659184e962c8fcfaccf0ebef0982e6e030c8deea3ecfb148acf92f86049139962726d6d577b017adce5ef8e740843483d6f4dce6c23f4f9299e8e4b1e7230a22e550ec53c5406da7aff303f0ad8da45b4fa949572416d5ffb866d83832edd9bd4b19cc29b61f5e172924de2edee979381655ad84f3db133160a75486b945b71098d3493592233ca817b6d8ae89ef0b78e22590e3f50197446aa549d0728c4a20f1ad7551a71cdefdd3a65f4ce19c635ffb7a08316d3c9481ae00b0ec3cd27a23274a080471e2e261b810af38b6a7a1bf4ae7791d9dee2e2b035559497e9bca8eba7d17135083b60650d5c7836b0c14d842b9d66806c22832b8213591d4bde9069b52526df6812b5693335b51c0e45ea98846a995c6eb18a977028f97b4d464f53f2a69817b5befac3e52d1acf7075288aac61c0cf088ebae4c8b11958b36c94b43e3f9ff544890a099ef0c4783673104102c40c764f8333575e376ee45f537d2bf9f77f5ed28c37fcab8c8a656d50f5cd25ecce6cb831a28a3d5c2a0f0f94be547dc75dd24e6973b507d617f460305ae223baf97645b725302edd4869623661dd5572e990d6750a1897478b0981a313000705180f3a14c551c89cc2fe4a068583262722a803eac7a45cc5ef398f8610f0d5bff66cd74b89c37839e017e6ac785c11c98dc93f9239207889bf70550fbc64d53e2428d91d140f05e41f1eece39a2d68c67eb90cc4f5805caa4cc5a7d551c89dd096bea238c26c8cbdcb4314e421275b8918eb421762c77d8bd04273d259753c50d2d10e3123997022afc6493828f605ebe2370608560c74ac3b01e5b8ce93e583c3a38ca231228528f18491376989bdd0016c229b150d3a760c9eab7a73da9c3118aa92de9396bb95631dd60e992ac840f5aa0ea456bbbc6b94ae1e9120c377875d4149961362838e1c5b5ff5807354c7e3645c06686283fbae7f2d4e68b417b7915a92a489eadb1d11269382075b8cc06c5a1f416ad7d9c7e86b67a09303c34698ba7eaf523ef51d68481883bbbba179e784a62bac152c3f63047e5a7a704d1fbd7b9ca968f8993caded8facf3533e10fc93f282280f7ad3c029472051baca0ae7d44716b8febd623fd843cf9c181167c0c134c2fc11490b1d6eac6838debb068e779d2b7b652cab7b6f7ed09d614a4135e1b19b65352d57d3198fd9b2d607173283e1d63c2b5399b61d21ea5061c1e92d38384e88581b3689e2d6fbc55aae3bc417f924bae9b3110cec758cdc0d58ec4e8d1c115eb67a789965239aa31e2e204463a66284a1c7d222f848549eaededb579832ed061366975ed50686d1f790e06ad5a23eed94923a902733f3ccd1aa4b53fb1838d6cb9af1185e6ff5d92021b8f7678b2599f97850ee926c043164e321ec0e22b38a34e65966bcf3b53936c3aa1c5437571fd8e214426cad1e86b531fc594588b908e206ccd530308534ab3b3cf5f2c67467e291ce99faa55da8511d2302eb06e8b6dc4a978b2102a63c0f42cee528b18c9426949306218b4d65e61e7b1bb494d59302669c545562df5f14632fde017ba29685cdc98dc94f8fb007b6d97190825ff47fb5cd5d277413408a3cfa601a8e4a4789dc9bd6247b3ce39203900606afbee3156acf98e0579c619a1f3f25ddd9ee04cecf652b1f4b9b97e8630b6f9ce033d10388819c4fadbb6489dfacfa76f424e68f24ad6b2129ed2de47b6695626b325002ffba17ad66da454bf265bbc0ae9d54a33957a0c6965d6a8448813c4f8254986356443547af5b4ca09567784110393de832d47a8fd7561142bbae71b7591911493f16b3bb73391cbe522b20f019909a4d8a9c5e25beaf8b3047afa7b4a5bd8b4b3c395a15a3a2348461f92f028b6086f5473c0da6da124e514372c4396e914b61ec0d50fe11b844a77cf4be2b29bbd9b864ecd2ca480b4cbd0e17e95a9c4daebee22382cd57b3fc6a9e9327b4f854e207da008d521da8d909a6719e63088303251fa823b5381ccb32563e855fd2be80d72f81db8840855c788b344636a4cee4f5a4a36776689391f99626ac22a6b1f5aff9d40db87e93a53926af6ed19c17787c197c02bb91fab83a747c7391f2acc31ab72e74d595c6d77920928bab80bb8989b8fd944a6d77894f9f43150ce4237d61bab2f1093a4abaadadc5e036c82cd9c7b836a84bc8c7bcaf2e80fdb0e87a69db76de6fbbbd573bf0b2efdbc9e662b5007f63ea79781cb4361a98afee82758ad5fa1259429fa4ba198c456c3ab22fa490b387de098975b8f63aa338e5fa20b2dbdad936873ec7f3d892697cbb407a71f88a835bc7ec897a56e5999787f86a71ce689353b3f3bbeb37889b3d0ea7cad55ed308d2132a0868b706a8b1a3d5388dbe7804436de1613ddb835ae008a910232acf5a177832f23ea1fc20951c16ffa18390553f89a655a0fd5130d4e4de87f032741cbf3978197f4072c5cbc212f2d8d28e0e835074b2fdce0b55fe631d8f083ef9f11be5acb59812cacf554e827948f8064f0acdc840b1b2779c070b0ced0f417b77cae589b9199d02c4ef6e8551850644e18eca79a7f00bd9b0dd290b93366934347a54021bbba4a215c5c869ed431d58fd945c62765d061e5442c0a60ea82e3287f3b51f5ebba78aaf81c2ac8ff5efe8f9eab7b947646844890bff5a5140271cfc88f86decb3951be76156d2af3b4c976098567f1e9e83badd8f2d0afcf9c9fc0d554702cd68edf9588babb1bbe7a8b8ca8326135472b9d6955e0f7a27160e794874607d8d840047f446db5491e6c2323b7a62840a70615590e41268b060ee05895ef430429a13f6f4d180c0e0af0db15841d6113d3f691d3f092c4454df0c87972bb58e4a76f35a6e10dbb5221d5d1a031a77e4c55d8c2750f8e153785d3415104d804a7170411620d9b636c5b78d30e02bb2b51773f18768f34431e907f8def8b42c0602d50079b820c9a1e9002ae1a2be005e8b31f8f9649a7cd97319a0f6e1b6f24696aae9df2ab237a26caa874203a0b95e7bd46bf61eea78110c4c3c21cd59fd76fbf21b3931173364c4ac6bc216c1f63b240b251a072875358d00612d7b9d112f00c26b49c33468f589b324a868fb902b20f87940f8ab5f734a4c3bf97f2fc3c0397f479378ae069544be6efddb2e13dae978e8f68cfe84e307ed7af5415be2f711448c08e9a462d60ff39c10b6e25e471dd71cf5ec2ac81bbaa397b8fdeaab54a150b4f4d4e2943c8db1ae4cf19227c97c54c70cfe2c58a1429c5e96d4e02d37a4c7bc314086ca4bb99d87ffdc188a55f12b6afb42d1e01753d23785fe4cc1642a5db59882b7c29fea8a0bcc8f58fbcc5c8f0a91d762b06c45e06ee38a0e92adc7de9de634d8b2f578b9c3072368e0d74783f3d5102d6f57414ce14da46dfdd606aba9cf4be1e363ac869504a4b9e00869cd90a03e82c2f5e427345bad9c8fb09b99635d1c4c65163b0557a773b4727eb7e6da53573e78f15eecfae97b5a7815b9a1a17c44f3a3b238a994879b77cc9362e057baa176683406ecf761760c8cdda96e41a270cd42de36be60cfce4a766d89e87c97111b0f1de62e45d186691bc92b9184956d651303019c9a046d03b88700114208281647ec49bd9ae0671c811f7d0bb0c08d7f8306ed0fa05c2e04e7d15e59ce0998b0cd6cacf51565fb9939bded47037689b1d1d4ac5c6465f95e639678602259eda4a1e3f57f0c072f921e2770769a60d1559fa65ca35b00849e65a796a16d605c5299aeeb5315d56ab1419b28962c97faa64a2b4f6a60f7a38110ff1ead819d422bb4f1ed8ae46d8f3472ccf4e606971a4172122be214cfbe3e2be2ea89c9de9f840524784f33001fe545ccec2b3a1c80e113fe63e8d1a8513256c35edb69458c6925bbe6e1c772610b964a814749c396d5efc0020654bb735258e646833a2ddbf3088d413baa9121d9f9148d42cc324b4a4500ab77a20470b839022a313deef99d6b790e90afee49e69ea1fa1b253b34f9c133866287165c02842be82cb4893557d23aa3f4f362bf0e5b7952d5a54a074c361cdb3cc82fb6816c279b1be1de5528a7b789cc4863cced60a2b25eb7ccc68c8022ad99f36df49cd41caccbb3e8d93f2465959c1c3228865a0854cfd2167d9fb77d65b5f16133df58a78a11768b64a4ce9189c42b246e94a58850c4607b3a4cd890bf4c4fcbc220ebf7a45492fb7db19e8f8c6f83371d2607cc8de2516b252da54b29311ba96b7744152887a8072c9f5f3bea7208382cc92cf312e07ea9054991be7e15f16d642c5d5791e493ae0cc2e28eae7d2e2bf513863096c0eb37312256c22f883f7a0b93d730dbbdc98bad9ac5ee86148c0b045d001df49d996a201d8c55d3663dc746aac006945ca4d22e4010b0580c82a90e2622faae1ab432b755354766fcd82de9673544de99fbd1e7029e007a8bde24f3f0ea647d9e463cc3a123f60e92ecbd19a57e90b7624c0e1b5cc1badad8cb034e0d4a2ae631c92889b3867c7faa63fd7680bad348d63240032d693ed6514701cc161ad87a6fcaa5a49fd6a4e19fbb463bf654fd915fac5dd123d9d7e76ecc39b84e4ba5dce451cf4139cbc113e471f74a48f7cd0bdb7da37849f02c0fdc6fff96abdadf3b9787104af371b3155b7b50f771ac77e98f74c436e1769b13d211ac53b56b69701c5a89e902e60e1546ab062b5e582ba1b877e92db20bbb67f4ead73aeb974aa2be0f7c96e6d0dc86e040f5e3d88c6a33ee285792dde7f763b99151b44144eda3aef1bc6673ee06be42d32461a5b3b53714891fae503d604a176c1e9ae866dc16d4181ce9c293299a9a1620b16f2eee2c1b89e8264705671ef376daa5eee53d719a87bee8b836f3b02ba4f126f4d04645a55da6885b1725a3695aab8268786109ed39dfbf0944874692d792a614f304b64a9bc27f1d51a0e5fd18ebbc555131863067aedac72618bcf0187e28094e65edd5aa60ab44e257a8d935be16a13bc2f68f121952ac33977d23bad2812e34c5bd172b30dc6f0069499d5eb84d91cf2e71979411a52112a59574a7e161f655701ca47deae6ef8855e0b91f7833163215b689937e32d264e263ea95659d6c5d6b9337dbe00cd2870ffcb5464aa06653222dd003e7036860c4e591b5233c1f242f8d8f7e75ee50d5bb43af30f555ef4ca8a787c86742393db2c399eed60b4d3d9ab1f4047024082a155b0cd2a06150213f2c332a3442edfdc6eb17cd938f1c27bb7b1b37f2b6023519ac082cc2134db16a0c8cb76902d82300b9cfe1241ddf2878a2f4c9da06d62e28dc63fca1b19a30518406a5937888cc5867f99062b26d40c8efb51672a2959c822cc40bec956850eed4c504828c5d8084fc83d8dd84d22abbfe2179b07020dca69dc99cd0653fc839924c7e7419726bd1c397b981db4e8b0404b412f4b90faaeff850994f6bdc3a17ebb68a85197b863bef493c0a4c86e863b6e9683970e2dbb8c1d40a1f3e88248b3ab1be3a7084529ee1edc35bf0507ca65d093cb5d761bf43e13d67d7a01951a5c2693729a03b09702e369568bce7a67f296fa68702a309f82cd0893cad3835c55647bd48cb738ef0a19ad71c58b72ad679ea28f033baaea00f0d0be9a264cafdced62d65f1471af8c01035df34733009def084daaa72f4c251be7f9825330b55e21986bcf02d0a5ee7c0dc3971e335613350a8a81bf63c6daff436548213e60d53abf7c9a779bf363a601f630e3b74d9b591c2a4d4ee1cecc994d4cc299e1d43a226899e3391acde9a6487b6e97992c0ad52ecd50b38ce90cacfb8f0673dab03f9de314530c3906628e46bd1c9dcc4a11bbaf58c466a0f467011a07293827a89d1121ba579631e990f832d03ac4c3b2cab2e98005cb6bd086a92ec1ac031e7cf17058be356f2b361663d9e15203af1bf9476bc4fc29bada6c38810b7d05ce0e0a687b15d3d12345fc9788ae75f2343b7c779604b4365a385444f1a5ebf4af3958d3df01f91d22111d9e71d506fe9252623c67a269b3c2826e398c66c02f2a1115f44663b237d56bee05abd67f697149eac979316a1c30f1c332b2383cf74abd33b27303c62a3cc9ce7d454d8dd30b34732702a00aa8e91f6a2aa14794a0b76dd399baadc087c4d58d7e58dd4c060f2ac34b2f2d099660a47ade39c785938ab4b304f627711e8cfd60971d936bdabff59cb3480d535fd9df734b9966d2188b1ad6c906c41ceea97a3692ef89d5eedf524f7e1580ecee215043524d69406eaf0bcb912a0620b159d4817b8add01f37d352957f6c0d59ea033102cfef528c5053a5dbb5e1660d1f1e59ef26a3a2412587bb2b9557490a01c5f8e406295cb7370bf3b8c4fe58de56005e89a5ffe6107ae2909fc485e963c9757b9c704f31438e7a686c1dbacfce66ebb1b3c3547fdfe33d4ed53190f330a5ac760f4e14e732d8ea1f26aa8a4eeb81bbf89d02eaf13bdaa59bfdfaf09eabf64b931960c92f16671510fb73f3ec03f021833806ded4f786e706f8f4a3efe50eaaf889afe83c4ba5d54125bfc5784da1ddd680dc4ffd744e8d2d423e311c24c66f376fb13f27833e7f429f7462ee9b73163e31fca6be1b50b8d0f28da5818789228b5cf672de4960189a6f627fe57aa5dff8220bb6fc593ffd381688fed71b8458d76743a5bf589dacc04e8899f7f6a07490f84ae84d2c6a8035e100b13f7bf3b67dfcf910d2c4f7b9ea205f7e3858ac6f6e5ecbdfeb38ec196ae00dfdbd4151daf50ca8e437b13eceb024c686085aa28816bccf381d722a51bb020a79b2dc2d80cfcfe9fe20d51b28287595367ccb194dfdc547b1aba26089bdc434bcd1bea5dc2aba2e419e445fa3ec1f61d7f177bc194d1bb1df52500f6338be0937010e11b28183c5fef3e6b5f00139f0f14f37660cc408588d484874d13e10735f57c1ed1840cc7b0dd57cf0c777d9252fc9605bf8b524a2402f0120acd83b47809428ab9e584d0cf3927652b17f44e3cefffa33b6067efee80e6220747eb95131d3e18a30c7e3ba9480f02bf205e9d2a1623fffc4802ae8f9155a4ad8e4af4d1d5e693ed587c83b4f874d1e269925fd8046637d1c1b4b2ceae231d9441f27c1c307d6246471ddf863bbc0b9157d7f4f3b895e87578e2b73db193ffc04cc87b06aa7581f984089bbd0d4e6688e5e8b40e948e52d8598d9b4e6683fcae5448cecc95d9172881b093abc6065002d05a216424990250c8a911211723daf6b906b17b82d1e4fde4bf6f439345427eb311d19c6d39a10650e97d1efe84b3776db2cad89dcbc9781be86b821f0725e23b220d1f37958beff4cbd53acd87540fd5160cc8f11e44cc164f482e51688365d9ae75885632c55ff0e9c2eab622179693b1268b82ba8aab578c4e4e2a820a7ac8b00dcdd9cf867dd175c1e9cfe252e9b606485841a6356e43bef4420b821b90aada0a691c4fb91a0b3eeffb5361dff0520bf7b1a4e875ad585e0a3a1f8d16e29f41d2a91f5253d87e1e81aeeeefc5ca403fe126b5c9dcbaec930215c1831c35c5367ba4f62cd775f48a6380dbbc2c3a295da221292cd2c3a15a342379afc2d266cc4ce1bf8c2b65184220440c7789d8fcee2b130de9acb660c73ecdc9fb8c391d1a4b3cf3d849e792b1aa32db78e66942c2c9f811cc9522b220959ca07c67a2a89d85bed6bb9486f82f2d9434c459b7c8a920d9b989431a491c04ed8a887016b8d897248a5a9a5dc72559e5155fed98ac38d612be9e6ff0e9a75afded93124a6d9c0213aff24e0f92b1e7b6f9c65314a4ffb47e2fbf93eac398d93663012bd5c28269d919fb24f6a3e34311f7835d876799d301120fd501b874bb76c2b013840a19c6c69e77dc33aa74bdc62502b27ba0dc973b889197d33844e11ec43df5041c11b6e2ebebd7ef0671cb909208d2c021f3633a6e91e32031910f31006fb141f2b64d9549ae5ff8977a86799115a603fff4174fe2454ae1f811136af7eeec1d1e83a7e217c4a030aa24717c5f12b03aaa6fd4c07e04cd7b27d20d0ba51e861133d82c7846a7770cded1606103fd088e32327a35a106149ce08032bb4758735642023811d05125f37943961cd0695046de71530057c144f38c26b4ceb682ca2b91bc68714dd66858535e297a5d37e0526f6f530f221d211a4f0d45c645b7b61fede226afed760488c6137cc688e82025d86c35824b68e0e053549e4e4c13879e1445b1afd09e52efb02071b829e1cdfac3a548b65409ff9ba2b20ce888a3f8cafccb04057247490ee93f5edf6ea07ddd3a389cf0742402ed87ed9f97a8b0582b75a5689b1f152fded3ffeaa54726f9e459e452a6b240b8cdacaa79d28a02742742bcd84a09d283015928502d2652266d714df29b3afafdeed948bdab97ce3e678164a1ff124b74e4cc24cec4565186bed7c5eba16eb454df6d23e71a07b4ca901a0a0e070f69b6d9e66af2b9e79e76e052aa1c340df19ae1b143a2d174d5444c4c54bd9a96455968520f4bf2dcdbf7685405f0c8902ebbb3e5302f5d064229b2f6907057f85bc2aae4418180e1622b4d336d7527c42dd4b82530eb737fa83aee5453bf5fbb47f5f8dd76486c0042363f51dc9e594094b340e824f3ab69831699e918021a6a4407e5c9db7adc228aa14aa0b0433fe9d1a135cb108732438dd3652c9e05ef3c0573813f2a6cab0601840651d6fc630688f94f48010b1856635456e823942547cc50c8c6d600db85a24b2489b38c6830277136eaa13cf88fb167b983c5e5e27e926b2f3cfe45b6c291c7f9230fef036dc0ef6ff2ead330b18c1c504ff514e05569de8122b0f96b33e307195135dbb77f7b1c80e57b115cfc4800389fb02da4958700f9e9596822a3a750cbea461105fdcd65a567c3e1bcd89d995edb30fb9ac331a291a151898502cfb12477c0d1cf943ef70bde563426f96966ad602a165850fe614dec0d0c04edf1f6c20dde56d0881061b1f723722a70b9d63b098f7020b0e168563c4e13da4c1af2b702b8e950eefe9210d8fc106f049b6ede9c6f04db31a1985d7a69d452c36b85b8465b3d5a23c9b6dc5be8fe6d307b2569244ac2ed64ff47533631a4b275b0bc477dc66285f19a78c9ddfb04ed1d1d2343b39d8ff89b9d3bf8d560ca0f56de2c002796630ded4ddf01079834a14d8574531b43c5cf7a3581c85a18a3540ec5c93c16432b935c3b90dc48f7878bbb36424b91b1923d9a2fab036f355a32de7985f239a17093dba7386705f13c93aacf66951f1abb0f2c8721c8b3b576aa478460b28c875d80ca7020bf48cf4fe64ae64ac95178cc7ec4691abcbf1671d81b929cf9de3f209e4bf039a3503a35a305a556d0ec3ec7efe6c11983086b6b6b00fbdee03ed0626bf6f7e2d44b7445f0b41bce53dc39d69cafe61543a360f08810258d0de7012fe553c7b28adf616229a5909cdaae4b0993008763596be9935d9ddddbdb2b7943249192e0a0f0ae209dbff57b0fd4d590d15b66c043cd86e0281f8fc69b05ba7db15acd7da6beb8f9b9506c16f5bb82ccfacb58ece0911baf502acbb65074d543f67ad6744b3ba5375e88bddb5cee84afdb3ba76fdeaca59ebd3c9d69ae94a3545417b4b8c6de908c208b41a187a008316021085227a8c18b1859b2262d46fa9ef52fd0564fb0a92dacd23f4c96dafda7e806edbcdd99a5a5cdee4e84b7d7b84117a566970aca7ce16db3f25924053bff67243fb44a2c0074118385a7488cd8d93ed321f42b65f00b420c7030dd4fd2791d067cb768b2212712244d74d5fd4a00f3e0df4c1efb13bf2c461dbce7a25012acbf69d09753fef20e16bdb0a4b95aba0870d42400418d418810b3dfc00013da8e9e1882604e1872662f8b7b860521584ff0cff1617ef92f8a8aa4cc22607584d8286bdeea4b48d5135bcefdefbeef1bb6a9c0936fecff3e8fd15fef1c60d627a1acaa06e6c1ca6f2ed0a3f4c18748b5de18701038da1ff6cd937ec7f9a34fd4896bacf5118d1f97d07a9f918240ffe779130d38176b79f13990e402ac7c3c6bfd57001e297904077ef7d8eeebd9fe9def34894f7154847a2bc7286bb77d86c914475dfb2bdff66a0c3d2869b5f4c9f94e691376604a15b04e5a0073d3c01065d60420c3ca3a78889172821e4871f31f0efc07f037e4a29ea07314a4fab113698b962983e08c9eb7056c643e8edbf0c9a48fddf12663bdcd08e3cbdd8eede4488ee6eb88971b8896d68a308bdcd189f86325df724e478a468973c7c855ba03dafe400de5d57eac0e126feee6738abe3ba7006bbbb11479f9456430cbfe969f880abdf54e240d20324c462e8a754a0e540aba5d7a4e93f8b840d91ad5390550cd25a8eacebbc45835c37e0e02dd2e3dd1a01216dfc1547077ff6ba19f86d6059086c367e1cf8b167223f120b64137ac767295de93e46c603ee8f5fc307581ca51f4b1cc09e18a6d7250e0710824f2c86c944ea2f91e3df50c6bb56c4329ce595201d39b2461a9134c648d218b5c63c47f100094a28b2536c8a0425d07c97a282ce51ff7e2d5135726c5fe6d8ac0e1e7bfbbaddb3dbb6fb4be6a8cf3da5a1b29c1f60393dc0014a57ce1e3be604dfa2ef566de509eead965fd054e682edcfc55b61c6df7eab30a3077ffb8ebe7c52d0f76be8b76fdfa459a0ebdf519336d45d7f347e0d5a881549e144e6d2d9fe3b78dc60b5cbe532ef9f262afcfa74d4a351eb310b313d1a853e6b43992f76cded4cd81829b2fd6fb0f7c8cef67ff1e3f8d959a41f1f74d6e8c7f19f54d1f4388ae502c41f7d48ce10866129c34d0f67c60f5f7fdd1f89227dd447a53f698cc4f43c4a2424a58ff116bdc2cbe469abe4fd6ba88011daf6bfc013405a36863f89896cc0186a6403c6601ac9d9fe2d8cf45c1a2340db1f86ffa84491ca1942528b265b903e8ef45c28f37d0d698c3ffa8f4485ff3ddd2412153ee9ebd624b2052afc669432dc0c17b001bb017b248cf116327ca0c38f9951ca084bfb600d69c8af72f3562b9a2940e85b9a6447decab2bd25b7cab2756f4296901ed9cd40c79c20e5acfcfe74efaf863297c7dd39ac91004aa33ef7f54d4bb6d8d137201033c3e424457c4078cbc6a0a0bd97b6204d375b60fa6cd93e4e88d027b84df68e36d0674b8bb3eacb70330695a3cf13ca097dcb20f869d800dcc2e5a533fad4fd8680b66f50dbb5e4e1bb03a7cde3b4edfbd095fa28eb34d6cebc45c5e002a2b1364552d8fe5568c88bccb67bdbbf16398b1aa148b6fddde5fe16bb9ce5dc8fed435fecd730da1465097aaba12f09a881aefc3376a70931ae95a6badcf477d54fe64342d7598f18e03baa963768a85df58841edca1f242bcdaefc015082f1c5af018ef0c1074b1c6a806200f8e3e3007f2c71a8417d1ca8ad250ef0c512871c96331a03fc3383655d82082d0cc1021f3b5cae183060d034460d6cf0760d1beae6fedc5e47cda9516ec01ed91fce91df7b1ae8df3bb0aefa9475c8f60384be6fbd4cded86fef7f6e8f636ef6903295c74dafb9e2fc40577cab3067ddf773dcca5225e0a64360ab2c75b4d363dfb3e66cffca52bf7e8cd30c6d026c2aa311b26b254f1de0c65f5698bf8a90ceaf039ef569c0f5efb6a3635bd5a7fa541d9b7d76f4db1004168e788291156ca10a315a332950420f5238c20d68c410c3bfcefc2b50b880fab8beca1a94c2023dcb630bf4592bfe92035807fe81bed01f240e5c9b87ef2020585e5fd5074743d0b73cef46f3bcc433e68b2f3e3177330dfc19e34ca9e9442e485778f4a9e99fdb7f1b993726c1fd554ce66d49bb29997d837a33a2d24a4f6860baf7ea3035412b2df1a04f903ef83cae2a3b0e37f02f0ac907a8df1f8ba1c6180431fe903c7becf013b1584ea0b2e08fb1210e41f0fbc00a92b496d731c618acae4a537f78627d711bb96db8860ae8d8017ae0469ef76badaf4b83c6f62dab8e9b2ef6a0eda39044a0cffa7ac5c8f0958dea5365376a0ff9755ed7f2a2c5054648da41bf72769cb555219fbf3c0f7b84e0cef6aa375b80399b087a1cc771252a7f0eeeef67eeef733df60de4f61e49abb03f9287dd603981cab27d8c0dff0bc18da41d8984260c6d8a8426d8ec006c8a841f9efd51179afb4a933ea5c2ec799e17ca741cc771ef6d396fdee7819e57521d92e075d59b9c6919a4600de068e8cae4872983fed8735dedb13d9207de5de94c54967bc2e5e828a08f12c1f7ecf1dadc97a8ee73e4f7efbcdeb0b74cabb0379287ddb89c4065715aea1a84830c3abfc881eefea43e3634395fbf5788b74c19ce0a6f982d9c25befb58f2a3d1e83f4c8e9e8632317e4b501c4b3fbe26cf1e5b979e86fa63dc6432994a14c9e730bd7d12d35b9349f2e2f7d8973cc91159224948d32d91a4a7212e913d36268d7fc71f91e78e3d7e8cd5a476938ea653ca2355317e9ae0a6600ef44987e0b8d6eff3b015ccf8b5f173252525c7b5cc4cdf2e970ea165768549fe6cc196bb2e779d1692f2a43373549e54f6b193a9d47199a793150a1a3223e22636b13a3a25a515b2439688d531294bac8e12a7a5d1ac901dba15bb6ccb8f4057f89b5083841237377536030a7296094dc864ad89e34c4a4aee8ce36ab8568d915f3c3ad8d6d0976b73761ce3267e4e869b35c66da72d8309cdfd0963c32865b889f18725275f6262ad2dcf92f2cc26c6a93f6d25ca9b94e7a9755d76859fab2e1dec0da157c0a04d7e86f828fe6c39f9d33cfdf925f8ba6ccb755a5094678b79529ee69fcaf3b7f23ce992f2d45b14757c855f4c956746952e94f2b435df8f8f9bf87bdcc43c6ee23bebf21761573e9dfc49798b9cc84bc491b788dbca92d296ae4357488fff16b9447f43eae637cb59eb11ff49109a6eeecfebd221cfcbb3f15f9e1bf391dd1fdb63ffda5369b9ade4bde4f2549c1c7c5a116cfc2e9a9a1f3617082e797c7afc1796b3c6273268134ec7e4f15b98ed71161d8d4c50265604f485e34ade7e684da6d3c7b8c9f41c77224f106c936e87e4adc9c7384989fd92e748fb25dc9b9858cece949890747f1c894979f6d826cf91dd8e9bdc5b19937203dc26f918b724c9c77889acbb84a4dbf42624f7252409c92529a9c9b38ee449fad8f8ddbc7bc3c03174e80affebbb71799eaeeb701c3ea92a86e071e37b35b470770fa93fb51067a1f08eb3ca67f1e7e93f559ebaf4b5a47bc43e58f6b978e954aa92d627f597a4a17eaa7eea53e5596fad31d6c6ac8fb3b48d1ed503e9c6e57fb5ea4f21e91ee1177da91bbf806221284b0614d780b2cac78f6f80754059a8c78f8ba01f0b92a60629a9ff6806b5e9947a15dd32a84da7d4ab724ef9f2ac3b65a3a5f2ffcf16bbcea0be2ca5d4cf917a8d2f11ce85fa94ff38ee5e509b4ea94f215529d2a466fdcff3406d3aa55e65826096b93a548f7a5d49cec54a95674a89c3cdfa29ae04fa347548952d6ed632932e306264ccb07183aeea7f1d488486daa3d6efa63ec62b1167a58c240c6ad65f41c650b37e899441cdfa2539839af59fb4416f50b33e0b12076d7133f537f585367aecd4d34f794dbab89952bec82e7e681718dc6c2a8381cdfe3ab0a652b5cc155feb744bf9bb53ca130429650e94ae784acfbc573ca52b4e7bc5a790294f4399b24c29730da98aa7321810c12787efdb98ea57b0c6c72a48939ba37f32088b5f419e9947dda812868dd916776357f8552559723017db6251a6f03602dd1cfd7f741b6937391f3783b0781bdcc24da1d35756bd1b575f35fb640bfa74c29cebfbff2e09adf2369441f1a70a731f3f0a7da98f1f4559ff586fd39fb6e92935fd5f32459a240bb292f544fdfd14ff4276ea7f7fe2e8021c950a47a552a95438050e4e8a57a950f1315e965f9e15ffa76959de99fab7b4a1eeb23c539ff2395260a45cb28fb3563cfe2cf3168bc7cfd900b971b9650a79dd4cf91499dd4c79fdb87eca7f23120b6ef0cbc6622f1bc32f1bc3affa36566f2ad0acd60dc7809a1807b9a930f84559300e02100f301156865f37f569567c10169f62f12b3ec6f10bbf700ed6f114940d77d7dfc0b86bcad770a67e4a6943dda9a7e10ca9b29624f55929399ccd99cffb7ab4c30c39a89b2b9e47dd38c7458dc6aff25794a93f4916e6eae96315c0582095053f7dcec6b656257e99e58b4559523385ae52521e7f4aca9f189692f23ba503d70335f1e3976d713f50201586b3a12cf83147044f101817c4c67f629d8d9f7236f85368401735facc3978d40d96d607d33e1248fd4f17221bff0a12b320718daff0ab20b10d895390f8c64dacb3c73f5d6ccc029176889d55da569667c6efc2079dfa943ff12bb6f1e31786e1d7ff67de9af4a38fb129a4caa39067dd28b7e46cdce45eaed293e59977e91f7f97844ebdca870f3e6753839fbb7196cae3e7709c95f24c9eba89890a8973dcc49f22b18e9bd80bf1679d529edaa64a14257eb98941cee6c4ada0ce9c4e5f6d9c75f2f83920cebaa12fb4c629952a4ff1511f635124dd28d4843c7509798224e47932911ce04ae47949a4cdc63fc2afbb371bb4f167b1a46ee6172d6ed63f61af3c35b73d3573adf4ed82cf6efa2a959b35acd6ffd29037508f484106844e0f5c40653ff06cca829d5d1f94b10067933695b1a066d7cf3fc410fcbc2e731bb663a840a8a4a048a1504e4e2625f439239448234d5f0cc1cfebb6c06df85a07d2a79a535f1547cc821689e8339b2a27f4d9b25d052931883ec19d3fda43d4d127b8ddbdd626bc7c5ff5efba58628913a113a1164b85f4c974728513224e847414b43d2142dbba375bfef726bdc9c0dbc66d97097db2c4c912292bf8a86e8bdac3a99b5e524afdbba7e49f3376f71ffd1cec72909a8f117e90f0b77ffbd6eeb0f4a4f4bf0f49ead77b3feb4b87cb96e9be86b44c81a4c9234f78869b3be86c6387c59fb3c68e73bc227da2bca7efef9535cc4dfffc8dcd7dd69c8d9f923354ef6610faa31e7eac62a3d8747b485b373c90bee870d9f44f944c5941535ca65cbcb4f37013531a286a06faf62db5d1a3c7dec1833aad2a37f16ffc3730a6b83ced67bcab05b38c3f8cede4f962bfd86cf58d6e9eef636cd2a9d3bd2d1ac3f4eda699e691c94deea96c08a07dd21ac8913aea05dca48f9bf0147823b4fd6fad337c64c071c3068df9f15387095fdf6fb7c776e626f521a014f4e934ee2ad2a657d94a2476c1dd5a8ab391d0f44f9652bbf9f07dd52da595c66ae3707b55b44ac04d6a8760042dd4b6fdd7b93b9dd0f0dbda5ac71c77f74aefcdb4ed2f3a41d34ab33ad7c2babfdddfeeef09d7161bcecdeec396876679dcb43dbef2e7d1e99efb1303e1d96a409c953110ce552b57ab7dae86772e3957cdb6381ace55eb4a8c53e21b375baa7659cdb93606e2a6bf05320297b368b81afa426b747ff3db50772e4fea66ceb42c85ef6409ba734210d8a643d8543604911dd6b6537cb3cf7b3aa233909b5ec5993e3722208ce326c6c92879088eb3706b2302f310379dc8b632d099876c2e097dcb3b24aced2004cfa6b39ca07dfe2c07b655296ed70d65abb58219c6e6d564ed5bbb3db5f76d358decd3d8b5010f24f83182fbf57eddb66d3b993ce86d0b3f0f3f0a09344a44897f73feca53ebaddece7bfbf9db4a14b83d04ee57f0fde9d7b8250a041d2c5bdcc0e1a6bb4001278318c4367e1b03d8c66f63f0e2fee33e67ad4df307f7e0c9766102bd7d7d941168d45ba72beec1f2cc59ebcfbbbf9fb9f73e02f886b37089fa2a9dc16f59281c1028515f59c3fcf057b6b85152f2da778102bd55bc03277341ceeef2f6b5fb5a5d9eca7f9af25f6f5dc0aef2733a7017b05dee6a3883ee8e73759f7f078f1b70f0968b5de58fd1e43c03b26ba8c00c12b023d0cdfc38bf4bfeca337b65e742c3efae03ddf4fcf52f40b3f3ebd8110601dfa97f8bc95f65b6c8b60596d457f5cfd4eecafc5b806ddf28a69482e4489e758f6f67f0bdc36e91d688b6589e670e1d94b6479f01eb3f2233d0cd00d2b62e4f4adbe2a70869bb4ff1fd5ff4d3498762b9c3a2e0823ec3d7f63f43d7f60f75c29df015e638ebce108a1f921df99e48e6d0258ac6f7e2577246fcefa98c58e6d02f3e0d67c4af3cf0d6258a86f8a50d78e778efbb0749ef43b2fb1ad2108a6f47f2946dc03b87575290b681349006d2b69730473448db3484e98abbf06d500684904d654004818820191045644010d9540644900c8823b6b7a90c8824e418df0963df1dbeefc3f0960a4c068e4bee2b035264dfe7719fdbf0e9be695bf75b6cebe204c5b861d857b5ef8d910244d310c7c509ba3841316888c38fd0810adc7a17700fb4c9a6b21ec21004da3e5b3612fab4a9ac07594b8e366d2aeb41880f69924d653d0451c4876fcdd6e9d5e9402771e63a272fb779760b6bf8e75f88c5b3c7f61e5bb53b323d6e2aebc1a6871a2167020a4c68bda92c0546ecb365df1b687153590a785a66a40046b32637de5496021dee0fe68d4213585fd8a55d6bad6fd6aff7044370820d906d6db6b02d0a7a4c6e685f2564bc824d4de00e642740c176775f8191ed26c8e1a59a400833199b2910040cc030849f1c6ebe108302408a7ee0c0043c70220c31dc26092d18a255632e97ab043fdcddbd4c6dacbc6fd1b67f2dd8832179c4845a77e5410896ed3995fa6db33c00e520a4081055a8392186d5a107459ac88108ae2660813b0111b6b5d65a5ba6eabd43a000059fb3c50864510882046028c1117e04b15df66389ed5f5b4a1ef469ca4152288223b1cf17dbe96b3b11b67fd64bc84410847887077bfc2a84be8c7efc7ae32d5babd5574d67fc0ac459dfdf1f3decf12b0a28ccfdc1c3674544bcb0c7c70085b144aa0d7da93f8eaf83be58d8d00803dae3dff09685d915fe49c21e9f0685b13f9505bf1ec76fe12d6b33fe0cfab2fdb8b3f19f2cf638d646fb637c91b45b0585b13b2afac2b5bc665798c2d81f9505ff387e492833c676498242415a07a94a907642063da6d8b672db603f1b7f891453369b9ddf76367ed2872ab5ed474aad56db7e6cfc231420ca8c08ca6c36c3af531f0ac37e50601886613f1bff78e295601bbc53826db00db6c13b1bbf78ea4c6af84749ad56c33f36fe902493664448337136cef08326ae74613fa40bbb30d8cfc6ff759bbe363bd7e6dafccec6ef8db0bdb5b12c6b1d19f4dde7360b674466b399e3ef2c168584ec466e0fc27e6030d81236febc89406ee2ff3892fb6c6d76ac8d0d367e8e137f58802c421aab0d7e25b7eda4281b7931dbfa5c76855ffcf11516854059f06f5c2c480fd9f83111e80a1663274e68d0856843624c14699f8b2b5dc8879c88b3fcedcfb6d1b6a28db6d136231bffc9b68d4546226fb1883f3e3267f96f9f8b3f181cf21f150654c275f29ad75ec025e80afed39a60e3f7409a13fafea95f2e9b33a5faa55f9bfb99b34e3106e4a4ef6d88b3aa18137dc41f71260e7196e3edc56c0bccd98b6d6fe53fd1528e9af93d1a51f6b8b071fed31bdad823fa1c8661f85f487230b47fddf8690b290af90a3f488a349a6d89a2288239fa0cb2f2dc732f0e05205b1763bff2f5c1986d512ac6a868c5cefaad1d16ed7fe4dd3da00f0b09ca1c9c09800487f80a3fb5e787f3b9dca4f96a7c65f301f96e5cf8007eae8d1fa48142ce1af2d6cae3076ba2097f2e45d1c74dfc2ba428f315fe8d14676e8ab18d35cc740b202106afcdfdef0ad66b3afd11f429e7ccbd8a728f12caf8566d8b8c1f80aed8bfa10c0cba627f7b11d362f3566f186aa5d5bee45bab7fdc8e12855bdc7cb1f24a63b55bdcb4210d45f7bdc67fd8e8d381f80d0e10fac2bdbffbe01b37536be5f0c320633ad286af1c9732b2bdf58a678fede2c207fb75e87469e1a6cd59ebfcf53754b65c696ee4adfeca3d5efbec67cf1b436fd518d7b748dafd8df71349bb7d8f30f8d92f3631806dbdc31f5f1c5f1c5f1c3f0c7f24647c71f4e1f8610a44a1c0540a449102aaa83ce9c26e7bfee9cfd3c99f1a857af72824f5d509497d45525f9990d457a2b9af8a0af80f92259822854ac58d7dea780152677d2e4ca0cfba4f7db5f8dc8fe29b7bf4ba4489a3507f75d1e4a3ee73afcb137553a18c2ea99b2e3ceacec1fdc70254b1026461822ccc150b1300024841914a914a282727f46600843404006c11ceb052a98b24bb3fafa5d2257c4a57463f1a911e25942195a8d1e8471b1efd1792f847a411891a8ddedca62795a692c7dde17f35fc46a7e949241389fb52c9d730770909b9815adb2617678dcab3c7267d7d13f9a8d1735f2acf1edbf4276a54428532a8919ba4d2450cff1cbd18d61877f8df8854ed4f00608b70c6b7e8fb5b010510d260010510d6601100cb00aad3cd91d9cd4b827fb638a9ced43e4dfbfaeabbf7de3b248a5f12ca882d5c88e7732e8ce54822e4ac2127425f688df147f15fd81ca30f49618d3a2e60fc7014d2187d2892cf635b215ddd27c928f67d15fbbef7df0bd0850bf0c50bb0002cb0d57231c0483f49ff188aa2f8a4d7e1f8e2f8a2f834ac31865ad423490c5be18cdd2708eafe5aa04b38336ef13f17d000610d718bffbd8030210ddfe307f3812d5e1807a0f562716b32bb59ff13431994f82e6e8e23895f2443d2c5109a7b947e8ed36f6ef1c312a5cb1ae6167f7b3c962ee40b379dc73a8fe7c24673df527afb2f466fbf057d31bdfd155b7a9289ac5b0c67461f8e3e0cc3d1871fe326538ed1875f22cfd1eb07c31ae387ff85344625e8a6f861a9dd145f96a3b329139bca6210db5f0240ea2c140dbbedae1b05d295fb749fe106412c7aee5c2495e70746e46987e4b51bbe563c41b0b39be27f56bb167f14cbece60def579e75c82379b6fd8e3c5fe8ed3593ab28c1475567f7da3877a8584aeef2cd5bce60cbb3d627afb5e2e97f2b4e3c3bf3674399ea79dec63367e5f7de2331d00bf4e781ac1b76f9584875c310cfed6722ba88ea4f5cc415e1000d727b4ffa1bca94ff5f253bafa4322af2acfb9f8633f4f8bf29d297bf3d9ed117df99a8d615e9baeebb9cdf5a5bb3459ce5b5ececffc4486c8c95c8828d1e9544f22077cc6ccb12f90aff97a705b2b36b33dbd8d66c912634573ee7137bba2b5dfdd32e6824f47f62229c15295df9f736b0867836040c3af55b0d3f45725aad58c4cdf2633cc88aaf3b168bc5622b52262626de2c36f3b698dfd8160783ddc4663012174bb9d10007ac28a928e552f7a5aefbdcbd8aee57745d4e9167eaef7f609842458a8ff12ecfe85462623547a7c223d35a2e928948fc26773f2377b6888aadd9157e1cb4b1ea5b2b9e75c242f465c859b8e62c144c846778360403a974b9fb985857da5077fe1932dcc46f7aee6716b32dbfc133dcc4a18a6ac86c665b7ea32acf8c87fc2782b3d9491134f7278ff2dc0f17e3bacfdc8c1b425f285010477316cae3e784b857a1b1da0c19456ab6e5373735d05584b8c9e3ab989b3ebea2b59a9b3597e6bafcc66ff0ac36a3c13c4fa73c0a159bc14824d8c63956559e8bc9b89f5c52f294967c2561b8a952baa4907848263150cc66ad736c76f2287fe2d9114e3e32139398b34e3e32932c7e2ac65324dd2724685242c662310e705ccce4cd6a1bffb861c372f6952d2f6ff99473d9d2d2bd9b41dbe3ee69f4c592beab12b45589ec6a7b1b27f6d6c4deb6ff5cbcb6216e6edc5b1aecbb0d6dccea904ab47dce9bdb4aed0cdb2a79f0b3ef7d0959e9ca3e09d95990f475a7c85d7e4344d4594c4444148bc56231db227930837465dfb4519503ededc57c7ffbcfbbb4447aff5aede7f0ceead0e1e6f6e2d71f02549b7ddbac967536f3d7cb5ffe7213092992207dd996deec0874d3dabbb9f5b7e16efb1b18b72df59f2d33753b774f1d6e6e5f4b1c6e7e5884c94e274de8967b3aadead0bc65a22f9448cd8bf8f65e645d67cb0f6fd51abb12ff94a3716af6b6bd8934ed6a7bfb957c21922ed4b44f87bc60d0957d1f9b9f9bb17cf1819bdd42d0fa0e43d66d58492ee42c3b82e3582b69b3db8816d9db9f4edb5edce0accda444f6f61bad39cdb6668cb470449a82987e24697b7b8ee451b758c270737b1d1f9274cf0037eb625ba6d22fb530d15340aab37ef4a3ac9f7103070424e0ad930b99fbfbbeafb35183f0d994c8a6321700edaf825cbe7e5e9917d856c7146fdcf7dff654e6029f7dc2d8dfe387f1b1beff7e463e7df9bba7fdbdffe9391bde9f5436e3fbfec69f74757de1a3aa33a75250dc431914ff5d67a5525237b5a552a9d4534f7d0d6552396b7db23c281646b23a5ecbbeec0aff575fb6d5e98c601bd74d6bccb656aa27eb937e4556baaa6f922c480ec7367eae72e17dfbb23167a5ac083e7cf8f0e1c3870f1f3e7cf8f0e1c3870f1f2118ed534ab93073f1dfc717bc20a594d26fb66d8a2fcb2f959e44fad1e8b5fe717c51fc307c10fcef7bcffbaefb9c9ffb124d454bd1b6c534bbb298c6ead849f6331b9acae2df48b3add246f35c400d6d342537631e1e4c051ebbc277a4251edb32a138c8164165db1bb4dd4b9a0841b4a94c88dafef00d2f916e68686748c8d0b6ee1e0dcdb69ee2bd93b977b26dbdf4de097542dbbaeabdd371ef74b675d27be7d3f96ceb5ee35eb3ad8fde7372b675f23d0f0d599ca19c211b1a9a13a4bcbfd7acbb8fef59280b6deb2aef59c75d47967db2cfb69e7aaf71afd9d6c3f79c9c6d1dc53b37e4ce0d6debe03b0d4d3d8242f31627930dc96a32e78438a16d1df5cee9b8733adbbaf7cef9703edbfae9bdc6bd665befde73b6f59cca625bdb90fb36b4ad3b4d65b127ef25b221996cb736995d59a124c06c4295c5beebd84dc786c9fb9bd6dd6bb6f51c0bb3f95416d3d7d895cda92ca71465599665599628e14c8ab254f1295e458ab22cef4f0ab2ee92bc3f43b67567beaa15e61ee10e7997d65da0ee26c153a1a2bc3255a9542a954aa5b22cbf2cfd9d294b25d597af2a4ba5928e8aacbb445e1d996ddd1da10a7385f0a1f50009990561a22ccb9ba3227da7207d7f4f2291482412a9542a7d89740a674a2452f9a52f4b2412e9d23c593789bc343ab6756b7c2acccd81b2d47fedfa37bb76b0eba333a2542aaf6b341a8d46a31189447ad2c8249c218d46a5277d89341a8d682459f788b4b4aec6b6ac504e85b1495096fa45af6d89743655e88620914a1b4492be3f456badb5d6a3912e0967465a937ef4a491d6daf6a490756bd2f60cd9968d753415c61601d4b96644b29af541b7c368545a1e95711cc7711cb5d6af479270468fe3e8f58ff4388ef646c5dec86ccbe2085518eb831542b33b403667667f60425b202aa4ef9494288aa2288ae338fe289ac2995114f58faf4751148ba4c8ba45d28b641ddb72229f0ae34d589b98adc93cd695616030621c4bafa108c3300cc35014c517c352382386e1f8e28f62188633143ecb35b6e543722a8c2b81b2d427f212ba09b2d94c18625bffa12bd5770a0504411004c1300449e14c0882e2872f862008fa0e0a593748face906d392cd3541897812cbb3c46e43c35a741de21741dd4f77ddff77d20087ea37006fcbef0c10fc1effbbc06e53532dbf21f4215c675c8a1390ed0b63317011320583a0d5df18d72f23ccff33ceffb3e4f87339fe77d9ee7099d84381ddbaa433e15a62ae1ae1811c753e3604b18f17d65a5d195da755dd7759de779ef756338e3759dd7755dec84ac5c8d6d559f9c0a537f10c4bd8670373fbb0661886ddfabbf4fa4efaf24e79c73ce5dd765319ce972ee72ce1527931567c8b6ea8ba3a93075053c9c0b46a453ab40703b745d596f4c388ee3388ecb990bc399cc71dde7ef32c7713798dc20b32d1c842a4c0780d080b6a5998d8189ccc384f45d42fafe4cdbb66ddbb6711cf7dc068633dcb6e5e73e73dbb6e130e9d816047c2a0c03284bfd5a6c8887b6eb3f6133e2065da918e36ddbf286316e2169d96a6cebc59663b7d7b6db0d8c6db721b67dda82ae5413e9fbbb36bc2da02d6c23440d6c74407282b6eed0d0cd61e88e60e8a260685b2f1d415b37164b227685181762dbbabe016ddd9b7b53c48d108e60dfc22c0fb4656b35eb43cdb6a0268475310bb46565b226644ec86c0e76a808b4655ff6e54ab02f3fc2be3c09ebef3efe02da7222221910dd80a888f009daf2d9cc7598390f33f761b6ad7bef5f91a0f6b312ba66a1896d3f97125c4570fd60fb571d500b04039201507d01d00ab67f45016d5520bbb2f425bf773f605507d813b0306c7f0c503b74524223e14f83b66a0df73ea703d895ed2a4fa90a8bdfc5aeecfb47c2369808ac836f7e7e4a435804d84554bb3a57a744fa26e91bab02d0ecca2ecda519dd9bcb830bbb3af745f3ad455bbb27b835d765896c8fed196558a001cdec8dbda12bd541fb0a020f4ca7489190c8fe606d6c8d75cd66be3f6fe685211ad0cecea76384180fcc6b3ed2b797dde541b88dd70809d1950a3486da102d16eb48df19c604598ca7e2541caed6d420d586e806ba527d6f351c21aa0dd12138e84af586e88acd025dd9b75f4d14be1c664e784da0e4a0fdcf9616df1f0a04bde50dd995fd211309bcc55d72acc69fbe999d95abfb12f56f3883cbecd89de66d61db477169ffea0d5518acdad5564b822b037d9a3b059e4cfd35dbabb12be7b28b8e9d649f2b8bfd9637e42b0b43cdfa984c0035eb7b35b6a500baaa3e6c9b845d5f05acd4850c2cfefba5a81a08c11345478e1c3972e4c89123478e1c79e289279e3062c4881123468c183162c48891279e78e289279eb0198210afadb7bf7ed05237f39f2deed67eaea3c6b87d36848faaaebdf6a6e414aef59deeecac4c05952ce8fa36a83ea63035a8b2dc17fc95ab65ceb1bd349d1e68dfa00a4352961474e5d6a07dff8448dbb3baeabd969a5b6afbbbdded4c8127f3b3062d9ee12d67858faa4e0ddbd55ebc71b9f33e3014c73b22954c242526a71314540a458a8affef12a43f9bc6625e0c0704bcd5327afa2d9ca5c72ff2687605e3115516fc227e5165c1df880c6b880c09d115fc5fed0a94c52b0a5d35a2212ceca24e00aa1632a4095db1b086c59f7767f5e7151200dde2f50aade2b5f77a69eff5d2aad75e4f8f4ef1dad35a97af3d1c0f4793af3b1a8d46d3ffba2b2ad22aafbb582c16d329afbba0208de275f77abd5e3af5baebd15d8f46bdee5c5a6b8df2bac3d1fae475a6d168347d7a9d8b8ab4c9eb1c8bc562bae4750e0ad224aff3ebf57a69d3ebdcd3a34bafb34bbbb44bbb34e975c6d1babee668341a4d7b5fa4b922cdc562b15890e68274f8fa77384b7cfd3ae84b7ee9d74b732fcdf568ae476bad39971ebdb6afc1d71c8ea6699aa6e9ad48ffc7e1e8edf546d37a2bd25a15cae816012801b02acd9245b9a25451063daabc97d7e3f56cfc640ab1f45c1e8ee772b9f03f193ead8846a3a9a88029b1a0582c16b4f1a7a0f852ddabebe95eddab7be14781f2503a5787d3b93a57e7ea7036fed44977a215d16834935c926339e8cbb131c7742c68e34721e14cf9957bbefccaaf57cfc67f52da48d99571beeccaaeecca381bffa90c1a7b1c8d2be2681c8da371451bff290cc3f2146b3537c558502c16e382367e939cb3efd092f647af9ed7eb05848dbf8473712ecec5b960e327714d8635210d2892208dae8044c02227334de32d96c7ffad00b95d431a72bca577b410ddb3c7f2c7bf2da0305b50d00d628f7f71e88beac7bf2e6f6d30d8ad815d1bd8bd2972560a2728ccf6f353863dbe25a22fe48f9b8d900d912240ce4a3982c26c3b3b5118425ffec7b73cdec2b5584d36aadc80c26c3f7200a32f287e7c0bc45b7836b338b39cd9ce1edfda380be5c7b73c50184c84883dc11edffea02fa99ab7300c4604b3ae1195050a837f7eb6b0c7931f6f611b9b213641634911280cded931c21edf7de8cbe9c75bab39ace63ca3c98fef2fa030f8c70f8fc11edf5ff485e4c7771a6fddd9cc7fcc1cc80c678fa42728cc2542e448117d31d1bc7561b021586d2c214161eecfcf14f6f81588be743f7eedf1d61d6d7e86ecf12b4fd50185b93b9525a17ba8748bd74c9b1e658a46460000008315000028100e0844029148288e65454e1f14800d88a44c60449b89b33c8791903186206588410000000400006604a3800052917f8ffdc57a8df5c7768df5c7728df5c7768df5c7bec6f2c7bac6dec7aac616ff7a79f490ffc44ad1726664d695a8c7e7ed407ff3720e65129057729cd22b8ec567caf4aacbb0e5828d8e2001aba54f2254d44bac3232b5f83768191cd5d5881ce65646b557b049178f0259baa88b8294d68b2ee4aa10d5a4af7a2f1735f2199eab9a5043993f786cc2665f098fab37d619aac41168e1261630eda702ab9158e48c1e3dc21c4d47031ee97f174a2f441f158a69f0e010217d3cb9fbebe859f7d857e74c3a7bfcfda0b348d3fee03ac06797e7831fda22dea40a223a0c8988b58483a47c87a4b6f65aca4131dfa7bf53b320829bfaecb49265acb9a10fb6118c23fb694e9232f25660083100063e04f13ad3e2cbe07f7c7a040b305c48c0c618b9fc4cad2634b3c855b5b1291a11e82214537403f94dcb734c3143063a3e83e53473228fc7db24dfffecd638fe4f7b7518f7207276bfeed6728f3c460939d5ff3d3e366d7cf59a9adb25e41bf7bc0c2e211fe64f535d0381c925d2403f3e6b306442eef8eb0f46a9c33848c899f614d9652fc2c70389b92621ef74db251013f2bbd9967efcfdf92082afe16060429ef80f6b234e29952f70a68c6f57b738d29c50b7887ff6012f83c62c1d86dd4f9735d361e4fc4db9548d89a60e23c385b979c0404f03cda80e4354491c1f12f2c47ea5190186915851cb1e27e4d963b83db984dcc8de4ed4326e0c6046aaea843cf11fe6461cff040fe03b85c1daa899bf1e24204b2bf96892906357b22d880e23a45f686680616456691bd7eb300efc28b45ac313f21e768117db9898f98f5ad5d4ea9e90e718fdf989d48d93fef4426aff1077199772299e906bf3691fe802301e4100555d703b81c758f7249e5f3db5eef7de189880e6c9bf7e6b7a79cfbd4f72e8a85133bda5c1e8d4a8e137376421bf728d4cf74d4d462b941caaa7682a0ccd28e4fdaaf7e2cddf9209b9fbd7657ee3627e3edbe22f4034e4fae58e4a2a63e1572249135bc6581be5027bc046bd15de72f4d3f59aa398baf0f07925fc1a17931fcf28b19bacf2c0f3096d90411832a95feae2e97a908c09acf644490561a8fb9fcf538cb239a0bf2f6de26b0dfdb1992e9f915d7e9d3911bf997621b8dbe0a91fd6fdd7f718a3bcfa285f4bf1b1a52b9f327898d8c738b413fe04afc5fd416fcf199a57ae74fcbd809cdc6b4d5d18e91afb2f0f15fa74faa75194b338ff14ee6598cd90f7c498cb4c5c14ba81aaedcf5a266f5573caad2867929fd405fbcffe5371db8fd3c6d7713ec63e7d14bf8a4f2a47a9acb4be755f6a1bc656d93437a97557fc49adf42f71dd2e84727b74462e3d09804f415097a2cd4460b4c99b52f5250128fd1b38bc191bc42b54d7fc9f3856e8d3e99f4651cee2fc853b3d1a9bd29faf609b99fd1e63aa68989bd4ba15fa2515cd37ba571751b91dae915ba68fdffd5ebf0c7cb3afecda5216425801d5749808c8cc8dae2a3c7aba2b51e63392d49837d4b229dfdbd2db254adf012928c83fbe749e64e53cd4393a8225e9dffea171e5387bc57368cdec10afe29ea64cd4a169cdbbdf760ba1dcbffa9108ec39645d5c74137482cb980b248588e44d5697479017573cb93f28d73db928ac1ba1779848d2792fe189b9c2b00d36de8acf8549014bfe803da9b35969509adff2a7c623b72f4c963c6b42767fe6a27877f15639acdfff63557efe05ccd125e4a8c8bc5d5be971e0e432b769264033f463a8ecabfcc1b043e4276da9e6c6c3afa473620c4dd676ce2f0a3665338a2e24b5302f70feb8d1f0ab831fb294428ad39bf595887f148d6324312fd75cb79383cd015d0c0fb6318783809ff8a21e6c8fc45d0353c90ecb634f5f6a8e572fd950524165219f9273969b4c169a1863a7ce367c1895ec96867e53637d4e961c3a73227e33ed4270b7c1533facfbafef314659eb141bf2e9a6c245afe259cb65ec0a54fcf174168e06331f45557071a2eb2410a1cd05955efff67db66183813bec35138ad22ded12f2c353a896563fc59193254877a11eced24934654c73875dfc41462c032b6deb0efe5312f5c4eca72738e16a7688387464eb8c20c1727740b7eb0eee6fb19457ee37787286d10713f728e61a435a4dbe09a5d67cff03e93151321dd798598c02f40ca6bb80fbaa97b73e8aae2be80d652db886415663e32ac77675bf6dfd85a1f1cebf60161402356b97382848035a84669e7af8dbed5bee23348557f0779755bb4a7baf18e8292e5c3ced355a018620943919e97d03079e111a6f18f93cd1a58c1d61feb889eef5de4a63371341fa439f83d596e90196c0dc8d34d8c6960029bc59ccab17e3aaaf807d2617b669b92c4a9a3b71d77b5e0b83650101b326fa40f13f21f6964cf123161e5b89a86eeb3cff9d5b3fd6eab676e8686bed18d336b7418a19c979204a823d49947d346b6c0cd67207ee3459d47c0d002f94a5c2e990f03fba58a2a9061ed7426904e34d4a3042746feb17f3844a691c5a78c845022c0e4ad27b20fb19198500355453022cac6ce5bf592d978e8432ac4c4a0d32f45c07684b6475398a44f3535a3ba75d56048bc9fb2a5a70a472567ef1b23c9ac07871c6353bdd8ff78ad39955535bd84ff666f2af80e5ffc85b467d3a742ac8f5bef8aaf6adead8765867027a6b112c8dd1fecbce78562667d9b690ebdaf90f3fa18fd34e569a92060422106155027961f65c9c25df859bd2caa6b238f3b6844f66406c570b8bcdfada2467ef82c53baeb4f96c6c7d731847437296bf28989bd54349f46e36659c757b263df06580b8a7f5e8025fe71cbc810cc55088e90e6415041951dc19ed6bc4cd5fd8bee32a63eb0ed9312634658d04177af869a0ce2a17b267f9e25ae581497ba772da440b6f70ac8f41885d46fd5b0e9b6b2d05dcaf540a0fc6a00fef7b9dde6d2304b705c6881cbe0e668523c4e9878c492b7427955091907a19e23d0f0f3c4ddcabca74af5ccaf0be3dd88f2265af51cb81d392e9747e1459ab50e85a7c44517cac39e00b879da4ec4ddd807694afe9e627f0c342e114f0b8ed20a13d78f798530c888b6c1bdce188ee55b07f4b65061e4b851d6a9c9b429901232d24475cd0c070d7dfb65b4ac98173dbf48ce7c5d086374bed2a9a0f95db74fb826798798dce9cf07cc4ec11d172365845492390e2a76f8e81939c99c6cd8e4b8e7d388ca9e8dc12e0d2ae9a7d0409908520a5308415a98fd7b0118c02c723a07a483d971ba6c0672c157d56e96eecb8364135be393d76ff81b86522349f58cd30b8415a49dd5e8329d08a9aa5b7fda49ee85a97537e2df47324df7c2de99beb9428a53556350e48729fb69a86788c83368f22262a1e19264478da43605a192f19fae0fbd9f45ff715ca5d3781f692dbf3775dbcdf5897377ddd2ee9ffba5dd2fbbabba4ff75774927516f147bedb097217bd58bf12e6ffaba5fd2f775bba4efeb7e49efd7fd92ded7dd25bd44bd65ec05c35ebdedb5d25e1e5eafffece665fd6f1c473732b8eb853b3222c14a0991dcc293bb36937cf0d3bd7c7ed1583ccc67e673d8ecc1e6f8f1f76ddcaf0f08b806c0f6d9db62560f10778ce85556986f0bd9915b4f83c99c430de3ac01b738c8ad722968d78cbad560ce4a40724a7980e329a1da063f3d231702f2cbc0f9dba59c953d16cc7f0d7d3950a66501c7329b46e4c3c58671bf3b9432721ac9365043fca35eef4d19fc7457fcc2f97dcda48856804e07e730f3dbae882019702f6eed472098fd2259cee2e9c954e3f2ca80b3046dbc47c4d2e7c18fc85f37c58b2bdc5b70d49bac59c9efe794533bb34ef6bddde6f29f04ac74098f463bb3dcb2703a987f2885fda551452b6b5f92e4eb401d36cbace564b333c6863b1634910ff959f8c8d02dc9eba34660b3cd0844a6549a8d9ce780f50f0d2d35154cade24827ccd5523c03d8464c60e61ff8815d35aaf411646895b6485154724870046d09f1f7f413a348f8538d4222342a582ee823ee4c8ba816de358caf6cd9c4e15038e85df1bf416f017342a421ddf6c6b185ebff43d8973f96c92023cb8f3796613fbd90c4e9bdb3cd0aafaf816e041d1a1b819129f0e90e404fa65e44d2fa1fd033d8f00dc3617cf8c2a70f7dfad2a7af3efae8fbf8a8853e0bd2f13ad1689c71c21d279c708513f73870c475e032c215580d175ab5a60a7a2d68e49b7007060c38acc9b5997e318cac58e134efbad12fa07fe6f6205ea663a8e03bbe12d54984720e0b8c1c7d637bb050a62fd61c8f74d9f20dc1fac12f11557cec25208f04b3909bf1abc858409a7e3ef74594556630c258779d3a23ac6ee864987142d823a71c88392bf4f1c8685a70fbbb4bb8332c3a206b6ace0d67f55d9e9c2a4b86aba5cb81cc8f9a02866c12285f0866d04318c04815e202e335a99cb3d7a73bbbd036e67a37e4751ace8bb942fb5c25ae657c402e3162473387e86fb5fbfbe6ff0c1c40330de5972be06946ab0446d4f0b149a21b2c0211127e7ec1b377340388dfb5afa49943f6c792f3a74dfda5bb0468c64bf8e50cf1d10c69f90b56fcb2907f6d130e6946517fd74f7234e35dff5452feb7cd5f745cd0dc7004543c7da73a8193f3bb4105e6fa07943df994f4e7c241c80bcdc013ffdba85f688fff707627cd1cfd9f6989866688f49fe0dfaf0ad4ef80c748336afafb4492a1192ffa37a5ecff3df64bf329d28cf7fe25294fbd769bba0ee434a30cc9e4246986ddb46484b6bee88746454e032b9a5184b6690af638527b7b2ecdec003785557f5d4395c880415c5dd08ebdb80f6a12f301d934d3a6ad408eab27bd5b51d8e9ee3107a59ada1923e2628966fa870c2f17f174fd23f4109ec2df1c43694665fd348d66549d4513c39ba19d5317c1b4a740fa54d5bdcc1a34a32a928a1467ac59c64fc8b2926cfbdab89bdc080c47949e43334ca9329f0a3e4831c3f884c4255a18cd25997de88eb7da9b3e7c67360b97172b9fc0a318f36e1bd3a916c658cbb05e9c61164493cf6041d4dea59acc66b7dd81309be1764fb9ea9ffd43dc87e27a33d698e6d3652976566e2b6b35a417b74ca39e99e98b3b243fbdd9f197d1d4e16f60a6c8f07054794285d018d397e7f9e0b84200f7f14e4a04c29697b56a20b1e199f835bec3f3bb5d1a956762b7a362ab1191fbdcb7b66d29b5bb4956e9654559dbbe67a60b0fde4da7d780c6ecab5c437b8fc91a758894ed62f83aca9a58bb8d97f20ab9d1fbbd1a94291dd0165e11d5293350568ab562f55e24bc4b9252c8ea59f672f4cb423987a2b43e967605924685f51d48b3e44f66bc0a01e18b10f02e20b1d8884b7838c7d4255f083a2c084e8d5d73f8a1827b37d7386551a771bfa8d1d972749854d88b32e22705a3cbe5af0ac1872a48906ad25679158e443b7eedd0521c9173270a401460c49b75bc3a7fb92788c01e0efd7e1020389c5bef1ae8fefdf48fb6f115b14c9f4bcace004e9754f8e728151e400e5c5cb70b5035721ff71be301695625b1160fa538037ee32dad8e4f4e828c0a670b65d610865af1f78b82648a4f376ed0f5b2fdcd2ab2085b2b1bd7ec3aa4c81e430dc66f0a3636d158a7c21aec0f3e818fc85466b8affef8dfe1deaf5ab80b20c8db40f91cc0dff816d29e0d99485a738216ff840e19d1fb75f7037580c18fa6389fd9ae0fc45f171d8c69ecbedf72ca4e9887aac21e8010fa186b8f0f84e91a1f7f5b765b638864b7c69792b317b5fee08657234f458e0af7362a245164083178229c01f494663a7d12ce7aede80063e0affc39ffa0b8a3c6dd01fe40d006c574df2f4accc95fa4b94a71747848a1c087e3e40d2167597110ffe3e4720a94284c9a52ae38e34376d2e0cada21ef6ac2135c58753929b891b95fb07bb11ade547ae8190423e080a1462023ce250d359c1de9b84009f89e679b4d7d58eb7155d28ea86a92b029019ab45fa58a83a2dd7c417c91477a700fc363ae7b38491b84a5e1c5cb14e905e5a71490139fb27fd4b94ad26acf8295e0831e559838969c6ce448f6accd1bd3c165ae688b185b005f808726b7fdedcccb96d4672d74dd128ecd950112899127c9b0aa9fc47a6421d11839c1c8214dfd47c20190b1018b53be0a196f500c6991edf54fe1dcd63e981d764c054407dc62bb87aba1a1520622781554ece03adc62754f3d95b43072bbd68b5c91bb31b3ada718d146e77a985a98c42792562c83cd3e2e8efc0cb0b41dfe6d120db2347c575723adac9e88190bc903b217e6010441efb39a6b14bc2845703de61474d793a75780713eda92d91e381793e018371d212fcf94e1055869c9ad29105a4d0318e5dc404d6866a7dcca4b22782b6dfe870860294d2cb9e986820841b317f510f5429c09fdf7068ad1251e01c4d34ea3c3914484b69d234585e1e21811fa6b49c0e3e85efbea4e1f38c3f6a308893a68aa2d898a875c5be1ccab3c95c2e70f6690fc6a5c4e6192a65a9ce8a42ef202e9a84773e1be11e0d377a7c50a7fa9cbdce8e7b4c34098a4e31d0aee1251a10744a39f6985cc26408ca2bba20a906e15a16ad89763554e61729b4e42d8b08fbc4187d6eb8e8d53f5ff1ce1071178233823e32909ab3f24bd7589440f92258bcec8726f1c6bf4b80ae2c00cb19b4b194023bde5292d95b295cfa6821792e1896914ed8bdb398033ce830c9c735a1ec2aea23d058329c0f30d0f40a180fff11b80a22ff3e209f2356d219045ab9cf5ac1a0a53b40e341a62a19fede02fc40c5df9764531acb5077fb4650cd2820362c269a031d471d6a2271760d3e084f85ee5e09e06a3a79ca35f07f562152ff287206ed190418ed5fb2b3ff91145b4a7d1fd670c19c198b72e44c1d7dc29f0dd9318a25b2b28c1e8263c73bf0765883a86575f67446b8e2b67f52217426a2b90d1a193986c135c737c66143e356283de1e1b648d0b8ecab17a4f3b74672ec99590deb38a5d67caf57826cde9a3673afcea3ad1df86b0a2b885cb686fa335e0176e7206bc81f1715d7309931092214b33eba857a1e4a1020210c29f9eb627beccefc7c047fedb38942424b542dbddf6f67e03b8a56c6ce472392473897a8b79aa813c79c97f7a619ce894718706c376d91419f67c699f1b39e9bbd525292719d587ff4283f3b1a5d0fd8a6979f598f103534c7c7628f992c17451562adee666259bdeddaa52af7c051409b5e9d7359816e651ee2235309f240b2cf70f290c2d9597d3499356dab18d232c19d415cc093f70202519ae8ec8c65a3b5b6e8e8b1d758fd8c58e6ecd7d364f3bf90525ae902a8041e7bb107d6b9f103b2c3567bea96795cf07aff565b286552b179850c1f8f17541ab5617a2c22337e4b78cd6a0385f6237a4faee58bc2bb82113cb41734dd79c5a869945311747c99f967346ffbd8e4362d5c8b3a6ea6c788f4936f757c9be524f7c954929554fee962c499825bd7d5826b2f6e4647378f36f792d52b2b9f638861dc101e0ab422d29d8b5a166726acbd264a58a3fae3b4970e90d55547e6d6739945bbac9c4cddee1573739920090b5584949427fc1c876f5bba2f41255355802c9f0a0b167e1b3c7fe694e206cad0014100160f1d27bbd9ecf0dda528e02c9b277bb5e4abda97aa62ca3e6421cfb20348f36631b6ad44cf81ac5a6f23e4a04c98c8a652cc7dc91aba319cba4eb3f5ee111cd8871b62acd0d92db42d1f3aec39f5e6a1f39e065772f34e90408b40fd5b85decb1ecdb843a4293eb474d58071af2410328151aec5dcb49ff8a68e87951783e6f1d06f8be2c7f6a88f9d302937e906892bd68be28bfd34f8078c2db0c33c41246496e0a2e4b61eac169ec9c7ba56d216f34b3238496a6d785ecc4b50faf26d99d829ba1c06aaa327ff3a1fadbf6de258e3c34ae251c4a20d28947891877f9d6785adb115d82f3ab2ea73755e272105521562c7ab67de823d67dc0fcab96cb07f3a2650f555a0535670999429a0e7ee9f0b29ead505d100cf0af141ffbf7328be81d7d5f8f01fe9eac7671e85c82291d810235c256fd3d9b8f096de2cc7ea1d36955f2cf8166a7207df4097982c50fd15de46c5d550e1aaaaca9deacc31320370de7024081ad2d8d52ef0da548493ff04b07ba8daa609fa68ec4214c1c86bec8bfc931930193fe3c449ab9514ef5a80e31e384f3fb58564b54acca06aa0f6398dc4cf0308cebb58c8262160ac53f05c9740409216ef081dcaff370b0d94f49236aa30a4521382e7331f1b5855c238cf0f1faf850c26b73810a6fd7682cb8c6c8bc66f2b0728ed4a570dd5c48f4e46228576edcc7a3d03105f379bf73e36d80464e346fd3aa672ac061912c5def3880a32a006d13ccc8f5f4153c449571da5705d7608fdc71b3bda84d82357b14a604c450f0ccc17e579806b52b240e7e86b76cc0ed089d1fb60e6562ece47c664a5ea39542c5b71d4247ac05e070911a37927d7305ef65db10d087ebe7448e23fc77fd4927384388eeeb74b9f6074d39a2b73acb48d724b7179550020ed3bfa52497c4c21d3577b483637e077fed4938bc9b2f331771f15d0fd7ef5c644940801d9199af28a48b511dba7dae1e5011f6598e08ce4779861f4332d7c94101917bffef0e032c6ec884174400956e33bd0cb6eebaf5ea12dcb81e4ba4ef15e1121e2343c6ad66eedbbedf508c20465e15d5ebb77ff101470c5505cfa5c564e606f650c48f4d01e22169bd48e7d02372c129cd52ac8a8cac449e1261a089cdcb7aa9c56535b2c42885a7749643257cff4085b6459699043d6a1b94168a8b390638df853f48722f8ababa5255bd7b64f72260f2c3b959004078315af6806a0e11c3357694db8a787c9c2f1365c2e6dea2f89b580299f8ccec8fd8b8b2f8a9e84dbee2a4505c5be876de4c834a2d9a84c9bfd0fe9652b8846ed027e998da5d6f24e16cf9390a3b2a4a2404db487d6893e658550cd5378ce815844b9eba45985641ec75a5bce960e8d7fb417f5e06c94db0421ec63352b7e9ac68a53acf32ab14631113f42f00ccd608966988cee5b8e1d410c0942b33e08db236226ad6a6529e570d6de2b705cc433c9c26d4da58d6f74115dbe86ce406f7be8a80dbebd57ebc2a9b0ecad9ea4327714f8644f6a6f275f3698b5deacd0a7ec96790887ec9b875133a767d9ad30751570a263575c62360a61e0f8762886670b958ebe2f7c60b012315c54c053845a25b44bedbff469e4ae7b39aca60c0e65f2b1c1ddb2895d0a0bfa33141b610610fec403ab4709f6a9d224af755c4daac633db62e225962f6add065cacfce06d4845f91c13a0907ec23e2924aa8a015223544c1ee2fd95030694f0658164d317c554de2b55353ea2f83d208ee49c55b70d5fb33e569c5dc982c19cca8fef25aa38e555dfc2e0abd2db4a3c8581c365bad57329adfc34a00ca001b3deeb9494a8ea5e168423d968a12961949fba6e2ad36ca34ef6d9116195e74be1ff0eb2abd7ca4294212af010b44f44e7ada7226261153f3a3c95e67b99750efd5035521d9136c559b2332e213063d89e8035868b20e058f996a90ba45a68ff080c4c212cdaecd73c6883c21650401caaa9a55b1dece981b3f48aacb8c0e3bd60a76fdba518551b2ff3ea9bbcea15625fb384a3380113b36612cf784db9f5a5d95604418ef53b453306c748a1bb228317d4d5ada74036bd73c83a45cebf1ee923385e1e4bf813f2e51eca0866d650de67aa8c597c07a4253264ea58cba2575a8f845fe940102192f16cfcc298bf42bc9fa46a008738e8e203555afa60374bd4b5dd42cb32916d6c27ad95bc5cf95b60e722f9b58864b456ecfc8b6542a12268d19f2d25ce17e8a82f760678b53675c58aaeee8545700be0084c45fb3c8bfa68672f717397664f75c1aada73829bba250035b57fa768bc5eb584634ec1db061f989a2dae635cf56e31eba732d5c3909a3516daeef5cda4e02fbe992d5be855176abd238964ef4be71df84a0080191afa23f124a2b55264a225cbd8629f36928ab6c51e577c87429fe6fa4d5bff7a116e950ca50e8e132789867f1f5004b06f11b2539a911400c6c1c34c65cda10ed52b2205f92139963ee859455678e718714a96d27c964914829b2740dca5d71fbb3ea87eedbaabe0686a98d7e7e97a92c9de927825d55288285170950f0ae486977b39a4219a42cae894c650446d0cffb106653597a7a9a3e85f4100038fae42ab9bf620c010203307df169e9b028f812cd46a28a0c07909f0e49ea12335c75a564a3b6ab9b67eae3750c81da75cf28517c302126c75811727174f5e50563a45388641b5e6571974ab51838aafc8daf8ac31996526dd9709f8f5aa9aece3b00449c7096ad94c84a29ec9556d1a3a238939acf70e0bbc0d1f7d482eda865aea9a5eca865c65a6a29596af167c0feaacdad6a0c4d49dbaad95af7f797651f962a44940965e83b470182bea29a82a51e4ccd10dcc5182954384bfdb5548f27a7e6ae5969db6611a5bb23c3253db3086891b22c0a91314f055205c5861fa8f660a984e147ad9d13176731917b31b4794832a0707f47b5ff88f557c9d7a18d40f6bc787129a9b8bee7a843e21c01bd76789a30469de78a4e831e38e03bd4f909632532903619759c7600c1a866f00734e718185cd6312a8fb0b4341aea1815539f4241c3a5405d99a2cde580a81c90157cb64100dc0c78ce01128be35241c8c1bdbd06b77e54b825dca0d390be77819f9e49cf1934b541b703d79d6709b6833f8456d3afe261ddf6f6509a79163494a7620094af82c8fb9ee9d180eade01431b1c925d6ca64f7ae50936f296f400b1c1bd87d6e75b253560cd0acf11f0632a0c9cc9ed7fd3b318c3b8533f2a80b285fee5d6a7b5a3ef728ba0f2600aa43c9e842f173f15726aa62ba871c7739b8bf6368d234a7e96e54a287ba4f1be8eb3a61d88f0d8bad817701be181345269d5a4faed8620a3b154fa70d2d4f3179591e96dd78a0573de95bf4ee04bc108aefd40afc2e2f3aca4dd93ac06ec952a936faa4d3f71286484f1899d7256603dca6291c2f641fb82f4dd5fd00734e37bc5e739f0dc37229cbac98373c91b9262f8b2e45a482bdc6a0106c6efab5afc59a4fe47112f60736fe41c282a4926f66429a75686b724e66993fbe834db99c8486e44a811c51181e7bc0eef3465a2fbb119fb78918d4460c30addce3aed5978d0c49d1427d74435de8953e6bdc38d864297aea8b86b885acf125fe099fdcace68c2f6e3ad4ee8b67a2c6a40682c4e84aa63f8ab9a40624c6798c962f88347c5cfcdc442b379d5f95357d985be34c441c4981bd62f08d9474f93a445e995e3795e304544695d97d359966498107df065dedb8fa4a791d4d3342f10d19c1357cd92a5949a8b8f0cd496b54883efdf61f4ead36932fc015b95522e0d2a5252edab8fcdaf1880cab3e543062cc278699054106b1c27b9b9d52669b43e87edcf006b3c8d94a9b64af911baa614d3e7326a6b0a36948d9f3209a2590cc9976b2637c376b5d1c3899156c5a0898fe8e344181ddebe643442b1b84fc94044246ceeaee443c2cc61acfb22a54a01ff5ae8e970b33330b08c66f130bb8cd8b615872331c3b24101379487506addc1cb601d74f065527b3c3c2da4aab53f8520a818e5fb58cead7291859408ec3d2c6e226dee7f2f4e8ddc548708edc981920aa4c5272268b48c987b91dcfb33a0c3ec2843eae11472c997da44e365c2931116fed7a0c6e00ea2f25340b899db7f7dd07fa898a73377859154a4857456b26ab3cf3fe89a91fcee97282aedd13a30197dc4941f867e3f544501d1c3f7cf75fee022035b7a0610aa5dbc4dd10bc41e1a933f327df0d68e1a02f91c78d82ff85c7352ab75fd244a4ac912679bde689894ba1b1e76c0f4969b0eb60e33b609235a022e163f236c91a89da258c9f1db512245eab3063d8d24094766d4f70b88024632c741821dcc84209f6a4ca65f9da1e4c2c69a2a970db6d2c0f1fb269222431547089678cb36f351c0cfe8047379e34c4b1f79c69dedce144165a4b004e76e13b43d45955c0e86690e567c5ec21906ced1d41911f9126b854807541cf2ef3460039bc4f2cf59b8e1072e041b8e3eefc8ef7045f14089dd5d3b563b1f7e4c6841fbd22406bead2b7246f6e496534138e465e2601b09ba866c7ed4dd245494b09ab806c650e829e22119d0e9b711c49bd5ef4ae4e3dd37f2c855277d439678314e8c6b488a50f3081156d66a8d84df706ef4edf9d4f895ae67d6ace9bf39378175ee078ac1fb23e72d306b8ec427d3d72df2b8f4eb14e7cc2d37b1f131285c3872787a310f74785cf4a001c97c02b3582706d2acf85062aa8bc3957c76fa6714ae4402f3392800580be5e8a126578d55746fa8ddeb3574776983f37aaaa154c1ac0d2ea74d2ccfdce1b692e98cc3c31301098bdb70bbe68f82f7a797eee5720cecea6dfa3b1bc15451936e714af65c47e2c55568d5a53080a16ec8a2b4156e60f573018f509498efdfb269e6fb69489de6525dc26bf651b7d235e5793f875bfb84507d4ce359f98709db4c6013f2d49412d77a4c2bd8b45896d99f8d235931631556ff6e9d5c5333c964f675f7d406f0e077b62e5a39f900d25e5513b24d637a4a002655ed991424cf14c8ded92e4bd4362c0c86e77762ca241da73d0253d0157b5ef3e5fe0e719b01a8ac12e20cc4ed07a00663aa300a736c71e230e4e2989427633a22078c672894ba8b19f46253b2fab02f325c9af15664c8a2814b0421100b6ef0446315b24143b1b728a7ef60950b1f0a8c6fb88a7348674a3874d07474870911ddb4d0b51ba744d7c65cd1822f29ab04aedced058f409af24278e95b1623d70430742920f892fe1dae40eacef1472147c0fab9412118035dab8bb64c6508096b48101e1e6488f8279a4fe29d3b38dc388a84f474efdc0c40605b75da71d6a5f8518d4949a80eed31ea0249c9fbe4c7f56e42441655d7a6da0ed749f175dd8b4ae471ef20c8a09e5c2e2f47415ddd63dae6e1ec63c99118dc9554853b304d4537f83bb22c5847fb0cb58304931b663c0900a2e71aa776389574c463019e2428a507c87b10db402ff4f4ee9bdad52835926541f5c5718f6c8ff9ab4ad33f2c72e5adb9546277d449c236d7241c401037f0f32826ff3b8ae7b9c9ea58abbcb1b82ba14cbebb4100b647c040a6ed43dd1575b7c0cad3beb4f6aa36dc772e95f9f262d1ee62b411033ccf804abdc3f24ec0c5c3bcf8f2fa63d1925c8ce7e587851e6bfb5ff2975fbbbbbc8e3fbed8defce68708ea38aceee5db8c56510cb4f38c4074c6d3385b31db07ee3ad2ef06b9c10f992d359b89d6c5ae8b9909c218a41a04ed0e85a218a4b40fa80ff68301d2e0395a3051b78050ded7ac4ee1483ade1a309d01f30511166b9f08b1222cb87a8e246a5981d2844011a0ff30ef6a59fdc4079f0b22a481e19141042d23f4b5d1479c968746af71ab64655edcc4c01d7fa0fc240e337a23d63d2ceadbcada011c8e26609ec12529c04f2df222b6e15db87e6837935a6b15e563a8bcd268b0031ac2f16007de4b832c8fdb393193e6291276a86154c3c3206489cc456fb533945a1175626e3af74f93d368ee247c772e998460974cad89ba0fe725eb00f02398728825ece1f574e15922e44d7b3c3390576e90d735e4e529f2ca465e48f25263baad031c8ada0500fcc0118d418aea1e93ae6641afc510685b61ca777c3833637f75af5f92692b45ba0f4106edaf6680fc6ae514cf9938757ccd81494e74e27873c65a27f073b7d6d93f88b70a0232ab27061ae32a08c8a057433380653bf78000b689b6d9046ec5f7755a8178f2df4d2e113c235ecf87c7abdd3034a9b91c1ea6e45fc622f35e5cb536237a20ff8ee146bbdce96893a2f73294c91c9e15ee2f1f5da7aef35e399c9cc045d1a9b5933fdf1d183885eee805bad9f370cfb84ccef86be455e903229000e844024c4b09882a7aab12931461409df39bdbb89d36a44164b2486d6fd96b53698bd41ec06c757a6a89adf8eec0af975f7f49d189810bd7442a8af648ea4d21edaf3815fb0b6b955ef61c57827382bc53486e189367bae054e6c22cb2ba1b52e75f61aa33072d1e47817304c23e50e62d15e675aea7d0b672c63cbafae686283d41028b91e8d901105d6a2b07e05e57a64ea42070753b6204eb3d0d36793ab1e0197f75e754374ff9b46214b1be83ce1981606ce52341a48c97bfad9c61a9adb44068ae7763ee55f2968ddd88340fc3728e5b5bd3b5fae76af5c5e3115b6ab401c3fa30fb012bc98fdb4d86320e86a7ce3de8f1f4e200cf30291fb34b7c3e0bb97371b99e39d62371cf20d5fb5f1a7959ff37dad90fd83b203ddd769680b4074eef8b21e484a48be4b69d30197e43f17e1ce38009146bc9b14a56595323a368afc2d49e261e75bece990fb47317a4c1d5be9d7cb79908d23bfce4aca605deb5475ff4330c118c36f9bc4f6e4600a5b7cfa996d4af837714ff160faa974ca4d9bf0e33b3b2939c4b6d65d8a8974eb54755d6b0d6a0b5440349f05202a261c6418f30029a69d97fc437f2ea06daed32d5ec968d475d73ca5cd54a0cf34a5bf4bf51bae4ad1d4caef638b8807f199a4075394bfc4b6326f4865030f699b589580f127c029b9c49e757becf4a38ad292de895449b4a14586685b9511c898cdf87c051abeda3c715e89057d8b7a834a37d50969f7cd7d3352ddb72e87b8e2ff0f67de2be7db889128884f085ba15940c1144c56a48e2282ef79d694886613988c6f8b2463f1d5375cde1328ce82c3d1b2a6bc251122a6873d5e40060e0a3baf28025602df6baba36caae24a055077f57830334d0689581a9cac7c7141ff6f345601162bca4289d9e27796ce4f37a9f6f27344003419000dbfbff3a21288179633c2995061c7558ab534971bbbea7c6347a070447feb611e3c37a4c64197ecc603b247467fc2d1b23a8334f6dc56701aa0acbe89ba815d824619eb8459b7326797cc574df3fc1a1ad98885efe4a28d27d14a7f8e7a85beb9f4433dbca44593741ab2764a527e683d50b17ae37583a20af69c0b7988f0a1199b53ae1d626ccca445b311383c845231b1a8d72d48895d94a9e074e4a1c3051ab7d82aa418b3b357bc044ac9e80553af5ad8aef03cf2e6e8aa0a5b52253207c893ad199b67e2256bd69706ac2033d3e2cf4d1831ba1fdedbc38a08cf6e04ff52239bae2d6157cee15992737ed27e73ed07835b0dc020cdcede04fc81b4208de0aeb3e84fd1d3fdea7c9852f81abe62127b88a0f6d5d31a14921f3955a737a45181e66049b7054adbac6cb468ee854b5f251ce0db818678450e5a242ca578c7a4a1bb3d3ef3845b591e834d00ad8437eafa4f7d9d654a86d752e671c63ddb1a77a4b4ff6054d992c9f70d7267cbea478113d5cdcafd50fbddbf99b2394ac1f02a8e88c47036e9ff57f5cfe3e434a7a15a4a1d3520da23e45aac68e2e6a0eec5ec13e5f22d12b622175e12ef42b7820508163e82499c1f54dd6818256e830bffba5f381c04139b1ce3bff633a3f16b967a55b95fdd908b854bebc2d8ba49fb111a80fa515a7d0ebe554b4ad43b1124eabe93adedacad80cf371220d1ea8e6f03cb1cd0d63b028ae49ae16ddd51f18575b77c9625fc15b118cf3153ac29774d795417d3a8c818e1dc9e44a2487084662486b23ef8a05253517e8cfe3cd109460a491dc525bbb72774fc343d7a2862667c17821bf53404a30aa6567178b2ea797e0462930d56259cb811831362001dce7f069fce423bb01f60b6839f8511da26f7c36a9901b7a9b000090489c2ba50aefdea80cdd56a162cf327208a0c060b51340469cbdbffaa92c9b16c4315822ee960cdf9ad9f8918090a653f0e66055020a3359dad2bb1966f20b529c343f7c4838e4091642e36436a9263d365f059276663689c3078e767846877622a1c4a834abe9e0e98e06a4a840ef4791fbc3a6c4e39478e941fb405ac05fa010275ca01b5b24c97950f43f81ac1fc25a087a4e273e2b8f039527199c751e950da1482e98ef220fa6fe1b1e03af2038aa2884bc8240f281bc22b1ae6570807507cefbd80a4434546658e534628bee99c7041ac1112236c6f83e3a0e203d6cd49ad0e10851a098681c41c4a290a1553325f03b9bc75cd0d32289364ccb5ce52891966a0855ce86105ab618164858092f2620f5a101bfa1a3fc0fd96d4e106f421ac1d8edf87a7af2fb7db4a9cca17b3b3f6cae9a3b4046341af32d94b7d88c6ef976311c32f9fa88edf786248cdd1ddca73efec72bb39c50ac04b1b40c5be99e98aaa7c185f1ec55627160057275d32c3bfccfe3e5ef97b82b6cb0fdbebc8e7776bbb6d72ea32a686c2f584dc9c141b00f6dc5a984894bd8275ba659c1f59cfb353e1f64796719c66e73bd64f6f1139c26b8898d07760dbcc51f3bd884866238c6446cb76d053efcf32f0b6ca36c9bd89c6db34ddb3003db1000b2bb87bf431b3e7604e2ef1061be24287f11c21b3ed6821be43026234a250f0bcd6662acce4ff4636a2144a0f1fba97daab99d4f00da951484390f93357e94b09f9cb4c1a959de502c2861e9177e0ba257b220799e1b922f1bd703c25f99ad584c47f46f58eb444483823817147010d0804c92e81928d4955215958106998c1f61a16bb07e389c26b308e1a5f9f00830125bdb85247036bf0ec69c515308bd36d58a2a2e09523532e215f83743b0c679fe7f773a92d12674bded5984b9eb0e42459d332a40d108559a893435632cfca01aa0b7bd38d59b338e20bd742075ee986e4c97514d3122eff9a246d07cc2a155c1d1bdceedeca8153621535bff229704058efed5f826422536a2a39d762a4e0bcc4e692c5a89dcac67e01b47f859b07eb466a78505d23515c8b141e1fdad0e3daf1ff04a03ec5a3918b9d920d26dd770483080d8aee6eec1bed79046c3ca6c5ce7e4d416184f6813ec3dc73446d9ea73f61c1fc971acf4e176c0d1a356d070ac6f064c51aa3940f9aed84346edcc08330856307ac759b147dbcc6c1d20a8214be6142590c3ca8931ca39c1f82402c4b41a05225d737a952393f781baa04ac732c73582e28c5d8c14251316c9fe67754010fb95c71e611283f8298067684d2656b93890334ae699f2625c127ec9685803d0367854107a8d298e2a84da911a50ee8ceff0a4631497be73fa0c1080b25d3a734ca8354461353e97c4f41848e42f3657bda0abfd5040c6fc4400a0c6728e756703b68ad2220b3a8d0c0b3a2db9a881e1c3112bb14f09e0d32d22971692730d05eb06940e4c93c6e134085198075e834343be51cd01d4fc3df07b8e0aaee64fd2c793cd909f288aa9cf170e0fa8811c72ece6d3fd828fd39dd9ba371b6696c85315e759b864b47791218c04712a8a5dc248d6afecd7a35f2044c41797ddd643a5d2c9901d5ba74d4989c976e34d6aaca2c62d031440b17e836acd994d45aae35138e0445f7ed8b685803df237c6a9371f8e89954180b351f3e8920af33313336f476d5b6ad59d46ac9dc8dbc0a3fee4b7041bb9d3650e01712e68e4f71c991d609fab525bf55f8f9c7bd3e0a6f08c4a0858a52794e714944e591a2825c97d1811f364e0c6db8b7eb993c83658cd03f62b2b23b6823879451980fe3e0413c265829b0a89728c204a4c01653e829e4a1681b9ef1495a6027b9f425e7747337a6eca58844e745705e4126169c652bdce8c726ff5b6e39ca447317cfd3cd67561b98dcf4d212c7561c611974fd7ec151482a644be90cd6aceba59c6dae0b68adc8d9c5858f1b420469ddb2b4955c05c044827324c541e12da330245e4d16dd3a9eb9633de7c88402618dbff528078b66564a14e59c8e2b3e4e07404a26b58a8a9077465b5a2ef126b02a1ea0b759b0e12712ef2f09c2cb2d326b3ec54db9c34c14cc5caace76359a544450a3f035a50ad36117a0311866c98994717621c6ec0883ecb42c2dccc040b464e0fdcbef81140f760df8c63c2f6ae1c870db0414922b634607b7a952370cce61e9e8284e41317a30e35a3d678abc32b300066d5b597d411085dc3e8caabcc861359e92b297843f314766cf2b1f98b600930d36412cdc6037600d001dd4c95e43861af956eeba8db17f101c41b1faccc33fcbd93f586d1c7df3d56fde49bbcc90eac97d2555c11ba65da063e4d105ecd0fe1c97b25009c62c794ca03c537a64d0d3a600b3e684a483189b21d5132bbd2aef0fc7086d59689b0de5a63e62e95366628564f37508ff975e7b039ed141636d5f9a753048b408c2ad01b9482162ac898959cf6898d2aeb410439d274e2040e72766801e90f54b07d79294a54a06b1fd69d983551a1a4fa803b7320ed69c8241bd308d5569831aee697cce7e84906b5ec86334e93bbec0e9c8a1c229e94a1a4f0094e74b573569f5029bd2b7e1f064920ee61a773b86dce287a07f710f02a7781339a1e98cb8260049ccc9af6ac665ca1c9f27df52b447a55929fd4883ddeb0a4cae30c93a594591ca37999eefab3e4627bcdb4fc5946387df632311216230ab4c50035e0fbfbaa49a62ffe97228557687631da53230386bda428f652059ab613966683b6cda4d482615deb3f4713203669dc166e6a2c3ebdf07e177dccbabab7f62f38b740a98831a1740bbc89b9f31e3314259cf9a8944410c0240942c68f441f444c1b588e2f3e442588d9dfb26eb3dfacb0430aa49bf4acfa0a2b850e1035d8c6e54ff4eeb532e50a67980562469eb8acc13543f0387669304d3a139e613d8f0a852a65fa9d23fa1af4a6ebea03dd71efcbae1de869e7a307460eea638456c0693008a168d859614e422113c07d1292231332d396946e18bccd04bee3d140074ced25abfb9a46b3ab59fba9505e758a6407f79165a4c7b7aeeffd6e1589127d7c51a090f095b2a23de7d97bfa32ef36a6b2b04906646e523d4920f07e9f3adb78b14c395bd140b35ea7484ef0ca080ade778ff59419e3c939304ef2a378a4c82e746b719ba5370c52ddffd06cd7f2937f65071e9cd6895bb82c2082fd6d431e0482c80681b044e93eb9864044b360637334904ff07db50b5e0acf1b28c24dcdd9431c9f31493e166c1141bd9c424a4bcc93a46b51c89e08222c9164c0f7e110d0530bbdd1013865466373642b4e50ed299c539c5d3cad82143622fb2fbee77dac2ea83c019697e318c4abcefeb8b67b9c5f484ecdbdf326e7cc1d1c7e388053cbbdf0a85d70511852a2eda5e2d27db56ad2840bd7336c8888f1279782d6f2cae8ce261e3ad5044fdbf882b30434b8538bd94137fe1bc0322223b5ff2e019c4b660ade5e0681550f38bfd5484216025ebcde55ae5f9e228f966a8895936b63de9202342ef608d364f345cb254186f5c98c02b47f9fc83d4b42398f2f1c78cc2a21a43d21d97f44b1a1d7a6fd23f0e8508a2757e12cc1e3d298b8cb943dc2aeb6bf288eec618c62ef42afaceaaf43bee246568016ac9d811466f56cc47686d62f49289d2b437bcb027b80ccbdb35e4276fca809e68c5f6480f81e779991cc82f8c6acbbe3cbe57aed2f7c76b5f532f3316452d8bde85c74f5c4b869d60ff77a5fa38fbba7485f69504e7c8f152258ec0f109a634fe8a1035b48376a659fcbde412fc29f4b822bf364ae145b7ad3fab1be2507402f140fb5582fa16ee580f6ca2ad11871f53e7fcd97008c5dd36f13421c2fbf362b7df049c6dbc76de8554d2f06ae1d8fbe120707600484a91967c1d62c67eae927b0fa7df7a125c5f4bf8ad06aed8a26fb835f04d77748a5e90f7f02ea301177feb75e0bffe91af5fa7cb9f3a34f1585eaceac22253914f71f24dad24f0752994b58e6766ac9750811d6471c2b56f2c96137d6d22d2337edec1c002b14ca064f413dbf826ba2492f149da8a23faac7284cf5a408337979a86ae05e68206b363a11e15f7b7644cdffc2250c69cebfbb7c8db797d7b77ab14d584b860609993ba3dc0521989b627deb27053e938616e614518606c9357efc818afc4ea78d87d514c53c890941bddd9c6bdad34561a5e3ac04a9a05444ef3a18a65c49c52a5328648e3d569a288f6198d42f9926fbd5c743303b246324896cfa04a5a63a309d4b02e9b57d0adf15a000a10891e05d1aa1ff22bdd080a1a2b1f70f7da0e60a51bc5ba1b79e43911b0c55c7d27715016a219d4604551c63b4400fd675204cd99089d7c628f1a74259f81c86948c1bceabc304453c86da209915069dde5c4ec687597b6a060177a64f0d6925db94e79b3642f380e8f14e356a666cd30c0b3cc8028ebfa6db2c1db3ea5b2138e70822ab0640a63d8e02039852ddc78a026d142db6a81f9cac689c1832b6fcf76111d82a41dac464de87e1b27293bd5ab3757f3960092ad0029b19aa14c6fca83f5ce543bdbce820a4bfd0b8b8a9ba76735f90077219558750c8dc98803a404eefead85e8e426f1a9a698a25795d59bdc0b1a38875c63f23d72809ebc168c43c686c8a49d97af96d59a8057a5f7c4d8c5133aeb0e6918b617ad8a8f75c73542fd2eefec386c4d34929a96eb2a4fd923ac03530c003d56246d6058aac8f075a7d6bbd3b142e13ac377ac84c11bbbd3dda727c81795b027f3fd79e02c6104a8848385178423499b7832d83c0688e4aedd8ea2dc7a427f3de6f1786c6355bd9548a46372d4f668a0dfa602f540fb049bb927b4958c1b68e88faef4f7e1ca9adac37ea5d36036d28185050164888fa8d4ff7035750c4e6980e554c2e873bc29a092f260ace70a3f6379479b75af1abe7fd841128b4a6fd447d0e2a3f2873a5cb690fe75b6d694dfdfc47d142bb76b2a075e0cb5260e966a0d5ff23fc75e013b0991ef4838e78c6343c3ff64e639d06d6892c15a208b88013ead884beaa9328c1905f2ae4b2854d15a375abc11cf0a57d504ec5e4ba6428622741b314b002896147a0e035bde7f076aa70c3196645bed5515845c0e9834d8510ddf9cf8031a5585d3a83f23fc0b5db4a03fdc1de981a740e1fa14e456c6e008e856cd4bbcd0fb940543e3fdc24d208257fad3fc213cf930054025eb887508978ed87af5bf055abf82b4e38476f3ac9472e882da1b9e2581ff49506ad0e48ce01b6846fe7eb1fffb36e7d1649f94621d8bd19bc602dc65b76a1c96f54983d9ca15f01405ef61f7ddeb34a3a62345382809d58d0ced9187da0e3b44c7c718f7ca771a4b16f68e67ed3e65ce139cf79841c186ede2774c187a48a062bde3cc19899c6261540606dfaf4ca97e8e7e6ca267bf48675137880485a0aa89e91f18c07afacb1f5742148860b59363dd59e9f39b6b3b5040e14e4c07e31882b3ab8b5cb04c52e23c755e6361f43fcf6bfd97d78b072d011736c8abb0cd2a135a8cdfd90541a849f42228c37811cb65d412214403505fde842c4fdb0e5209b3a1c4cd503ac40206ec8187daa4c2e36f06daaf5c6f83c6f6dca54d2c229b171f19950d065dfd525d5cf355c9cabdb952a2f71f686b457468b8197e8b182471081cb66a3e7de523f47a03ae7b6e9018f598c54bec558d86028586ae628c78095152d2506fc588ac9471ba45070397445d81c544d62f913598389f8b250c32ffc4b10d4f690f6d18f151b2a688543c447c7f86ae109ae937175824815e10131d797d798cd2fa8ace8dfbce627a671edf4e2d84f2ca49c495ed1b68e74d27cc92710e542627ed0886ede2516c0e8811f10db74e2adafef476cabd12c636608501bca9894710f26fcfa2d5a5f0892c7d81697e973877ec1a3d33456656020faf214b019b14e715490e4266921fb5c61154c313b0f4a5b2e6b0d0a61da75645ae09e8714b79a561636b690de2e1b2b179d76f9d33b7f8d8dafdc92affe4125d6c8e0aac274ede5f194a576e4d101f23f19a35891111eb3b2d776eda0f1ebf4d622eaba7bd954f9668783dee88f06d1beb4c2e83e674c203ef2972248173efc1d221ea2ca970ed0fc913e74081f46bf5ccd93ad33f04731a62b015ca0fe7e148f4b47696c89bc2e969fa8984de0328b47480b9cfe494ed5df781b6621c814a790b18da9a451d741bbf9aed7d209e8870c6dedd15faa862a23ec0537037ec20cf643b3d630648b99220255e2b5299c31becc22a899e016ae16b0662560eb94ba18833e7d5be15d105ef40acfd0ea4a795848ed888688720271a7f693a0098718c09e9106f4d46a7c0bf54a51c770b2798bf0cad685732a46e74ba67248796100d8755c327df6b046bd639c064680110fe3155c2932798cd0159f0e5b67025eb76fbceccc03c9b2a9c6e3e071d0e0eed292b90fdc00a8bd712c84ec75b4121c1795dfca988f22a4eb145fb28894fc929cf6351d188fc305188357ba7f486d39a674ff459d7b3d5729ded449d1813183e3e864ebe776673e3da2bc9a277256caa9a3ff67864cbf75024099d70f6f0204b4c1742ef559627a620927e99e49043933783740eeb0a003676b4e62483cc3534cee8c60cdb9f6458d40d3eecfaa4c0a0478826cfbd6854c987c487da8cef612f4605d0daad86d998c3b1ee2f4a74929826e701dfe98fea0a7465fa0aec7c52a5012392562a7f7cdfe1c7afdc99416513803cd62085cf3ba628d091a055f5227b919984cb823fae843688be6309fd111902bc7b691fa195713cdca8b5e1e9a3f6d9662a4267ba882c3989e12f53b4596291d02b6760354b96916a7b0a896decea59863f29b48d0affabfa4455aa36bd1504baa37a9f1f77e16b47ab0477c13314f829fae803cb1a55f98e386c74147a294a1904e47573cc52168660588b6d0a453effa62784bbc580caee2f84f9301fa02a9cb384b5844480c18eda6b79d6782596d7b9a43fe88a299d4e5af70562c2ba53e1a0e689742ea965b80199ed89a0a2f13e200a1277db698c269473fde4e16ab721c3e19030ba767142a9a8328d4e1e0c0962fcb12d8bc846ad94f89b5fcdb84326a284341d0f2b558ebe0b2b043e69a102a6182fc531971a88cf30880664fb9b580d46d9ef05822e49e90064f35c017004a64b01af17836067d0f6f3cd60f9086448da902ff63ccb2c7ca9044c802b61999a8dea484592c1fb6a5c8e9956bd78c3eb1b5d8fe0eb712769f498f9febc6bc12a44dedc985d2a4d923e78571c098741d6f4b10ecd0d7d90847151693945f7b1281e2db9c8923e325351f47dd5ee723dfbf6c04bb6356dad561865fce55874ce0cf178bd72c98a5cbf8c6b2663340a7bf6e81c6c41a0a8ad6e0c10df95c877c74887c5b9d3cd706626f1346c890ea0db57b4df7c5f3a8ebcf5a2275f886ad75e7bec33c118cceac52c6ad6300b633ec6adee8a49cc1650098b3c8c0348e914658dedd7595e8a010d3977163d1d47647c10395b480032538d925d466c32ec8c527fbfae3c3a19ba928ba29d804371de5d55e9d3fbb3721c9bc59c6606c52e57b66d6d19dea27cb93c71609bd78342227e0c5f6a3627acb18041b3916260d873bb923bbe36d0a74efb51233e5965da50923314eca45c20d77d130c05eb17ba66506eea9ec8c1f51c55258b4c5e5b5930fa98a2d0e331f75c32691392e8c8d07114875c5dc49c95be6b3e11d2c9d48954593aede44da3b940f494a55a46bee6b17691235e109dbccfcf41b372592b55cffb1e13b73f7f1843c4f4056d2ff86bd24191263535021c45969174116947bb0a3f20c0fb9f3d74b10cecb8287cd3641e52359d3a560b2f34338747d647551c57b26fb0f6c637a643a612dc8e14e4b0659187a7833bc539e28602c6f9aa8f0f228f454682f0dd94558b0210d2ff89d9082f54482600e1c54503c51fb0e6f54aaefa06f1726266abb188224edae886f3c9047499283cc5d908c589719e5a9df0d8f1715dc54c987178ca438590b22ec3d14844125474a21567639a5462e1758a2bd2bc8f0c7eab288dfe356c43a903ce285340e812ea7c1fe59489f3d6621a80ab4daca276b373afc4d5725a8c9ad297f6b1c139c9c491028824ba4a50e9c1d1e44c965f2a92c0744911547174d8122c5813fa5688c5b5e1e45630c525ba00b7dc39dc8b244c53f5b6e3d04b93525b579b3d0e98392aa36e78d20d80b31065ae00c9eac2f459b70f20482ad88efecbd50bc050b8da9402774ee7829b994b64e7d338b66f7e1a220f7052bc2e1f753cc1c6301cf98a1bd9c1d553996d3568f3aab8e0b54452339303dbb9d785c9d1b8da91b421a2436557624b573f09baf8da915e8ad95ded5157332fb37e52ca59c62a0b58e80c26caac68fa89fa7ae659d07e04befeff7e0fe5b532949818e40d3ae7d2f8e91006b5f54c972287e8868a15f7e60d947cc8514e0dd3f49cadc82e86c3c574adde639b00c7298ddc16321f526df83c3764d9341593b0582e8647d7b56c0677520597d33fb7c994389541010370039f2e85de5fcdd2af745d359bdeb0c47dc2093ea590b10dc82a925518a68d839c1aae6d99cd69bdd075d8efc58520a754d2b0c42ea1df9f9d565a50ea1c83f36971464568cd8ccee5a77d27f2546a16a4d22a4c83019400f680f68f5232d8ef420f58f1fbf141f26b8b59c2c21ad73f4715094a459dce5f09f30c614a2307fb661b5bd1b923d4b474092f9fd135d88bbea4a9024ed47f9376868c7c2936ec5ca5d4e54547002422da4c4e4756b961cf1b6bd2ffcf21e0f796f6c463c1b8f37a7df63d8e94ef2bcfae4dc6d7730e0305931f75e03a0be686b4a6f19a9dad570eb47cd0ccbfc4c43a367a4ba15dd82091a0a89e49d34366f88e482ee70e140a00c8347d7f4ac2e59a167dec2c62d80e701e6ba94e51c6b0069938ca1c193f13ce05e3bd85c0e709bc8f264408b35dc56fe9a1e85ed8b1072bdc2c8a34f36c794a649e03a3b4ecd8ecd860531416ddc85fab19fb1c42186c652930e5706c516d71507a173699d14653d379e53be3321d6be5251c0d0a82509a269ff95d288257de77495706c1006b8ff4a9395fe572adf88d0475e0a12013e4e44acbc6faa897cb4a57c0b9da5b82f84d60cf886d7c83e48d14a81eab234e6891e9518a6e7081d2314d1f113f168a6ba2b947bca445ced5aaac8a1aa7eed33e9743323eee0df70c30925d433259b7edbdd131c7ccfc860dc93ff28e10089c84d9dfa4bd40c4cb904ea5df1545bd06acc44c4bc3a6354548be1a3a85cb74144da1942f4d9d0e58989292a14daa4055d67c966e565ace8e7e76b2e719d4738cb08c351088d1518b15ae6ba2291e8cadf2cda43a42cc57700036841498246672b6e442bb5e107fddf4c07e051a7b3a2348638fb6bd641c1cbe1bc88184a9ea551ede5de7c47c9db5d3bcef6e583d831fd6e7ed00c4113ef17e6fe38447380e36bf56f983b40ed4f0999bc5463441068f98c99a719089614c88a008e3fcd7aab02362c2dcc461006112cdd4e02ed19a4061b6574f74d270d564e2b41122b3a36f7661bcb88d87241c71e3204bd385f70f802d1928904525db491d4e76f9486dee98c0663ae7f7b792e4cb2f3e5d51cdf17c2646ac27e9229429fb0794019d4239d7c5e405c5353da93a921fd279a25245878f899d0caa1890cfed12907d36c438c1499e1c62a477c1efead35a363d03ea9836af330349ce308207ad2933628fa5026b321a27a2be1dcc4a606ed441eba7a14e884f0ce49b0c792241b9d6e94cd4baadf945289b4fbb0d3eb6178ab8fdde0ede6998e6b8c010ea2ef0fdac7844b755044ae264393d60302f6b7ae3d03d0119c6eed601457d7f32d0fb64a0c008354d989137de621dab93673dc421604f542579c1881a1ddc26e86fc7833ea4fa566f0040aa38e0c066141925de26e45e2fdedf79d43982f1e972fd12766181b5f56a4c28de83d85a9e25b61f7463ccdc49785852e1c7a972e608363f512b7761afe370734f5a24510252f771babc4f734baf4769588de344417d0a4960aef65567ee507af448e14eb31bcbf74e302c31b78648af914785bb36aee42cd5a7768c225b64b5a064115081badc4c7d133c348c099fae6cf2aa23ca7390a63ea6bf4abca0ae29bea849d41b379cfcfc511d0e38451e0813adf5546d41c3aaaacdacb35dbc77c8db9117549676f7dd9b797ccc88ccfd582b3351feccd5f8f78f04e046210606f16f70f4a2df3e6546a8172e547043bd28c0c07f900a75b23815490a2cc44350d19ba41841cc97ed5841a21817716b56926aa3aecfdfa7b34d81dc3fb70f6de23b63f9dc4fba09d26ae4d84f97fe79e7652afa6ac41b28a0d7a188f9adab18357c9c95ebc06298595d00608ae410af982ec18af412c05b9089d8e64c138caeffc8c81f6460da330bc3474f2803ce26c7ac919fc5c95e9c83fa8ac0104160da024639ad4ff1c7c6121a4a43277404e18e61bfe81c539eb19da07c52100ca3012ce5b6ed651d5d792d9c44b612c533b786cd3942884d2b82bbc6348b67256d76a1c064d7c170aaabfd9de0efe4518ce58f36b1d6b8634fa9008c40a3c57049451b7bb50e40bcd946c65687a585ef0bed9244be36b4b3dd2d0089a0151012488573417b370443b7fcbf66e62f6288f41ec688c26140e194459f90733cc2ecc0685e4a4245e0fba4ca78da11ac4021d3125d63e0ba2f7e2c9da2877aa922ef641f8ef6bd7a263f30132e91c500a7e003bf3c4fc156734f772aeffceec14ef494358b81e0e7a4b40ac04bc85788f380d9e9b2707b51d1ea6255c44fc3c1ca78553d3dfe723782fe0882e69fd429d9a2b6feac1b98dc68cfa7af512e450fbba20a93513bfb5faa52a898b8fc0d5f3583ce17c1eca9e718fac5beccf4d641708ca648259f8966d25b96a5a488d9f87ae93c463370fa690558e020a707776a2440318a89d281a5ac84b3bcabed1564e7d1f21c04f277b7241f263f54d3f77fd5a4b7d9eb0957e7eafa0844e3050266324c323aace140cf3b6a7c15bee865dcc3e5b617f052a2b2962b552eed3a278cff26e3544274201f537bf7b0dd578bca98556cdc1ed0aa03800a7b2329a03439b7bacc1e1c1d9a4b6c1be9a2cb3594a4c5377448cad06e25816e66f36c855da8ceb533521787f28d4e4fa47406ca3a5ea1bd57f51e2b3896f8c4ca3f1118b6cb47caa39a8f84180d89986c1ed816a4209acd7c979a4f155dd47310255a8ce880285faf75a4514500ae19dacd8ef8311f3c78710dc68cc08755f5eceaaa7f4681597d11a9e29903d3f20d94c604ce8dd320667762cf1d903f877149f47c84c5fbbe70f0674685f53d4488733eaddc5f556f774ebbec786db2c36f1fe7deea55299d2fe3449a96cb3b9e59d020477f83e61558978a33db25cb1494b658763e1867af1a492bb1b73605a3ed173492bd9bdee4e0cb8c542b78e15c6ec0401c7c53a095e067c5d4d7301d369250096b37b3d438c65a486030e10fc72ad5b4ffe20ee9d85a6525de331ec113b88340e24614679dbf74c60af5b81a83f889980c971f8ecd121d9194da7289bfa5771d611e9e8d16f961c998cb47774a71bf787e15a82ea6d25976adc7cb9cf662f5cf8c26a37f68abbb604b655c6f8cb30e4798c109050c13be0236093c94c3f96c265f010c71225a5d808c01c6f75a9f1f58db7542877fa9e9c448359ba0a0d3bb5f805b2d74b197102baa5a38f9cc3235afb2471ad2088bced9c3c730a410fe8cddf196d951c8a89a62d961b75116c7aa0e8e8c57efa676f6af35261ee429322cf173c95f6b66d7781b1befc4a60163436bf888c0dc011e6f7b55194228e8fc65496b53d5501a43148ca38912645c19146cf4b800bb0e9b3c70d695298210dd1480322e3b1615db6c194525d5867935131387566c5494ba99159804c91e730dbfb0816996277799f8ad32055f0f869b6be55f5831bcfed2a16875c9c1e7824c9cf725c57952a1d609aaa24810bc503aaa659a4db94936592ac4aaf8528653b3e2604aa1bc7d4ac48164b7773264902395a141387fd17d85fef1a90a0e08f542610cb1443c35008409639b74d541d388302e8883f8fd5a4a1e2da98d75295fa2efc78561addf6c9e0eae1929e36629b48595230272299f92c21bc54a96b0892f5d976aabce35d993b259a5d0326f6f81a32f8e22020f2409544388fe1ddc2a04d70950c7721a398e08022ce45f941497ff868a49d22fef59fbaede29e14443f2087de00dc5a8ca4025ec4378f72d4ef3224fb51f52410f832ef7456c6f2dbd9973b54a23430de2c4bc340f4a06207e18613d49db3b7dc1e8752684a29198c1d5843d5284aca1037542a73f2a8d3c9b4a6c2119d5e25cd7dc7f90c1ccdd15089c3f4c5460d66686ea64ea9f592f1bda4c3d18c0f150260cc335373d74041f87605acb6f081d7221564157a192e4f0d3c7fb0b62bd3fed9666d0547c224a93c34c51f2c3d1116be1adda337ab8d89c8392d0c714901fb25fb8e383a8aeb4cd27442b17b217619ea2fa553789d1ec8fbd5f82904e2689936d88a0f69965c3c1f3abac27d68bd8a44919940246caacb02032e3970b25c0ad0438ec0f360ecba532a389c2e3d0ce2325d1c19db53a42498582e29148302faf3b5605d6056514d1b8921c010228c32c0082a72288d80c9c18d30406406c4032d52c901a38e1c34f2208a03225277994fcfc0de5106fdccf870287435ad13f3e149a858e7d8ab1a1c3d2843cff077b21958fdf0c4cf50b25eb9894476f7e69601e005b8051b06f53d4d9ede497d18eeb4450038eabaa996272984cc21537c539129f922617cabaf8a25b9e226f5a5cbae55b2ec5affda771b638c2d1f16cfae3abbbe88917ba4479a24f948337eb4a14c23da68e3a66fc04df1fd88f38c4b353b0376e124ec1fce8aa7e1d140c3ae34bca85f2b09a6f52c91cda99e628b6f1eaf045ff64cf645443c3cbacc4689ff8dd0f6c7de1f8dfb2e926558cd4a0c521fbb3a86b7b8a4dca4fe7f165be64797f1ad25cf989acf40a721c1515390a62d2e9aa67cab2f35a999161d2abbbeac3552ca6d6b9181cc7ee7322d38dbbfab35bbbe8a2933659e89eefa73c64bcf67cb4937e0be1e477493edd875d6ecfa33c7ed4ed6239a3ffe346557ba822f48eb280dfeabe1807f35dd4157b446531a4d53efa4fea56911efa43ed6340510a5bed4f4c537181b3751c512d55161785e47d43ab14a543466d7afff59866fda425d3cb06b8dbbda0a922c8852df1d87dcf86f843616899498a75da58f8d6895752f4a92154deabbb42911a5c84e6c4762d7eff2f69faf2491782b28080dd7440e49f6b5dd803bbf8ca97f23da91d5ecfaefd5972cc9922cc992ac90645da090cbe419d783341c70e796587a92554555ebf0f6aa7593b56b8d90e63457490e3650312cf893aa719d15d58d6feb56bb8c6ff569a681df6a38e0beaf22cbd0386adae25b7dd7a8cb3ba93ff201ece1bff52de250e3fef5d66980801b6b3e63b50c2633d382135f43be3e485bf94e3c44db58a46cb20cd76a60cd77aee63abed5c77276fdfaf6072953749c34b29ad4214f2e13b1cd445f5f9e6289859bf857a7c956229bf7fa9705bef3e9dc98be718a25dae226f5adcd3291a89eb6fa2d5eb20ebe3f465b76759d67404d6ad5a63c089003618522442189942492b8913442c83abb65582b62844ca29cc6da18576209ea4413595f622fa18e0ad479d789123f7cd71ce5adce699468d987de72d2c8ba0eb5d36a2b10a080fb70c53759f256ab06fc77093567b9af8b2fb1e652228b3ab125759cd4e1cf35f0c39e6702bdfc688567ba11daf9b106596b413874ca1116f41704e1c5ee21227231cf054f3ef8bd5859479b1bdfa4ad363618bb22283e0c07e9dfd713b2f7f2e38b97422f435ab2b889fc910b645d6cd9de8af1a38d93b236b237d6b29ce4cf14714c3d0fa872d97fa18f2933a4b56ac41cdf5abea56464c419bd89254a27c777f0c7959892d9eb81737430d93f48f8e25b49acf14dd6705fd9f2258a459e405aace1ce38eaec441e89615e1cbb8e391127b6620a6011cf04630db684c196b2c505bb8877828aa5a8c41232b5a5101266cb07e5a8137124aa45674b9c2d1dcbc8d43b918fe324ab8d3a6f411ddf72624d5c3969be9be099c857817dc196ef31d852dac073e08ab7443fde734d605f71122ac78023b96d6c7171928432be4915d4c033791522228f4ca5464c7b4b27963c27a6fc8fa827933aaef8265192c5495dfc1627d588122587782608298410c651fc28ddf5b6af437fd027547927f259ecb8e2a44b5b21516e22dfda2c1389badfe4f5fed26aa84d4ab921f407d9c13f6a0e218450d2c07081eb527b18a0d9d6b2f8221b6088b466e84c36d553db783fb5fca771982fe7c3990f20a30f4ec2ded3cf814a0cd39ac46c0c4c8b2eb694524a29b1a774d5029add3d9d4dbfa3ef830d274d6b45221bbe3dec69c430d1a617f617bbb04bc3be591aa3d25ac4106c9e6f94e4423c8281ac7b36205108888990c8c52429489e13b2201e67ff34fe0c4b5823029c74b38f2fb50c7f0a6d434a46f2a397652424ff32491c699d1d790f7a918d752737e8af671beb9863806cd858772e36e8658ee1624687f3cd7fbac507b20e3fe8e5ceb66f8c303e8f57931be2152bdebfd1d366e07fcf947d77ffc5d1c37af4fe7afb7edbf8efe86933b68db56dcb1db3b7c2494f5be126f1455a6751689d0dd1baec84d665205a2732a175bfb56b94bd90d66dbb7b37c67d5a3e36b1bf5a57b29f0cf9d74689fc6c4b4bb503f6fb4b57ecd7b188f0798c1588237881b00a6d1f31b1a1bf120fcf838c5af778b67c3e38894c762e5e94d8f04c2edf1272e4c89123478e1c3972e4c89123478e1c3972c8d8cd1683ec35dfe7fb7c9f1b831183f29412cf7b311831c8da2132be2e8c71be188c1864ed1039638cf177d7637ce53ca5c433df39a79cd2bfdecf25fbea6dbbf62d91e034f49e36631886611886e567c29404cf943150b6d6de7b31cc7ec6f62ffd88e9f856c77d6fc6e8dfc0f07561fb18863d0893a7d3e974c2270c530dd23ad0d317651ad8630d078c7f4125376bdd7d8ad9fc165bfb3163f4c268ce395f2539d840c5b0e04faac675565437d147ba501a2d062305619b532da8d3e9a65a50a7d315ddd3e9743a9daecd39dbdc81b4bf15c3f958cb3ff1207f31e8de6be2c3230b81fe04c88789eb918540f7826e7e26ab09f14c190381b5d66237df5b035f8bd96b75dd181421962d16ff7a26cc7ec632c528962f082e86dd8c5d88ada610bbd6c678ed10f8da6c3fdfcf17831183ac1de2caf75e185f185ff85efb37e7c71604f7666c6f088a0b4548c6793edc580301f70c1c1eb8afa4832a28825dc986f123041901a5d560ca5bf9e25a8b65d9a569298f457fbe8429566addbc705ff7075d82a6265d16e1be12928fd1c6d1bf988a31c618638c31c618638c31c637009db107af2d3bf555bbfef570e44544283ee404c87f98f0f82cf4303f7ef80670d27df8391c00010a608097f4633448624cf1249f8224c6f80389be5eea14d6fed5f4b176edc28374fe90067da643efa1b337a13dfe439b7810fdf12734080a1df2228de245b4e847b4c88ff4db24fa46054e37e016604bcc44156ead538e4831023222ebe04d09de8cbebe17f14c2a78329d3a33f2cf7d66e4a3b63bcb7c66e49ffbccc8b647b40ef68c7ce733af75db26d16f637f471a6e15233f330d6c06f631fe753c9a819190b890424716d983dda95e7f807b44bf68f748c7883fa2bd4644bb483b0aed367ea39de538da5b9ee33abec3d393b5fbfcc4534c89b5bed611d3d125cb98711a38b3ab4ac6865dab3f136a78272fefe06f2f6b35126bedd7207008b20eded425586bed3b64411cabc9cae2636ac43f6c6ad7bf2fbc545f7dab965d53bb5618956f20356290c3d3218418e866f7a8e7b67a9ee48ff4912c242401a7e55bfd9c9e1db8e5bd3a2d169dc1f126ee70920d8e35eeec1a73768d38bb7e8c295b6db5b6bebbbbbbbbbbbbbbc77056d634ed354cbbd895731ffb8b75f24c7192bf8ac520d0fbb5d65a6b59d65a2b5936b6585f02866d7d09eb4b585fc2fe7c255fc28593aeb716cb34acbd9f6fc01d7aefd95c9e45b412536a767d97ffca2ecd73f28cfb59c3017728d30061ef3bbeb9bbbbbbbbbbbbbb7cec659452878a4c91a7fb23a8ccd2225a9c14a9cf3c43beff9438e09e2254709937b30ce6b403b0dfaa05371bbfc56f43b0956f8fa032d98408a364c5d633bd1958938f698b3cd116ea42537486d2d0181f5f0cbbd83bf68ebdfb5ff1ed7d7bdfe743e90ffaeb411605372bb0d4a1875afe7d3a63a91694db7ba36b30bce5d956f293bfc9bd7d4522fef8384a29a5a43262fa8fb5ebef8b328df854c301637eece4e226f56b3ada926a39bd6420c3be7bd85f2dd2cf57ab5022f307a552a9d48bfa3407dbebe7b1fddab4e599541014f77ee89aa03e8baac086be2006bb421e1beceab3835d3fe79c73ce39e79c73cef9b106c931b2ee010525eb60b2678a6f55440999e378cbb7aaabaabeca6df04eeabb761a3c94fa537b8d6ff543da691c0710a5fea5fd06efa4be93fa51bbcc3ba973de1e427c909a0ddf302cd5823a9d60522da8d309136118763a9d4ea7137602c3ef1f75889a0fd4860d4c6d36d506a6600aa6608ac2945fda836ffe57eb2e0df4b762909e1fd2a75892c0f63c3c23a8acf31cf80ef21f8fe91b58e3c8b6ac8f22d3c0de2f0fc933b0f7f72efb176306d1d202efa4fe8796423c94fa26b40fbed5f7d036ac6f1288d66659d5baebb11e7cabff9167f85f1a8eab45a890c99c20f7b64c51912f72c3f91ba72d2bbe44c4a20506b2eee5ec3a9d08cc599cc5592276ada5816dd6e13e56c34aad0648b3e19a0faf07278d9c85e3c3acac6733d16f2b5895750570e1cbaef2c5b73c909ba9144f0fe4e6cbcbfccb077213c667cf13e4a66ac64c191995588ad66699481457203767e6d3562c511a1ad1cb2dc2be9337789c6c99be7b4c9879a61a68f03899f3e2bba784920c1e277548dfbd23c43c130d483c4eeeb8f8ee1141f54c2d38c93380ef5e10743cd30c463c4ef6b0f8eef900e6995056f038e92380ef5e122fcf7452c4e3e4cf8aefde0e52cf24c3091e374f01f8ae002ecf644282c7cd94ed3baee5996220e27153a5c4f24c300cf1b8b952f25d0bd433bdd081c74d5487b2f24c211a78dc64d1dfc9a0f24c272ef0b8d9d2c590f24c203f9f0af1b8e9a2e2bb17e8e9993eb2f0b89972e13b153fcf64e20a8f9b2f29be1bf93c9387151e376148be43d1f34cd9128f9b3a46df7df03c53e8e7cf293c6eaa20ca1cf92ec4cd989d6702897c77a1f0b8299345dfd567c2729ed084c7cd19885245bb6addcba13836fcb441eb5e13767dec2d4d2cf5e026f5776c4ff67e7020078127ecfa36e0ecf99ce6a105b9073061d737699dcfaf413b2007720d50c2aeff2267cf2f6906e8406e01f5495ae7f369d00ad8815c02eabbd05a6804f0406e87fa03d03a9f411fa007723a3c945a9f45cf9e8fa273f0815c8c24767d01489f3dff441b40fe406eef60d75fa1cd9741c33841ee8602ecfa01d03a37d136a440ae066ed7df52f6fc18f40b15c8d1501f002a7b3e0cdac50ae4667828f55becfa251a0b547d945d5f43ad7827f54fe8ade44d681216c899b4400e06970ab9140fa5be0cbbbe668961d7ff9617767d155ae7b3be0b9a28d320219dbd404ee4a154c89d7828d54305b9fc50ea8f76fd142f28767d12988f5d7fa4d51f51d593fa59db7752ebcf18c85d3273e6eefa2231f5459a8c565168330fc37085e1919b16f1b82016b351f65bc1d0ec4bf18b23d85e6facb711adba177206db6b9148e62151cf2404afe45578e185d1e8e3e35ecbf28d85b55d29df42055927519466d33c135e7112a814338f17d194ec67fef32c13898cb8d9dbbecfdfbb4f75d023e82996246a0399add842531d858929cb7293995b2ccb627d7c95a8fa92f51153f3552ccae78ef9dbe6343431650412190d74303f6a6843134bf0c6797e747a7e479493e1ec39e18e3d79b0e7f3dcf922c8eead5919f1b24bf65b1971ba2fefcbfb52de133824eb703d404f73ea8a6f93b62ece31a4ce54e2995af04a16269aa8e0790a72970a44996f693c073e030ba372efdf0ea676b897d218a94ea4b4e5a41c2fdda0cd16dda13df4a7a6d4f97424bfcadf76943144ff80e9d7131f9a89585fc26df1d356ce33ecd71decd78f35b20702ee90f54b0572d0c2c0ec59e7aeaf22337eecb38c43085fd7f557f762bf6ec5b379bff932fa11da106b10d6196bacba5863585f585baceb0f65cd188975dc36b0f6921598858b907ee1008f34b164c3f4f937648488ecedf8309e89eef9316a29832c13a6bc9fd773fdc0a3087b2ee1b17a5235ecb35882a9ecfa9bed395b29906bd614f37acb72d27c8b335b518b528b2186ddcd2c03057e5986d7aeca90395b6a5dc9ae364a76b6a90e499777827d68530df2016daaf34dde546315de54dfb84235a6836daaaf9a6b536d3d6537d5f587b266ccdc544b88a2dab78d77823d0ccf216e8a03f6353bbe49964d56911ce38db064f005ff7c68c43325b18347aa70aa30614f799a47d8f3dfb333087bfac6befe28cfa88f550cbbae7dc9e2db94332dba932c96154da674812bdf58b1345b6e32df6658ebb2a9752f2debb5973694675cf80257231969e08e1d4f620fca31300dae5e7c9b16be94f6cf973330be933105f84eea20c077f2e586efa4cb9e6f59b1b4b5d9ea36185a01341101b2efb21b587b3e9d2ddf72b4908deeb7e086977a741fbfbcf407fa3724b0f30d1a4cb9c97c9b65a290d689b4d9927f7f66fdde89d46ec55827a90642ea60e24668ffb0cd0904b163075323ecbb2dcb1861bf6dfa1dd5e06a6fb883fec89bd749f257f4be87fc4c622f258c6abf8d7f147756becd1779e27c28fed3037b6e4e65f866f14e5460b7d029368378e1f0889993cf2c717777a7313dfefc085bee5087c72747d66554850453321a512b98144c9155c394c741211eca33410bbc13f976530d9e9e87d78af621caa7bb94bef5e0836f126e07819ef1e01b886f0ad8a6f6a487c8371bbef9e01b7c3f5d480c31044b840157e618549374421b6c85881210410411449480881298c0042c7267cf7f36205cf16dfe8353c537ece183ee12d405b1f1cb36cf9cb01f8ce701a24ced2a8ff11b56dd7762eb624ab756e47a870dc5448690bd55842bfa77621804f883f732d8838732a10fa6a754dbbf28cbac8d3146197d525778a590ecefdb0fc9a80ff5a13ed7f5f42f7a514a69584d6af729a531c6fa91bea4d4047495ab54f7a32b515b58a6519f5e945e1f9727972a2e512e5b3c27c7ca6333d1cf1f41b5d840d679ca53d666d94a141faeb22c6eb87a2733ee9b71a8617d9b1704b764582a1b98550b0b7833865906d56ad4446d441de7ae5ce594520a5958bc58e9b7e14a4afa71cf8f34aad8830a696a56d155afd2a8862c52c7902fafdfec395de5317827f31d8987321fc67c1b55cca2c661f7e532674e44c595a8e23bce03e4bc090f653e4dcbbbe7041934cf54f7bc353b321092dd459a929d52c8d7ab46b8eae02afeeae9fb9969a86456281664f12dd330d98eb34d641ceca69ab7dec9db1df48935ab6879b2e8e3ae0261e1373bf6bc28b20e26db71a4fc2cd6bc93d9d5a7726a57c5c8c0d53bd9a1e9f6c13b990f7bf04ad0266699bd70bec45535e803015ba864354e8adae87e75d2e86afe83f418dfe693a8e62a1fdc643e5c7939ff7256175cf1a8543ab6fb71efd3be475059075742205d4883be5cedb0a12fe587de9ff04c38b2263c2ebe89fad355b1e539aae9322dab9f933c538968acfdf88fd791c6b7d0b750c9425a8dfb40c00df2303c86de036474227e689a0954041ecafc4cdbf0e19dcc0f6929ecf9ae9a0f59dc649e543e2a17fb92e910c5cc403ae5831384b5910e72df9714987f6932e293290328715f89c758dfe326f12947232222142127403e4c78642150c617bbaa8df17bf039e56844448422e404c887098f2c04caf86257b594d21fe4a7f84b12a5bb7b75af5bbabb47f788ada65fb50b98befe6accb58a9127b95181d30db8856d6d0683475ac593b8e030aea3e799463fdfadf04cff73ce993de7ac799bd5a4d03a5f917c076b5268ddb6ed93fcc5f20c6b6d8a142adc25468779a6fa03dc9dc33c9942db983d4690fc14da6e120d77d4be471aeed0d006de409686211ab63404d15007ee401ed8037de08f9f3cc555b4af38ca595c6b777193f956fb8b066be08a0459a44f5289bb3381a93cb88bf674933d4f60dea156999f74983de73b12d55536d3a8ef0ee324af7946ad55832ab3be7f755a2b8d281417184108461082d0939ac8e383601d64d86305ae8810b22066eb9d4022320853f06555239ac9626cb01fa85657a8ce25a59452c6c8623eab66a0455bf409af545971e3c0570b88b0c0a25560edf91d95c2a62dd228ea38e94af16d3e06535a8c3472fb1789b2ac566b5d6a1d4551296bad15028f93f2a211c706ae65aa21e745498744c38e8b163c0398a187058a8f004ee4cf0a194e013049d9625001000c2f7cc89f781014196278210b1f6fe23d3e533142f121d2117a1514b2cce8d62c04aa32f9aa3796958540a02a93abcc5565aa4cbd41d1160a8542e19d293c130d7dc94e18b32754c133bd8745cc67e27e521a82a120189a61284c86911207a2ccb736c399dbbf489465b55a9b6198b679c9b2583c1bfa2e956832af8b0510e572c1e582f72cccc502c85d471cc10298d222d4b44ef4555e2ad5151373c9c85c3417cdb55a5d3b765c3636d7cdcdc5625d2d8832af96090c8fbb7474ae1d883277782e9eabe7eaf1b97cae9f5328e5aaac60a76bce1588326bad95d63a677d08541e9e89fbfa0f789c6c39e0996af8fa0d78b5f4f517f038a9a38067a2e1eb27e071720701cfd4e2ebeff038c9f38230c3d7d7e171b227876742f9fa311e277d0cf04c275f7f3f4efec0782619b879ea0a60f2f56b78dc4c79f14c317c7d1a1e37555c3c130c5f7f0616cff4c2d793c74d543579dc64a9b5a5eac74d9715cf14f2f5b7673af1f523c5e366aa8a3c6ebed4138f9b30d5e3715307c93399f85a1fe499b2d0d7fcb8a9aad7e3664cad3215d6c7cf04fafaf699f257ec338d2aeb7df957d65a559093ad962a06723227274606725247eac8cc404eeeccd0404ef2f4f4d4ac20277d7c563b20277f7e76d8406e9e4e3637909b2929372cc84d1515d69e2b2b382dc84dd46461c9d181dc6c69d1d981dc7471d9099790a8a48c777549f018cd4800080200531500003014080444a2f168248a9371cc0e14000d7ea254684c9c09c5510ee320658c410400008000000000101010192a5000903cccf663acdf6fb3dac45692dfb8f10be5d547cfccbdd25f26f4af3eb8dd6da58b587d844546fe6bdb9425fcf99d17e27ecff8e75b42edc52ac304b97549af63e1e746f86efa7e0d78bfc3adac1bbb6ef470372de9d32c3a82f58dad44fa5755e41a36feaee66f12a2e87b1f2b0e4472bdcad3247582aae8ff4a87e812ecc139f10c9b1e8802e28ace62c77d467f58c71810487129ef6eef504274f862a868634bd590001995e6dcae3d80b8f7973ca7a201f92d09fa60232fcfd2f169cd3cec5edaf92a964935f72c42e0844ca7a65de00f4d8235a4fca19cfe965ba7bc2b6df0e071eea2f7dc0541e70c5f471f972a43dc8a65a3b8677223a56c740831a0287dd0be43c0093ac52e1c3d01fc081b11229cad40112442941d806c1d466e1cdbc56e78b90937319226d43d3b5a7b30355fe314332ec371507c341d12d21a7ad5a972ce9e2d01b91755090ed3d8c73f062f160efd0f1f16b753022a2a6716e2ceec91c678c7e578c9da2314511ae485ab74b0b1b98cf2c8c4b790ecd399a30abebf84f71f25f0519f81f404ca80bc296534e8c58f7b9002d6948fb44808b771f0863e20aad0f0239d69a89a66e6e6f3faeb1cbe993c19e2f0b0ecb004dc0cd00f9c5a9bbd9c224bed70d463d22b010548c0135cd0d7a2498dac575678e9c6fa8d13fbecefbedf2b612ca49dd59d3e1dac7bc1b852edaacd565cc6eefe519224d53e02a1178248be8ff9aa2bca9b48b1ac9a3c44f4dc154eb2a352d4b6bb0ecfd45f488230fefb47f0e51a0fb373271ef042822804366835097883a5ba69998276c74f811fcf5929d016ed8f6568b047b7106efccf9863719dc3f43ca7e41cf8b9af7ade21c03ee46738cd273982bc2f66f3f1c63b5bcbebe98a4166f1fec754ffa9c8cd34cb8ee5b2128346140cd211b8b141826dc891107162687e3ca79a9952abb12a82cec6a7e22657784f48dbeb2f76d4b7894c54d1401e0dc4de31fdc03efbd74d7a9cd8a11abd7b4a4d69d97425077c5391bff5e1de00243bf4f05e2231986f59b705c9f9da294bb5287e0b303e2b3fa3c504b615b220b61f8dbc74519af254b0b0302b59c5cf9802f5810a4c209af2e935c3524d6976ba75d0dcfa2189bc6f6f88219417f8cb83595425f2bb0536aef10b48bc653cd4d03e30cc4fa5169136678402896dc4ab370856c63211d7b15374c0d2dde966242dc1ba2ab117aa661ee010af9f76f1d7bb2e7fe729780dc645fdb943b57c78fe6624ce8d23104b298fccbdd7da246a6e5328b154a1e026ebb106e56d017901ef8213bedac16b471f980af1794060251fb5038916335250c42fc865abc191083b78442cc908b3bf03cb08bb91a2c4f4a622cfdd96fee1a606a3385e30a18ea9152063d75c74e42b4a24b6d043920cd81e011b370ee0ec858247896331804ba2d4bc368b45f18b54c7c6e6e318cf157b1f21e3cbc36bccae80a0bc5c179632b05cd803c7a6d82ec226cd4ce3dfde0193c9192308a06217eb58237bda9d9f907407f84949f3d93f3c2556d8efba3405b4dc0e033e1385590f662483ef2f207f318045c4d84876d986b668ca466fa4e0dcf0b2170862c7871986318602fbff8b1a0b1d9432b487d4c7a94045affc976b506d77f811c51bbc0d7f7f1bd7c64e243a82bcaf73136b339020d9e9b2e68c9127c7949a72ad11a2e1250da3f13c28eb8f78e7011cef034a1cc3ebb4aa41e274ce0351f968516cf306e12a78540610a9d16fa7c33320c5c074e55da77dc2abe95ef4c0014ea23d91fc161ccae69f4da0b3cc6e2b15c14c55f9a227e578242696b64c3cf34e61580a5ae9ce91c4add5d77095421f4d226b41ab0eaafde9b5fea072d48259799756489c087775d4fde67dacf3aa58d81f70545f1a0e727f2c51373e8f1cc9e769cdc1fdba95145beb8811a51c969cc323f90770bccb07529bb0f11dc4eb26b3310f5795acc17d491cdc9fcba0026737e02e370162c55040ea1f527891e671c206d9036ee0e5ca8782c1426551287f15c2076c16558e028892c294f64812cded0cfdf9268b1aa149bb2be4075538432aeab311c5ed7b68ce8f6c9f145ca0f837f5b11a50e361cffb993cbea37d37eb3e9cfe114654a84ccc32ae2b2436010fe7568f2648e2d3e5a535d1fed074032a2c0e937fbbdd02b75426754395eec13f8edc8ecf6b33fa4a16a113a6ac96a4877484dc68fe4285fce7b0bd78fa3b7f59f174adad0786b626393d67aeae8a2caa92feccd939eae4699c75c82dafcdf880316318bb34a22ba29b43cdc0993d56eac766ab464ab51e2f3f7c80716d5a4ff8254e8b365667ac03c049efa4ba99311776df5006d50db26a622c498f9f3d7698507843b0b1163f53ca4c66b0b661e194abd7580f91788cf1f201c0b10abf029b12eef1caaad096189c68d92e33edb7d5f47136d296cea431393c13c3e235c6e38a4719dabed70a6dcdf39b8ccf71718211d2319774a4a10f276fc5c44696b1fd563abc7bea06d0ba7b83cb908ac8002f4a73ec913a2ac42ba04aa9996905067db4e8ceac8006e4fcb174b844fb49c36d07515367fcd7e6b968f81d06e43f93c89e5d0c189c004bf0fc44e9c741de0e68cc49483d8624d45b80152149e45dea93d02a25be0b5c726bc57b57604f8229c7df14107f8ae8434c6212b2cf9e7f2bed1ef7ba536fb6cc0ede95daebcfe5c7dc0f9ae3a35a0b9a338c84d52c6b185407b679841286826faf1220e36fd99c3ec708501d5f63a07e87baea2d99f673fd1ea133532cef8a383a71d80b40fec8bcbeb263b51aae96a8ccf922f8c6c676f0b5a829c663140dbde29ececc7b1906dfc50278fb6b883be77790c4baeaad9e4c962867132377148ff9c6ea2fac021eb2c0b14a6221e442a7f0a6d5c8a5f48ed78212d9b772eab55c74a297a0467b37f595c30c5c015240e95915da315121c6da77a6812b76ed484a9cfbad5e3ea4d5893cd7dd65c611aacf0c8500dd4ea7ac2e946c654d1917e3efb9bef639694747857e19a24747f42878424773299ce857b92ae7113545e2de275df76d6dcc55fb6fad50b88d4847e944ab43ecaf5eb649f015fa2f27830270815f8933c213133993f5146c8f960f4b11dc6857ec6075f1c5b045c11aa7b1c5e9281587454052012b42e321fea472cb6142585fbeceff028cc2111d73ac22c4d8f05242a90829b116b222181e9240f32f45247160c999d1fe22a3700758348cc09c164fc4c752b1fcf9edb2adb3d2e908f7b632f1830c2c6e1ec6b0b35c42cb869f7bdfc88884f2cb0f85433a9c2738301f28509a42488e0ee275f248798c2596631f16c13820439eae47f057b0088dbd64c69ad12e5e0c4d75e761a564491698ce0927833d0d7bd9fe5ece4d782d885c954c82fe2b606ee6a481381021693b84044d8a2b57c1503c06c49e779f187318641d120b6cbb5cb7a551252017e97b91a03aa881d85dc4097c356cb945dc8fb011e8f9a4a8c7913aca73fa0cd5203d9e644a6be075b8da18ee81cd6b147dcd887c7d8863f3e5167d78770499acc0d67e86cc166744ba3e4553f070aad18e84699a11e5e7b50ec6039a83941312cc8956044da123510ddf10f1345ce9dfcf77c4b9a9ca9b7173e6854d07bd3e8f9ea226915090c3233639b2431a1d2b2a9237b08d226d959248408c80b637fd8f983840f30961395c802aae7e3a732f125247ba93d096d737adbbd6ca8a42ae4fc58a84ce0385c9524b440011d8b7b4030d6954fc7ce9766240436211e26acd605caabfd5ca6a81ed7decfbefb1efd164ecaad3aafc6372969dcc41c0b5540569ef0bea4fc64930cdab82dccc1fc6211997bbe6a7ab6c4a84189e6a958b36cda49be756a6b0ec050a9954eaf9df3654f658debcf1a48376f521f051345f2736bfa57aa72b047e1cf58c9775877b0fe69fa2040caecd9c809dfdc28beb6ee5c798528b0b824f4ac0ace3226f6cf8f8a328ac84bfcc9870855ad58112fc8e2ecc1f87b31284989ecb66469abb780f39e21d2798a751d5fbc0c00a64575e091e360178797322e462f44634f512dbeba114ea93d1030478bf77707df65771defb2f0a6fddd9e9684212936c19c9aeacc4635d605d8dbd6f71a2a3304b636914cc8e464bca13407daeb7d7da5a2770b32262c32c5ed5ecd15836f2c92be28a4e37368064cbdcc7e79df58d6e71d6ac3a6d243d63f4ee0864f0e37bf8c9f664a1ad863a2d6deb8aebe2d12c30316c772cfa616b34ec9d49284cf7d0c89e822b714fc35ac2b6bb9aae76b6850920d36d017cf6bcf682c0c88b4c01f12aafcc4343d2e1943caf348f92351c5cea0bc9ea463eb93cfde9d4a31129ff5d9f994e1cc0edda573711ce9d58bcaec6cf0931965d0fa31b31d9eecc4d5748530fe216a69316562eb8da0dfe79890f1bddb116f2e8e6e6098feffad3b9bc91a4979fb9eafa7a22f0bd6bfdcee58d04bdec5faa8bd71381ef5debaf9737e2cc9d61312540fcd0bf80d79b07d8cac1098203346499ad2d2e3a44916de5500220aab7f6afa059815e4b081bc5f2bfefedd6dd21671f929f777a12fe303038b7824a448f81087ba0afebc27cc7df6d87d5ed2f02061ebf064b934251dfb061e11b2158df54c2a1fa4daef5cfff0ab85150e98d126109eacbbbf0f8f3f3ec70befec38681bda8c139a5f0f41b16257c9a57d6a78a70a87ed30183fb5f719228584dec1a03875f83e70dc1a24628687a28457eb3ef853a5e286697fbc65cbea37184f97d75b124cff72892b06540c84dc1df6ffa1134b6fd65d63ac3465b61788c2141820bc882440bb94f33ff09344c8fce47c39807b710db8e2abc4837269a51d4dbcdc21e34b9225db2c8103902b4ba69f1c5d47e2159ac10aec51722b69e64d9a7ecb75dd00e0223a34bcb797511cd864226343a901b6b26cb8ec8f9b750aaf2b9454ec68220c88b45216b412a7812813722591b662a7beaa945db1ccd9fea9e11c161c7bf1242c5de8844784b48eaf68a47f91b14325634aa05793d290e66ef16dcd183222da69bb34a91d67de11491664529ef1cf783ac6c9e341af967e1ae70859398b4788cc894d149c77f0a37a0c753006af7d5901c2622ef9940e0b3a7454fb6dc5dcd09286378109a6c482f24aa02745703b400eccd0a5314a4f450462fa9b1b90759de902f035c2c9e9c45f16d18006d60627b625f9aac0dd9f95928f76032742525c6a41463011f2e5a4125461dd7e11f3ea83f2d79ae5fd26e78c10b479e93c8396aeb67c37cf80f967a1fb1ba6bb94c8ee0e03d54e3d408f6efa6e5f2445d51fc56b772ee1820354dd5130b9eb5c9fac93fc147beaca5b731007970fdc68f41fdfda4b7739e4a38c3fba3e1c2b8d6a9674637b8e26a39f206b1a65c3337b864a34e11cea4095f6958bf3f7bb577696819eb863c4db9836e70eb6a69f2065126b9636e70c7695df70da2f989d2727b13e3f5ae1b16b404792d59404409b126c419e4a0041eb88e1c949c79e0d00a81d960e1faeb057353163000d325ce10b9e7910b65adbb593bf50673168c8a2c798c9a2059f90f10c97e256301d2fe90b28994d01b43840844704bdb1be837b563a1a1823298bf78c75077a8e04730e9a0ba945b24ed79d8a18cb80bb41c0d4527808e0edf67fe459d886046e0cac9af54d40f592051dbffe917de9d0caa9c0714f6029e0655c506b7194ba43ecd5c96722e282c3c3d0d5ac5f9a0d30b7b4aa62239a1fd874fb6d7b98c7ea6c551a877f02797a145a2cfd06e787e327ff2d9a1d0cb9fa69f81f9363310c57700ed4bfb64d850653cddefefa95ed80900cf4a5e5474cd177dd202ca34a84cde7bb3ecd022479e2e9258ca52afe1a837ee0f2ec8fa10aa4a8876fc175e2a922ce81f33a14a497b8aa35364254254dbcde6bdd0d16553b01e9e512d7249f862b1ec4d4b07931e79f003ee2a5a6f10db709abe2564995bdec25915941879efa800749eba866609dbe67496b0ed342f8af54fa172666f537124a264f2e7504b22bb68827e61dad0e1a9f092c4299bc7013c4a1700713a040c32cbe529bc3e4677fabcdb2120c840b9d9c225437f686a3b445fd5219daa0ce1553d24ef380f4443eb72b659521feab3a16e9682a6e3af595d82f5f04347cb588435b6701e50b47b1ae70547f78dc2275ad78eaf8c818a565d9d1763a61f7f8d356ea31e01efc15561d4f447215b6e07f13952258706a83c9c91aa0e0a4ce8d1f46d5d4df8c60720306b4b34194fc69f75a7ca60d967490b8068f9dcb49423bb9a611de5c387fb6dd5b289af8e6c2ff6ba7b1d666bef2e6c000843bc5f7e96f22664262705dff3dd6e7c8f8d71b62f3efe78cdc0f58f218f418f5d68956cf8c853c422fddc28de17dbfc0a31fdef7cde60284fbff2ea98a0803fb4731f60540cf7ed4f90c59980b9900f4060eee8b8becaa932330b7bd9af919d65c5b6fe83e20c7a72d1617b1f13003befc209970e6c0974b79262a616e04994de77d8401be89812b27d23fb6b0e42bfbab03c2eb50cd108033f6397d8a477060bf961525549a31b20633466bfa9e23573aa5e944ec6f69dd9c3bfc89c2910feca556d52013a612eef026adfb9939dd2f4af3e44f846a81d81035d95b639edc85349307d661748952af957d8f3e46dd366c21c839c4d054492b0a373c69e3ec6899e5e769172d72ad03cd4f8f7d8873822d80ee85d4b204d99add669815131cb799f6afa84f8821c3f27747c466a907f2027b39b9ae81c4bb285185af3f562fb38f19949eabda389bb16c1f1625c684e03a08e7c25b8e384e0f7be0b5446e096d51b1595f9b9590510ae355873f6b10697c6bf031de235518af1c0106cf998109e04796f7e5717755179befcc10ea77fdc283384d83fb097087c20d41a6b4eb5e489aea5b9e25a9b91a3d1827afb0f152c29cedaf35c93375d93f4a0fae4021908c4c3c27c79670ce9e396cdf77a207c00365f932bec17ccd277634f51705ed70eaa40e1457d2112e9eb489cf38e00ba82ee02208ab54a9437c873b4ef460cd457ed19cd9208a62e77b4ab4fd8a20fe990f870984b45ea66cf67264fc5eabda077ad2177078df556bcf65f00d36e12ab502dea86976bab58f1f038aebd6513dc1d2034bbba0eca4436bfa517fb60afcff3cd49b6cdb9d5c94b0d7869b80ec53c508f355e12057a00ae8ab10f91020c4dc1b75bffd950abe2932c44cf257be0a97cd1083c1ffbe94b96cf19675d71a46fb0c84851e31ceeb2b75c628ece6409010690dff53a2e4d6d3e9f34bfb49903ad73aebaee1e45201d94eaa79510b1faeb386cb98463998ab2a646f85c4f60ef54d97d9ee0d36af2b59e37ed460e70683439a96073bc566db9632a8d303722c1937783d4d618f4b966bb7a245bfba27963a2328d402d15113914a1db7145220222531d222cb5ba45ae4eab67f132fe412599ed8379094211df21d80086538b846003ee0c622c4ecd3bd26ceb6c4b2d810d8092d49de10a2a117993f736dfbcbe478d93baef7026ae97551d14ec29337f6182097a11429d9d93e84702bd903503a665af9bea396727de421e89cdf5589052cf08e3be51fd859b32634b360407dbae9cec4f72c47a8e648fac232e1487ecb5876de1f32ebb9003e1729df48300ca89cf31eecbf0840abb1d6862230ca2347a7307389fe6e8d8d88671301ff55b800fae55cfb84a565af513ad4ad950356e426c3bab94b698a51561f3004d29843bb5192aee10328fc7e531fbeb96d978a4959b0891116ec34aa69403e3af0ed717ee810629f0bf4318be011f41d8df365821937a28c490e6063be0f883d5ca8cc1e6e6c6e56c0e1072b07848a932373f3bded14e4dfed3be5e2b425fc56efff9972e848be6c4ec3b5ea8e0e6ad7a7183c8d3ecc8517c791bc90dbab8674fd8746fc71404925fd44e57c147fa1fdc3873575fc707b3b481bdd547e24ff7d764955a94b545880e08178772aebc7779b70b8abd28ddc0a17b27fc2137c797f35eb825b0fa1462aca2362235f2e6b7297186f66fb7dd6ccd3450fccad301815bfd06ca7f608cc7503e2b0300c24477cfc86ac39a76ce98f5aad688b3d7d6e0b331a37fa1f6dfad990db0450df6d299691d0a41b15ab74df2bcc3def997034c580906799414796c67e48c00ff4a5f0168f375b0f00928046b3a2ef374cff4306ecc2ae756e70c57df1aa690278e600d632b6759395ecc8a99155dd7843171d375634a07b26b7933ac49a0aa8c463d7275b14c8c42817a87ba2a976f5ee15dbe331537ba101503c1f1140d499371b5c6844b019b2b49310c3c47d1b6cfa2481cd7dc04777332813837a7ee1bfb8ddfd413981586143efac09913aa0e5d1212af526c1f8ba2ee62d37a84787aeb827b641e7815c2f21e660c0fe62f90341a0f6d7e3262dd2ba23e37bcf1f5636063d59939e9452137a5a68a68879f7aa6b606e59405ee41884e14a5424d52e8670db87df1de66f93d0ef67e5e176a59cefc5e2453bd2793388626e770e80342d44016bf4bed94df88f378c4f626880b55a303829e23e053efeb256dbd5cb2b06021bd679e8efafda6a35d2d288fed8c5a6506c1de9df609bcca306774840c9c013279cc3cebac36ed6fe63a0d0a431e964908f72403e32ee4a5eb1ad441786d7b0b185c059397fca8ac31c65dfd1202ed985ed06e9f52c36c03fc0d0b930ab1a854f0f54c02e933676539d1442ed8b3ba2cb42759fc0bf01fcc8a09b1dd9685837bfc42347331f1f1906de4ed60b1fe62e28a130c9088b84e609360c019210b3ac34c76c3329ec638dce51ec949bfa86671a64e93b0b4208ad34e499d7b076dfd7622f7650cd4176396992455a77affd6f551085a6c65adcac8d6aa93b0a52aea1c839620f294735b7bd52374b3574b7ad570872a92fd0e47a93141c8a5ee76a04c74bf3b694ea3a55db9054595569a6d00718aedc4cd882617c5a0551abb49c045aedd521714b291d34dea9d58ab0a003c379b62813b6a63fd89164f8da50ead4c0dd239d3f4e17f51147e195fad68b909bf9789cfaf7645c26ac775865db64875eb4acf353d552bb3aa65720af1917b74d6a24f198814709ae085661da0c617044beacffc210b4e530e55bd8772c0cfa02da7decf0cf4a78e80d1376f8ad68f24bd922a95836009d41cce3e80d6a3ae88dba1559beb6d3ddf53feec23017a2745ae8626a8826d3b0a34f8c808c791fea295e5d78c5f19c7056c07436566351d35eab9ec1e30fefcc73c887a4fd2ef54e510b6edb703342734ca8370ba88fab60547410bf67d0ec437db49027c1c43aaf12cc4d3173edc37df749a567a0f06da2d38ec5ca463330e2cbcf6005a5cd6bba3d632074700e2c18c7bed34e1d11a114f70b1a19c539b407a7fb68a89718bd81e0d45c601f5699b8cb978750a81dc855138200ab0fdc637494c07ebf7e9b9b2b48826a804e3ca5257843ad166e01e63305c07ec8114dc7f9aedc521496a8c7cd0b75e696a547b4d375cf33b2f568554b1fd69a575cfc62c0cf1f0b5dd3ac98037af453ce34ad3d7a02bda9433250c865d8c0c947e131e949d106bf140025e7321a9a3f3704e917914bc1d5a5465eac32ed46cdbbfb4bf395f30b52a75c339876dc9c7ca3c82ab99c07ad036d7c9a056c13df266c78088bb605d6e0f7aaa387814a930549b0cbf17c1cc6098bc428044b605a1c6184332d2da0b9081f00f6ddc0ca42dc8609019532f26937613c67626f1334142fac6cebc0a84da15c45c05727bc32455119f76f9b1df52ea0732433f9ffd33606b369d9ec06b1f80b9f834343c150892db140c9f224aa058c63d69327c02d1f52c29e813fef4c177d1e0bbd7d3ac965d050d4bacc50708fa1150401fc099a33e802b2101c7e71a1a9004e026461882731db7d707c0b57fe48a579f45361c6237b2a2bdaba750c2ce19df72f51652736d295ec5a1073fae8f37b2864f9e17e543e8864caf44d82210930b2da9388da8d6b0aacc329588c7c543a41c2b68e6d7b3f4f056c8dcc2bdd960148e379296d811fafad380a9fdda0d1f9a646e281fa132048d999619e7aa9862be59acd7dae0608e8ce6592138679d0132de0b67758044a64b2c8edf96ddb672bdd4740bd553c2371e70a9b5aedf84a22935d6da5f1fa191dee042b7bbe13b96b22c9888c9c61465361474beee6e712716b216ec3e26a761c622a1238328c6e7e97dbf920f8444cfecaeddaa11d1fca793c4c4b04da434197763c44e3160517c8d1a0cfab563afc402bb4c6dae4c8ddf155e15e058ccfaf6f2a06ab201e6e7c6c88985a2d3c835af00900e5d124ad89b2a57fd6aff7992e33c49438a31b1b0cc65c3c09fccb0d6a47993d8a5b37a972d90dd7dd9e0e0cdfea9d00e3c450b925399aa99ad8ddd40d462aaee4a8d28d3991e3625c68ce8c5cbccdd535d8e03d648121c6147ed2ac32c8a65c49af2150c70ded23194d1c87a9e0974e67ef59e2379c4b48884af77387ab5a4cfb5bfbb9600d01aa41f77f2737cf537703688acdfcb162a50214c56d3ec98296496f251563237dadd9437192256b22d4abcbaf2bbd22b7ce5b77efa92a0177063f36ddff8df2ebc7cda22f8bbf01446f13479b7aa92deea1e967848d13341b36ed4702974b591be2df4f23406fb2fe7d460f4c856187e0e667c72cb0affdce0aa93d344da2590b928db8e4c472d5fb8f98ed2abcc34c1cde7784b3342708cdf56ca76fda97b76cdf3a001c2f1da6fcd068001df005f507084e2781a93da40cdee527a22401a3873cd733e7ecb1ab5bfbcfbe043f18d1fde22850417530469a0ef7a186489e43a66640a0f6431809f6e7edfc119249bf8267da4846f341f0c7ab2cdd3c25ba79406402cfbeae88c931a2d556dbf25174e60d8c194c921ee84a65b03323e1124cacb345650f90d84938cab0cf2e316a129dfe06b714c8032715e3d894327749727bd33e1a7d2abbf0da126a1d607df8d68c1804ce2e87b07e376b3a1ce127dbef3ef1541eb5c8915dc860cc1fd92851b4f977bde1b89b9f16e60c5036de5ee1c6594e133c9c617cb2e8cde6bec84d2bbae99f8d1cffb6ed23aa5360a55915b7cbcd92fe109dc7864ec936f959c947e6d48778368a3ca6fa4d33933574042247a24f1d9f344eb9f084470a03d3bdc37eafffe0fb9acb6c89c44d895db36db06d084c7ffdca00800c18d657cadaf0a1efd38a0a93b5b9ae6b48bd0d263d93085fcd70f8b6033456a1f6ba5c43f8a4e12b9ab1588657396978da12198353b5513b2c4321dfb5629297b266263f2213c4a8ff661704cfed864b390404b3ff71afc8e48a1386457c09e075348bda3f0d68795b04a3ee059039cd6d424f1765484c5ac7101b869c31a55f92fe2934c92c04acd871629cce923ba4f2a05b0d7198608d618486742403e9e5e32e614ffb4a6821c9db3f60c8c660009d3e63bbb4193c383ee1e7f84a33770241368edb9bb838c718441305621289b9eb7103dda8c0e58a3ecb708a8b85d0d6a663aab991a555b7a004722b5f4b3223e9f03e7161b8eb1b08183329cf77e34498b44b687c77b0dedf90bc53dcc9873f970434bef8fed352d3ce515fac8cb7aec7796e48aaf511faf575a624e9f041b8acd6ea3ba77791f1ab23c84f92195f327a279c078fbb06b80af8455575841b752978580434d9b13b1b2f1e0bcd1c2422f514100b5d0ea77541101adfa525bf13034433fca29ea13d739e29eb44855191e3c694c3f936f3cd1335061132e9e88aae15dc19bb19489a24f8856cc2e117e984be5ec71993f9551624f4e23f8a3752cdf1243a21ba42ad3ea8db7445532619b54d2f9e904ac0ed9eb782f99f19b4e71d0bc2b8f140a8a145cb9987b204854ef97e0a113a2f9d1b1e43d48baa40126ce21e7a6a49c154cf7988f236506c90b32e5e429b105ba7db17fb2cce714212a01428de9590564f70dd1c104c11da9c0116eae90dc0ca575a8a0699011c456c97375ccb09409dc6e78a9a378b757bc03eb3d050c3b33f37b43a512991753531b9db5a14f6729088e26c53771bd9205ad9525bede8f52039b138a3fb14fa8660d4eddad035defac1a52568c029c939968cf5935cb8eb04e6b38f36729110f71afc5581e8b287d237edffb23ae97c6b5a3dafed6c66e70c28ad82ca4df843808b98b838760d41584379762e743c0d1b41ec55534ad9bedbab8bebca7a919de1c4deac76bb835f71af4c3354e152c84dc307e0871a2d57e24d0137b6f0fea967c4b9c3f98bbae1ff3b6471a3626773859c90e9deb1cf0edb9a5abceb5855820ae9722708e0628393626b65fc4334f3210c643c4f9973769358c81798b0c9c32d3581770e38cfc6e68cddb8d19370b3386489a560eb9555d782d0e7e8ac59bb5a7979159dc66c4ed3537830ea8486b1df5bd84d13b898299884edf7091068d88cad35469b5911298a6374bacd63aba2a604c228aec727f232f08870fb35ea056109b8f11b0e8b3422a6a74ce9697732df5e214d9c35a93d1aa5216649bd2d8f7ea459b01fc17144d03a856cb8226cdbbb6cdac1a79aac18c3937059a11a5010a9c27f6acb0b4f3ae4f8a8808201adcea4791d20b24915c9d816fc1b95a8513717d0eff879b98371281944f958d7af2778525cc12af794479a6b10678f893ec0b4f5a4707a7a16617699389baf2a6470291ba901cf3591863fb9c39348fe235f413609fe96990c19bc93a132935c7db1dad51c4cc1e758177bd0772f5045e21523703974cd914b49069a7e7f4b2f0ab4067c0fe04148a80d7932f2144db63e1de4b321c06bec765bab14c716c20a0105a3924fcf66cabfb24e2a0f1d5a40b17165173d39fdb60c94422e412d2ded1368b10239b52e1429118ad9b8a783c9c900daa59884bd07502c799186dde64a9135408902b51fcc3b9a41c180d04a4413bb2c2bfd4b2d13bac1d7a64e4f474227e547d249e3aa7d734b8e81c1aba70352c151d8f208a268b10786413ef7cd9bbb67b799ae3ad85124a21af2944b95a28d585a2484ae30240b31a45450faef05d7b268c59c93a07e349fc720dac33e34e0e02b94b6ba8d6ed3dce23eee30abbaf110aae5f7b7dcc3d5d130e96e314be681e5b26a2f4dfcfb33ba9e3849af120b766965037ad2d18162bac0fc5ae73604dff72ba8400874917d11b75e719b1d9985cfccee47f63c115031173ae939dbbb5f23af129669f39af8c65e2df1b3a60dcb6218aa6c5b0fa431637a9afbbc03abd4ee4718fa376c727c8d317ba823a0578b9f83873088707f3b06a8a24982d0cc5934e34bb324c4565c6d183462075655e204e52602e03a8aacb3d63ce1cbe391168b9347db4b949909f17382fb8b4f6c54b08bc569d5e36463b74121682c006b3d475732b366eb362f3b0d8d2af9e831cd3788905e8ad0aa30e24b44d87f6c946308ebc8a129db2d1651f0d39e9bd0ea240817cc540566fb579092fb317f378a9e8164911ad408029274cb167fde499c180d4080b70b18c37257ad1d725673653a27c8e89b99b0d84d30ac42cb4968f9efa8231093aeb9d652a1b58a4b264857ec185bd09e6a4c136e435ce6a6c7eee2bc820939ab65421f2545bdf5b8fb9300574c145f55fe2dd8340cc9c1682bc1f256fbbc95f189f6cbf54d1948164347b81a1ed5ca866a7a49a9cc157a198f7d28cd3874aec59b983ce6f5b85b62f0e0b4f7962405b3942d1de036a4457d3221a151fa8d49dc7d6972ce3dab82d2b08a9bc322e43255948904ed4172024b9cb4cd6ee0068a0285e708d5e65412d7b6d0376008f624ac455688a699da2a75bae29a681f111703bdfcfe38690420bf0ad47f99caf09675354cc29993b482448b9540aea5b56edc4e4784845d93855484a1357e40d1b78dba21cf8008ecb908d86841080c4211164f7bd91e24478e49dffd4cd465e638b4a0aa6cf3d813d20f8914c7f435a0a365f252256a9bdfa03294e781fbf6ad65cb8eb193f3a20c4f05e33ef7c5c8e904f16ea50d87159a09983f95c0e2b63219b0209e1a68fc02de9447428e5fe0ec53b2dd72b8b7f90007460a510e9a03629c9c05083323c7c8d56a94c9b04c0ac2cdc1a256d08312b1b75c257451a1b9ef0fa4b85d9fa05583f33957b340d1c107a0c10329b15806834043725998ef6d8a18c2e7867bc4c3d7d2ab5483e6e821f00b75674bb2643ef3bff815cf2cbbf63bbf5dea4fdc29cc2437ba43a404ad88b931dfbb4cddf12cc080f03d311667773f11cdbfffaf2480ba56e4332870e4eba7de06879c9f4303cacbd886c8fb5847bb847a2be9d1a04c14d1d48efdf798f295b1e69db2a4ca946efeafc42115bae3c2f650e871a98beb9c8d7d3d32ae0ed6e990a368b0c7f38b1200306bda65f45d6e905826f24b6255bbceaaf33f76ebcfb325b7ac4c29916c3d5fdccead2cc1639bd4b14f3a78bb5315694fa7403e2c75cda94001f1619570f17f156a8b05abd6fa7152dd4fe5d99487ed33487dc385902c5a22b7229168e0e5b6473b7cdcb0352d17864eafb6412de1399ebe5db35d792dd8ca84befec8d7f5281676e1ca02390e16989c007c91e2c66e7afe847a59ce87f298bc857183dae539fb99c456e4a59122355c7683953dede3573e8a3b2d7dc19256e5d0365cf2f94ed5be6ada664a350142bc25cdce852e10123b9d74b9dc29c103e4465846e80fa814aafc773ad4f6af10a3099bf7e094ba2648683286ce95462903524c0498c788184f81facfb88990f59e01679829a2cea06884c7e521be56ee9e79320d0a25ed5a9dcfea451407c9d992a0b494e0abc0d392234537cd4f6be113104834617eb5bc1415c917c2e95ed83421299b7c4532a2099b1d2f89398fb9f12660be14a25c91aa769b9675c97c047b8128feff632bb587bd2d7eba890d49c0e5939b7187fcdd040184c932f49a971bddb26b4f6506a63d4628b7e7b40f968eb7fa50ea609deaa962e8fca39bb3aaa0826eceffe5284eee998a2f14b18fed5f8cff8f46054487c65dfc6918bca6d2008eafe919e30dfa10667d3fea2be2cfc0d84d6a60ca28be50212c5680e6e4a80f051d8f4df672322e18e7ea7dfa109f497a3712ca01806a06c9e5649c4825bc4b7e8291d73fa4659efba2f69943a3846d4750f6ef96f0e184cae4bbadab1f8149a5b3772cb82b60bf40a31e743fa9983b6cf69829eef38cfabf804272ce705eab33a41533c6aac0e0c277ae4027cfb5ce07214b748f55ece680417d8690e7bc18afaaa40d533ab7d88a3d6399cf9af0b29d5ac7279a8ec078dc3619a3db5a6be341fc61c3caa64cb4e66e5b880f149da5a6c729beec7556266a47d5871110d59d636c567f43debd20e679ccb6d963170af99106c636f3af3e8f14b178e1abc6cca09611c5bf758d572609a1d1f40af3a9a9477e6cc3799663784947a38505a05f392e72b6812f006db150ca26b64748708eea517185e02a3b9953bce8a4b1713872abca05e5051579ce0fe6415ff014b19d280bb20b064f6f74dfdca8507ce5f04ba1603e8c3fbaf810ccf895a45f6470d6e49930bc1598d8c59247a613557cbe92a15e78214c640476b687b25a7ab241a1ab02572d20df7c1dcf65a5812d21bcf20a411a363a6e07307f0805d37d1018913554e52cb8cb28e29a55d07e19f4043678499b97a51b9e0167a09dd4eda5004bf0d3c96bd06bf16fa2b029fb2a88f22e470eb5d859fe0e27a4905653a5e5f99637103bfaf4369e79e020c8dc3206ea611e0436513cfa41b0415b1322ab40b154352508216b48a216a7d4cc546c92ab5611a681d46774b31b54e7b2ce355492d13d530914e61354666a8be5aaa6d888fb5767aec5469abe585bf305f5259aabe05837a6e31a1342ba08a030bcc2e8721a1c207f47fad059ace611c9578c98cc50f3a4bb5c8c71faa133da00f419f94a4fb71d031d6b21b6949073c1bd18d41ac4285ece701129e6283b38a637b071711f5308ca6a5ea9f205a40b515100e4db05718614701fec2e6e5fb942ed3b2d1170ed8ccb4776210f69f3fd8383f6cac48bee3ac2a6c2422babf5348a39d1f16046ed346ae88733ba6666c53e6e8841c3cc4f8eac468289ba00e6ba5a1c0b1b4c50d42a98432147d3446858be8fbfa4a29d9a0b95577cd01b25108f9b82b5711f55cb8498939e363b68617ba1b1a2265bcef5f1e65b2040ebf183b49e34ab770ddee37d3351f92ffa18c7d5da4d4a5671014e1e355f6abab3fb2146b86cb4f6481cab7008294bd8647d88d476163dc164ee50eb98330c70631e1e1362543df492edd45d017358194c8a043e6575af4493b2876de171c6619491d608cc3f7c76161e940b3eaa81fcde14cb5e7cea87468116f1d0a21af1acb32a4da2ddcffd2d3f0f99481003eb21d870fae8913e21a861ced03e08c60b0f1492f133e60f0bef0205c24a52a4fdff490fd015e4ac374504fbcb33ae90b807b5f02627aebc1bc898fb33d5a954784967f42a457d4e87123262845df17e2eb405f2362762083277f0b0ac03ef58b0d6510773fc28908e898c3257835d00b73c47bb234e1e3f9e4a9c80232c7736a450e17415c53bf0e6ae3e83700b748c526810b534929bae11847da07ebe0ccb7b2399e03a2a35f9a926c22985a0d4c1ac22cbc9ff47ed3a771147367e5a4831a544f30741e9f80c6deb0903f75a841687daf252e73d233af2a134b8329e65ec4fcd81395857af81d6ef0c8ab305db38f61c7c9ddb2c97bea55ec4a1a50d6683877562cdc1d417f44ee064c958c3bcc07c9d7db48ce54050092b502f03fca0a48db2414a5b3da5fd5c710f201dd32ad6d010ad4ac108e34a690e1cc6a2aafd61482edf871bf6de3696f99aa3d6de4418f8d0c60f32d143b643f0f5f0c510a528faafa41567cfa216609a74318105d3e33da4d8956b8f4c526fb71e7b1e8c0da3b67feef1418ffc5e4aae83349b3dda21f54631857abb2fd722ac70cfaa57fb6916e5f1caf3bd67902bb33c546a8768623ddb819feb18007c2bdba1bf336f879a7287ddfa4f577f8ea16da0d87bb91d891ed1aa53fb6b2ae1854ee2871a6b2e0e5e5dbda539a5943837d5275557fbfc10b417f26c09c14c7e61c21c4f5fdb9e6ca5ed27fbb03bf0da47c105559f24679f9e969c704ddf4bbb76c4336df2d797b083cc64897f7ea60407ac25857f944947b6136edc7a4aa365498b526ce58fccc3a2cb41d6996eba46bf42f6b26977d189ef6285caa8f33de3edcb85bed4f7059472c6ed2a11916e8871169ffffd96c209b7d59d6a927467e1a585eba4a29a9cc831af3c606bbfa56d6695000ad800fb43f25feb282c066dc3254b85c2ea74525bd258ac4df0ceae88138ff7d4c36262c8466a76253c65ae54394e85cbe32acd5e2a121c1c3e62d809600523edd316f5a9368efb1619b61775021b3925851fc55fc3108635adf8d6359e9f122f1855a24815a86c9c470b420ad961d468a6422b4a4dbfa04df7254bd8b6628d2cd4be3449b2083069a76e965a4c1306f63075a8cc3d47637bec0a4bee358c060ba14f344c186bc240eea91b5c6aadac63e39c2590bc17867440e49778fffef9e4c467c44451a641d8c847ed79091484a79e6e1434559d8e7285859cd88772c94dca56a8ff8af6ff9bde4b2586913c9f7f6f25bd31ca44b77931d622510f527213201ee9dc8d04ec89d45ec6119c02926f50f21ae01e67e00032daac4bcd83ee3d59db6845ae8781331480a48ca6e26a4595bc525f2f68d8362c5268466c3f126160e04ed45887b72ef88e3e3b5363bbd900a9ff66caccb7f356531d434ffb6d258bc3f36a3d5e6230c24c5862009eb6003360c2a10b034f49cc87b87f658eeb9805ab9dcac813e044995f616e811305a2f97d0c30cf7035e3c7790845fd78a4897ba1e3dbfd393908e995e9d0cb56edd11a97f6b715d067c6dd7d01b19d0422031370ef0defa924dcc5e4f0fcd820325d908609fbb621d1181b6305f2a7f3a4e80aca66d25e5c4eaa1545cbdc62920bce1660749163a4b776be1a268db383217a40219a85f547c6dd27429d7f47006ab78192450c1e863d2f960d988e0369f6bc95deea92f3948aaacf93b48ca960ec9f01953897fa50e5bec1d0749b65c4337d94b5ba84bbd099b2adcdd9401242d9362044fb74640dbfab2ce7a3b0200163660c3460f334612ccde84d0eaa25e010f3240e3d1f2b4d8ae83e24bd222b85bbd037c8489b9192157d74e5cde4e272401d7657c6f7ffa020b1a0ec29b154d1db936826fe51d8bb416ab040d50f650274e8284b453041ec8c7915e08d4ef504c08e18424d4b4db7fe4b009a7d9ce17801ec884a4465134c72fccaa801e112d24fc7b9c2ec9c7ee86a9a44afa1eee7e897898bcb208da4f00fdb64435ef1e0ad6ea79b69810f03758d10c79d0e654e437c0ce8c82db27869110a6e7a18a2a38c56bdae5621b7ea48b20bdb5e1906e148fcc3bf592037fb3623c8e4469cb9374267751a70dd67649734a5138f2a36dd811b51a5cf33c7b7514502b4c8c55d57b84e856b6b49510af68e024ea2b4f7abb18325dfc60f4719dafee45c6131141d6a87aa1e9eddfe3933522233010e7d587cbe7f8da9d6f0a57ab7922d022786ec8089e43b5fe8444406c90dcf5c0b2024a0390b4224ac24c6bcea38af441c9c4be33021875bf3e7d3692a612ac2638c1a0686c5ebfed9119b118b2dc13c360f8e44dd1fe561bb27b38488c11eb3077030fc93e30acd2fd73543d41872de7502657cbcd3daba8b2cb5948b2733698e8a021e732aafb06813e476837910682dd9e3c0a86e76e23897bbe8de8c1e4b97d7632080903654416706c0234cb995cb6b5f848a0fa5189f1305d7a3d5cb1048b64c01fbb79c3fbfd84c1a0e600c87642419b76605b420260a0051fc4816bd5e3f18623db4642b90f7316554c442928b6e59ff78ea46e1151be955c4dbafc2f8847a4a1436adcbbacfdc9dd351172e9e938f15f327889180f359b88c980ded15183cd080bc848dd4bda44461bc720ca3598f4ad128e873e9dcc8b1aedf3cd44cff4dbb6b6128baa60b4b46637d7aa12a26d2c0958299c3cd2b609ba58f588340a5b4c0597a51e23a9161b8a8b187fea73bb5e72f1d28e7e41d69de8c846618138a0bb4583b8f7a081c0a82eb4f8a643e7d00704d056481c99309735cfd470277e3622de3d81bc032102b03dba32ee822b61968394d9b812ad915d3494bbc14db52f6bc60df5d38dee8d1ddd99fd5d4091aca3fba062e332706e34093e1a3240c05a748780a50fecb951c14830778daa51809eb1582ff4e81998ada1517d522e4e7e1478b5b43b788c7e6038e606f2e2281be8b9c875234103b13ff00075e8c80f020ff4384e0c029b83a4f23f21b2e181532056897182b380a7c4611384a84c85f8a475c179e6405989a0254178a25cfdf47c77206c588393e8fb7cdf185da39e533438c3d60421fd708d9979670d4ebecdb140a4d4c210a5c199140f41a9bd3d4183333b865be789a39d00b41b55c3b57161e5aa52044fbdb2856f7423eb2115c2a9cf83701ab30ebf177c7086fa8683b02e6d1d4cb041e99d0b2d18eae23e00d1406b32d3c1573eea8f1000aa84b3c6f9654be78c1d5e4188cf5d137cf0ef4dc8dcee04dd49ccf6c39afb567aea6af6358bf41bed777fcadca959221cdff3811a39f00dcf9ca503d2770bd460991e1ed2678e5eca28c34d29a94372b4e45e8f7d10e27c077df3ce76f4c46eef9045c9b5f111a08dd786c31b096be20ad2b8b3df90fd3b4ea1d4cc2e2c54cb9c1fdf30c0fbafcaf2fb3bbab80168bf9de0cbca1dae1d4ad935d02f5cceec4eba5322d47166ec0e5f087871bd9e2ff6604afe98ebf80184c0b234620d600224ec856b1b75a510f4a6ea1d73d04d764a95af1d53746561cd50114202e9433af35b5044b2866df6b59f38b1f5902d2f5eab4f24a6d2973504c323201ba72161089b8e7bb6975b02375cdec18a2046f4a0715a042558c4bee0e82bf7442245bead40188064871f545cb87870c9d04605c8a7651144fc08acd47cffb674b4675871328c550cfd88c0b43430cb1d14292ea9d478dca6a34e4769b56114fab47c9dbf1a3bdf7a01479d0709fb631da16a9399a6e24229c1009cbc7d77c148f23411ac7db69a55a28cbde1dc9ccc928c552a937403dd74a1067a596877c4f440a647ac17e45e447b42da83b807d21e887b20e98d480fa49e88f52eee35582f2ce02fe50b4449044a78f7b45b2054b29a0e159a9cf07d2c88f032072eecf124976d88f0b16c2a5532677ae11b4c39ba356fccd8f7efdbbd026c5e17da78050086295878e1f5b0302dee2662b3955771b77a7765eb5e3a62509963299290b6a5dc5bee2da54c5206e20a160b180bb3257ab0b1492789fa39bc0dccfbd330830cf5539a869983c445b7d43e95d28230843238570472351f80bf58049d44c996c1374dc0040a7f30155bab46fe3e30e9421c8a8b63e891c26854aaf8042961fdea556fe36bbccb2f19d27902c46428f5a86ff98d83c5f4a5ff3e7f90ce12284a7c80e4c6effdf61be74afdbd8527c343ee1abd203c73d7e8c9862c8d521e3b288df1823c21efc96a0b7d63065a6a91466c7b33778d72b4b45de4aed17bb6bbe0ae912ed9fefe19f8d94d7484b3f4a3476fe62f98f7f7689f7a01532ec280d95b523ef85d17654897b83872b4a2da0c226b46471c129794e3ae1d9e7b34a3d197b4f11e59c3c45f52e6f9783fb20689de2c9dac1bc249038abbb89f2d370bc449034a1ab4ff70d2a019b98b6bb2e55e8138588ca8e4f870b050397217d7822db70ac4c1725405c78783a50acc5d1c125b6e1b200e1698cf8d0f078b4fcc5d9ccf96bb068883251604f3e16009da711777c496db05c4c1b2a3e4e5c3c1a284c75d9c111b0bcf12d687836589cc5d5c111b8b0ccbd0eac3c1328425c75d1c6ccbdd02e260c9c1a2a3fa70b0e86011721747c496fb04e26011c2f2c4c68783e509961f77712cd8726b1007cb0f16a01a1f0e16202c3deee286d8729b401c2c3d5898b87c385898f4b88b63b2e52e8138577a98a43e9c2b4c64eee256b0e5fe409c2bb221d4877365a8e62e4e05fb4a6d4acb8773654acc5d9c105b6e0ce25c89059d3e9c2b4139eee27ab6dc1e88732547477f38577478dcc505b1e5de409c2b3c4b4c1fce9525337771406cb93b10e7ca0c4ae9c3b90265c75ddc0f5b6e0ec4b9b2a3e4fb70ae2881b98b5bb2e5be20ce15984ffe70aef8fcb88bf361cb6d419c2b3f40f8c3b90244731797822d770571aed08abc0fe74a9194911be78a90bbb81eb6dc13c4b9f264771fce952752e66569def2af337f25a943af0afadcab92ba64fb5333e4cb0522f9e268fe9ad2c625e5ee648df7d86910c6d84ea5d028dbedcc5a5a6869269ad368b47e37972e71977c1793aadabe9ba9531b876f2405b9af60076ad8b703d3059389aa545af798d117a54273b41c7bf46694a3cd70b0ddb43b90c240ea2365fc5da02f8a84e474205f5606aa27b67f125c0fb673676ce788b0fdb1e853baa2c74c9332ce45912d7f33b68fb15dcaf69ffee112da86e34492f7a53f34a88a19e8ec5115e344d3e768d4dfc8fd70a60d0e2698975f044a3630210d32d848da923bbeb3479084e336b3465bf22d586bc8d935a44a90f8cea63c52e6f313521f17618ee02f4ee6ef3d1bcdff860dde8c9ea48bb3e716b9b881178a8b7e65ced126cd450a73d17d5ccc387cd02385d198bb24857113b6bf0c39da769a8bfe2d52e831d3a87c9d5dc118e6965256021e590e3cbbca7248daf29b8f6941804c53fe74d7b7a6a80d8d92af3b5ff4ada9544d57ca7d2ad0e7e8b66dd462ce25b75929e5a45e47db7cfbb174524b270dc3d2492d9d340c4b27b574d230aca514c9d523a79c9999ee2bd09c5ad774f9cf57f51a5fe8f963a5b662d992affafef455c39469da4aa594de95a494a1d68769419d244ed071775f02caa4218c8b75d659c45da3cce2042129a8a64ae540596c7832795802c875fdfb3b00a262654f1ee6779353a0e5b634bb38c9d0dc8f37a59aa103c24fb1177680db18535095fa6e349e2191ce0b2713177df6b808cb3d68b9b71742ef98dad367e259bfc03206a8ca5c82c99633a02cdb51b0e52c09251bcbef262fd10e3465cb1910943d4a2ab69c01e96cfadde41ded5fc2a2e78c51e1ef6b38ce5ddf45adf5cbef46bf10c75a97283d853283302e82313439082de98c09cdd3e474a095ce5a6bcd4b78f20e5a7ad48b8a68608e29da7f74285b4209bdc84e9b64cef9a4ca949851de78f912cf198d73ae3f770b8afb6e50ab150af5d5d2eafb79bf1b1a526aeabcd98244b5579fba59857606174f5f5d3cb5b43c0ae5a1406ce422ea5b4021b403dc6e196bd82917506e54eae4028e733e0aa43f519f02c7b9532897a7200af52e36dea5c6a36ad478f9a1a8bcd8fb958af59315bea8e64f958aa552b1542d77f52d9ee7b5bc3c9d6efcdcdb8d87f11bf5c60def578f44b5aff75e38838babaf2eaec2d5e7a0e279ab074fd0a174b55a613cbf212f2007862f2f5f8ba057dfbd7fdcb3c0b99df5de2351ed97dfbe9b97f0851526c06ed6b3c2195cf4fe7e4558ffc2eaefb3567f7ff5f7bbcff1f3036b2e8172ab542a8f962ceb57e075b1eb581e3599be8eb2b657a7f78f88fe96f78fc8e94f4f57372a1cbf026f7c07c2b01e0443ee85d01c6007ca8d23e4be49b842fd0453df02bafc09acf11ab4f12a706eab02e52ea96a65d55a62954aabd5abbe5f7dfdbeafe0eabffaa5d287ffcb5fb3fcea8da9bab87abc022d38d6d5ea6708ea5c1f80c75aad9ed2176c048e49f6ea85d00e707b55c3cd2a1c936cba7a3c337d8fd5f2aba7205e7dcb5370f52d73b502e9b7fcfc86e86ff915787af911393d3dfd6af542dc8a18db7a5edda8c2fa0023455210725b60c08f117fccd0b868c3135cd4e17245d063bde1af04ce40e8fa2db5a8aaae68faf5e99380eb36cf378ecb2b1f2dc59c7dd0fe971302cb9899eb04552e7679e5a3efd71ff3e6417ba11cc2c95016bb9a7ebc54dd2db437e47e98502f7dfdf871f50f554681a63f767d49a34ab08c1142bdd65aa9b5d6bab5d649907d6aeddb97d6da2bbabeb52f91ea152833baea2431f5cbba85f8907b297dcad95ce9f77db47254856e528efa2c3100fdeeed8f317bc3b9257b1f910ff50ece6dbf1b54f8f27d435cb5bfb7dfcde77f7f7e45fc5fa0cfbd3ff71d8a0e6dfc13bf7f2adc9d7a4cc117ba173ac0eded532fbf0e703b15bee04ee7f63b22a18f29fd2e097e215405fcdf90d263ff6ebcd35350a3c0707b21d45d1b975927e868fda79ffad3fa85f8474406d323516dbf317d75d1f40e9ebe9d9dbf043671796c449d766312b9e7fc90e40c8e486496edefb4898d971f05700ea600e6db6852e3f1fc1ae0f2367ee76d6a84da5bf55dc09db781f156a52289a03dbf1b4fe60b3dc67431e28ff9e3e2147fb858b770089abe8f31273f4581a7cc911642cf172380e5cb18273a40360d4b2a344a9b1291db6dc0b86e33302aebbfcdb7c2c56b059b7c3f7592b8df4d9d3b56ecfc88605fc1455bc4c5148eb8bbbb3bf84dbeefa6e6cf01d2e6ab34788b86195cfc1bc8a42a3a3b4a7896f43081fd2081c1fe035a7021034758b8dcf680a1147ea893ef4f5f930427f81f7e88d7d199f575625d1598cebc45bf6edc85727d853a679336f31cfa33299b330ac3cc28914689a49248227df76d8584761a129146eaabe88b75e3b6ca8593c936eb16ce9f194b5f33c856fd9cda4e0d258cdb017746669d6e67785770b15e2e1caf9ee1a8da731a7980bb662fa0b2e5ec053e7b9447d8f567b69cbd2068e3996bad3fc3156655806cd5afde4b2e760d63d7dfc1aed38894a9af42a31aa19f83027c7d7af8deecadfb77e5a3b97f0fcc24d0b4733c33a57fc3177efe80084fb669cb2ab068b165cbdcd4112077d77df79e37a737c35bf397849b348a7b5f25537fb37eff414753517276077745022d6f35f2bef3f00a075d6ff79ef77263ec79f85a2af35632dc5f884b79affbcb7daffbf55ba795fbdcfd2bb793ae5c3783dc0904ecba7b5feeaebb970b3352d7bdfc7af3648df7bdd0bbdf75efcdf1c6d4f9832c9c40a126ab02f794524ac3910b2f131801b6f6705282a30b5b5a796505826a39b7fc6651cfae3b64c145fbb38898cfb632266332667b8eb66ddbe68e5720e4d6937fcae671d7121adc95b3bd7d16dc35e616668ad0970e69b4c5d5661a36374391b969ce37df633a82d8be7a0447ba81497667cab49d9fcb3ae72cda2b7e5e453c246213426de9898bb7242bd5dcd5c91a6953c54a967d1fe69b89e9b1348371db46187accb27d7f26095d12daf74b35fa6a79fa77df5bb76dcb4d4edb2dd5f62dd55055bc755146282aa8231a7aafd62a151529aa8a5f94957dffabd1d7f5afb6efe31f590373978fbb62b8eca354fac22b65ba6e47d7f1e8ba1e5d27765dabeb48e83a1f5d87a737bba7bb2bd5f6fd176c52e2ae71dbd9f72fc6a59abf6617f74b4654ee97aadc2f21dd2f2595b2b84bce6ac064df37e5b84bdcf74d3aee923319957ddfb4e32e6edf37f1f88bb3b98f773625f7371e77f56cb0ed678b6d42db927dc9d8e3c664df31aed11e37a07dc5d8e316b4ef551975fe421211145086b624822288080aa07db72482c267cfcf0a2072620a911345444afc1029510491123d38d246d2160b489b7b3c645965689982cf405f47688dbeb612c8561489c2e9b9dfa06c345963ffd65c1b0e5284b2b95388d12842cee6b2cee6fe86e3c6c3108c64416c85077afb51261dc9623e3de0e6f273bf71b1207fade02deec9e67ef3f197042ae222f729bc2e6d71ac2e341217411876a0f1fb63fa73ba94724e29e794d6ba08cecd8aa2b10b2ede9b875851b4b5d8658fdbd1d67d2ad8e78ad0ec59f4fb3eddf647d6dce77e06d37f4b6cfda56f48ccbe21ee9132dcbba8408f7208bf066398263086b132b16d0b2eb8c8fd11faa2a1e132f0723926eee2eedd8efc358978b8df90362bfed29952e0b039b9b9e772664ffcecb8ab2a31dadc733ceed2b13939138a6deeb91e776d9b7b0ee6afcd86fb3b6770d7489333b4c3b9461368e07eeae4608f5349187b9c4ba6ec7132d91c187b9c3e9b9b4fc35f40ba4620456ecae6de7a3b9c6126067a3be25680c00458b8010cbabd54d5bac258958afe07eeb65bce04c2fdfc71bb618fb2e603aa3967c899412687c3e67edc6ed85c8c7f8fac399235f339d7336160a49d2465b81f5d28bac8c9a42429c3d91f29c33df734f4b51d7137dc8e5cc4819e3f6e479b7b1334d28a099e2f635851f494b3973c01dc73757acd1cdab2f25564ce3047187a12993387be4cf0967d7bc2b6391da6e395656cfbf6b9cd8aa247299b01d2f2a64895b51189acedf9a6b741173162c4456bc3083dca1992d9b3b7f77e44327128626486295d0af36fd5a38f4b683273deed97e044e714f196452a02a48a963f4a9910fb29586ea33ae8dff66b64a14739bb978657b49d145862d37c2c65bdaf4ad338cad02dbbdb91352ea13daa6254f3c7a6a56a3aa764cd563ba38a059631764ee900f9e2c2ebae2518f3392efc67e22d4abf2a65e8bb00a1c749a36234692e1e983d4e9a8c0643118de622fd89548d14514d24faaa32214ae94b7ae9f630e522ab077a9c341abd32d8e6c438f6b74b1b6fd8564bdd4ecb95f24fd0b4f1bda71fcdc20d47d5def6f6dbb3b0d00f60a10517e8eb947f7b2430d81d592380bdbd0c1bf6b4c65a67ad3fad4b5a9bb4d65a9f3e2349b6d62f83b75ad8de54da6070715b0183176485a1c79cf5deee57ada22ffaf7efbe3fe3ae1f37777ba9ef4baf03ef7d594f385760db2669d6e88681658c38f389899e5ff758f703b0c4a6f93266b448d2a9e87a93758a85853e820406cb236b5e3474ca4a2f773b0fe7aff419f959eb57993fc019174b339c5f67c21f3434359a1acd1117abfb1117ab3b12172b0c19380d691a177006dce558cc99855881d0f4bd2ed6974763e63e0448994b5fa203e181d62ecefaa3b8fdd64eaa5d6d84a1fd47954532b900db9731632b67d3c71549cad0d9a62e7dd6d20d9db29668a40ca5d94af7981c1973c3ca8a8b4952668514933383acaeac881073030c55a9ec46ed0a090629a6caf057483890362f70c064cdf6a6da1070dbcf7efd0d732c9af6df3653adbae90b075355c0149294a17f5347a6da0c920a820442cff822db1ade6b3753cdda30b563aad93892323495d2aba3554fea0847d29532f273e4e4b041064951993892706471571d73e0b0e9e30a7a451ef5685466104f8a04429f7a60f060d3af228e241d3fb2667bfa3a92648d7d3ae248da740bc5993062723e9a94a126b848df02c9a22d68a249196aca91327476a7f4d216d24819fabeafd0f3479a560e4e03d70aaa6054d2299dd4d2f74dc351025b534a69ad94d64ac50da382d99aa505157ac941eb991fe2cc0f51ca6745d1b204fa73d0aad4cb0e2b0aab48d3971c7491a6e1bb281f260c98305c98d00cc3ddeb2e006c9d52615b27a5756e0aaa522ece0f6de4408f9784bcafad47b0a268f9a7ac4f2da8948b8d6ac306f569c325abb20d1b2b954bd537646eba3df480bbfba4d427a53e27754a7dce9f1e72dbea965e543863b7489ba24a411611f41c31103174928da7bfcc4d770dedd74fb293ec241b5b7074bbbd8dc1e70c18ba960084ae735bcbb365c592b3afd7f428919c55a4652d7d143db286f67da96ffa9677f0a5864db6d76f9fa585ae8f5bc0d3f7f0429bded2d7f6f7c11e7888fb9e90644d17841d3fa3adfbfee1b8cd167e8cb6ee5bf08568ebfe097c196ddd17811e7f67df8fedcba24d1d7ee725e91fbd1556177ab3afc33fa2adfb26f0914c60a47d34e0c5c6470e6ddd1ff5098a1e73d472d47218c99aeeefe71823c7518d2747526d5f2df4f8477ff455dc55e9cb6dee7f127de91ed80e0fc803fa687087be3c66df6771a147cdb33fca1a6241d96aadb5d65a6badb5d65a3d124cfad4824ab9d4f81ee38f45a3ff9dc0828203d6106be6aeccca024cb9a859b41cf95eea23c7470e90188be623e7064dca5c5611ab465934961416183e72f62dd2d8eb02b0032ae19135dfe77d1ffebefc7ddff795becff47d9f9124fbfbc009ee7c167ff9c8f1b1a3b3efe3db79387f25d32ce1d4824ab9d4b0a1f2baeff113b95286fad04106f9988f1c1f3a3e76be897d7ff4b1c37679e2227311fad80ce252039729be0918950a63172195500c0edf45e85942ab232973df4508dc162665ee7b1d38822f48999bb4ef6b1ecda37934cfbe8f27f574ecfbb8d67c3b0f5b711706007de9988efd118be62ef0ab3c928bf74f44e851c7f0162c9a8b97556315b9886da0fd8f6610b761cfaffe9b683ed5dc62332ae5f259c7749016d231d8f771ce2650b2b4d0ac287a3c61dfc7d42b3d480219442b99402e9803eac89aaa515002cf279a5b6a46d99c72e1728dcf4892dd759985c51fd117d25bf9a4cfe2ae6edfdf0193352dcf5b791ecbf35e3c0fc6f36e781e0ecff3be9b8ff3c7a269efe97f3fc30ecc23ecaa03e21d29737fe21c17ef6b253308d64102b97ff10efbfea851b0ef0f1777f4c89af9f7771cc99afab732b1c73fdaf73dc74c182c5a2947ca5c135cbc4fbf21dd7d2059f48873748e94b94f31b04d3129735f0352e6e29c222e5e1a9e00a62065ee7defbb99610c44e69ee11129739fc88fddc4f445e80d25bdf4527c854e41d6787fff0477b93afcd2af9499c9e15ce6c85fa004b9486350f436c3d1853d5f82349995c1ee0992a1472bfbd95e954ddfabe22ece498d8c2b5b5c91c61062269034264e92868003134a44116485dc35adccede3fadd70f3e7dc6eadece69f4b594e40a182183031410c7ca096666b5646dfce3c28586253a907734ef750db2c0421db480b7262b182bb58903576fc519364cd8f5dbf032595ed1ad3edb719baa5b958eb57277a86b616da221c445f2f5bf465a7d9574bdb458cacf0f508121864988186fbf5c5ffc6b085a9698dac5f2e6c28f8d22129a9d994c8e84166435310031a152718e3c806d34c411a382b5218d9d4206d60c41160d0c0e5c0a68694131b1a661fc07c5c3305e51466ace0c706db4c41a98510541cd9481cf0208a9a0de63205270f38f0c86c1c9c09b2d1820b1608d93808a3834d0d3ee716b3207e6641c07496f8e82cf9c1675f01935901042557c0846a4fcf96d97216c4d1963320b8d90f49db9f2b9aa16841d460b69cfd10cbb2479cc5f6e7b165b6723a6019639fabe188e2f951e0fe16d220d29653a07b2ea4e1694bf572861eb5b4b9a0b4999c9654b60224955da9ae5587c6aad8fe2f9dce8828878ced4f73c2134c9413b4fd8bd8f8573af57603751a65e7c924524268cf0974d2f31e4fcfe3384e8296c37abb20b7b1538e83a1def336bc6d5fa4b9bf65e8711302a29ddc84e88b03b2c5844441f5dd6f40eeaadf79b2bbdd1fa12f55b8f940b6baef36347697da361c651abb7bb91d6d55a44cf72c1ee8fbdb8c8be27b42061943ba56dd7353382359a3bfbb3d2d41b246887be2afd5773054ba1f53dfdd1c59b3b90b7ff75c1677792894a3501485aa281402926c14aa84429950288d42e1edc9f61d0ae5a1501885ca28d48742955028130aa551a82de63412052d6733e8c1abcc8aa2f1e354c6e095322d600cdbcb5002ab04e2fde7bd9540bcdb435f2adaf2fec276d784f52a70e76d54bf027572781b55b8f336acf0d296e76d9b8d6d536ddb6adb58dbf6b26d30db7663db4417bd1929e37d067fb8885ff2b780a73781dd5e813a6ea302dde6033f70027d6356142d9dfcd4b841370a30d411b383470fd1659bcdb6596a9be5ac7a542c9772b86281a18e981d3c7a882d3aa5c15047cc0e1e3dc41318ea88d9c1a38708863a6276f0e8218273275949ca72865cb24d482e763fce1eb6699aa6929a16932927c984ba51b4fc911ba44f13b6cd7cbb0276775cbc42baee0e521c12ea88d9c1a387d8a22f7f71306f755f82954c295569c24c57ab3e158e8feabe9bd219d2757d9048eebadb8cb676dcb519b9b883746d3a6801276d428101e70f6d75ffb2cd74f07df79bd117c630af0f459bc75d338a14bbe76030478ee8231c4c1e1df94e213e425fdc8c63a2337dce39e79c73ce39e79c730b2eb4e8af05bc1acc4190412620a59c715405c94a521653e9f4c2114e889b31f18274714152a471322e16b6b89a8b1d67c44de162dc8facf9389f5047cc0e1e3dc45688235fb0b45951b4b715b9f885191c69767e1b44e89a8bdd36c5c56e9bed215df7ac1f67cf4a65e262b2d599e418da0c55105e5ed926d3d4619b26cf363d17857c6d47a6afd75df94da66741d6a0b6e9d24057a1cae2bd381263775f387265ec9623be937e2e09f625d1fbe3e211d2759db4c0801bd275f293c31826c7096d49bb4be118ee04724b5cec4aa552e96d84a16fd01572d7934bb9588e795cacfbab4d475c4c9447333b8471b19008ddedee27145903e42f6913f46477dd6f47b226f5ddf7dd734bfcc5c13633e48b8b8d1c93dd75db15ce8696a3099332dddff88674fb0be7ccc5ee3918a5dd84b2bb4785e3edf2b784638e5338aa4c61eebe04203dca291847e66e50094e74fef106ed8e4b1a6fc725b9d8bd109fb3dd3d902a7a94538c76d77149b4e5235d370a598474dd20d3773f6713caa4cd1ffa82f92e49b6bb8e4bba41378a9b632a7dd977f71b95d2f739e79cff7e37f9ebbaaf9185dea2c820974702e9bedbb6d8dd6fdd6f50f077bf15b9abb64df9fca2bb4c9fff87bbbecf3f236b4a9fffd217cce71ff5ceb4932ece0929763fd69d5f35a58b8bb9d87d7e1810061a7397063827a40b8914bbef68d749da9dc22352a67b1da793299c3c2e76dd7f1dcdbd5aab542fce749f0159f37df72db8abf4ddbbe0aefcdd631da697a52fc7ece0d1436c9190b7393777d56705c9a291d0ecd10349469aedbdf74f6766bc7f958a7ae18884666fdfdd5f8197b6eeab40ad80ed737861728d3d4e1803c05d631f102ada3ef73fbf972f1c2db073f8824315b6c77d17be706526476202ce86119abafbb7a936d75d59e3ba8e13c368d2a0685e8ea3824384e9e328ecbc8d7e14f4dbdfb0d52794101adae2c018ba6de1ecf1816655d1a3cb664fcfedc92e25f72fa59ffb65c8b64ba10fed96bc6d977b219e246bc26ddfcf902fb714876d9d08b2c6db810c528674e5b7ef3d902ffdb2f7b0c7c7bde7887e34cc71594f12d9128104810462df036790322c78cbd2d72c41103c1cb9b573cf9e1ccca36e9b47b38abb38cfd39e77f2bc16cf43795ecaf35c3caf86e77d259af6a12abf99ac91f24ea009c8d714429e6082093f7ec4c4d4eccb1a0beeee3deefadedeb7dfb66ddb977ef46ffb6e2e68e42b2277177e2bb8e86d1bdeb6bc6ddfb695b6cdb46d7adb4edb96b177b748d34d5a9e6b7199bb48701af5da96246b409a1991b6eccb65deb2758f3ea9cfcd85230b7b0bdf06fa4f2fe3defecd5fc9a44f2d9f11d476a5cca90a7d027d465b34dab2f6ddca36c390f90c8a7d2faad94a85cab63bb695b3190c6d9be4af6a63ff725b0f97031acb81f561ebc072b42d75d46093787ec30a95d17c5614ed15c3be295f4dca130e11ae1c3a8186c6bf6f03f3cf9210a53777b9ebeccb253f15077d75d3bab76ddb1fa85e54ebcf1efa9255d8d49f31fafa6153f1aeb55dade325debab5d6dc65fafba529eef266cf8cc5f6dd2da76f084d8d2d5f12e9b63daa35b2cb37a4cbd9f74e99edbb535f9d653b734ab37d2dca480a278d4adbbe106ea604b1a55aa174205f252628a325d30657290829de87c16030180c86fa6e6c0da212937dbf34e4aef1ad95b9ab82d8c7c51f0c34f3578aed6badfdabf257e987b6ee8dfdb116c37e308c490956f271d77c9dbee5eddf4e9f54ab07674ab02950d316f72de0a52dee4f60490cf9fa6e191a08aa34be7404f9994ab0ef0c0ffbda3f7d37162c4d014b4652e67e29881295bdc45da531a4784b50020705d5640dcaa89453d2f1574a8914f9428d8132aaa18c6a28a31acaa88632da093252e197341bc99a524dcacc3e28fe32e978ab08f92a4991adfbd784ffd5ea74ea2cd8922da51e2bcafc8874bb86a69c519c71a2c75c5bd2830cf23111c0b7f329f978644da5225d2522e418d25562e2a2513ea2af97ef532f6deeb6ef6fd7e624fafa6adeba2f5ff8d280d3a33e022d9f0a47901a41120f487dcb8f00a5efa69383016c4ebf336d5afeee4c9b932967df2f3171d707936289885be24202b9f48532929b0ed2958de4c76406f96012c8fd1217fbfe28800fe67bfc98ecfb78c70e1e3c7af410c5568b04127cf8f891f30fd38e49e7658553e968df6f094b46b4754fa52fd5f0675c9ba25f5a6b6f2cf8319fa1b88cbe6c965c9465dfc732fab2f796422c53fd178e8f472cab123f9135415808638c31c618638c31c6d8c3b08b976021869041beda04c2e4fb82887d57b0efa68447ca6c3b5f6d06d97ad87cf8beb0b85443edc89a9a8a0765d4ed58bced781ecda663b36c39eeb27f73ce39e79c73ce39e79cadcccafee96865f863f0236423063f423f2b16eb45cb12c638cbbe4e05a30a75c4ece0d1436c853a6276f0e821b6c02ce5119907e6e2b5ab0dc443587604ce3cf4958d60eec25448d128f374f92853c947d9281fa18e6e505450555ef206725bce6deb71f16e4b5cbcdb924dc9b6b3ed7474c8c59bf3509e6ddb0ba19b9db9782d4c461db9781fe6bb41d96881b68f6f6456146d5f7e2823176f0c75d3608c33956c44dfab7d5d0d655443196dd908976ab05da3f7efd55aa5fadff960f45512ca54f251498c52ad04867cd969653ad8f7716cceb7e9b64ff9ab54c33c72ee91b398732b671272f691f38f9c653e234976ce2521176f492665ee5be95e8fc4300cc33e4d5a7ed3297df2c2fb2730056fdda73941c8b6b3ed6c3b2d5d988284b2efa38c4ab29250e9898e981d3c7a882d1274c4ece0d1436c91f01979c9152c611d59cabc8314ef8f1727d1d6cd324419ed5b9a956a2e5e2bb34352e67ede4126d11796e51d77592aa47893f67d1c5130123964413cb36103b2b6f1ccc5fbf8bfbded6d48b7bba7af0f466f6d7fb01b43b5216cdfc738f290ccc53be4e2c5321b2df88c6ebe2948646d7f546ebe5ac812438f5826dba1f76aad52fd8b220d8661d87d2cc34378c6c394af6d67db41beb2cc5bf7ef26a56bf3615f99bb8684bc75b78dc666fbbbc576080b74370101f79ea5b78a2f2a78ad312fa594d74519c3e6ae694bbea5f4d239b465f010063a7a9bc6b9ed1e91104941db3278985d9c197b1ff7a5b95f9af8c10f1f17267afec3a83e931323b2634aff4a19af76945a4a29a53fc4bf94725b8d1bf4dc5d76d152eac96b2242cf5751ecd9083d5fcf6c1a42cfcf528e49f6b68534d4605302a2514a29a595d24a69a5b4d6ba2ae9161c36562f314f02901228350000b6ad5564a0e07cb440cf2761093dbff5dd58b1c7ce2f39d864cbe3bbb13dbe1b8a0770808fc78e9850c72c859a1b1c82396ea030c4d62adb7603e665c51a42a4235224d724246654855a4350554080b5d5ae6efcb04a809ca986acc0061123d5460debf20d41825605d88a3a42cfb72df664fa6ea802285d0085429bbe21482c20078de694d66a29add5525aaba5b45a6b6f2ea15c58303bba1ef2ebeef1a3845cab093a5cb4da1bb604e9f9e077c3bd117a7e8e24f474e570e5d74b0efedf4d6df1d124d07c3760646ed0c0d010a0520aa406bfb002f052c31240105aed4c91d94c911e6caa4f85bab750ba54d346901a2e2ea9026414b2a42f6e13c1a65cad18851c455303e45c27adb33eada93f0c6043d16b8def86662aa4a3d70b67bce58f85a8809eb06b0a05979d3240b6c92977493a5b7cf4ac78579b169b4c846e13133d7f9ca1b37d8099d46446137069880f40dba1056ee27384115e390fe30fbfe4a0ede31cbbc6a4ccf65eb76b6355d22d38e8eae5068f3086c78f0000296100ae5c53803d935f76f4fd0364158cbbeedf0de4bbb900f86e3899ef660b5b9ed0f37f28a1e7fbf86e2c09ad03e4971c700a252b7e37b6f5dd54fcbaf98c14e9c12366878e9b2136f22f37e78e182e1c629ffe0944700ae127047c1c396e082992dfc36f83c323a1db1cf17ce07fe3a3f901e665c52aa242a702025408c809c8d95d55ba5c4940142339bbdd6ce4dfad6edbc37c0910816d7981c646f24b09347d792f6d3a0f54355159d181226dbdca8aaf614b117a3e56610135df95aa860d1723f925074d9f0139e5ae496deaa35cbe1b1ab634d1f36daae5bbb1a813037291aeef362d2ed0e0d1a9c7eeac90257d996ce46353a9b46d277d830798d65a67adb506a1a5a0519f72916b9e9bbbb60ed92c58e5bebe6f2cd1f3a50c1d62b7afdb27a0daeb5bc6f80d9b5f778ee36c0e52c2a047e88f66859459f58194981d428a0aea122939d0347429a9480754d4aca048e8d496b31a14155623824ea15db69cd54c6075f457046781fe90fc07da86142d888ef0228a7a84173e39f062c9cc0b2526e8e2086674e18379461766d02674b7e5ac0ba32e6a5d34b11d416b7f792f3f8522d76eeeee3f5da8608f33314174b1434543e3f0410dd2ac2d6c12da6211b3411a33081ab5e58c0b24d0e042083378a043d035aef88e3e1d017d71c3a22cbc7ae513454f4ca92bd01e15f606fd09f5a0bf2d67454e3c0545430c51d45384566d392bcab124d02d5bceb6f8410af4dd72b6050f66281831dbdf041a2b33334e5471c20afdeb7bb6050d77a1152df79ce22db983a8784beef16e31e3386fb35bceb61802eb1045ebd872a605961d85ce5bceb4f88175a2851855a6f596332db2a853682194029d63cb991642b809f45fc142e300c346a15736a83ad027267488f202ea44141f5c8a283a7b9cd9760a5db79c459929424b3a61868616b45d5e5db79cd1627b54c92c17b8ee5186babd1f17e5872f2a8c7327d9fe497692dd49297d0718761df5d5d6b45f9032d42dbd1fcfc7c52b5fdb530ef478684bfee6f56cf95a0979851017670a49849618d2218b1c3811032a581ca188274c60340415dc51149dcc0423b613ccab5472eefc581918399c92d864539ca8aa22798f31230d2d052d341fd58bac2d675924ed71c6e8fa45034b9753fedc724af04505f9e18b0a337c5161bebf3b38ba4b1fe7763ce7dc4ea5601390cf1a93133ddddda78315073d7fa4eeee0eee2a6472a2a7bb7bad02cb9811876cfbe3e94e6d4d8f2b21ec753215a3af2f5c09d1967f4ec56236155b09d1d7d52698ca045b093580da98602ee06214057b34c1a4a905db69ad378eb8cc2ad2dc3704dcf46f0df7f27d06b9bf12daee1f932295178ca1be94b1dbe4c2f18619dbffc6918724144588ed306f93f6ab2915db8ea29990806daf99b4242b0ece3b223c4a29a57431829eefeeee7305774f4d45db2d67599cb1cbd0a62d67595069a2b92d675984a1d2739685169e43abbe65cbd913406cbce52c8b2af628d61accd0a8f434a1006b77f7165cf1c4091a9c41450f4dd8780a2420e30546c0228a931e6c7c9e60bb10466cc7dbddddb3b8c004000b2076ad7fb138daf5351645d8f5552f9e6656b0040f36fe469058d8fe2eb8bbeb12ac9822a68b00ecd1042bb07471050d8a0d50aed8f55f44c1ae331c50d9b51efda0e79c56e04066fb7f578969c50f34bb7e0e7d209232a764620848401153e20726ac080017475284cc98b1e00465fc80864e0d611235d1637edd11f2410f097c808234a2b8469841d2501428ac58c1f1e005dbe5fa408e59c71e53557c216536738288071516ee3ba44cd9f56f154fecfa579f6837e8d9b506bb3e774f5b5031e5845d7fabb53229c2aef58dac506bad7966b1c73cf4448d8a136cd74075d6aad823ccae5958bbd62980d8758a1fecfaf49be8b1561b94b15d6a103f50926fbd36a022ac4184fdb18340a8e8f9723b111bd6b00258c68cabd8b68f3b21abc39ef867e8819627f533533faa9aac995f9998149b8aa8c1b6dfc99254528ad8f6295863a6a46d1f08197abc3a76b8319dff0d89d931db85a4ccc43cdbca1a97225b76601ea1c60658ca20102a3a67fc2f5fa802ddf9e9cef9eddd42d63f22313b879d4ccad8f77a4ab3eebdbf9fc194fd86c46c1caa6a52c6be8b0a74fdf956d0694d1ac3ec523fdbfef540af0709cd16d3c9644dccb631abd8963a9274f36a01133ba2e139bf9bbb0979475286e36e574f309a71cedf8dfdbdfd78829dcad0230c6c737f82c1c0e8eb250a1821240a304b607a64cd6661602f4ec02cd9dcbfc4e82b872f3878e162732fb1cdbd4cd9dcdb707ca1c1e65e662e722f50b00c6627a98ad1e67e7c996d6e86a4abb54af5bf03b303a30486e725897bc902a3b3b97fa9f26245d6dcfb62f472246beeb5c11a821e678c35042d6752f0ec71139a316be4c5c695092b460c738f27586c48ccf64217da8985861ee590fd39af0b1dd8c209762a72d788652798bfe614b0d3cf09e814741292b9ab0e55d9dc9f66eef2b1b93f4119da9cdddc9f6afeb236dcb458866798866bd8080f6128b8084fc154f010a602cb4eb013ec0423223bc1666c3641b10ccb666c36318467583663330826c257cc264e30175a0dd82674826d4227987784659b504986655a6642c2b213ec043b9d6030b1172a48b4d27c24032e4a232430d41c774d593380edefc2d4f19709276c1fdafeb3c88f19173270a48507b88b3e8ca6dca905aeb2484028919304d21e6f1266ec394a1124450ba458e252ec502972f6f414a8b68bdbedb4d65afaa68d67dd42cf19da40737f241e6dfff9d67f825ac7c51d16165adb226fe91ecd44e5e32ffbc45b6e8780b6093b25246b4c80b2fdddd26ccc065921175de74cd9fe3a47ebb86b87b5e7cfd7d3529135746edced3c9c3f23efff7bd431fa7a59e1fe0d69983636dc27b1c9e1a1af1513681451c6942745dc60e3af7be82b091260d0bea099608a22b4c0c65fe7d0579218509102181a3c6410a1031b7fbd435f2c48e9028a9c2b566c30c5c6758ed53b5a67083d8aa3ced933b286bebfad6113ee615c74170c8528092b8892a00151124f10250144940413a2249464210242322202aa1101cd8880644004044404c48408e8870c94f31139e9c19e197bdd95a5d20a889c982246e4840b889c0882c8099d21103551c588a8092f665c0811351185a88929889a10226ac287a8891e889a20411a6554216242075e101131210511134e8898208288891f88985042141b426c0ca258163222274844312744311610c57820025242b40416a2257e40b40417444bc880688918d1123fb42c648e31ffc78c6bc79e4f03b4e79c4f5d723bd89216c3514a559baa240c66c2624b78787852b84f7fc6e88b7b1acec0851990390a1c6cc6eee542196ae8a0c729a960157d4dd9dabe7b31955a6d3f753f54e1a9074d7f6c2965b6d13e1259dbce71affdc53d585d01a681a8746c5686452d19a21911000000029315402030140c078462b158926571a4ac1d14800d7d9e506852988ab32cc651108462c848438800000088000c46830404c0232b52a25b056a61f487f601d4c9a61dc700bcba5c400849caf3cf5d7bcd72fd2d8b8a6560f1b68ccd723adc27e0f1c94091ec17732dbb28c7c582c20b958b47d4218d99e23b6c9b6d2dfdbbfbcf38ad4a2ccfed44f55ab908b792c0b0cdd61adb71ece5d22a548cd6954d3a60f7189fe392c1953254d87a3ebfa99bcc1d97eb094aab8d92425df7867aad5bd6377d973ea670910dd87cdd3f8ea1aa6d276479e4e355c029276e90cc8dffb0c0b2f9079fdcec1499312f4995ca95bf497898b4d68515cb63f2e652742a8ffcc2d5fe682f28829d6f92895ed252b727cb673205ab097aab968c90a1580593e7061cf7d69650522a8bb591e0c407ca5ed2a2c1ac8ace57a0d212c41f7b217e75a1d7025d35b41b2c31bd51daffabb2e8046c2187ee05e7de58f4e6671ce7ce8a80649497ce8eca81af50dd483d75005231fa7b701de6e96684beca24e1c21257839e64bcb2266cea8b653d594d78f04c77271b028603625e796f935357c1b8a2370d50f72e3bee5164d408059fb46ea30ace0763aea667612179ab9240cf50ec23126d0972ec3de867bbde4171c1fa394c8afdfea94f254db7a730a1ebeab4f7cfc492cc1bbdad960851ba45fd0de905aa5afbc910e783a81ca9f6c3199ab008df6c3f53fa0e713cf52b016659af0b06e59c41de59568a9e51b1709695a2675c9d4b48c214a3670b9b6ea35cec80d52849dea164a89e2ea76392825ca142496bc47f0751abd662fedceded6aa82099fec0172b68d24329da78d1850fdd1f1ce2aede3a5d61ad32f09c89d39b94ad60eb5b7cf5d39825afadf1f555df5410f8c3cd15d49dc8a28dcdd412f57000b1ab746137611730fe221a02d08c56dd10774e06b071c621f805263a4d317edf9d2c38c0213cbe126353a396c541c064c6b1ef029932a067f29609831e6856e6ff25bd9a5708aa614be4c00a550863225d62fc706eb978bd6aac1ccaf639ca22d81fcf7e575a21808fa1da8a88e09bc045b07b84359d875cc467cf82096e6220957a4beeb78d30306e25e63389502c42b305239ca8913bdd596864971d0518c2be19fe833991d27f1508080b5b73d2452908763ee05101951b36ef128aa612a0e2f8191848b8218a02d42ded5611331ae91095fcf6c5b0430fcdc813f890de7d2d7d997a597b15f1e1815f567623c2810a1e500a774119f7f12de32029436f9d2d38f0d17a95cafe2ff79369483a5b11a55e858a2ceb25bd5289e4acd7a52e718f848a7c12be78acb0491ea6bde55aaa9aadf501ff3ec1a4c1e2aab58f06b822411fd7881d37372bc9bd4a7b96e5913bbbc99209ca7674bbc44a487331ba9dcc963a90cf5c37bd801cb7f47a224c89df7830fc4400a0c599e46af73e27954d06d0a851942e2096ee2f2c6b8e4ecb122d4448a56b66f34bdc2f05aa41964e2fcab9c17e79ba86784741b05a217c753835d9bcd2f2ceda59d966262357e5f9245dc51ce1a0cda4c8b8a7ce93f17a1cd01cb34f43de7a4ab99415b0584d57387d89b1d5f5acd0f9113d1c2b0b1d7d58c8c1a01607a5c13fee54edc54bcf4f8ce09598678010db9ade0a3a1fd18363b3d0776cc55e44b38be7665b2e67481557a390388d691cd287d0c2f2b4b58fb29e4724e7f25f2dede6a5c414301eb3f1a1e823c82358fae8184c6bca8f805e10271fbe79e3c6c67526f6b69a79974af601f1994d58a3649c8f0ae83214080bafb1b8ae1aa9c7ac1ca307b18e41bca509b36d0adeb19c795562a90b6b804d13915212da6e73e96d2e19305c1d4d868806c50e6a816fbb2dce0027f40a359c4d05eb792ebaf43c772eefe781d1d8f130dcc641bfe88bf2c9b416e4c9a0c23c4aa32cb31bdb7c256a7a61fd859cb7913f53f4829a38c8fbcc567650e238c542d5d89695a8d6391b497ca90e2ecbb605f85d62f2014bcc67b10772a0104199863f3b985a538091c1651e94902fd0437e400f8885412fb5720cadf14cd64cc96552b88363b2209c5fc7a9c42d78859ee1027e841f3db45b3f4d8d03d8b3fc4d61d08c43f0d845897ca94a915b748d5218f55f313c550ace5ee27f1309cfc1ec4ddbd2b4e0805624c102a324fad5d59fa63142423eadb9c0508b485f85558f715ef756af01cc3ce2ff8c13469a0241171111b7758b95528b1f1ba1462e24bb2a3123c0485ea617133bd11f2bae00f61965c2795836810f04148be8c1d13fc3a3682823ebe1bbce1018892d6c43e8357b4df42b42dc9fa13b469561cd07feeb0b482a2caad35de97f5c29e2f91096b8297a5ad0d047c1bcb13bdda60697e1ac461cfd54673a34c6ded9755cb328c404d092174896a8ea7c1a13b5b0ac9d591420eeaf5abfab2f70ed449f9c38d1f3bfdb4a1abef18776d2c420935a7cf2e5e6c51c3cf0fc6bc30acb91fe39d372bb879432496847923687d3df92a0c4b7e58449b79c999121c6c694d95d28b4c9d0fd83540d6523b5b753966a0cc2bd7b07883d7d9b91aabb5852ae9d4e43398ef019577a5f9e5e0d001ee37631e3670656e95fb0b08d1a2b2ca8da2141f68554cd416c931d6c917492acfb0d403f0e053f7a5d456b136113c4f338cfcb4f6ee86a3237cc67fd1c1a3c45a5f91904d78970fa5fecca5c9961282270df80ea672cc360806c0da7e9230fb7f68c1d4b36bac567e049fe2dcc84608449d025f0223389e3a5122e9ea61ac31f4d1e3ad6026cb1950ba14b57602193eebb6f347124c9264108a795ac9c11e5cff2117c061b4c2b9c48c99fa84d90d7fac41e3bab1af00c7891981665b0bef11e29a01959c93cc40022516a9c85833b1631ab8f7abc438d74f4479189d07fa7d8f0df004d5c5c6fe8b0f2a988c3084c4d8ad31a6c4fb7a6cc00e5701894f098fa8b1b3c46da9da0cbe061e3b859ec698a96584286d4c90c2e254689d1a3ba56822d37b310301d82ac4ea93b16e20e9c399930d016a0c571d5dcc415f67c7b28a11c9d5e25e1c6a95ac3c436da5632e5962cb4dea59c8a1597863bf541c6dfa63e88b39f654be67bb4fd22490764c54cd8444a0612187b3eea115605d2444b6178b16452df6da785598abc7df8bfb3cf0cd0a294cb37c0ee002dfa41d0624116efef2ef2d5b70f8f012d16afbc357d5d3220714b401334bb812959fa4d57cb0e50c997fd59829f9d65e5b3dc2af1bab6997fdc0abf497e716f0083f5386d05471026253a3a2d24ab378814840513a7e3277bbdc5b03bff50e96da1813700e043cafc4bd31ba746d37e66626cb0ec47f482f344d0eb8450d5ab4284aba68a61ac0b6fe480b1e0c22cc23262d2a077244bc23cb26950d580732c7f0f4c1fc378f856c945c96a6d79d4bb620e4943373f60673bc43fe395d274b4e8d1cfef210cd10ae9c3dbd9656bf8ff77f5d6c56cd684b288c2ee326117a743012070e8a3f2323449669bfbc2b3bb4b066da0dacd0e7c07ecde7f847b598e999895418d4bf2f6017d5c5b2202754b1f449653d6d2aaa51074d2d77ce5eb0cc1c808522e069ca05e9a282b301f553f3aa43d5183a1c6eae6fa7d7c4e7ffb47020b035fbda9108c1d9c3515f4b067d2df0f1f6fd1d2762c6be83e0adac2162ddd2029256a1146b2daeff132feace908a653d2e43b80e2807cc9c82b892411594cc33587a34a59b354e80f8f34cd55581023a58d47e8cf6ff5cc429c02080faf2b97ed223ff45055fd492f8ab6321a7f471aeeb4ec6daba8837c2dc9bdb6e3d8efeab58a6b989799a5af90f34ab2394b020b831edf2f9a3a055b9c4f98bcf10b39a9c04614d6d5e4e9226bd29f13041dd7e53880bbf64f00857cce6fad0dfa44994fa43c9c6f14d1dba4205ef86ce19687ffdf4570ba4da90293d97ba7ea3899bb15f367cc511bcf8e51c1ea326a79c565df57be9913e8bf87f2202e63d4c55393bb85301c90659506cba6c38b39c1e4ae240613292a6c897ecd043ee734c00ded2d06917e0981ea6a6c83f245115ea50fda7c4adbafc4ba404af09f0e29dc80c10dbee84f0d2267ad773a33065f101a3236aae7f02c8aa0c854c1319e16324aae24eeb134f80af0df6f38cac3449dc212d6c253d7792f69a3f7c67591aeb9062a207b79b887951a9d0d688f08a6fa5c69d4de23d099df1b0b3ac31eff35ca5e996f11a77a97d08af05989bb6d6ba9b6f859a6f6f9cabbecca98825ad0e16629a1732333c84a1050297784b81d1a3d37e06bbc353aaadbcc59a0d92091141d71583f99338bf9ecb2f91edd9812df8d63e9f64c5aaaaf3af4502a1a79309bc98302ea901040e486267ea708e52a394c0a888ed43aa5f7d9ba83133ee11b7292a2fa12862763d25f3ad3059860782f32a275c084544935f46987159578b1e9ba794505152f32601dd9a81dfe4775f08b8cb72893977091813af199845d64b0addb25c45d35e0c8e1620d9235191719cdd1c9d4a2fd0628b71db7635a08356dc7f1598c7f361c3dd9f039d3522ecea880891b45c94b2496f870212bdc5d7b0b993e2e32520145f656d88893b2134403150a20d00a13c4e011e7b547076be1a0960bc614523ed991c189d8fd66f5dcd3f95d756ff7e4a94fa543cbdcb6a7e66895ef72538dbe64eb5b41abc7108c39ca54bdb6471197d69e9d2562da4c751038455b3c1170d6591af29c9c39d350f165a7628cfa22d9d5524535ed5ed8266800eb88f800fe19762898451ff464e92cd14138cb46afff2fc81a8da84f884f16fbcd918332203d0bf1cfaf729f90439e3c5e6d5af680868f159d315bfd231e7c56acc2c788a5af177f8ee1ebe9d0d40397d984a44c9af1deb62c59cded34c43cbe942634cfb82f2a6be765b0d480cd28b9df994f6e0c5d093a52b2146300d030cd5c096d2b8cab6455e62ba2e47f09df786cff9b40ac594d58493e9e595c9a22aa89fd91a2e8216d38a9c3324efc2a34c86bf349d64d3fa5d9a859a20f26474b3fb44b285d495ab04744a14479b014396cea222bc1b500fac39162f1373a4a8ae1be6837ed51ae19e93abfb8bdba191e65a188c267002eb4ed0365aca6840dc3ba4a32f35bd991358ec56deef084313f38b287f475b96c2753342a8a1a334a7d6a75a6ef41fc6929d1f58773f369c8945b24afc717875a86df236aa408e546a9a8c07978bcb4594b0ef061250dea6ed961f02c98e00a8b668a0426a1c767a152ac93de800b9cdc8f389d25d84b9d84bfe9e6f5ef54965d6742238b0d27dfa82af00deb203a6e01494b5fd613011fb78ce82a5aee221e78641f9bfb22c568ab00258a472c2d9322c8d05e13a003f7638675ccd665a05f1887c58bdb76027fd1f2c09e1cd7e0e85ff71e4ec7e63419304ac3889bf0a0dd5890ee7c5d9a61c432f51c9e4c44dc04c06710a4a1728be1694f5f956bca0739663fe5daca10d856e9b9a5fcc74f7be4b4d0f8357048998f6f1c17cdd2c84a1774c9c20a35f9ce8581ac44b3b9b794702d7c6e0a9d485c13d7cd93d6c6c3e13d76761a9f0ca933220785378a6ab3b10b29ebd9e55ee90e6245c32b4548440ee2413998499c5c46f9267465822bef7a621f404119bf51323de3ebd165c4324c33c78f71b3566ae521281a0a8ed9ca38f699fd8d526e762f8debb4b5699014fe37cd4e2e66591387ef6743fd718b891d4b06f453e69dda5ce0568649cf0bfb75d3a38c546546ba98e93c20810900b0df0372e02b0a512a29a16fabda7831570a92d50a8b8d19cfde3f11450a9c024fcf69590db5da7caf10b5ebe491894d02b79ea8b591f9b9073344870637bd386dbd41c5fad31f7a290c842c6819a3db0eafc09c72bb473371a964979ad0e7408d8f63340f846c71f23195d9b559ed36845e1638082e35b5b3b289e89221da056552e0c009494a2043ea4f448d585a42717545194cea4a59a23c8fcff9a36df3ca53b4ea3c26d31375fc0920e12635d3783cd7f807c10e480bc0360f224848ef30bf400eeae8f65edd4ce04815b82925a3c9cfd723a1d3cd6da3046a593e4f9e19e3a4068f6dea917552e22bcd432faf61c605c86d7f682a9041eae746f639297ba305b008270c637bdcc2e71ccff3837be0b9e135497c0582c3bed6b151b9519a28f927c104fe9f3673aa8c8fed9f8aa7b21e332f7f6fbb34361e967801410731bb815bd2965dcc711d7ea965f176063cfb922413d92c86cf8cfb3f106970cc66b5f70c935587b3d35002b3e8455d861e2170e4b7ad1c800503f49c0e33dcec21b94d27aeb8f182d86aad4ceb48f480dd7527e32cbd9029db93590b4cfff688fede6496d2e9d82670c3873e69cb578bc72d562e2abfa734e58b15890c9558f5939a48054561adeb10218ea0e8c0b1bc8d136ed5e4135e2aeec947a8cfd9e9894dd2cbf4eaf6126a32896c0d59c008b44fd1dd91ea2ef92106c4a0d1bac032e8a01f79d4245deb4be5c1f422b0f22e31bad733a8aebb736bb3a29724f3566fa44b22407226d230fc6f21282b95dfde11c005db241aa93a4ba09e0024a818f4f6e6bfd0c80f05080b823d3f44565a113cd1719a6ff2f52897540122ceecc723d4b74e8c542a9617dce2c79ea0171ca5dc9202dc75ac205ac9e43b5263cfdeac8ac7853dab925d8f0058e319f6462ff3ce703087578dff0ac975cef0d0967c756f3477d5ff95244d9fbf1d062558bc6f8e4e1f0b933c0fc95b9b4c703fd66525c805f5a8546868b52fa44bddee968c4729d4e5e7a08df1889f8c13b7cd4ce536fc9e6c0ec57d89e351fede6923080ef1c5d0a427825becf74319e078cabde78e79356759ddb2abdc09488f90d05434ed2427b18b155a1d2f04ccdc4f1f4721131f7927282566b35bd9b25e2ae31d2540cc1c0dfa68d593567b73941126282854a2bb3463075fb3bb5cd501440aba009db90bdaab0953103eb67084d0fcfdfdb6f48108ff75257f10643f4895160d8bbd9482ea2f93fb1bee33f2589de70efaf987419f2dcea9c340587332be2409b8a494dbbdbad727260ed867b4d23d6abefc66af777f1a278913c8b05b3d29368e8f43f84ad8a0620a5461043f74a3ddbfa592d145c2bbf01438c1af425f348355eb1a94afad12f5a3c67a83f2a7a883785a3a08291e518b823fe8a079105326bb7310a78920e8d2e8290bda5c7571e739a883461d5eb53f463682386348da1feedbd1e5c17fac4e5d9056396812c7447d749183c62469f4188e2f7d13a3081dca0d592736018b87b70a1f718ef595e3a0d6d885595abae4685f835e3a99e43c64c54d030b8882b9138193b1702edf5b3ba4078ed76bc1507f03441f3b7ee7aba214176448b400240f1ff41275b6ad9c91bfbacca242e63afd154631954c76cd799f4dd8ebdd8d592ec3f4674d65f2e705945e34ad6b1883f4c0281671dc46c8c702c88d35f3351bc3ae4913d80cbbc5b96396f89d07896b0b6992de46c849074d8236b0ac8843432982916ef8e827508bfbada825a2ff7d3154300acb6402027aa0bf912d5a221588a4edd7873c0928286e0ca2799d8c2e686101888c0c296b1f1f350341972832ae61612fa981a92609564a063f7307d0696fef502a4a320afe52e7930bb29bac801e4a87b8779cf3477fb3f031716e3d1dedc74e10304d164d69d44ebae98ddc0d5fc79bb86bb98c7e5fe24896a7424edb5be1ae5e7ae591d2f72e92658569937fe8432b24dccc0f59c4954f348c1bd52c7baaf4c83a3012bf0589dd585929134a8715627849afc4a32215d4c230faf951e2a08548bb5ce0ca846b042e2699ddb156362321917cc2827aee4f456fb8533c2086d61d704d5294a0862725ec3e40d719149b937babe661f45242347aa68f36dceb0359421ebdd14cd4c96b9c5f61a42c2465c9cd303895fb1d7678fcf1e19e4eb77f4cae58d80fd969fe0072e98057da808d956ec00b1b3f468640b840bce8caa9b6ec34066acd164213ab14225d46f133b1a8d37ea34def90add6638be6892b6146abbb020932a7d94ad4d936e5c9739238cbf056fadf4e0b69d6eac2d3952aa456243c0bf1b8853b0b58d3143459debca0e62d2d7f84ffc5416be6f155cb1c95ac6f2c3472b0fad3368faa89c2899997a595b6b99d33b5b89ea22fd53a2192b75f063d4abb44980d239d34a2d8c682010108e9ba2436af9720dc16418a0235685610bb2a005876eadf12d08bc91cbfe8bcefe2e6f88f8b68146e23b2df8442d7624967083a84882e2a7e4b62c9f52d2c0b969ca9ade310e9820fa5e571d992bda0caed880b7fbe41bcf8e257228f4afabd2e45d5a23f08e9edeb089bc034ff06fa1b0031153d1a2c32957129b360264989ad1d0e61a425e54101d1a404d58008cfe3ba4efd646530ab1d76e60ebee971018995f1e051a0cd3ac83411de6847e3bfc4b410d82c56048cf89d314897dd13966a050c358060a0601d768591ce339438aaa192999d46bb542b6a2b670a59be50b865c08912375b580ce0c6970b507a4fd903548bb074ac438c375f82f9f2dff45b9c3e9064581b14046b3ce117c6563c8fbe5774039929069b767506d4844c90dbf76e45fc06bd24de529316077172fb6291922ba095b18e4280146481f1fa3f18785d3ca5cee2a7c33814764975a62c5c5d926aa7553179f1420c5c31542df00949603353a9f72b679316fc9b43728cb6ba604892c7c7febf531878c936829c3ccafebeab28f1db99d2552dd0bf036dc620d0ad264bdc289dad00d6c8195fe2e2a016b484ea6860c89cbb9df16b615fb1fe3c9312a7810ec505b850fcb76e1289a7421e81c1c32cfa054183e917c86b3fe77d52afab6f730dbeaf491d8c014b94ae4399d34aa5eb096b490c1455a5370ed40e593bbd9466947f89e50ba166126c67f78f931956b943ae7dcee02be419c2b24c09a23199bc6f14461e8ebd76d37011913be9863f2c36a4d460a1b5b0ca2214c942ac803d50c83956f552b464520335d4731816c10d09faa9bda4d51035c5ef80ed37b3e77d369e43cf32b97a49544d6eb0e3980a8d75de7a62193cd2f9833dcb02056dcac33be42a08a0f1de91704283a24728202ab07e0743167dc334ddde70cc61386bb68a3331353255cabcb7ca71dcb2732a33193e0dd1022103b7aa58e885fdb2dbccf6b36b0ce319776eea029f81233bd40729ab0f0326009ea4d2802a3f74eaa0bd94d7bdff0e1295cd54f08fff27e75b141fc09186b6922fd0920ceee2b6bf90d489255e34e39b06941020f425cb2e32726e2d4e421b7b54e175bef3f7d400907db649fcd183adf900482e9ed95029b57b26a6ed1e8ce90f1afc37bed5d2f162d4649576514f6635a5ebc998de0cca03195a4c609dd884691d1982976b7c1828475cd4d41947313ddc84b8325d426389190ba64352c65b8a0153ebeeb5c70bf43620174cc236f9dc3ea6cdbc8cbbb33d510f6b1ab3bab8ee53da0312ec3e2fc3a36d29fddfeeb00a639ff14621f4985cbafc32ac2d2ba4365119b814e818e54823d70d93e60fbe390e1fa7caefdf5c73183a4e97ddff8b59368be0c039c74ca8cfd954343b4d4dda64877f6b2038b3a61c85e0a30551b6f2760533d8f0f1189c131e44838f9f2399ae4361309f9db40c07dc884bb7179d66073dd51f54608263873f7fb41b2c9de68024cde00352f5d5be142145b650cbefbecc38f8132f260aa9f60cbd4a62b8efb60d88b6a4746fcf751718695ebc66ca0f7a0c19073977740597f25c8bedaa2be43722ea751edacbcf4c7fcb596532edc038d1b76bd92e2d8d5eb8770f6bc30b110683d7e92dbdb771eb60e65e2e27cafa564bc877dc11a5d706d5eff10b0c3a30f0c00a7cb57571fba80265fc7bc24fe589bf02b7c559c1a0b7bfef94a295a384891f8ff4f1022b507f4b6f85e308140affa457e673628a196e1cf5b80ab982b69f2a3a33d47b69537a45b1b37a03a91b3fb8802003020dccd1bbe9cdc749d48b136480804182069ee829daa36993864d9a366b74de387ae8e8b1a34776a054ea7716050224718a01ba8a639f6bfd296af672e4683dc7f8d38589dfbda9f99f7ad2073c266713767aa2b44adeae180eaada9f8227a9e7545a10de628bab14482428a032fba7b82626b04d15bf5b44c1a53b185ae5bbff76f40bd4f9e2e1fa3f7906889e04e3e2fa5d46a202cd5f391ab3a2b1d1a5956d0f8373e27059933eb56cb0e12e96071b0f1c3f7cfce0e11ec40e2b778b8914f9ab089dd8ded88d05d6427ba9d8d170971287c728d0d91bf4e203874af794cff8f809f4520d0d6c43746ba111869eec1cc1e5b7aac89ca72485492d39398bc0bd20d7f408f5509afe3042b6450f45c6751cacdbe07222ccb479c6b30d4ed3d41fa23ea09a1cbf5a0161386e898fd6ef5d4408fda04440d473fb2ea51e913ce43a66b8f15fd04a08a138bb15c053481994e48185b11cc27eab1f3a29167ce978521ed9a95b245a0af982fb4df7cd659e212488f0b77f91ff1b1b0ef0c5715a6d3bc087f397dd80634f6bdbf1f94208b8124a71ca891f0e35d72f6b972bf86878c978ef79af69cf698f69af69cfa97a0754580ddde0f3872918f441cf5ce19f2b6b89d2e7796d0bc12aa0713e9156c0c1ea3929333bbbcfd51a3a883fbf071539e7736cbab400da5e3b15e8f4556182829b6c95cdf49cb65e417ade27c8a986b9216729b7bb85e068ac3caa5c292969acf73c202475ccfcacdc9960c3c184dffbda1c829f053cc7ad931d62f78ee7982358144f86eda47ba99a1b6f6cb8b1e1c6f7fa9ec7dc3374957ab743d22d0b80d91e56ce093d888b54813166b558025b703da19b025059324469de542ca194da81a6f6a13b10d694a755b4fe4cd2fa77dd46b99dca8f79f632c4e82b29e4a5cc0f83c91e2aa5c0658825e1d0733b9da9388af557e80493fc2b7a218e0173af5c39bcbd8ac492594e8146b5e6a10c3dae2c0cdd1d83b3c0a1bca8290d35df866394c02a85680b7642f0a93f6b63baae08d3c088a0f967ee62b76563a8b006d2435c0bdb5717300b8133cc1cf80b27a24f70d168b0554d21b019bdbc60549d6da3def24a7afb7d6589a986b463fb0873c338ea423d0bbf01914915cccb3d21c365dddb0e0b53890adc40421f2440218626d61827cce35e269d898f64c7aa0b4c8aeeaa9eeaa2adb769dcca962751ea5fa62851c5207183b7272638a3f8abd7d9cb01076c8b4a8ce23a9a1a76da1710c0ecda73c403e1e406f7dfc7e1b437095a777041c97351477768bc321ad22edbef13ae901dbb9a5ff29cad3b4a5517de306045f4f440973c2055a646185009658164678174522b4babcf0b8a34ec8e3c831ab14deb6bee67db4793f5786756f9fe055d470b47fc552a7e04e2c51b427d27200224a5ce4f4b62d30b1727ddba08cf40566bb1a775191c855d9b31127126b747504b8f94fcda0ba4fceb78ea90e08e764f2ee7d992283e2b06fd5c7b6f40cd05cb4542e29f69c67a90551ada6446840f356ca8c7e2d6a106e2b675d1158de0b45c30312be2ec9700f93b820f5f7e70b15d666eb4cedb00ed63713a4d6d1ff9eaf7a48e5b94e777de7e3a3dc4065071219cd9e52fa35bfc52fa6532d1928587fd7de6af7f3326afab7dff7f8e9bc3db87502f702d8385a562638651a5f41f876fa840e09b008d4f2170e9cf64f4c47792f41a504828d8a41be139453ac62871ce86a164899ec72cde49b7845cae5111b40a67ac88470edb580ca3e116b6d8c2c10b8290de444f7f2574ba51b06dceb34dd672f152c05378afc480fae0ed7f59dd774067007b19e302ad89df7e8e9c67d82a7d960d5ffc9f74cc24583d489e6162373d3cef3556f114c08e383035fa71e630f46c60f5fe36f18a4bb7afe7ee6a2362271cf0b5813711d323e4328d50c7e7aad78929b290844cadecfdfb33e79c43e592325d3ad3154eb85ef723c41efd292c877b7be979aa6606c95bc0a5c6af3634c43e00fe76e6d8cbfc301a3c2fddaca58e2c474826b5be7e31ede1c2aa20d3eae9cce47f18780536f1b067b41813198da6cec7d70d7482264052801e22b56f74118e65b410af3a917a7d6ed5d0e3f3d8b58f162902b7fe2afcb212d0093cda51b2aa4996db3940d26b9c1d550308241e748474c3f9cfce8bfa6c0d279d2f510e66f3d938fb0b947536b40d8d65da45fc21e09c563074b2d822a4a4351597c097264a29aefdb92a8256d0d4d8f705bc11bc7f38a7806e395bd6b990389c3f7aeef5641e9a3594ef8b090a313966afd23b2dd552c3a7175df4b6bc990f978b67818943ae834b2d8425f033131798a84166f6edc6cdbace5ca0c98741b29c4a2a54d1aef329b22448339256d1c3cccb68ac7edf8c3c40940a6909a5bff3d94bcb1bc2c0ac97619716f7b958465d94483c39ce9d9a36603f60648936f118b11233806fe3ec91e180f79d878163e9297014e0a8de8afaab1fdb3590b620ae83460b84fdb5ba2907fca0f173d41322b40b53cc0d16b590a7dd72c600296ff822f759b33f42c6ebe91acf7be88f62305a5cc340466a07a56d26792e82808e047486de732391dbbd1f969f970d08311692d4270c4a496ffcf85b78a3b60c4b94158b014a7870a2b0f5c3d82d04d38f65890356ff4e3cbab4c0db5c4195ebf203ba00cfc72b07e08e9d290b478b9ff9601ad210e2e61b5dc95367e8e97c88cc2c9f4da04e6d550acf60b8276da18bbe4cb35a3b222974d1742e8a4bba6ca4c03ba4335b75351abbc11588b1c207373c38f81ec18eb40c95dbe2ac2747fbafebe0705f4e7977dff7e1c17ec5922ced872ea471c42a24b6f72d0b6fa5352e437d91c8e096df8c7612402c939d7a7d9710f064adc36ea09e50b38e18c72c0841ab1187eeefc40f38d3f885d270f3feb37e5bdf55d405b5b9f583b4ebeacbcdd32686f8d7c4e41f559e93c5202c92388c7c00fcc842ddfe4e27bc8da8810b9b4cd3483075093de3f7efd110ac3e1f91197157eb7cc34580e37fb132d3e1c2e9d8cc2c65a3e64e9597785f8e0462214517da39555bc24838210c83bd69e1b8d21887eaf65da6c2c31a0663f04192d4f6c73544a1a234d9cd97678c0c6282154242ee7c4dbe412c25d1e6c8901a74d4429fd9f48310a16292c89821fd538d8a2c70d674824cf212531edb2333a02ce7ca290258f40ea654224eb2e41fa902f020cbb54500394f571cd87ade4fc990b79c6121496ba280c48db59f84a3986089af04903a780de23e6f97b38b50c3f6b7a055e4b9491a50c1c11e4c27c5a0aa46c56adcb0714d0d3cbe517453a98bda98a57e237e9c3cad544988ae86a6395d71ed623c212a5671e393739554a23b52d792e8d6c2b5bba6c1c71fff2b0d0840b285a3764cd20426c770ed767eb2822b5a85bc024086e78f64cb0a68e5d90ec9c1758e031b88504ca3525566f21cec631c62dd9e035fa0bf677fc463c6302101fa08417680b4b576bddd1f43ea6808934f0d581c633bae959d905d5b648b9d3a6f216d470e680219a5bac2280f41a727239f8edc36735d3a12337461039f47ada3b5330e61780d8c257e742e8bb164a387e8c0b38c769508228c67be5fd7ffdcad637b621d5579d5d59f0f9736209f442b8d436fa28c95f58c4cfda639ed90e72c6053716930786a685b5e659585fbae9cd035c9a8ae3306d53246bb7df668c937a17b985cbc5b64e3cfac5d922d0dce0c29833620ff40e674c4de3660e4cf6ef3ddb05f761ac81b11286bdd35efc2343c3b3fea73df5f7ede58a25b4c0c9559099b81e4013ea0f54bd62d66f00aed6a8450925bc7fae06aa80ce4c27b01741989f9511ff060ccca27d7188ca86cc854e1f950998d9ff04c914563e8b8e2ec0190cf42ab43a24440daa589f9755cf45d325f7affaddeded43192590ca201faec580c5f1f799e315b374d4806ed7ebd30357dfc8216d314622f8e9732d71d660c97af5c4ff7a87df9e1b9fe31eaaefc4dc9762d39043f9078f5bd5299ac5c27230a558244300ec589af4f4a4a93d74eeb5e11fd9b7d67f96a12cb23cd4107e4080abc98814c18fd897890c0945e740380e1c08245df48cfc9126475c48afc1f46fc2c0978da2af98e02e5a00b28134609671efa2710adcd3b58dd2c82e48af6d515ce29736ee8cadc2431835add7714bef0b0219fbbffa91a112036de5300b02d9047adf251aeaa5d3faec60b885788628bc433acc73387898c7758700d5132f99b352c910a88105844e78150b4e0cba28c4a59f3b7b86c41868039a3e82a1aa604dd194183e70b1b0e48562e2445fa4c5787c2fde688b3dbadd1f7849c85cc5cfbbc86436568471902b3bff596e752c381b827254e4f7b7fa38a47c4a1d0dc403df5976daecad4effebd52db35c8b1ccb5bbffdd067c274ec79636f4328cae49f9f175b04d31a50c84be5d2015c91f2fb10fc6f233656c7a03d91518f102ae07ee8c9a476c44adb4eceee03fd1d43000f323f0f14b8c3a4bb3de51eb203e415f2444595674c0f92f484fd60946f2084d77a0845e95a066e29a28a5ac754c00111d233adae3d4bca89a71935fe7d9670577e2cca99d8e53b7711075d99d0684dcff914cdf618eaafc1d863df69eea9739883ba859c89f44eca8030e492b660d9d7f20db373779554feab11799cbc2d561e00b7114d27dd3ce9a43f8883ed68344c07ca66bfeb46ca66666a970d8ef7cb45abd75721c1ebfb43699452256ef5da8092dbb9fe011201ca45b4f4c5a754995573151c33981b051a6c42fa5cd4aab78ea06e0a65636b3e91ec19b1c900576844b319f02c54e67c9e9855bda9d3369cd36f8601c481c1481f286dd95a1f5e7ca85a8cf3c1d00a53638456f5e5c44a6c70c611ea292c455dddafe632eb2aa5e23d17bcfb9b3c3817537614a777d3213a6d50d964e301bfd48b065df2061509e65c112fa6d3000760664b4e3136ee33dea530e6ef33416a346c179cb314a32290bc666a1a53a63fc7c9c7c0e694436320910144f5b7cf54afc3d665d1e53a73baba166f3ac8ec289c0eba3763591abc292de5130bea34c5ea701ca4571534ea6db783667d0e6df71244ce7ee47e434ab0da8b333bef67f00cfb0b16ee6d0b328b5d9ab3c1beb6b25dffbd14a678e1a1541d392541bcbb01267f3231416d5a1dcb4f78706500a89388a91587063eeeb6c54f6e799e0415f332a4bc5117e574418688f2a325954c300d5ea328a844ad75b26e3aba7cc30a407ac17a417ac37a4076cbdf8d66af06510daadd0f4cc7428cb6e6203e4f1e9852907ad727d0a9621c7bc0355fe01b21372130ee9d63c03d83bd82e8d619e8eadd7c6f3ecbc10317919dd42920906ae56975e2c2b3153edbb3a45d3128d331bcf34ce3bf09671ea2bdfbc1b796d61c336e8684f9c6bad4225a62deee5e730effa054d26da10b9789df2b4ef50f20c71821799b626bf24bf26bf27bf257b277d2d124e7bc6ed3036e1a82f3e3c875af941889acefaf81700a2853af0894a42deff452c9e121bca68bfcbc30c0d44d599fa5c9ed20622257f0bbd84b28eb728a7f44ad0d7991277019f604415f5c4c4f554c831ac11a5a5eb55f6fef1926be20f1c3c78f0a0816ffa848912264c98b888e389099f2934c5863d3a7d2b7c66d8e03e5f8fd04784de38fb24ad38a1ea0418656c19760391449bdbd2a87bf0286a728e006b31e9236dc08881c0f75a38b9e23b8c823e50d7055feb6fcb3ba9495ae0f5191ac6e3a7d8945d8f138733359cc9ddac0f84ae4d576cec400d46fae4aa2aedc7dd08c83fdea0accae273182a497503a5046ee80c0c1b977b73e638815115ead8927029be014d24fe75831b727f2ac0a642bd69165181f509d107abbc3417287b9f584e1f5a02d55bc453f6bf03e221f921d56b0938e9a896b7728c3a061db7d56c24c3956b477f45493da8590f2e83cd946147ff460d8ee34a6468cf108f25c08e61b043110c41af3e2df968466f7b7e031c913651b2f6e9664daad4a911719faf6d10a46f3cb94f1004078508ea732d84423a19daa377b32c94049c843b80d2cbd23b0c3413a103f8a07582a33d7cf474f5d9f6b251f01b8add64f80898b3f5805caee499edbdd64ffce1796c058d5ff8f98236ab7f6240708014b2ff1fa350470aa24a718c92c2578e516009c8785a268a6d2114eae682a263528f45632a3a6b9940ba131c6e0c9d986042a2098927766f3e3efae8f1c3c73d01b300a6559f88a9a300c86e1bc7081950ab6320714af9a29eb7e87b411d43e4cbfccc4497c41a95bd126130ae716e024cf024eb570227f253201f7b7c4de1ed69105d9bb47c7b7a2baeee45d0bf987d8d545b49b99a4d230490abdeb558b68346dc7ae99b81a3fc9a00784efcbd63ced80e7579c49994745fa8b5c692c8c000f2e49a119835f08678bed21f8c1f1de580e2a318f49ab7f99a89cd4cbff43d22fb06e28c9743265d2b9ad095d6c68e10b6e3bc0f27789dfd9a9f4bafffdf8ba1ce60de479cda5fe6f5563a5c92946ae016fa8b75c3b031886a8bf5373eed5abc7c2ca80f620a0772ff579dc8861036efad7e047157d7abfd8c7f671c281c2eae23e7a0010ba1a40f39ead68bfc27e5969cdfa4507b01e6c7b3c4b4ad1769f8405d203790bc3e7da55b7ae146a679be67fdf750da17605fff1383510b69b804ad11d96e7eb3e61adb8ec517aa2560cfccb38394668bcf3d6846d529859e50fef70e2536eb3224cda6fde72708858fc24467d23da4909718e983479f4e02c7bcd765256f78780fc4339f6d3be37b16af09295871c474855eb3569b7b66fdf56a274d8c308ed01ef25daf40273419da7a8432c0fefedf52ee4922c3ece1d81486561b4e25d861070c32de2bedd0d3afca2a1e99f6638ffcdd5c66e90b326a5a3486d356da38683a6c2c6bfe472d63871a1458ff20a5079c77ff9b6393f9193f31b602436e7e1596b9e93d2116bba18a6092b95af7ffcf9cbba47f861d67e59625f398c071dcc5ba4c62387c266ac3be9ee12e2ab65ce7e27a874bd0a857a2f8ba5ebba1c84e1b2625987ac87df29c5a19d786b419c53411eb6918cb80d3bcf14d920ec19f14fce660fec49d0836179beb045eb023597b2dd499741d5eefc1c461c41f4e36f8464f6ae87c7038e743a04d50cf51c4bc0e63c570c59f80cc7d18521697abc1f7acce402e76e7075a47bd9694bd3e75a4e4913b28a525c731646c7058f95a99708c7585863f77494a34e51bb599182bdff91436ca3ed3256e56c09feb5cd0e6fcaf455be577b25ea1b938a3ba57516e0d273ca0814cc48c10d741c5217cb972b48b32a5a794ae0671380b654bbeab3c5b80d04153ea77a2dc7cb477c924a503d451978cb906b517ab7348f9f4322ae1cd1d12062c886d9f0335b128f8732ace84591d3de0a086d206c5300c2ab296621006f1105b186f58b3bf88a4fa2351038314baac81f59ac21257c62160b32d9fb12df90d67369b79a3e27a3af047482baf1a257d47b55defc1b575fa056056aedd7a8833231a29dc68bca634b4ebc4bedb6fcf26b49e29d839697ddb0e9fb6ed123b74ac7eeb896821c30c962312dc92337fcce6e822ab137638334aab5675fbaaccb6b009f08ee3a765416acc07426a83c5a09f1ce9e2d626441fdd6ad8e7308cc6732092f9f2eba3a8abb7138a698e77a3592ee64a14ae62bf80b9042baed65450fcbd29d0467f994ba2ef977d73e127557a76bb66caa0b4246f7ec4734711cf6479875392d3fde47ec89187593da720ad307314840fe25bae5c3428bffb297197cc764e3145329a3578b36a398225e99066c86723f10822f310742467889804e637e8170323d2a6020494b82a1f0f9aa2df5378a22898f078bba58ec503746621984046dfa2c8e05dafb27ce3e22d3e45b34387696d09955bec4daf0f26a0cc8e403b77347e8c7f7dbbf8927264d9d5d0d657eccb891c5a748383ff587fb2ec28152964c0c6bee87c145d69f5ee3b5be39cdf72733641f627525011e565bc3163bfac37dd0a0f761cc3b5849cfdcca427513792bdf89ef5ca814aceb334876e113f898f8bbd25365e01e351c3373002c56eaec5932a754575a1b42bd4074ae885682d8ed30119bfb19cb85c495a978bbd1fff11ba43f569ec2c8fb17aaaec290b051a5a6cc91863064577893e0eb741a0583aec2469725990815c3c3072ddeadd62b88d6a1aceda3c434de45e92e6e0be6782fdcf89bca6a65ea4b431cc3e9a1138d1491407f7985b4b25f09be04f6fa1a8a21265148cd2fef4c9a85c42018ff28192d552e94c5321681f4a10a5eae7cce3df4046a364dc58cce84d92a09ee24449ff17ca6d12ca0e0b862af8d547f323f4607ed1e147dcd20f17550da1c2df2112d53b31e18439e199592a983c03811dd32b055e599ea4c49b3159806b4876565cfdc1f39d1848f3de0dc86fe055cef508894c9820db2aefe55fc803ad18b440fe22f2c7cc0f4227a1627c48c316e52a9191954a93a4ab3944771a1c1aa7f71f642698b9a4e145c5a46319f85a25f33742781374e0f98a8ac27b4d1be132e91418f4346f2311993619021921006548418140bad7c5f9c2eb688a5748443888004ee9817a4549721f822819f07ba45194bb9f9db538f07690a5c6576af423e60f66450dda97822ef66377f633dd0f4841733cd3b98524bd1a23a458d44b0389327ef7c49605ed215df4eaab4a73da617c215b8bb8346c1e6ae91af64e5a365167148cd53736c8a765da95af99517fd9cd575f33117a476c11f9caa0164a3381863d19b4f7c6218daa0d35b4f2053118abd0a80e5994d7433064c5bf1e165368e40e06f5b3dd641d033e72f75444b5a5c59bdb4cce124316bb50965202e71324114ea8ffcf4dff4ca2a597510e0f4deb8d5f609e79f5a3dabb0bc5bd6db26d71a1366db0b06248ac16cc1a70b664525215a3dfa74893e0f948b93a22a8244774b7270fcca1580f3489600133ab779e9fb9031698612af3a21ea39a732e5393801a27671e436e8bacd61c635e1139857ba3319254b0f9407c218fbb298cbd346da58086c6b8731273ff240ec16e005d3e944e526ea600a505adcf30f52529ed8b50b25048f032b4cd308f8b218e88732a70abe1bdf4dfbec4853c244e17617157a101eed3e3c22fad748d6394b213fa200b97e73b06a335eaf344c1f56f5bb60286530b4560f71b105189b5c3a6e024f452f6354dd06df6d78eadfd5b2dba35609b7c7f8bfb303717ab9a2086ebae17300422e2215904a0806161a417b7cab83ab2d09e3c39afc32b9ce74c413b161ce56f1fbfa837ca39097441720f900872d893c45a2a04f1c10002b20cbcdde42ba91018379f3d86899083d33d62436a539e15564df00c5f488da4d6e2340806d8eaf80d14f202b934e01805db12650a5d7689dcbcd606d8d4ca08e976179823af52db4b14660370b18f78920502d5e34cc4e957e172092a0831375994301c842a1402c3f4adfe04cfd1248cc3cd69b52505b8add69e582c254bfac00dbbe2509552cec9f7c6f2c515e08b51b4df91209ffd407fab9647eaae3a8e0ff89da5851e36d32e03827bcc26ca74ea43f516a5c64e44cff3a0f5d3672192a777c0b9b81913794ec1858f09c713512448db04f3f134f624a78c69ba329656505baa3cc1cbde45482f84584b2dd173b549b1aee32a30d095503ebdb76540b4658f64cd0d9d9e3ecf534082bb725ed872f2d1ee60fcdf62c5fbc0f060b28455a6fcc50c4c99bed6a2b81f359a149cad2630bf00c8528cc579410f8ffcb4cd81153317c07121496414a9967001bc5420ab067d2193adedf894c69321f78ea6209d84cca665a8cbcaf74ac2dbc6497b65efd717f66c4776d3e2dc3fc50237b2c70967e25c952af4687542c846f07d01d1432382f77e0752799355245e6afa4430ab7646b79cebea4a4c7ef27242edac6a129a1c661d6e10ad442cc2d2d580b8d992016e654020b58a8851481c2f1a13de8b8ffab8f5d58c508e7870b860f84aaa211b0bcd4a35149bca3c9c04824212029dc500be6449ea68a3ce653e1c7b91d143a5a3796e4ead9d14952af58d32259eed9156637874e4d1b10787e4fc1ad0c0580570cbcd9c8abac0288ef50b020e0fd5d28a40c15e76d798febe7f6677bedbe89af4b8cb5cf1720cf84fbd464ab7f2c0d8d65a890edc492809e7b5b5ccd9532f32925d20342acca2f21b8ff110d0573b1e6ec27595826fc9e361104511871726ce24bb0c276f6890ab3287a1c2fab7866b91b62c80f9478e58ae4c1a4620df9592121cc102ee67e6a1a605655191d0bc1942fb0fdaa7311d24ed3126706bd90d3fb9cb52d3945689ca9250a8798381f2b0358bced03440c04a69cf10cbdaa6081179aecec2548497aacaeb1f67ee51115b815b8700988550fe5b6bf804420e5930022ea2566e8f68d030815ee1b44bd2cf4f45356d12a1edc34ac40c4f55d92c560da4990871cf9a2cde5cdebf3f1d0e3089bc8143aa7cf3f74e5a0266d2a203ea68de5326489ee6ecca908413a26c7d7b64c6e16586f63c121fce824d61924c777753c4f62ecc22246946730f2234c58ede950ad5ff6a911487911f65fde597c89fd178c9ac28d469670d80af41ac6cedbbe0759166cac748d8f391e91d5e42ba62c8874104af3c2d7b307881c42b4563637e7d9c17ef8138b82ba7a92128116eab0df71c73b0e387e7f3c972fbb60ebb5673e9fc1ac068c560a559533dee0b853bccadfcbdd92783b8d6ba6253b807d706404ed81fe0fa06174a2bc40c8370e9f627621e213797055600388d60ab8032f4391eccec292d84b80a602a5c33a238721f4a1f83573d1590c52d2a3f888626f89985d07ad120568485208be043bab04d4e955489c9bffcc0014af13dd194e65f63696a4a0b0d11ce5349c25f567e53b0451e09696b118c96f29df3774b7382f553e1242112c81040d9954ae016f8c5c4e003adc4d94debdfb32f70871d7401c7e4b07c100c3dc0b52c1b527a3c4d4af057c0471a568207d0c817693953cb16ca7cc4afb77925992b027e6a5710b4130290d48bf46366d97759731a89eb746e10dc3a5213e8d5e11de322f309189297807d2613709bd893c12d29c6383b91bb031c1689f778fba4495b5b22b43a69ab11cc522e75f651c76848e5206c041b0e61e6c2826c21201689b83453cbc88126598dc33d5113569d39f0780b903f6810b9d561acc2f1e2bd9009a58f6343e953b5eb1d7d668281eb3a152b51b156d30948937bf6ba8ed305dbbf85e51dacc62c0f126a93eaae02e837cf138c8dfdcf402bbb7947a23c6636c71d86cfe5315ddeb003fe92ccb7c5a6be802cc5bd32c660822facfe8bddfaec8fd9eda8be9739884af33280f620f22547d657bd01102463bb35612876e36a9c643c2d8d1f937b64454954ff2dd873d81dde14bb3ef2df33d15bfd7da3e2c042899230f30b7e2d989042e150f70e6cc86fca15eca00f3134e0fc4aeb0bb31379725519b762687b4b218307a14ad2d82835239afb2a435dea8e36abae2878f371b2dbdf769e4f8fb6918a23d877472661eaacef091a8c3e787354b419707129027f484ec1958d34d4967cfe13b557f80cf49009f4b312254c3cc05978c096570366e5b098051937edb25037ff2eb99077c349c784b2aca5b8b0435a4a4f243515ca6ee44246dd648260d641326d7f220bcabb2b69a4b11aaafec239aa065e8e096d5b4975699794947e496a5a885dc8050c3ac925c880af5926b7f32846aa24f69e6f1cc8fab510047337c5216650c8f77f59d39e49b41f898b16b74b8662a5e95d3ddb8bf27586044d0d509ecc0821f112ead13e9ed62debbe80179e828eaf47e55a799ea7709a4eea6ceeb835bdcfc893c2d956bd312261f300d936b5410d4016c1eb3fa31e3a9cf257944f1180dbff7fe078954293fa560161de72673da180883d6bb725d54efd7cba3728c2b8feb2b5192e2269d0a459914ccb081cbc4ff39531184602e12f8bd9af70ff7787ceaba3b569c29754bc2d1260820e2399f90559aaa3fd1245cdcf7005f672f315ef5c06e81a41a6a623101781e0af519178c04dfed293303ec584f48b851aec1e4f42246b8b9b3e510506674456b6f2ddd951371941a54ff507b6bb55f7cdcc5d6a3bd4008e16de06d8b80b34218052b9982b7d9bdfbf57ae65d133978c886e467139eced4204182a79b0712bd5e1dfe57382fc67dba3d8de94b30d508dcb6cceab09f15b4af8088ed641b4fd4967e9b5a39d487c60a4a72584894c1244e5ad414e8146b685af288e2920100f0ac11510982c48fdf350ed43c05ee3d4bbc2da0bf8837b1d9a072955d9022a831fee6dce7e2c7d916673160289c3903238e22968548435d592b1a34b0f813c67295c9330138caa68f18e073c38acd159bbc14edcb92c6f3f848709797c637e47bde5f644986bc25fe2b67d614eba0ab821ec4a4e7aa90be9029d87c05d53bc0dd7247506de99c35baf7648d4020d31105d03678b9ac66c3a354e1dc86a8776f2bc8b9cc5dfd0861d0e6ec5b431036128ca90d7b4d62272c3a9626eb7ee8af837afb588dc70aab8dce014154d422b11a7f0b6274e982861c2844bbc14956eedb709544d2411af942ed58f9d644e621a54ea905babc8c3522f3495ac024129f45ca9f35d9f16c92289f357e0f565059b700332519c40252f28c3bab5548de45fdc04fa6843b74211199c798ea992da92447488c1127d714f74c8d27fe75cd6424c9d2c42bce2682e3c04975e4d9af50ea4528c2ca690362e5838a2aed76e28b211a51c3b974bd0a0571979173e7a85895a794a85d0c430c59e5b7a50b56ec8299704172b847bb19a771b72e503ec00681fe5d2f6f1bfcc3ee219591fc5c4ee03424d7d007c160df838edc791e80ff0b90a8f3f68f0e08183562079407a87d93a832ff3af391b62926c68ee5fef0ce3385f0c0ed6e9646edb2da625e38a8897dd7f0def5f2ac1df09a08dfed1386aead377b9bccba7f143dc7069943efd321076379cd3815c4f8d51e55a61a1cf18fe00ea7cd85af4a72ef0e748ca75bee93155dbd7f765d97d8c172fc519b3146109bb528581c3face9600d8a6d9b8981741d1a1da070c2fbf3e77e1b6b395bf6bb2e6405b9f66481646c8c60a4d69a6f3018b32ed23a0244980176fc7e4e060d4ad8039c9186e92e1cdd7f9ddc263d8e0d88c20befccdeacb4b0ce37ba874ad938cf93942099e05be732c08c08620544667b2af3b7ea3472d6b3bc950a45edb7e937993e0db812be415988ec309959840481766b04547d542a17c13b88083bdcb51a82bfd23d81733fb5e3ce94537a1ea9ac6b0d2f782a521cd479f14604a0d7fc6b7d4c8e3cc8a96046415036a614b00ba001db3b2d608c1feea80b2526de3e979ec06023b499ab7ebb872a0340d650b016a3b0797edf548f37802a398934ba7ca6cdef313097d150ba85ba87c1419bcc1b4b3893ba45c43513262fb82fa3fb5bc3c449781b513784c988dcfa6131d9f878e416f5b2c0e5e4c8f1040674a4db0e73ddbb5a7d258d290aedcbb1472bd5278459745ea317f36ec1173e04059fe089f65d3234728808200104fabba6bb38086c3acdc4bde01784f3f578484a68c0e45539b2851fecb7d84be54af0fe8997419d0dae1d9cd3401203bad7024f2a35795e8b6229255a9f97efc20ebfe0442d48c82f71d88a4b6ab3286d12c2d21798d7031b40490a494755ef398c091968cf2454574d26a3c132a3a8ad01f94c8d559a745e5ff646364d65924cc6d3ee715b34e6c9770f9af16d111c9026abe48ca7dbacf4c1d1a577f5b9ffe5c56b28776de82c31f6ca6abaed188b9197e74ac2ab03685ad68013f348d02ce9720fa70008b3e286dff2847ef1aede911eb52265e7099b623cd5537f1e5bbec103edaa1b9a442c34de64c54d82bfbea69218c9783fde6bc45a53432681f34f400754ee2f0ec24af687f7515e22ce12f0ac1931b3060ff86eca99a5af9d18a3f31d18aa513c1cbf806ad98b50f196eb3e4ccaa71b422cb7fb2055e3ce16e5d4a98ecb54310e223da7e2ecb6a5ab0c91cdec4467ad349bdc10193dda51854a6960ba54c3f6a488099cfbca44fa2712c8b3e4fd6832d086db15789ed869cb646aca48d1338474ae0127d534e961f7007bf8eb31b407cd6796fc55bde316842b2aa348ff310708c36264718be4cf407f85b8d59ae7bfd49134359ceb9cf01619540d14c97f85504e8e492556b1042a70ea4e7a5f87a53fc5de25087516285a1cb8ddadce00fff8cf32b99dec0da46f21fa66011f27819a27bdcd7236aa73aa3c10b57ef95c716f9c9ab46a33e8bc154caf43e367b81a10bdf06457cc30f026cd64493192802957fc4fe9316a235859ce135747df0005cddc102a1cf833b6c0060246617c35dfd409311cf86bc4f1184d3dffff4c158300494fe68e8d13189ccb5102fd278808e9aa8dc1ac5e7fc6a9144048ec4d0ff7829fd6196df6e51df108e43a697daf47589106829f5d7ef7f731f41d60ae4e292ea3936a8c8b00d8e5d3ee302a10080922423220f52ea48d7dd135fa4cd35d9ecedb25765938f9de012536a2edb092ddf6bab679133277830be2950104a76c7284e6d6e753ee83b7391d6eb0d9c005680c87027a9ef7413d9befe9a59a73bb3b7a617646ede60cad8a35606f11a7b8982d9f50e960db67cb15568a352d718aaf90851360671ce7c59d61e1bf1f35b5ef050623bce40c567497a731e037ecc2473a51d0603b0db3732f693e31b3a3e2d88dce3e555709aea4420309169cce6df8b3cf10f8ce72748cf44c6f42f499b1be922c63c6465489edc2e2dfe965baf1843f880d00b7acd583738af856aa4ab9107529c87dd16de8bac97c1e602cca6d4600939e497f161530640b27df87d320c716e17e8a530010e87559a6ed8b5ce128afa2c01c82c9abecc1703a4a7951685cd36b4dee92d856537527d711f0bc7364ec5600dd841e75c7c788330c08164ee94c1af9a4260cab643da74e8ee4c82139aaa27b49240c50260d18bab1c1f57fe447dfbba56af594187027d540d8fea2f0ca7db32ee7d2feaf3e8b7f9957c99b5f42b054d4694018125db1975c52d43cff53606092be8e62eddbd3c8a168092ccf099d264646487b1c9c0fc678bc7ba85ee73ec7f401ce69e16ea8c636dc2bb72ac5f6a9a318a33d83274f55251e005000d071d67fee0a69fd47e7c052b6bcea59de5d8654b10df31f0d2dd6fc72457eef83b8eda29d4f1be8775165bfc30e9ee57fa7ed06d83ea73094a82a568ce7231df17ee354d6b87bb750ff4dad7875c7cab19dd1e75117900ace33ff16d91bc99a1099e596145bb8e9076afb959fd3297d51f73b3ea6b1eabfbe645164d6df1c0df4649467e111ed87ea6a8fe102b6dfec4a7bd6f9cb4fd1f33ed5ff3b2ea6f16b150599bedea9f5132f330c3aa6553585167322b6da665e5d25456224dcb8abb49ac6c7bf311e4eeefeeae03670015074c5a7cdf8ded61f79f41c180bff7c0597ff31c3e068e98bf33de0e96730f078d5126ad2c5b23ce649672c033428bc539d00dd07595f8ab28e377b54637c632e01a89bb2169a3e6b02fe4918f5ad1498a23ed13343ccddca5a355a4633511349af27fc1941405809bc227b7eedf3775be6c2556ff740f3e5572244b47b3c96c5d9a20cda75d232f922b8e00b5a29f95904a11227c433cace623a3e58d2bf3d041a8a5f8776c4bff8ec0031c2d74e50dc735121fb92533b51a725a3a6af377d20ba91ab722e0cc6e0bb071e22e3e10e4ec4429459c4815ebdb42be56af5cc7739dc28ae3d3f4469fa72bac5192b32a868ac699150563e7bd43e82c12c55e8e2b71f237b755713cb57c32d51806d2cec51072e68f0f1053da0ade11ae44107b338b904a316b8cd4c8d71115289b27189f8ec9e5164d9d7126cc812d60a8c922af1c589ff5ff65eff0adca39318ed5b61c9c1482307261801a08a817ca368d0ac582d9608b0bb70822b994301343a07bea351b12d3dff181e4067a88d4b1c914043a753590e310262b388990c20e8402f121487da6ba53f0af889a220744534bec2f4d11312efda69e9cbb3babc249554820b76d7ee2eafc8b1b7c805ed253aaa0f164872d4526d56653e29c9313850b712781648c2bca7e336b04f2d9f8a1b4006f645d95f5c358c43e3025e8ba9eb89a902787b89b70d97ddcec36c9901aebf39182e8d20ed027290d7a3a7ed437caca61cc8a815721569b9380671b8b61f33a31bec84cfd17966a22dc63dca09696068738f7c465d70aa2c3c823894630de25af47738326033a6d5b7210649b891f81317adaa50fc50f5662c226ebd95642fc62d0ec2784667b30abd4a566793a80b5ac1c84a4ea198a6ab2e95c6215e952c2bb829404dfcd3ad3ce2adab1df09be3f4867069b2dc38c0782ac89eefc3bcadcb1cc43922457313a47f20d2739f33b917293adddfa056ee7424736688d5e4228fb38d0072d270112e7a134ee4c99054294280a359586857452e50aea84146e5cd41e4e2e5000c5c5a478595f0b70998549485711e239a3f5e56c22cf3a00dca44d356c19e56f597e02f54e319620f3dea37c07df7cc51e6506899d872f6d39b18c8b47fe57e7f43215471be2bd9acb6bcf1acdb5357743dfdd3d90ca035991d8b7df993cc5aaf0a44a2d44b4b46b5898662313b105bc2ce080190c20f81fa6de6c7710941301335ddc988291757259120ba1a9d3778242baac3a51eee55f5ee752f475aa10307d572c9028d6da3d1abed77ca98afbffed18ff5763b92af9f3b768785ff2b5aae6fff743d3f05162ea5450e4ce28783b81380a0d672d31ed1c9eaa2da3e4f7ce7115ab661ef2fe3c5846ec644e7f786c64a0c2b65124a8c48720afd881d1efcb25b8fd7436aa9d3af60cf82855ee29b57e050a08a0e8e5fff0b4b731367e08e2e28c4685fd050bc181938be78db1a4175ca33c1b7e1af34f1ff14ae1323c2b241134c800c54860360fad11417c2a3e8fe4cd7e324ee1219026bcbff419d65147a329235c664f7c41efdb71cb6af51f742aa4a918fba32e9ef27ada39d379338ed15919d358f0379a018e3887b81876c6dd8cb959dfa39bc06966cc5c3ee3a7584176f6c39831f019856bb582e852a3ec91d154571288aca3c5d310193c06c342df0d1be2885754ca932201d047ba69226cacf3460ae7a9c74ee9369e0dcabfdcc585a06e4dbf471b16918d36849fd2cad000a271f986f75503b55207854e63878fc5dc465c15cbd4850c022f2072769c406f2f1873ad4e4c67d9e30147809827c7304ffbc144558eb2020783264474a62e4173f134016230989ff406e6ec4e5910080bcf1f49804fc0bd9f08aeb106b86e6454e329d0ae2c099c8fa0aecbd1c3a84bb519e35f6e1927cac1d4259341a124997e498a1c1054098628ed3789d570c945ff55add8c6111cd4cb7d0762e23eb2bbaf13090ee9ef23bbc9a91e683118528f2e1f190e83277d911700226fdc9c26751977fdafb7e5ff32cd686951705baafb94925c1919f884f4daad47620a9fe07bb82c520f6acc57a158744610df0999b4d55b9132a0c1a0377233a6b554ea716f43eeb3a40f7707655c1c9692f72f254a69b827d01b12cc1fca2aaa0af191165820bd03340bf4aa0460e9c8347f41773ce9f4f7f146bfaf8f3a9ada0bb56ddbc80e8f6e723c5366462ca40d9b396cfc224ec943647f3236aea49a6c59216161771126f5a31b7f5985ac1fcc67b02e112f9814533c337e572bfa3e3878cffe80577f31414ac5085fd583d7038dd37b20edf80ef18648e30f6d8b94b144539959e2db2f987cbad3e9fa9e432e1443af212c6eafb3f8b17ad8d2ca4f29418b0a91243018e2f774b092e04e63f529407efa56fbd0686f504e41ecacf07d7a6f11b9d1bf9576d5c6f3419ade172d86f08f9953e8bde925a6fae6b3c4eacad3e84b14f648e61739254cb264b3ec619e612aa21bbbc5d56cb6566641dd03edc14a1f1d04fa2075a11eae9d31afcfe2a4def4d738070b6d23639fa045c47a435138a9297c41ed5e264fc0e60a6e59b550cccb35e3168bbfd74cd0ab95b785c9f00e92c495381736908060a022c15860c6ea2052cca51eb0e0dce741d74b19a6b4c68a11cb695e569cff05bd9ab155372173a10ff9c665d21d6c3d9da9d439df219e23a2cdd1ca19e5627f5ed78a89134a6c98e416965dc2249d350f418b00a22c34f4fc612b243095e4aef6c250079048b7814ca60a3f3ccebc34a2d10800832b76547eacde55f153cb0c98569194a364f371274c05f8ef9583818098e4d999ab50092f4430baa1bb37e2ee3a50c6dec30cadae058f46c6625aa22239e353f0f2057014d5fc03124f1999b8bb17d40b7e6af6b62de795606f73303323b8d4afefd30331e0b2e0e7705da37c1214484653543d0d38c80da6e09647240e6a61ee3a0af87e2c250e6a1ed064d3201dd10534b1418212fcccbcefc1120e983b2fc895ad0ef7a40d512e08c07e4545d6d7ca8cbf97b357ade482d72bf576caf9ead6a8879c523946a96f8e6d58502865451ae110ef23045d9480385e32adcda57806c073f3a75f89989ba2d950b0de925dd96518c1414da396301d9178be2a111ad22fa013a9a3dd5f31270ad34b7342e67a37bdd29cde9a2551fc6c60a6ef7ad4a44472a63a62d917b3cf80ab11ed902128c222ccb32f6a7b61fac082d3a45ae69442aeeea9e8601fe9c266338826791a9c937d11acbe91388dfd681eb7495a7280b58f582a31035cf5f524f3219646121a3805b0cc0779a11f0948ab256b4415d29d870e13302d5bd9abe6ebde43e977d7d9aece01791be6672ec824c0bdee257bcd290ab0ce650c8983a428e5e45413a287f289054f35a813682913eb9b41e80bfb94efa15613fe59e82b1f1da740d0958bb3b94bf372ba85ca4bd5b940f65bb5fea8a3e92605cc202accc05bcc60f998014266d0c490b946395f393c0e58e696c4a512430fc1579bca0057655064652855c0b2236832abb6dd60317db871b7e61b84c6793fb32d5cf45ead40561eb2c1044bd79c19b9687c7cdc3d5d6632e9f19254e3add8059cdc7f72dce27f9358fb56129a024be7cfa11ac889c19b6ebf27796fc96894b2aab1b7e971125bc85e6d29866b50172cfd036c226fff71a27076b7a6014f6c7a1979858208df4862b6e4d5761fa90856929d75446e355185da9454fa126d33900672946a3bb94738c7138d24276dfd39369f7b11e3f518560104fbd0d91d164d3659810e5b447cad43ddab7b5a9de9c839e437401fce33cfd5c0767bf47e3c584ec1f815cf7f174b75d3e8e9e504eaf66f2a7a2e972bf970a7c350a2520f37a6c7f13403e0275c9d7b11468b039f2e0155babd85ed53d7c6fa48863fb8c8f26d43e9261d286fec2cb52023056000c7618f0931da99658a8183bac3b867a3b58670ce5205d54443004b57ca45d77cc2ffc53ca944316b9ffa18363c3f1e3bbb01d5cbbdd8792cf73a8bb752891d3a00cbcbc753d84b600bb0450928a7b7ad6c80f1c99ff235124c26946583e5db12e0d8b2e0aa5c05cad90ff9e4754316f47b216b07c2fee80da09eb04c17f61369613c8540860ccba04b31c91c70618c807f3faa3071bfdd3e83d97d22dd82b3463597b4eb2008e7dee0c027a0ac455a8b08cfdebe3a8eb48ab667fa5b224e7dc7c27131f1eec88c5f9b747522865cd6c302aaab7d1d4e905749ccd008ce91b5141167f6c65960a26ec1ca55619ae34009d99870b1c89c010065417f8f5521c7d72821d6db42ac00ab2b72cee7c8cd0df0eb92e71ac5dc7eb62b744a49aacf6fe1975ca84294f9e712a6240040460c23568ff511ccaacb5e25af77849e50b9b97750facf46f324cca70aa020af7d7ed47b8f977c400970a4a5c4bade7666eca03347944f857c3a7afe275e2c53450d6b7e012babf16a612724cbd48ed697fd7354664c4a86fec974fd1742e664a07f1ef943e89609840f372553c39f8607fd8be4220b6814403ec27a2fb18873ebed45cb17849bfc2917484a226318ffa4a4126e8a2b7ea6e780ac2e081dc76ce257685726c2a1f77df078330986f43a60507a32389e51a861bf0095033e8147ccdc8318436344012027e64720a6b9b881747de3f01731a75181d22db1af4034336322c253c246fa4d8092756a88967515b9815019e69fd64b47c6fa2312476275147afbd32b5a829fef6ee1b43dd32e001d685e0473e83a6bce0196ca572c388ff01a64a9242c35b126587c9c36290104624acd10f511887609d3a83f415bc0e481c12a2e72e21bf6645771f0c82f00e3d9d7f7c306d570c9826981a1de4a7f8a3f4bf8b640a597b0caf478109a511369744e29627e5577754013bd235f360c2627fd1ee20a5f0fbecebbadfb5adbab78864df1c8579ed15865a8e1885b5fa14c21f74c6a19298ae836a937311c7adc2b0537861a18304129662ee2502f578c18e6359da2b03aebe05c835b7894404c0a4453c0bed4912ae5dd3dcd18c4612e862e66b6dd9ac84958096984665014aeb20d6ae8983c93a00c49406364d04328d5dc0426193819ef4b9953c02311ca2952fa8fd3aa8d8344896f41fe572981bfd93b31e283625a15ba029b8cb9c15ebc96688b0810692fc15bb22c9442f05d6272867133c32c7e33a09ee3d9546495c4abf60cd3905a861773e5063ca5586760cf76692c5a62f2ee4f3a9a3c2fa8c6f4bbacdfe98cff187b824e67fc2d48e98dd494e847e8ba4488c4619032412314828ab6b4450391a498bc2b41e1bcc8f96aeb9f5565bc347f06e836c083a084f1147b3b7fe483bcb73978515cfbe844b5c627e3d66dbd107c05d2bd13a38b379b90afef4c59b763d0f9165cfb1caa047c38454a895cf6406a707db3e8a5fb8e981b65593f785d505b60f453d236a08886d1cbe712bf29d41484e3b880209aa44b7b63062ddf682581c2e63c16313b519419a780983c702a0841adee739c12b45b214c008d84d8029f80ad2a050ef7cd19fe6be00188ac28fcbce07f5040a4bad684b8a8950a64943c948634f6db59cd1c8bb192b3188f178ee0dfe73007e63075366c7f12b6376d23d1d209de28dd1b65f21e232c29853e923f40362545a2ede309ac4a337012409b4c9219d15b40f654fde4cfc9924162d043a6ddd5c6818386d29b45da4e88f006b1bbb5d29c9bba239c6b0a137d8407a0c749f70bdcf5e897aff2773c972d79f08b67681cd9b53047c23500d1fd5411cf27b517d78c3764d6a022803e96e68b88df03009d71598379bbf68b4bf89fa3e4084eb9194249a33fa132fa45d216bd90f2457f5aa8e3426338ae4a59290a68710a94f0145f3229988c609817925a895dc274d35a381be7c149dd84496cf9f21ae6e7ab252146cb2b82a067931b9fc69cb03b6f4564b680bc3301456fc539980ea0aee08dd5241f467aeec1721d4e27cf8b8196b384370674301b3055340d3bb29ef109e63b4eb6f44dee2166191d0137c63c4b3c8068b8e560e6613941ac49a4366282d9d581e201219061e2792f15111dedf28bacbf24ce6e54390faef27393ee406d6baf334d1491425b911c7038f5af65fea41c411e105c1bfb10c7f6c5314937056148595564916eac604919b52cdd06a6f5127abf85ba41106e1f823fdaffb440f7ba7c5eb1366ed722c4077734d98ad7f264f3bb728fa4d7b1e66f8edcb289d75053cf74210a6480f6478fa9179f4b4f82075de9feb59cf95880bcb05f07f4c2a3fa84fdc9c828ab6d2b48438a543c70f6e0bb58af73485da61ad86c38abf1b034c619b01b5163f6ed59052855a398918efe63459e653904e4e3f0ae36c61c6ddeff5016adb09ee072d21e7259ee464802177c2ca6eb2d1669590197cd178817c15eeb27bf8400e7f6c4ef74f8bfa314c4575210114ce8e1138e58ee92a02698fc071900d18d7f0c7b9d2fff26ce0914a495d23afa8bc201ad69a1204363b44ff62f4a02e89e38c14667c2d08ca2eeeb115aba4fc1ef0ca2d1ae5e2b666dde84387ccbdb9fd2991064208350eee98c06180568dc261398f77ece56d67760336b1b27f45d9184f1afbdc0d47bd97e85e24b7f0a651cbd9c9e343a5cb722b20fc86adfab4f81684e19d1dea5ca9d8aad1a87c63da4f87c1f877ec88d78c5c85c1e21af9147572c0c278e4a5d47d40ac8d458aca2a424f7d050185488585b502911292673ec1d83208631f20caef8c7f1df440db7027ba07cdb9d6a6efe1c2b8e65e50801e817f7866daed01e4c96065c061a0390ca334060548fa4f9b1871c3beb3b87e7988a8dc9b1ed8c9e554d0ad3eaba869f987646848340167ef2d922ac66d0551392bdf1b5a5debf7b8a976f3e831023e086dc786133212bd090a4ec239f97d653a8a934a7e03244685dc68d03fa2ec047720bef8caa149ffb1930f2e82e30e41850152671ac258190145a9c9a1f6687b74a002e79423a007afdfea2d792154895c8d72c389e542a3a1353eeb32f76c95660a86db5b3e009a36c47d177f1e8f6b848a010b1fb75a3116f1113e3a2cc135d00d9e879f653c3dfe0e03a3003292108ab37828cde79dbe88507a8222db33f404212d3049d3b67e3ddd1dc96ca3b7b142a8fc23774f508ba379d809cd2bbf7a6530c4fe9568dce9d4df4ff4ac272469bb65c7fcad2d3ec791c859fc60a7e3f03528f4c93f3447c4e4546f48fc7be44a9160b1acd2f40791b3525299315668512064a1ab3b90ec77bd7e35e2bd5c7fc7fcd10626f4692db8121af29a7eb8f0cbbf0f634fafff550ee1df7465792827c5877ad34b57b6b69151f2eea208be33ed78370f0b5319e195504dca884e3cfcceff1913916ba40095888fc4bb2ff1d923c0e8d75a3b8e379b7a2ec8a05fdd273d2af337feecb8452910f8d3074e3ffb04c274d1e6244ab404865cbd8e20fe5807d2f15edd130c2533f809dcf0c2e56c9ddcc96ce470fbdd379523b5e4e304da1eee54e7ce5ca9fc91a77b9936bc990782e2452eece2ecc191d0af0d5e154c4460d8bfbe76a79bf3106d2438c40c87788e56e7c2039b3ed41d86798f616535cb89eb6fe002369f465c3c3c45b2e255f30e3d5b1f50b4d0a70755085710f963710000b138bf127df61beb151fb425c97e8027dff40fd5b7b5c57852089a502f735cc96c50a11c5fee0506ce5105f451480ce5e0584cd029ae44d635b3050424e07ffe4d75ac9f0ff3e065b82ac4de5513857739b9d33419f5013c2d4b4dfc2c81820705e9de9ce0bf5303528bb270cb5b6e93cefd371a5122dfe80e0e4c4c0c44169fe7b5bde441445f507fe43beb5bdbb37d93ba524532206d1052106db45e53731178e3ba632cf1554d5e63563b0cf060ae85c1b2b2ba05959c114db334e72fb1c6742d206308e9592b2a4f6356823c6b42c757e11131adca28e3c22b0649c51a2e6da583c31d7134a6564ae8dc5a3838b65033a02d524d35587bc953775ef297d6ca952e7f4b66ca9b3eba441529d37756e7952e717e1206fb56bbe37cf574d1778aa498b3af6d4aefe0d281366be90f94042dd0212e20b1e5c003302249a70d1ca3f41e0f063617de64f5e7aaadd04614ef234c57f37c8452978a84961c2a84c101f906981051ba03cb1628ad9822f374c9182030b4432a05768a9c112209410f3c3da3041e7bf01b8c0ea6422e907133416b7fe67200552bc18f920850b30b8e68bdd52c0951d40b19483182224e6b777749bf8014b5116217080a109570e125d2e886f7b3e2fa72f361d81f5e9df49769caa73f5c4244f7534b196ae257a377534d53649607f22a085461ada851198c06a41c0cde69f94d9258143952bd2bc608a225cbd802b525a985d3143e50b57ff2427910d35cce2bacb815947b07e65200c06414132df766bcf9099f2c30e24406346896b963f5a48b73a179215c4f0244d0b5484c8e189257a1eca472bad98cdb042c673e384ae44f01f8178742b314506241910482fe8e20aa186a323648832832283ab1fa85fa89fc50505e221f4ee9b3be76e72efdc4fee9efbe73eb91d2cf60395d06225669b921b49e612b581e8370415e2c162bf8d0f40732b3ba4ef6be7006f1cd811ace3f8395ddd4e003150ef59f4b8fd846a0e571704976957bf541db55414783c396fccdbe3a4b69f2c700bf7aba73a592b9538f77b825368863d591cf03a1667f827ece68093250025e8feb73a3aaec3a1573d19be1c1307dfd8ed9e3a7677b7dbd8428e65faaec6898637e3e301572819a918352a0ac36667f7c67fecee6e9f6e9c9c1c1c9d9b1d1b18545513232503b50279be191e8d538dee4d2c2edc6c780fb8bbcbbbbb9b03dcdddd9c2ddfea079eaa4abbbb7b25423f8065dddd0d63f6ce9e2054f757a7731c6753ddec903cfbb3df6d63a25dd7996a86a859fdd0dddd2a717fd6437d3c42de412cae839b69db70745f53c8853cebb3fd79bbbb7bea0677483abbbbbba3dd9a6c6e68e7236e38a7fdf11a22babb7bb775faae7de8feecf30e8881b1a7ba4ff7f07972f667df27b8324155a51c005dc4998371f40d0feaa9adeaae7d5e36c2ba1cc4aae1d1f866803ca8554a464d0caab28171b383a353bbae5bebe2a01c0ec2d9b98161a3a2316a64a4968350759783bcba1c74daef58a690b3b1f5f88dc6c139a6b83ea298eabadf66b04df7d2adcecbf66167958fca3c4aaf79e1209feeb5592bbbe5352fb9f49ad76a584c413edcbb2184c0440178f8b604a8eb5b9fba53d7715c67e2b6e97376b36f760f803b4dd329fcc183b9b0741248b842c2f6f821049c5d47c2bc42c2f658ee8478f8f01a04e0833d00aaf5421fa190f6d1bde985c8ba1f3e4298341c7cdb33ce6f6edd1c8fe5e1d60fd70de953c833fc21dd5ad7291c3b130a291829829b080fe99087f890d91018748839b60f2a8eaa329dde677bf8b402148428c46255597121fb33856c8f15e2e212dca8db2ddf1e353535cd4aed4f6a7bec077551406e6c41bb9d40f0b08dba61d7036ed74d11088b0de61f2bb1c8aec485d5955aa5c56764fbf0efa81bc5f7f6aa9b52b73632e49fa49ba953949952c7cd0c078d5ea696a169f10276d7f546ce38c877233792dc1efbe5fb3cd05137a90443e0563f7f0addeab048fbf0f78f39a0d39a5684c69b42b74ce10fae5cdacaa51f2b1fa8f82f8402f24d45ad78e03c3bf563b237b1713b67ea843c2416dd035725f8c0550f20b87242e7aa099dbfe2a1065ced40e7af98d009c66a524a4537e04a071c5006160a725003a072a2e825c1419b57e6502a5251cc015739d0f932b0d09d1d55e621a9be54161a3d244f4be5ae31013542a41d7e3b1ed4ed60802b1c60c4f0a9cbfd16631f7e0f897d98bdea21e96871b34dd9621bd2c6026dba1b90e66a099dbfba81ce5fd940e7af6aa09306f8dd423279e1a9eb28f590bc92452ac643f2743a8f06b87ad5005734d09f1fb0ea7b48dddaba8e5295ca43f2a06e3147da1e1fc450a53c240f09a9c6b9e6f53975f78edbe12ce6553f92da9b3b07ba9eb0b30eeb647977187e7f378f6a1f4905fbf955ede381e044610816c02677d94dda411287550be8dc26145f0d956e7fdf54abfb5c59f7376faea142777777254265d394eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6e72c96bc90b06ebee57f7766ff776ef1e1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d6df7766ff776ef1e1d1d1d1d6df7766ff776ef1e1d1d1d6df7766ff776ef1e1d1d6df7766ff776ef1e1dcdd07594aa544732e4e830eeebbeeeebbebbeeebbeeeebbebbeeebbeeeebbebbeeebbeeeebbeebbeeeebbeeebb5ebaaffbbaaffb2e196b9afbbaaffbbaef7e3bddd77ddd776b3c0a85428138bc8dda3fa376cfa8dda8dda8dda8dda8dd88858383838393c3a8dd336a376a376a376a376a370a552a952a8733316aafd56ab55aaddda8dda8dd68c60c1a346ad4f80f59be36dc868de6696345a376a37623ae2c4ba3d7ebf5ea97bf8c58ac30b4d1e39bc373e4689e3956f489d46ed46e74e3060edf1ca820b3baaffbae68d46ed46e84e389af0fa8c3c75707e881bf0edf1dbe6347f3dcb1a2b751bb510ed1483c81df079e7ccc62d6fe6e4e5923ad3bc17cdb337264e59f8d1a420d0d7135b0878686ba939f4ecdf3c481dcd0d0073a08364f304c2d4cad56f35043a821d4500d754a9b274d0d0d0de184a985a9d53672236b383aa8a124e40e6a083544aa5eafcae4945859c6ca32d65e9ad6b4ae75ad694b5e4b5e30d80b06f3d7f42a3b6b54903942971b6a688e70f299972cf24a093a3a77a91934beeffbbc2619c645312459ad94cd92681d23794692244972124da9b6748ac562b1588c244992246bd8d8d8d8dc58525b629289f855ca6649b4b22ccbb27cbd5eafd7ab693186c562b158518c91b86459d7b4582c168bc57ea504bd714339653389a654966559be5eafd7ebd5b41a8db6c42413f18b99bc5eafd7ebd5b4a635ad69ac150f2a08cf0c54901934504168d400bf068bd53c5936cc57c704368b8a94655996e5ab7cbd5eafd794cd66124da92ccbb22c5fafd7ebf5aa51e34390c50ac31e1b37fcc68de679a38622ab3449af89e23fedc90456346313a97c2f6d84416cf4a082f4dc4005b9814374516c9ee20ba813a2a54a566b1fb1a6aa754ab4a67a529c44bfcd42aeb6d56aedb59e66e1b8811aa19f6cb01ca8a13942c77280620ed4085d37ecc027823e6207b6188b5b4c87ebd0d13c75343f0db0f61159a84cda60dd85db060bb759080b7b83dd98a1761da52ad54cdc665270c8c0330eda3f71a407c67cdb3336af94ea38959a6ae119cf8ad0b1ab5446817de6af5cfdadd56c186a3607b7c7d6cd79ce325baf5cd4080a1ce4cd3d6fdcb62d8f4b5585e3298607a5356052f97996e4d0499e76a0a0230fa11f3c7c4c59972f755557e68504155557d6c58cc7e06be6dddd67d63943e78faccacccccccccc5b0db373bc4af539bcdd67b3d9105677f21ec848036d266eb71dd22d236f84db6db7e6a111676dddadc9e9bab581f5e12783a46a8746f6879f861774be9166a5aa915d234d26c8cdff83ebc795b2b32c4099b7d27cb7049c29e8fc6d9c2996bb53757709746e776f3504e391da613bb1716feac01e0e9ace9958be3db7bd69dbbadeb6ad3993e768b66dfbc0afe33893bb6fe34ecf89c6ddbd7fb6c943eee47ddee7711ef83505be0d949d5040b63f9d2608a7f0c80cc0acc3a59e444af8082fe11f174de5ef70b0f8f0aa18a7f5bc509c27984dbe4f54fdcec4fdc1e20e7ede13de13ac0e9ca404509de964c4b73dbcb5dad5fe576d6cea5040b6ef9e4d4238c866459d28b85933c924f2490a29c2acca312d3c759f8977c6ea3bd5ff9b2284d5f785ca3fc9f5e16f95e0a5f28f3386cadf25881c4e20ecb872dff5ebc02a683fed16f8fb1f08c507c59cdd6916d9da366ba8277aa0fb5d57d605063354a92390efe0885a97180bba0c81e3453984cbe85757d605d68509153d78152eb5ad055a1c71e1720417298ab858c1f1a2092dce44072d4c2e45aca4588a532d1394c6d071954413ba4ea6a452a18098b03ffc2b7b198de20579040b6a4ea87071192fa41cd1e488181159b81804342b965411abc2831617237172058915d4b4c04284029769bb40b22a5b6903fd32a95b9d0ad667be113417d4f956eafc6ead8ba654bd5a8ded0f0d0db2d8c53e99994fc6ad5903d82ccbfc4f0b07d19438e8cbfcafc641613868655a3ca9f3bf250e42d5f920c92db09514bd624b907628799035993949e2a091aba025a9f3670beafc690a53e7cfb12ba2082d51ea9c92449528b268f1f2858b3ace3075e6a08ed34ca54fffb4e4915d2cc91486834c4ba625d39269c9b4d4911d51f7322d75b0199b4813368bb61600fd002ab91887b495b27163b2116d441b1151b7d6f5620223da6255805b8930e902c321ed338bb4cffcf5e25a97e700f0bd7035c4430d01c315d75cbc2402fab13cd6ec90b848455fd5c59e36d75514432a63ed333f28f4e76fdb566eb2264650a8f1b03df835c02597ab148eecd20e1a3861bd54afad269964bd5466ad974a2e21524274821da89851020687d76bc96b32994ee677e5fc4e36bf8b7548137cb1b8c5bdac5b5cf8bc852c936d6f8b0b7b5a5b38e2746bba56c5b1786389808e5f19885f88ffc5891a4ad51782eecf2a08da711f7ddb63d304fd5df12f921584b8c10b5d5cf8620516b86e8ad290809683196647b8f6a9eae3706d9a30c29fc27c2ec24133e4212893edf141adc0b676ac0f3f33a1e2b9ca18da05272000dbfaf5d9e7b18580a5cd251c34eea8fcdcfde2206ecd32b56d2599a5d20952e05692d34b8a93ba255952b9a6f2ca949230695f6ad262fa5247a1ca34232914316123c082c0aeed3f670d6d55ed0f171e11d2485c2b22dc0f691f7fee91b8e68beecf7c119858bb22620abb1591b00be91014ba3280bb27beaf46ec99dcdcbe755966cda2bcd0feaf86d6142ac8090b1d3b1e1b1410956a04ebd6549e9d6fca54391c87ea54a2cef9dd76360d1883a4cebabfbb7377bfba4d7c69a1cee5ea964e40a92350dd17b2bbbbfbdbb3bdc4b73dcb5cc7afb38e5f4fdf9d69720a08ad5b2ed1a4ceb06b80ab854d93264d9a2592245da93500d1bb523e88805ca903a45acf3efd695043fccd45f173449d2bf51e6b04037081d50f880f16db136211f5fd13e51da9a3876a009226b115c0e4f0022262b0c5b5eb837a8f3582d57b146bf4de7bf07ff40960155954d228d4ee573ca570f2de070779e17844e8140af96051ecfed4a7583decf330d0d05128c87972c8e49448cc7e213ffa852cf7cbdc88a4eef377ab8a2144c762e7c416485dd2647165871f284eb0a0c3920e64c27cd823583b0b2c75c6179a8511b59f07904d13f4ab1020212fa8e8815fec446ec1989124b9826b93782c890f26bbc19628f4064abce5aef9dcb6ab83ae8b3a73eac4c14d11dd1d24ec60712b77e1250a2f55eafc1e191653eaf8f5776011a5ceef590dd94a644261440c5c9f7facaf1952fb3f194cd744fde43852ec61f15118f2d167196171fee69f0b5415e6b038657c57d0fd7dd48e5de5c2716975cee8816e3ffb1b08fc138058e32cb9eec811228880ff8547be07c323e08ba056b9df0e4724b0cafd90cafd068e54fead2478dd402f87ddec94e8f6ad37ced4ddc9cb32a3d16634daac41542acbcc3dcbcc9d46739fb9d368336a739365966546a3cd68b4190e88b3e4a5b3e4b5d3fe7287c15e554af72aa5bb97eeb35919a6e61ea6e6ee3577279dac3d81b93f81b9c762ee30f7580cc68149489b1d195362cdf22cb30e15648ed0b4132ac8a9679e47a3793e2395a0f37b850d3aadc83f85cc4cf6522787ff314da9b6d46413c5605d6e5ef8f57abdbe7461a82ac92bf1904669dc202a55966559d6bc5eafd7cb868dcd0d8e4ece4e6a67a779ee700ca994310983c1603058d74a5a599665c94a355e6ab2896e707274baecb2cb1e1849fc152306b992f14a31c9442f26244992240983c1603058d7625dab3112972ce31927a962c06030184c46d76ab51b3c3368d448396bceba244a53297d4d5cdaba221a5321953e9bcd7ce630261d0683c160442f260c9b413a8d1a0e7398c31ce6301cacd0c68d1e1c291c389a270ed68415c5904a92244992f4d94c14ff55aa994453aa2d85244992a40d9fcd7ce6b31c296719e928a922fa576cc244f15fa5a2b4ec8a684c85f4e594c5b6180e923491e4468a222ac894980f2a48108f7900eef0c0cbadfc49fdfc34cf9f1f46b6fc4a12bdf877a37de148e9291c55a1cf4673d68f6e6d5d47a94af53a6853e8fccf838db63ffc1b6da36db48df60aa9175634da8fe25ea89bf338e10c89e0fc119dc70957dfd3d5901c1d9ccf7922389f131e2162fe91ed717e8644725e273c3269fb9cd6457766ffb85e8624d9de2708de0b752708a61503b6a70f015f31607b9c27e29ff33ff8fb9af7df58f4b72752f31eaebecf797ffa5b88f3db13c9797f9cdf58ab0f8795f33aef009cdf0955d8799cd709552082c84eb8b2c1791556ddafbe70c5809dbf7907e8bc4da882cdebfc4da80211446c5ee755b8f99d5fd7ba727e5d25b078c261e9b080dae7f437aced1dd68995c35a170e6b5d37ac75d9b0d6753a2134810ae5d3e96b5826d4450da55e55bf9facf1fbdefb146bc11354953e41b9e7d421e118b4e29bd3dbdd9da7de35b93b053914eac671ac13c0f6cd849d2d2a20fbdb6eeababb4f5dd7bdfee3ee2ed8dddddee9a35a74d726c77193e3b8c9b57fcfee5aad9b4c378c30ddb5ee5afbb77777770d7cf26d0f7fde5ee59cdbb6d3a9721d9a7e106491b77653c7c110d39d36d50b27cf73bccf94f375dd9ace229c2af8756e32bd77fa80a6fbe74348c8abdee9eb4ef5d499521d8f2a291410ff1ad0f9bb8f9ab837fd6712b221ec10c51aca81a13dffd466bb01e551a96c6e3c87d21b1c505505a743810b4517c2e9f98b74eb1412b99285081374aecee79d74400e15a6b8341469b05c4963a54c9384734923a5b14813040d6998309186280d7985cac479ddc63173144963d038714457756568a2388106a6044d0d4ecea069a03e6383190ce609982860a6d0334ec81093448c923348355f4cf922093e133be5c04118a511827e5d99d1962cd40606930cb56141df20c5a130b262d4c4b1501875654649a04831f3440a1745502ea7ae8c4a143e7ce3acf3ebc83ff6e955cc1ad7ca11affd19f9c4ce1f3759ee61b7cdcc3ed794a2829fb7eeb9bbebd309a0ee077559ebb35ffb6737f7e6ccbbbb34c04c1b2a743d28939b490c22d69c6cfaa0ae00eafab4622c17e9d6247f904b23cb6ed5f7a41be730180c06337d7fb28931611e79227fc2d85404859d26d9dd891a15e9b0c80a0115611ffe20a95a84565531e684793861a7ce545556e834a5e684c1b6c7961ca7a2f09c3db3b539bb6e88a1634d6df75355b1b6c7d61b61683315e7b13fdb8ffeee1b0b88c509d6fe8d3b1698051dbd320f0f07753bfcc3ce7d0bbd6e3da68dfb8d55ef26d0043a09a650f59302f10bcabde94d2ce756228c5e75aa872780b5c3af6f5a1299760ef2ac76dced24e2d7caceb850f94776026404366049aa65c1018a6be42e48d90b5d9c89624415ae918b9ea848498c1c45e55f16788e69a2f28f3ec0195851e6081d7c90e2e51ab7f4610822a470b2a40b176a708d2b135337695c2de3d2ea2a1901a2f28f1ba64e2675c2669198ca3fce2862a22061821460c144922c2e0a4cd992e4022c540c31836b9c4861f87b9cb3cab4129890a8004a911432341031c46ea1450e676cb083294e40e41a670d84411d732a18c5d853c1ff6e8da10104220b16bc2cd9a18c3243922b60089345961c66504419202a088265ae54d04c0f1534a34505df430101451074d4ef4f28201f97dd52059139533def3b14106f4505dd9289a44ac6a89e4edd27a656babaefb615802a96205d74ccac9a829e1cd34447ddba6d2e97aee0d1cd0843479508e8a8aa73567906d2d0d1396742ded40928b4675d2439c43083242e68b4282242a2021ad8408927444b4079e2050e546c72c82c1121836e2b1862063a37c6520caa1c5c60e22b3410ffa1f67b7f31a6f6ef501c9cc061eaece00a15b53f07099331560c5183d196243a8080032450b0850a15267081a90b2733d8b0c2f6c09962c8d48e41edbf018f3c8fe7031f95b74ac95d3461c58b19bc3002f30298a4ca0f2454832c4c165526e608203ccbc1081892cc20ea5de8508302d2610c26539d4ef0600470b185a8031b7430839a0c956b49953f254463605193628b24ba40bac2f5811f6ad0e4062e4eaa18414d872edc0f154ab94841ed70062e6ce0a9fc20931a8c20c90c5a9fd55ea2f67b28206d440e56d82b28507db90207106e52c56b3bd01d347d89812b67cff963b3b86189231a728002c3918bb598e1044f1081b14207d2a483264b364f503a8170a045edee74784d2f7d8074b72402cccc3c7160430540eda0d0d1b748ea01f6ccb7610b595dd91648750469a8f377d4956da1a4beea5429ed4734645b1fd1faccaf5b974d429dc79304b4adafc84b6a9ff95b44e72f926c7e1dd2141645e0fe226499f123aaf35549d095e9e77fa6707d0b9d3fa884cd19f52864332300000400f316002028140c074442410e246124d8dc0114000d5a9234644e34190803d2409041398ce2288a428c31c620809431c8d8d05405145b8c8c4defd0267489395e2ae39115a1686ac210ac970925c5ab711694def656023b0fa30a607b1fbb1e89beb9d5306d633e250599615dc992d12a6ca16d78e90f9a99b4d385b00b1a3f20bb653250fd5fd8b351c8290c508c8a340bd46c790178ef4721f216a62280041ad20e57e49922ff2734a8259edf86261b846825787f451a13566ab3e00a0cf983ee29098c976796509e061e517a91f130a767f0fb76c4a4618ca47760f64fb28048e0615409b3b84be5140b93f5d1cc3ef42d76ed7b8b3bc297444fe0b3e875cacda3e7fe5f10e61cc4c9c8590cc681b01c1d30d5fc4a5218ea4decc34d8a3591a97b5fbc016adb6c9c3bd6c8ca58272171f1c5efe30a16e0774c6ce3382280c929d770a83e928d25abbf757748e120866c7aa67c736884b143cfc2c2fe0baddb5d1af86a61adebfe6907403a9dbc9582ffc065f10a0de395002a26d652970f4f9273bd22c88f2a40bacf9b29d2c2c152370a98bb0b5ede9f742ab1009828c29a6c758ca179404b1b70914c75bfe99fc12d30bf5a15b30e43672fc52e8954c692e1d7f11d7330efc2e0ee1122fed52ce603205bf223dca7ca820299cf1db37066cc72b3f2bc63cb63086ab8cbcd53c83c431cdda3652445700329e16581fe8c2d86b75f9b158c2bef355b320a6b18948ebc6f3cfb48b59d84cfc153db42b3e5745148afab2e537e76d225527b275841afae163c9a33dbe6069d1cf34739e523d13819731284b4bdd8eb1f7cb6840abc863f0183e456d80469d98118b3a04c96384e1a96c42ce267889ae0980affaf4c24257f5e1f664c271b9e2c81e8ed3304de0e35a5d1bef6d5c9856fd9fef143d21e13693f4a8afb613bde30cb516d3b1f15061f3f608836e21b7daa17c2429b93a500472a7122e1e40ad8a720f2b120383540200596026a02a85ed5d9feef1392fb8903139206c035b085747049de5b56fb50926ecea48bcc0ef1eb6bc9391bcce31903b8ca27cb6886164d0ae68f17c06858a10137daa3b55266c88ae1cebf42adc61ecd5980cd977b42230469cef30d14c87245d43c048156668b1a86233a4f24e605a4fc3593786eaec6edb27b6b818cced38accd16ccdfa168d0cfb76747a04b698186c5c626af93510361e86508ff28cdf5ba673d0cd0de5f6a89bcbde0ff6eda630112bd94263a8529c429e81f9bfec25b1f97148f437853de86ebd669d3486999d61509e48c4383eab932275486979676098640da7d2090f8c2e7f08ffc1645ddd21c3f9ea48566b7094addecbc0f2aa7ab82a8ebff3b60132e988cb111f17e1bdccd4b8cbfa7a59c0f019489def65835235e2d8fdfc0b6b141db8729e82e3c23f08920994d8d8940d10311f4c823c662548e8b4fea31a7e1a2759d1290e5b2d39a7ba5a452cdd11c1e3c8e1251f4720606132eb77965d13d3a27785453fbc61e88ea599ce7b9c229678ea879b15c8b42145c0cd489627533e5a9f69df399b3912b8e65af13323597762445d2e2c076e87c98b2316343c6982992c892929407375ed2fa09927e08b713fd6aac6269576e3f0360a942e2f2c01f8fb3139005bd5b85e90dc04c2346a30b1f691e23aff8ed4d86eb2c482e4706633c20d965394029466ad91787b8c28d4c4b1c72c8920c2f29f8cc8f5a6563eae3263330c1c9a504c2f02fff91156068a5ccf3c064bcc09ea63a0ff00b8d032401ead1b4fe4c4ab4d115fdb17abae77b11c7f4f036e9eaa27501ba9be5bc2f1a05a331b99cc575a01afcb3b39e252182f496f497963554ff416aeaadd2eae40ed0134db7ac239ba101549817060215a3b131129e8c81a0eb545367495b552ec78a8f3e1e6416261bca9a62392e4d22b819fe811b31f49d6afb992a9706854eeea715b0f5892f90cc7024e1b6c7e59e95b6349b5969b9a85d28081d78dcdc58d3ebc78b550755ef8c5c60a56a4521f3739e0b7423357f79b5663c594449d9082efc221566d03b6ecf4288422b09bcc3853fed600dc3d0f7169d5115de63f5b8d342ed4e4ede7c5e3b66a62e454b40ba77a847edd7a4e269e54e3255283677088110d9c0769a6fc2574989044a0a7732793e6fdeae032db0224b9661047bd14ab9be1999d19ba56c1482838eb901f0957014921312290f01b65075e92533dc6d6bce5498d9c90a5b140dca4c6c829c4d97da4a6f44bd416e3ab8afb76b26efc8f524a0bad73955f883a4868bc0490051f83056262f5d4e603ac30df71c9900a1baa41db9c95cbc049dd1cdfa62878b7f1de1e4839769bb8cd409867e8ac6718e1f7a784873a418acedbda3563ba58b80642424398570488c6d0a912451a9f6d5056f6a28ccfcef4d8f5fa14069e5bfce6a8d879fcd279f26cc82d82abfbca412742f994b638d673311fa6f6a86bc2bf86d1463c3055230558a0255bf0a880843837d58c00e1a194bc96cdaac8c4d593ad023eae94e3119698a147d08c72c2610a8dce9207560d1c5477329a84fb299619a3003e8c54a471429b3505128f15736b8891fc4821dc106a524a0fb53805a5c14967c27c317a5fbd30a2db28bb6153d0cd895357e08932c9b4074d769a27ce36c7ec81423c8472c2498660a8914138f1f44413305e20214a7e679050db1bc18c50df10a03d697839e569416a32bc38200cf89b459e8af3ba9c775203077939f2c14b3c7f6b09532f9296a842a064f070284ead6c5169b1ef5731e02106e53bc4daf42363a073192ae91e42a0de73c15dff8131bc68f9f997a4c5b17fc2e3fa823eb51acbc93f0068a04e1049181a4443d9234d2e177b677d1bf47910bede06e24b640f9983809b80db8858fa9e05d81bc6458a1c5d7888cde09260f0540bb0f933f66840b1a07502a2525617264362170e775e72341aca90781a2b94248b99e25618ef5ca6242ff3db51b3c05d21fe60860ceb8c140e031f715810889c6296e949191c3682d10a7babe80f48c46cc4c219c35ca7bcd31f6bdfc51b467dbe2af503c1e9a45bb860fefce86dce2601703d87f1e3b8bc02fc342ef9c1d02f62113189c0af1277c5cb02489899c87c8f1567a511b07316f5ce8d8834c7a4618d16e08e2da1608976cc8cf41a153d9acea71288d18de1da747f4a8130ce727acd8baf775ec04e2c7aa9763881d4986e34082689dd011a7bf0a6864e029ff3a5598400194e82db2ccec4f38f2885a4d430a7b4df9c63325ce6faec6dd5a86b678d411100f428317cb2f1510453fe40399421da449f6c4d6a2af5630d7c701cdef9af16d8c476bd6c13c098b46b665b5ab6dbe066a3ac2ab797461988f074af486c90d14a0e813d051be5b6dfe6acf0c11b3f3bd9405ac06efa806d4daae4cdc0d7b6ebb1ee8e8e6396937c64804d66b000a555beb2374787507fa7a2e948cb4c5985aaf029aa222a3d6dc29a802eef1871dd5292dbd4701afed1b89663a624e20d10ff67299ce6663bf36ef71329e4c7255d4f0a0d3533b021e432eb12159b1d43142ba8828205d7ab0689eb741d337116479afe79afecdae0d061c8746510a082902c0f61848761e47171212223cca8ee20f117c6af0ee660be630935f42415b26209d7799d0a9a4b1fed89d5f46d085aaa897d14c19d083a130a4edf2ca423362a24107b505d1db0ee19474b0b4c63106bc67be96f67e6aaadda56d99b5dcee31992ab161a4f8f7778468bdf91a00e2b659a9a508b741e9db764032a427aa38eee92275871940046e1ba90cdf27fd54a7a16b53284c874a78bbf192c19534f935be7cb1a4ef42e2578637b9be33f395168b887b2022b3614fc076f0f04bd44051a80c72605544e7934fb2d59a45eccab692ce0602bdef8106dbd0f591006ca2aefb856944f63eb3199265ab7b3048b2ac50bb2d3556f525799525776b5b4bc571d366e941bd8f5f46b455e66cc2520f32aa6d20343bd08fdfa1f08faf8487a2928d924345d337bdc92ae57767be5e75b3dbd92d2a29a7c4d07f777a07abdcad62324835e3b570f86211e5fc8ce5c3f80a00c81f65421acc87b481641dcf57a938739e774fd71fe66de98c1ee38f81305fae24f2f341901ffd99e6737540e70f98874e2a8ae6a264d3a78c2d89a8a584f8d735fa903b5793d3002c80cf36b3142fa66d36946db66f92c7c36392c9617818c0a9075138467e715e85fd68f4c1ca75609f305b84867cdbe31660e3a18580408747bc7d346257bd2def5b8b4952d1f28d849316f86fce7bc254dc4aa35ab41fbaf448d7005e1ac692e178db9a6da52c11afa6208bc9fb86a1dde27f804e8f37a46d3592f304414aec4aa601610bf96bc1413ab94509df7ffde4c14b28e21e2237dc81a77b675568c33f3ab630d70df97ab06e1193048b51bd75aff519d83006e957444e6d6721c984126b13cef05fa134b70966ee3e3d6ba42f6c2b4e796f347201a3cbc98d764b77aaf0f6b849f9d61da812d659434a32034b2fd0afbb4f6b17a62e42e6bc9ebaa25c367af8b3953842d96d8abd598781c9c5b3a096e624a19b5480877100f13f3fa11678e3e50b858b34a6d3ff0a0928f7f1a7a82ea4e753fabee33890be54f2dff18aad882aa00b5fb03c887ebc015c5176701e80f97c3ebe73b88e12c646deb0a09ee386792434d5c23b012e710b915b180cc2c465fda073b9435500a72a98580b1f41abd319b71d5fba913bf10b96006642467552da192c33bd444c412d5241772e356c0545ac148f9af5bd446159f78c3cd7143c96d2cb59c163b049decf110d6a197349371e8133d3292902d39df2232500fa32d7ff19121c4fa6b133d912655ed02e63158a050c1fbbb6b52528eec7b035a6cde382a4c3e27ea52320187ccd7a049367924c91b485c1fff4a835db1caff10959997db331e285532414420b971d791eaf0eed31aaeb88f970c8ebc0965d7725f398e4fe76a44295c1763755c2e204e907f8e09a278b6a1d922a5a3cf141a786c5501ee90cdb902b37e4ff7701c6f4362059a79735e1976f7656b8785ae869511f04271b038996d4c8baec89b357d04b5c4cbc3817816f5a3d8e0865f6e45b000083deb1b064dcd6ec65a151879f9cc8e15a469648861d730207160bf9385496b2f923e65b6b186f64663e4ed6f70bfcbc9652f504cb749d8bb31ec25e12071d2174bcd823a2932eca23e81c605d5a69a322d693c91932fbd3383ef56cbb6ff7a1250d43f11a7dff93f501c30c77f83157ac9c7e20625d86032d4008b9537c3284a01dc8781f1cd4f4e28bfd34fe0f7abf7745f42ef4a000eb355a8e0c62d53b9df4b79fb69d57e5aa2b0aa1a5e6590012af52ae9a816d2916792f9a148aacdef74464723ba1fcbec5b2cd77b00eb6991c1eeb5dd01006ca6a906a0bbf77e4816d8931b270fc0a3275694640dbf7d885937efa0867214470c190e43b18bb7e86a9d51e7fb111c3ff536f95c9b5744b36a3e3e1b7005f97a91b36dd1ce37c01557cbee7115c48e53c83651ac9600efd2ae5858d9f04ad3a898ef828339e235f0b7edf7de7be9a0d65aaf912641a8e54c6c3570866edb622ecbfed9547c5629a09f82b0b7c7fe753ad9656a68b1565474d862f940153acbde951101a8c785f7b7376bb0364c2a882b8e9415693ac0d534346556064328ac066298384471c0b0d6937cbeee5f1d3c393228ccf971aa09c67749a1aa0e6bc59f2a40aa7e400676aafa25b7e7531ae80b8e36ee2e81d26a95329bb2dfacd5e82e0f1691a9ad5ca663de37b99663ab749da5fd07c8ab6750eafe876edc0bb7094cef376c2d9fb1335d9158903d667c2a3524993cd8aa4295d10bdd996e699d37906629be903e1cc830fef51bad16d1a8acb415344cb84f65410a6733b230eec25457e5f2e52610b88f88d10b7c4df8e1f85746f4f74da5312b7415c15904514b28df7aadaae68090c5ed95aa6b360640dd6bd8114a62347f71562129fe0ba0c6cadf7ef05a0e842bb57e06a76454f6dd78b49feb0aba708646befa08c9a61e4fa05b812038eff54678be0e30168e0131753903f41d431f70ba436b0725063da8a54aafed2e9bbad0d43d3b913fe895db5fa2a1c799c7706cfd27eb72163893043fe1eb61fa6e7cbc1fdbbcb795e161d4a1a8c8aa1a1e6c0e74c183b37a6102394ab6447e7021ed8a2f4e1c7cca32f069c9024ebadd8601fd5074fb739a9a58649f27d437e909bdc740a4e571f16217746180e782a083675bce1510ee45ad43a9567b3f5e8220b083e0563cd28a0ad1c4e6046033acf1db162032421d0110f4cd3cd28e1927f9de9878ff3f43e49c5328b0c8b9630a1989ea4c261778c400f9b2bd52525d8b90f9f49c21e3d24f2c470be765c69bd3d5b0f77485495451ea89f09415194022e57fb16569bbd09292b123ff2407b13add19db1ea4cae69822008ab402e1ddb79a0418b553b974e724368b9d19e87f0f2cd02f7b02b43007b182f582d17ba557306796db2b2fd74ed11c8539f68345a49dddc017cf6afd761461ea3ab9240c855db284186c204f51af5bb3a6d13bd0de76f1ff0d08c260a368f2598772b738e109ce9287c188c906806cb1bd780ddc32cdd5e4e2e5f2572d54cce3cc6700990e52c95b9f339fa3ed92bae63d4288c8ab91ca2c33ba924d64e89f06265b25307d1a7cebf07014b93c28111242d01c511f3b8ea2cb8c20e72f23a4087e5ff2d1371f2fac633ac82d720c8fb3953fc864a27d8b2062bb710057faa0e7f97691c057563a8c6e7e6caa3c10e5e8263f11ea8693414966bb99436d1d044f21d22dda29df46be8c5b11a31e8b34faab701a0d0f848f45760deb31948c12099eede795dd4ce46cc1e67fed0cd641051ae53323ee453933de16d0ad9ff19d367061ead9e226140a0f3a13c21a720b7cae30b7bf0eff88b185585a2804e9dfb423bffcda470ccf710281990d12d32327acdfd1ee8c88c1127f6cf121df4863308816c36aed04ba110378a43f85f96de4c22d63de1a482282f97e1acec04f73b1410c7083e027cad7308eb57092c1bd420bf646a1503f15849b7e8ba54c5c2f8870c89b214ae210f6d42a329c47b4f9a069604246c6d0f0f2fec24ba4bcaf0e8562ece95c5a575bd09f92ed6a01f05352a37a22261803bbc8a23166638eebcd9c55d18192d318452915d9ff1f7903e6475070bc0d9af33be7420f87f9685a8e9886c82089090d6267024f66bae9ffdefe11c54d71411cde2af71c000a4c0578f45bc4454d0e1ba9534a470ef7902153a804f8b735ae8e03935c958a75e3310bb86dd49f2aa7ca35299253009af0815135aed93a99dd27b0c572e33d620367fc6c950bd97734cf44bcde642f2734423ca26e5f5f416265147ac16dfc11133a97bad9b993f0ac5c7e89d8f570f8dcac603138e6ea93d99a1b66e6af5cb84af3fc82aa13f94a630c70acc2b6a3900bdf9d1f003016afdfbb570da75d4e8a4c398078ea16c00db80e4ba68e9a046df8f8ade682af2b776cbf4a60947a7f64fd4e065f2199665ef2ba9655d55f55c8bb988a353da1501799d6eaf2898933ff188ab8276e35d678ba655ace46f4588f4e1bd19ccd1bb7a0119daa883f8c3e592071615a6576613172e66d7ed76ba5cc2384bb3deda4e20865324b9f79eaef9ab6972afa0b313a72b763a0fdcad2c1fdca5e10288b678c37cf4e1294048aa5f6c0902139967696902c9958e67673576131c1979c30c7baa82372c3c5cc23619249bda8a43fa0cc5a353b6c1abe58f4e80e26a542e1fea2c35e41227862f2c425b5e05717d68f30a6e07980f114de28c03a24a694dbcdf2cc1c59ba1057e5b8a4cc6694d99bcb49d43b2d48695b932ec9e88ac9bd6264a594b4b510097ee1038766f402511983cb08d7a1225a17f3891665d449a426151f231af918ad37cb5868a217e9ed60843350521a27cbdb525535145c556902c206223dda0b9f35e43638a40b1073e9f7b21d3357a5cce12a0477af86b78188fce84bb1cea68c1391f82de192015f45b3f1bd47c382cce348ad338206f99d9fec73b72bac565873c671229c9c67111a6480b57dfc24ba25c0f56b31e6c292d2d92aaded38cdc64bd45f617648a17f4079fbc08c55038a7ef6cd1157e7f2daa342789bce9480423b4cbff1a60cb82d2281af3cdd092543db68bce8984f45a2b46ec5398c8eeb9e661bf135576297c60769b538f6584cb58b56caec559f0bd16fe9b668db409776f3478ad1bc29c302d7d5598d02a84fc5c5596ae3930c4380b4ac8605978a27ffb1ea5e03ea6148242b5bfad8260a6a7afc6888e4f7d30661d24e0c0d4525066aa72ebf91e3ab6b8f4e55fa661b2bd38c141ff7ab1b8806a4c8c404eb3180aebbda8ea290ce71d6edc0c837bf410d0581b754dc7a51acea7f0ddcbca6d7bae0e0e1725e71a7ced6128dc61744a9a8551322182983d850e0b01d55fa7c4b8f03626fa2810c2658bb44a9b9360264de27e18a493314b49b9db4ce74f93a82e28af3fd84f223f0601a410fae610997885088862c2f483abf206a067118e5946174dcfe4fbb1b452596f2ef504ff7b30338b101d764d84b68ca8e61f91dd302cfbd88b308c4719d42d26685090783baa7610bfff67a4511e9678d49b341d3d9da55a3fd696c8e56e601a989cbcd26ad28ffc10977457fd80a1e316186870e64a70101b563587ec7b4c073cef2d66e335cb0bf979c10ef5572fe8391ac63480d804cf3000dde1c71a468dd656aa70a678dc9a6c1dae9e15bc304b4d33f0f95673c944cb0bc7492134dfb352b4cf0b3aa9464fd9069ca12d76a3fadab05efa7c4424986b077aa197e509777681f57760565d902ef29668d1f682a798bfef0a30534e9e6529221b63d55ce3d338271022b139081bcb6838512d9b5a7368c963765e72c8faaf9a7b88c274b936ebf7c45b8230780f9ac1ef3b325b7916b5ebf2e013ecb7c30088271c1100ed12eb9fcea0d8761b1ec70a93a7cb70e53ea867ba62b9c9f1b1575510bc9e198b77d1c794bf9e5bcb615fc3e0d4ebc4691c203841e345dbffb3e5a8eaa1e1ebe28c79a0c17046f09292cf8aa8c0d4101aa266974e806a9b841c1670fc7aa6389ab8329e6aab22e48c2d5919a1be1b5175ef8a2df9497d15714dcfc70ad166be905acacd85292bf637e104d3d4366a5283858ab43d7bd3a998453ab321f96beb6b09edf5b10a4cda3f188ad81f242bfe9b9662d1b75976d4b2fc4257f4367b4d3596c55447105965fec70b644a1e6aaebfeb9a16739e8d6fd55b571e13a8fcc9de5c9c2a6ebd82847ad0b8b10094c01a7b026a39dd68e1311a097ac92e8dfb9ea6074f4f821414be481f01484001c854d26bb682595ab2c2459489b9c6e253c106054eb47b2b6a806c222b57a4ea24de957a973d93d271c5f9cec6b8066b57081cb28d50d818d49036475a8a72a618a630caf1570e15b7b9e07b4cbaa5aa15519ceb76707a5a38842d4568d5f6d25e28d2e2ff7daa6b66d673d8b9c03b4accbfdd223367e3684a079db985de89f666c2c52060f2543d6e2e63eb7434b5d9883107c9fb6e041db6afdd741e63fd346738c962c211ef30f1de7359e1a495ec3204c4c5c803c4707e68c302b5481bf47dd72163734255ba1d77a7da4d22acd6521b23ee99f9b46142e67a4a5d2ec801046f2178a9e965fbb78707de6ccc917410f63baae1eb2fc1df2cba38f110fd2762cf19de1bee265ad1456a54bc19a281d6b9bcf80f740b840bdf9cb427a6c7cd96821f2423041ad9011245857aebf025b176b10f44dd3463b506cfc190b621c2930af28842c26501c356745301a5ce0effc6488f0468333e276e349d3f07e2b24a0fa4f20e59e077a8fae98811522cef9c727266ac3577dc6c469840c882f3e26aca69c5e30793badc3e66bbeb1d1bcad5a1486b6286e9905bdf2ae0349134cc507ec91d801dfade67d5be22f3ef76672bfd03fd8be45187e224508d5728970543544780c11d0ee171a2a89e720419259b9a3e3d57690bece8dbefa8e583b6b7c68846f3cd551653b65409b7dfa004638d0ec9b213c54a1f189099989b1c0a6a16c1502b99c5004fe711556f8307cfc9512748f78c9487c90cf87a65e9a9de3743e06a33be79f243aade2f13640cb97766709053553c34c2241e52f384c63d2ed3ce7392411af93492422d04c2427ff95cd7aa5efa7fecf1af8f74e17c290ec76343c43ec089bbcf7681d2f7f8e092161006d7876c99826eef61e35c6e438967c7b3658e1122f08fdec5fb6241783c1a3197e51d33cf0cac2c808f519b16766d668e5a515cde32383fa3f40653c353c8a6b4fc60a232d1e04b3f18e73eb0875b43e964823b270c9fb8b4ef4780cda698e53b021369ae1000d1ff416e925adff776c4b8eaec9118a0c9377253c589af03de9984baa42b13b81071a466ca600f33377c2ffe75f48702f5cd90316fd4777fe43f092c1b9aab3a157bcce2b370d0280864694f309b72b6b1dc2524ca813f67c2c7840e132316653918b47514ba370a99c0e1ea2f108326d602bbc53a18267996b0132f03d5626186e3bcad22f84165b3c7974dcaeb792bd12c7fe089c54cbe323e8e517db3bcdeb12f6eb13f80fecd52395f3999614bdad352bca193464effb37b6cf066aac2576ca370254d5823a03adc9a427d2b8750e6655648b90a7aa5b52f0add87de87d3deb2b615950a80228b976f878f3da2729d186fe1f857500f2e99a1a0e21fa9c8c376875035028c45e01922d9186b64400bbb0df2496e4acda082901feca614a6101b31cb9f94608740d96e1a112f6f2267536b64009aaec38d9335d8ede9ad5e3ff5507df937da93c5b450c3c87bc909632c945e3e2617601e06fe293e48360a04ae31deaac82216fe9c9a06e4ed14d8f84aafdad17e0e4e8020366e7e4a21a5f1681e009f45e5d303acd83cbae41e7a7467334634046fb657aa1afed416910bb834decbe9f12914a32a1053fd75c0a766b2920c53f716747beb54eb0d8e62172ad933b4d2d870eda1d810957b0d721b854066fcb9685a8eb43c69e8371de05795eba615682f13015d994ac25ebb7b74335336f3788973238a744349963e1fa8d71dd09e3eed7bb94da1be601774a6d9895301e4c47379569c1f29d75b793c1eef717692d03a5ff04bc5c6a43772f170579fec530a5f4f6157239276f79f58675b19379dfe70b696d16c56f123cf935a13b19ae3b99f63f7997d6be705e7027368384d2db55c0cb89bce5257e336fffbb7c471faf92e3c5a909d9fdeb40659993181fa74e58eedc5a53c25b25f907c97bd6434838a07078abd86b01574cf34af2d50ee00782471aeb3a7fd0e712e3423389cda33589cdd04d62e7cdcf1ddd24264363129ba1998e9d3cfe2e31191a93983cba49acc51aeb9358e5007e2079a491ae6310ff0cad496c866e3ad68858e5c0a994a26a13259a189991ef85a1cf4a98d08fe5a11d48fa124231ab47939139538facd4343d4e708bac594960e49a94fb0d8eef8cdd50e0c6906c56d5398ea0ddb2c11b4f25c0685772edd911cf0779f81a89f3f61619e6dbea33483f197ccb5c87717242b8650c840cbc8a3f3077c470d35eca2fc866a296c1ca56360d0966437f12f1e0d67fc2b12aee9f49e75eca5cc887a49e83cb56669a0146e37e12f1e1d6ffc4b12a94b1afc7b31f129bd26533ddc49395914682a1b1bf643cf8eb3f30a727df151080cdf24f9d34b156da2de564b68622c8567635f410f98cfb3edf40b7454fee1f5b78aef4a26f1259920cfd217421dd59e3d497cc3d248fd1dee71748961e2eb39bd7342f92acd6613e203f74a3d6573dc0b89369e79757488b1e9647ba8a1be7b7e038b351d7c7355355683e4713e7cab64a3dd8ffe9a597b712ce222fd2751445a632dfafe788c2427a955bc8245e3d47c9b6649e27c72dc75cdcab005dea8ca35eb9b81e620fe4e7078458414172e762b3c1304a9766ecca2054abd98d0aba17071bab1ba54833011c435d394aa7d1297f9605067198e1ae12dd8bbb0dd48d525219db3309d5c27053e9c6a047b3ae4f17861f4210e4d5dfb258cf19f182291a57a2bb8b08153fa96d44af93ded26a856aae8e8dc66535322d861b509571f3d7de3814afe50c6599f53d7fb33bf3c1f2e51aaf5a8d030fe9416b3f3dbebeec2e66da4f06ffb635322d4c372aed2e82dc8714a332b6575098d8c0a291a8bb15c658da16afb4c2535e21d36627145ff6e85079ddf3f8e16cd9036206b1f281545845116e16c1a78502d7d44473073976897d22c8e9e33e2bb36d62378734a0c89651082d86bbac08c372b1e52b4039a1990e6c8d86eb72841650e1c3b193c4e9dcc2bee0657815bc172c418cb27c34bc655f00d5dad9a7b777cf4ca856c3ad4a77137e6da60516e4abddb79a6f0c1e4971499199e32a2a4beb8b779a5800de7eb1ce3d69f4b4ec90d3f751a5a41008c7d600c54e5c390579405a2327b8559ad85ed1333f0966597feae7beb0e1398e6299e6d83cf8513289b9ee0c929dfbad71004644e104453f78a4141fc1197b0a18bfd401ceb7bb403970b2882f84c5275fdec9210e72e375df9177d602daf1b088a2ce11c225e426d88c56ab6b115e9ef8cdebd81f95ecf11333828aa82e85e746f609740dd5683a0b773d17b270f1dc191cdb39bff826539788f9b74b9284525f5b0882fae723b25d0a90fcc9a34b0bcbd8cbac202dd5f5a249fb623b07621a3d6aa9ec6857d287548879d9d92f8a82c4d84f0dc9f5807ce5a64bffb0e14cc4ebbbe189d79595ed2dae046dcab69268bf19aad0e2ab9defb9fe785749fe09d7368170a8b3069b147e1f304f96d4abbf74f765a1b20a578e679102d523f1a94cb3f159c6fd0e7d23285e7803c4725874e668651e3899b09c6cd2511a0967f5e133b011cdbb16b861ca41fff2a824db83f924cb2776a2d750d9d04b6ee7199a81f6e62b412870ff32b3939d2ba93421082a8a18bf1e42c84f589b2ddf2fe2c2739040e5a75b02980c851809829e2c375d6447dfc370358189f8cb4100bed3a23fa147463ff908190316e9fbe89b7399661707b802cef07f9192f817a00a88afc0d92d53371faaf63573f36e6d2b8a49b389261e31b8254c9b6bdc02ac8f2bde20f913281f41621d506d17796381eacce186fb73708fbc967e81761a070379deecd9d9b0cd3484fb056a40a075fc7bc0af7c7ac79b22ff18658b196ea04539d6f971d54428f430b8ba53d68b2260de0520d8240081b161830db0da3c0908b924e005ccc9bf0cd86f3a9d295e32ec7cef527c0146c2d38a8f1991e0f5d7118e100fd664e514f1a0668a18fcc5249ba7dc6f78659adc635677bd17f0e223df1e8dc8096395e632b139ab8a87562f210da5554eb893346db827c7be8d2adc055d280d93f963e6da3973d0097073f64ef3c0707adc0c044f182deffd0889b2c082b1c18ecdb0c80f11a8cc35848cbc52ff1bcf7e6347cf660db038ecda6d79f3ab52eb4fa473eb7c7fb0ad485ae38da1dc42c026acfb9c44d4b7c5d1904bb5948e231468c0eed94e0c2eff454570883bc2c0117ebbf32e4e3b78468d331e9800078c64d29879d95cf50cc357a0e810c3dbebc5c0bc0822b0a1bff1c78ccbbfa857dec5c6bbb7538ce1542f4051bdefe7949b4972960451664a0bc494b2934c0cad27c4d3169be28af5a6188358ddfb1e7a57328d40d5e17633236fb68c5f3edd04dd5051ccdd029a116bdd3eadcb5971a9af5325cc2beb106d29857fc4039bd83ceaac2ce932766c64b00e138abdc2399a84327a5f14889720e43609240036ec892d968ce53980608e50ab382ea7c10bcc213548b6ff908a7ed22abf67801f9f981c1085c73b820673d0856da092a69a432f582b1496d3d37a1169d84ef7604a75e6c8a2944feaf9f85a14b92f636ee65b0a84c2e984f99ea546c2eb10a4288500c25a6019a182710b3e3b7bdfa3d97cd97359848bea6a65b6b88187269361843c9fe79dc8593623953d1ba1a20a0007e6c2002d81dfab9f6eb821592cda146de6ffb1140879f2fe37b4383ea41a0aa30cd22662eb85d89b554048e4139306b08d093bf73f64408730b6a144e619ef7ea7bd6d4c9a0ddd2f7491aa6e053cd203bdb3d1251380831dc433634260506402164e9847305574a069bb34757650dc2267865cbda461fa686f3b1281e7cffff8d2af89a10751dbd98bed6d008b0c6ed860b6f4ecf21c017a7aa472c3db0c6a500e168be99ee30120a46ceca381ff039336f9ace8a8fb0f2e4b04c222799283fca59d2a2bc7d7cbea9642f08ad250d6727260f2ae51021b1ecec6ebc2150c19321abeacae74a261af994da11b3c4f1361f7b09c3a17a3591080c4e3d82ad96ce3047065ba4335b9295609fce086585db7e0061e7cd0d99173e21ee09a044ede6a1121704fe35c101451dda003e9cea90d1d5f281b1f114da543633ecc633c244386bc9b474936b77e0ffb0657cd0bc8e070b31184cd23bd480899dc0eff14dee2b8d1ddeeec9d724a37b208d36c4503c4e16053ba15d9274ac7c1427d478030b44849cf2a5d0904874254fb2666b68c58ef98ac063d57ae507c71a402831f9bc69a4da5baa5f68037d11710a24e7f4370d37e876d3b119e87f028220a40eb739edd826802cb34e7de1a26b78df29eb4b70821e2cd462fae735f2fd8b6c0fbf2d1f9ba5a05491d2c1a5ef380f10736e4116c0a4a5edccd6b34eb0c68e84d3e8c5c721463a6352e78f03ea3411c2d2a07c2b79cf569e3270ae32d4146018c9dfe676cc275ad6688197e7f262907478b256d3699beb3de483bf052804bcb75a45f1b3f4ceda4b4bbfa6134346136282743f59923ea44444d626061245f3ed472a346b4f62e62a0fc2c37156c8e053827b96f2b8908825116329f51d7cc6ad2afbd6fcb7ac74b8fa10be1578ab8918c0aef5d45e29ba6ce3cbf3e38caa6405ffab3d39a373e4e85f3801861ba7785112cebf61a4ef8de2e01bcb490766d663af460c12654d20982e75c7255a7831b93dde9fc8138ca2b6c85ae179f3e17e3e2863c33b0cffd463a895e834ed24e4b3f9b6510a0dee89d52c0d4c768e43f7b916983846215ab47cb595130c0618dae9000d2cd8cf8ef2b96867250e1363813a992b19952e615bd23a568a46cf8907aec92768b93a6eab239b55f48fe1745b4b92d72fe39b42f52c480d0217671c81ff4e01eef7e35c886b434bef2466eac1cd11e428472384bd5a86d5dc4da2bfbf8fa41dd8a18e3bfffe5c475d0a7898bf30fe5640f76c5028f9eed01d1e145e102a1c6d3385786783ba7e0900c9268dde915602b9f80e651de89855479ed34f3d986f093fb9cd6efe69fcda5cd7e7235a788032905138317196b9be29a0d4dff9e02f832488d2f6f8e47ac6befb3ccfd43bbafa1de20be51ddf85839168ac5d98b23e71ebb73e8bf8242e806912d67b5829b58b606bbd32e3583de30f1d168355919287266cddf41eb73f51b6cb75ae1defe8d0913a068179029dd2d0ed000fb9b49b0f1c3a37708fb4716ca08e8d14b24d3bf3bb386a314587fccf5dedc854dd06b5e1e4cd204dd3e8b34a68d764721b0612714ccf3767a9cda7960f396707a4f8bcb2b5f810dc469f08ed6fc14c56be5214c873b3df8efb5d617d12b0dd7984b3a04ace4c00b2c7f9cfd209c547d3fc13759e657b1a4860a4cb1381387dd50cde11f141375b7b04fc4d18df3bfe6a54bb8f60e6211ed2cabc713d5cb082fc519916399a9f51504494be42f182ab1c417a20348f0875ab8347a1dc9e0ba71ea2c9ac3fd05c02118616d9c80fbb4cf5df5299b6f025a43d2bead1f9f3a7512861d4ad604a13679ff07d637e233c4e17284f9e2491ad8c48a2f6622d978c7d635adc18a326072e5a41908ea695c64c17d45c2c9e56f7ae582dce94066a5e81b2bb29df373b7436291849f17ca17667dad34a4abf4252bd66abf08a03771e2092fc95599559233163cad063220540ec656cc8a09d21c8f55c6920b3c35d0d20c6c710c269e4e6338aa9e2773415c254bc747d14727a308bb90e3429681c72538c110f7450efbdd60276790cdbae4920a15444a4f394a91bac857714794daa7899bd733fef1e619f4b315d4019527f3ba9259580b165d68146b0b625aa08973750432f70ed6fbe780364f0314bc69a4a78be91b2d93d32dbf714c92edf496e22a3b160ad9f14b947df66ca4b4592f15400e079f99bcb944eda8905be74f62d5708eaecc882b76f2a0cd2a5b95ac8e20f8b6cc7cc250318cfe4b018826e8ef323d82205a7c8a9fe60b2624009e9f2b325f2804502bd56a937d73f49b90b288078e977acdaa0235a8f3d088ab97d065838aec23eacb05e474c04b2d75d382134382998f75cc107700efcd51c2b9f98988ccb013575059f4564e18653b169bd569b4cb9d49e959f1e108a82bb917c105547c2b5aa590af4265f7a2c0aeb278ef2301b9da03ea50dcc75cad36c5d2c590fe636850c0a41226f2060f0cb03069f5db3945f1614580d61e76a83365ed0c69995753c47e26642e4d45e0b4cc5fc481a4a82cfaa6b476f893dc57ac247c5649abdbf453938ec1ab6fa17eff14c785b2b10e4aa79dc496064eb76959656f69d28748cbf8041b5a6700474c107c3175b5dbe8d2a3ef29ab1b5ff5f506c1ac79e2135ac710bf44db1b48624996b51400606201ec721589c0079d8a49f781cc6351d6d377feddb6d5131c13f74e6e94345f0b630a1def33d00b4ca44e34934a0cef1757b1683a51c6574bb2df69843db0dbedc55d2f82d987327e89f619876579c2f2ccd250916b1bee64f73e6647c18de2e6d187a42ea1b86922caaf09e25d89a0b9c9d4c76096b17d4540f25126108e86154b8dde4476846f86952a104718b11d3a5e33fd2d7c4c8592a1a360d76c09cdec7f854bc64a22e3a44beb600f31c60ac1a4e108641475d2d17b8c3ba8036e4315d0f3b7145c9404596e97105bb330a9595ca56a1857595a803fb83619109d3d6486219e41f4101a5be8c3308e909b892420a279a6cd5c26c06435b09d6c3b1719f9348fa68fe5fdf457055305ad37933e1266db7060880378e03f66fb65744ff0028e6c57f1c28e89a3f6de0b1ee34b524234d9592515073306fe43677998130235aa21ba40b2698fcb2740f45557b04bdace07fa23c483ea5382b720f1751822897480db322689b9e7436dceed46e060f0f7abafd7e12bd52398235d52b7bca584edbe761b3704f978dec1f56ef97be90501a33dd33e7b0040de0858b3ea5892d58e0427f3c97a519efeffc7dabcfff0ff4b0359e6c8e125527e9a8943c267a4eab3127474f618cc32c6cf4c1e79591931a2699d4da87dadc12abc4cb514a6e09c90e2389579d15f000d874017ce7de334e9f2d4ce6053b5e49ada300e18ee2c87b2075ff583259887357d2019a29ea050714a6c61923e4be84fde2825299317b88d4c7fdcd8bd4bba333cab9c291862b542a6b2d8ff29ef48f409564f0892ebff3133cc494edf656c073b7ab551f027386758963aca773f920e2850771910c97e86e25791cccf52fdf98c0e5ffc5f74180285ab8f8bdf3bb83b38dcb7277331c8f92ed56e8f2825461899274de8bc697d972d24ceb796f0a81597471f162793c26b0e4d36312c93aac14113c466b0c54780e95ada965cebdad8c047d80671e04c32b39d8e1778d985128fa46106597ba283f4aa9659e415d5910ebc9e57ff604e9c949c4f0f7eda94c4ea07f1370b80b6be1da97433308a1d56cba973f5f8f1ff13f1ff2f10e4ff37d268c65a124e06909be7f388487085816546f2bae18d6bcbd4355dec4ae78fbdc104e1cdde79dea277908588a67ae19e94e422d0d3c331d9f9f2f7a95330cf1df33aadb5648bceb6954aa19717b3b34aff0a50de9275182b8dac1b5c1a37efb6f0287bde8aa4539388f3c28e96203733234aa6753a13796364264f0c48ae3f26b85aeb856ef3c8b4a4375903dd96f9c226fb7a4ba8967842df30c0a988ed74985274d0476e8a97e04a1559ee86464582bd450044718c894689e2d583affdc17d4f77c47736594b03c8591828494f1c2c2eddb0266d22e64c7294ba8385921e778ab37da2b317864395df0efce43fee93ba45f40df04071eaeb30b6c1ff7756885c898dceb755d66034787fe191a05aed9d46545af598edda33e634f4f95518cc2aae126f10b06d15561c41d328b15ee17c29fe888d3a4808cc2945cf138f832f8adf108332b41f446a9ba7fb02ce73d74531f5576a16f0e6559e641cab5ee22073e6c2d37fc40d990f80433f76a9fc4558d3e1e6d66402ba3aa173518cf9bd2ec2d50c8040dec9c67455718aefdb54a619b24206cd543a357c2bc61f058c96806b60f635ed3bf8278d5041f625c391646ecc4022061a6487bed73b3937208644ebadbf419a5b0bef81a3af3f3db74e86d35de79999d13ac2d87b7f535c3aa27fc24afdf5604991d5aebd53e7106cd74f5faea425ea98d47f5f2edbe43fc10a9d2eaa5e0890161c4abe44a131fc84a40fa8a3ed17dc8533941dbc714caf7e1aa139722339e2632ea407d692f8a11033fa10b89d1486a714099eb417e8d7eb4fe0803e051cd95401776c093f20f48c00fa2b721e60b91074d23a6686f95a3f83ee6dd37e03ea6fa07eacf46a5632bd44632630c14d167589475ef8d0d5da6ae7e7c3ef7f7051c12cfcde6d2ef49969667a6aafa8bed34c35bffcd34c0252dd828424b9319411bf1a05d0581bcad70120cd3ddc79119cd4264322843193609ecffc6eff30b5ff78a42e34d8a2c74b58e084431de3e258bc2138a119497f2ccce24f99518ba15ec68ae69e02aeb913330a2f982d6f427940acde8d705b5427b1a2273a7709a66a9638629f811bba908e5fd499d66559a1dd875b5a3f50655eb6232f5a73ec0b54e28998c1786faf1228e74a4958d154864a03a9cbabe84b56282f71fe5093c70d1e7bb2670a14846344fe99b17311ba7c122162e962d90c15c71e13781435cf6c2112b37ea7c80c878aafeb775b346a07e314328d6eeb72fa8cf2f58442803d08016274ccdca1a6a6893ad699c8ae1d04b6b35ec35d518054278b3c64aed4812f3903dd54c048705e3a9497931d3413b5cfa537c9879d10f034a9028472d0af9099adfd2137a1aa9ba2343339e56da2a813082315a0de4732229ad063504dd64d41f425246ba11502eaf7073e119a270cc6398251b5f33ec592ca83e3ef292d1133abe33d2df3be36ad066d704183ce7303df9f0a6701fc0cce261c3941c809217700724248138c9800e4841077083941c809474e00724289744b9be593635b99b25ef191503c62281b5f643d53028e6acc28304681d92ad851618e3a765418a3c26e15cc2830461d3b4ad851616e15765418a34ed8eda62a8be910becce8d26b2fc7453fbe14897f27be838cb576309b56b18a17f2638a7bd79f3cb1086f9ca3cc864b4e7bfa40a4978d5094b18edbadfe0742cdc7a2492fe895e22dedae4b245317c0e35a42604b364f578febdb7d8b220599d18d7b2948949ef6d7aab3787198fed9fe35f8d30ba95320f456399d11f6575dc116cc12939350c74f36382a11002ca0fabab4cf96f942ef00ae70696c2956d74974e7a83e375236639b99dd5064683bdb216bd18c6b62ce5d8c8cb64845d08e4d1f6917b20826d7a7ae18e439faf8c5443d004d40b6fdcf32155044058b583d10842ab87146e3d8f8e351e6bd7402b9ca4accaebb47fc898e49c0dc525d1caf9775ba5d0af842809e0a420e4f8c8db8d162d2073bfdf7080c14afe5d585dcaec90abd48d7a5cc6200c26a93274bb800e60cc9a648d375f0185c5c75428a1d51d10e52f4db22de559a6646463a1355182dca98dca063b024e1b45be845139f97a9f35bf3898b2d789248a95e682f6d8cd1f1a8a35bd3d608d5b2e44f210cac6ca181cb4c99a95dda34b426703f7f73f8c351ba37f4c04afd081c15aff70d7b7a34cff970aeb59a22d209398a8b646e49625d7ed70ec956e646390141f0dba947e3f14ecf90d732c098351ec72eb889ebdec52e8471da801c08aad3c2d8998799283f4e996f2db2adf0f81cd6382530481901d003404648a9b0090d78b52cf32102c3081f848c6cc38ba9689ace45ff982dfcce18fbf96233cf8cd32757749ea84b671d8f566f87013d16f339b20823b250c5ece3ad57b556a6d32788bbc8384ddd62dba559698109b7c6aefe1f2f02054f81b3216244d6b0963bd3051eb0904a7f1e4d7fcee48bc37c54235fd035de395004e576ea81c33ebd8afe98b634d65023d041c9ec403d95f79d5c660d15e7a9a20f48a2d422104db733277168d3e723f4276ca00f975554040110856917b99f30647000a3f4e56a98522dfebba49cf2928a1de4db60ef1f70e88524cfbf51eff882499084ac654bec3d57d63755f09b00d93870130fb23843060764261e0b9377e22bd5b07ee8b4dea450a3066fd164609d012ad5772338408646841a3e2f201e2b785c35ccd2998d08a2976fa8ec1ab1c7c7154c2bb8f1431f0164e7010c0eb8c58561f5adf5552c0f829dc8af12c7f7ebc00e6a578cface3fd6582ad0f2853738c44b00d289d0cb06a9113a2613ae44d689504547aa642f6976f610b0455469f6705a7057c553676f21d99bb613f1298725320d23c34c6d2845ba3509121ba4a8fceecc5259d93b858d8e4661d3e53f99d9c90fcf28340ef4d63f73185de063a9d3e615ba500f07af79004943aba90891dd7c99861e1b3b9c3a67a8673d677ce899ad4243e7df69325e076c6916baf6d10c02e0b2cd0c7604104ad9820c6923a038015050c833c64c18cc42620477e20a02bbd0616e7636201b83bb220b29089d0490a378c21ff45e49feaff5b24b14a6cbdb40a5ab8604f81455f70fdafc8bd881aa74188ebabe6857a535463c00c481096d1636494420b23ac957e02ca59ba6ca4d0e13c29ade4c04bd76d2dd57441c3d9ee988f45a2b7bd152f778f17cbf6d60d6e3383230f8ba8d532bd39af0c64e699d1527f64018027f8cc61baf306fc1f68a1e159757461a7699fbd1d8c5e881c3258d65de606f2774184b0f34ef725f5c464622abb7130d2688c5568be5de87ff97e0c494adf63ae606db6ee9e41bb792c13879f4cea0790b388770405da106ae0807a7a44b4da66fd068ab1e388f79fd0c81ba50dd2742fe9c0719237b2dc6e74d33a6af00182d2da81fc0f1d6332947eb38fb4c16da3e3e5ad71b8b5e7665447f0c4eca1eefdccb7d890e3dcfef70a2f7903c21de3fa8eb55f5c26a7d7e75d81c0c0cd68302d50e1becca893c19eb77ce2d959bccc234250e84bb083c7eec9c10993f09d7623b9a6ddb809c4c02e1dbe89f934b6ed96ed487230b352264d8f2acb90a7264f2c5a532548c94c92f5b991670a15bbe351368c337be8f554470d2ff4d6509cd4a55b6bf3b41fc668e632f54dd46177ef4103f70947649c17b8d83276c422f52635271251561da96079d91e0d916740db3478fd3bbe49dc57364690c1d7d94d4bcbb0c255eaba2dc4c0411aa998fafc7fd7f15b6903862c46ca25cd539ca2e3d2a9b365767dc694988325775ea0728cee3406fcc6572faab336c3edc806f17032d444a2249f0ddfa8ca716439e21afb27a3d5f209c08c46100bbb045621b21cfda1200b287244572d24ce22140a88c82e681723e49b10b36c6350b6724f1d15e44513c6c9d7f0aed3b200c2691dfb76da618345158bc1e145208752fe6ce47990e81b95d52d5db022ce214ce8bc48827b6d10644dae4ee6e946578a94e62b1a9fb0e70b8b8b1feedd07fe38f8e2c53a9a766e61c6742b0648f9b0497f57bf116c1599c472ae8b82c430f773a68d1f4efd812f819b35a4da67bdf9d8eaa08d0bb1b2693f37ce5942aaaec4ea11e7fc9aee6a22f7a4c50cb3d084da929e7fa2073f46c1ecea0a83866cc316020408388a35a4ae92034750a2e5e52faed628110b70a5d170c972f2eebd6d9477bc4c9499943ad6832e15f3fe1dd7e5cbcfe15e3f3ac4e76ee836abd6c8af86a16c8c44d71bae0d4ad7fa943708837b65e28dba46ca1610581cf3334013a0f1bde78982edc24ea48834311dcc3a1e21cc50d67b4728e65ab09e899ed19350091f52570bf5c6a9d2cedcd3fd9e592a3c7a20bb7c69be9dc405bf129d7e875855907a941b1c27304f71c8c35d5eae8601a049c3476d43ec411b89a1b9ced0e332add41608be2443aae38b78cb66f7960c62fe0a233bb425f0c9ae5dcad44aa3b124b4917a6c21ca8c2db1dbf3f2c679fb1e56fd4cd96ca1217a9835cbf745491af319fb016216c63816beeb5c9af8bbb9458e21e3eca54cef45e479596274844d3351f821c0553ad347023da4ee8bbcc490c2ccf4aae70fc3d75bd2d75715906df613d8a5fb558a764012a5a1550aa5c9f9a4d931383a87e6e315a3b3daae4041d5a0a5aee1359390947bcc07582d94656ac38ba1e65cb364b125c288c42786f81a44ab3b2c903549672aed61d5ffd85cdf0a597f713d661263bde14130f6f9463c3eef287bf591a723d04313a1575ed40075f754ae74ab3b24ed9c1aeade0d09ac378c47d48170b99d7d7096370936342376dfccd3a65bbbed67902906a46dcd647619a551fb6d42ac4c222eda4f60557a5a0f41d609bc31774541fb5e18681cd467e3993044d8e8d14c3e754480a706c4659ec386d7e7ef8213bcebbaec64c7bf24d648d603829ebc8578e77f0f69c6907f4445e1096e5d34f3444c4c3004c36ea20eec982d2ce07ad5a60acedf4c7854ef3388dd5ba42fb0941a7ae9f23ae7df4949ee629a807205c0f1aa43e23ff87f8816129d89cdc39aa572d5c0071f0b5825528fe0cfa2dce5ccb00b58d85b2024c6d0388b20b4781eb751c1572bb66a8501a1e6d5490072bb16ccc4a5ac48015f29cfb8e3c3ae9399276549492c43c6f1e809e8f57617308ecb602c7b1e618d97bed38b209e41eeccd48b99e2985dc2ff7a0b69f04860bfc2ac0aa5f904d69e0d3103a67be609b66ab461d780a9ea5f870b3962345d137221b38be43123fe155031e68d348f7b92332d4c813d0a6fbb5904ffe6b20328c0be437594857810821a2d32b512fc6b7adb157d9b609ffe763f91a4de91123f8feb661f5851a2135ea70663dbb9b2e8ecc88565e3caa9aeba0efffed07f1de2e7879b4d57f3c5e83cff49fbabf5f7a0ca91c2905026c7c95150f35a47678109da06ab96eab0ee08576694640c9f5300e92624d019f9b333f57168e37d5d16e34742ede7b4391230643ee38bcfc8e0d38d1a72236158578c4d601318eea05d886c63ea7c079dcd3ce1cec0adea40dd26961933c2ec43678b18ef3aabcc7d8ef46583510ffa817bf60bdb8c16bb160e7172c1cbb649454048aaa43bb59309819a7c5e6ce77379e015c9a29ae1988b4c9f2452aeb2e964871d93dcb84412f2f1cc3c58e6d030b9d45208e7c28f8eedc47f13314d66ab4e249f1f1d45463df2e55cf5b1fc852793e407715ff666b2d218488d0caeeee1de50a660bbe0b1d0ef0f3b6803f0d48dcf14149a3433d3d8c5f0bcb5147c6282149c412c1963768edb8e38ec455d6da430908def23ce8501c35c81d50c6481a1403706bc74bedc51b3047d40b889b62dcdaf29fb154471718b736dcadad840d43950e415471c4169eb0c5941f5c200b2bf04c61064aaeb8e2c50a59aca00a3f18e1f9c1075d4da690a27383284ef8e02102360c55904a1682841ce1c28823b4609b20421080767a7820a446931f2c91822154b030a405942c8a7041922b9288024378087b3676185b4e9f29ac0accc2a7a9ca50148aeec17dbe47f76c6a9c253813bbd8f14f98bbd471ceaa3dab6d3499e527f779ee739efb4abef3aa605b91489496654c0986a4f648498b647f759771d55d1e47f479163e14308e7c778ab3c48abe9a17bdfb9d175d887ca9029fa88e4da9c5de833b8661e7a8607c2176451866b15bbdba1f917b31234588ec23535219d0d5cd3ee60fd9898072b08139b44d75c8d316adafa9f2ea6bd054795567fa6609a76fba67d96f44f739dfadf91245690ffe91838d8f2e7bf559bdefc1fd6ec7b94129ea63a6a88705e6ae9dbb90ec1a35c1e60ef7aa46eadc735fdd73fa66d34bea6fb26bf655efe3da04d52a1028cbe0c4f4eafe46fe6acf6a1c353345df83bf7fe46043ef03cba1f2fe80599979e821c7d69451077b109863dbd82b0fcca16363dfada9f2ec39ab33559ee534cea41a771cf9f91edad4e067f35133857dcb3db88799c28248143635ce127a9c79ed716acf4abde9d58663a630ecb62551587d0f327b55db049929ec5647a2b05f6d5d12857d5ede02537b575a20d3ded59ef695fcbdaa797c3633d583630b7bd4c11e047b0fd8b778f50df3da2d30531690cff48f99c25e23eda9ddb950d8608cf4bc1bbadfafba5fedc5dfe77c2bee5ed4dbe7a35ec9df5f7da35d3ee72bbdc697b2fd6a8cd5d3f357e3c867d8574b5fcd97f44adeb3a5f718bd54bae8382c1fbd87e8f858e3942eda3c1b1616af47e9a5db2040240aeb6a64297bf698e5a4f7281d6b1cfcd2491a67c90abf741c9215e1d288c459f8aa57f2d9290a078f998e6af03345e390a8f3f9c16ec76afedeab1a7e78a6e8b7f5604a29dde172a8c4c060318cce1b3866cd4cd93b5510f2b09fa14130878e3d6f2db633a37333a30bc1e7aebdfa11a7bdaaabae7a852fba48cfcc94a502cb9a99b23866cace4894adc7195d741cee337174d15723ed611f55bde2461a4e3d8fabe08bb38761f7890e30549843fbb669549a6063b2dbb143d3eec672dc4f70cccc148f99b2e7f22604572a2a9427362e8a656c0249a399804a1aa993514973318b5dd149a2ec3d2ae057a09b049af1e4241e1d7e1cbde83de6471a6784b3044764adf5b0c04244a71732fa3c9739cf866a2f4e2d1a7d8e9ef3ed18e7bdd3da7b5444c7999abd547bf5a2d3d5d45efdbc77b57783e8f4abf9116645a37b8f9d5877749f5dec6257746c62f61ecf94bdda067ed65a2b8421c1652e771cd77536883c2ab8fb76f9eb837ba73dcc47f74d7b18fd8a3ba5e78ee9d5cd7cf79caf466eb5c3b0478b3dd372cc6af5b0a0df8e332fbadcbea2dfb467a35ecd8bb467b50de9a5c36e07866dd95b40dde057caf8ce547d619bfb8a9ed39e5d4deedd7b70ef44e7be65cf030b881b3b0e305f11f7cec38e3f2e7b98aef566b1d10a55d881b81fbe4b07c7870fc4fd4e9f447d30609cc582001867757bfbcb0947d4a6355305a18e2d59388be1a4537a9ba98a71fa1f530573ec22e3dea3a6215137b5eeb0c306355395c5352f1f4386df3c294b8ce5f127968f21c7cfe5a5c3cec3e087b38c297a29da54dbf4da7aaf0f5469d3afe4477f6dac52240dab36a940f4350a6d424f5b36c62db006ad1a42c17f8522ce1389baa3e86ba8a1e7f1001ad2a65fd1fbb8c00f29ea381b96d7c88e85ebe293cc4b792c359c53a3668a4a8123c76d4ec0f1d1c3b4cd9cf21fc8917197bb62bc749949d7320ad6a0df320e89a27fc92998a28701c4cc07a10058aa02b004b0e9631002cfcd426daa65118cb3dc078cb3681f2ff7acf66ec067790f2c4f7a0f1c5923bfd18b9b4697915f3c4636ddcb2d87c9a797469e0dc6a49732fcb64b9691e11723c30f26c32f6bf9e92ed78bbb46c77799ee7239e9f9257bf62c871f8cecd9977eed49d925d7cc14bd29db9c309413fc4c197e23dcd28374168d333ae935db7c037ea9747ce3b751f676f08003e2b63beca8b7196135f3907b90287aac94e1e7c22751cf7e66a6a867b50d6a0ac1d5a73a91284acad9a44b123aaf1d7eded4de0dd8b7f7b0d7348e76fb4de32c5969b7c7d98e5dcb9ecd760f07f86d5e0fed5bece6e3cc3b3860c74aa2e28ef9e88105c4ed43a2e871805fb471cddf2d7bde0ddbb3f7d07e35cebdf64ce32c59dd6bc7c92abdf93345afe599999aa92d67197e96522a24253d62aba218b3ecf144cf7d5ebb77433dbd0f7cee309fa92c662f662fd2afeaf1397d333afe8de8f52451198ef1773bedf81bb77c33cc695fa2b28fb2f7897a885edf635435ce9215fde8b433d44c7da6b0c055e32cb9c7a9179d6a1cfad1d52bfa91f6a2b6e1369abd18b57783487451bde82bfa9128c3e955c1f758fc09a3a21c7187dfa657a2dfe08bb417df8df061b7127d24faa657a3637d433f7a8de441a2322ffea2ec456d734275794608bee9e17445d3b185fd5e0e4e15f46e98bfef219f699c0c6709cefd3cfc58980a863375b2c133553d2ca290fb7921d93d9ba93dfaf99c4f7b54539af3598c461dd4049ecd94f7f3abfba96f9660bf99bfc7f42abbd437f41ef6ecf0bbd9c37e0f3f5bb1cd9d9b100c24875ba58bfa8a001710f8a3776d07e27e3fc42ebe25d9af83bfead299f9e881c0df7c3dea67089f0dadd8f067e7b5b76945a2aa8f6b056c83c045fb5245101f7507e6d0b145afa3b3f0d694805950ca9e2a97d7ff982afcfafad88a3baf3ff40524aa4a512251f5d996e51d76d8f898a9ccf499bdb39cdee5176fc92f77b1718d2e1a1d67ef869c8f741c723e92bec9f96e96ac44277df4950f4c84a0e423e91b1f980841894f74971c3f4bbd6c247a4d1e404cd5cf8c805d0f6301583976fd063b8d655bf651c78754c50001c1a4e53201153bdab5ac1ad41ab259b6d6d75a15200058a36e7a060a6b66d7ed5e0639150443cf0f29d4842bec7a20419810b1eb7b803f40f4ec4adaf56747caae8f3a4dec70b1c30e3b1b97d7c8e8232291a82805cb2721dde61c92e8dc8ff49975f0374fb30b88996f6a1dfc91b48f99aa3e608dfa4d0a2c3fbb1dec317b4cdb00f78d3aa4ce869b13b0dc1e3b2fd33623978be5f4ae120ef073c1f8e906f8b94c77b1211d07f8918eef654ddbb85c425efce52e178cbb4c27dd75bacbe518bb9c5e48261870a6621002673bc30f4686df29c38ff422be7860e8bc1b48a75f914ef5cd12fb1b8cbfb5b45c0c73d800b7c59e7dab315c81b1b338ce017163f09b2efaf9a8e3e2d38cb3c41e879e444ffa8a9e74ab57f3386ac770e64da719c7e53919901cb676eb823375b5b53ad8639915e3de24a775366c3a7636aeec5bee5cf292d5d4de4ddadb9e71bca83dfbd5caea1be84def31ef727a93e9f62ed63ed3b6dbcc3ab1ecb3c79a99b38c819c36a65ba6c035e84790996acdd4ce4ccd1409ce9428c3afcb392d1f3355ab50ad41769473e5a98bad5ea2608d799a5927560e72d26c35973d10bb0072da71478db729f0b6811d76f89039c0b10b1b8c8153e5623a9caa4a6995f59475bd1b585eefa3e5f426975a69cb290ecbeb69953a3b763b36ba49fa9caf667db364d3ab96537d83dff21bd2599ef3cdca993276f1a280ed5d6efa9caa54769ab30b6b64f7a8609c25f1382e67398ee92d97ef60b7c3bbc1e52c5fb968cfbe9ea4bded2c3769cf9e1eb79ca58525c3af450b53bacc16961249e2d19c73ea28451db7492d9317fb9c3cb296b6d28963ca88eba196f2ce14949a759a504a93884613361813e584bf270ed3da522d8bc54ad825dd0c671a8e3a26118c4ec7167dd15937aee33aae136da29156e91ce10c936ea59354c24c3c720cc0c6f822a385d8de5769aa02c76ff592e8ac2c2db5c585563a5d4cd3647a41a5f66352cd3a499f5f6bd9723aeb8b53ac2ffa9aaf56abb6686bb64e26189da8d33fe40bc3efd56ab55a2db89944b1d5ba32470db6d28eb9ee3877c47707ba79a89b93a89cca451b71a411b39137a4cc99ce87809e04e1bcf4a0b6a11aeea95110bb5266ad4d9b7366f2d219238ae50874ce393f27b5f354051ccfe24e5590879990b65d2d9bd6e2d115238c4757cc3ae79cb666151be19a6d787445cd362956b4299b142b5ad04bb3c2655b57a558d1825e9a15d108d3ea6834e729882dbb78946ddaac9f75d37ca2604fb028d5270a0604058b52eba6653e5130202858947ab15ab58ddb348c7273ce0c933c578989ebb07b4798bbda6834aae1ba11ae958a68c5f048f4da34ee8a44fda7f05adbd96e669fd9b798558c0ad9ceda6e669f99c8769a15b7a573d3b8dcc5571513d5b8ed754528e84aa6eb96dd11ce360d8faec071b316c3aac52256372d13b258c42e563b89124228d3e4a49936271ce5a8b3d3c2a2a56d3548921c2aadb5d6b8594eca0b0b52664a5ebb9568435a1f496c660a0b7a352956b2299995ed6a544a91563219245f99b46233ae8b31c6264aa292d844c98b2c28e93ae9e3a3842d659468431e63e18837d5329f28f6898d427da2582028360aa55a767da2582028360ac52c1569177536c8bd35e9e1d132eb24da90dbd532cbe30453623275562479a4134c36913d987432c21ba68d46232c7764114903b973b54c22993538706899dc2162e23a2d135db92391c823b2884432c2da687ed4d92077771c521587240dfd8b85c921d106ccd1bdb46cbb22b180d7666e48d260888a5bb8e8b0af4b77a915cda1a9c23055b94b9d936c7167c988817d1f3fea1890f7fd862bd5b2ed75a58a896edaeb8a50d095abb58bc59827dc7b23144b8589e5c265392289462494a922c154b511b3a54ab5d00c5af86c793867f464dbc544e09da8231ac51e824481524a291e9148a412f6c3472765208d40990454892ed231482609e2025ec5201b966ec73c4b4b76459f366a7594214c615a765d3852e7800eb0309e2dd8d2d2edb06f8937ce68b19a9d663afadca059358435e6a50eb8cf2eea76640ba81a5fccb222145b5ee4e2e2629a353870e0f0a12edd0e7b171bf81b52554347c3864f411dd149b421b5cc67a6e42394f2c85449275147ac126dc4a0f88a36e4bb23dc91cd4990cf14d48fd92ab2ca96e76e0c7a619a259b04591d835e2f5ebc80b73168a6e447a21b65d47175f48936e463d0b567c9518e824422797ca20e89846ced24600db9a51123274d8b9b0f0c095480e1ef863f4400210973244200777851e6a476d9bb80b81ffeb8cf63ee40e06ff4f91316e58fa9823c6a0be6d0f139b4bd78f9fcfc8fa9327d3ec85495def2a9336df403726044ca0e3ba20d8f99b230f2769c39fc2ebbbc257edd8e1de84bdf389961b703bd876ddc8c8ea9f95100f604c09e73f2980f32cfc37c8d43928655a554a1f97a65ce47295375e3ded837608df94d0a3c33ac31ad3eac31a7bd874598799a76cf63de66359f0390f9209286b4e779987bfe26b6a476b3ecf2b849448fd9c768746ec463a6260f58634a791be0aeb7da66bb8d0bc6f1b7caf2d237c9753fe596c3c82cc7b97453fc688ea4639bd116619c5eb884746fb9cbc57217e9a3c36d92558a444d5cca41268965f298a9f9aa53246a5eca9e5c86d9079c732509e89ee8e16b5f5a830f84125d31d2b8c518638c3331c6187b766c12a1ec18a9d831c6292df86197768c114f55bc3b1ec709767c101744d99188275c00859d9d66bfdd8eec420c73c1101b3bc5b01dd889aa6aad2d68c1ae07d8b50547d8b5d60f60d3cf29652a61ce98356c560d7bfe6708a08b8fecf9b3022df6fc6141157b1e8564cfcfc01f2252ece9f38b5f3b278b5912f7b99852b927ae678705d7065188216fd36377c9b4b27f82b86253fa8b8518b2e9ed49096a85cd8251010936a5bf4c6cfaa382a14d5fbb1df43c98753aed78140d49a3c5d088406cd68d1ae013168c32655348370d8d4d8944239b46244ed8aca8844220fa279bd25f7c3a6ae667d3e3a8e1617302256c7a1f3f80d8f43904d9d9f43de820d142c1113a45d814fe9ce0089b3e16398282263c43367dec9134f0270553d8f467c80d363df52972839d1861fef96382126cf9538a8416a40a760e73ba5364b8b04d20e7a3df4e307e82394440a91db5009480e357b1ecf1362cd48ed1a56124ea0464eec8614ab9f9f090343206a886f81a054828f1f549e4992a4a7916406dacbdd7a39e1e2069589567ce93544129b4620d34a41daf80233b9e87cd949047d2289134960bee357272f934a7f6ec1e9340e5c93657a3f4345351eaaae45479767c9633e5e6da600cab52f9e90262e683711dfcbdec509fc405c4fdb40381bf97fb7220f007e3f434caae7ef3f1510373c0211e94c6b87dcd54bdbcbb77fa1cdec354b9fcc5595028b66a782840a2a80f912ceed4cc5476438c7719462482b9e8314430af912f5e3ec5c0c1fb502f30647406031a3b837182f985324c303ddc981336fc01e2c98e9bc7036a14500fbbad6e222d2781d1fda5d3225d33533559f6faec958b3162c064d9c6e57af1d15da67bdb28cb903bc647f7017318af91325e5e2361728c9a99438c0c9371e645776b39caf86a7419fa6675baa76fe44f8f914587c9ddbd7c7acd35b006bd9677966dbe98a28701abd8144e017d2c302fba05e4bb51861f2e9d34caf82f72e9a64c7a4be6ee92597eca23fc9148d4fd34caf073e1ce7297ab7417768ddeb5641e3e58720f25212ee7b46a7c6854969c2b4b28d83cf99cef5e6a1b97a594524a6d7ee4b96489bd403ab6003f8fea24dab3d38963a6e6b35c336ff3cd92953d66356aa6a60f899aa77a25513ec0f1b39e85b2819d94524a29a7a436d8600cf67958e33c6ae66ed8cd6c3353f258fe214f33257faab7875fd5374b56f5f637369600842ebeaa519f374fdf319280591048ba9cf8e0b7849e85ca36b08b117b01b32050bc0d03a2c7001a5f37dd72cbd3f853c1f4f62f55ccc01ca31deb23ce92957d3d0e9d3aa76a2a7f43b507e7a55ed91b6b613e3dc71a1e333860059a43d8663c8962860a4630467ecae3c8f8ac323e4fbbb78aa291c862971718a516ef74effd4db6c38e1e32582a8d5ebaa8348a5fcd71bb649c1887794bc659b28a7198e3c83809e635dbb8441ff59827bd873ccc61e76931c4ae7e93b54ab9a36aa36eeb3aaee3369b185e233954e641a2b81db57eabdfb4a66d44a2d13f90b3af076c5cde5fee65f7314fba0f79986fa3fc5a8f1fc373be0d4a52ddb45fa07a474a52f0a0153ffa4dab4d9c481a2aa474d157a58b62d03732482f5dd32bfc91be89a1bdaabd4cdf304ffa4a1ee6f230c7f06bc1a1e55e36fd25bbfc94590e23bf384c161db65cf41ae9d9944a30197e9be465f8bd6c1896e52fee7299ee6a79e92e97bb44c739ad2a7279516a31b1bcc8f013b15417a9f41229cfd488662947932d506c3066b59d3ba76fe20f3b49f0f9b6e77cf03046179665d806347f08ca2e36c50973d9c3017e391fcc09e0d77ddb6c36f699a9eab46713e3e5bda74997a46145279aa6d25aad568b0453621549132455a2c747a12b9206fefc30b4e38e8f5b481af823c467c74b1d2dbb4e9e481a56a402d3625b2e76849d8d6b3bf71a1979a68ad3dfb4c705bc9d3b0b0ef530552c2f9d75f189c754b1e8d2bd248cf1e9c4fda848dfb96a8b055b945d5b8f8b071bcb5c865f860266d5105b371255e323509452c376b9bd46aa367d2353f1bb46aaeed7c3862402c51754b9fca0084c105962074810f9e2631054412caec8011592d0832990e0e7db32434d6a54a65d61b7fa86c26e657ff5cd9c620522adcf6e3e04d96b39165969c7f4cd69a6e6ea5e0653065decf91c9010d91389943ddf83ce09f6fc9981157bfed080c99e8f47920c8933d624b308a53879a083203c018a2c8440f1cd2aec38b144ca1084f0040bdfc4bad813893d230ccc3c9e94077b221165cf213e89bf791f5245bf396515b6cd5aee9ccc78fe75ad907ded7bab532a959ea46487441d71df685b9947b699292ba5ec7b966cc5899d943f53f736fb8071f6ec733e9becfe98a9fb9b9b9b25ab79794e8ff48dcd3b7da36f6a66ea4a7d3333810e3f79d6cce127b5670f3f211fd12fa7a77c8f201275dfc34cdd3b83e63d97a3ced4e13ebb4b0017f6569dbc9faf3a5487acceac427b244dbc9f526e1ddaf7b1c99d403375ef69385357f424223d5f3375efa313a9137962cfed720d9aa97b2e57a199baf701b326d0bed8ce56831883c01a70aaee5927ccda9b6d6eb69b6daef16eb427b57783fdfdca5e7db344ea19fd9c2fe79b3035c05493608d89e97a6f9631a200c7bfe612514e9a6d1ca5d950d2067567778252abbc3d543977ea37f82da1d108ccc102fbaaa2f13ae2ebb76d723398156357185015034ef8530c54c51d99aa90c6ae87f0c63e59d78e289fe803455a1a1e0fb059f9982a521edd66ec32ef70cfc3b5cfb2fcdc2ae950fbe8c85491b4cbc58275d14517df927817bee9f5b1c854d1d7d12bcc9193902e73127a9b93b47cc31900df16b9a9698f01d3c7ce7492f951e6a1f38f7ee5807a0664ef5ecf03e6e054a357b8845d3f01a8c3ea1d78c05bbbe8f52c79c9cd92e8a03e1abe929e3affe671467dd1e6e804b451dfe5580368a3dee608831c77e61158a3461e5843894c318135eab527767da6840c369ea95abfa3037304790f538563a64e00693c0051f5b5baa2e683644a1960ec241cc0a0d3edc8b2dc2f6280b1c71d5883884c1981358e44160c016dd4c724767d4402daa8973105ac01296245927eb0c4c18a3b3b7347c69df804c37c640052b9a40b686065b2b3ebe9e7484b25a5e5c1ba5c50abc91117da8ea7c153763b6ce08d44d0997a3e466b357c32839227053c2072f24638e79c52ca39679c738e443672dbb3e859f5f398ae9999294a29aad6fae2c2729aa912d682c9995c98c56d195b883042600cc3244a4a1a6c6240244a52aa5bf0cc2d2df42585c549dcc2037a3bd40da4f2ec9b0965f320370cac11376a537d8f019335358bb459750691a858eb0f6b7dcc693353f1d2ab79482b2f0cb6082184f7c14e5a33b51876392ea4b5b6ce5dbbb0aff5d18376ef9879655ebae3513f6129714c7bd69c74dacb3b6feb9c91281c5305c3cba9854931b7028cbd45d2d0db9a9982f76a2cdb8c67e0c4309d394c3f5b26ddb3c546a2e05baab55c462fc5680ba53013d66979a0dbea1f12054f35104c624db611111c6b3792478962a4576ea66175ab5b9361c7ec2dd386a8d965679aae3065bb0fdc7dbfb968197eb5dacc7e5e5b2d0ee6b4d8cd50a727214edac675a2112695585a5c4c2f4e2c305e3c9818326278d633626490990155f79602000d345032355022aab1a4c132abd64f074c078c60531d66302128d7fd0fd9a1567776250d6a86bd4d99bd511976cc96b7a315d8197bc3f4de6ede5bf6bd6931ec6de362ecad83d99bc8dbdbe8656f18c6de48a5177b6369e1e80f417485a9da7dc0a563804bcbde4c2c7b7b51dadb89b43718786f2fa3bd79a2bdc1747b8b2163db5b0cdade9eed2ddfbd696c6f3362e8de64987b939981cb32fc527486292344a144545358a33e560aadb44b6c3006956d5913ed94686d94e1830415d1d2b8836951c3c36abfd9efe535db23bb764de3cc7bf91ef3da27fee2f6ec77a6eebdf3198f964f93002ebc696f759bc81db9238f4427b1eeec7a9bdb64a66afd2aea88bbf2a859be194e0f8b532886a962bc98d44805507d8c32b4eba394f8922afad56396d6481a560dbb621b0554a845ad41d2d0d7fa99a99af7c97ab0c46bc39f2580f61242d876c39f257c763c375bdb0a9466a71816e3ef89442bb6de75ed23663d5a8fa74a4aa9e14c699ac6306a47ddb8459744d90799aa4deb2eb624caea4894fd009260160e6bb5871d07cc61b7fd8f1cb04d6b1aeba9ed09108308e0c2f22c3c2481e46b0b09e5458810ac62e7831fa4d26a22892a12687b38c0cf153453f69e67a31d07f869ba87f6249a8e433365bfed2391a8236e1bb7d599210b4ba882cf073f1d4708a104214490a024a9da08d31385e215fbb885addb5e0eb1973bf0c7c8ceb69745e411a99a9ffdc5aa65ddc0c2b0eda38e3dc26e616f489a2a6fb5241b24b536c53e4e248a5627b68437f88d07e6d09b1e930154d5201c6c8a29615b132302736ca7c75a0075dcd3634440ec08a81a9db6ec10a98aa1d76c6bc710a150ba3b11695144678c51ea00e759310c638736c532a68033a199b8b7cbd96cf7cb15306b06c3b062545648a628a4421a8f75b275dd37adc36eb3bd322453f4dbc6c56e0766a5cc143dc5503a3d2353f4f7cee0538b0230456fb304e00dd006fd966d600d8a812c369dc2a652ac10ac41fff204cce25a160ae79234a2d3733ad689934d0fa566ac49c698603337a20a73c9143d0c4c4c0c0d1a339bced82dec1599a251632daec5b5e8cca653ea14ae3555b6a7c7b3d45a4c259778d92149b3053de692343a941269b2e9b12298114903a140c1b3e9311e5b634bd2b0ac944d5b568aa461d99e4d2b149bd6b029b54e7c248df604e6809bc618bf4129bbfe75124ca931e218493196626489b1254697184d4e5e8030dd6c8f65929ddef2489aed549b5245d27497524202b3e24558f768ab0f66b7c875ba3e118d30a9c4d2e2d23de0c6481485799669c01a4eaa0fcc7103d60002a4290044d1d3999951114234ea14d40182d7803a2a944803e6a8758a4dcfb2b1290d9b1e8503d6a09f50a20e03401bf454c7a667d5292885df8ec01c4230473da578c60aae357b600dcacdd41e588346fa8235e8675437648a3edb335ac076c80a499a2b9286c3ba06e4409d64f416891a692b24242451f44310daf4a4560c4d7e9828f2c304910d7f9870fd3041825d37fc59620b08c89d3d2584318c387698398063eb408fe1b0b265ed8e0a7ff4b9e76f28d9f3389220b2e76b786c9a952d49a32369263644d26060d8733e6801a89cc4147d3e1699aa20779bffa1e9a4eff4d434eb6435ebbb66d25c9f65166a3ed9f338bbe84e124eec5176693e48046d9a33ab6a8e4e9863db944281a114428a6c28050f74362b0158131b8c8972d2ba810de40044d2d84c9bdc0c8e0d5f73433e622d38f380a92b65df471e51c60153f75df661c06db22b0aa6eeb77c5f71f0d0720c445d948f5d0f51f7f35e60d747ec18defbc3ce409f4c562db66a6dadf453eb55b4993de6e97bd8631a07bb3d761be137b1578d638f7d6a9ce3ccd31e54f7c0b4d577a6ea73be39277dd53777dee4ccd7c89ce8439514062fa612471041ba8e90e288206cb9a51c02ddf0e7881f28c936ed50b3b2df2cbb96753c6599c62ad52cec83ccb952f600f513a694524ae79c95524aa9125ff8c110b4d003152489820a5d3062e40b4884945841942f1879c12b57e0590212860c6106493eb9042a4754510528b48e7002cc0b52788195029213d60528c44b4587298047cd49639a0b27bec0829ed6932ebe9c18dcc0063e3f78c1075d60013664650486175258817d71f63537166441a02dafc0810d409881145c30e2e70656bc8676b86062049321a2c0ba50c3e475c40c8c90524a89654f2ef6730412d765c39f23749a70553bc61902d83b69d561b913f6991b1907a4a21d91498ddd291861098b8513238eeb624b29a9702d30a60d7f8ca0c266c5105161c8128f5d5a6d3451015383c6718307576c16f4d182158f4628614b6c4b29f1e9301bfe18b1832ddaf0c708259b8502a24c5031a20826b065011546a8c0064608a127c0b60b5905675a4c23d80a61116482d710ce964087b035020d03b643983c783299c0d749fdc19813d4854b32a03f28423aa188216a508409a8d0852c02be1bfe14e9c2ec01c636fc2922a40429968b9e2253d8ac99266096282c2822848905cced00a8a6006f4c541ce0171bfe14297205771bfe1449c15cd2821f84f821628809ecb2e10f11572021220948808204246a141f29310c73f2849528843d23d42360920f3582710f0b9e80816cf2440bb4f044096a921c5cf9027ed53083233eca962f3684d2842bbc603b7d06f3c5cfcc96f355a2e20b4769441bf28751074621a0aa3b115b9e46d45181006cf9987dc01a92874cc9c390cf536056d49991dc678cf21cc7e91b1fbe1a5362b6d10c7776e366f7da7ab8c1639f1940b4418fdd90284af30d2a5110d2209480b18203110cf009d51235961b4c15f076b8ebac348921f6b7391201b360de42b95d3fe43681e725c41275528259ff943798f293526451840e6e2039c1d03733fc3669a4892c3e1fb42c6e221746787d3ed450840646f8e867be89407c3e40217c542ff9e18a229f0f36be1003a08f93058837510816adcf871997158e206ff0052f0431f4cd4c53e0846fc3389a6f60144d803e1fe60f988d19dcae90441374be9937227c324ac9b3cdc39312f0051e14f9b6d8021d3489911105f874ca1ea66f48ae29419fd577a6e4cade6c57f8aca414fa1ce102295fcddb153e2770f656f246df99c2617e3ff4e03eaa6f7c983eccb8010e4b29f50e71cb2a1ffce0f73795744a39676cf0d3042261c39f27b410dfeae6b9ec71cfd9b566b8b9d713b6b022eae26dd1deaae5a69b723e6abacb5d9ef3517bb56f4bc0acd864aae24e4b8677a6e8e8acd884841fad481a56ec199148aaadc7e78954b1bc3e52513a9d2265d752152b8082844878d47349b02b8d3b3b272017089885da8e7cbf37a40a88ac41d2f02051f57bfe34b7b5eb15102fc6736eef34ebaa6450420642e042491523407cf127a8ca19a207433d4e7eb278c1135f6c0253f5717b02b320945b5d4b223dcc1b424a7fabd7e9dcf97871d8f57039ec56a6bfd0370220c267d2171281093f68f2b53c6e16b4e2a22d2baab04bd9a5bd9e80827da72a36b99a66dddb64ce3a352bc626194629929736a793a329447636fcc9416bb3f0865d70020b5a95894414284e34e1a1d5892294dbf0c78914ece804102cfcc364e8874910fc6122e58709d00f93289838a182032b05f85972455ce204ee677e200e7185124950a28a1f25844079509bb04ad460c76f1887e412d9acabc4901d7f332574769c8f35b8a866b367bf750b883babb566dfb40ef0db23d46aadd96316f7ec1820458fd8a6599b96b173f9becba26f9925bf45007e3b77ac83a21a49737dcddce43b203c6c0884db927b776deb720d2ecc69209f9b06c201e1b60ef070c7d8c1d36e878c00bcd43ac0dbc767b55e6c34ca4078d8f03ac05d37fab9490e6a1d24eb3e8b9945f746374ab76f9a87eba01dee0d3bcd9ac56dee5ea4b977194a14a759746ff43e5ecb705f03e161cbc76359070fdc6cea3920029974db1ed50c9087a7cd82df21bba811f1b2841723cc8022084398e1a40752e82b7cdc15ec781ef009154011dbd9f135333e38846268dca8013e3912036c9f08a245fe0413436388139a3018127de81114d4249ed0d9f1d8bee02707431b5ed97106cb4195cdc25be6e0b5e3f1cdc1946cfeee8901619be103841f1a540186145eb00045108600630a3f4d849a046dbce14f1329337cf00328433f3608ca9f910447d3a6b1807486931e4831658cc1062308c773db8c2751a840c7368305586ef863832a57b2b7233b9e8b4c7636eb32d1d93818da2c8a832d18d9e06724c15ac6108612f584d066d1192dc0a3edfd3cc164c39f2782b0e321cc134866abdbf0e7092212d890882280967ed6319701f3723a009427f47ca7e7677d93638831e3325c067de37d86f6562f3ee333f40d8cbfb8ce395f2f601390cef0cb199a7c7230cbe4c3bd46b93bcdd200979f40b598cd4cbb084029ecfa0d76c1082c5ab2b301b54d3e4298e50971df3c2118783ad1f08235e4156f08e6e85a22a7b149c8f38139baccc36919a4bc522f5843e624fa9ed054690d652a3e7adce3e6344b0332af9e1d9f794c3e2210da2ced40ea8e0e2234e193f56096c947bbc947d2b070d046b5dca2f3ee6d08183d44a0c10e48a0e4c914192822032b9230c50d825862cb2fec637a6282924d3e269f9721980307dd9b96d2c432eab04c36ca2d5b976d6c5396913953ee5ab24c904c151bdb944523199fa9ca464c9925e723b99bb94283108d160d42340c4dd50c97a741babc8c8f0bc945c6678696cc4b8649ee813978946c221696161616979c91c01a4798c834917122338305a62ae62bfa62045c655e32415aa68a44c9938c60563622f3b281ee24323c1bc947321298a3b274cc08451bf2f7db286725b927f308c5c8bfabf698ecea28d3989d46c9e8f9a119349c1f9a1fdaf762dc04dece32f9b058d725b32829b3f066c9bc58325666c8b06cb3b2912d911c893729417244a2aa8c26530f3cac912f556019574cbdfc0cad195c33e8481ad1e569280273902e8758199773b945c69e5d2e9d136d975c7a4b66f9688b72f751e68e733c29dbd83527d1f917f30d5238258c1013d58b442ca55c63c764fa910ebb1d33421225678666ae48949427c900b3643c211aaed0309469d842a2e46580b2cb671e79536baa64b8bc49c754c4b4335531990cd09690c60e0d421225ff620566b95c9109bacc4ba68aa4d148b572e75caeb80cb96c216b8d7995e155e6b5d69a67aecc0c750bf084729c11cae28c90a4a901e2c021c3036bcc5c9919eaf20d29f3a261878617ccc15d6ed784e6cc1158437ec60acce5181e58433ec90c9f119aaa1974ce3c425bca2005d690b71105ccf284328f94ecc9640f68a65e9e100d42322f168d9d4da3c592b1b2696c276096e9c8768404512ae18972e36e67836be372869fe9c854e1289266de74c44485a4310199a8203581a9963b1be4ae39eb6bad73b6b104285a9c9d55d2d8846b031c73160ec241db2b267b50666a7bc9266c3e9bcfe6c304c36d6a329b414686981964648889bb09939c792ca09fb5b7ca8f798cbec9cff93652122cf3a261c706154c372bf67850244a9a7c6a66cef093dd4afb661c760bc8fb45e83201b3324fe6992a99cb70d68dc93c99674b196df291c1e41377624c3e59cb9ba69cd483e166997c2294a21a3f239f746e69df498ac92749fed43255644acbbc7286df7604fe66997c4c405395ba419328945cb10526a8f8e44d52a62a486b091bcce049134de8c2276ff2314179ae8921f3b8222306e70426ffc839b8e0054636e52a9895795eafa9320101a6e47f828c20b4a589095b9e2533b4e56baae01724c4921932f9c8987cb6bc8c90bccc90bccc4b2628f3489a175946110268b9481b2e3618c3da028626201c9fad8037a8ab60088588cf8ebf449aec28e596047fc714e0781945f0ce3623090da9196498916388e1c178e1c2421a755bf6aabd55c55e6900002513a32f03e6e5646a29611167b5b7b2bfb7cff9e0371a34d0a0a1b443e301905357028e47653c433e8501cb6419322a083826cfcc54fc8c8ce308d639671e59c0db63780c5b10a656105bbc8c6c937d5cc130f7720e4ff04b0e3253f130720f5d883fe9a800b3622beeb8e458440adc92e311961c794c39c0ac78a4442a91666815a114bfe1111e49e944d2c81d5f084d19e2ba10ca1423a21c7bba1c9b04017339fae45316b09623d04c4931026645a0f80a9aa9f81833887248d4212f87c054fcbd4040b204d146bc1cc29240728854bd88921e93a481509cc82753ba6409b64beac8289286bae494294b1075407a3048227247a2a21c2251d10b3df12c39240ea172a87c154ea7518ca794d2295409cbeb3ed1d36ab58428054921047b84944516654bcc4951851e69b55a4462d8f2239726c5d00a44416c28d8f21c0a3ef996ae888cc8abd56a15c1c50083b264b65aad16115b0de813a156ab95026d0906a508f2d56ab582c89890ac006ab55a4544a141d142fab45aad21b022944cd0d36ab58cb0542e0ce29156ab2544a542d71304d522f3c14cabd5daf1b6fc3c55f156ab658378e5cc509efafc0c25d19250b22e4763e082cf1444eca9e5969f7c8ba481d9325e1b8c29ed68210742a650dc9a228b2f4c818525aa4c89e275b3169220ec208a206c0b285c4489820b2ab2c80cf0f25141cbc92b8a216e0acd234f5caf272f709982d838a09d2a8ac85e3d40e822065806d433c5158a020a2b98440185921ad000ecc8570fb4c88ef0006809c6844481767cb0830cc8074888429ba1458f50e9d15e548e5084d20b212a970a9d14a4583962a58816d90ab897143f4fa4f081112174717a0144857e841045ebf9f9410d5e3f3d9042c428cecb1da138d132edc86468c73f602555b1c5ee78fc920108d229f1be201684b32ca0e68a5b10342b028b01ad01c4964812132d0a582a42bc543a2a645a40f97af9a80342ade14f02c24629666fc423ccde1b29a59b9453885743cd70af39fe7faa794d23a400c34b1e2469426f08854a4f8c342e3b7e263ed991084bbc6008289230c4129cf0c598c4882881a21c000913ced18454c0282c58e5c99e43229119911ce1d9f3741ee1624f189c000656c4c0889f185c61cfe3a8e9c19ee741c59e3298b267a5caa884ac567555cd325424020100005315003020100c07c44291602cc9f458301f14800d86b448644a18c9b3204a424a21838c21001020004000440068482b00b3f77555ffe8b76cf6646da0aa20b0e7fdd5505b83d713179c42866c1c3595a183a42b7d6512347592c825dd5e06a4f0c80a6eb46b8f540cd6043f3346c8bd7c613413bf2525c835cc075a1bdfd736162e1c3a82793bafbb185cfce17a4949b378b3d173416d0b1bd50487805fec95d92177545c44f358d4c499b673c6ec033d7eacbc8e370298093baaca028f8debdac3f58d6e54661641e345e2d269290337638431a0bf1ecf5e594ef0dbfd626e2cd21b7fc01ee4cfd65fddf2755ccb176eec385bb3c66dfa38233deb39761c87156ccc190f89afdc0c76084008aa8c400cc2713a0fe91affb4f97df6d75006e1fa0d7e47746c5c916b11efa82f87d647157eb3c98d4ed0aef661c1050a2065fbeb35757281d667826f7d2b6a579c04973d17a205c88a3afcc44d7ba2b5971b76ccc485dc2db115d32b5ae0c45ad79ef4f8aa7c4b4654d98be87f9beccd1c960d615281e03e01a7811b487928152c8877f82885d7a04ff3d293432f927cd2e9f256901166c4c25e4b697404a9d1e049c036db7c2dd27364d3713ed797e1984e40032ca85dfc5f4f78a833ce7dfaa0e62a882aa9cdaab4c7973c482189934f58c8813623dcef8cc0f1a8ea0e5a0a8b06e64889f1157dcf30962c3e079815b888bdb02f56ca01a09c13ae0ef14c03f01f5d4628c31a6a06b9531e3ca439a738e2867be0e662f2807574bac963fe053877b4e60167b9c62e0c48916fb91a124284ad4e2d7798eded650595203812cc5861ebd21bfa5e45e11250b3db02daed33666e8e5550682aae3fc4f1d33384b940baaf54086d784b52b3a69530591166f39ef57aa1916fcf6a0117e520a755d52e5c6ac0b5e12a72c0bd6143efbe9277e6c33710bfefba882d8e40ab747b29aab784c8430a0f515160da5d0ef3577b809cc4003c8b001239570d35f3ab50e53c8f3ddd7acfbd9b110c6a2e610607971e112faa4be25e7a792b6791d173b04f6063f091b2665ee7024e10c609fb6efd64d0a981a03ce5ce09dcdaaa46bbfb4cdeb0e762e857695a982eb41a138a855a9fa14dd7810190727d353be044d3aa2ad98306b2decf08b569bae1cfe1b6daa7f4189b1d8415c26d719004b2fa707b882f8b90eb8a8be4f8ec437fe7838f4b18525c397778eda17d1c99ac7b79325e45947d20ea62416e80582a0746756414631fa958e8956db434ddc6d7afe5fe57dd7bee59b2d8b8396d370c75ce1c91d36b4cb2351e42cb1ffc0dacee283433ff24cf80882c0a9dfef29ad070310b063dcb05c01282cbb69e5eb47e05cdcb4e59a7bdb4d736e80494d4ea58b4285ac1faa0b5841e87c61cf3b248aca6177550c8c4cdd7a5e03334b54a73d8090ad34decccb66aa5a78441f251c09c36e7009a91422adcd4598841559fbd3f9c76d8e60e132573b2610773be833bc6ce21af9bccfbb2ba73968390ef160c6710c8647e19c903ca9bd433c316a8ab1c98f0b2ddfd008b0f828940e04bb10cbc6cf727e553404fec79eb9fe612f7626b00af078d1ce38776dc0a68e21049be7af385036f6b3c824877820a3143d5077ff3ed658501dbc0660592f8762f138c160d5cda3da8b81c338000502b60bcabd914b05f5b3f29b33c13255671e093ca82d2d162d308cde04a4e36612b3ffecd6fc1a3ddd3fe83292608e5888a6d32ee5a8f01c009739cafa095bac6a7c3e1beeb2a2bc38dd712b7d6f549bbd6845c81adbf066ed97b325a3260c3a1b27e27750e64b54bf8d8dc723bd2d0a85f27e35b9a4b647db0a54729583233b9477f759dd03b269324c801198fd0471f48b444b898ca29d4f41d5995d307dc2190786273a249368d425dd7337487348fe1914bd7c665b649ff561a65d3f21c3565374be73082238300c4282c2db90816c4c10298d8fffc283cc77dfc80baa142b8df68e0f0d26c9f84ed0b4d130f4e39cf85863d260f366578d4fb2dbf8b242d6a9b9e4b0876c336ddd26ae0eb1fc0e9805adc8dc65c079cd13ce7d03927290d2e4d99e500c575f5d89a31e0d46439a5e8b61e6ae9bbd65997d09120791c00bfca07c5e9aed2e1d684ebe3ce3c1603c27c006ca681d83efa3cc6f5b5baa6d622b76c888b96237169b1e22753411c3c9aabb1b1484d17afc5b8ba294161faf7e0d6f5b7082f86b3c171d6de8835d78c38f8651493e15cf1da0491fddf487a83a046986342eb3bdc4f7a2b0796b9805b03bbb12456ade955da59d6fe80b57afb052e0b9fdd147938e33463ab7d7966f456a45503861ad8e992c31e717b25234bbaed584f4d1ac50235e3e4af52afb061ae296f4c07ddfd86351cfd00c7a7725dd437305ec76db28a51f6483f6bb928efbf0629a25c2667f948d6794861bbae723923e175575f84ba50f1bc0da89ded542998c5e1e64e190714b04cec8a10b89b4b582fb7688a97b68f1f92848358388199a60c99944be389bb29002408ce6ba5771b1d46a963d873dda3a9db176c8ff4fee35cf12ba9f2f123f1681820e396f05a411d19848a261616cbee1c84ca681d9ec6009bf2b7f6400ed2528505f42a5244e3b988a01f601bb5b857a3cb2fdc6e99eb1fba105a36af6cd7fd283c70d69bb7de61e0636d3ca21bb0446ad06aafbce8cce47291ecb088805ddd15fed55b56a2c1142d02c94c152b1eb7448d052047198da16f525cc29b6743f41dcd910476edd7f6a03222c39695f646d234de9f872c59c9d150f9b58f1df0565304c986fe10f5e7d25228d09a353717ae4d6211b788d0ae1ca0d5bb3033a950eca70d4314d548620a7e6a731e91eaed00b783491f86067e8c8e30323c951c614a6f3a8509e60820ea31a0e6d4170daa837345cb8100a9848d87f965a6ca7f9373809fabb3ce9711d3116f26d919fe65660d765d4f80a3257db7ae8ba2d1bba7d4d9489bc6e3248e412c3a3734a51f73662232e6b06dccf3119384af49d4181039fda5c5cc7818d65d0a0b08690629c1a7308f0820182cf090f0207fae304c5b05399a0cdac439c2b7097439317452882f0ad3924a06727e23f03184070c2303afe4c2e3253438b8faf913208c824b8c8fda14dcafedd53312fda0ef48c932f33a19ea167011a41eaac5be6f893671746993ee664e041710a32408899b0fb50469581926fd9fb54d6705a3f195774640bb35bb1fe947245a352606c6e6555be4cad1269aa74b7562e0d638878f8b2cf0886904dd7ff0d60d2e960645ccb4a0792a91248b373b99745e8e49c5ae859c55a7d08f8506b3b4ed4805e3883ab4482c08d60e469f192e7430f4b9fd2ee34ad3448dc2c679f17ef658d9f955b721058fccd90370f1302463edf6fe7c8fe0ea9520c7f6be8f7fe0aeffe84f41f44e0f758c09e9f0f53b2b74f0862a741e781cb078dedc1b107785416e29f188e889d703b1a75d02e6ca28f91e827859b2e2092e255f478d3bef95f315e41764f9a42000d0cf5315dd95dd8ea80c4b8eb9e31b455545b9bb7eb5ce138d58737bd0b1abf519410801cdb7a01513d27008060e3fe9cf5e27a2cc9bd850c3cb5847d6206d2b0c869d8b7b860ac86166c7142672d43544693d589da7c11fbd865f2f7d48bf0a14b6efc709f10489d10bc9319b699f3fa6709e50aaa143274dd2df947d80cd647c06f90bf8114d750c4934972f6cfb37022e1cf4bcc1bc2c6588538220c84f0a438b117e97c253074444c50d8264901104dd0c11819ff887c930dc4dc9c5875c905baae28a975f7bbc23c647f4697c1b21698b475abaf326a2312112285cdc8d401d4bb8a699e09db8fe15af45c93918df7ceeebfbd0c2760a034a4259c6178d5e6ab12e0e99ccce980c68ae0102a8a1b0817798c6231611afedf6b9e31f3015267b34478a04bc3312468690319c24584d119befdef56c02229249eb5bc7bcb45e107316a71feac36599620308138c7621051185bfd383d5ae03794cd1a65e0c309c27c16c7ce8cb084827c605b695fa8e242f4c9f0e98e0ac55393fcd27fb29a60b1c1b4cc4e4405ccafe0d7204aa0e7270dca7355892ef8c74f03ebde32d2e00cb1782309e1bc482a424063c4c74ff3a4cc8267f69ef3cd725103981643b0848cc8133aa805700fd6f11b4194a810bfc37cfc0f71dd67bfd35885a2540b63ff07e11a9e4e1d3198def6c4f39b4f1f0d8780e7b02c3a3e3cdf9a6fc07143ed7585ccc0edc58303f18af727610b751717e84a8d6f055de4a1abcdf264ad0e0a205eaab2ef062e01d06309c5f741b3a8fb732f29ae8e9680aba366737f6352f9f1778aa8171535aea9b68c6c372a235e75c1aa45b1dc60b46dc9411e05bec17333408ebc0dea97e13c3496a60482a1043929b9f2435880a3c847270655d1220514659ebb70cae634a29385d33903c4b2cde490d892aaf61d57d06bba8e3d9315e564640d5b19396ba1d5a134df71881e91f2f781f12efe25794ae67beae767740c7ca4e0d4e6e8d3accf817d82f97510a0c0d6cad9effa3b759c72cb17663df9541496ba2c84642d02bc0a4b55b51fc0785233082f74a4942dc4a101c8669ad8726175e390a7ad7821a0d09074b36cb448331ed4fd582521b60e47f79cff837edfda858c07b18539be4b6006ae572ab76b9535f53206ae5fe0949f17ce96078cb2053ce03dcfb8627f11c912e2586b2ed3911fff25104c4d1b08bdd32507ca45f60c5ba71e9e21e2d30b2b131a81a1ef0e841ccf9d1ab1d49c715dbc0cd595ca8044728968725ccaebf527f400ca0ab5feb24b5cc29364121526c4f466643ea9b97b55c5961c1507f75ce671f108508fa8af7bc5977a3ed049ecd6854488819e0a15d25912b7002f54cd8a7b96e03b86af65a074c9a715950ae298923f3717024c4b241d1fb113c413588a266166fe252e15d1fbf1b83ad4f07cd3512b01a23e0a6a9498011cfc4fa6a326355b853b41e7599203a74d8885f37d6b0b3377fbdedb46a5efde546636709a65781a0c6f63149639ba6a03d2c450d2f8415da4f3a8cc1128559175ae9ada79b4bc6562b0c9ddb078cd72efff00fa4666f52a88f7eac83f9cd3b14192657596068fb328ae87269d6fbc507ce311662c0b4167cac780391217e5f166a4012b4edc079566893356a8b0ff20462e34596af02c57603c2ba3e47193540e599ef7f4653ed2ff8e513b23056a321bec6d16d1bc66fe7eff261e3b9c00c774ab064e7b9f6d68ee1b1351ac4a236745cd0de32f3d8b4d09a88e8ea76b8e26ab9ef258ba54cc6bbf9f116fbbb057abb00155fb58bfeea2aa623b6ab9322637a9d32cf39f75ac766ca452cbe40ca65a6ea0eb99699b85aa3c37d43739411a94287ab77935e9cdecdd68b83a4b7420f71e0bfaf47be420570361eec03d64f7b1612443933c10795f455eac5a16fd613f77a9b90a707651ab3e225a15cb25f6056e060fae272a9ee47c2c733048ca90ea25b45bdc37694e362fb89946e7a33935127f9438319b60f8f0bbd7b0b4ee8c25e2933267391266ecf410fa4b15451ed67dca3ce9d959b88fed226ca830df284a98cce1662a61ba3f6d7551daba92852f00a5708f4460e67e4cf8d2fc685ee261045e3a9c94e0ec4d1aa5f4b69517440f45240704d48ab4852dc30efee02114216309ba7a75ed1abdbce2d736f6b58498c43ada573082fd5271bfb8a3eb3ff2bcc23696b5493710ea975de3b8e607ce092a44474ebff8c825bed6c5ba544b1cf62204c9c98d47f6fde063c29f0925b92982deaded2c00b388de804909d0c1376a8a30e503abd09451ab7d0c8e2ad4f8695bafa2ba1b564676e882390a11654f5a2fbe5adb28b399f753610091fa08c0d7e8582ee0e883229269e83122e49132bca7b73a10b632d7aedacb062ac172eaf9128317ca0c9861aa619cb5d857883894d0187d94f29e48b5958c8116d3ee27958975c32f4a0899d22ac39f6bdaaf8cca19063abebcdd789f9e1b7c323a347546f045c438c52fd477318227ae6995accb055c0889b56384868f7ff89b0251e8692b091f33c5874089a62c74ade160c30432a15a67e086519629b3ac72ba008c7cf3d70ef575e6d6fd1517edb5f01f4da270db691368606ec1c4aa66627e61c4951ad4eec7a2350bcad9b103d139c243a9e81c0e407ef33e0fd31029d4316f04ed4f33c8ddee76d236bf065ec4abdcca07163a94ddf23aaf7f1ada14689fea40bb04d7c2e3045a40b686417bdae6b6ff8536f05e8cbfaf13b4e4584bd91ef2eee05eb3aaf3599b380b14bebf9044741094f15055481c9fdfc64a7cd27f95c05267c0d82061bdb4efb0df95aeb543688cf7cda04092acfacf10453c13cacb9ae0899d5b24c65fd662b63c72baedba30b25aa4696ce6102192a1e66e2af574ec0e71a5d71f695d5ac30530f52377361c6a009a20c357a013e55e2c24cf3a84025cdd6430b7d55249d1ac16f2d0e146181ca6b2f01ea4efce15dff84682286ab64e9d3e687712aaa147fc31085eb17ce37a9e25d7c72cb6dce423a9c348ccd0bf3026cd2e547ef4351d717cc9b2f0ef53827e2df1ff0f6bb840c3a44e609fc20fba26483a6be1afa616559ef591a9603ec596ce817a6f3b86a1abc82b606e15595aff22246ca7d92aa18d4de13d03ec814e350ccddf741124d2cd50a1f2a5fe068394bca55704b54945960e36dcfe689becf99750e8bd18ee3eaa47e12466be8b48e3bd6c6989bde0eb14a2e1a864fec77a625ab4b3049a89805f4074ee9571d3ceb3e3ea3e22851ce5bf40a18e7cf50e787da3a93cb2419c6dd70f59c7a8332eed1d22ba521848c17437cde99c9506d19e8a461278fe319439e0c3b96044579ce88491d63fa9461cfcc264295d13681c6ee0d88dd6450b3f4de234c8d17a99082710e4d4bb4ee60b855f6076ce8e4058b5329dd44e10d740b69de25cc27839a4f3ddbdd8ae239a9cc0a603834a9e75711aefecbbfd046cc72b1332d8f5c15f98afb13233f9b920f6b2ac5d39bcf91beb3a50f415b758a99e2a4c9ff2b1d3183981123ee27b16a1f462d25d5304290008e383b10505cdc0719bb2fd363183094456c66ed51ae4dd928fb1f19b906b7b104ca6fd1757147c8f54e87950e04161dd5e08825d69956227208e4183183648d514a69345091f2eb484f1e70883362c0b60562ef8b412eb4950e5308688a75d63b6fde846e22fb9d51a941e212240725f2a7bc549ad5200906ea2ca5870c029cf84ea145b81afc5669726b5cfd1035489608e1cbc0444629cd0cc898c47656b483e678a034cbd550c9cc090218d5892fa12567b5b00b9f52f0434389a021c55a5c6e866da7c0cc6c26d11e7fbc04c44b61977f40c0057ba734c810a862aca494b859692221c98a0fa2162b41a7445210e3e270126599e63af25412681190634426ca2cca3337987445258381009b78526019560e5fe9c4206a423c838fb3e822b966bf21ea91c8330c09e131d149932cec7647f77ecbc17433090c023804cc4a586d269a3c768f34f641390141feb1f2bd313eef53a09ab832de21024f65d3a29f2566e6e1c877235df9bc18ed9df1d6d8b93b020d21025fb59d604c75ab38fd57d11995791c2c9dc71c916e5c3fdc9d40f73ca5209a1fd2dd5fa9e2e9a14a88210f4a510c3c5405309460c50464c7870faa080c1eaac418f0a014c748f4b727f8b4eb7025c67087552c46a2bf5d0f57110c7358c46124fdda93beed7a10f9511691285d0f08f7430ff40276f791bf5427d93e15ce4da3452263e14c7cb5d55f0513ce4216d67d89e79b469e364008adfb5dac0c036f55395f8b22c95360eeba29174feb03447858637242e2fda1d6bfc62d0543fbd182f733508c5fdcc024a8821026aef64bf48f8197af0603e85a8571b9191d2e7532ef601039071b62d7062a036107e2d964ccccbb70258d7a260ad4663ef3a2c6f894890d685eef980290a40cddc6da729662d7516860a3914987ba2b3328686a45f6e7891f5561c817747e7bf634011563d7caa1e3cbd1c4867b89090a0939cf196592f46ac26fa1c7d628df7b3636f34c5adb006555c67374f1bb0ce7a9fcb2cd3f01c2281a985925d0980aa9fba47471cee2ad45a291c0b6e28382f7e3e7e5f15f648f9cfd923987db32c8da4328f0ecd47f53d7ec095a1d8fe868bbb16edd14802377c8708fe5a6271024199cee5ce544107b3b6072968d6499bfc60f04f4680fc2ce5a39f3be90c2812636f3c48303d7138eb3a6a733e190642fc4e3b75214e5b30b0a19d05729010f6de5505583729001fcdd44827f09cd625b54fbee2c306dccee9d8ceebd238de164f43c6bc062745ac8b2718ea15a783f6ac45e67973056b7d71a780641fdb9cf45ed57814cca9cb9eeec1377dc5daaf696c0d470ddb36cd3ba91eeb90b373a8eb294dd7ec4bd4a52dfb9dcd373dc4d96f5fa80e75b4994807de0ffb7dafe0cc016b41120f93f3a0cf7db4e253a86852ebb1d39ca279f510ee8961b39da9e607ca5e68b12b5399f1a87db83ebdceb464fec3138275eead084e2e5ddc312120638890c6a3c55e426785bbb07209a510119214fd1cfbf0e5c96dc1c0dd237e1f60f8c855011088ed7c19d52bf4b8b4433b6d1fd85b3ea5a7ab04e2e5308b9ca990c2569bdfb6966765dc733319f94b4bdb71c33bf069fd5f4f704b7c5d5828525770f14df96cd79d471f6d5f93edceac565e772f3735171f7aa64d0210bcc4c5c010b5b4b7507b92d64d80076e750c5c845ed3bf342d6f38c940482530d4b10394bc4acd983c8e247cfa8fc42c4766cce47ff7fa2929a27879473b9bb9a6095e8a793650355bc2c31f3f13b824c8e8dabacca3198964f2a71ef48ec121f704cfcfe2401af7b07d2b71b13d2db980c87930292942a6db808a8e9590cd93e033e5621f4c504d1db98d8c6cdfc9e6f6f1914d37c6ee9f020036652b0eabcb547101529088830ef22ddb556a8ab0a21d56c1450e262d7f7c63c62f2e80bd25c73d28e957d1c2c84fc39de09cc9aa20a87180b0d36f7233a637bb81f63e2276e3fde6c6506b61ffaa22246c6428720f4b2fb3cc9170e51b3c104f58c29ffcad97d7da2ef9be7d86002de5f1914e454028b76c92283646d3a484ed648430d66bc6bf6d17c705aefc0d3813bf81557a26a4456a15275eb9a88e1b57cc2e004a3ece7ca35496106ef9f8a8fc109a9ab50acbb767294002729fed21b24c8a812ffda9cd8ed5d969d4e14168fa532422bea95827323551bb8a1db1a313412d7d2189c668c0adf43b49937cb330da8214c80eb17e9975949409404a0ea37ade23ba4c59f14b580e457c1a2cddbf9f3b2b48fead0cde8c179a069e6b5b9cd46e8804520fa6c003949a6084553039d62caeeab4e4f2a9f234a2b23e8c6b17c308699a8ec4be74c699d9806ec16f0cb664c94bc4da240ff670881ebbc9edcf68f9a0429620be9da8a8f5efb4b8053b34a5c6b8b5e820a75cc43e6fae0a802e86e443cb1ebab1a30786823e60f9646ebbfd0688a12aba93a21915ece626087f0a2a6f2f258185a6da914acf6831337542f639854d2df6b05f9beb536c3a71de6352e15db4f58a51724ef6e12cb2e7daab848d3fa2f8839d62100effaf298e163956a15f3bd562daa7c17105afa91bd55b10cbb9aa83262b568db5a6bb77a0e13db15a3a0c0ed4ad17e96c419b3c2227728a7eb8383f44e591f94b73347831895f88d69bdc8ad5e1168ca5bd5cb124f4685814c79cf23835ac259947cf1078bc28853f0220f58957024143577608cc59ed4b9a2a03318f14e0aaa9cf229c69bed491b85f2f4861c486f47f6db563ffd3e3387170542cfbc4c974490df078f0d5a1a847299066833a5c646d2fe40da684e07ae5ce476bef416ec76fb344474b18ac69cbf84818d1d603220cce07733ae472c0cc4937e6a8451f9e14739697611b7c1353ba698c12af12470d789ab3e2ebfd99c202cfc5cb7a7582c3e0583ca984385de9b386366492e69e1f4122e98263dc5765242d046e0a57fd3a02d5f10350c83aa504f2d2c1d343427dcf2ecd367a4c8625b62d012339882b7e4a7c64660bdd31c1aaec01552708e8b6a1b3335dc91b9c3618831083e215a7d0d461362545b1dae39e1ff14b76056de1a1bfd0aae052d31e01184f17399e5dbd83e3aa7aa5b9e7180e1f54e65052add9259c87426466108853bdb2234ddf5ebb551c78dc00cee1faa1d91a15a521a7b18963dff5eb27b13d05ff51869fd093be03555b165f578a8eeed30029f426cf33e819183c4d3f0aaef5de9a047c28ccf241e7b742a6223600d103626119762be4404558f17189182bc031e555b5ef79d85119111a9e7418f8369673efd3a3bff1d4ff2f0523a26681213089d1fe4f40c335c6492379320e49f4148d8604b0dde3bd458d754d59c772c9c438842dd0fac07bb312ffb855830125ac841b303e1bdbf17e1e1b8736d5c73393025d6bf58b613af0302f079b6ffe837267a6ba3fdca64147d241a1e6f3bd0f1ecdc3c25f87d0fd874e5556e87943087cfbc247e876764f4126907d405ffa0427a088ae6f29394d1005dc5699b07bd66f086ee5e5956f7175e080f59bf3a101dcd44adc608f2bf2152b8c2301095b66d0c739c16f6046239c4e2629d02f875c28a10bf232c1c9b56002f2329e211c20ce0c82b761b1af57ff24ac4d06a88fc812d3ce68f40f57abb622f508f9ba4cb87b8a797b63b5bd9ee11c3eb81304624309800954bfd24916baaf3ca8233611e4e8ba1a35bb5dbb954eb1513ac3f79ba3445af40bd79de4c851c909250f8b03046f0390b45a2c70ac4ed027ba76dfb47ce0bd7b0e672a50f23d9caad5a8221be5d947fddb4b95a622417a26b1884528e425f27c3da33bfb56f2cb4acc6e61e30b39e384bfdc6f121c8bc962c329db2f57319a4deb86907658ed611e7dda1df4ad86819e67e421a64ced4cc6cf0476e50551454dc8b02de5cf5a6ecf120233d59589b45f325889e12f677885cd86d569a2bee92d329ec9bb87ab3f548f4b0f39df7f61c15c1181c921bf4436d5a471b51529803258cf20bce0e15dc23d102ae9844f1c854ec75247465bd642cf8a84c6353dfedf16d767e06ea93a924a7bab150bdb477da6eea80d4c20c89ad261eb459ce21999d5eb62c8ba247c89960a4dedc5b297082248a0f1bb19fda6fcbd12255c71b0cc800ada4fc3021de6c8c0158647a2a7c8b32cf72a51fc81229728741d959f8890b6ab337d61be11ed8ab97844b6288704e5d2f524b22ee8f0a920214dacd4f4dc1e70f74ebb3d1a163775bd65d10930297cc627cdf141b3d3cb604093d9d5a0f27c1eb983e425a0dae3816327e2bab0cb34d27097159b11d412a4e020139e7bb9ba179e9bcfeedca1f592ede7da49719bcd3071bc17baa792684ea7c2656eb7d8eb41fb9f5a8225bd5f6018213474c0e0a9aaae1d055f4700d9119383dbd5dadcd5047ec2971e938af3ec6f78b97a271d751572fef0c5e284476ea0f0cceac644cfd509191fd33001715030ce535913f3d010c38d4506892fba0668e3dd4e7b94c8cb9680d9089f199814c723143012a310721b671fac45359485a95d6faede77a3711296d519e557f3fd7f3629268fa00b049f09585509d7aa4cca67a07375c505fa797d0c73c308695a0094cfdf9404f5adf5118602057f7de0c7f255a02f2bb9b332e4b09356185050b51ea912411450f2dc533b411c3b01293b03f40115f69ea0ce21b9a39d156afec084d21a2c48341cc2b7ea3608d08b5eee531ceb8a0393d0681987033704b301c1b90db436c7f78d96ad3434867c19306a6f040fbac1e5844263c6554888f1df682ce516ed99029b5d45edd9f189761d268ad9c2a50c56eeefc2d3880dfcb711b231df300ad4dc38a13ef1bc13bbfebb27c578311e37f6ef056e88fde1bf9637d95b24fc89fffdfb3e5760da3806647d7dd43c5adc9f4d94ff3a95df20a8af8cc1e7f8e4b1ece10e45a4dfcfa55d33d79bc18970fa7891931d5c65ab5a41248782fc13845f9411da3ed00adff15293d2b03e92ae027aa5b89221bc431dcf92962ba8a706d349f5ec42a318e366e6c4681ade78c9258d0c450f1ef1594bebc40fc15beb89816931d6ee07b5d1ed2e121e14c3878ee51ab757ed8c9a4a90bca064782174224214589c4d2112b41d92daf250a3f57602894ec2cbf0a6bd675cb9cc8cee467f253d933dd5aa496e606482c2715138f05263394225a95f5d4744a1e2591fdf82121560c592700563bbbb6dfb89b251d103c22f3a0aa57acc185629b865621ae229dc4e715775beeaeac2b346540f3692e4ea160046d34beb0a2c6e7874e7ba60dfbc437926e487ed2a34b90cf3c0a6fea7a2c0e0b7d777edcffc291e6270873da9b408996f99277d20b8a23cdd17a345400b15ad51307c9ffaaa3f809aa4c3b033efc140c1a1de58b5af30120541187e550e5a38db09857269ec423a185419f7ec636f1dd4cc1cc387c6601b5f173b67db0dc4d27e5ad3a04a191bf4714302e2918ea8a1a96a083e039ac90a2dff0a4f1b3b47a2d9d141500c23eadba5dd34b97842951c954b3562d854e0c0612b7943f488296006c86c0392da193d5adb3aa1df1dff67936e854a5232e0321059ea0b3030fe1b38243c6c8142713e2c4796abcb36b5e8576b38150949ec5243fd5204cdb7a69d7165e355410e526e650d78e7447c437432fbb030ba7c99ad0e22772cdc39c40f80909c007da417b7d4ceedffe1ff350e1f662c561a09bb671f501bcf6b2320b2e54d884ea41c3fb18a0398dd48b1a222d0ecff0867492408f40a6641318610f49d8d8c8de88908242b98b37cae833c8db805f462d4c2d62338ab92e02de9791c1eb638aeeae54dd8401cd00d672fba4b2cd5ba8640108be0bb0fb2a5c3cd7c416e0396111b93a0c9b0a63775b1d897f4280a23ad6636f8d9eb1c05873f426d2114195e4d2b21dd718ff53773711504930ccd8c9e26f609bb505750abbdb7925307d14fd2f210b1c78cae14ad6fe89427d6a792c34c2ad1710a1d886a45798d5e945c4a57022d7685b5e0b6288c2fd9662ec792fb92dd0147ff044dbd354d6837f22df9c8a15759ebd495032407be558a56d2b5d5ba18329d9d914df9f4d446074aeba2f07bd260f449e2a6814553644ca5b40c9c5025bf42cfb822263021d84bef0a0474bc3150b347e810cfe96274cfcc556364cb39b3340e340694121c281f7184fe91189cee61eabe3f122783e8862bef87ed9ac3b13f3ce229c2566a09e61a9b5d9db14f6f37b20774bbd5f6ea9b417044478c36ec4e9b03aee4b160cba77a341b2b4dd266e15b0e6214a593670fec48bb0675d4f431eedd17dfc5a5a0cc20959fb0808ff0f3d9da89d19894b29e8e4ab904318665c06df84e394f98cd52e0209077852edd6353ba129366d7179e1f6406131d9d5eae5ddc480b6c88fbd600fa67130521894e21db51e09cd3adddc366cb5286dc4cdca28b4bcf3c2c79eac69cff0ba4a95b41f22367838f03fc84fd6b680c589821b2602c70f1635b7afecf619a9eba18f17fa4b87dbf9d86474f843ae6ace66e870c4251173ff1c8ee8b001b675b68bbfb4697a7fa15ab5f9e02e1e9e58085e085d2528c0f43a46be7f9668cce3fd13c63e8998f7bb406364c100474a91ce9820587730132afc6aa9a3cf45df4b16ad2d967e00a11eb700c46eef171807d5c065c891c5f39fe0e444fa013c479ac82cc4d8203b67089853351fa206abc71eb184b1ea369cd62cd2391e8fbf3f512f6f160f18481595d2d68209ef3fdb1cc4f768a1c2f7cf5e541048d7fd2f2e018cbdf4ff465e76a934f8e0086989742006657ad7dbfb36f5b21616230caafadb831a4b174b811ee90b8eac352b07a6057e202bec17633ec6438beb0ed9efde6beeeca21096200fc1eed165e57a1c1e2bf98acc3c33760114eb29d868cbcfc953e07b892344502482e0ecbdc66bb9270a422591e514d88b4c56ecba98485026dc51ce6369570166a3d6250de8880b06ad8a5308d60d59aad45e444302171389f6253333a37060f04271311802cbf4202ac673ccc525433dd45318b7f5741fe4df58993960a71e38af9036d5e173e68751d170b653c571bf0553d81957f8fcc350ec70b31e7da6c0322968cb6725410c4975b6fd01d12984584f61e5e4643260fe83907a98a8d00df3a3722a0a2f386ca79cd71f8f12fa606ae247713bcc233c5505cfaf783d6232390f4821522833f7e34f043863a962b5119487d00f2c72c711d6ce42c919b6cf8306a5bcb3fb392d585947e4d5de24cfc6fdd150fd096fa8ce608047667cdf0662d2b111754e5370aefe29d54ddcea8e5521236e7c5c10f08943c5618a1df6935f7148b09e38d160e7db2a34b29e4e3a126713c78d0095c0400a38abda62500fcc9278eeb72705a34093a143e4dfc144c562e5a6fd654677ae500fad8d5b0862565fe35ae92b9fde95e1a56cb8aeac6a465e475b754ccd8322c5b17d8043e15ab06fa8494844596ab9d29b0e7e9ada019bb87790a93db09acf473c4d3ef09652c4e50964b3dcbe02e3893d2c7641eb6652a3887d7619f14ca873c289f2815fbecf9ef390b5e2beac456a97f08e6e89e8ffb7421fe2ee93de333fb9830bba3f0a42233a5daec3a4307d7029cadc16eaf0e057124841ebc1a17bb2e8bfbcf45f9ece8747f79fab0277ea7212433b2d74c485fb226015f85b92b6983bf73efa4694b93293fc6d8b0b6b61f1400b380af33ecd37928dd4a9d83245e0261df25edd6ed6ad825624f5dc83380ce6afe77c7a4459b5050c2473fe41d40ae4b73e7fbf80375c0ef30aff2e2ab63083ad4544bead746e3524dc3c4ca86058e59ce2b6ba4eee8c0d1a9f5e91be0edab639e14f32689f84ac067514861dd2162fd3c05d05da6894ee6e5e08f75f0b30159b355be7657ae72259d571bb7fa46287c555132ec45e15df85ab8a9a8d7397f94f4c1da87284fa7e43ab0a5c269eb9188c573325930067f1657c6f2a5260bb87eb92e7ef22159c2b6e32f3c75cf8adef871337d3bc8b54cc2e11d35b899dfb9f631f7278b0f5c0067618de07bef618edcf181bbc15346582cb0a77de0f4f413563ddc18a0b9cab785c16306830147b5de1ebce0225ddfd0f84d8b9117f8145bb4c623459efc323962f50cc46017546cb0f7b52bf93dadd42a57f1e3c08503f2c2ceafc889855f84e842f3089614c303659cf82c2eba436867cc8d9ce6ed33c1312c488ec32dd8507085fb71087bef333dadff93d746097bcd9069c7a9b29c61edd1f65f7ef653b748a416608964e4abd2bead950b3312cba1575947575531bf1051071886fbb24c6d02a89538c4957e88b8c81c459674276e4f3c8b6782c6d3686196cc554b40eb4869fb02b7fed8ae81a78ab24c94444682638f2a37a1f141d85f40b47e989b3a670299e12b3a1b948281666f5a3f0154d11fba3cc73b073d27b4c47a2b65a803bf4835045e86591dd4f5feb46cc9b40b5f41eeaab17513d939c55bb7871272494bfedbf9d0f8594536cb55a6dd6833d0029b40f11fdb92382b240f7af1d575478cbe4fd3c2da80c2e4b2a8060adab5342fb6cd44f95eb4b12aea814668109444bd5943b6362791151a58143777b3b92f9f4a726106056899acba55747779b3f22c48e6e88e3a3527575451e882789d22934ff9cfdb096e2bb65b9fabb5ca2355e2d02316b78166de619e025c0cc5aad4a1221001e19b6a8597bf37d57b7001bcd17e18caad744d12fdb4c07de80b2ffe7c0c4a3a55d44210d000d8331f9f77c0cfb6d533c2fe8f948cd5b6697f315d2a5786019a140cb0a1ea85b3945d4284a13c6285525f4d8071dadd4cda29f97a1203f079a704994e27b505140deba5be8a0979141c9e0d9d4d946f3942382bcf96a6f1e0d75e903badf6ff0595b8cfa6084d67b56fa7124fc429c88ab480d05b02c34a0a00968977661c807c0c212485c80fa2f20aaae7a539f4dbd806d7795b0db79968726417499ed27fc95a1cbd3e3c5246a7bbed0d4358850f088126e3cd8eda8369441034b58903fcbfcc324023197e09d2c0e11f40fa892a1ece7b1812fc0d8fedb8a9f17b72e2576b87800e6b67830ee534c58645dcc30689bd4fb45129f9148752705adf0a73404f88c5f161d59571007d8c6868fab53781fffc21f38fdf58b201bb2fd49cb7f09f97305577e8bc6b5150954c1f0a9acc7ed024cedee59dc796a1593c91d3b43a0c7d053bc3e35a1a3ec0aa68b6bd5a71dd23787db906764c2d9c42d653aff0153ac23940baad7053dcad9c00064ff9e5a74dd83b6b0089e4900d528bbd9e80f27eda45db47a6391805495f468a99377f1c7a31b5baa0c786109bd87a56413fcb572c2ad66723bd909768973706227715c0846b9141e768a3d57dc9a72856b4a9ede7d7ddf1f129009d025f978e40b65634ff7b1a10f1d3137a4814ae2ed568c627a22305e6e6e704aac0cc62170c60481b35665833244eab6b3a7ffacb66c8378c8cf126e23dbeecc8c2a903fe4fe64bebcf75a017d6f5dcae4d0fc0c01a6c46a6adf1051ceb0d21cf49f2e6e4b8d0939de28d75e2bb4d4c8c635229fc8e327a79e881eebddf4a9923a2aaae5cd5274de94fb95a2448253c75bfff8898d3a5fe2a5c4e80667fd217056c43a719f4754c4b62827cc30893d3744e30467cd174da4f7452d220a8a7cb6ef68bdfc819c689be330fcae1a3f6d8383e365e18b0fa242e69a36e7e4b5472debb729e82795f5c1cea160c26f395de85cd57d6fe45552c4e1d1a0b1747983c9963b7bf1bf662b3d119a1242c7760d09cace0ada2fa150f686ac23fae2e3c67671e68c621500db750fc266800d0e56eb7e40045c0750eaaf0e6a96caa2fee371488034dbdb30551d2741615439088e3f5874cd11b4a76211a18612421c8f13493aad98d353f43c7b42a8a4c2870d517ece1d522d1f591442a08a394ba3344a64534cb88af089cb5748c0875da2384aed139a078bb2436628fe64f496f8bed100dae3646206b90824aeaa3bec5d6934b83e16739c129add2027f5262e778afe6730c4e5104e60d7579e98cc9718cc2cc751aff5613adc425975ec17dfa7f858860dd8a4fbc447b20889cd6ec0faf488e9654094286c9d6b7e214a99d2c9bf1337010124d4f0a8ce46468c0191b98f6be84c88c36b423b065e3c186a9715cae09a1efb1403f4fa8ff615f0e1f6fa81162b9cd8400cfa6b7c72c48555abc1aaa34900f75d9cbebe61c552b7604eae7251a2d65b3d2ef1a7a78d2602e33aadd9c43fac3bd452a380133c7fc3aecf83ca38939f2f63e6be276b0ee1bbc4eabfac5e9a57f47dadc86b5431d9bf8918e14f8fca00752cfd4881f9e534775707df947f31dc414a034a115027a763760a2843ae27d332ace2584862d99d7e14f9c4318e7fa4506a0b2903221e247e351a5d6595042dc9756a359b47b5011174b5ac4b95607f921f99b44701505ca495a364d0eff1b62f9404e850d8094be616da2ae430fcf9dbf3b7c73f7b616c3024b5f995208a85ab5c41579930dcc4b23d97391817491b6fdc5fe4178f15e794ffefcdffedbfb981136072f563fe5a2f3c14d9299ddb5fdea09eb723ef0598be25f5a1b453ef60198061319200cc61ad2d7293a876efe0cfcddfed9edb7fdd62fb714cec30166eb04ee56583089ba2a6c3c531786c96b66ae31b21696f74cb159f59214a3bfede01bd097fd6f457904a988276ff299fb2789b57c0e04c61e06f57c02eab2ee71e88eb0f1cae43fd0dde0cf421235b86910332e1f6e78fca0b1ce6299ca23ddfd7ac74065d29e247738887ccaaa532411034105d2970d98e24cea82c32b4925d571d93c98b937f9301d01fa9dcbba01b59bb17a13fb2b87715ba0f7aadbfa6d6b067fd6d788a4056f4454c0c3dbfec289b1f49573047e74b67ccc70082ea032f1b933a28408ab12bc9f0e1e560af19f3ea702f406f846a6f826e64d9de4277c4ea5e24943a573a44335a8eee25744728ec1541a9134d4f11e6cab9bd2ce83f626405c61eb8870be0d72191db6d904ec9259a458dee83f0061b2f1ce58291f70ca65fb32d4f9b6add6671a6275ea52d09713d1acb2cc6f5d1e0d6ad04bc2462c4290b280d6df9337ae2f6ca57980f72e1a449a10ef455e7d4bad50be40b64cb66f1598102c2580ab9ea97d1cb307becad293f279788f901e88f54ee5d00a5f6aaa7187385c95e1a346d75d6995cb2572745831a4373fe997175c81863dff6b577c28bf87cb5ede5fe6c87d768aac9ca9a5806b80e4491c0e47a4378a30f3e5e667ba499b876d25b2b5908ed23e2cd0d74476411d7c3037bc5e51877b54c74f1c82dd7f6aafa77ef51d2507404a68f73cc40e4ebc828dbd4c965f7bf6f84f911b9d1a76046db39526452ee7592403eca5fe5e09f934a04fc884083bc68253ac85b858a32af722a08c9ab7ad59e1d57d114d8878c4852ef2118adee1bbc81a51281a263050de383be0217ce9023077414f4b1f0074034222098366c1a11601c187fc256b0d4584403e7f98d1db71b83985a9cb5bb6f3c5ba712a7b33b4d62d68bda22849f79b4ba9c7dce987db3b035776a73876fc88942fac7faf6b9835245c91228bbb21f2c8fe7a50f579dd93756f8cbac4e839ff9948d74969c85fa998f42233d5039c26018b99048953b3ce94c00f0e8c4114c6eace900d6daa488fd5022e8f2d89a5b6bdb3a8338dd7d205b950fc4a9f8458f644e9e56c77ac7b80d745c873a5a72efa9a2ed1b65ecfb1f340304fc631fc21a7cdd530d5cf0560b13d05c581bbb56dbc226307d106bd5d3b9b56eef02f59c43edc4455d5b4969985bd3c029a969881376e8b9fec09df28067220fb2f662c16d4aadf0a14ea867870607184b163ab2f1cd4f4fde044cf183d705147ea414a0f8640d2ad08f9b5e807f76ac11a9a47b157e12215c96b0de1451f7500867a31056a66601e4da01b3defc7d77b43ee35d4df10b0b30a8d2c07ff55da462e604c29d4707fadf0b855fa461c48e86708cb2ee248c763076e407dc69dd57b5ff6f5063d4b00c8d117f9b08bc7329e9bf139f7e45b7c2bca77438809ccf40412e7c3b264bbad696fc479f2ee106762cd0e939a8cbac9074f9539718de495a4e2260bef6d427b12d854f20cad5fdcae5bc112e92e6f40fb4b16bffa92b6d1b026b8f57a9f001d0aa3e6a542cb824f0ed43eb9140cbc3ba3e6bfe3c4a2579acf0f7a5c983180589bd5bd0d6d0e8d9aee7418993e58a0f94bb45e17055bb2ecce1e7c0915272b9ca1a4020920782d8e38eb4b61b6487ab67cea86b29b66863dbc15f17534bae7cdddea68d6d07bf04482981a1cdaa169168366c5ca3ad1548102f7bea2543230904166c01e59ff0474a084ceb59c667b0c95ae5f0be980d98dbb9052768456ee4ddbdd7d1bd6843cc38d5252bf7d0c6e76650f215500c894ae71439ced110221ca62ca0a32a6333c9e371df82c0684aaf5b95332e29f982640aaa496a2ac97ddbb963eab0682af418d6bb4f5bc8074060020b22677b42b763412a6c3a0711055400dff78b1c2df81dfb06d7ace32dcf66fb2a6284a8bd3213dad657b0064c2e20326173982ebecbdb843720de840bfdaf45c242a6bfb717102cf3079f61556b804f22a4322f82471f862820c4af531ad3ebbffd9e48cc22556c7d085ecddd7dd16c2035e3f70ddee0c41e71bd3e52bfe8621eb07bc410b8d30479ed8e150aeb38889600505c8317d94f6b8741a57725b7353a0b793fb6674206d262ce82d732012e1503cdcf2767a1aaf52cdc900080e60ea3634e9c85d284106e5526d72771bfb445581bb02b5ff87236d21067918d8202d0026b8151ff91b1119b9b1e47f2fee4e0ac5f102a739952959972993d92413ff8cb38456a11564586a86f347275991fc6763149864b7cb4a8b59b0de2821ddb810441765456068e4006fbe6a172305b5ba966b1d63c17f157883f6694c0523bdc5b0620b5dafc69c0e569c0cefa26def4ed93af03f9f03f3387a9d1cb51299a798cb2f138cbd57e48922cd339b8f26b6a666313f72e158863d94b916cfa319cc252ba18d5b58c10b6c3b4997eed902971b555ca430e085ba637a20920315e4b1660551545516eb43f71da0304d1cd0144f92872ad1e9edbd2a280879edc853235e7cae4d365e8beb79e625a8ec8729de079c9bbc845149e44d754c9526ca95bc28d11e6b46a555be15c4a2fe1e4007972855667873b02b606997c1b537acf42d0593a243394012e78c340a93811c4aa0632e8346300bef5a5d5a481a6be5d8fd5ff2a5a6863a480d390a9096f3d80c23a5019229f94f85e3884f85c78f679a54b978ecf85cf1ffc4d57ca1509273903f92860f8267c002615c0bbbc0461b3e3cfbbb8fd609bf9abd3eecc186baf767189fcea265493cc37bb6f718a3801147a9cfb699ef0516b42cfa9bca66822394aa1238e816ef5a744ad1606c39eca5c09d1f757840596625143aa0918c560cafc502b815a1416b92956c1f653e28a795a3698901f7742a44c803e0740c580a53d75854ac468a70d3df4f01777419315c60e13f3e064400694b3951431951f4be102824c741996b76e90b579eb31d7600c0866ecacef10920d2e25ee9c9be43fd556bb4386e5151c692708b5515f18c9a02e655e29e3d18349293ac4231adb825d97534d836df12041ddc37736faec9f33c48c3cf15e7a279467992576bd128137b6e550d403b4cc55c7f356ef75628f0e57870ff58e6ee651d61ee4de19f7b44d120da09c8ce06c87314d28cfec493f41d1c5d0f5963e6345bb12b02b99ae608d148284ea8721b32bf270a22808e179f841016ec4632e3d475607ec56c720a52e1b4ec7e066c3d6d94c3075e00dca0e668f1374a50d1e5f2b6a52d73ff588c7ad3c03fcf1998494a4d19a3615a168b354c725181aec5695b0bfcf8344e7549fc6b70956078cbeec354348d51731bb43195133f2dbe7d1c0088b6d13e10611a126448047f902d3f5fb8b38f6db1f20b12eec6f8b3e63374437e3e77b942cf10e126f720abd2027e531a557d90055ae44e4b1d04fcf556940747b419218c04ba3fa2d75fc91b568a62d73389b8223c0ae9b096f6d3238571fa35a0b289102b2c5aafc55dbae5e10c30f58381ada9539ac06993406d869566050f324a5ea6ebbc1c8a3d4daf456eaf7ec599df69c56738b1716f2840209d3a49e6c5c405d90732fbb1b0d792d05821c77688c120fd273f31585d90619fd056c2c5170ac178da76ac1abe75dd961b1eb5c7fbfeef868fdb6acac734b117f4d5ea2de9b934a03e8dfaa65f9d0d8057c45d6fa2e372474417289057a06b220540d8de5107da46efe4bfc7907bc75d09a98349899808416e6015ba11039fef1963810cec485e3eda1c00e708fb87019c2c5549a4b10b4d54c03246b26df6c64f933c2b598c738a609bf652cbce41a11d91e52e87d896b3b39483dc51275eee84cc194fe6033ee1b5500945909b73a398b9d30854e01af13a917c38d59a68100a64de9ee1edbf4e609b304cab0d29ff2c7d6e68f8bbf1734b3e4eea778af9794594e2e7601ee89768c040eb5304fa3523dbd56652148dca2f091f5e674abcd64463d1f8e262403e5a7c206c8ee66f189d1f7f70098cde89a056447f69a2b4a1d16aa4648e6291ca2790731f8922065bf20e0d32109f3c5a19a547fbc50bb29da94b253065c4562407c0183c50152a561c13004afd5046a5569e883b0e878323c251444deecf033f29b280536e735b12fc0e029bbf01304b6c9211e03985be8452f3984870ec43df6769056bc345b68c7be620d4b5dc6d9bfdc15ab654442eca5a4f5aed92f7fc3dc4217a216594dc34a08bb6146a2f9ba1714c40ec48234655072d19c09d2694a7acc6169ab8e522deaead3ec12ad8343bc541de91634a79056f4ea55d54a4ff314f088bc61793e525e22629dc9faa872f01e625317911c88fffd7d8d0a4d5ae605716933eb86c0bf4eb863dfea194a48d6a6d840550517e3dc5b676f5142406a2dd7eb39dbc96eb3b7b19d4197f2a83eb69d8120fe5a897c607f22a753e081115785cc09fdca7beac246938eb667d5d8d132d12169f8a350d035ab3c9e56175420f449234673925c69f67c80eab0667539db1b26cd48ab35fc3edc23b2906b3859af116dfbb052aec5d1beba6be1d0c00583bcd2ea385a5d311f86cca028cb9950ae2df687a56f29fff67bcd0fe3ecb20dad1d174784a84b2863daa41ad999e7317b298711d6779717b1cf0aa0ffd66c6f0694db60f5ba33cb6ee6b7bf75c0159dbad379bbb53ab5cd1a3efb5e46be9999b059620311969f2a98740956d899e9c01449eb69825601cf89a404f58821f4fd34ea5981914812151cae50dd2a7010c92c9170548c7f7d7016f82e9df95f08416b335cc79dc5763c8c102fa25d0ed0249cbc23f17acbfc5e6125c00fd86d03b21444fbeafac89c97a42ac5e11fde2ece51fff04917ce55f2e174676541d78ad313695237ac60b00dcfbac8987652d693756e429964bb506887f6227cfb04d1b752a1e77dc32d6ebbc589340336169c82bf6c2384b47268a98b6525917d24b74dcb87759503ae127098c5715e0da0b49388fdd224c08736ce42936b4edb6bb03e7a4875fa4d4eb19315bf1bcafac6263ecd9ecda91fec7e7cda4c85ccb195248e0e1396df75727c936a8bf0e84978b083d333aeb0637902a530063fd524bcbef9c842f27fe7f7ae65974bc85e1ad6542b16b3406ac3141a8525d38a302d0c7aa4a377bdf81c51b2dd205db7c2e4b3d60ee4bde085ac580c3ba258b4a2ff2bd83cfbd5dcf75bb1821d4b9dfa0602bb74dd43efda97028379bbb7ec670fb6eb7f6282b1d35f21fbaaded106c338103d7e337cf8fb641b2cd6f4d7cc15a41f8a10b934c120a0b0d16f813c44c37c3522207a15056b6a299d30c18d53fd04a05fda442cd888fde6b2cc367f99ade36b28ea652b54b26b240485192e7d23e35a2d1e84841c63387c2bd006789493d2f0dfb05290e6fea2b84cf0aa80f454a538b90ac9ee6fb23c0bce31cebd3c5c9d570ba42604aea072a851fa83855816fbc4d349702cb1be489aeaad9e5321e0200202d179fad1a0d4325b4e41ccaef91342327b61b2e72806bf0755da3307c99b1ee0098e5a2b2682634eacaaca11ce12bb7711646b1148514f6fae49f3b2e4b8288ce48653167400de889c2ad809c173dbde18ccdb1e9760c646bc4d142331b799b60e943f2d9bd2dc1f1b66292754578d13579c61572369629401908858be5777b68a6ad68cb769f8c09026eb4bcdf0de2ac6bd4a0657d90fb3058a500f38034afc16252aa3a21d964dd582396a64b77fb1f04a4e1c418ed238573fee0c52dc9039c505ced242267be6d7d8e24a696d637a61c47e3d677d9eb664de736a4bdf712990aa64b6318dc62162a0108a66fb8030f5371ff78fda670d7b427408c1f4abb70511125e64dea63d7dba3ac17976e2bb78b1e6609ed692e89c5e6d54c348b98e4b37cb6ba306263ea558c02fc7a8f00d169eeba070255fd426fa4b7d400abcc7859ae0b5e5bd6be551e1d89674334583b21f1d81f65f024e3f2d71437dbb1c85e6d2ba0316e22b0a37896537127dcb5ceb4a0af7b2d88170266cbcf9c84e5d7b6018ae57d0ee838ab404977e45232a381e66fc2e7a40552295fd22fba3b4f487fff06a998bf07e0432126fd162ad14065d78444e7b669343cc148989d2a0bee7046f6d2dc79e006fa4ee78a7133be6574d7c757ea17a89e1696494c03c10e90cbe026194b267d66e1301c8ad3a2bff043e971f1fd7a0208695bf87a14b0b60d28e098f527e74d2c116934a943a9027cecb0f03dc41b08e833bd58d10f6a80315a2c371a29c9dcfd166a720927ca66f5052e4bfead13311596c2f4748b5d7ca51f8615c2b50d89e8c092ba35a1a2a41188defc528254882a057cbd59aad3422a038031bad7bd985c41a256049e030ac459f6baa14f1fbf10419e560fa425e3dbe3e6b7e3c12aa715ae5d30568a010b3ad91d594c1abc30198200ec8fc418803a49fcc873ec5250a5c595c506b873fa18c6876529df37b3d1fe001fab0f05ff24fe9cb36b61652dd9c2f8cca9bc6c5f021d86592ed1f7f14b86fbb6837ce79d6b1e080a8db0a6e39fb7f07742c668e1cd8474e98eab4f6142ffd471740e33a001899bf47422fbe8a0aa6cdc19e02587cb1af781c8da8fce3877e0d06ec857dcdabf54cc9574fa3f344093f4a8ca912669e256030ed20978c1f5c8ac37894e9251be4f1e08deb114c7fbf3e578d25372ea542afbe07c8f14cc8f726ecc4962e7edff7fba500217ee35309f8640609756ae932f1dd1f7e02600e79ed556a99f106fe4e30001114a0523cd9c8d3260a968c276d1312e85e1879eb6017ac0a4090a0139024cfad0456fe7c00f162b1e71a006d081192c32e305fd34049068088628c679868126e12d6fb520ada691cbc91066f9ef2c1e39ed8fa9f182afe1e70d96d126b441f18c6f7c9e13383e0d3075fedf4a1f920d14effbb63a59b7d38aa4e78c04a0e08387350877f2dda204cae646ca848406f501bfbe02375750cef4d0f188cb032be9847fe0bb043a86ba2757ecf9ec54079ac7b33d45d30e1d9f31476394f1b319d87c995d47a99ee2e2b0e97c7d01c77530a04e0c69f09da3453069e7c007a8200f408a881a7a3590f14354d2b107d11d3586a4e6ca19fa1fb0f483a807bc1f5feaf980df152bdbf0d6d0b08b5bb2c4b6cc8320cc4cd66b1f4f865ca55deaf36feb6ad47b730055c5d38ecfc74f078e27f667e88e82a1307953b6133a3cf43384b07e1cc3fd6f680d284f548e86d426dbd8d461cd28081a924a5b9b6690c6af162cc8ead0821930f1a5d127146f917ea72a92865a9de0e963c953dcd52fc85404544a0fabb82582258b6edad6722bfa46522062e0ede12d13d4b13e3da2fe513451d797adb308d1f9af7d997898623441c1a3686700a3ca25225158b80ef4d256451c72f77fc4885e4e5f255559754e2052a7e11465418890d18db9ba0cd3cc329f7cb73ce6b7c02b41d9fc04e4f5076da64033370f472b64a93354e2745a1b04f67e64560c8e0d6f5302f4c75a78f00d4e8032bbea91fc3314cf761a655121bc132705d30ccc8bd50ec1dcbe05df27b04004555e998153c77c09e94d18859f0876291907dbc420c864f0db624d302379d603eecd4de90a6444a9c510068849d61c59f481593f79c44d468f17dbced3b8d8b2c251a24754bc152c07c8430cceabe000f3f0448d773c9b6f122cf27aa6387e9e9109fea8d746456b188b98838157acf68c06b6002551b4660819552f4445333a58d307437814ce613ac02b5b095a1acac9a7657a8b5dcb174a82fbd72d2ac9ec98d11f6a69c3c275faf59dffb106d3124a19200bb9b7b8f96cb6d7df049be971b669fefb34e4488c7e3a77fd29e3d8f467e3779f029cf321d87ce8c2f1ec57e7c7248eea08c27709b5e85f85486019b2247d037062bc624fb81bce763618fb5a682209419423e87b14bfa582a424943cc14c0ba7398a1896f152c20da3098b9ffcb6784fe4622f7cb0c232d039b801a39fb815cfca193de27f161512fd2ac37ca223efbb14150c07f0797639a2cd2971f3cbf5f11051d786f6abe0f5a644db578750c53f16c9f763f54a3f92a396f215a40e7ccc8cda1fd25ccacd892c7ce66049cb597293b935e51cc5cbb38f47ee30fd56010664238674001660745a67910847c7777544a0fd9b4cc23059e684f223d5005612b4130cf14c732b852bb689bb72e229cbcf243906dc22543307ef959d201d630b80b13c3095f5eac644f59d68f829f8042912de3db7e70bbd661db284eb35be9c0008bc66ed293186eb7346c20ce010736e3b589f1883105a934556bdf4a24a2e88e6200761d120b4e12e37e0d829cbe9df61e60df121777dc306f829591f0add6120f46d1548c90e1c70772a390fef5e61de5a36e100825a95f120a71a431771c75fc73e22b91fbb5e82d2f75327cb2a9f7e4bd1c829a7bcd902876c6be6fdce836200ce47c921b8e1bc2ced37460e280714a42779b420f660adda680fc31b40a4cb1092a01b92ab4839415b521b3e260a21d62e146547a4eab227057fee84bb54315aa7310cf2d0e468100d5562d1584a7bb845199b2dfff291d207c59861c3b6a408ab02a746f1335549f341938cd20a89f0a01a253ec73a38e7505e735b261fd38029ae7c1b354701a93e9b0d3a561f3f5ac3477c95030f9f577449078fe0c1674f81b7bbe8cf7a5be679c7ecf0ea70785e550aa1fa84db6f9076b704ac163ae9bb9d38bb4d9087f46958d5a8bcaf3255bbba6ba2d34b363239d92d1fc0bb8a44ba4c65694a993b8f7cd790556010592eb648ccc894d1e648a1a37b7d91088ffb5743c6e1543c8580bf2d0ab0b24e4fc75ff00508eec92b8d7281c886a0fb6d854855b4303fbd024626df88ab42d8cb66b83592382a0bd0a8928218f6b99b88197a985359e9a4a2db462868a173783fcff99ff6f5a520e9ce498269d86c96436d896fd0435370985d93e1eae9e909b1f86dab502e11549116531c7815aa5eb4472a58c068bc9d7e55602662e5260a6e04b613e18d9b3dd576d566f5c56b5bed2c1dc90362c00a12316bf92efa02b7587d09b20507b06445a9cceafb08f151edccd9135167ed4049d5cdc061554ef2beb48b30979dec010ae36a79092c954d5b337889116718b0a189b794218d004e582b1090d4e58f7e5f4132844ef38862c14208ff276d238f68e1d8fc85829dbae2c847d07edd591f7ac1c25932325d1181cc57263737fbfefb7e2646b16386a9602de3b56a6e3885f6033b20240059b732e9d3bdb9c33860f7e26171fa58b96d292329c6e85a0f087344344e0e721173835e5512004a7e4488b391e3f7a6b5bc6375db22353ebc1c7ac21a19da057ef2e68f540c1ac115ec9128500851c20832edba78150e88dd7d8c90e8c556fd0bab2f8de5858bd74e587d0d06b34388444dd70c467ba3b11907d691f1c6ca1b380692f3c4c3bcca5529298b6e6932d2c2e04451ca6428a782b3b9d3e286a634410c4c30d423a2a309a3d8eba4eb194067b18028312982cc004fc1aa1875caedf5c0982598ee1a922e99473a5a24df573610d47d87193f76e89faf9c6b0b5d188aa80282397f5ad2a9920618555fc96a4e754e8d65b2b380c972bb5127482f7d14aa3e3041dc0393ac89f0138179abcc8e0c008e300af38f748b2e6e96cc5e48c670c8fdb9fbb316e01058f749449c5654aac0a98413aea19f23d5fb1cb0f3ae8490ac372e965f0527276c7d86b623d5f5b1ee14ab51c455f218ec806d7e34e1af7dbfbcd355d1607598aa3209830889019f11ebde0ebe30582339ccd0a4caa9b3c5486e8f233433fd964645bbaca8d46545a4a40aa11c7c2e7d44c03d4ff7969f26ae51c72fb4f5801c1de46b9500a2138e316e3cc8df8ad199cfdb86404f4bb19efaf81789e67654231cff4047446149ec796fc20561c9ea7215809be15b8e05fca49f0a96a59823960d63603dcefe64b4b0ba05b7b20c3c2e62d807ccb9601739ba6123225ddac4366f163a631c5e78050ad43f27f4154b1d696f8861c3c8effa88463634d0406fc7670101ec3f2506d708f81a10ac5a132c1a5a5c086290a0a538a241ee3a4c0d850b781a69e605ef453ddfba79206e04195ce09dd6680bb2239048161397924e77dd1ce0323f9f9d4cc3d3583be5b80d50c1a60c1bba561017e3bf7fb4d0a0692ab0f0044e93e83d87cf700180cea2953eecd3f8eb6b31d0a048a41fd8578e4271e1f2b4dc04009cd3d970677c5b0a9875ac11a951e9207f6950586e657152d838da9f046a9f1c0f0aff5706d140210bb70134dbdc68c1f0701ffe60d84e06819d6c2e2bf411b0a566b7ce5e88ea6ffd4dcc627946bf80a7e38dc10e8afe28d217e2f7471919f94dabb045ea15ee3532eac7a721b47c1b8009329bb2250ba5cf88a4ad524101838e2c4aa3ebaa4115a6d69d86e260cb0062ac2ef8eecd6139b14f4ee5a3e6457439ce3d6d883b62eaafc567169ec63fdc1476bdec08ade80f9bc2087efb6984ca05d28cca81a036adb077566facfaffb37faeac922ce003cdfde2d0667ba6469c33d5d4c7795b9989e923aac2480ba025e065f3715e03436daa29538955103fb959b9b0ccc1197109681b240d02d8a010555ad38d15fd59bc6240b2b329953c3fa4b3a79a6cf5fe908ccb32048077583d0331353e183e85371e4ec8d8ad18230c558cc34b2f748a6a014086c2f0367534c4071a8d86c2cde10ff2cb6140c24187e4660d09589092929060d480721f56e03281b900a0d2e024a391df402c7f94a162c440cd4b1252b6c22b03a79e6751496f0756215d6c37f091ee2d8e667f461af5352169ab41258207a6912b8a12a78596444f200d374c25da0ad6fde2cadd3a71c38644de26e2ea79620abe9f6a9f0c519033abbbf5eb1b1ebd77a910d368f62c6b5a2710d511109127216b5a17f9a2d79e2e583302799a45365a125b5e475d07acb8f16736d42a47ae4bf54c5ecee435cae0ff8652d414081ca3a3c47438a8ff9a01b384272fa7fa8ba15a38982bd4dc4aad430732ac8010da058ba0aa11b300a1ea2013ba0ac9b7ef0fca9f7b01ee28222f0e6593e341245c7e0776bde469bf40cc6f216e112deb8a46c2c5c239d7940771d06ba748bdcff6efc32f7e331cfa5870efb453c5c5b2eaeec2d7b8c8712aaa9dec8a0bd1b763aed4210174f341734ec21addea665e0d5d308b152972321420f8c358784471f68d6ef796874b245c249376ed7fbcb179f5b48222663a1d7d9427ea55ae516593ef64d20f795a3e1d8d2b9a6c90d42a0be4a750c028e5de856279ab9443c06b1508cb9a5f5176b4acad65bdf202b503c6e2bbfea8f2bb9d73fdce6a7d2680a20458667f3f9b7f02c1fa505180a0aff189a09ab7d66f01cd070c78cc5954e34585eb1b1d8c58074de8a15eee786276d2b921be6619c79183998757949069dd144dc29e0e04aec4afd30fcaef6b4bd4e8c0ed86415a9c70b23913fc45d0b31c9b56e1815cede8be72a9b55b63bde9f8d63122acba3c44ba431ce382b83d27104b69022214081b1ea73f38322fbd1ca52c9090fddd402be1b2b0021740bb91f09c3c2d9a03a0dbed38f840ab1883da01925a1eec37e7c4cff9d4c8ec9dd9010b0760d4e846edac7dd32925525284d3f19dec578953e7e8b71954218da34eac3c18fffc129ca441789bc122c2dc08a211d50428b0d3bbf1ea17d7ce554a72dc52dfb6e2cd041882cc76b110722f55b0b71ff120945db4780f4490c6c6854b54b1338d69642023419b77b31c3f3fcafdd311dcc4d5ce89b2d7a4d58823c05055f658041796b73b37f92201da6e7afe5b6db1321e0464a0ec29f734c6aac94bf6df5c1cd57e3844e0576e70a74536234b6e23c2d9e093bbc4d2019841827207a136e7c61fdd4c72085bc32ea178b690b61a5c797e5d580599ea511fb91486dfaefc248561dafc8e34a3ff74aac55f05f517fa9df683c8edd40e65d85bb6d6c36800fbf7d9afcb06a3ca5825fef0ebecd5524d61e789d2e3ffd3810a6dc668830886ae0dc2e6f677d5967fe8a61543136f0b62fce95e2869c0c93a63a4967b66703c8f30f1b4d876035d92d615e723391e6288836230e4b20529525bbea39554f20c122bcd826fcebcc804497c0d5850eed038c5c3ab8a952cce265dfc7744d84d1534c84640a5f7bb16db41dbfbe2289ec00a06d05d8e72b3e3dc09a480175c50b914de8495ff265ecbee25ea278d0eaca49f08554340018e8957046536412a85d2256f9ea774a533b1b33f396e5be0cc0fb5da785118a274c8ba53051504008af965aee2b3333f6c4a165f5a7f3bd2275e1f4bd0603a71d7ea91ffd53f2f552205a18a238cf1e1a39136a7fde7cb0f2340cd6bd4c7bd890b692ace17aafc11fd62ac5d4bfec4f9df7768afea0de9440a5a7015105b7d0029465cf06b914962180d88c6bf361eeb0baaf688411b9333b109c7cf0e268c3be9eba5c89c0b08ae97dcf98d0459ec3bcafd7d4e88e21ca30b3d96d2ac65befe71e52dfb46bdb59fc2b720b98ed935a5336d99b5fd16220230fce920618430676cf6b4cb36056fe80933c35ed8d7dc71d4fdd614bbc31f92843feae6dcca05342c9e98a9a7c9c00b9e7d3d3c25fe967b53d95f6ac4fe43104883ed4289848406438391632c4ed4c8af36b641adb22585b9c7aefe626c230488664965e4485d324a3468920197d4c5a400a319986d2ff97520e0a76719e74582f65aa8172b41bb47f942bc31e07266765ee944365e481a54269c081605a994e59ebd78e6399c3d8bb33c63b266a1927b2434dc80189384e73201a05cdbb5dc6f26118c549b21e3ccdc8f2c69499c997f268b661bd59993ffa9141ce655245f31f46d3d5e3a2a28c0f28d22c144dd41a296dd071926e2f22ad042ac9d504360223003755eb929d929cd6df0826343702894f8a65a9250108af53ad7a9b28a2c460a758ae7c6b28296eecbc8210612d80dfa3e1d482961090320b4f2cdf5baa48aee6038ccf8927833e14847418d74df3bed539f0f64920fa345fb9ec86e019504a8a68e2c63a89cd95a78247a1acf50b4fa48195ec9726a7d9f0a5f997cd88154a448e36f5419e77bc90104c324fa17690f0664d9856d6307c4347780c46b61d19dc96011e7e27237e849bf8b34365c12009acc7d541a8183f88146595717f6ed22221c424f1c6d080baaeb0a2f717ff71875ab1f9221a7d79d0d6a1344a14895736c4e9d3ba4808ff5ee893fcc34460ac38f334f000a120a89c7d4d7bf976dcaf455767a38102a2a068458f91a6f108f658eeb7e4dc0193e268688e871ddadb835655bee2f28e2a72595b695e3c10b17c44d8356fdcf565d45b6c1334378a1f2721da47a04a845f045145d197ed753cf40fbcc9f46f22e5c4b3ab188809e57e628060ed3a99431de178097d1ce3edc01dc55c05488164a675738646a8e5b2a564d769f05b7afe47fd5752ec8cc655f64e407ff08a9482f4afb22f6d5910a6c867ab0b5cd363b575fd67c97323d50f6b9219cbd0e3b5a34ba426bb37d3ddd4e56f01dd83c2e533f9f39e5e87f3ae994764dfda768d9d9ffe80baab6e2274ba6695395d81afd58dd69bf2f0e20ebe02a295317b628a53961537746782ff778f80430fc8b985ffd154c40cb526ff3d6d3ba01c08a1f03de1a788dc923553fac74ca2c98e54612aa092490185be678c1997d82b55ae7245eceafd1ebfde71992e235db7fdad585daa03306713b84d4fa08992d4f3b987cd3216fdf69c9803dc140e1ca2b417944d1e126685b0880840de4ce792106678c2e7420efef768ca6a0f7891ac63d069efa4288cb6ad443826ac14fae3cfa0aaaff6fe0f8eaa635ed7a59dc7dd58d317a0d617719060d4bc8dccc3ed192918d7fc1414311f4dfd799122c5adb439432d4b706e25a6d954836c9158485794bf12d20af1927a0f88e7b91b64d4bda11a43fdece6cd19b732eed2d20d2e08fe9115b0f62322d3e77aea5b11e06e008861c21506f21ff02245c99f8fd91dad91581f81b1f25162988166ab5145ad81f8180796dd4e4dfcab0e12c9ad5f661c3f583071a9974698ecc0833ec2068478e5eb7f44e55129f949ca693181e5e7deeacd1fc0c8dd8a92e761974d63fce087444c491444532138e0e88cc2c184bd78c8c7b641a0b0493d60413509ec4a2c7be111926100779a9bd5d61058c8718e636474c8d3c15997b13461a541dfd78d17e50d185e5926d4d5599dd4959e0475c608571f5d01e0bba382fb35340eecb1ccfe669bbd43d11e5d335207322aa8d4a6ee164ecb3e8d00361de586312deffd53dc4f72f4307325c7c05a072dffadfa1ccfe40d504ec71b62735b768aabe9b9b3b48a6ace5926dfd46108c0c03f9e9045567f412d1e4aa44feeee0306270cefd2086ec1e4db3e9f379306a1416681b9a54ab4ae46dfe4efe1a7a3deba73e03ba143c9327b7e569181ca9bac4453eb5b655f6e371207210f18189d5a0e9008498db664d77c489f4aed8cc02f85bb5ee4037c8b38aef08b309f9abac27fac1caa7a1242a1cc185b4e984fc08e2c146a0fd29a04a9d942d92c6381133883d860397a56d1a698dc07d7bd89ce0779d6f3395231f5f83f11cf1c90105bbcae684539d5cbd86b47f488784da4b63e4f9b1834cf6f6b00b4a751fc2ecc0bd93b5881a404fe3affa66b2fdc4862b7877203f3d9030990eda09c2fa9addae1d644b1dbb0bfb66d78c1c17f9c672a37cc33a4f89a077822fdeba37c5416444342117f5089aac56b5863bc9be3cae9f534972d571bb2f71a6fc2af7bd1e84a2822fb7abc0c14005b5bb021b1e29e1c876719b0e7b3b4db7d7a65ea84f3ad84718a5a8eeb0dda31025d7c3238f91392913323ad80566ac2459a809173d342f92c514ee6b7309f3f4a7ef3bc3e8a444d99fd7a784800b0d14dc9ac22a75b78086a13a19cf4f972c416133cdce664b20294e400ae1a001016a4034b74967c7f8693b562cd1c9b65f2cb60914ffb0201f08867115118e2b1fd6fa85e648a8321c4000e57eb07507f295e047d7d3f0a12001def9eca5c8c0b2d494e656d7f5e43eab5c4fa392ae472ba8984e2c50220bc88264545caf50cd0d49789403f6d1f7d064a388121710960cbc6d5e0fd7aa1f9ab2fca46eef4106a394562f1daa23b76fc6de72557d47306fa1fbe331a1d8cea36a7430aca7ad4997da5df3fc73bf0a8f52fdd7ea7ccaa4bd23584608edc78edad0888d0ce74b36afa8a72b0338729d8853054a5b31e5a4093ae789fa32cae61ee98953e1ed3727f654b03cddec1a80273cbe1e31228a8f343bbecade3e3e243dbce2686da99bfc08bf2f6cd6abfd311f7d746c0b527635c82d910dbd2fd6d83557481a8c28350080d61a48ed0ad4c7ce175e6f529d6ca263153cc4889ae796d2144bdd8c625057745f60b0305a0dd4c461d40305ef314154976cfb29cd608f6b9839fe03a18216096338dda97b3f75057ce886f5129e6db20728439b30f1ac14736d36f3b38d9050a04d502aac5655d5d4010ba9a0e0508cdd642f486606be674e24bd2b6fb1d68463aed17f10a32eece7e6250926d1e2532d1e5915c9192bb73013753d5fd112383c362dea8ff41b86e9f8b0682bbcd5c095c0d8c0083507fe0850c6fbd6dbbadc92da54c29c9c4059a05b205b320dcd18d638c31028991bb9b1f6bf889aad1918daee1f7e1371598399c83c5867b34bbcd1b920d7c43ee74dddd4ab21e3e83fcfb57093964c64dda5567815ea30347d7f08f404ff1d4629f1a715dcb87d7b066b061ff18f58fb5abd53ff8c35faee5306da3c1ae255b4535db0dfbc726eca4dbdf42c46e38a43790d1484333fbe3ad35c6f8d1a63bd1745fb783ffd475b2b60dcdadffd186bfeb68769c9e5bf156568e1054a041fa3d1aa495dabc10f00ba921cb628810bffbbe7efb747a17558af8842f848412b8bc9f5f1702148b842e4183af06e70faf99b64ed774815db52b178b630dce9f477070e93148b48d4bf721bbd0970af1a66323b79fbbf00d2e622a5cc5edef5a4cebae69a611d9905ffcf29bd50aaf43fde530ff71963773e84fe0ff3f0b1b328d6ff8b77cf7c94df3e60fa2645ad0c9c7f481c3e15849523cec537bd55eb56ff261e62494164cbb62436662da6df9d1f8c6b4ee78461a130eb9913fe07e6dc0c563d4d1f1cfbb5db6a2172fd28412e737b6a54bee2cb92ab3662797429d743772d37de8427ca361103fe82d9287c6f5adfb16c686ee33731ff771af8935fc0970fe196ae67db7932c26c8290813d34f6143cfc91e092463f2882c92cbc9ecb8cb9bdffc76021b7acdbfcb4ac926f9915b57cae572b15ee86ebfa9277b6a797599d404acb5318e6cff8c2f7a09d54bbde4d34b3ecd52ba3c6ab05dce628d3ec1867d9333bf89dd0d83369bcd66b3591b91c9643eb65ffdfac2f45b847db3a1e162dae076bbdd5a54ce97cc3f594cc447b51a07b2a6785aa76bb98fd7384ce623f366e61ccc8aac27369448b55abb5acd644caaa3d38b09875c30d6e09738304cac0cf6377fd4628d6b2c64e70f7ff18c7d7ef80dc396965a60437fb951dbb8d17d5b7920b5bbdc5b2178d9a33a74b06e3664dc7f37eefa70fff087dd8113044130a741f69baeb63ca8f3ef68cb5feee30f850d7bd648d6ae5633f066a7e09c5aadf64ff352033935e776f3ffffe3dfdad11aad0b746ac78935804b9fe6d2f79404242b82f40940013f9d5a1f6bd0c740c78efdb29584dce99b8ab4e4b2384dd32a178d27e10142b858de89f1961201033fbfd6ee9db23ef729a5f4e6940818f82b5f54071b384384307ad2c295a6169460422700357049aa02e6a8090a5c608452222632513b82de90e6f647259e2cb1002328acf45411cbe1454497980925bc54e8418789274e7caa9900dc58f4848827412c21815c07000b80a8ee6416126e6947d2ef5ae95bca52d1ef00ed9ab5b93c0a55db344a764fa5873a7db126a471d96dbcfc0f447567abbad3e89ec49882404b676e196277929376b56ea15502dc587444d345dd58f46466f36adb34734766549fbccaf91d5fcaef49e9ec64f553a3f83d975d69f064a5794fcaaeebba4ecacf71e935096f465c624b0f17154461c412233c28e242c5941288fc7002c7109598d975eb8d297671146f861333218ca0f0450a0f3a1d2099c185580c6400832f3ab18658015cac61c184ca142d1cc1850723740c50820d4a6255dc9efc107b752a741d2c06d701512b0dad802d42529024dd86b6e8340f5e723e4d4851c248a5a1bf462c3674161974bdb1280b15b4ab15c98f0bfd23735174f48a44469034bd20e70229412c64a14265298c11274a742a922c4b7caa992c51b2cc20896666f56db39af98e09862468a04c325b7c2ca0be167af0e10459cea749a78794e49a30fa91828522ecc291123d9a82562a509248e26df1fdccaad2d0e0107102112bdceedaea4128316e2c7ab2f46409540ade8c0c6cfcd845d183110a9470c0a2852664ccc036051151887c50a1ce40eb94ce979ff42080274a9ae0fe26edea09e57dcf42c186ece347f3a9ea7b2593d201a3d5ae956dbd4c0d8c69d9c0a741d3608c74c91f0319e7c1baf4d982e7a2a3e185f38d92fa4eae1a6cc83e7ca4e37bfb3834da663e0eaa055e1c5775160df061782b50b9f414106de352ba9481cd6e3e0e5c1c6132ab1db86e8d3afc26a6c5b3540b466a02adf3b55eda166b082b24f5fd4174bcb7da000500f0f901fddd831717606d5011d2ac001b4141e8e0456e97538676b0c476b1d69ba42df98fedd6dcac774a19482cbf27034938a42ed568fec344714b6d934dffc9dd58b26d41ce949b51af8325dd327bbd2ede6e9fe4b7242c15f3545068377e8ddfc5a733be7428322a2896bfdbe279345e6afff1b6c9dce4209514cbf2743ac5c4c8c5cef0c352322f61299965eb8590e50983658fca60d9eb6eb0ecd518ea90977459436b85444a9729902c5db6beea3495b55a66562b289ce6ff05564a97ac182e653b0d105cc24ae9b27542fb4f99a201824e78311fcd7f124a86e2bc99156eb5e584b32895b548d5c557672f984f2ee38b1f2c3f0c1b54b10d4e314efd2d4d9f9e9caec747f87add5ad160f94fb7af7466fa2a3355d994d7eb1aab6cd76ebdf145130beb266c66055b3101735ca58ea379c7bd0b707276eae48c0628672097b8002f2ec0437dce8a21ff74eb9dafda2cb965c3355f1767fd3987d7c8ed72d2ce01b186031ca005cf64aca7e8e3bd06fc2fb0233f3ffae6db070eae575d81b65935c895639d8f0dc49b1aadb8fd1ce31b09b0c1156bd44ef63fd830c66ec7da66728e7e91b48b3daef7aae40015b75fba7af4e8629929569bcddb55136bf0bbbc932f4175df8389b20dc9a3477c45644dac91426589f994d09848b8d9e91a7e1a4c444b433866e23ac0b65d69d672fb75f08d1b254eb9fd4c678c0f36645b186d11a9c7ffaf56bef362d9b5deb375b39625635b4442723ed52e9e5e062f6542f497de2d9f360e9c243a40c8894a454449371e716311510cd79301b3efbdfc5accc7df699bd4c71fe1c7068c86cf2b076523f3c3458bdb06c67bcc3084c817218cdfa0ab8a835759150730581d905f376885f5bef8ae06b9b37e57d5aaadd0e5799ef7cca1092e3dd1ae3c4926fc01bff3c794041808fe80e3e5d3334d9e4e7ca7f7f4e4a91c36e64facd4bb0821de981b61ac1079653e1422511f51733e7d959da8a753cab03a20df7bef3d19f2a33ec74110274b88bc5ebc36ba20d1c2090a296481c39021b0e8c905d1a085288c743c22486471c5c9172523746020514415209af8e09ce8f45b171366f1908cffc35030e6f2d60fd415361611b93064038ef93225c9d19424447f67620de3667011c7c3a384691f3b6880a8c8651b6e18bbd0fccc4c93bfd7c175f7e0bacbf04c12fb835b1a983f6b9d2c0d34e82dfbc647d7b86a0611eb378c38765dd75fd9928935fc3d4ef98dcb6bfcab4f1f198835fe59d8bc5c7f298c582ee2fd60c37874fd59289a02067fdd478330d81f0dfafb7b4e2cd35be567a30639c8d28fb1882c82488222862834e04e39a84033d2c207266098a1833d358cbf7ff8fbc5df3efca72d6cfbac826c34028cd29d2f845efaf1e79c37ee80c8868c749991924e1f59a73abb8e4e3a5f7e7c3fbdb384cc7baa2d21934f1c60b15cbba77d72c47f86f2e5c622284afc1fdc580485c9ed3992f36a1f082b1422e74756c82fa4dc8dc9b6d4351caeb664637abd0f38fb234b7e0782125cf7969079fddb058f16b718dc585444cff55408fdc262a3cc0b80c744bfc2b8d4af58835f469197d7caecc3947fd45a9796702fff1863f7d1556baddff52bfc1bd658bb6105127191251b675190b20aeaf0aa3ce150b4c69ecd664274d5c3318e71b820287f5f592bf054df7e35afd56a352c7a7c8ef87370365ae7d30076c4fb5838ae0aae7278b4ed2849a9cb0d5d16d330bec133d0d02fdc7e6eda621f1ff631817d64d769d8c0c1af1f999b6d02320f922e63c1867debdced76e37fcb3e3225f186f6c04468ab6f5d5db0a1d5679101eeb5cab2abf75ca41ac949cec3bc5e1ae882a2ef38b186bf066bd80df62e500604c19f814fdbc83a94f7aeafd46539eaa26f8d74bbd56ce8b2233eb0faa7477d7b34bf09228321c9f8c5b22ec7f90d8e77e91b10ba86bfb66414ba4c16939494a0005d0f72219739508c11503add9fa4ac46ad6377399271cefdd337b492cb50a23c716bb146bf0f0e3c5e865bf9aafc1ae4a81323036647abf4f78007dfe85a32e207378c463b5feb7c527212367cff1db04197dedede0e3ef88fcac27d083ba5941228168b0901c984828466424032592cf6238b7d058288e8051d2ff4e7612440a3514ae7a49446a3d96a4336229bad363444a331194ab9681250a0f4f7b50d9573d68a9294ca4a655dbdba98d33e424c75edb44a57acf19b78737a77c0f5a7c1376ae207feeedfad100160ace1a7d6aa69ea012c185c35a31a42cc5dc51afe9e0e3674d17057ddc6e14438ae295dcccc2e6e5714b9b1c84b983be3c6222f49d7fa4dc7806edb22e8912747a3d59c35c43d2836979492903a268b14111bf6cf4f50db4449e36363f84725185899d360b7d2d160f7fd7070c5f2e46a6d53b331e2c9d922961cd18da9107872440dc62b62d7bf638a2757cbd172b41c6dc84664535d796dd7931f4fced6b5bee99f214ff1e48672b41c2dc7a47f787239dae733906c08d1a71cf21d638c5da50c12d00b6886a9c70c93177726ec94eeb2156347080229a5945d376747a9cb774927096437bbae75841042d080a00bc76fba8fdff5f0316370b67ee7b5a76bd70ae202c1db0d4e9c5c31a54993154858614a7797eec5e5af72d5abb658a9a2744e4aa9a44f299d9352f0dd27f8efa247306172029f13c8c41061c62b533994789a92626a29897d831e1bd69f0639e94800462c7fec540450573e4fd351d3d19c2cf0a644405d49591edca6a4a6a4ee6b524a6a30dea3a3a326a5265c9352d352935227f54d6d426a426a3a6a3a6abad526a478d460bc2825d9128ba3c732cb684fcf4e8f97dbed0aae7074ecf4f0f12308097e1367c4603bb8475f6e7ce2c6a2a3135c9e5c8f7f5f1536943f413fb2a019cd6f502e6d7e1375dca7eb37636dd379efba41b7c38ab494928f6245be3578a4d4e012eedf46260e87f89c9395a2432a4faea76dc22160cc15c9f5800903260c9830b922391f2929a5b9220dc6cb93e3c915e9e91bfec9bd78722f3061c0840193e31f9edc2b8209d360bc37140b78c8f1108490109d52ca29abe0b8044f1310970b029ea658cc818058a88162b19810904c28486826042493c5623fb2d8121d747029a5a452524944ce49e7a4521291524a774ae594ee2efd8aa0ebc9c4d8925dd3cf2fbed8ee3972b920e070488db183a7a9c6d354a3dd2939f4dc06dc3805879ecbd3146fa766c8d3546b9bf0f234f134d1fc799a686dc3d344bb44524ac9d3646b305e9e26a306e3fd789a6c5deb1b7b799a86da866ff334d1e2a5316930ded0f2340d798ba789d6755d57a1d87cee941b8c6c3fd793911f2be4db75af8a73a654943503c9d210ecea7ed30e91a1c4f6c7d50d9fe8c6d48e6e722b94b71be2735554a474bd6e5551d1d1e5da20cb5945cb4891f1d72c1aa7bbcceed255d027c28611091676972e3d9064acc133d6f0a764c0e83be51e1888375dffb77ec41a5dab87b362366ca2ee56eaa43eea36a25d09e3574482f5f0818484f4b221d368b55abb5afd83202d97635ac3dcc6c3060e1c15c77b788d8f888483848384c34c642061d8c3f871b025a6e66619ba0c90c7dfbf4346709260f2a4d34e179d3b7406a1b3d26e7aad7f3a26ce3131b172e8e8b77b177e9b7fb979988ed6d96c366315719a12e67cc391c8225ff09bd7da6b4636ec5c2e97cbb9cc83dc69b00963180c46c4863debff6ea4a5f6827460be9d53add6c4e5b95caea742fec4d8a55aaa66abd558516c28614c9289890926e32de43597e2576e7f977042bf607ed3519865a6bfc2865eebf79ad76a55c6cdb332b3f37d9f11935f06d4594c1af4c9daa14a1ed3df031e7c43c68c686526d6a0adaf6bfa3f29be8e1f16470c5de6ffd136e18b885b810b30803999210b2a683a3c4393242d459260e1c484c5991d9ea1015d3670e480a083c708ceaa9595cf92c8993c2abd1ac1ad6fb07b95c341b1a46aca48d8d5ccd3c85771e3620e5eba35b061bcd22dd9a0f760fbf95d88f4d9c8aa3ad07ecea91cdc021b7e70dfe3d6fcd83d658960def922f03b1fc01fae195ab4cc7e6e0737166929e174c489588f922a4f54e1854b94824392263c70f1b119d51c6a406de0e4d8c0c14db9243144123f433e441741d87e96fdb4cfe56f772ec00a96198a8f32fdf0a31c9460c30f460b36fce87baa8afab0d64a51b49e6a8c07d0cccbf4ebd7aea56af12c42c6d377acefe42d799a277a3a75914ee9b2a1f036d0c2724ffbd55939ca68132348f333724ab992adf851239e7f38e794d166c6972d217ee3d348594acfc9b0424aa9622ffdbcb2ddb6417b6b8ddd35d660efd9528b67c93d9972c7adafc155479f2557ee91daef674b86171b7edd4bef80e0b8f2a50c3f9c6f1b547daab699dff77d1f7ef77b8aa341b6f9beeffb5a2aeaa14e73d2aee6e8289dad183bbe3b5b40705c0904c7f5968a1249f9a156d536b115ce8f618cf36307e26cf9535624e1ceceebba9f13859aa8ae48fc984279de64c5a72c46a1be9b93a2268b8b44546499ca516508d1dd29ccbde535ab4a14cbee6ec9586be7ee451d5bedf49fca6ef6f439a774101a8c720865596b1966ee3bc49977f0a43bf79472b6059bb738ad2e1c299be977947ac71a6ffa5bd49bb35587481374b7143920e80032b2850c4cc8400520239d08f470c3024685146079a1e220c39629c312ea0a9aab45c880243b1a9676c124c617174c567ca32fed26e6365f2a40159960854d88a14c38b223bd73f0b4ceca6b6460c3885bf1a0c1b17a1a2e97bee281438363f5345c3920e8d8b131569505088e59ad56abd50dfca23f44de3a03cbefbd9001407a972f38c09c191a970d004c4942db842f663805c9c2a4cb9730fe6206879bc1cd247903784284ad04910aa02f351d13ecd0fff10dbfee2a2bd67b21f32c47a427d524378c4afe5f8e943deeba42a57a1a1816166c0070f9716cf346da84b2651da107124c495576c3a8341fd0cddfedf6ddbeef46a6ee46838d2f6f2cba45712bdf782b6e2f4862295211367563d18dca9cd90e6e2cba31e92cf6bbb1e8167493cd9c93fe291a0abac156d78e2b4cb1da21b0b8b2821bae6a2bc4185f4a29638c2ea74be93df493dec93527fd536ac77c3abbae8bd35d2e9774d15942734f799bb02a41299dc62bbf1ea2f05239bc36b1e10c5ba95df7e0faa352397cdeee3f401333a06db1c315585ea03382157489e5202b2294834e1fd570fb41e8eeee2b57688ca4f8a221599515aa20595172c16e9a2f44b921b2a000a6c94a172980965e349c80a8de5043cc250e9527ae182db1eeee4878b8de4247c935b78ba838b9fdd2c2002be2eeee5e450039daf9ba0f50842901b7e5491414301991821455a07802081778480622d71f84b6415db77e33d335ab282c8d1b82e04c2bac53789871bbe5279304c9f2031112e4071072fed624e0b696ee96d703b1c60750d08285d702126bb4ecf79cd87628bc9b9301e2cda90524860a0819c08158c37fc82862c368d3e13e77b888319f7ed4d131d9f9b1c3c3ffb45ab970c1358f81c7ab0c7836de14c0ca0b2fd0c1042b9650d1893e488892c0485104c848fce88013764e10bab188492889235adfbd2ff26274639197a158e5c6222b54b82c0bead94bbe9e8c31ca8f972767f47324e6737a76f13f06eae33d7d8cd4bf8b8ff6454ba61523a605d420101193a02b2ab052a465c80e442bec20850813100b2956fd2a3b9143cf102e4a18264038224a0f463c81420c28e85212e05709d7abf456ba0307392871b2822e5a5e56b634e15305962e3e475b502cab62812581064d6a4f9ca822851216a0a282217231257056783425020b3518d4a0cf101ac88bfdd00294436c080bd0d104724b291865e1a5082ca86bfc9bd54025d8bf21cb80ae0f6942a4064d4b987c704244c7230e882749508102142743e8f8b3cc9f83fc3930c2862c0b57335bd870d592524aa5ac2fe5cb540e29a59c2efd654bb96ad00671cf621a460a52c84941fa94ee2eddcb15529040824e29e594551471e50a0eb63fb60f1cbcb81bd929a594944a49a3d16cb5211b91cdc8561b1aa2d1980cd18e303262aed96ece39e78cc562424032a120a19910904c168bfdc8624ba64c1122168b0901c984828466424032592cf6238b0161b3d129a59cb20a194968c84832039bfca8f46df904255434340000d3150000200c06068402a1403010544dcf1d14000d66863a6e54381ac982811c46711806410cc330c610830040c800849431a21d005fe8b1599d04b574a9d1e5369a0c5103d4bb2670daeeba921fb12ea4e4c8a7be91ddba8cc2f1f8ab1c711d605cb493b6eabd191d50a8c5e8ab6c829d1ff06e13818c3886e0b51c4e2de8cb32726bed8b7c23de1a46d9e5a73c32c12c81bacb8fa77f4bab95668b44c2999fbff31cb8b72d38d33a5e349040749afc89b44407919197d60e37aa1de3413170dfe1c3c9d628a7d1a6f3a67bb0ac239818dee67103a8cc75c993e3de9b2f98158654b4f7da798d687c13686fa0fa1badb4d15bfb47d1304ca2bb5008e7b4f8063453cdd2db34fc7fa94b640aa315e5a0142f8fa9d4bb4dd5575f0c816a8659aba5499949cfbc5f837abed06f069d511b873ec382338c527d4c20b40a5f9095950a6b00c76ab3db536fefaa393fc5fdfa5442f97d2b53690717d804f742ebf82f1b6eaf0a24b7d25dfb4378ae95644575beeeb823d9d3b280c85694caaab9fcf6f7586da6d4534ea6195becc1254c130c443cb24b267bc9aace33713aa9a33e6cca78d70a9d027d417dfb2c815695ce8c369ad42c4f2ada9f2a5dd1ca3e7e2743555723564851c1695e36aa860c99d9b4b74abe02fcad8cadbb58011bf63c8cd190b9a6d8279b50445e89c4590a4254ed53cb480e20c212460279271997bba035fbe5443c041740cd6a192c775cb9c03c8a3fe61b199875e5aff582560194c8f94bbc5b5185b4250be2fa8514aabc7e490f0ec4163ad943408e14985e3166b9d911e4955c6091570da6fd752186b419c846ada093f7088780b7e9cacb030a3fba76102307bf3e1917fe01ac0d38a61bc8ab57a593170eb67fdc174d09789be5b5c052aeea3c5de198b4110c10bc24b6f130961649a6319828848cf1fc69e18b580699fd3ab270b8913c8d6fc2e6665fda87154020a3c036ad34500646b50c15346a35b8bc32985885c373270e69a99f55131cf49e922f0027a3735a0799bc4ec9d2060e05037924a349235da180f75c84b84809becadaf0d8ae00fc107493c0dad09bfc24623b9271032b1636a870c062384fe4aa9174cfcda3ff75718761d201264ac994b09ae8cd22908261256f3f700b83ccebdde3df08f633a41113aed9f44c919311ecff0125ad02fbc2d9627edb61fddc96a9a4f05db6748e049423509c4f694465bb220cced6cc9472482d60e4cc68be283e5054e22efd2533867f301495b634fa5e891cdbf51fa95b9fd8cc5fc98bc00834bf0df01ffc976f78dadaeb0d5d5457f5890035352e374e9469b8f7afeb5831ac329bc299f25e1026ff724b541ba8750c787132c3ea14ae8005a2e438801eee56f313a9f55f2ed77e73ebd0549efc0fdc542361481c8f44d5140f3fba78d311b336bc507c8c6f56076d38750c243c48cb350239e59914893382da8fca352a498c28a1dd1552249aa3a366dd95b70b2290ecf683358d7353d601f4b6984f3999e050cbdadea63a6939af0320487852d8b20c114544008dc8f050c68dd2359551b37451b5bbdcc559d989c8c13203171c35cfeab1e216d8d258037f39a5c6b3191711d4ab609f1ab72c73472bc3de647a45cd6133365a3468b01905c2a0cc36cfbab3dadb573452ed9882bde415d4df1d76f7ce228b512d3aedbd3867517544af83412b28333c51394a4c0edbe8068e633c934bd7e96279c50116dad1168885ee3cfb5a4ee6f1f991228f396d5400eeadfb12f513240778de725d154b8d21fcee371347a2d669c7fced6bb774bb465014a679b063ccc53b0d6e460243e5b475b0d29edd42957a27f905af252e9ad663e0aea30d2a675adadac5febffeadc090ea60e5401f44d210006c080cb91a1a04d1ba2beabb54103ed8db47ce1c1ed210280cf33c0f4121cc440ba5b9839accac0f6e4d07a1d05674174625188b5e5efd2ee7276d5a700f9b2635c842965538c53e50d822c7012ab1a9060c8339cdc880c213982f9ecd41e7e6c5f1552ec36ba7773b3083ad3e5feb742dc57e9cf0866355c383c65f9355ae14906b44d9c6f7844294220b80b71c1fa62a200fadcf82b204d65889bfbb3d03fe774a50eda546def36437ad112c0ba6538be293927c298109ae1444ea4f4564534633b5183fa67615516df63cd48e361a2aa113e5eaae48135944c8748dbc15ab237e27bd2a341d27a8d65cdafc8c18f918039bc0bdf2164c5b26f1696d713d026b9f27a74f70301ce9a51b16d33de180625735cf20102693e3cee371ce3a62720543a7c96deda4b8caf6a128f3d26a4bc785078b234d181d110db321647d3e1852a877c6ddf32c0a2e1f6cdb5a785be9118b91da4d5a4fc7c11f462ad3282005038323c2a59cabb868f5e380312bffa796b3221ba98f7ed28d852d3e3d95bc560c884191a0174d1c692c3ab3d851dd9df3ddce7e37ab5ded2d9803fe10b081ec2e72af560b19671cebe43ae077086394e702fb6d6af53e760a7956c261b8cc3b3cb98733cecdecc10824b76e2583df3149bb641599c0dc24304704adb2b885e0aafac5c31a84318871f089a6942dc3247822e14453ff6641eb1371d12b6f25b25cfa716e30350bad8cd3c3998a04534675eaf1399dba54e0308d275bd3b8079531d5de69fc13cba07156fb536bbb2fd31e472306ad36f57ac7685071e0f25518d14441b01893301529b11d17c4b82cb18468584b94b04510920929d81d0584be6ec86030623055b8d3d270f5fa65af8f796e8225e0434c74159816de4b428c3243ddb73bd8642c4186cb063e9cd581260c3571824959c50aeafaa03bc451ee53ce533ff6c47ee07498d87df3690dd2f0ddd1f40316c2074c43c5412c31717f38696c98b94f6e58aa9618394c4342961e657ba1f77a8a7ef78a30430d38b32bfc23a9c7ba2e400b469cc1b13b8ee164069cabb056a2ca4fc304eda2584c23736485eebf11a2b56458b38902b2c949adb99b232626a2169df4362464c4e159c6b70f42815998dcb0549b3e83e8c4f825deaacac752f9404a81258d6e0d207b09a4bdc4ce50f602623cbc14b8ef7ce2bc126071e65e76f4470c263e25d955562c17342a4269e9b8a7ece095b1e5e222236f04640ef41fb0e6d7e5e388cff11cbcd7f9df08a6b6c28f9309e638d4724c429e7bdfd7963156ad0a633946e041c7083a9b7f1a3f9fb8e6e7e5e4551671d57da97e04a37b89612f188b83835c628c25b2632e1d11766b2cd28282de9493301a1e6a2e4b6952a8429255e0e6b6b7b7441ebe8ccc04bb573c50168968f13bd407ce4ee49462c4c047fcf129d2629b9e0c15518b6b43b5549450f4a0a7f431029abd7822b6e25e3ab122a4b91fe918af606abddce79efe520a93a67f1b082000b6fd18d4aaacf5b232efa60d36c47f56a0fe703319e47f70d2e2577c37f56748129e52adb63a6870706a96ca2b56b6e3aaa6050d16627fec49abd28c0b9ed8695bfda956128d1680972dd6536859160d264ae5f1e5a961785508d53b33f87a1d015a7c60bcaf3aae6bf55feaa333b6cd8e48597e8fe6c42490678318ed3dbd2515115a2e3d6ab0b7cc507f28fad6e2bfa3c1aac9b54629c819b9cfc813c37d6331ecd3bddc03698fb3d0e703f455657edb352798918f2d095410213cd41a52d755c90a5cebad1f264c4958609c4127955f8914551fe64495cc7861f82a76a784186e18b2ed554a2a4f8cd85e5af52ac29627f910188580016cf89e371d5229f486e1646e1c7cb70b7661a1c7639730e323c48a3e42048aa21ac76ac8f241e476a2c9e6e1ca53c7970cc05f4f480f6620152278ac2e65bfee838d1e75bf9c5f1b9d6173bb3ad652e40f1793a30a05edab6825362a43f6dc8241b5b34675440d62e6e09ba0197cbc400f8dfb1732f0654f876e679b33bd09a8990fdd669bb431b477ae8b0d89cf6a4050456ba5f2c9ef50a6511a80ef9529fd5c01457432b0bf3e3877cfbf8b94eac1530d6d81b3b562c89c52228e6a1552b982b23f57d3e526c4844e3f3c52ef3450ab606254d5d2253e8ab4ca798fa5ef06506e24c50aef7e428c3142c8f92e1961e154f8133989ec024858d9057091257ae0c95a50d4654a1b02c09ea552b76adb1860801ef9ae7ed83deb85cc8bd0e72b4e7e557babdef556c11e4640e54da86f15dd9c543e4e5a583f6cc0010268de0e801b8141ed0e242255a58cd2871cdeeb36e250844e25b7fe822866d230111dfa12c6dfcf0a59640ddc669a2ec85fdfdc3b4a77900f507c2f167789e59e5611c5c2f232265d3de6d294b580da1a88857851bb61128e68a1ca626fb99ae0a8696d3bb6a5797e1bb42353525e90134462a1b0d80ece9f8114beb2e3f174d2e2a9065597c4bdadd48bd29909a8b08b4529d0508d864b3a63f50aa7d059709d9ba2389eb93d5b21fb4646318ab3406ffeea55b3092de6740c6e3916a12bae739f9f56a0a034213ba0705193c5d08b48463c74ee0ea55ced524f3b5b880603a2d827010f93f5fa9cba00d5d7ce2c3c5a75e56c4f8c8eb389ca0e97efe07b6ee2dcd9f309305fbe74a2c9f7597d6764f549c40560d6ffeacf0a14518cf8c19a554b29e8bc83cf04c66c26fc0681a7773efcdd6cfe2b7a11d2d1f92c1e05a0c311f863b30caf7a8a1bed7d4d095443007c002ae0314095d500843fc4f0b1512bcb826f091f3f1556b09aad783b70d45f09d0990474cba4b9b3ddbc2938dfad8173d975fd86893b4bda82c79a10f1c841c9c1b0ccf90e35cad5851cd5fa922381b4e3c5b9845eb2810a6c296da2527753aa70e1905bf6c8e2dab072a80e7ad61f5db64b53a0ed46d7fab51dca906e0bdd16626027a9bc7580ba06dcdde2510608ad726d2bb5727a64a4d13b2d6ce147743d675d63ea645c2602fa84dde21f43198d412860b2c2caf20f888b94e3fee8dbcce95d0634935666c2f430288f61a3674fe20b2da6585ffb47632abc9e85a8f3ccb5d3793211383d6c86342615c0711a63e7b55d90a1c09ed210a3c6c4b8774822b33b15cb21668ae64545cfd99c57ea8808bf1749479ae4ccfe27d30f3d0a4e60b73be80ae6653fa5a99feb45d2b8f0480afa543c31afa7485dec12f6e8ac64b0caf6b042bf4d6ce9c23176cdf1c91d46cf14bbafc677f5c614ba0011ad7bcbb845294aa9d0f49eb320cc707920df84591aa4522d8355031117a304ee8f5e46861fc9076db1c8c7741b306903d29cb1a5b965d39ea86c2cc5aa405b8b69accb927368ff662430fbbc0ae51d6aa1663b3a67576c43ed6ea3f6705067f32bc59f9b48b041ab441c6190eca28c973bb7ba3b49147262f63cb410628d93126b5d0d64f8f6dba86263e223173dda0efc40272a887b76bc94d28f20f222cb46031d6a6bbc03c5d38fdadd374110472890db25cfa587ff30b316f31830b8a4d22aad2c5f60e007045821b0ab6f09dcfce3c869da122ea6372f0df4a2cec42adcda51360734c8875c250bc2030d3b830167ed20887873c7a3c60b9976307aaa53079e49fea0d8ca5fc992c86b0e1b6b0676471c1a103451b30e74a6e40fbc25c5f821df38db0dcd240fe19ff2c7577da665c0fa8f6cdd15e1636b041578705d2958531a66db1b6d2a0143a04993f7ed2e430147429beb450cda1999705e932efc054eb6f77ca4650e7a5be949c346cefb129fc861a018ca015c6a7a93b1d8fc16ae194a2952dd5a2724c89dc4acf39ed4e2037819ec053f729923d00b5c79cf52c4bc649e1056f99dfa29312fd7e63a91037666269cf7240b5f81a7ddeb3ca4324768ccbdea0ba17409bdc40daedaf7f1d2223d82e2c039363d2e363f0871815beca2ed9b6aa4fbf1a05991e7940185a80c0fa2b1331c1e0f769c58467a3091a176a0b99842b8e4b5dc3fee43249e0db3b6dce9d16e11cb1d5c84b704c58ccc5dd5d56bd11de67592542f511aa0c58c6b267a93c21833fef94134bf21d1bcf1007d1490a547901efdba07372a624f0f2178b2872a0d41308949ee14628dd48cbee420f5318ba1bd84d2761e492a71b549712cfa02480c727bc7a0dfde4df8b8511c7cce94ccce891f649aa2439f55e42a60ada318d9c0d3dc24861847538890df223ea173530c4806e09358e3188eb50415f665a184aaf2b19c5639505cd47b4ecf42953c986c1fe1b46b467cf3f27b2ca5674701a9c461f4037b622f327de12a732404475c2bce98646f1c360197a1a391286f1811af1a93288dfee7d027ff20d0334ea646694eb6d2dba03c5412a7cd1fab7b120516696527a28948a15c9b20f2d7068757e697997ee6308b2ad927a23931fd752fc4ceaa731123ea499b212f73163d82ce1d4d4bc9d606cade8760dd589d94419237b2e925195938cb123fd7d2d6179b4093c188e230af10a78bba68ef355d497b59f51c5fa643c7bc9016edf527de4c647b4d1b8fa501d0d0f22e98883b396ec141490324015dc639f164d1452ea69f15be2aa7b965ede4f0bd7d3ff6ad94a0da917530265ac1a971eeb72821230bf80cfea55943a79b6b42302988f0d06917d46f182a0f7aaa2a715f5e88990e964b5284a55e30294fa026e84da5280225f0ff24b8cdc73459096957611f791036b5311cfe4ccb28966f1c38bcd0c719bc615eb39fcfd1211719bac67b4f328aa52e31378bea84bcbf567edc994c6e2416defdc5f7591a4e0a7c5765d4ee10ccc28f8c501e78e6ae1de62177383845609693a8997d6805cfe43c8c855efab0c24245012d2c8b5794df35ad7918000efb42d4de875572abc6da6e9c837a304ce747a59b773db3a6c4da3f8a0f63a4ba223f559d8bf7260a912bf19bcc80795ff11e311d8e0e89838b56a3565ae4b0250274c66d6ffa9a55f5105ad035023ce027d83880bfb93392ba71a058a78012ce9f2f3139d57726a7c44b66475104776c27ce1e4b4e5112c8b393c279d0644e845fe6a0028afd7b3034f01ec627155963ac0214946c45da6cd4036d51c70e4a36a0ef2e1729b48ce7982e4358d7c13a884a407058c0b8d15903390031c458cb6d629d14cd265dcd09e8765d9e3762e72fb4bffdb56cb4d883e9adc4070f397d89106bec460f6472e5b3dab0e604e318afca794cada61b26b0dc2a4d850ef51de143c9e57297380ab136b4277303e46d2298089ad92f944981078fb4f415416386afd151986bb7a1bed390b2ad6fdafd782a8891f45e4f0be694b64777eda272f7021bf43063bbacc2d6e4a98d424c5b77534b1370facf6024e79bbd419c7755d8349c4f94707242b70385160a8556f36953e95fbaef08ce3f354051186a92a385be926185337129f6fb27cb34d0604e05d3128691010dabf0bd1625c8f287362a99137e6bdd1618924bd3edddf04948c99ae5ffa16f41898dd3db11bf0c829bfc4f1045f73e05174c8a05c97cd9e950c39f09172e6911cdf6cf7d48781ca09098962b4d29b31d524a428db8a2b8c5c91ff56a0f473542b30ae9d710123786f2b71c3814ea7f44688b27bfc50401f7fabd69d8a55018576c789359f34d347e03ec8f7964f00e0f2186d52d61c02188b2ff673d1290b8e2b24b988f5137590914b62caee01b7b639cb3ac37b10c95df405c4930122cc9eb582bf65a6dec5746b65f6c0dbe98b4356a26ad4886087c112060550e522c27dc1814a1dda7a627e9f069a981f21941192d2e9ac40b4a1983024544e1017f7af2be138c9f88724383ec18e16b44d9eadf5c06204b1464414e4b0d8880a94ef1828337ce63835fbaaab34c7ae14312c0a8349185cc4596fe692d4344eb7aa9d159dad1714e573f5f0e252dab26932a222089892953d84495ea82b45932217979275d1701b67a10d865fe935dac52da652dd909382248bc0c096b0d926baca9807a96c53e9d8fd30d9948fe854bdc6ac69cdfae11a625ea256ef8b47d91d37dff2efb83e9a1d03e3ab82a1bca613fed6a245181d82737ed997aa99df9111f813f5b58f5aaf140bb41d1839ccd89f890d9b222362961b43df664466a25ae100e17d099b627631e7999935e26f163b89bec83cd84f73d724b973588152b0a5c56a26e0a903da57c584d699a0ff315951c864ad10ce8cd00197c6d1ba814e30ae7914245b61c4331c1b0bce893655660d9845e48a7a26d184c1abbec1a3f6aabebde1043ec384edaaaf95dbac2ba59ec00d650cca967c6a099499dd0c3632c47284fa0bf50e13702535f33914cd9787d1465893f78b7f8e3c05334983d15a52a29d603480a9bd75e2e7033998b2220d95bc61ccf934b6e5be580269367329e9d2c048f0a2a3e61a51e9e65eff323d5c101e156aa6d83f0bf5f29ab50e3ed5aff09c63bbf3bedc4584994843032d11623e8ce650374cba8514cd8ee56c86850ea33b3a481a5a9429922ecfa1c3ef13de0aaf571e585fb6d089a35932818950d689f03ca074d2d15da56ebdf963459357804acfaacb5a4f2e1f8f709c95d14eae93449d9e41d507b17a99ae40aa650b52c6dbf8495fb13f06f1c5d870ccfec03540dfa4fb796954b48df74f1db448c7842b6bdb395bcd95f269fb695cd6a7bf4474d4ca7fb23ae9df3327cfb01ec6c59098ee0b70251663966889dafa2dcf8e168cb107f32e037f7a1e591b64a74908c3fe610e43c03f151087e2a25a2080908227dc434e9b1a5b394218f1a87b09a1823472d311ba7f94afa1e48ef4a1d05edf39bed69a81a92a6bd74470b9358a96f99e23a65bc1f34f5a6161e140a89332c50d99238b5c874b9bbd0d0ad3c6541994ac0c9a9ccb3ae9ec2d42c53eb873142cde70fef727c53e3ce6b654ef2cca2c41db1798bda4a95b226e3fb22064784943136d8a04a789adc7c7984f20afd1764dfb9bbe796e3c157d57152498f266a7508c90a63cc53ebf7da92f639fc6e6e8adea3119780b9ffae0dc01a1acd604da02837c1b6f237110035edb1eb7afb739b25d8594c43a8452cb37ca76b1317e5fad1ca38412a368945ec1f84c4e2b48d8bcce57d16d739c53452cda84324c8ee6cdef58e147e1ff690e81cb642a08aea5153b4603a371fb207d20216b33ab695c25b4c1500eb8211dbfddd215421142b312ce5b1318f1ad2f992f924cf5bbed663616d565937a268966bc1b07ca6649bc999d56997d1f204207eb922ecbf2c6b867284f856ce49ad276494f1c2667dd288482e69211846ce67fa1418c6fef437617531cb6fd07adca5eeaabb3132e3b25f389da21334e15a24dab891ea73d3c9524adf18999dea4e300440394a017105ba8e282085c061892e5432e1b0cb99176e11156d0b9512ac8bcfa5fd12667b7c92ce66eb5a0be7d518ceff947951d39e7347ab505b252b018c21d5166f6faf5e2b16a5f6e660b04099781a05ba058c2bac68f232f3ba666d6b0b78c140068e9edb28d351240f59652bd81a7e6df7c4104e1c50e5e526a2d6242f89f1fe8829c54070de03aa6a6c558f892a89f6d20edfef237744fde4d418754d0724a050aa8b2172a3327b95c509e54c7821f8172d230a594d894f2ba14cd73771b5c5ffc5fb54daa9cce21b681a5195c94149fa4539bb39995aa89752f1564d970cfb4739e6e2bea5e97b903b641d2ed5034a1a9dcf0d828e93af79451fd3f1e1091c3b473da3d180b99ab146139e811d7d8c5d9205a3a7c1c0259c30ffe3d3955d93178c799f0b425dd2add02d4b9cecc32c941ef91b5cb489faa844ac77ddc833d0ae5468e36aa20a124824469b0967b5ce1b999d7c52decbbe873145d83080ad9119c6f1a19f498e8604f751fb9fb4e1edc6fb0b7e1ad4242b95a98e617fef68c24e4b1ee493905fdb52daa40dc8786e66f64809b25d61c8d66fccb1dedac5c235fe8af7201c5a57b681cde8b382b53b4de15aa0eaf969ea8251213bfa4c68e39cdef471bc9bbc23f972a2130513a3a0cca1e763ff897d4a940d140f5706d8024a5ab94c1888a389928625f2b7a36e334341fa84b4b821aeb18808a14e9bd9cc6b585744fecd90e3acf95f36be6ecd2feac82c7d032e49d911a777e1366bafd7c0f217910325d13be8079cee5c8894d3104995a1c62d44263f181456a7d20ad07a6b2347faee6b74b2b9abe2c796f35bc9689e829da6ebae2d530b5575569a066283b0f2d304343b6696a889a54118154ee9d96c30d4491edb7d76f5e01610be61c1e2697ed08d3dbb883b7b24376f757d29aebb88b648252c3869c2fee82ada9316e0f43ee7f52c4b7f2383671eeb9d112f29a11d6f9633284922daa6b103b78863ef7284345ce04f916cd62cf64faa5e50c6b753402ef0ee99dc5e031991a748b29ce524a4841d808ad3565c77f27439016ceb5327471b8f5b7a633643bfb027129ef87791b5cca2e0e766e3a3252058355d8224fd0a8d46897648385feadc60a85e9d04be57c6be434ba1b69b6616e0559e83e5c35086a93d37a581b7321018aa1c1f1682211ab793806682dd7c020738d02974dcfb1c8106c380a92076971e1e37efb745812ab2fec6134a657bd4b9c3e31c27e863119012de0c6175d66fcfb65a0663268e1965355d43eb2f6172dd2f0de8dc726b4dc2822d0e59ac33b0aba29a0bf6bec4daf924f40e12643ab48824d392dbb8b3ffad2ecc20d453c3a4c84747b1793a2882b8b664ed917cb6c1054933d0c693e5e06365b4b6577f57820ff08914b08159ee2fffc0bc2d87db7f33260c1e23f6ad3e4598e6fd815138c3d675bb9737db42916f6db3b674afd8ddb148b68eb897092c48777b8dc6cc20b15f799b2457dd74af01a88905fec2848855b0cd7225cd978f2dc612137443fb2a337284b72d3ed95a11ab458ae8e317ddf980f92b35d36776cb551a520aadb5b58a61e2d4203a1789cbe35bcc451e56cf45f2a337c1d2267f8870436aee5a60a076316b1d668af102e513992e6829e7fe2327b484bbaef9d0028ea27ebf2e001fa17a6d393c62203524f4a3ad5befc27baa5075d93ac548508c94302d587285272f52bba5ace69b436b294a2207293136e533aca21de9dbed8cb062cadd1af44461b7a2ec327321511bf14b4bb1eb81b849c84c94d4e813732ad9669dce2ce59ef7ab079f5a10a774310cde3c1ad85899ba2803c1095160e8d861393f1305ac480305868fd552c2a51fe26418b4efb47a6c2961de488287ccce31e6f40a0738d7f8ca02602a26c0c73d53da5585d28bd953ef050efc04cf1f7b7aaac1816905c31b3d0713e1a982a08fc9301f1c5f7de1c4ba9a43a5b88a9042ec727c38c62ae297ccae778bb804fd47b4317f4a5dff5462f3a60dd43581b39910d97c79bab186774bcf409ce660af8c9a23d06d6c601183eafd8785e4ec1b4fadbaad208a182a07550bc836fee30c5a210d8bb95a352eb5d68d98305e5cdb4d8e27c9147ae67866e07aa373d0e07c63043ea87d2846cd2de258d79162f76b407e298e1e457d7559af0dad994516d8f5438630495c6ea5f887511a52c87cfd00b427a8b0f8e1aa213f00e21f1c7d02751114ae58f6ba5fea36653ff21f3db247dbf3c182bd9242db63df644032fca847f42779808ba70df01d2dd44d60c5700f187af9700ecb553574396b12da3c781e343266c420b3f7ad31d150e78d0f5c5c54128be2e528298e54bd8d367a034e03af2d90cf7536985cdb8af2b848fe53f43cd1e2a522a841d8ddf13ef19e354ea2396dd4c01de6594a5ecd17a93c8dc519d78313b6af1b58b7d745cb2933d940cd9fa2de12273269de4287c2b5c71c976571c6e2d3a7bd1708ed144d98a516b4500bdc0279391a1cb40918abe8b503cfe66a05c4a995351129148604dcce9cd85ef074868a31f9afa2305ca9516e06d1d8d1faaca0f96c15090cad75b808988eb07d5a205a70ad414b967ce00bc4c44a5142afd72c1b38dbf84d85efe63ea38af14638c183893580290398715bab052834e752930d03732bdbb13adf5934c96afbc27c7e81524382c57109a2539c3328c92e1f176b588271287a731227b6ac4504c5ce4736a188437e312d57f415e87ac944eb22a39a7a4d7b869b6128168685aea53ebf598c7a782195d5ea435210e09e81f146a5907b6e737a82fb9135b8ba675bc173fcd288ce216719c21c50a92fe0517a558e215ca2d817ab7832541ad037a374e21c9b0f1436a6f8af518357a23ea64e83177ca6561e4dc7fdc79e0d7ab692a8096322b13db83224ff3b7fd797244f9237aec19777044586dbef330dde49e2912ddf53d980d968d0f372bf0a1a31b10c82b76532b8b61f55e37fccf3153ca07ee2c87b8411825d935173fd30edd806c24aa2b0dfd5c8283bd594c4dc5a0e121c0b0201ba4753d6ff17648ebda84cc4747b38caf07b79ebdbf3c8a4f140a9874db36ae6f6a224c6208cd408a9545b77a26e8008d174b203c88c3bcd954b38f8e53179d28eecdbb806f46dc3d7d81af520b52b82b85d26afdadddea986b815d3f027012301add87e9bc06eb80a39a1efb57d880d7aae5caf9f1f12977b969946fa05c69ef9c7234c534c56119d502bd9c5f2fbf8486eee02b0b9e70eded95e0cf791d0f86638f8d1f448b488396bccda043905178bff2a4b675a229ff028ae1068945900221677c06bc479bfe84c23d831443e8884fe6f00d526a4ae7e814d981c83b6a6d4c7db87e7b4423f1f1e81ef4d2b419f3df733e3fd22f795ada8ce4853e5419f8c2aa2252936da32d7fab293555d5eaf8088b67534c1026439c618672897a4a20242cd8c3b4e11b7c97c27ed6bed0588aed16df4b3271d4f0611f3a4cf467462fe3e64a5bb41174d4cb3e8c4e90299e342b1d33897b02db9398ddc260c0cc5f4242513a010a44d0a85b5c08f5e03591c3466cabeefb81adab5c07fe511464c64d967414ba73c4f8f7829375132f1cc615b1356e70ec4db3fcd4d0a3d8402637f5cc2b70d49d2c864a1d2c3bb8179812915a229daf1b084ed2c751a3de365a680c83ccdeb976df030c2801c8e86a450d570cbe6ade45f25144e12b8820a528ad977b7a88ee81d748380daceef6d80f79e83a0e5a1193c59baff8c7080217ebd7f0acbb493e32d0d5ace79e810371542b403018ac2d648285e61fdd5370517367aaeeff4dc42a009672c927ca99bb709989c26fd96af283dbd0bdaf31f01608d628817ea52712b71d611dda7f97059feeaad8102f9190cc2f19e8d621f677bf1ae5643af4ee1cc86158347a9db5362a27c6c198ad907811c9236bad7910527f3a9f0affa5670a65a1e7a9585704987a55866a06cbbf8f10f9b09742215cb7a9d939c055cdc60e4744b52090a29018183995ee15762ab1866df4d0e60304e4d8ee02909fb621eb0be313606dbe4e7161e922eb3b1ee8459adf6ee1fa6d2d5c26a3b1f18e4f7b51fde08728f38378b6e662c925b1bd766c3d8a8b4e208622644fbb05b8d6447e2ce398c5d60cc0e492c2a2afb1d0db5f09a7634a8d327910ded0e0c85b8fdf9a0cc486d52656c8e8518f2c9acc976172347a56fd42ee5d819bba82242c7c76be21b427f05d8e4494ee33c234f2c9d7a5c1f7d724abae6450c293246b39c7df18642ec6506e5fdb70ba9347b933e550ca7317f40d840d0a5bd2603dcf4cac44483debca32cff31dc4ad0927f2d7f11129d8159a2b8853e9913b2ce105e44c7fbc5e59be5d2f6ed7c1137c7c3e70c3052c9d6604f7a8589b4c0a4980eb9d1d076708b21fec1dc9a2503de867b666006983770d1096ce589e3eaeac0745c7c2039203477f8d098f68253c08063597f7c6060dd32d04802ce620b9a7463948da9d0037484397c0bc1bb4a88c96fca306672a39fa3b3106a3c9839255d59e9483b34aeac9d9d56a05ccd4e4b9ff98ce6e16532046e85bb2373a3642d8130fb4f9b49c9a9be6302aac8ae1ce52ac05e28a8602b32720d7b5506e80e071a035131b6ea56c67e0dea97465b93007f53e25e5b980b7b543f8013ceccb7090d93fc57ceaa4f4f9906c096d271ddcdbeed0173d013532936c153d3166ce9986f16f9d2e9bda347b15876172ae2ca355a3a28307749e6c19573499b3ddbaf7eca5faab2b622865164d4ab852ec53a84f965295aa9c62145c5192d2c5d5a7008ab55670f293cc630e9ce5597a2641152f6b94f39b57c086678d2f1822c485491f0b28c5000b3266b0be9d9cda18e03cd1309b0566afd17ce39179587eb940b06ff0dcb9637fc121bc740f474d0ef7047be18466128658016e3093c88e6348c0e40a57910e26ecb7529abfa42a28b22d2d0d25845d52c66dc10e81244cf13c3cb4b2c8bc9b52518b079c04b417d53735ef5ed5bd61a987df2c5e10d2a34c8417de5a7c096e17ef5ec589f38eb6480f9674436eb20eda184be06117d3ce284f9b544f226874b62d4bbc311e2e046c4181921053f4424603a2bc1e1b1c39546608aaebf639d295a391193a5bf958c805e22daf65f04468d0207815ca36a483d60476df2d4a80d73f24397b823dcb7e7448f9ca1bd621d1b729f90a5297ffc69484810e51965d2ba487550d7f9ad104491cc53251d430d7dcad8da3ec15ace1547c9f48643220ff46d62f869d610b492f40c83e2ce73f49dbfa49a9421753ceb20838dbaf828691099a8b9324af1c5c7c04e99133c21c9bc116d05d4a8a25627f1da878bd02a393b9059e8c10e32b0c9677da86fa72feab4455fcfce08d11d113190798c1a362120c9280068d277ab3853aeb04e8cd1454fa3f913fa87b42b6a1cdc90e4fbcaf06a885093b810a36161b20e988c2234cf7544ce0d19602943d193a9a67a88e4cb90614318700f18792135cfc9665df8da667f80a9b1b1e63dc05707f21f740e48693916210963bacece9e4f62846238a87fa5c4b94936adcbe67f7c884d3b46a045e6236d55f5cacf7282a905c4d34674194f84cfd735644e3f0ff8149337f36be6266179ba9fde8bfbd4dea238c0e2966acc4c493d3662d1055d87fbc22862a3c4485133ad2fad35225123395393e1a21d7fc7bc284062a17e77221e2bc3196194f56854845a78bf9a8250f4b6425b97493d1772e0f7fab3da295b062ef0e4d42be964898cfbcbf597715f9bcd60a991c0f0878fa9c15f0f2e9e3b3ccc8e788de5597658190a1220d47947a71e07d33c28ec929b9d3f52ca6704b4fb509c3fd2afbcc3e424d00907cb910a1784128bfd0db0788455684c40d69295544fff1115d0d0a974075ba52f413cd9c395b99a45099db2f7dfb888d2e8df00b4ebf5ff4c88dcb02f337a3981e413db41dfd820278ab3513514fe71aee11887dab1e452ea990b308e1d9a08343c969c6f529a2ceaa3dd9dcdc5e1454cb4e0f3190004dcbac53e700ec10bc16cfa7af8f7218563987dbe96c7a8ffaacefb98b61b14daeaaef42168f7c2386131e74735863b9a9efe2c83e8045d0825f03c5b5fedd69b8b213b03a43de2b24f911870595ef770913519671ab218b683e1865c2854335067040cf6a100902ad5dcbf8ca97ee0f236299606984ecd2c00aa475601c2f0c80f18164becc8034bdd580a229965629b1d0dc0cdca6a32f50e816b078511140a3bda131cb06e00732fe9c6f4f7bb9c61b6472df73a4e6559a02a27464e3674baa921a56841196db22a151461e9c427e30269cd560e60c2b383426046d48e87a1e87351678c132b8d27af5b3d7ce533719e76a278555a75e34d0e6a18e187f24d20705702ba1338c74ce7c8e1b82643ca91435900cd479d4ac83b34149c2437dda2024ceaa025d2fc0c4657e7f3ef5eda414d22d853fcf016069308f63108f893515c6134d86ae25ebec151e4cf141bd2d46e60112dd6d92d0a8e2401e2b3e91cc96851ea4ae9839d58d293e0d8100d2053ff07f0f7e19fd9481a87b9810fbd8c5b3078883aa48e8a13d25cd04dc05718b771a2c8590b33693efd24b080590625b582244317cb56757d2a9bc3113c9b28a4ecc21218aea2b27f5aacff8b9878acbd961ac28fe2cb6c0f9dd3dc18c88406a0e7436578f96a24bde6b4864da09fcb91539b9a185803c19f06aae9571ab99f857cb5dbddbb922b6e55af3aed31c7f6452070bdc88c382388010e2f1e8f1af0466cbd408eae05616e051485116f61fd3356a0dd14e10096cc972de7d519a1439ab537541ae19d632530cd0d3afc1b9cf95d28a1de615ca07cc4f6c1c0174819faf466e2b8ec580d1df2dd6aad8f2d0910f06a7ff1f00446133758d1138f21f2757eb59426afbed92dbab8d4073f8f12f27b60669bec459f46200ef6eff4cffc7c9d27d483ae93b6a4bdd0a7388c1fb67e202c7e6c4f7fc3fd3e881287dd8d9fa5249431053b23c61b252ce9272c828a300cb55361c6d589dd7ea2f762e2dea2ca690431c2efe064240033be4694f845b48315403a641722093ada1aab4b76b51b2c6de85f31ceef91365e5431e34a3f8b9d4cabe4f588055532a0c50a151ebda40918f72d9ab97e94c8d47b6f4a73b84c450939c74007a15ae6ff25958fdcd2a3b38db9a2d0ec687ca6097a068d265b7aa32d72d21963dbd3a3da4d334804be552b2f25717c1fa211d857ac5f4bc7fe2b9a2e2432d385ca01042ad7eb436476be99c5a9a09dc2a33a2fca19d2f4690ef6dfccd5b54e33e00e03d8116c82a38769966e3f09f219c499855060d814713767f30350f2c23841b7232d9349d41f9dc98ef46591434c49666e12f5981cbd4e7e94c24daaf0d99406ac3bd821f08f8b4d30f8754c88bc44941dce68b29603086374e225f9e6dcea452a750533fb74a60abe0509e3ad6e8c695198e8429aa63f870901ef77e54df3f5d4c61b4699bd4050c2ed94062bda607cd66cdb5129cd9b4ed09e7beff63eec171bf67be7d3d83bca7c95a9ceed073927c6502a26359e007ec3da1aa630e19e4aeece370b463302a1884ae569171b09bc2e3346f269c4f12f67c4612fe45a6cb42e302493ba1c2056fe8cd898128d37c438911fa7e14ab3c24cea78ca3a184adabf12f04e300ceca3a5f2e5bfb4004c770ca3ac05480d3fd688c7e307eab89c0142298141487be8aa777fc03ddfdf2949e820fc223aa3603223669ce377ac3163ebebc80a35625acc992ef12b779f24c9d0ce6e409e6c8869f65ce67ddcf2a9c00c33bae667f6b4c2004a36b661491abc2e1e73417c6d17d4f3da56ef799db66df188726d23105c2b9bf1db94fd194ed051ed12cddf851b17e02125bfd21641ef33cdbbb40d79e1f536aa7a86177f7376666291dfaa5b58c2d581ea6f59d562c551b3e3fd0c58c9be86a5caf8301146c9f8863ea97e787ab08e65043d300dda54a6e4de23950fc69f69567844c2ba25f81f63573d405f42aca3eb375a0835c0cb7756668ee4488cdf347f919816f18992201ec4624afe22233f4967cd4d8d1b9ce6545976c006d35da8742b3d48ad625f174093597ae0e0069bfbe90c123c529f8fd03952471dbe33153ee8f73b5b65818153abfef0ab8f68ac1580a4f79d3cdfcee741bbd0257c773e364c5ce7fcb48b368d1b6a8210988cbd01b0083aa42d3471ac29687e1e71a1c7f75ac2464895656786e31719116a2f46aaba90105b772a9c913a7f285c66dd95f219b518ff5b4b86a9312ae716c1afaaf634ae7bba0b081a41864e4be223f030cdfe0c5d8d25567f9c03439e259040f9b2f7cca1dd146ea199e2f8b041120e68d38ac6bc9b81490c40b6f57347436103cf0121565a0750a41cb8b9003c54d8e1ef296a98522c59a210ed62c077c57c5c28047d428aec207d6893136cc35ba983b3b9e65cfd7989d9da7bd367e00fec8cfb6744e79b25eeea5cbf3abbebd32780bcdea8c53e700aeeaa2cfea183e94c6c92aaddbed83c066f547e34ec6b9e2927c145af73a24dabaa8fd35bc9f60c41d2ab168cf4edbba2082086916e88563e96f86d6ed201ba9571a12120b6079036a4350c306de5e1110514d1c0386b1fe70cd487f87d186b985e6924ad30d4a91b49273866024a1b4d85f0ee3c014528948b4b0f9d25588732b66ff26d110aedf193f1afb5276c8618b9c65537c9cc50c6be135495be27077bd15871db430d2fe3f3d2b449096f86324105882d0c49b6b62fb1cad0c87696134dd1e67613114e7e9583018342fe64bd127859f02b5390c49bbb0009c2d2fd60f1fa82a57447aaf9a0f4d5f62dccf5e27a10fdd57d291be33fe7bf71dd52bbd309568371a6fbf9f4aae137e82a71bd80158dbc27c61560d730aee3798de397173c71095a48bb8a2aa0c950c26c02cc58e26a31d1053a6cac150e52dae76310d5991cae687149524c3c252bb18a49399228fb0df2c22304ac61ad2841843fe5a2756951269044ef82736815ebb2660772006843acf76be1f363e56b9612ea4477fd19d48a3e670e0d496c7221bee594961cdc2e75e78604ff99d55f4c81db5859239abf55868da8b2c52d6b504685795c8ebd04e7e569c02d091db30f3e6c2cc901abf9a6dc2e32f4becf5ab3399515b2fabe84e6c3ec1d4d98309e676bbd0a991d8d3b9247aa6118b89a09ab5161c0c5ea3e209bc52e6f82d0aa2b8a4bb9a763665d7d70a02059ec786fec17e302a3c1e226d03ab2b758b6ac91f3ea9aa592011a3e153874c44b2ef8e9b3b397be2d43ec5905cae068e3b14ef1d951be190611923e31e431bf956ab5caaeb6f963b4b0514865fb15e6eeb498f2be6879e9763160317cbacf0e0b10d4e5cab11baa58ed1563188f2f900c659971adffc30b82119ba9a1560146882760cfb01404527cc489c9b1c74406d911ef8b830672d14a8f0118fde5131d3ab934074b5712652001ce130601fe65765f64e220441ae032c54b94497613d4151c843f360348fcb880cb8670578998ff112685f9c2350bb2af735ac60b47453fbfd0e8d911e9b844a6b351cdc0616dcbdd3fe993571bea2a5bb16cb1a2a7fdb14388d232f47bbcc30ecc71372f17d88b76b26c6e7a6e19a199021630bb66abda7397208b8b22caacfe8dd4bb029baa646e86d33bc5ec900a4d8d4f66fac091d090cf42320bc1744b902b4b06d8a0bc2005e3150122892105169545b633fc27465fc90a430045d3d11774ba26a4f059ec70c9749a7b1c87ef4aa122b81b2858acae300c52ecb54126cfc4012b31ac946b5b9d244e88c6ebb397680747db76eb8b92f834735e7e7eb48a75e0027680855a3e7cca562ab8f80f983fff2f8d0bcc46e31b034eee3c3bc298662de7002cb413e338543c0e762c1654200c83885ad5b3b212586e65f7949de901829d99b7e087c8a488472020e6fe8aca3cf94b52df660340d0ea1b9620a7c61a2d4273f064c0c049c712e9290c42f70e30702439668d20512bc88d8e9d148146e12cda53dabdc438e7c4d7d371125aaec80004a9f6ca5c2861dd1339df8350098fafb6afe77a3aad95c9e071414b35fa1293bf5aa90f01ddda5f8bf1ab3aa8be8e0ece4fda1ecc42c70f79c2a7aeb7597aa6e908f94ff4730e491044ce98aebbe10cbf765cd7e94a912727ee55caf57a8369465615af462d84b72563874a30342bcea1154b15143398193b06db0fd85f49d329de4f7fa90ff2b0972419e929c55ad0fedbbb35625290b848498e7c633b7715847454d915d47a228669ceb7833ecf5dccbf88552c6a339b050e2d611ba632947e22289faf6bd0cd5ffef3b09b44af14792c5ab4086d0494b8802d1a78d114a3ba19fe393f81dabdd28e63edf89488c3722e51758e511f26dceec604838671c14303154dfde81040fc1387741e1a5e79cbcb36b8de8408fd9e4691b725e0c1d425e556fd3f0f730b03265c96393005cba0598bc5cb308a06e0608e649358fc3b574b9d5847ae20aa282e33192f0ba0b04d4824ca042fdef290a95b94b0d28469b174345da8a4ca04735184fdc2c746c40c8f79470a1fc83f6c2b619fb60c8856a67440ab364853276b92ece423b3745cf805dc9645b8e2294148535c9fd9e6b7e7609dc75c3bba8d2521b5b51bad4e0fe28955a0413d4ca063b47651ed289aa1d564efffdb748b80a2bba5c185078c4b40cc09bc38ecf3d3d37d5194eaa71091abf3bc99e40bc30b670df431e85305eb2166478aced47ac723b503872d6c48cba81f7896da9dca6eac871b837cda77934ef59d7b1cf7c7b308843780581eaf97769628cccecdfe99f56126700b676300eef62e95affb80bf336867b60a936e7f8f75c5935f9e7ff0e9e95a3ab46ac836536bae836aa6b24603123f753cf34986e73d16abce536c4ab09e3be372d778c6f71852232351eed469912a4b4724bb915c75f9e2ce641ba85b3bda7cd6ea933a98dca68b226288b95c91709896d96437afc18aecc4238ad25e9088546561a6563387484658274ec416f9960d55ce76b1b5d751399810bf39cce1300a388c9f993d253eca91ba04e189783a2e63536561d41844f233cd5ee85b00041b23d90d04dba301ea3a52c836834f4b5c690f1f2e5813241ea2a135b31f750eafd0b4b37789a4ae3f1ae8e6c896230c3d72b21cd6fff011b3db564049fb9c3d160a20bc9368c356b1e82687b625e912247ff313399de0a10d5c2c222703918cd027f78a3f6dc1232e37f7240ed7a1c9eed6b68511a8106e9de964c7920bc1fe58112931babc267bbf92fa8522f101b7d4e666c095f0e1fa7b61acf30917f485b4601eca10ed2fc64e30858a875cf329237b178268a13b7e661c760cce868e65f7ff4d9190f0533b5f5e0ffac3552f7ca44bac75ecea2ca6c0e163826f74ab33e3c34040fbe81d581bec29bfdfaf1f43af4abface55a753eaac4455d9f9b6afc06033e06b5f3f5d8078c60838f443db1e9c0952b5c98a896b87d1cf7a39006835af44003be3c60a912af9e49f2fdbbe1a303e3117a53739224e4d147a9f3ff389a82867672e3db5a780cdd487aa176b2b6aa52d4046b7eab4fe6042ecc43ae5b7b24fb23efe5a2c1297235842f64376482df9bacfd9a69b808020016d014544ebfef10bdd5496e657bea3ff90229903d0fdf27422e4d6cb6b58b207cade697e33290369a44d048fd8be414e6b1dd2f49922f16c95c6d6917efcc8dd0eca2d1223cc13303d885eac887694f83a257cd3b5691101760875c6ad19467ced911b6f8b2417e019af50d8afabdc941b7d2c7185aba3fc8372eba171b92a1a45f87c0ac6c6dace722d8048d9c8568a8933a9a68939d097740e3f59ae770aa1d3fab1e216ea0d7ef41a50e215acecec828493557a965fbe11cd7f44f05fbd876e47da1d06a15d738f51c854a2036d6e1f3f9787aac7104c8268915814cdce5143f27a5af8a678f0e79ebdcd7d3b102d8de8006b1088bf58d95d34adb578169e5b580190a2257019d6832dde0911ebbcb3bf498a2d35560a2ea6dce9956a6ce57e7896a7af0b88d6ceb89f89263b5dc11f84eaaa6b7c4012e9fed726f4d7032a22157fbd8bdb558cc610f002d118fe7c9281f2567656197ce21f5ee5689bf553485760a0d9a7f6d51fedfcdcda4a0f272de3958b1f6b343b000d3966131cd0803020a922f6a3126e776e15fdf2993f65445bbb180a8203db4fc38df9b409d81bc8c153fc9dd5a803a552469ad44cd8e976c61ec1815d474e0fbfbaec357460ef4b5f905314e0818808d208e8c5a280d046051218557c0360ce312418a2a286c6af8f698742f9780ccd3550325894deb595d47f91b127cbfd81ca9a20621856d4c10fb3ceb398a4adf5d73ac0907efca3d997d6a5b805137a020f07a937968944cc404e705c9fc11c0c0a9132600bb868c4e355b49edd0292461c6f2f006271e294971111f6ada43e34cdecb6f46ec019f2ef0d04e1c6694cf5e0bbac347972016d523e54eb00edf3789b75fbf84f815ffb2a3f6d4f9a9b0dc701f024db01cc68b76cba74237b0a58fedd2a84e15c8f07d0045f389322b08c6301f396b707292b6cfabd00c53d884163ce372d6975ab650d98ee16e8031f5368dd1e58d5664fa945a5ca5c9b4fdd9b392c124a38fa9c823318b4ebae705c566b28d9bf00f2072ecc940a3a16ba141385dd336d8e0a926263b703e52938039b1564f056e464db42c775d3a9df73bd933ab3d37079284143dc31a18fab608fe8fc9b993930de60d82a41d26fdff99b70f0f77707945e5e6b804a277c266cf96d432ebd96a8cdc495b6c71d9fe3a22d8ada98f3e33522157899ffd0bf266936fdee508b24d1dc68493a457f7a61d2630d03f83e484b93ce9c402792d7160fad399728f86cc85578b8713b7d2b28428350169ccfa1231dd72f4740410b4b05badb34e9c9351f772c1c5b9daf4ef4287e54aac5d72915ed9cd5d624d5efeaf4657d49569448d10c1adbaa1cf641edb99f1e6f788b09c0d916fa6a574fd112ed980f711f746e7de04112137c85b4bbe97645aa00bae7b2104fc1c21518e153283aaa6876f00322ca2ef7ee2a136029d0c564c503db3ff90ab57abd40b30c87d094fb5c64783b2f5015156c741ded156118327b029003434496a55deb228cf2e192560d6d9092d3f83331bb5e2abc76af988b2f67b5908b1a76f13bafa9084106f31a4a5caac76c93874a5f06d955ca0bdd0d70e6810d33a4ed8ea609f471ec30286d99a25f8c18220e7a2378f5630222d5a47bfc6c5d5c36edf131f86cc2eb8ef6c9a6ced10cf7bac913f1b32109fc848fc00ed078b5d5a57b5bc8bb685ae6b4bd0278e0983a1b6f8ce0b1509feda8e6943975a875d66edd1822e63ee7613ce1d725042da60247348776a83c4fd8f266168b101f0338e85d30ada42dbeb0d9f2fc939d6c0fe43156cf8b716758e91adae36bd3faa7f905403e33311cb22d081db990bdd56f422a40abd1d12f8ef6d45e13a97d5252ffd37e6ba8bcc38b5307f34c301f802d5e92f7dc92cd1ae3cb36ff82f06809c56976b09c99a7d9dd3868650edfe307ac4fbbf2ee605088a0b3e9bb147d2e1d577bee2381962f97073c2479f727de453fdccb6f99ec77a04b2da9440e80652d4a97cb744f7b3f7d63fa796052085080273d6b72afecbdbae36452f8de5efd6c68ca2833eede44ed512b0c4e70e56c55ead97d7907f09283354c16b54ed64d1ab093eea3b6548a73b7cde3aa2aea103978f2c3e327252c0dc78256c8a0f1aba9d402395f99b57fa00792a86f892eaff19926a853ccd867767023a76a219be2e0bf1d30ccfbf9471e02e8ef95feb39bd4376599887093a4183751385e03aaafb98b033c1f923e65a4bc5318777448ec3dd0b68fe3889fb20cc921463605529a1c6711cbc1086b2985ccfde6a2f7cad3f6eb2fc3c6b5bc843e3c7bdb3ab3582e3682088bd8d4753e3705817f4e636c67867f332ab71c0ba770f5363d26434733cb31bf80ae8546d7483ec994fb3aa3dc9b1cf615fccc050e2319e785073e252a20a813d7d54c191f2710c3549afb77b522d650fdac63116cc71af68007e8bfd7aa0a12fb4b18704ea005013631a2ce751b466b54181049ba8495a30b20ae2f5f382d98bdf247b0c09a15d747d00e43fdc1305c56305bfe8791dd794c9b5c64001ba60178d24da7f0b023d8075d8fed4bbf66e70a4c45a5429f19417e451ff17ff5c0423b0afcc54290d65c8e56b86dfa1435e1551f47983e55f40b6dc5fcfcd087010f060a120633abdd283528601d9a4dd62a612cc3ce1cc278c594ebc342577d1cb5cbbf84365ac77e41d76dfe85dbe30ee80821bb4918b492388561903a515f8722d30479f2829faed5b8bd03181154a122b958ba1a8569eff2d83c1f6b3a3b2abacc68e5167be421ca5138e02ef51ed6fe3946f9a1654086fcae94366b84320c4a0578a8d1aa4d721ce17ee744b13f1303b60282c0d5d0f858980a873c25d1a5125360a3a15fab22f4305c17afd730b302bf2586bc8926d4cb35aa79e9a45e35f8d563e15d6f2ebd56929b8ca3658a1ae544e0341af4840888c110c836337fb972750731a2a87aba1424c0cd2fb48c0c13788139672d463fbe87b0086ec96d1cc28d345c9313f340ae5f5682f7bf42a5e7ed8211a64fee0081772741f500018e3aec6b15032a7237653a48c9bdaaa55696222418625eb09de07b5f976483d7932ed0a7040bc780254579887ae395cb28c5c6441ae06086b77400c6631325bd4a835622fa8af00745668e7eb461cbe4741b644cfe24e81af7ec72baa511aefd30c9ae7283c95b6da46e3cb35852a7e66f606c47e08ae4056c1608f59d5ff801dbbd47523ab3ddc980fb8671d26a6f2a585c9b2656a50f0729674c85aa5980bf5ea6b6549f3e653bbe73df024290d5eb582845415f030bd1ef039f5902ca855bcce374895557d680b520b886241832a915246ae1d569ff1a0d50069ab72ff451be267fde7d31027a07f40a0207cc464ac403bfe424a0035a221b36ebf5d821e7c31b4f503da1f87a45a20503a93744ab3ffba04675b5fb27b773c7deb31bcbfffd681e625fe77f9b72ae0c7f3cbb4635b0576badea4435ae00c987b4688fbe3b5d5e6db8b63b723b356885f0e3350414587d07bd230ffd7283b3642486b8490bdb7dc3b0f0aa20a200a761b29bdd636378573b566b8db5693b4dd367bb77b6aeba9b5f716086badb52dce15e67862e812712703a62f3bb2ebec93e4db123b73ddeddbb2adee6e97be7293dcbe9120db57ca8d3606de735adccc0b04d2e1ca9980299e013ffcf5cf74b5445b72df4a90b76c8d70d4ab5c0feef5d706b2d0366d72daae9082e5925aa157b24c7da155144c1554dd4e059a54378288c03175ec55da2a17200992d0210558584c42a06056ce26a488628b2f7ab0628115530794aaa45b5c2ed74e767d92c9ae5bd7c338915dc739d821bb1eba72d0457691dd2802c7e564aee706b50e4ae68e391c68c99c154c32678514b22e70192ac16598e936abf276bb59ad206f376012764f9439d9ee50c194edada5a28a6cb9d800886cb954d184b44949b956dbad2afaa369628bdcddd11a9c98b8d0dda760842021772c207bc034294078fbc4d52ce1c2e9c375d75a6bd75a47ee41c06550e638aebb52da1cc771b6fbc105358e0264eedc0b308568e6b8e30a34ad72f0306c016e611d33d9debb6ddbddb68d04307087376c9e6a2d095388668e05dd7279538cf99846ea67d77da291fa593f6d8bb3bb96ab4edce337c512d32883ebe7ad8ed8bd97470c4caeb7ceb4e5768da2caf61f0f4bd92af5a865c86497a854b174c82d51c975858721f214ed76c59b1dfeba1e1949b91aa439919b5fbe187725991b5b2be03ace4f748d221578dea3b3a996d93dbb486a6ee6e0f1038c1265d2625f2f5be798a726272c340b957a81dd87a7a0aaf7ceee29f2f8d1e4e7b95e6f5e61efb8adf5da4c4dd449935deecf97648b05207227570a5a2756a6a09cc09748939220f172fcf0461eaedf259be39cac3cb5e6d5017566633d918911ce6d449c9132559e7ab202d1a728998d5867e4ec070f32396648d9ccd8f3a24c56e4f1a3c9a9e50a1629d049ad116d92feb1af793d48d688af194cd38499f2cc4b9c195b70ec19830409142da8a33ed553a67ada54cf0581dde636b02b99dd88312036b71993d099cd95cc2c75525f6f23d2a7287a45a458a49a8489736633f3156bbe2365a24cf356b86fb4787327cc767ea8c99efe89f9a846fa75fbb6aedb1e7ea74716846328078f8edb3e6cab689bb49fab25ca82aca5e2cc6193964619ab31deac33d6dacd6ed65601b977dbbad218e5a47ae53a85eaedd2149a44b800df0652815eaf2faa40e0eb871089f9a0ad53d747955cdfe78a3d55fa792e158cb44e472a0be2d11505b1cf55760f8eb29709c0bfc6a0593d0f6b633eac91588f56eede650f74638924779f53dd186b8d46623e5a77dd351ab16f8d39ba91473e721da9cb474838776ff50e2041848843da00f52d31029384e9537a4d1c8d0e40a68f03ca18b9d6ebb4a06fc7a10a34a9aa6c2828573b85e96357a97feabd49408a84102962848424c9d2ddbe53ef66b76bb76dfb15adb5ae8fdebb6d55406e95b5d7d5319e78aeb7eeb9c43a85baabd31358d4dd850277b2f2b4be05f9f2a5e8aa75ead46abd75eaa4a97f68ada0dc6a1d2ab78ea3815ee70f66ebad2eb9a525b7e69cdbab0af8a1b679c612b809fc0ed2a70a144361348177ce680ad1dc3a6d0a6d6fbd45df9a44e4d68f6837818053c8ad4f4a5bc8add603b6193832c1ad6fa7f6a227769567db92b82adef466ead737cb4aad953a65f0873651f29bd75f8e26872a785fafcf8c4340311664e6e0c13109f899b1c8cc93e102acc3025cd2a6a6c64d9f1791da70c50f5941fd13f351eb18d464d3a80077540a1152a866a068a30431a3f1a1020d35f50fb21e8ca19044c90c5cda442e7bb5fbde4a471a64b0929992d9b977dd968d2ad0eb7d2443ba411a2d13f3c6a3138abea3fb769bef36ca6659023a678344afb11ef6dfbfb1dcc6f2e65ac11e759c932c810f9a6bcd43f58aae5391bbaed6fb3988e69512dd49b7a54c9e3e962f72379d927b894607dcbdec3c0bca00029736efe8dad454e29a5bd65dfe9aa495a7c4d6d22d3b54dd0dd4525dd3b7b7867d585feea360576f363535453d3945414559a956a10fdeac594ff70fc8b292f544ef66abed30056e79ded9d8bce5d9dca31f8fe8ba8dd8ba0d09eaa819dc51f3bd4becde12ef6dc49a3d192ec036c2116e45b89d717b1ac6c311633e8cdc1c87660c61670c218431f624009f232183241ac2ce78c4c8cd713ec11e37238f1f23884122cc1081bcc91d58911933c2e3e088a168d4a447bb10a70bc38ec210e27449e0038230066746f856c299310367627165468853e4881453d91ea945309808b823fc37713ee333c6ce0383bddb00833ac21369d2e2e08c43429cdbef6d61af600f32e38ca48ffb1f4ddad19a40f36162ac074ce7b02bc9dd3b204ddacf4cabbe34792336124dea9f588f9b9b31d6e3e6366e632c6fbeb992dc5d49b64fd23f311b5792a4fbf809dab8378ee3d87d8236461d36dbf850773fd2a4b5311ae9c6588fee37ef7e33d224a3262f4ed4159c915ae97e29d5edba0e233569439c3074b20a71ba29a2ac8e18ebae44e72d1530cd4326f8c1c6451887822a500c05113ec24718932899893006d1681e7f23d2ec553aa9adf7668cf5b8b9e66e2c4f90c7223b9ff1f0383b236dc2a37f766effa37f4278004ede864b00d0d2a4a558221dd3a47d00449ad5a43d2952324d5adb33b667ec8c0d8038730835efbc5edd48bb8c740bd592ed479106196ce3e3935cfcb3c0251902550823fdf2ee9d0ef08e0d2c766e29e1b0e8860234dce009abd61167162fde7e3838387406d949384e7797ac55218a2ef656a748ff748db1ec72781a6389f38ce78c6598f1a73dfebc59ea68546c2cc3bc7dc6588632c6708c31e2d0264c6f46da8446077c4f976c94206802b000a36936c2386126dcf1074c061018242b10a5aa5498260c7f92e45181cc1a9a53aa1eb0d191672bc2290a2115e1140cd24335eb19bb6a23d65c23965da619f1d5d12696d649b69789248802107d44502c6d2e7f647349662b56e5112ec298847a01c51759b311bed33faef14893629126ed3327de3ca7d0fce97a7aad4f69dbaedda1aa0243c3d02b3ba6265b2458581af353ce2bd26e39e431dcbdb6b5eb8b3b0712dd980f9ab9d37c37d0049a4b13e4cbd91eb0ac67cabe24b9db17e1c41c1ef095c400260529583c81c1141eccece9550552f243d5112d44a185113db460664fa9ec69d508ef41a1e71b88c2083d6392580c66228c1d1844848f302699352d6ac0341361e3ae92893f4ab3a2b8cfcc35dd265a952da56a1e7b2d00ba0054f59527664720415da9c47b40d653f6eeb5b382414f4f56acd8282b5050163f01c14a5353935314d4b6dd1b956525aa3e355050f35427ebd4d4e4a4c9e9d464561339856892126481554552121284318359d3d8c7b62c2569b7cdbe485003d122a28021d7ff00525f24844cae1f42040a2c403dabdfae95ca5585aa31b97e96371a85bb84084b430c3924cd6805a2afb5b6bc7ccaac9db7975e5b9bf0c89e20b99e72ad1db2a7c51db228d7ef0801c59c0fc9f53944728585455c22861dc9f59bd828d77313a4b507397c434c0953bdb020e38976f7c0a6082f2b5027616e88411058d00106503c71d1821337a8800b2a1d945511543be8720493cb115f3aeb8261890072ed62f61733819b0261bb2eb4e14f65645048bb508615da9067c2eeee6ea9dc61eeee6e580f72bd7d6106b97e27848225a38994276ce0ae8d71909b06a7dc33727777772100179a3a17b8c8f5234854f1132a7250eaeeee1fd1e2688149d702985c7f90a8e2ee6e285b7233e9804416a3a076805c5f83d21f6e6880446d97c2c801896a47b970218317ba404110494d2619166078c20b294fc060048de20913dddd1d0389da89116630d55eea217737513f21e28570290532064854c32834c029219730166820000b48e4fa1b90a886d6d2a21ba2a0ba78f1240a0f5ed05050250759acac7811846e0540c8fd1cdddde00bafa599a3088bc8f5b6d65a0f7b0cfd0f96a3020d0850a189157c38065ee045162b5ec0218c2c189627c00882a9063ff8a0821a8a90c16a9b351f2c67a74729891a51cb386e16418d49c207ac1fa210016556b378c112606811058917743f38fd8083559361393b3d379858d59482c87d1c9e94e12011580173851655a6249182596daa5d2541c1c41759ac301183d536676023e4b2e78901b090bb96020e72ff24132072ff255392431088585245941cbc585222d585d4d31129c8a204950f4d30c04075c10f96b3830350ee7738fc0712f50ca38b0fc4fc208b2b43acd0240593140e53dc204cd78393aca65a6badd5ab8a4d11e6f246184954844145eee33240e47e58862a772dc94aeeda1216881a06ebee0693fb89ac8eb984e50a860db922912b1836c8f51d0cd6ad040a72f77f0069218e92a9225718acaad659749583ab2b62f044071e84316b254d5e000686a92c35a617ccbae3213794a7dcafdcdddd5c80417022df20c30299266a78ef7421d7e7a8b5562f6ae4f283e5ecfc00085000c10b10b808c29686c1b6ada81ed787b5862a72adb5d65a5481c2795524cca9adc9049849c4172ac87ddb594ab9b35ec802f3832cb95b5652ab5a8b5e7872810829aa68d2a58a19c5171ff0b004102ab8a28bb2418818867d1f2c8b4cbf5c4b981739c8f5b6fa40885cbf6821d7d370065c7e399b0d153d3d90ca7d3b0686dc63aec8dd637e90db8b27727f3021a659471a3cc0d4558f23bb5e5daeb1b3ad7bd5f596eb74ba5ce770b85c2e976bbb61bd3d2cf90684e96e994242b94f67a040409aa76909ad421dcbb007aa43ee4f0a349b671ba1e4eebcb1ececddf56ddbb66df3ee126927c82d8f268ac125659a52327bbd799ae6f83ffc1073c0eb340ff23acd6b0cf23a1e93ccf163093dc0afbf6458f66a0278ef43bd899ed8e5b2fb912fbb4240b37d59969e9022ad7320d1566ba52e915673eb15246a8d48908c9cbca426a70d13ae583b6174b001d60a33a86a41c91530513dd02283d31420d1d6a2513ea8951df029135d324252bffe68c04dd626c7f2088e1adbb61f4140ae80680a57ba1f640babbcd1da265423b56edb369675fbdd7a0847501f8776caeadb36207b0487c7fd8a46b631d6839663cc077d774e077d7904470e01cdf7f67e13f1e7c214907e517f884783f1e64e921394a0440ba6663fd4df8fb1fa99adb83377e8f3e8cb82fa613f14b3c0de15bb2d60b6489ae17ed89f5d95272a58499ae17ed89fdddce9ad892d98f2e4b245d29827172dc0648a45c7f40f4d96165df29cca938b164d3c5005fcbdc5b938eedd6198f3de759c771ef0df49a215f45d877118fe244999b83279e68d456a6cb10a9794aab1d0775dc5a20a81cdaed188f7ba65ee87b69a2049d23f3449db4b9ad44a6368449ab5130566c2a2115be744db8d484dd2ae87eb662cac2ca82964c414ead3214c2077d71be8838d39342369a099b4d48432512a7a6555056ec1f51ec78d25d7ba87334d6b74bdebbaaeeb5a61b8c610d84c339646d908d7d2c1bd34ca5dcd3d9aaf9b2577ef4375a86bc4926644b219df1b699637ce88148b0538d6a37bebb33562980fb8073ff0c0892a2c1bb07070d44414323acce0839418aa3894a305bea1022eb178854bfaa5818c2a4fcec7645481a8939c5c5226ba04e36849993c2953cb11413c9102c512563049b2c4055b64a9814956155859de8ffed949012e8fe0c8add424eda426e7976c258acc0ecf850d38f10325b41802861e66945441104ca2bc50c40b5730359d9e767fa6a0fd0429161de3445e29536f07aacf8825ac25433431c288199d4530b95ada92458cd2135455db299926c7803a90603d21b2851039a8c28592115f66148b2d94709245032d537898d15326da546b1d3d1670be576080c5850b337871a5640a0b58c290b2c553992523b4c029090a082dbee8228b2c8690b2830d45389942033e583962064940c0016ad6ac88c1410ea0602dd130aba13378a0edc1c4beb2111bab6b1d0cae39cdeb9d80dc39a6107ecd873ac70f1e51b8e6dbcba9e53b900a84f30eb2324bdac06e70c63979be6f375d071b83e8bfbb680e8a35bf6289b4e59a2dd7dcc74c993265724dcdb82392307dfa3184c025094128cdd13fdd5b68470cfcf699a918033f31066e1e0bece92c3bd319faee2d5b4116021a3cc1c5871e3481458aaf20ca0a5654684ac185d7a988b465af836ee8f480eb5b2f914645d729d2cd1fd296bf771f984493aab2a8b0b65c4d654bb7d8534a29ed4ec5d63f716650f46a0be966ef44de18a377b5e838dec81ed3904df4aa6025557090020a2853c0c8c149069eac608c15174ec8b00395d2bdb30b9612b5aa3de53e9122b7c694fb48922c252d5159572577ac6bb24dd0458a2f5796dc404c17b30dc0c0862b1cae0cf10332b33e907ed1048d66984cd330163c4be3073816a4be63415e796cdb5086a4bb675869a1d4f4de2c315b95e7850cb9d576edb931ca9aa4f1d4596ca121062acf7922dbad5e9e9f546a8c1b52632a0a48cd0e9eea6c9edbbe793c0fdb81559e9fd77ef4b05cdfb77f37fba640a037e60e9a883a6bebf6166927c89746f3a5b1c5fd564b20838fc0f2edd74e9402973d993600b0e0f9997b499e5cb2b8ca36efdc389edd943c67934b1653795e663b6f3e6a9920e4eddd8932f146cf12bc4d9a275cdaaf82f59e9d7748ff6c5b1090a8d8fc8da11c0da403aa3cff234851ff4c2e3a60caf342883450cfe6b7fb9d17be3ce7fc6cc0cf654f9e2f3f20ae852b1ab2b40411032cb3f91c13e8485451c5240652448199cd1e9c324d54e3212b2375e6b8714e9f3b6358c1734c9ed50809c993b43e7f675698e6696a65ad2667b504eec2e4928aa161da8ac6122b2a2ddebcdd74ce39e79401ca10504b72ab895cda3c87e654d02da564edee0ff58f3d0fdb1dd6fe0ca9ba68c17095566bec66ddbf9d8e56f1bc994e46030a0d2834a0d0804203ca8e2f5b195f0d226a204103caa88535e22a895cca68185741787175c5ee80cbd5538fab262e5860f9f0bb753715b6c9930b1654d4da84c7dd0892054dd1a579e697054c01269c53960b16310837dbb596e6995dba2fcd33738917400598100c2ca288d0c136c1384f2e58cc20032c50d003def2e48205932c6fcc026c40a6c715581ce7da70c8821a084b850634e452a644832639797211e285b2cbad9e26e779b24f8ee5ce1ea55416d4e424e96bad43d5756b50e5999d659567c67cd0bc43459aedd7d53a779a9435a5b5f6745dcb7004b96a66b40e135c6b535ac592e6bad3e47cd7759dadb5d68aa7a05dedb5b6fb26b5948a0e69d20ee99fadd5b5baae6a86cb56da846911239008c810262bd7b7bd6d2803d30ca940db483a609b913a29604ab3ade2103bc721d367c8d4d4d4102b2b2bd790e9d3ffa7c50baf30edb66a73ee68b7bbd5ba6d9bb5f6de2b7e750b63481ebfe3c6f24848924ddeff50c1f53a3aaf44272f8a6d533edf31d6e31b4350b3119b974835b73e70c7f77a9ad53fdf68c4f51611b1a856d9395305b271fb6e42b32ad0ced84d1f31cd6acab2a123965f96f12b23e8097c0db1b4f634c412964b3126cef8f277f06198fe898133d6dc9e8ae99f1bd838d4243dcdede997fe298fc032a5727de676e61689e6edf8f6b40badf9a119f198e37e622796e11d79bc876bcc911d604c673f58ce4e4fdfdf18cb2341aef89303e6be03083716f546411f93d2e43429a4a8e8d2e0262d6d42844aa78576e04d1aead4247dd3bd5d8d4675c1e58d1b4d52da64de71e3eec5b5cebedbedbcd309a51f1555a24b31b8e089644c72a4480c2ce887080182b1ac284893f4f49b63792427df77509e7312c973489eb57f3449698b082f373ce5b23bcc8b94b227bf0225a10783d4db31097d1dc9ca336714d387368581142530cf9a53b8b4a4b49494b4d43f515134aa0a6ce9d3471ad50132dd981ac21c7f734e597812ff8edd86614aae85a55d694009ba1bd791b9e57279def7e1d7cc8ccdb4f9ba0fd380826b6a6c6c603b301cc2c21c8c135a2f46982303240a67cca09213fb6840c13916095c92346ad4d0d10189acfd6840a949a1739acc5fdd3e0b764de66d6b7d5ccb055e2b57f2f781e00c6867c0eba429d3d47c180c7332be35371f0c16230c6988f3c1627c37a06d327b212c0c439b1a9a30c4336118be42f00bc3adc5822082f87608f1c723c794f5ec3c84cd2ec612980a4b10546a108143cf8bc165ce26e747bb29f835396b9d9fb5d4de5717869dddb47677f7ad74f6151b4b3d51ceb477db38aeeb5a2d970baa7a56bca8ef03c1d70b86a7cf4c370312d9edc9a9c95a5fefd1d4d33469b20624c2d5c6067f57aac97ab3dc7c36e0c592257bb00f0724ba59ae54c601892e962663c4a031eebdc1c1891123bc09c3106653138634380cc399f00586611800d794b7a55623891a49c8ea4c0287b01a5d6840a991448d216840a951ab51abb6d65a6badb5de5befad327bb78dbb97c8d618a29efb38180c165ae1a89c9c9c5f85addaf4d5180273f7fac3f53586c0de576308fc7d3588c0f71fe880d88cac1507f1afc61076e6abd5d67a0f639a6a6bbdf7de7babad32c6f2c8f61993cae221cb4c9e4a2051864a65a15150ed0407a68a4312192be6ea567dd9b44cd12b39cfda0d562caddd1095696735d92ff48625a9ac2ae5cac909f25c620a4c8d8a0c6ca0f282fce559a3d243ad063254a0f2ac5171924b9b27952679d6a6909953c64c0133a58b9d2275a76c37344d71a2c9b3366589fb6a5059505879d6a0ac72696b5050e430cf1a9410301aa0a03a2dd4c6d410a31598d29e6938cf31a7490ed4a05ce559834226d34f1b5535295fa816a9b652ab014ca6b526c529975f4d8a934c47213cfaf10a879f75ee93394a2c1126ef5ca137783668c051793e0a4b9e2352e7397de82789a944a929fa20355002eaa66af832a6a30252ba564ec064fa1c20258f898616323dd9d325539c69cd8916faa1ae0b5c4e266a981468c9f34b9eb519b0629f711b6c61f9759bd75876ae49723d525fb4139439d9e693e69afbba02be805f2b20cd609579f2accd8025e378aa4032260f3d4fa67fba4f214d4a1a6b54c0948220086e1b48696db13c1213a78c16e058bd9f544949b3581d81d0a4cac373ff3aa2891a53d2ccc69b12c40bbe40a9008c258030bb2c60c186315598a042050e64bc8e252c837f084c70d724f81608c6eecd2b93865aa1a1699068f3f018eb813ff31d789c4d2ac9158b653dcd774f49ae489dbfb1ce4049a0b920cde8831b7193e0586d2ea3e636a7a00e9a6be6bcafe158763431468c33ce3c841830cd58761d8685c0047f4ddabc6bd2e6adf155c51a15b0cdb5b13905896a8e94a44805a24acd737f9be4fb224ef06952be35b022851a5ee8c205273398f5a830832f9cba5461e286d93d7dbaa751f72d18e0db94940b1b11160a81cb9c9cef903db21b41fde31a0ad23fdbab387dd4cf1c8b46ea18f341f3d7eb67c6580f9abf3e737c0aeaa0c1f8433d23f6b1d876e6af6fa257bfa6c118d388e5093206c1bf5e9f20fe508333afcfbc8aafcf88140bc6af20d1ab7ee6d7ebb582782c9564fc2ad22c4395c665f043fd1241907ac760fdeb9c5829091c07d217501238cef57a6571bd461a975d2772b95e5bf73abb6366ee9d18e3c6b961dd74c8e4cd9df276f3de76afeb9b7718ce57dcee719b7dee80cc0035e9d014b25f02949815ddfbe7ee02291ae25123a9fb761c420c78a87a9ffad44360825d6379bfcd30991b91ec54adb90ae5fa89492817384855cd4ef02d3d6932fbc1e6c953cfc58bacd6cf295660040da4401903840c23f04107563db470d504c6acfea415a964e0d5f7bd65978dd4074d9f5249e6ca9b6caf1ded0df8f915685251950295312da0c286250090c1d50aa078e182168098d1e3b07798c1c90c4d36f084980f5107980768848ef7620e7039af8a5420b256b22683965cce2b19a442b20285610da22983678d894c9eb948ffcc1ad3985c7fc40889a9027560f2d42fa14c1568ce3ab048d7cda922d3a75e817d1ce099f3f62adb68d43cb59e16d969e14acb0a6f7636c7eee8faccb1589d759c97fd0638d33f2f20b273ca6070c7ce8c082ee1e143e76a754e3c64413f0cf19005c98678c882b6246feed05cfe42b5d2fe657dcb079dac26f474f73b84b33ba1882396622802891d986604a042854a0f3188c1072b742e9fbd25fc5c5ed6fd026ca7a579c00f9e644127ef15256ecae03baff35a6bed3ae79cf3675a5b6bbd73ce39afddb61db69b67e459336d053aed364bbbabb865da5b757d77ca4ebd15625b7b1bb26d43b6be5adc7befadb50a513b7dc01b1af7f6bdf75ed009a6f3364d30c52156fb5b6bad5df7dbd97bfb2adedbfaed2e90a8b620dece556f5d1faa9d4bdcd1e2516badf3f57616d75a69576badf54585cd0117154122640891234648fdc39dc89b07e7fc3d0c4ff0f7fb3ed4f3fb7e345087675ee1f5c0eff3433978cc2d4848f3f4f118ce8cf515860157182264c6e8819021449aec1c1dec4cb27b50052a0aca5d51befda256f5c61d2163697397240b299aa11d144da188524aaddd8aeeadba55b7ca9e6ef5b4563bab72510d2a55f7ca7de2cd1d6efbd140970db9b8d6ed64142a4936452b8869bd334c6c8f7b7b398ecbb9212ccb9528fa74cf7db3a901752819471ddceb537dba63c580f87aeb0bf4b1f5b815048938cb6df8c6d2a416d7ea6aadadee0512d1271868d48ce103a890c9e54d9e7e971405fad84a90eb39b152a826fba94920300e676b53ebb9403ac3c48f9e730b992b966de7acf09437760a5d69cc9b2c2b4e9f7b2fd0cc8dee7c8dc1e5b4ea466bedb66d4446491d1848bd036b14ba7cd4bc196dae116b48abb3482c9211938d3281fd49c9c054c40e987a608169862f3896672d862f6e139691672d061b3881c33c6b311ca144c76dadba75371513835ccaac609a3c6b31f050abc05f9eb518a434144c23cf5a0c4975053c23cf1a0c57c060b5f5961c53a8f0160ccbb30643975e826df2acc11044aba736281e18110504236c4002877972d1522697b26ca1681113801c1568476d69091fb276884107b3ee8b69016f56201f5b728021054b5d30518317282a4b7c6003272c24b266f406b3c90f0a5cc23c58ffd86a75f20794c47cf447249aafedd1a7af53b4d6c3973c6b3e5c4922cf5a0f6172b5619872b5e24aae2352cfbcb24eaee7428073bd154310e6fae953bf893d7deaad58bb043be21a57b8669a699d425640c92008335298bb3af164d88071ccee89e2508b62ca659eb528151a878b1aa3cada00e2ba7cd8b6295c4d0aba970aad2a4b5c3479d6a86051af46c5aa46050a4a25890fb4553c3a858e68ff78dad13f5e3ca2e97ce7b4239defdcc6e7eb143aa2d538004e3baa71003c84cfdb297444a371f2b4231a271f80235ace4538ed28e7229ce7f3db143aa2c5de73da51ec3d1f41e88836e30238ed68c605709f1fd1645c76da918ccb4ec2112d3c014e3b0a4f800fe0f3ae2974448bf11ba71dc5f88d17e08886f39fd38e70fe73037cfe9b4247b49b079d7674f3a0037d1e9c424734d8854e3b825de807f8fc6b0a1dd16c8ee3b4239be378099f9f994247b49a27e0b4a39a27e00838a2d17ce8b4239a0f5d019fa799424734fcd96947f8b3e7cfd74ca123dacc739c7634f31c5fc0e76da6d011ed751da71dbdaee3449f874da1231a781ea71d81e7f11d9fbf994247b4ef0c38ede83b03dee3f33853e888e6fdc76947de7fdcc7e7634ca1239aeb0d38edc8f506dc841fd15a0772da51eb407ec2e7654ca1235af7079c76d4fd0177c0e7674ca1231af720a71d710f72087c3e36858e68db5138ed683b0a8fc011edbee8b4a3fba24be0f334a6d011cd9e02a71dd953e013f87c8d297444ab1772da51bd9057e0f33a53e888d6bfc06947fd0bdc023fa20d39064efbf4a13f1a3262601cfa05aac8f4165040a61762834c5f8104647a0a5091e92780804c5f0426d34b008529327d0444fa2052647a080865fa074491e91d20cee903449cd3e704714e9f06d09b0094e97f3c91e97dfc647a06d420d3f7e0b1e346a6d7211289f4399ac8f40b2040a69f79c9f4599cd367489cd34701e29c3e0910e7f44180488f63894c5f820032bdd0017c327d10d04f1299de0022fd8d5aa62f8008999e005c32fd0064240800894cef13804cdf7344a61f0100995e049e10323da9c50700f421d8c8f43b44647a1b62a61fe710d3e7229d3ef43a624f1ffa1a62cd11afb8715dcbe57de06b06d34c1ffa19b166fad0bf441bd80d4e8ce943df12c3e943df8932664c9fe9437f452bd2983ef455ac21ea4c1f7a28a54c33dd614c9e79e61a9493dcb973833efa02f46be2d2dddddd3de79c5de5388edb21a6567a45adc4e45a7fc408a9a9e64e593faa04befc720be07b8a1e741d6c2d5bbacc0cbeab1a4cff7807e937fb135b4b6fe92eb3d56ab5887a6aa9aae3ba5b4c77a9ca758a460ab89c6188143952af789db5d6d2aa0a54fb4ab64b5388debb7da36002f595ca6367e7f024db96a165b1466f9c4acaa57d966b2c43acd658954b6bd55995dbeebd2502577d69b2de99a5f2d40ff5044f78bef64bfdeca64afb25d7d3714e9f69adfd62ab3a2c2a6a4e57d49ca6f05273dae29425aae6d454736a42664c2d4a985a94286a51b664a94561412d4a542d8a532d4a935a14156449c878fc900529920d2142b7a05ab0b0820bb97e27accfa92d7c27accfa930cbd570bf6eb21b5d477f710c9548769e604f7784228f26eb06c6deb39f59d9ce185e70fdd20c635d5951aa2d5359a6a22a122533cbd43fddc489530359289ca54ef58f9629b4193185b823a65087c4146a6da125b86e6f6bb4842e53488929e42d3185bedb5b2666095ea6501353c88959420da650671bc68ab1632c19a5264e9ca0ac34d09cc222a5a58170972f40732a4c37b3bf631a885e32499bd2a4504c9f3b7d9ea04e4c126a307dbc4c9f26a6cf9d3e779c1b930f644486c8643259922448928c414af283870c895325ba242b0ad24446b674e9928c089121448410b10246f6e3078f1f3272fc68720ac271a7961f7348565414a4480748d1a54d930ac710d51145f7b449363484636828482633323a627455c4c8a8c90a6bab546eddd525df6fd605db8212fd73d4c79f97a123f46face25f356c3e479b9b75c423a42e7ff774eec5e0826bb45337d95a6bfd69b4cc0e3cb6a6cff66f6c29d3c769fad85feca6cf3696481634e17e0377883f3eb19dbeb6d99b5ef7c9103b7f823f94647c7ccfdbfae26d7c0a793903ed7c3ee70d64e3f3a4982699a4e81652540bcc24b58482a51c92bab0d0e5298bea8a5d21db7752172aa56c9b78a2e54a134fa4a038651a79d69e30653119f67a2f29209371eec5494c2e69972fb48b53125550159e5e52002697b4cbcc3a4465f122531d9eb072173a26dbb796fef11aa867d3cb0d566272d93a9f9d425db65308fcd8de280ab180ef4171267b3c1f91fee9c62151508ffa932542e4eb21449cc0082132038712165fe2631fb026ef06f6d81e033ce1fbbdd1247e8bb226f171de5262d824feee0d68c23d6592ea602051959923864d5e2ce913d2cd971665f1140b966f232d161b2bb6a5a6b6e0b2a57678b945448605cda0f321e3ffc7b2c7d8cc56e778ac62e3a0e8e551dc720d78c2df3d6ec7523ae21123f1c7624b8127f4bf6f07fe168a43389ad419ed0b34e11e499377c436c483205195f04baeb48bceed6ca9fef9c6b0c96b646431fe112c1a45c1db8b6ca3d136b3ced859a64f2da9956c2f8a47c82cfd53ce30d90a098212f40453f1134b9cbf57b16ca73ec6f8b4a949ea843fc389bdff61e37fbf35964896fcf184b7eb7c823b726ce38f26efefc5b62bc5b611c8ce9918d9f89ced8c366cd459e7f6c297559e2a07a8e159833295bf67513249fdd38469feb6d32fb48b584e2df95e148d6cdf460ac62ae8064c6f5ec7effbbe1d5d168fc5be7143e7dff7fd13ff7ddf659f7863474f93f7188f379abc5967a4a25f6815182b1ce026a7201c32bebd0c2243731962499b943db0571fb0d7714714b93c779acc01fb36de984396489336c6ebb86ddbb66de261e00efa7d4343dfff770db4f3ffb006b2f1ff382e0e49c1f8323ec11d414dde8b781c6ab20b15fd52d5d4ca3ee80a5cb65456974fe4f143670bcdea9fed4a53e89b29c15cdff8f61e162f756aa039c362cd58ec2cd2dc4f4efd33f3377ed3a7de8648411d9db79aeb88256d520681b9a45938077de0bc8e64ec8bc105c7b67bafd2152c9b28defbc43aa7cfc5dfc4f2feef8b6597c7f79387f38d4edf2656f1303812e6fb1df084ced23fe2c55370c77ded2bdebdd23f226562da9872969864803bba3cde9bf151504797c7539066423d3e0589c6b1a1b29e9cbcfc9321d64cc51645254a068f34abc68704c986d42492bbc3a8497bdb52624f35b9a3cb266435d94f4d8addd44d5769fad837d4f4b1b76f1981fb654b65fb96ea1ff1f63de5e5dcdc633b890d65dfa08e8a459b1bd4d10dead0f93eb19d2809f900f864ccdc47365f5bfb04198f557676ecedbf8b62151bb7d1024d9894e64d0679acc786f36d549281543bda8865976dbe89a53d3ef9e384eb697c823b9204a29fa8a44cb7b4452d11aa19110000000100d314000028100c8784629148249c49cae63b14800c84a644704c17cbc33408520a21630c0184100000080c00c8d09044a000d6bf030402a58e195c7da1c4f43152830628e54cef531fb7fc21330d12feaeae71875e0a4b8464fabd5d907de4549cfb2cb98acbd3a124460183c8540ceac72508b33056831d2a4177bdfe425b5a812fe237623b71fa4872482729eeb80109eab87e3a601f9b2243165040c603f575a3e38d47a388a85ca0f171f881c65d16af58088711c4953873ed1811c33fe8a25501ace8032a09585991212ca2cf96a85df75acae899a1022796180a07d1e472f19057a6c5067ea4f476175d3ef075cd05afa09bec656609c3d1552b8e7fe81e7343594381134fce0655200302f2b327de0090615b0d8851527b7c7faa46023fb18af5737adca6d46d344705195280740845e2b09a4406f4130da8253f584b72884ed2d0aa0427d60e1bfdf27b479c9bf84c834d41dfed57de0da1606417ab9597bbdd263bafc76380ffe81244d43e229a0befd74028f31f9a955e10267fec7e669717f5270a0634fa463b2726f50fd237a2eb1bc08b9f0bd25ec5b6a1035fd29f6637cd70a2650eb09b2d9061f3d4c7eebbc1e8fac00415c1006383fa2e202f32b994668a5de2a532224a44df2485a7e865a1f5b73bb54714970eb86208f3de63a892d6a98d7c8c14367dac385bd32495f524b7b76bc07639d622e009b3850c9e938af678af035ab69466e3a5e1db789e38875d1a1b7c5ca5293f88139eddbaa7ab855c7c32eb8aea7a2076a17d9f7381fd1bcd010d365549b70956b77a7a36fc6dbe978e82ec9975c2f909757f9722314325197f68faebe5d8d5fe38f9a8a062b8293c707fe321ae13b3faea0afe140cae53707286e096abf05ff4c2fc2778006bd3de56288e30a7516176106e6711489d38113861812dd76418d229f8270bb995a51f2e603bb9bb80c95bea80a53a1be65371f73c8f9e8585d972a8c65904c0dc2ec6fd8bce86730c23e089138071315b6e060390cbbe4090ec6080a60aa8a94b870b91821a59afd3f0ae03fbe2677298164e77680b11919ea5618544308a345745f7a6a8c00c8d37be915800ee8732f7be871307e61907db2f11981dc6f96c5282f6e0549446bbc181347ae1f8894c1974d65b8acef52e18dbb2de14c9aba543b582d21bd17bb83e1657db87aa5e70742a859a2fac2f2b8fd22197272f0473dbcfda31a15cf87266a45f5e735177f36712463c640c4838548bbb5234db0ab2ad63e5a3ee2550a327c3405e5bf7db81020eb56dee712def3d4dc3a0c7dbefa3a8f2befa3bc7d3766f72bf91c6e0d29452249597a4162182f0657c7db6e99e1bd1c2ff58c769eb558f507f190f56effd567472f53411b5e3ae71c3eb0aa01f696a78f33b202159e2bbe71ead3854b87db9bad7206ce43877c6b7acb747c48d06a49a6365a50dba454b9409a5918530346b665f735b54ec43a305b470aec8ab6b3a37f3deaa0a1f1ea2ca6cdeb3534effe8658b64f8c0bdb1a944c295a4e3f6f6941222b1515a1538c90739a73b15f29070245455e0e916bfa6eb24c28a08a1840b0b6367efbc3ea17cd057b7010d6007eed6c5d183be8822071443ba0af45b109928013224e2b8efb9c6585f4ac3521e44bf91bb8419a60f1abdeba9e1e934557d03ab767b2d8781c2148990277ac1b34d633c1329c1c8ceb7c36026267b2fd3811b65128c466791b2dea3d8ac9be8c9f40ac1d3a174c8262aeca5ab4633a584d8be8b618326e8a2e52028b3c1c1d2f41acc8b15c1cb9fb6a94afde79ab26075beeef81d9a2a4d5608f070c829df7687129a0a556c3aa47b65aa20b83c2e72f32a5c01945c6904b89fb7c58911339ce4d1084bf63cf8f2208cba6df2e465b226a282272dcd3f035fc39474e6e256531c43898b095d831f9aa0ffac538afdf4500f01de3f28670df5a95578dadf96a7f21887be6911ab0497548d9a246c04c4e0879c8e31e592c866d7189fd83ab799a6467f07da77353dde029082c05a51ab584804e7c4e446020a250575b3fcb319dad134277528323c7d3580b0a715d8a3f36abc36049759272f391bfef9c068ef9f7b95b194ad7159e6311a34fe12a11a2c1ee8b709c9e8d60fe68d1f43f809c3346894901560caf30f9730847048f3b1ebc28141f3b7a3d3d4e7cef5d1eb3f4e6179518ecfaee1c2ea1268cd142841f4279f94781849c260477b71766055114982b3b3aa226bd75acfd5ff663683e899e92c777f9f4277edc226ae7648c3a47193543984757ccd0991da652be7642790d7a87ab1a83be091c2be03ec5bb901d3d5241db9b79dc7603e8492fd273b9a45243a7a1cc49a406b463f6b4ad712a5d9143b3c71b37e3282c2ed92f56fe6714f887935b1aee42b506827ac07efa74f75e4c2351a8c915e87f419dab18ee1464e186346c19a183bc70847828d865f8df50a0ebfe6d5897bcaba1a6e2f55b4c66219beb494c4170cf2bea1ac6d9df5d09be37430376b3c8e6d59a397d3f655e8ef2546f6dd481b5bcf385e78fc6f6d4807f2f07dff19043e2ae50cf5c64b93eaa20cf9fcec09776ecda8592468908130aed370e2e966b8cedf6f914be39d8077fa057fca04efab9829ae4f535178a9628c0d5440bd8321d354cda14b0ad774622b32ab7b5ab79e47a13f7c804686c34659a6519d55fb1da1f634d2e2e88aa4070a049936fb3b9eca157c4bd587698a0a8f0f73bd097c30bb3a2663a0579aa600d8c05dbc6fe8abbac4bc2e070f1c348860fbb9da8952e60609ff970ebcefaa4db84131c5dc26a08f288f81f902525e8de6f347968c95138e119db87226e3df0c248864168f4cf8d4dd8e2e52816fa279a7a5034a6b49ea2081e340a22470fc9cdace4e13badda34e04a5eec1c743a91428078201f27f037315317b6289cc3c0db0b57df5c17ad99f33023368d8dd5aa6050ea5f8e1aa63927898195993520ebc3751c76d796ae1e7cddda99f39ab08961983fa1143a8008bfc38b4a0b4f3d7408b90c40adc0b023f1de3d8073a687c2f4146dd995e75f1e3407703e86ef3542b4f087abadd21be3e235b75cdb956de3e24917a23fe3d70808cdd1cd6ae0931b02552b0a6dac7ba7cc6e932d9c74172fbd4291678793423a49e1cef11618c9f09e070187c7bee08514794559d3c4c698accfe08454a52b1f1518773adf6a82c3c025293ef0554a1079251bf1415c0036efe0b2c90dc24405fa64388b9112d6c6777de3fadb9e22141c10350c1e63046215420d07e7591144903c91800eb0b51ff489265532d391dfeebf6388ecf2f6e917d7ea58e53cb01a668d4e8d06fcc092d36b3d4fb150dd46c6ec17603b6be3b5125e1596e809685c4258940dea03a3357f6018e4f2188282fe02bcf2b037a437e16b1729de2e5cdd1785f804b00e3ad4f807812a04322c6aa3b9f84101511af9f79a320569bd7b0e42360fa49e5bdc190f75c1e3a36caf5a5b66bc98f78f7e59724f6a51f0fd2d50088900cd163f8048109d555ed13ce774977f66d0823ebc8518c6a8ec50e3290936620be361595a11210b28ea5fa20800a5f0533fe11b45862750e7e735890c70a2a34dcaaf22eedf97e77b05f06f8d883bcf4c70a657da02e714a80a994c9ae1aabbab340b188f177159b51e8a0338807b7a9b08e9113fdade5d8b29ec301b1cb8ba7a5b1151dc7d318d40d056aeaf821715175e6cb566124a2841ba2bb63af663a26eb34f7fcb38b7651790b6ca41cc7161be0c68adf84f285f2fd073edc1b7f5d1d9a4a6eef1ab021895ccd7d568807cec79fbc30b92560746e748e1d170a4ecd276595b9e7537a3c1dc3513a6df96fd6e7b5397d02bca6ff86eb990850908513f72b294423322a650f3cdb7ced7d83104636cec852efc494754939d23f534800992f3572ed3862a27673af021eeec4e0507ace41c1b3b1d3970e4d7dd6a05e929ce82bba8d05e236247e410acb35012eb83ba080e830643b477f3ae609f0c0304eff781084b40967da7900175ccbb4ccfad3a1d24b588b85cde9f50942a4804417836d5f8320371581eec23515348e7dd9c8e5253485b5461e9cecfdf8c036871eb88ec79b5fea49b31134db67664635427cb6b18eaa5043ca19d02878f03a88e3af809c0398c8d5b44e75571a5a4a112c084c8e062d6333637dedcff3dc0c25cda5b72c16cc9b6220ab3b8d8647ce57f20b536f2c44703d1b3b854347591b8ed52683f95ac4977ca804e158be4d518642a56bb47e4f2b1f9cf048762b431798e6c7dec2e718ed145fa864c809bd23137c698a4c6e691b3d351444268841650c4202bb9bf81092cd581b42983392daa854cb724ba2cfb36c1bb865316aadb2f53de122bb2dedbc848e8a305cd3429b12a649c3833e8eafb0a8864485ea8386c0be5d9a0263b21a8fb36617d5976d0c8894470156d2d6da1860d58ecbbc17b90456a24da1f126006bbd103d9eebe9d1be274ab17110f0b74125000452371ec8d0403de77451c120bfc468f9d5c6a5efe3fdd8e526239d6b1e5e1833089e462cfa99afdb237e07105641a23a59b30f2045682bef886c956c00f49a131738007635bf1933142a85cfa31bff75f11b188a70f20197f9658a5979d3c8612bf0170a5021643050c8a2a4a996ac19d1441e8353047aaad4cba6c82d1a88b5599a5b1690773a4f6b11f245c2e5b6b9f61ec79d32813cee41105992edadb29927b689c34f7d60b38efbb9b742e934c07795a00bce78179323d007143ccbdf8f9a207156c954c9487e8d2f6cf306e3719341b1cf80577a212f15a4a50364ba613d77cc0ccb8d6813f92c4cc036a11414b13505188682f300e913d61e410246421a433299332cdc4122f483d9571563f6142d072288365f45267cc9dd18ebcb04852c0a84e60a046b183174eaf687b97543675b706f5111b504cdb26e290857951021532908dad8c915f46f344b1cde85bf46500d0cabaad05a30ebada4a540635029dc5114adfd6142e8db3bedf0837191ca28d2430db808c140f013e1693350ad1a2e636bd738e5cd1029772147e952ef0f47f05e3585307dc2ccad0264eb64f5928c69796548994dd5da81c504de1561571ea2a7b52f5a3a8a5974d72720ff5b7c630d6d9c3cd5fa00965042e21e332037cc4404b7439eae2000903680bc62a0097133159faab858544d1996d4d6e13412002b8009be3c242851b8db89cae20110cf1581f227d1820920446994eda98848f52c3d11569b951b0e881fd3da646aeb2d9b98a5f9ecc59ecc4db1b54b9fcbf1a20c76fc735d32a50d16e580a68c9a81f51c9aadcebd4ec363f5e80f782c31184a1ca7bf4cbb18b3d705b1f5684ac3d3e4374059094facb23dfb86345dff029fa8e650f83e08b7a23595fb7de7d228d1c3228f8802bb44b7dcb0dbd71948af8c4bde1c38a8082e01951ec235447a7cb1100d78b44470f0b7a2ad97b134b3f3e4d30b12251c9120c0054caedacd651ea5f80180831294a82457ae1a435f764bc020183c0c3957af06ca1187af5c9d08afc9b65e11d3c023115e24a1cc36977f7510d09a3525ac62daef941ee861699990bb5c015676f65e02b307104cfc0307b67da4e03a05accba961b1ab3bbc0bacbedb9e9e0593946b7559190585f54f294c49a815fb5567202ff14903c29b2062166a10f0e6002222dcdcf2a0fdc2ca295d21a016503571b79d26b06b66ee0b33197dab0f6d1f4ba1513c3bdc4267b554d3d823558b89b00409dd242d52af1c484e8588decf65156ce5a98a12bc7c88a7a7b32da3c44b6ea69200527e6aa7a246401f5b9ece5349f9b5c6e6a6d13fdd68cb3c98218de6a6343e7dc09e530cbe3d8126d190221aca0e438fce3454f9f8ad602c3cb17a776cecc90b9e4c841321ebcdcb4e555ab918d1cbd9026716aeb023dafd4732f1b54d410affe5aa52a9f124cb7085dece917675721b61d6be446fd73d6525df5039a8bd3c4b8d67c998ecd83e541e30836fb808f58257fcfbc8b1382d9bd8e805cf5acdab5b0fb317a11c19ccbde398dcea9c5d5494dc2d198c3d02fd2aaa4ff38af56be944bb01ccbec7dfa66d251833750e3f9eaac12ef5b6e20265ed5c788c7c2ac32d3db1cdbb3b09f8f81a7a0543b438bec2bd1ecdce3a427156f0c955864c36d0978457583c65d7be55ce412d30999cf1f868d9ac208ca919d4a55fb08110e5ae0b7597db9c684459249c28b10776b41a27a6b5c364825d7c65a827908bb491224335a295040036d3514c43f10d331ba1349a77c70723c25994579c39060d18a14183445d36d8ba0f74789aa75bf0ab153947341af4599291b5ec53305dbb82f0e49ff40f13b35f8e47679829ab536ebd38ddb73d58b0ec260e59bc1f3c5163702206a543e163b3454ac67c513148b7ac59cfa04fd51b0e7507d41b00b81231ce8ecdb1ca8a5d434c272989119a8397d674b3503efbe848bc4a550560715526b65c269b4eb30f70b9760652c7d934db6d72697f940fc65f8a6573f6017ac7c18f6b4255de837ac70a58b9ac1a71f23bcc688c3adf7b097f717f37039b0d85f409e3fa0cdb3e52ca4437a799237b1e828f73414e64c4171b5281a31e113141f830e3c0f35a052c4a1a0ffc236929f5507e80b892a285a80a7f45ed53a201af41b1e1939a8353c1bb16b8a4046ca5d1fc311d6799736feb8208e95bc00537fe009048259e248208f580131fdaa825949a3108494b8c5384b20b8df65126b604ecc1768349d1347678d09979c4ad1ec9eeaf8b0bfa2827f12f4964944d3629d50a9a921852d1f9241800dd1847f746fbaab55e3c3465171c93a50ee49688c3d6846fc7c87fdad3099707653bf792848e2e6415c860b2b0239931720792d479e470b306b2077140bf13cf8d4a31f7aeb223e14325e894bfc10eecf935327dae635b067a038f4c1f091c16901a072c0268b444c561543593eb992d50ea24f6a9c2d5b2eec9440bdb93feadbf2e082a58b86935ea62bb27ec6039cc293e88355a024a055c29083ddebbe273ddd9a6b6bdea47da30fb63a1fe7270eb75ab10f2d9f7c27d69e9f6bb28318757f3e74c49d8e0ed675f36357873f3046fdf3f2f0ccaef83a6966e460038b8a0a32dac213a25286fbcf5049f7c577eca2b1d9072556652c54d2aed8b4711703f20762c2e36f3a20a975e580542cd4346985a61063bab06ad4bade8530bad01cce45cd4d1aeac9eaa86eed8423687802411d53b755360046208b9b076c9a285bb434ad5be8f46005720fd76e1aa545cae60676ac24fbb4c3c15ed18f9a62404cfc2d26288a43d08417a44235e967a8ae90c40650ff27c485cc0f36a915ee788d3aa3169635a4e0d9844a5edfcc312e7aa91c34adde5949d294a41bcd08c5ceb31578ad51aa1dffc4687039c38e3aa65aacace2dda34c52e996e6a2bbbc9c2f7a4f7ebc40b35007ef7205f03fd661fd2254e2c0aa0067f4dc6602d17cfee0ed8bd2a18ffedaa36da027a9850ecccba158c9a1d8d747113f04627fa014dfe60ccde098d83a4701011540852a785e32238ed87c7e4f93c28f995ea3b5a3f1390ba83f93c2aa348847a226e095db1eae947af3894ddc888e79fa858b9066966f7d5ab02ff821d09fe9aacc36565a20e50220e9cf377209b13a82be092b8ffd3d0cce4b7a844b68c558f8fd106dff7f54d584caf19036322a4dc9c080c9960b66d7de51532ad16eeb60fa09046ae995ed6b9c69a0b9fa1aa94e72fafde4a232df531eff8d85c7d86bfb83612fea36487258a255d0cdc9127bf6160f66e0ffb0b2c46f1b9adeb3491af7044f616a4cf444a16c2ad019e0f266f5f3e2db45f3beaab3d8d343e286bda214533adc457a1921d56fde61182b6314a3872aac3939a2b365b85bb74fb8053e6dd3574f03527606647e35cefe044ffaad84a201ffce24b021ebf2a623480df840fa812448de581f6dfe937a799e6191d659ffeb4af75d2a57138764a02029b1c0d005dec63eb410476e1657e3f80cfdd35664e4b2d7766dad0e507e0f91ac6a7a2187c1b67a2e3938d91b38e070537e07cd068411091fef88abb5b322f976599e634cde628def3b406cea133f11f5f70ce09e6ca02091c328ebb5e9e1242e8539e59ab37d48028f75a44d08953297b5f2a4bf7a3fdd625ee86aa5546d910e8ba50e7b1f7f8679fc2f31586e2b0899808fce04fb60459006b5541f6d12c1d55a1ffa13632c1d212267fad50d3aa98649cdd9b753f8f5e8a952ac5773909e322d961f33595e0bd83dd9b27ee10880d7481448ffb4d27a26ac52c5491e9e97f72637c04b43142f81d781e32d0f5d0b3c43952eb06ad82152e40ec8b0aab5dae5766979373811dba500020ae164cd8b05ce36b75f742be23bbf0302c34e8c1af7d95040ec5eed2e38395cae5cd1e62b300185257bf94839606f7da2e288d8c6037572b1c7defdb01667d9241ccbcce4ca491f01ef1b6c08771f84970f58a9bcee038558f3845018ba0201b3f39dbf8f3c475ffb0471f3e4991819277ec5d41f15df449ffe7b95e4fc6e3aff5ec657ca99fceb35b7708ef66e0829070ca52c8f68c7e3da4f82397be69443f410b4ae3799fbd933132c656394b77df097ca7454f1fcfb14b8f93419ea3801b2534ba4421a654cc0e9acad5292c4ccf7e4459dab908b1b30cc3a99bcff6ae7e7289161552a7348769dbf8ae0687fd10f7c526833bc8eab1e98258eb1b194fc285db15640ca443f03e94b1547a61102a4bc9d58b04f815d58e28fdffa4a2b089bb269a4bf576b444811aaac81a38f523183594311b2036bda5b7bee42a3e7cd39c8341e9c0970d3f6b76188803ce6bd48d9df35c063877a947c784e81b44d4b05054e36a326f4b98261fdce8d4bcce81fff3b148e5685ea6a1ae6b97e58e7036a30579fbfbc1900e7fd50e42562a5edc3159f8781df8f4cac584e3354994126adfe6b64c7a28091defb7b888cf653ff40d719839aafd580b50c32cfa90ae3f618b64049d198d94d5786e5ee3ba82dd113c232543453393de071b8cf308de0260807a2799383e2eb6e7fda36f50a2a88f7b35f3cfeba9dc0774ceb5f7e47b2ca6f289845a486895db46975dfc3e08f38068511aa5646b386470039ecfc2759c09f34ce407072e0296a09db711a4281845cf40139bbb3f2d72d7a61f2caea834ae768447dc6d78715a70d90463cb63805fe47f4d20a8438473030d38d308ad0a8b4d3bf4437d77bb0355f9450c738f8efaffa7d716e27ed15bb6d26b9516503a10709cbb7164e07ccdf3517dac23cc4b09f06908ef2e211e5c70833d8d8d07eedfd2a706a033359b19d3ced89181b39fb47b257ecb6018b4c3dc5d98abc0a1301a2adf5f01824c01716d6a744270d4b733ecb19338d5ba4e1686970673a7a07bf5cb69d4667d62de99d8b9d6197594a33749ae335adcc4b33a0b2cb10058bb1e943d65992f17dae3cc451b55eff847dc7249f5b89919acde4169ac97567e9e4f796bc6d48b2bf74c180997e56284795a3b063f0deebb3554b54ed13108469374c084bb18e538d13669ed96827c6824a611390195e2ded85b37e7ff4358fc4bd357a21cbad51b3e1048e563ecdda3fdc4ef283d07df25e1339fe25e8b0290aa0e434d4e6b3c0967733a948b5770b4818640c55f48c5c1e14e5779bd0d284ed111dbec9bb460f4a750dbba0e35f11a0aaae087b75627e3499f2aad2d9456f093bbc7054275a3c2e007612bebd0b8517a74edf960024081caad51d2a2a1307f45a02f87015cf0465e7973b24d514663966d82f1ce7d22a5c4e067fc3c38295e209115a7039852741da4cf6e1c80b21525e96b54e0631afa1839a8e2331f588394a5843e9ec5401ca9ae7001abebd9a74e2be40f289fdc46f51e15aa4fcd7a7289464992e0a8f09891436927c7ca866067d21a31ba6a82da323193119b21fd203eb6d44f23afc9a95d5ff128b511f841c71407808e716760a3ea53cf7cac5c1f24177a9456286726807b305d42fe657cf85f2ec9803d1b621bf8f7b633d19b32e47cac6c3c7f761b569a41bc3144b4a04c956c779e655d90198ff9f38263d45989f3c5c479c5938ca432503512885f088e20f33715aa7840a537215d20ef1123333c1985cd8494b70def44d6a1bcefd037c103bb74a44b74b677c0d3643bdb3667096a2505928cbf1049d0470ddc98ad1e07dabd9ceee5ba65cc5af81bfd05addea8971a7b8999c1dbf15623c37b75d1db7401723f2d5d6670967388d301582188f5e0db4b62262950e9620da7992e51d72114955e3724462d114bafdd8f9d002624d66d426d47eb5e3f67cac38cbc2c7dc0def906d7ace01790afaed14d0bb8df543734008e2dee006a80cc40f6cd2324c5238490a022f954ae70cdcc6967b31f33ac5803a94c59e77092326e6ae0ad163588cceddc42a4010372f0e342b1a66e70d5d61cea13c7678751c6a151b6396e8e8823676a4f907507a499300aecc0c947d5cd5da4d7daae2977a236525ab201798e6486445b2fcbb8f47f58af1ce45030c34c3f61e08818595da5a0c1c1382a1abe5e15ed38132f830515494d067649ef189f30d159c375747ed336baa53adabd42a670ca12c745b693522028e3c5662a63b15a78bac82e6a201542ecb1fb81aa32f4f00477c34418842cfef4c885107143a0e72b04fbed0b1bd4a38aec1eb95b23912833d37cd20bd8b0040e2b5982549fce66045691f20614bc0b9c058556c23e18ff6ca5808e11e5219359f36ddee0a26d22aaeea1e8ff6da3d6b10b3c157420c2ba37d167c61a8319763ef2a6494331b4653321a24c335137f12071d983c8feafb8f6965afb3284c267c3f3dda7642c2108fbcfafb79a5e94ba9f927e1d11c66fd72aa12dfd6f3a80fc29e8327ddd8e14b5c7861e11a2b06e543c0be4d711a628a96579b5f552524cd3e3f2e6f04851fc8e700f78460b74f6254b84278ce75c0521419dc447c1c7290b644b2a9a370b10c66531e2acd97ac7f4168c62b94e5477995769a99455e57c2803837a4867e39de1217037cccec24edf26ef35082e5ac6f77c1da4d76d59e2a6aa41da1d07e26298e38a4daaa300b993f3842f52ad3fa0fae230e40d3ed27d08659b1b6914e0daa6a4ed11ba467b2e716c4f804a5b4b2fbdcd2273e69bf5cb783a570fd9a7beefd6ae3ad911ce5c70b81fd3a5a47ea058d99ec6d2e6b638617a0e211047818f39db4e76f48f030e7bec552e505aaa88dfae46a0be2fefceabe5bd43e72ced955100dedcdc32bd32680508c1fa5e1358d912480bd9a5e095a67407da6b2e221656fd9c1d05436ca055ec4305ad872e5b4ff450b5b5c07994558ae4398455a75f9fdc2bf3092a70af5753bd15d1a42b1b582a8d325dabe50b18fc443bfea8bacca7ef409dfa91fa9173d59318079f9990decfb3b5aa9f8f16a8da614c7a745b97f1c8ccebe0f3667cb8ec47a5c46d2e4bd09278654b72ab9739c03be0d7b7977e1c2e563981a98ce871f1dba3737e03172f54c9fb81a8d2ed5a5c0b186ace61efc8bffc95c06af6a11c51d4362ecace21ecd7762edf59a0b9cf3e71a9e344219e9fd1da281a04641f451fc00c98dbc4f0526dbaa8a72e1693ebce9bc8f0b219d58e322eb94534612ad244d4354d2c0126eb4e9ba60880694517dd61ac35732a1376ddb1437dac4a574d44434236a4c604df1e4fa0e2a651f6e8870ab50fdbb7454c7f8e01e30527c1d84b7b0dd63c501787ad1809b5760e1000d1ce0445160d8a7e1064cfe3781d4f8f42c479faac4533190f42e8a04749e06dd3970297026e58015b1d94144f354594a8a4914676f6040e7d715357bba778e40d8716cf812bc32863c7273034d342dc2280de93040fdd2e19bb3b89e811bb4fc8412c11bb36dab341576f16a9ead79d9e012462eadd1d0087552d29d297169723eea9ee5d4fa0682c91215389c7bc1c7d6d2f0ad523674fea0d62311b8b994963f3c9e45436ccde12f32b1d0caa5f92753f24db90299f128b25e41690384724fb40d30061dbeef9961bc49c1139b9df40bcfd74324fae5161f4852adb59a36e952e8190eb0a2123b9920018083c5e38c98e3151c58460b6085610659aacadb9852d731ef99166f9935afcc1a1eda2b53951449f5201842f087a6eb3a0c46de1a7e04b44a76fcfce98764f0c968b9bc36524e3e3f3f69789628be356d0be228d23dc50452e370781aaf1b4bfeabb5947deed2f259e7d60dcfe825d8cd8c6f43111d03f5f45bba54fa0a597bf6715999973d78cef854431437106a690445bac92c38fad135378c59429a4a42606015dd46d6b65de2f254f28248d2bca17d78bf8aa81e41cc031766bafaa57a78bf43cd53ca010ccf885ac4b893f56ed51a60603448194f3232ffce03a2788dae89f19d20bf9178263f81883756723f01a1b08a5b59720962c7d2ae6d9c4d1e80ea0c9638b39d5fe31511e6713beff2980d8bc6e99018f34faa7166ebdf239e3c3ae483047ca23acc6a8c44f6443fc02bd90a92159c24cf28caa3b86c923e861fe6846a0774b5b02d8bc43be0ecbf72301039386d5239ef6061febd79f99686b8ba48ae13985e900c4d850ebda5fb396d6865aa4c7fd56c114931a4f0e6dc3dad86c93bfbfc09763e8f3551bb6d5d3151e83d866af7d7b9906b456964323906de04c172736035b946b4f370a15207c67978de4ab7cffaedaa400a407ca4fbba1cd5d08662762c37fea52dd59fc9db2a62420fb08007bc93f5ac2791c50b17d283a23573ed07c352c9e36d099b275ccdc533990723a089d9c24fdf3955e02600dbe6ff32b8970aa90306de3cd860e0924c736df9ae8687a30dade2d3454a870625a307e5558d54120f20a2c5befaa224b15387bc4b598e49c6ab3fd44d1602ce7041dfa5bab18aa2c4077b13a88c39d1ae7cf02d855ce60d23d5d42774674a536724483c860d924ba93fdfb16d285200d2f8174ba837bbfe0841b902b1eabfe4c95a9cf011da2cf10b23aebf2641407ee189f8e0880a8482a1c0ce3824ffb17516099f2976f531e144938e6b1ccab8456e1c6e9f584c9dce8fdbf6904c822555dacc7cec09b750222903fc3f531a575b5a55b5ddb35104a051c804e7f88e569f4e7dec56da5d1a858cf8656f20aaac1f1adcf6a8892456b08bc816d60ee774546f5ca95370722ea20c87fd95006ce65594b39931051c3f9280b4d806e8caf391b0a93bfd9fd0002d423b952382740bc1fd22abbc5f28bc4fe82f42b34240b54f3b72b793bf4b8b00867e89abcbdc252b53f7bbd65000269b6646278915aad258c76bfb0aa2851c6f168c7f261c934bf9ea8b7775f64ad9a65cafa667c51309217a899eb63043d7414ab94a0666ce9cbde059fd9a27949c069884598375aeda28c55f68cd293aa47a24c4fce18111dde971e26c7935772dbe2c84ae144025c426e298a387d3f9245e01932b809ab016ab6d38940acab5430ca02c7d5da88cb6752305b925e6c3eca57a485f3980344b45ad15e8f4f2031ce013b1db445eede731cdcac5a66834529e9f62eb4791d70b3c15143acff3b31462e12a8991a927dae47b0215f924ba619a3c8105cc2531a269c858487388600a8b18440117b48793ab9fdb8a16b373551560a82a4a541f5112c90e4b261360a8f185c6e58f2e0e37e2e477bc543ca685371a084c103213cb1cd4b22fafc0076c09660bcaa67b5bbbe31b543bbeb3e7d600f08ce3e47e213214beabc007adf6280484ac0174e2b8b5151483fb13e7c684c72c141fdead7ec6f0067df7e2bc1abbff637e26a7797a70e05ffc00d2089ddd4ad88036d806a07d1844786be06d40b31ff84ac2d0ba2cce308938019fc0098fb0ccd0d017cd8a4599ef7a2874605df832dc28a222c317f68d1bd110f2bb94cd547c0323e504950aa8859d59cde8bc0ff453142fa212dfff2e2b820a5f1bac56a672b14f0db940e23be6680bacc75f5652a4b0dead4d4789fcadf080fe5ca3a3bc82e119756be2525db98e0a4dd8c76bae40d202b1f2df4095fc2574ebe74049ef390b5776650202f7f26ff21b719ada01aa4447191229a70f1e93a534938840fa1410daed1584b91ca0d57dd0ecc3814581f0312b07ef73f1d459d5e9b781f8cad385ba171ec8bc36b071e0c298ff2530574d2bc0a0bc80d7950b19501ca172f197761d4d7e222ac3ca1c6333b5bef708e274e63f6d5ee337d8c902630d5aa5e9ead418ca6c967c393316633fbfa5d70ec515c281c02f582a960f918dc8f7caa878e44f24b3fb31212cf5ec27865df8dfa78b57a6bb57c1520d6fa8b16feb4250fc9d45378cbe764a60cf08f6d1ba38255422509760506c5e4a726c84afc713822ce1f7b91b50004087f50c95ba5754cb3ac177a7592433306fc95bbe953ff42a9f0c2d83c9021c7289fd01ec8b0f189325ea8d42e94ff072b95d4306583541486f25ce92293936a6c11c613f916cdca951e84193716b378a2d3ff05925402f21f878f5e094fbcc07ed47fb84f38bec6136393db985e461712cf1383ec33793319f6ce319c10a4101f16261e69d4c169c167c415de9a192086fb0d5d78feb1955caf38aa4c054703fce12e64e323e9d5dd18994f559483ff53dc81b4a7cc5c4f401e883886f9362166794daa59ab5c11ee0c84dbd70145d2c7aa2ccedb07ef926152c30293a67dd34285ce1f925cc153403f3ec0cf81f84352df8242f0aca72aa16d4ac019536616dae44e010ac8d1bbec8983ca6bc5642af4a28857308e4c88d8c74b57104142ef78253e05e99d40c48f93433c1ff6071eda596a2a61aa47e1a53b34e8966409b95d0399301387f0097ea6f090a75e07ac29d204d8b32de83803b80b26517a241f2150522b32046ce303ccd6b037bd52c62cde0ebca1a3572038bcc027aadb5d5711de0f797c73ec494a55c38a648064455a0208c8b1fb76eca55a7e522f89198a35eb17a2692cb825a2bad48dd2f13ce0b111ccdb997810d2672143df1496ff849592a75937ec5603057e42aede2492f4f84f01e4b99923dcf96d635090bd7c6e4163542f31812aaea1db82746d1b0d7ef2f76e3ad1721f4b5bd28c6b28901ee5e6043de877f986056ddc8fc3f3f574db22e57914bb2d0faa19c5c51d175418bf6aa3b58c528157e6c99091079352c056a82efe69232f7eda05b603752c380930b556f35fc1180b2f878ada1583a5e39cd0a6f1e89902b68eb914143b1f2897ccb3414a37d6446c4f80599d78b293d0fdf83854ac669c12604cf8b813b1ec8d5a63b4742ef3cc2c5c5981346da7c2934b5a99eb184ed550c2e9ffb02a272b7702fb40a8b8e2bd615d743ae7d6b2ac66593d1ff4bff2595af0c1c813de0a8a80cc62d1a3c5e185f46f1e40c56ec6cd56e77ee195cba8fa9a8dbc4046c6884a20d7cb31deca214577cf31497e6e15532283df43a4567434dc8cb33c9ae06d418709aeeb970022c6e50232cf3ad065f28521b8622d2aec0c3bafb64be058849ff801ac3992d363ed0f7fe550e0db083e46f9d8c2276884032004a740d988fa280e08831f0f94378114f0653db1b529680389eb484eb7f82c94b0f020c73e84e0f8bf50e2af2543a575640a19dffb1723a19d1c250b8a166e581496afa48364340889ce471b6036f9c5a55fdb75ba790006d3f0c84a4104c36b5b189a2d22879666e20c94256eba083b10fa6814bae16b8d62c2f8f6a906891301d017aaa8e20d2cf4cd19e2cc01ead8c46ef2fcef9b1b32457b9493f30ceaed296815b3efe13b004623175f96a539fb467396e3b6fc5fe9dccaceccc42bb559100a478dc7355bcb6af175a1c745e8201cbefa87e4cc732b0d14c5f1beff9162a945bf14c933eb0e9d611bfbbe298be0fe4af9a73ba01dcb83afba5a6bf9be9a6578a536af4e9b6b5a9ad2a1d845e2d1a1e9bd1aa9f7262c3216fed0d0764606dd94a0d523fd7dbdf32c7379a42bb41f5763d52c70045dd1694b44946c5eb168cb084e1fa3a23061739d98e8394224e32939609e5680460be4523b35a04a87e2b57448c5f158a7f65a0cdb2a74cd3a6ea11f00c5e97b6902a852e889ec806a2c046fb18747936dfc2f0e93343ec63e8d80b98123806b8ed3e58ba97d4d5df164f1af64a4ed1cd408ff0d392dbac5af74cb3fdaffbff6b3ad6adaa0429b5127bbc3ac95fa1c7c5a0eca80c4ee898a6fb42fb287eeeaf8033176c5701d48f4b9ece0509edf45b9aa1946a69e035fadc36246b0e781af79b387186813e21e721979e72de0464760f45114d03124763af11116074914777c24c15ce843810095735067044494514c90a08a4ea7246f168dd59b35067a08af2d736e9684dd6c725793e632d64b24112701a745afab91fe4de5aa7bba4ba27bd8265d82a1028d10f91b05192bf331e33b317e54833f84bfdd9f3d08dd552b06418ab35d0777e1a9362abaf1533b2205de8355b1a9ae50505138e372f9ea2af57114e157b01b465e149796beafcc54bdf2d7f058696db26454e56a902194306de932508b26962a353e468a0b4ddb3c24b11463534272929ec78be486a4bb4a98efcab03b71812279369d017d4780c67ecd576ba1a03877a7294246cb4ae884026736251ca78710834b766acfe7eaed3b06395fb02e3dbab411b02768d7a092beab0f2daaf72da160b187103685951c15dfa98ed2f5461814f49d9c3ff614b9c33858f232f97ee60e2e449643caeabf6f785a71dcd98824d3c2ba9c19284ab6e1a22356259b4e434b2c29937679407968d86729f2f8ddc158785441451c0a5837e5421c25d2c8600eea18a7d6e8075e2197758b60c3fb8da604ad4cd226f7ac3754d615849da155601ea1d653a8226b2ee450bcc49955b6bf29477b0c5c1740b2ad519997a3062c6618492ef6596e67031fc57004793cb51b3701f028df3d2b8fa18d5b1bc69ab2246b272cea9ce50ab9bed77781b75af0a2c90a750f1170a9a7778010b9dd308162e88528048b96461fef0a8fe43ed2aff5579e4a410efa61bbd2eb6e5a7f67d5067bd0b09e2ab1e8641326df54d97d839ab0dcc48568e254e1d21ae6a9be880415569f8a9af0320af1b61296bcced22a2b7e38210b6ed123e4492cf52a2c5bf5c714a385b60e83d1af32a7752cd4322ce7053f8e19d2f4f695ebbd1484558ca9ee43a286cdb9481e54fb3cb108d865ff6ff8c3c1aa484e9471fedf1c96608f1131184cd41939bdfbf9d2b324aa7728950a5e2a29f930014569eb793784d77584d9a50380e8e68476123a008c6c2de50fca1ba9dab95daa25049eb3e3061895aa719181dbfb4f9493f6a62ded25caa0cffb8a120c501925cc2f73ca5c5eb1f115bb7a72a89066065161ad1a335c457888cb6d6b7296590299cf12ba489df2a07dca97fbfefed24dc5d985f640745d56facb66134638da844a1c0e5460cd46882e8722e639a0e648b554b3e55273b91096c22fde655bb0d71000b5d23f15960574f01dc46da65e05a08f0c9e906031c0df479393e80b3b187034ca9b0560e1c2f3f81ae026dcc394879b9d0912eee72c853ca0e3bfdca466cc406b5440d8be9f3b9452fb917cd1608e20200ecf9474d3a4eeb49294a8c7bfc8119f07d96509f20c14cbf8367bcb675442f7de007566ed1429e5403fa9db6b648806020a8f12db29394d79e0affe2a74e17c20c874aba16dcd86f959f7fc4495d937854ba107be675aec4aa1a20938fcab3bbeaf8ad0382453efcdb8a4b40888974047680d7f7a52bcd2becd0900587e47c3e061016e14fe909018e7ba28e88662e833c8531e70bf956d8c42f8066bd21ca2dc08e8ede3eecf79bc2e890764aa8b11b09359a53e6d4d601a38a014123480a14be8abbda4dd8322f64cc424182850b8985c4b1164285f3de2bc8f45d2678056e89fc9fdf7b53df0ccdbfaf45cc9cb9bd833b1afa2c1147f5fbc3f90924e273a8beb76989dd3380c2533fe54708dab02a651536156e1384018e9d1959395cca008da4e3d11f40f991c7086398e7921cf249515a93db5c5e3f49835f3e9fb0499c4e1c021bc179ed804b3475c1dce98cd18d04395b23b42e7b3415d6993d41dd3a260824d7485022e6767869275f76e9159166212bb04680ff10f0076489051fa75e46b647aa2191a4a80f4922ef6a0c5c5991d1d603720c30f275eeb1b1ef188a2662943a20897874582492c464c15282a40d02ebe96e71cc2bb9273820e4489262e482b139d88dd7f210b1880bce509345d017755888b6818c49601388f67f116130a8b460d7f20b92b6a1b248ca270f1a5f32ff81f6b9de520293a266b13c63b7130c9fd68800cab8ddf4a123712cf59f775413ef7707798961447606319c4d995d2604d8418824bf1a62d7825f15dbf2a755a535057d0f23a31bc0a53de537a86a4197e98e087604e1c7631aab16331629f36e746fb0677aaa8394c29f9fd7a12d27694593918d5606d49a765ed39045775354cc0aa5a6b8a384d0ee251e5120d04698b453c6ab454550ab22012304f2b9bc2725a0acd254406e16714aebad8a1b32edd3d663e39c60d28e778cbf69a9fc1133dc201cfb740554053b49c4ce62241328745024c60d08fd8fd9947ba7864418d220bebd6b98c872e3de1f240f494892cf3815001fad443dc435cad4802d8336b27c8e8cb1bd4592f4959aad4ed5ffad86cbdae572d54770c47644129b60841f15942bffd4b4e17947998c144022332cc4c59fdd5debc3168d1d83f6d6fad40095f4352ef5e7aa1d5b2c01ece18ad658907b3d36e21b39b72dd704fd14046e1e00443aae716dd322c55a3d992642acc305b15843062e2bcffd0a59f8e987e68c793cd6c40d94435f337476a17d90f8e7823ecf2733f58eaa8484131666bbbeec3296a77c67ecda4ec61e3e6767ebd8286932ba560827014e0afde141f27c12ad992f9688f0eacb4a7176b359fa4f79e25d7ce4b5b7410880b74a858889429fc5eae939783fe34d8bf52947369a31892d492290a2eab9a97f30cf0d08107936942f8eb8d6f78ebd7667a66bfe265dfe50c3bf72cab2a3a0610e10c95fe8d3682088213f4210e9e5c88d5ee1ea365e1b3da370a58c217bf3bd31b609f137fa5be172b698964d104d8962fe6d7c05093ec83e81a0d5ab9fd3de2174a1f509449f87fbddeb989b6eb2ad58bafd6dcd463d2f3152ef13bec37e1ced1df368ecb8d3d894708345e2aa5df950868601bf68a30cfae0ffc650cb419686abfad817ec600d9914852009d5f49c12705ee9ce5b369b1d1312e1b03ca42509eb40cf8c188b07160aa222d8615373ba1f3f3d483709f33b7afc1fcc08edc362679b88e37d0d6b50c2046f59bae6409551f3113994942bb31995f96c18784d5f2d39a5e9587deaa1d4c308f400fafab1d42d8d595d67a2fb52a33d26fa10cd11df7062312e6133b2d6530e96b99f15320bc4e92b2fbe292f824b4b77b0154afdbec0a049a2dad0aaaf536ae75e3c5ecfe15aaf6babc1d3f071aaa011de02a83a5ce9fb39cb0446e6cafd2ca99b10b819a6aa71d28817f2a28a87ea65783c7c43e11534e6fd6a4ce9e049302041844b48bd8c82e74ade3f08353eee19260da7a797eb741d2feacc2180151d68f67bc8b0de8114c17a17de9c6b2ff417b06a80923e93a9a83d3aff356507a271565c0512f5e5dee4a146db032c47904b0e7c6e8d94a0025c12f4eb7cebec3d01988c694110993e5fb3af02730b34a24586e5e707ba09cb7e0155b8baad8c8c04480519556f3619d01f69db75913d79cb3f2641fc7448c64c9783bc356b1124a3507b667d722164a21e74453c3f28a17b93eaf6912385126fc5ee3551e44024e64fe197f4ab16a3e45267c706c4c60685d1efd799fb998e5e4ba6feabd58c84a91f32d8d982902a2f4318a21aedcb6023d2b429f210e978248ac17d2581662b1bba64a74410de009992252aedcaaf503fc143a08233843721172d063575b63009344117975ea038ffe796f9a6c4a6144ea3571cb7598f2dfc8d695426c2c3bc05d5dc2f2fc0905ec03deb4bb5dcbf496a6448e943ab1eba59e6748be4cc60d5567c3289cd220f90acf52ac03dd0875c13d41a47434335d88a82a4784eb5c2880427987db246b72c408a4fe43dcdf805dae6a523a868f8a8331407727a86d56664f48eef594ac2c3b6f4ffce23ffd2db2a0c2f8a1e8a38b0a2e9dcf37957f246f511f2e3b8ee75dc25d511525993cf3f3c0900ce300f3dafbc24a80880de68597404320ca2a106e97bf9068deda11962f3b603e1646d0c46f0d7c494b30d61102b2360c3bb3bbc08e4719cc4518a803a7167420bc38ab931d0e40c21d25b6dcc18df12b4c8920ec8790d3d4a86046b28d3759a8149566c92e1801a292d0363d436a14638c47f742b3fec4a2bee47b504f8afa40f80e39eaa8862d273973e956d48dc3e09780349fe355846e9ee6d4ba846a01b255148b50d9766eaa87abccc3ec08320826bdc596c22c2db3993381358d6fe9240f387a39b20eb9d9a192bad58d81d9e1dffc82f1f323d1be1507cd4f0b494f52fb703b0c0cd8a9a922f36941397411c053afb14a8c8baa3dff37d77414d19f42b41346512e24b2aeb4a72973e4b3ced3160627c6ee402e68f722c6b09a33b53f905594beb7f32a2e04e8625ffbdaabf58af120d06b020e3379e274c6073c8b03faeb35a0af73b9314472dc5aea5d705c2837710ac93f09e00fd829f6e8591946f9a60944c88eab2ab93cff7fd498f342f02349d9f6760c28525cc05139070332479d1803e7089b5952dafcd1440ea2e9e1ea789402165a8e9e0b8dac97e20bbb50744619d1cf4bc359cefc2260be286d489ef0f626ef5f101f543f41c310544d4b10a12580a79b4380c940e0084548635de71eaa285d3a661db73c3d1691e1fd902f72d8d00755ab1e24afa76a6e5c027a7bf4fe7ae46b31b7bc4becb1d065d2460880984b2c9d767afd2f1bdb1bfa334a660186adffb03f7aa856e0d0003556673f2f136c5db9abdb0046635b3dd3a8db0136437a1bafa687a7f8eef83d619145c04a436da46294d6bff5e6dada7fa59a90673e2440e52b5964c7381666d593eb02047eb09ea220a53c4838747118c64958821d694d5bb59d8606b8464b6153d4b9e6b73395fd5af2f6781ab52c426175081b3e44c53cadfd64f9fe101822e063ea6d00d642fb0594a9c1377090af0df3f50c2cc31e1343f18478e18d2bc42f5e2e3b31f7fef4e0fbd2f41d61cf820b594eef6590afa7cce8b9670f10352315d7bcc2fbcd2bb22f9ff21af1242087ee891018631920dc490f7db1c6b6cbc34f5f44eedecd17e4ebad66242bf17dadc8d7df0ff6c52e4f5669142cd4bbe72ae68001fdb55410dc7fe51f682936a2bfbaf4982d65367f8c94511a87890304cac4baa0ac5a853b098d90463331d95b2ef865f3d66f94af7c0d4cb6ee27454b4bb185b395272542590eec8d126bbc2681d6dcc9661df25ef6bdd2429ea95d0c5936a5e90c5528fd12c1a34ee12a06e25606cbf610534832d9554e3a3c15fba8a91f8a196f96dbe8d2d97e8365b21f48c597de67c3b10aa30814485c47b20f0f6366630cd02cc405a579369071851c539ebb57079eae6be5a6c228de01ec2f278958819eb08b381b7990ff86d735829f0649eb298e48ea2e2565e31994921a6022f7b901bff2d1ab9131a2003543a33c27724588320b252cabae5118954d970406998f4080ee67c5519ca45614b85c8422354de49e458676cde473845421f6ce526074b468e76b7d92c44a772374b372dd47a8c78b6d7a375a994847fd3c1edf14e15637e92255dac990a4f71e9d94ac46c9cd107fa6aa7c8242e183effe75ad3f8629d5a5b9f477e40b4635bd232a8024abd821c6e672b89937c835b2de01701648d3a1ca81b556cd4e461d69d314c99d0f5ad30706a5b0df060be37bfb9740ba142985f1bebaf804fe1513b3f68d5ffa0447faa2bc10ee7b24cc4887ec24adec88445dc5536d1df1959b0432ffd1b76510d25b3e39a1e43c1cb6232ccaa3a151dd23fb1dede4f64765e2b85d0c8221bd0ef088aace80148b7693def6dc28d170d89d203202d81eb02bebbb19204c608f22ee0a8fbe80b832970994df7e05f07d7425499ad60fea570fb4565d152bf238703bb4f648ea1ede27d5c121b921093f41d04e4373e75c487ab331eef5b9b835c56c26bf19282ee96f4564acd8dbe8eecae4e5400ed3c60e97f7945a91b4edd666c64beb98598b03a6bbc3bd1d64d88fedb3fd8d6987280a77bcb060d8996a01a274f24a148eb11ab874a25701ecda1c1019f93b747fc88bc9a9f182f5f3d39cfb2183961959cef5a018037897161a866399ee73dd7ca2faba8ead74ba70da27acd3bee542f110883ac767c816df815e813ee7db2eed98ccf6635a374e7022046c0bd86b45fb5a48d75e76bef488db91d5128fc40a68c3980d5e34bab6d6c34bd011ea7f6f0c057fb66fe51b2d4656234040b0f6c5fed82cda7671a6b57514db3fef0835dc60a6a39a84f6efc5b596655e48346f55836b7cf32b0447e446a1f1dc4d8180a004d5f3c24de5da26021669a49dfc9efbf993f5330254f2b5464035c8503aed2440cf58e22dea9c24f901a3fd55bc08563c2fda24f6592f9e5d972e854cb0ec5ffb91c9a87a2a50d099139d443acc928de5d9b0f2c5f10a18d1aa7e71c878a42aadf06e7f8ab19ca2872dc371a68a156316911d40a5645c0fa7088547dda49fbe3cbbcaad0f9c81ff22a75a22bdf33dff4651e5d2881f734c805bbdb50e876be3e23d690cf4de07f681c97de7b2f61e2b9c1ba99a3bf5928ad27b8f1fbcbcf1469cc63d3c78c651feb1780482b15b5ce18872a0981a19733a8ed844e41e19cf26db6c01b18eddad0adf6b5361f007e75808159ac82d97dc53fe4ff8d7b778d5fa6ee0001dcecc8254bf860348e15762566e1da01c95e6bfb869e8fbe3393a426642ed1fe8c77ade8c5883bbe0d0f6488e39af068138c35071d8c4c3a3b60961ceca9205c35832b8118db07c997a062731a70290d225d3ac00cf9b3b66b16023c0e18477b5b0d92df4c0622170015ccc1d8eeaae448d0aaca693de61f505789efe93210b54298f333b144ec4f8ec44d24ce9fc54201fe3865c2a58611d9a1abbe7cdfd1982f1f825a3066f72dfd8fb1b23d1429a66b2f0dc228d8aa33536471a92e5f304ac50b3ed081d40836574ba78f4bf03ffe979608425d17f84ebb2ef48f4cdd8e292332049b4e6eee15e1e3b1bd10e20e41aaa911acf662d4a74a1db77c77a6a9592040231f463b11948582454be916a2b75ca8c4d8c04eed9b476929130c5a037326d759cdb8fd48828f1a626694422e33b8f84258116c649b070c74323f466eb766d3c1708794eddce487cdc2748b44c4a55eaadf8350e8cfde5db90462fcfc573fc35e37a1fd175ba731381183c3bd71d799a9738d73f0df9df1765e5facf3f72aa9625f948302254a406018f727273e43802a2de2925451e875313bf476c429ce55a551eb9cb79247767680cdc45890b9abb3cfd9ac1706f42acbd1e8557b8ae47276bb6263b930ccb2a34a3f1272f212b52d1d664a92f6b8758b235b10f272f5216e0b57e7824fc4d9d0d77137f019d67d57e073ec30f881f02dd6bf541a8bfee476f6928c9396fa520c7fb0ff2c8f78eb225d149bcab5ba7f30e18a22170ae3fb47960d2f4e0892ff287417a2656582f0de4c464642bf9c84e10aef90e707ab29e38596e942231422403d7f37dab23ae2cc576611bc7f5d6b6b57ba3e1098193f6160ddd9fdf04060a86fa2ca1e8cfb5e70d2f2850ffe6e584aef6ee3f4e3b2ac773f053815732a1a533bbb9959ab272e98dd5ab2541adff04fa88f0c82431c0ca2591a1cd17dd789fcc322ecac277c1e319d3ade7e2806aa4572ccbafc6c5bcfde9448e8af23f70cf4bd66a1cfafb8e659bdb432fc8f12ec47dbb4eda27f49cb29d33befb4c577cf53cc73be4f157c7f696449fe69a8fbd4bff7d5e8f6733a633c109ffc5900988faf668121f5244ff9195f632086786b916d79a697dc18a4ca1ef83270230f131bad5600318321a9c8b6a213dae58e374e42a37c84867eb6ad4a582b345ea6d03e1e8086642e54d093ecc7ca3e4ebcdcc374ca158cb377c93bccaefca7b71620176f9a1e9c34c19cdf8e9a5e9a8580fd3a0f37cfe42841046e649d49a4c1cb15048621c3ae56d3edfb81f25451a30a132770b75e75447c86b95adce519491b7ce908445195b3e2cce0d360f2c6fa3671ab46cfb87d1b6a16d8152805d6d50b7be89649f234636e7b508c48c3f59a00eeda4b558ec5b142099829ccce9f02e872b04520f81627e8bc6b896898d772cee53e422fcdf5a07c0b069c14e11c1d52068a0d526e1b37f04b322619b9e4e926391d3202a056d6a9cbcc5f0cc2a28e83d68b2881bc7dca72e555da35c6e8ac7f47153f297aa1cf60074183df61844de2dcdfd6a594e05b1c305665e260ea1a08d5ea300a4ba1a0ec9d759a3ee8639840f7a13dbaeb15f007ac450e819d1c421179efbdb5e8161e2c1d43ae440a2cb061a28ab4b5f30597c34b1d4a7cb4ef223c14125aa32890bd12aa6bda482092338bf9c154c5b5ee113746f1f0ad1d804a8f93242c239737c792a8d21f66f098fd361edc2cd75e7307118032c4be3410eaf5c5033d02f235bffd2c1803f532744a227f46edd0ce1f82532812ee411364c724001c7f400159f9284e7a97587c2a8679c3a8b3ac91613e10e53b1d569d0bcfd7138d7b865466ce1cb7a6a6d251c94dc695995d4079c2150c5dac951c1b455421c7fcd8d230319eda8bdf9e39c350fd4fd18895cb6106d41a84549971f48bb34eda322397b0be801c5fbaa8d5af0c7d9830b800d2e5a5aa0d389741464084a6821ddb37057eff2670b03f24ad266195e9b059ad4a7eaae49c2568a66734f1d09e172459309875df1818941758cb43819250bd316c57b3a9417138085e848c7c0e2c806b098018633f589bf1094f0b95b093675309e5e4552ff7cd7a673d4e6cdfa786cbefaadc2484f77752301528376121b72f9b03b3714f81174733ce7d16e56419cdc6b38915e0b8f97910646df70493b557602b6d4e423b4f4e7ec513b797d33dbdffc23e06d15d118275872e9fbabfeb052a87ac7668c0c1017bd2161bd6d35f9b25a8630805cb81e44947189dbdd7d1aecea0fb1094bc832ab2eb3bacb6952befe8f7485960d7495fd66ec1bb6947b5f453c4940928e5c7441d026209506e710c6187cd6ac34378cd8993c166dcb86f86c0253b017956c281fccbb477b965740b618d9544620fae793c9f6b53b9d2a371480575aa1816dccb952682a1a727b167e0181165134198e7c82c6bb80850975486ed93dd6b189589c3beacb6b3d57a03e2ccf9532585ecfa0c885ba4c1a8b6d3710a658ff7d3b2db9aceb1c3ec01d35bd293120f722ad8ed195761002e4d261cbf16b4bf666fc774659f1405bebb5a6ba311e78f5b5d090f7e265a47e4078f2009beab28f0887b716af60dfb228e6c8400055dbd31e07ef9eef8011a25118f74b4afbe367cf0cbc9556dc82f60a6a1a762eebc64533929e4463afd0e8bb9b79f956f6706f5d8018b52d60888c407615f248d39812eb0608a8f00563949d3d0a2a1cbfe05ad533839b64e77c2904468c78d0a36cd61ae655e4e17168b72c240ab4466a8bf99db890049f38ec8175a6bb09909be03ded5238b12d713104cf2d97fffaf314627da3679efb000f062861e1c23acb45b0969e4c0610124479151c42b4834b253608e38e8efea9536bf5dfee2805fc5751d33974956051eb56811a7c16e1eaecd19ee7d197cfebb1b8bdc7b8f64d0dd218f2b46049e5e81e21c4fa2195576faf3380d008b711c0913463855e85ac62a1b285e46b9c32f7f293ac82e8fe8f5bef7c08ef9aee9d4172683fb870cc043f8f75bf2c04e5169a26ccdd400933af57394611492f48ccecd50669e22fcf9e46bb84479096911d3e96d6b14d830a660ab8f0f01f5388c355aa0d5b2c7740b1dc1cbf54a4c23de387924f00c61f369c5a94a264813ba0e8cf034af9265e850d04023c5a4656491e463d41d86a626bd07b45665d8505ebbe324aa0f826a57526ce7dd288834503d3a309e9f3829eb33870c8c5daee5a296b7ffcd0137086e0cba9f45bbd607c324534ec856e422012195bbc8f28a18fa4c44f9cbc53168a873b89a92ab8a7ff8703f4a64be1829b79e695436c677bdc4ef76b83dca702c3c9ff666eeebe153f953682ba4c0d9018a2d094ab7babded1f35fd80c75f58fb3890cca30b20f7ad7793b153c67d12762f9d6d326cf7036e68c98fee5c96f88006dbb4e6116038f70721efeb93f2a9f09751bd623f4175f42e49f96ff648b70209dc0184f6e0a268001fe6d556a57b9a5823edf5079a502a42311ef1fe7f38865f26f919e115862c03c9e8390fac5e65b04cb4797a170be454bef4f5b3f23cfd0af3d755a2b346e0c8ad840cd75731c833728dbcfd2c2e1902eb7fe3e58f0220c1bddadd0c2fe46b7b8fb9917be8edd33ab9f6cda6dd157c9109cefdea0e5e1ac014fd240b35594047694ecd89d6fe9efb0600df4a4bd6b52d5b7c47436599cdab4e3f224c0b7679243fbe106419d34987ada98df8782b0cbd352555fb93bd9bf52fd685eda6d752b1277499208756c02b23fba5f60caceaa7068cfd3b4eb458f29296fb8269c7b559af71196767e418db9fc14f2bd5b8f28a77834c75af996660d7774def22fcb85fa3390d65eb50c280dd13286277233ac080d6bbb9c619ca887c37403107f5f32e45bfe9150294ffc5efe3fdef18e8904f54ca543bc87c4f74eeec3e7a7ccb902e8ec3ad72500421c18c6cb5b3cb8624d78f69f65a98dd3bfaf342e709fd0e648d8d93f53c44fb3312217d0fd96b0750f01f4fa70546f7465bd1c3f00bdef166b6571e10fcb34f078005d9a8374dc4b4002c7583f658a75b31fec04b4e52b397710af20301be1c19be607733f28cc211e177b222253bf9a30967d0280578eeae8584caf24ea33d9777d7613e4915a6a074a29399d936d35e75aa8a05184f185d568be59cd1a86d6e3223d2c84fa982e51dd3966689c6a0ed0f8d905035abe9e6fe36bdd900b8468488c90eb38c8531fbd1fe1f46104b4f1e5b6059ebcea83fc608890acb7342ac24c5ec0c80966800f5ac413d8f9d0d8910d51a31fce7200315d05171604f7f3002408004dc47f91d81ccc0eb026d1b1c42883de590488e8f090b95c94a9e95aa6508ba092bbd6d6dafb3428b8586f13d3d64b5400e10ceb2b1c74e4593973f55de19c6cd24fbd99df0c70a5040e0102237b06fe2d1ad4b2f3f142d0d8b95397deb7994a7098668f818f4b77dc34596855e10beb9e06d4c581ebd14959b6241708e66f7b661737f523a44888e49975a21fd7665e64d581ac3dbada8acfe6cf8abf2b392f30094fb7c5bb18ef62d749567f51ceb15ae2405952efa597f12866c957d10aee050a3ed4a74491517d08b2ccd4c4318263c627fed9ad0b946f2cd618d5324676ac6fc7708e1285c192cd274c926e5950fa23b817f142af43b7d05d6021b3a794be04a3da3eecb6c00966694950d4a445734fd3e2be96556c30c6ad70cdfc4d6ec1f4a1dfd66cb3b7f20ec64cf058fa4c88000ffecac9feaafd0ddf131565f6ac3be7a280cdd8f29cc1bcccb4a3e7bc5fe2ea49a440ec792321e1db79515408670f1141795362909548a9616f4187a06638cafb1074bae2fb21cecd4a0ead18d7a77a3826784278445a8922d8eb8a9bff9e17153690b2b3fe17d65b0f7bbf99438f348f607ee22bac7710435ad89faff862ccebc60ddd58c1d1901122f9703a2ab5d61bfc290dc6183a2c3450c33b8422cfafa8aa1240e1818cc0ace74d1aca05031f139b8021b4660e04f3e0ae046ceaa49547e9d047bd9b0f8c43753ff31c8105b69c73b3dcfd2329f2e993724ea1cc3c85207a6530bf85319366a9d959d90a250619f91654f8ed2a96a1c902e780600a53e699a39d6edca4c7970f79467af31d7b897214588c87be9fca55365032c1676e31e246ddabf573d36bebaa51e1726b5355d63b24450922c0a791cc1ee6a4b752ea6478a3cf073b72eed600f1bc5a5411a0a5f900e848409e84df735e902e35a5e8219709182385c4d9e58b52c395c9974d8ba5a8e1d189e225cec5553c391574ba077bca4f6e7280366c4186fbbec1bad18acbe1f15ba5865d172925ba11350a277a91e6a8abe9db5a5989ea45530d78d4d880e27229ab5a28d7a9039d295a930f18e04f3bf5c007484eb053906207af0a2073e75e1d03f0ca6b98d5e7edb506884d7d14739c9c00ced718b45131e4b9b60b96e54537f7180b629cae219e225f1fcf8d8dbd3099d2f02c6186ce0028c2e11af81794b3ea4e66a8c1d3e3c5a9e659e6157966319cf70dac7865a914297cbb7fa89028b078eb7b75a7d9773e03b9f8727100c03a1086979df70fdd6de85b5c84162bcf8d523dac146d6231f9dc356cbae7a65446691dca4dcf10ae7a16154e8ef8422385b0668ed065cac513093030bcbf14c1c6406c9d68b0400f3c36fd9be1784df5cfb2e8e78a8d01ecf825dab84cdb2411ff6526e5a56cc5911820ff9ecb18451d187b3951b13884ba918f42f70f453fd1c111a1bda3accc72fd1bee69ffe850a5e296a9986f0fd14fdd5d1aa543ad33ebeed3ec8e897523bdd3e8662d0d63faff9b0f8e234fdf20b365359aa024ef2c02714e2795d205c4bd50bf2586d0e81b1df123273d73334662018fcec859a2d207815f9a34f7bd503c40e4d22f4f558d92d0f6f5f67ca2226a8ad81a964f1f819e4fe2e01f437f9017fdca2d00b769fe283d56cdb812d38c555094247bb54cb8c4693ce1e198a830cb1481d973e052246916de0be6cf7926afbce89a6a2ad47ed2cb957a0bab90b603b8aec16463a49097cde7ac7faca840dab2c100d057d69b991171b456c131a51ea0a2a599c72cec07c13d310395fde097cdd7189d72e09a9656b1dfb4a5563d25e53c3f6ae2d8a7178da7dc09bb5376d20bbe61f78f9e1714fa8ffbc74087fd64d13c3ccc915c7171de8fd93c7fba3a05d0eecaf69cd1d87ec931b2a1825a3fe2c67c79fe1a29d0270707ce7f822bc81ef76ec1c6c7ac65d681b862590d1e7b31e327848038249a743d35f1cd24a9658605f3ecf5431e2a31082dc8e4b3e4b85f368ee5ab8c20bd0259068019af6b0c3148f1375eefb7d42a14c0d452d41ece2028711ec4015b76c22f98ececa0e9b135997b52b156a7464caed80c089ff6e2d2a4c41bdb58f026f25f7970d23ccd5f63351afeab60520889ffd764b5d263b46a12e0a4f9a5aec0aa93d3525a61eab510c169afa211c2aac0447993ebc9b6ff9e4e4890dee0e1b986aaec02da2b48023591908e466fcc3089a547e3b206d12580c9e5e4648a5ba30a7298a262718c7eb2ed3e99af6add07d0f61dc3d5ab0a37f36e08448fe3ed45607cd3457537db4c75c77f4aaba6306c110fc6e95634e6dbb4b2fcaaa2ef6098e7ed5ed7ed7bd8733fc343193fa60420b0524117d04a67d43796953f92ddc24672f4149d40eeca357f49516244aa3ced3a90c79df7c556394dc2a2f2540a3a600908884719304781bd7caf4026a2c41900d20a5d42e5c5eeff5184f567765671c7095c5a0d35d768199235720af42f978540cdee1329578f5f0e976803bddc580017fee075b2c31b65283bce3f3c047343b3db7d6b005e50e1c67cef93717fc23a1cb5a6584a50688f4f3cd627718e8dce3b12ea4dea55cfc41c11997d1054b726360b42866e9500b3ca435f467b72fbe2a07bb5cebfdb1bcde2d54ebc3c2bcbbce8db3aeb82ed640c5ff3b05312bbb1f8c8ccd8033c806e36756d5a4a5dd3e25e845cd5712dddcb782ce4344076fa9e280d3d2706f7aab7014dea11a52f242f900481b871af4863a060553f0d67452f281a2770d0713b4a0eb079c3530135a1e1a1aee549838030b94f82243f3e28f0428f4cc0fa849be59bf7c83ec820618c2b47bc02d73abfe17dfb20e0378d2cb14f1926602a2297bfcb201554fcbadee45ba72331de81a4f29c41bed42cd9702e1caf81722bdf0c4ea058bc9ab5d1a39f514a5fa32e2dd30876267d6ad0b43a8fed50bb7cb6a35dc7fe15e42666d702c7018b4ef5a4896ca21ca0d8d9279e3cb3bf3260c10f2b330fb56b17749b7cc33c90568ede99bfd87975ff61e52ecc869bd766948d9630d23ccbcaaddb15055d533eaf93b315dff889e574f41603840557d423ba29c6d4f25b5a5b8a76ee744f811a9d1027d9bb5485c801b57fb45b605e35664084567ed1544c495e04075184f6f26b582c79d9e17f2cdd087dcfc9cf3b778543137a7ee9f70870fb0f074f67c44b344699c8ceb6b96156a383ecee9824ae430f2cd7a3ed873f7a0e0e17fc8a92d913c61503e2ed8ec3e6e028a8851074b202e89aa2f2163bda07a89e3c4a6659d67ae0d0888552b4bc15ab4dfa94a1f221d8960dd18afd5f53950dec5a3d51cdd6b37739c5fe0b092a271cf9d796182bd700ac8c78e9bb9b1c6d54b598a0f7a07b250ca92fd2c38ce6ad8eee34a7c5ec99991c4bd66b69c992be1593a9b1323475fc3a8c559ab00737c0bcd7dd3ce8850be116ec69b2ee6f9a8230508bfe6814e0feba34a5a454458cf3401332a3147c0a1dfb67f6750a4444cdad33ef28904ad43c022822ec82da753d19adcb232bcdc25bd86c6e4d6f0604543b9395662b248e6f9182978fba0b481a46d9b16e8918018203e8a74e647bee5c5e454fdd27dfd300b4047aea15052a4267962fb32449d4b0436732ebb5f7c3f7363374a351e8f71f3c7f6ceca4901174cf67d3db4eeaf11df3076be9d6146afd06ed97ee0fedd81f1bf7a962e4dc63bc1dfba92b118d1a371899055cd0036ad7a6935920d0ba4a078a6fa6e124a5273f0e3878bf1b909cf16b7b78bd44df008a3a5da1e918ed9ae4db1cd18041da4553ba4d06a5ea0915819cc221a6d3f0264373645f2e22bf1140697d2fe481923aa9de96ecbdf7965b4a29534a014309ba085e09410839516bbdfbc33942b36d9b1c7799d3af419c2334fb8e74e6fc9953dfbadd3da8b97a53021a4bcdbac279e661ed86640fd816477d6bee1abc62e42d0ed471305e9cceb90de8da275a503cc043cbc639d025e448063268e198c04179b2c687a816e7db027122a8fa183cffd07b809c65820db88a3b6b02077a7167bd4b8150b82c5a1c583b259dcb8aa316b7b4356582d7477ac8bbf17e158c2dc98b607449e92e5dd049b3b6898c8128053378d9f0820e3058e3cc9e31450c36b8f245939511b4d8bdd5155b5d1c8ae3000cf3ea946a5e411c0a050a082588f04a94154097e61ab842142fee60200e0593648ef9b6885ae17ee11288e009572b48199b7f409f0dde7eb84d48da6702cdea8ebc7dfa70524aa9cbf9d249b364cb1148a00541b0c0294c0f2370610624680208a5175ed0a2a241050e30168a6e252a4a20c12969513161860b0e4cc4302582e862d6040d3d6c2ea45941188645a006463ca141868b33ca6879c0871fc0f0a10b570f3ab4ba05252f9812135571511b1aa8a82d89496494dd962ae34da07d49b398cc4f89735f4f9096f994dcc48b39743578bc5282a1f4202d9b5ef72773f6b8b34aa6cb9864ce2a3149a5941274e24d31ccd509d00fc53762c34a142600fa09e21c71262611884ca1faea1212f401010135cba741a5195211038384645f4fef30cb6ff5017991242220792d418356e5e870f0fb5ac28a57fdbe9660e2c31e501306484b6690c2d0c25a0c9b545e0649c323fa9dedf20ba37c7956daa29706713417ca82a4e1e118f9be5085b087f665155ba2c72413ec434a495499c568233d58d157a6b27861cf17c5eef65a3d6fb5f2289d04f9e1c61f4ba759711794ad665b037842a86cdca4f25b0ccd624dd04bc20bbd9faba529fae941b57a5eb84ad33e3f36a72e29950fe7982ef39b6f2e04070ec2bf79436d1ebb219b102a734af93946f5933fa85922f48d8e2aa77fe64fcac31e3f535368730c1342e5b1aeebba8ebfd0431094f9cdb9affb42762c738d897efbba8b101cd807e641b162db1175f9723cf3f2bd3c874eb877d2ace8186816c8495e987342d4a296ecd2d3c7b0cb7cd674e6b34cd334cf5cb52ad33f483a8ec141f8336f28ef6e487646ba9220118ab44ff6d345f7fe4979e46cbeba3beda96f77a7033d3089302f545d66ed44af7da1bfe6b56a2e3f4af4f58b82e5b16f683e05e318ec437a509c1224faac690d5dd2a40163c9004644817104a52d0151eb920b3626afa7bb7b9eb600fcc69cec9fe913cc69096eef845c5481ab0f8a9e23238c8c98c215a0b963b0e54c972f9a727c3864c1c14a4e3d6a9202cc462f63f2a4872c564fe4563d72bca88fdf368b7de3cf485cb3c6a310af20fdfac6812e3ea0e63b4c2189ee6e66e66eeeee02a442222c99976d9a629f88faad81180b06d2b76fa10232698091c48ec9b26216cc11df524cb162b4208306774350d82f2e167e283a3f8744489041c0168f0012cc89a542234eac60a500e3030cab06df0e76c1a30716191db800e6c6061e3c0c41619770b1f043edfc0d861d08237b52e1094adca0c087cc7666846a45472d157ec009f3829ee0634764e2f0dd8501544aad8248b4226594524619a39431462965940c26157ee4f2cd009ba56f20dfe03e51648c87c97237eeeeeeee2ac1b36594328ad82d1f3ebe88986f1fb5943925f8e3855da5a574c1d2def50c6eed6bcb946f6f2b7dd43e1c8392244544f09c06f2faa7bad1dc01bb1cbcb0ab18451fe94b4a44a0f97d1151f43e7e5f2e08f37cc41358920489ce10e629cd8a2ce5886df042a642855ddfecdaa5260b649128e99f6d71abbb4c7747f9c21053be9052266a4322a32dbad4f2ebebd83a5d9fd249b544f852cbf224818484848484848484848484848484848484848484848484848484848484848484848484d48ce3041eec50ca51c251ea408903a595920ea51c4a3b7828e550c2a1a452baa16443e94689872bdd28794a364a29a54ec93fa54e8953da9434a50f54d29432a5aa047ea0549530a50f749430251d10944000008ea28e7252ac66dac675291befc6c60d158e1c3a561c748093e3c18ea49c249ca40e9238485a25e948ca91b48347528e241c49aaa41b4936926e927878d24d92976493944aea92fc4bea92b8a42d494bfac0242d294baa49e0074935094bfa4027094bd2012109048903078d3bca49b19a691bd7a56cbc1b1b37543872e85871d001ce0e1e50555c52cb0e0f72703ae060e59f07f1a8ca74825ae9c8814375e303737aa94a3cba61e3c6b3013fc039a251bd6493ea68d4b7731fe87470842d4571980e081cbc90224f32c855b4231000b0aa501d0040c7675a3ed3b23c5b0072482d0b64478c2e1c4e68d9c2d2394eaac5cbff9669a7297829acbe9d6563dff647afa0c71c775729a34f5965a5588d71c70dbc186394d16594524a29a5941c67ad555218748cdddd314a1ee28fe086fcadb46d8f87f99c46b4677fd2f30ca260e3b27dd68919e12a577cfb939e6f3005f90cee56bf90bfeeb881577dce30f39aed30e3655e3317aabecd6a7fa279c8f52f7d0a347ef6c954d4a760e3db677ff6c5ef16c813763d0a217c0af4db27437d0adcb74b97ebdb737d7fcb11d6cb131436cae5fa211baf798c43dc6b249cf0fd0485107e887ee6fd24f321fa9a6f7784023c5008e17979fa6b70b7073bc5c2f6a1d599148aadb60fb787bb4becd20bed4a2925d7ea79ab953b8bd5f3bbe05208737f1ef9ce23444a4c18d9255e68d29969bbf3eb4ba4c42ef1d2b5cec82e6d1bcbf84493e519db2e908edb76b5ddcdba47689081d4186374c6bae9eedce5da7dbde5e9eeeededddd541645c769a908e244df076d385553a9ee48f60c765d576936b52dc5b1e4ee568833bf5e53a96d79dab70d87a60f893e8c5e85c8f2acdf570b76f82d7af398ef8e08f89a6fdcc56f5de6b708c66fd2cc6f9463618931c66c1e7d2e10cd23485ffa7e0af237d73ea347c1e637df2807f5db7e80c5db97104858474d6a9a36358d6a9ac69aa6695aed2015125979cde3b72f21c87cf6d5cec3eadc7542d253365d488d7491a0cdc62b091c1846af5ebb211a48c594dfc05d1e4d4a29350fe52641a1eaed42d257fbc2da212152e2777bc8ae01d5bb31d7c0307a16833afbd8c3f600d137f8618c1bd32ab627607086194a4b0891f482560854d370f13460810d2540828624c838b5d8575f6ab02dd750002b682cbd66a8e10556768b45b30230698879a2082ed48a5713bb4b35d020c3151964508694010a6490a2450da52f5b88a0c5ec458dd3cb0c1e7080418ad6ba171f069c340bf31bccbd088e2010175e0563652211e2d7b3cabe903ff36acaab6f5752bead14c824ee609863a07fb60fd0914b7ddb07a82ebfa1eccbeae755c786623814bfbad72c1f2c42d5b90a4acf6916e68fd5ea39392ad556c780a0bcd0c39ce87cf5daac0a56c7a9ce5fc1f52f37a4f91ebf5fa69c796f9f6d001842796f160af1eb91eaede3ecc2f1cab22ccb3ed64cca9ecd524a394435625963dc1d7682b9673333f310b5d65a3f327f8d84f4389d5c2e970b2df95cd9e794324e4aa9638f51be41b7646e292577cb0ed243c41e97cb15825665ee186316dbb66d1bb6310b401808f7cac84d5baabaa85b08d2413ea839094a29a509a006e8baaeeb3eced979edc34ee9e73246c9489aa66955f332e7cb0efac763eed9cc72aaa610236f550fa5022a5824026f55cf9c79ee019800a1fc16435fe0e5f745c5d1873c3e36463921616509ae40557c4ff5b183b07f2b79400667082925f0d66b8cec45c8ffbb710724b60886fe71e39c3d4027cd0b42f1a4634b31acdb39f62c688cd54a8e326af4929452ca18a79452cae933c829e79c333e6dda9cd1638cd4f78b4e69a4d1877a31c41833780c8b31cec9c31a9c222d04d3d777fa3a465d7b21cc89d643bae104c3157e522f9e46df233eae5862cd0a1f9d1b1472b2608e9e821c5830472194ff0573f4da6331c6182598e81f9f6314400a3cf68eab55adb15d4a29a594313a41e79c733291d36bf0a2534a299d18a5734ad99413449d2d243d002fd4e48ae63d1fae184eb40294ea550333b048043cadcc8d6eb46acf87aa979feac31b8f79e6b5677a8819d1e6f4503660bdf8095ed94de3a3f3b73e3f137c5cb1c49a169497424eb6ccdffcdc1798a21fe2c7400e6c992b5156583047ad055dce1eda44d5fb76115830472d06a1acafde0c2a5c54c0450b54f5ecdb56fd5c12881958d0c20e49ad2211f0b4d88d6eb4b64804ddaa6ea480167bf61929a055a104a1841dca92b81377aa43094249e6352aa9ce20145604daf9b23678218a2b32c0e2072e5ed0dad6129da02949071d9678724119ad6dad12af63b8703df5eee7566d3cbc7861cfef8b8ba395dc70e5f7f5fa8ad5007e0a0a2005a1ce834b3dc79f527fb24b9f423f0aace617c89321fa1d9d9f7efc134461d7acd1c23ef6833aaab16d128c31c638e79c534ad9133ae9f9f6b85a7809bc95ee3e83b71e7d84b959bc9432522b728ce1498f73ce39a59c734e3aa794513019fdbe5e59fee7f715059aef428dcdfeea70d5e7274133a1fcaac64b09668ceb25900fe96e74e9ee0e32bc10a318ed88507057761a618cda7bf5910b3d2ff3d173a29a0f857c6ca22dfaea6c51020109699fd85d5ebaaaa6f1e18f97fe82c75a4909032a2f5d25998afd76cc78ddf2e7fbf62367b1b1bfd0e3f58232dfaeb2801451cea106c35380f6c909a72d4539a504a35a289de99325638f143262792997a0869858e414717a947388728c514e27aba7324aa193d3858c323a6d14a3948cda488aa81aacbca2a440236fb001064623054fa164b018c15318eae5a4876ae12a4e3e502d0ba555f18315d4a36b263b73c5056b6608ab2e976b089bdad25c2e9a78415b6a82c54113185b9cb0e64a8bd2124a6891c20957c50f5500c135ad0450c50f56ac807a70fc5005103d729764e428e4c6c80b0b84ecd346051253f6c989ca00373485e144c514b5b4105b4c10b5f0d034e22e97ebbfcc2386228ca279f4530ae6a17e29fb8d343f9de010bf04bfb969db67a76f2c67dcaebb22fb43b6fdca21f313e9bedb916ba76d0a325e539c19f39aa24972936d7bcb913f8cecfc8f6e3622830634e3b1ef2b8a31ff9187061e7b5cfee4a3807d0a363a1beef8b905c2ccdeeceda98e04c9cc1c105950f97d6511c387ac1efd531404c66a42f3fb6a2af36108dc0da1dd11f9ae549f1fe6f50b62fa76ac0f88f026e839ac95196f7a0afc217f5cc5efb681b631a5317a20bff9b611751ebf5d1e14fa6bf7852b7c177a6085df9cbd79a2a38071654d88c114f8ab73becdea7573e99d734702900e0c358f4d531a0c89beabc7116a500c6aedc3915e5f4d585e7af5ceb56ff3ee3302e4b50de40090d7aa4b0f8adc0dd136306cfe2dd47ca87adcb60ff35d20424e80bc067200c813cd87b63b22bd569e6230f1314373a5007400b2e18a3161bc7c58917e5f5764b9e2ca6fbfaf2ba83c78811afc10b25eb689b1a8670f8a6a9d1e3f84cc40d5be8aea1c9d17992721477105677a495619236aaac00c57a13abcc83cfd867976ef45c6cb8b8c122f32497c5123032cdc6358a4f97d6551f4ecfb01152ea7342f7f5f4e689e433893e54c9897173148d1840b0c175ebe38c5c0cc19239e2beb94744e3aa764344e7489936360e5a1b0edd138e6743a5dcec9ccd3190c251832e801e6bc0a0ab1cb1762afec95cb01e58518b640d887f062658c2f6384d9c144d31856c67081755d8573440a4d07c0160f8b5f285ed8f2fcbd5a49175668fa045d87892a46d30ff5bf204138c30b6be5c2e8929d72cdf218f46a5d357bdc7e5825e749e95517e40699deccb10f9e3b631c9a1fe39c397e68b610db6e906ea6ec2348374bf62163b63c2be7accbb3cd05f3c8c2715ce598fcd0fceee6d25d7bdc4bc9d42b2839c61895c418634cd22c56d189cd3aa7a7e2b88ab1947276b78cdc3ab06a0fd0ca3d0f6a55fb3418653bd63d29dd2d54eeee86ccfc758c34a3ae6ad6aa569a35056ba5d473af594d414ac12dfb56fba177c4e6a963ab4a316fd521d087135c55c6581062d5dd58a471c6181b94cdea2cdbfa94714a192918dbeaac0c4f2cea3dfa675b944906a7a7a9ed8a91b76e7c9de586a9e4bc72e3db663725a07153021aaecd431be740d7e1bcf30e0c3be7401d2329ce53200bc788e7813d9a25797f5f48739b94908d6bfb9c0d91c599beaf3947e4e6d3e91deaf323e2cda2be7dd4b50ccc5961209ce10515a9aa550ea5946298d7ca5c19a35bd735b89c55f49e2248e8dedc94800696666d7477f7302208677861cf47ef079090e8047253b6b77748f3f2b04b66274d9ac557585bab74b1ff86fbb4402e17c74beed8a94bdf9f764a1dc963972ea56cab136eb702e79d13b536e5366e034259619f687160d2893b5ec1844413130a52c04e407d7102aabed23c653e6831031e8ef0a10b1acca05935cc88f104154a5071c5f08117276498be711233defec61d9c32115c6d4fdeaa59ecfc1bd65c53b4bb9b99d90b6fbf7fbfe3ad6e1ad779f7c54f89c6ad13cfee24fdb3516859225daf9f8e81e94dfaa748b3c1183ffd84a12e365e3638fa398d9a63ce4ae53fda674e21e4e71a1fae970c8ba67543701cd0b9e74a3af73a00e3f5c76d12932c90ec6713ef39f525f1c7c6b5e9214fe12ae675033590529082148cacf8e381d326c916defe3e7fe72967efe93d395d92a2ce5355553bf5c3561a382cebe097c907357ef5fb32638667daf97d9dd164460f3f7e1a939386d09e11bbb0a01f42d6f056eee3f7b5c6d2dbf87da151f321eb8827ae7d38b07a2176997d982f4e4858b474b1f2cc4753aab00a6cb47a55fb482671c79b99bf2873c4116ac0d0654b6bfa7625784d5c0163c6122edc50458b82456270268b110da60043250032cc004c173066d0c04c76e5c35dcac00e5faca881cb0f50695a6948610475c31a327cc97af890f5632891d4021a2dbc800a975604c375e2e11b0cf76988264680439197336560d10ad78c950f37aa032f70ad2103cd08d42cb54276b1e04336d2001033e80205358c91430bad90a7ecf021572192a204126a9881e20456ecd00a59cb0a3ee42e03b8410b5c0001441a3b9ca015f297e72aaf822712028632beb0b246193ef8d0e232529009838a09c44859d36ae283133538411060b0c0458b6d60618a19a44009c1839516bb0af1a795d29041872b63a048d3e2f0082d2dc0400b23c0c0a2c5327831858b2e4bd4d0428b594f5452104519589841d3627efaa0ce76f0ba15081d56467c90e3abf801173565346184154a5872503a830563c81c29eda0839830b2a05507881083042bd86246194070a1a10b2c34c052430d3f6429b8212ae5e58635baca94e58a95b30cf0cb94c5cad75fa62c543eec51da38b8010e5797273a07553c16a200963f76a9a7089220117ad8c763567b6fea3b15a63ae55fbc22be601096b9f4d4b73439aa68e62742f11671171dfb78be340b7c4665327e9dc5d8310c55e5d333bf512e4241d133318a7a5cd262f4b4553cbb2ccc970f239a32938585dc4f848a3b943ae61816a122e60d6218889379634e91032354b3682ce3449dc6a8a79e69e1558fbe69314c7c6a16f5a825fe4428dea1be5a791eef84953a169de20dd72c1a9d9e9e74221407f1626318fb63e3b43b0f6d74540f79bccd87ed4ef5ed8bcbaa3eaaa7beea9dcd57c7faab6f1917bdfd59a38f2eebc4248661dbc428867598a4a0d05ce29aa62aebd12b297fac971c22d9c598674fc5e5fcc49f9d716fa887abb98a5227de607df3addebf45ae39483ff5f5ed9cfe3cc8b1192679147974d6ac7db4cb2fae8fd6f1b11b0c319fedd22be83e6b834ffc73a8f7873de6d237ece34a2bc8cb437d97fa654e0e4bfadc28866d4b50c73fa7e5479f40037554c5a772209d13a1081215a76d99a75c366b769f4eb336956a8ba8df6e88aaf39ac50ce5a24e91cabec864214385cc94df1719a30fbd5f35b440a345d4f7abc518affdbeb480925a3879a9538b2d56986a2125febeb438d2a208680c9a2b612df31a13e635c6e9f735e635a6cb6b4c10af3156240fdbea44d93edec50bb7e967bf74d6c2736b0c952fc241aab7338083cc2e9a5ef3d083cfb151fee12807c19c0beb0c593ae2f77337028f226ffa86a47ed817d7c7cc79ea6108dfbe9185aa63ae81492abf062a11400abc0a3ef1df8ec8001e855db3c64f2221f8dc3e713e4981bee643f55108e135902b03887679b0094ec0ebc72f910c41d2acf60dc17bfbe2e2687aa45f58c190089b1454c2489ad5430c86c5b63f1ce3aa3e4a974ebcc698e035c685355e59d820065dbcb2109345989a85970f6b16493c7bcdb2e0f2ec5964c1c20c165d3c3bc75890f9ed2110c33a94fe39216e60837091083eae0e5f67297ca4c2d0c6e1f090f518681f270bc45b25d1f1f1511f2055a3936f8779d61a985191b275b965493f21fe78bb53c4948b3ecae9dfcf2954a47891f2724111541fb772e0985445e7cdc7ad29c20d2f36bcf4dc108004eff3dd61b7f976777a922471727212a108922a5c6769b6d50959b28b8b4e58330bb53749823ab771cfd7d76f7cdca50fb02506ad322c8ab5b46c7c372ce5e46d751fb7ae6cdc497dabb862f2922c0f1542fc17b43becdbb7445a5eba1739e8a5f70951ccb23606b5652eb12a7b2818ae62478432ef4ee6db97dd74e0a97fcdea047496ac92282fd4f9d8c3abb8de0ccaf61e58cf292f2c9ab040c262082b2f2c6c78c6c2e8594c9ad5ef4b0c99aea28a69621feb411d8618a40fb96f315bbefb7d89b9c2b1ef98f1da37766f37e4031fbcdf5fff76212dd8ba11b0806d9110357373f39a19909e7a5d23ba2a4657610e34c593d5a9634fd8e56ecd71ae7dd9c77d1b76c2d76f487ef54c529f4b3a1226004a27524a09ea44e90297fab60a2afffdbec24cd98c853499cb86a752aedaba46d4098c439a188e620837ea25362586a3f64979fb2469967425cd92de5cfb845ca7e3e5f509cd12c2e15cb37a7ae7dba56c78e6363c45a57d6ef84d0c9edbd8708984e873f8e64881363ed9ac14c85648602c2ab44f4aeb88ac74156e7c476c8029af9dea13baf1540a0c7178cadb371c2923388452aef2da1949b9cab76bc0f4ce831a87ca6df80d1b2aff7cb078365c65c38554de0015b8cdba0186d5866f6724e536c0f006c439d2f9f40e149adef9f4546764821d287f9000d42cf679458733893f3a40d93b5303f282c7322c8ff4ad42cd879c65caab0a342f89269194777e42fb2869d6b7c4e69bc00dae93b4cf043986e5918e24dd532eb9e8ddf685f2b50f8a4ae8ebb33f3a5c16d1f1e1368bde681b1ab6eaab13b2eb31df36a77f523f71521d1f1d560323ab773023395c863993f8a3ea1dcc310c1bc2f5e14285eb8589156a3ec6ee86c4e8fc31f47e6ecc19792b752535232542bd7a1211224ef5ec4cc6c26b4a99d7942c4d99eb6503525d533d7b5d118310473d34ad10467486a8a78204453b83991cc278a96be4d09483142f383461eea47fb8853913cc31802569a204f3254e3067823906300efbade3b20fc80b5ef4ba6a9fb0bebc70bdacda4748f3d50dc79d9198814b6f54cdcab0daac13da271c8a980fa900c50993229877d9279b5541b6d291c0581c49fb545048b3302240cdc21c49f7795d67a43d73ee136acf3250cbb2ce88060a7546b206445f55d7344d6b00d61dd11ceb8c64ae1d0185a2578f9e39ed8c44b0ca66b126d0acf508fe681646245e49794ffc498118e69b0d9705e12a2ed5b8b44447f19da6a96831697ae9062f8c4b68780c86abef4a48b542c06b5a1d1897bef825ee2c7190484518971a05de8eb8e4d41e9fd6a8220b314c10f5455113adf6f8252ec5a51491d637bed89c96246116e22b33bc90a7c069b78117ee1312929e6ea3c5d56a9f1f933061c0b824ee9c0005f5e509e8c37d8a3bf56909b561db6a96d56febee1e5efd2a0f1778bf3ccbd3bea305afc61d1ecb7303030fa01f3568868d5a1ad8d45df2f4c4adcffa4867a0ee5ec59f2514f325f18700bbd38e81a10d7de20f7b3ae9244cff6e49b35a059e3f01c558ab3b41ab501578ec7a82f9507d5e36d23cae56213bf5ccab968143f33557a269e0924c09efa8a7aee1b54b57d23e4a1608e60d810d22c11e3aed3beb03db304ec628b12e463a3f64d7ec4698cee0d643461e5878600f6e0daca06b81645da8eb041e14159a7584976477300946907e4f98430675bcf8c32c1cf1e0b1c5eb14ba1df000e980e5e1e88065b5cfee483432b73926599ef6754ab261be9d8fa6b88cb60d4ce294c4895d2e17bbd855c5f3c2c308c3d46507a62e253062226289898b0d98b87851051313172598b818c1c4250b13971e98b84c61e2220393116730190106164d4c462031199185c9882b4c46e4c064840c4c45a8c154040d988af082a908314c45383115810453113c30156102a6228a98b6a019c3b4650aa62d4b4c5bb8306dd981690b0a9888508389882f9888786222c289e98818988e28fa65ea8286a9cb992e65b47c7df2a0bc2d78ac3c29bf142bca63d0c9f058cd22922cbdf8e3b1da4963144a8b1e8627a5593a76a04e940a2a467ecc8a3fccc2eeb4873f3c826f006cd1b2fcbec8f0f21c6e4ff40b6d6a9f2ccbab06ae6fe7a26d4c6f4f5b19f6905639f3512cbfd5e51a5338fc20ad225fc584b73995f2147f4e8837507852a8137da25071873ac59d31bc904aa152e8144a6506209e6978e62bcf2dc6765aec6c658168ce1bfbb041e80ceca39d9db12c90eaec371b84d2b03eda17080f1b848229d4d7e24f10e1cdd3cfc041a81496f23dc3b76fdac7451f1bb14b0a07e111ac8ff6860105df2e7b5d4e0ba47a3fb567b43ced3d5a6c4fd2b53c9da969ea5a9ed6b23ced845d3d4950b049b36ed871b02266a74efdc33b38d1a731fd53d4640cf1edb48c99281abed1b4cfbec890f2edc1f72b4acdb7632ecca87f62ab5d46f6399301f19dfdd0148696ae8d37e666669692594a0eab6cd6e49a10c99e3a5127ea449da853509d201877893a51274f0716ea9a6b1e0aa08562b240707c1015bc7a778f90dab60f176a495d82b957894ca0a60a0f464ae480031508888087355ed0c04a123bb4da9934c1e13a1d7313a8676014ea51300c73a256add5d92b750c0ae6b36238d2b7c592a0b74e50814993f85381dd698f82420c1e25f0b89dc8436e48e0f5681633818282828262e2aa6a6c5a84f8963f5964596a6dfce9a30522bf13f09df2bc4f7ddce2af9f525a1d48823fbe9e24bcb047be939edfb6a3da64ebf9cd3b8e818d94f08e70ccf0526e73c36db8064e9041d60dd03d85f5c890039df43cfd84a811ea996f5a043cdf0886b287cb3210e847b3b29e66b5f7b31b427d4620e536a0e711b0711cf66dddf8465d2e0218a033225f624f08b03ced58370273dd1d896bd61060593dbda6d03f7b96a77f78caf9c66b672ced7c64935aa894073593f893027b7a7a5847dd7ca485eb9b1b1aaab7f8eed9ba62e7962fb6c2ced9a3e2f8eb270002ba27d4e91b1278618feab9474f0fd40cdbae89edbbf41b6dbeff05674c79fe52bfd126ec91f239ee76cb41b25fc59f26315c3118b43ced4ddaa93df220c2eb0f772949fb92f6a0229b8771657a503731a37d93262fdca5a0a5a5a5a5a5202c872c4e86e7f5f460f5f460ed7a18de62f1dcc9f0562a30080fc3a39c0c8f02b380593c7a648617d2127cfbd6135588bed4ac7d04ec4e3b10bfe0663c9631ca183d0c2faccb41b2ea8bdd947006186f6a5920fbc4b7475915a02c90c82ebc2fcfb73bed1dbfd4330c5e08f4dd0ec44162e4bc3c833859bc70d3b00add69a2b70a6b7c044140e3d1238c0a2b0c96b71223724b96d75b0afd0d3e91fec407fbd0ea832c0f1f89200296c53ea344c0f2307744784a09022d0f7b04b9f921d0f38642f61b0c9cd8917dc128ebbcce204ee418bf9577507b91f69e76a066ef4ed34bc028ed31ca8660734a3297449f2094f628a7e40836540bdbea4c5515794616a4d911cacdcb63d224c912762550887240b19a221c1316f3056b6b977a6323a4a863e9a8681e35156d4b6798f172be7c9db1e5e5eae52b8da397f1656c49a733d6254cda47bec6bc8c26acb3a3c1895e1df34db256de8a25a594928de28e8cf24561c71c03b1ad07cfbf27fe6c133514f144d3165658b1a5251d48ba4b67495f25c131611d730c8ce24910c704300a3b58e30e510b0317c74d09376872da220a84d239e7442d1b276add3851eb8613b57038514b8713b5885a1c7871877d0371946c298fa8a572a2957390e3022fa70a16d7f1adb8f0c2554f64f9e0a9be20a02d3c1b5f9258a40bcffb98c4255fbc54f735893bec1e78e16d50d8f542992ead15a409aab4829861aadc2c35a97162d768b38b95f0ba86c79e8138ed6ca481380dba8af83715a8e4b41f1b5045d3a5268d67e72d459b163558f01c7f5f6abeb40fceb3735397676727767ea22d3b2391fbb66f5b9be4b8bfd037acd5a7d77984c71a362a9238b04babc19513289181218a30aa6061af95ab44696d23c48e34a614eeb8438d5982e85a20d2c3e9dab1038da929b13d599d904255e12a19ce6aaec435cd33104a14ce31d73487122508259c631e65f31b5eab13b59c9a9c20c4a97399b90c5729e91bcebae69c9b8045094289e61b87f9b6ea7218435d013ae361ae3913de4681c44e110371d637276a69986fae04f30d03358fb28138ebd56ddcc61954120503abdb78a67d361fe7516ef8b6f90d8f00e7d8e637dc05ce310fea0ec0784e0b047be9d488cd48cc65d4149c2e3cfe6de1ac8d9bb0b94de7dce626709d73bead905d498a8a3cb7710cb3f1f193f7d97c9b0b1e635990adf07625700b739c751b276aa53e1b104a1b3994adfbb42f0dce42c1d9ce9568def97ad7790a84c266407e8a3b5276ec1477a44764ffc96a79da6f3c738dfb80e2ce521c250b561c259b835edcd95d8a2ee9599d5f7f4714db468c53cfb2af03b53219541047662e4125154a50246ad52ffb7a70a46b4ed402ca32af2ea5c71dea1584b231c707cf5b1ee937cb236ba189a8b4ad55953d0c1922d2001000a314002020140c074402a148242052a5617c14000b849a3e684c1d0c444914c3288a4186186208030000000851608468860a0427d065019a659959092aa79ea4f7b88d1e3c3e384241955b8aa0358bb5825a0f05a27dd06606298198f91789c2148923503d578c6c66acc48f48fb78f95f12090ba577c8214f0ce3282d4ee790920d5528f5b8eaff98ff7e619c3397b2bee74e35d468b88cd817c777626948217e6b61739cceb078d31954ed75076d10412fc9554bea5010ea51c90f732f954f596f6499122d2c1591f5a0faba015a3e80d89306a924c9897871c585c6afa48e6be256cc116a230ae6c805c5111507e4957901b8d02c8875eade44e4ab917dac76c941d53de24969f369b7a049b89e675fe1917b3862d7af34def3bd7441e94f39f3d9ea27bcbd5e5132d6a3cec538f7d755948629902ff732311504dac1d92d11d6c89873def558353fe09a864eea9a13089bb4a656ab047cfa22663f0a9606ed3c4595ad1070308232a8657e68626ca042b9541c57f7918208a45f43d37aefa364fd68c1583454352ca7214e78200736ae02f1a34d12e47dcdc504097f3e17129f592804c9d38bb318cdc4a158e3d92b9a417b46911136052aa6a805c12824ba05feb59fdc612e80caf3f7dc0776c097fc6f194d76f98b497a865b84b794421b25763cff4b4c9b3094d1166f341e41d5c67b42c83e3ae76c9cf904883139831886512d30a53cf19987ee2f866098c6cd249ed0e84874fed26c5807469c921c864b6dd304e7c20e982c3648e7c4682bb0309dad992fcf26f5a97b66621d306ee17adc35fc0eb18fd23777d89557f355636c33f1360734703d2a43655fb3c2f13755a6661cff94d5807a9b63704b3f6468d7f63371a748515c47b341fa40b85780c603a76deb6239d2ab97bbc42632ace737a28429d6bb3d05ff2096d73d3b4f703f9c8af9cc446d20ac2b04530dd3d62751880c2d6cceb504e6c21b3e279030e7b809ded80e88629ed37eb1eef6e0dced4511daa68551b670907011b28279420826a42114ca5aa34abcc67a3d4e973c8803ef84cd299a08009558de978862c2090f652118069201b220df4416e9af8b704d8729f31a3019a11514b42c58439dff296ad9a059a41c620fb24095e140d87d1a713e467a61bfcac219511fc87d2aa691ea2ac23472bdfb37b378f6913e2f7c3a7b73f4b6861aacf5817418fa1ac4b54fde0fef8c7b674a25cf7d156fe974e129cde0bfd330dfaec531ab63c22150cbc4f51075fd3703141ab3039e8da29d80884838fc2893195ce1d687e372462e029b5a5ed2aae8c6bd506512bd038cce3fabe8ad791297e3240b5c51bf64810bc9742db5ab54cf869cbb2db09d85260bc36d49a45b3194804818270f1670685320e2ea8d6dbcb0e918d9a237c8b76354762564049409bd13c49d195ce8234e1f8d2fa4a3cb88df63736291e2c6f40a4c5c859324e5bf7f03bcb5006323610642433aa79a1953c0bb5722f3d69c4700082ae59d275900841661af2ef28722d26437ef219c244958ddebbd089994489243e485dda2a0f6cb24d5ed958dd31045e8aff7bf4e44a1022e952a90227e13c64cb86d7b6b526bb8ca44efe0006898316fd5942abb8231cd5a95382633f7799de173b4b7a3e79577ca49936fb41cad459fcebfd1ad28c20c6dbaf5523622fcc6efc859cd1fa8e91c756e53659f2f97829fc21a0dd1e57fc9661eeb182ecf8c4131bce17d960ea7775ccaf72ee629efb8027291e66364379d3ec0a730d535808bbbc3df8bef6bd4a0693aca43212ac7de109996df8758dac2ef25b27332136fe03f0bbdf5c5cb88b362af70525570247a0a5768de865fbf0fc64bad328291639d666b5972c3244dcf694fc8899ce2a9b4416edbebb72a8ccb7b876e11fa915ff8953ff9aa6111600688f82ff9d55faa03d1db488a5152a55444c5ac6ce5aa9051881457c95ec38107619d2d9f922a273d7e7e00215e9ab84cd62b521538839472bd20339b688dedc3461e8390d1006a13f863b43fdc70264ae5b5a2b667e97ba9f08575f6c1072d24e64e83e050d30607ca7b4dca9c3a70475d4b5d4832547e0ad7ec71b8de33c5f4707aa751480f22b61bbd714421d4c045a741115c8d430d12959470a2cc41263f0ec154b5041a99d82b85ee2f3629b0f3d09365390d441cc5ad0867b2738925a5c199fe0c6aca602dd0fc9a1d714178507c47a8cd519b1f6cf6e3a61a4e1b2dafd9eb4d87c40572fed60a82dad30a902eddcf8597a49d599324cea0f43c452fd8863995ce878e53564a194381f5ee6c85cdab069ad1716d353a80e75ef80cf93844ac422538c80841e9edc2c6dfcaf57ec7082bfb2bfb42f1e6a0233c3b590b1172fe9fb6671d52bc5bb23c84f4d973ec8a16d8715a43cf224ca6308bef46df0b7d0eff7115a51d2c6998c73cd78ee4f22fe7ab40df9f13138f9c5fdf4b8d31800ab6ce2906823a27c6fc1878ebc2f9993608a33a7430f7aedb1dbde582981e8cc92050e3a5b7396a051b695a165e9f96543eddd03d9bb56a59fb15f89631837c4a52e9f00e9a5a575328698a5e85d0dc5dbf5ef0f5dc0c71a3ae2da10ef5c1e648b8136d00f4afc3ded23c3e79bd08accdd820d0f8763015f4a87cc06045a576cca7a36f2d68f9b6123de55f48872ac7539ff099b797ac11cff06cf51e1d2bee2c8f7d69c4fe378801ebe85b5900e16873d06fe8ecf925a571cbd4a0d84946f6c4cc9ed2f810e6f3391ea52e7d3e46c57c0face3a78919c47931926c49ee475006d942384e060e7aaae1f160218d158b87121e9f220721625a4b1bd3e0c7dd6cb91f8e6d6355a34732e377c60162db34775e000de3fa2e3110ea8c19a954ab288fa73c1cfa88d7d09fe875c09899584f0022ee60e4730fa41f2242539230dfe534147a4d1f69f8ea62139f04412d97746afaa926c16710d397282ef594dad6e0b7404cf2ac537b80ce7956746f3223f0204580e1cea86de8dc138ff4a1658e270399a18d8090605d5bbea123037f50f7605689d6bc0511bc706a7e98782a303686f80f0f8d840d3a7475afd65f63c360f382f7678d43c21e43c838ebb3d7d9534847ed40b5d6ac47b569c236a9d47314fde6df551ca75376641994ca4c80296f80bd87092bb772761e83dfb01d7e7c106e00595259cb8fbc9f93f35eef14f3e1d9ff9510b2b1d997f4787b359c406ea3dddb69aa96342dcccdf71a16c1f93ef11ccf8e2eb9bf68b2cf8d9db244858d2bf1682a1cefbe6619754b2c569685468a806e51a3f6d53b20d8d3b5a1cf41ce41073be30882f1de743237c92199dd3752f6a77255a328ec1e68250f64cd2977eb63194664b85d3c54da4ef84888328fed18bd4ccfa45c1705254df397d5b2e98326fa6f20f0249ffc0cc74442622f45a206027567d62caf9c8295701959e2f33c918d4c31593330b302e035301522bb3c89098053e1fc739c85c72bcd80e9f4f4fd18897079d2721e8a72497b7ddeba4056d17462479c2187f90ba3c29dd885405cdbe07e2d02c55a87369bab705c82bf3bb01737a7b6eabea46ca24094c7e3fe9d3f7c7ae274de61cec1dfd065e0b80097ecac9ab83f294e016edea242c6ee8bc058115d9003ea3312544e954c3a16c31f3c227f3ce7b271fed987818fec0106aae38d9a2aae8b875be0b0b236e62d35e004fd05da17ae87389c1306c5e424232b42eebed84f926b34884eed9d9d5a388527fb9a8b40f9e3f98f0834400375c8a830408bb448d23a93430bd0e8b8bf046f4baf0e68e009d16fb25fd958ac174c0f1ae174ead6f18096a956662a3f29ab59a8b42d0c3f3cd5ed79c4b72dcb1873eeb2c1c4a1c4588194a366a96cda89cbbc1e0a7b8a94a1fe8e6c4404bcb9933f618790dd5e22a475725d8271abfc4a8a37a2a6422333beacedd2b78d4d63f4e76a3be43369ae3459738e68976ee56da00275b54a4c1b232e619210821296592068fcfe35ae6e111f8bad81943a2f4512c1a6089db4d783fcda3066c6f625d012be001cfcc63883e7a2623f9f55374e20b403877aeab1ed6cc26fd3cc4c3107e65c38ca0d5224ed987adad76db0b013e8459a556dcd06eae97b466225fa5ff23630023a42500138e131f5534be7233fb5dcfedc3828bedea57b8bb084e13a904b8c197dc57b402abe5b044999bc2f418fef033939e43a491c17ac7e02d21cc13cad18483c54d809851fc1f2d35f80018f5e71dd86996a54e0ba633e1709fba94989f50e41fe48b7a9a5fa8a1c847fcf8ab15f329590ef22d0550e77aa63c86d3619875592f9b1187dbfa1d253945b09027200897ed796829725e88076e83adf9548f837b622403cb050658e9858e2a2643015a0dbec3762864a9e27e070804394a9eb17536d8a3341419d130e79a6d036596b9aeef804566228472f5f92bfedaf344e6275e6f3f262d4623a28bf9c46ad88dd3ccaa2a0de39f2ddf17c3e3e526f2a880cb927d091a15f463813d4e0460c591fff1bb2538cf6fcc4d57e09943c4ae59ff8be82916dccb19755f07a0f7a4e456e66158c4cb5504a3cd06c70564282b112686faed341e89d06108bdf0e00c2db25cb26c96faf670f9f0212fd4a67ec6d6faff7e530c50c35026c2d301039cf84c12762e6121c889a617a3cbc9e1257661cea3456c8d26cfa5ca93a9862c4b3b05af405a0a361d44a978167533f8b20ea52911c5218bd6178e3efda251516ea81fa147bef2dd4a1203cf9e8983105d9350945f9507a21cb0d235cc212c5eb1048d71cec3dec488268bbd596b6286864987cf87ad4c26629a476552868484b3f9453d5e4161d426681a7f1ae4b3477f147c023eedddb2d34a3e6b2c22f072c49111382c2caf4bfafca22372f980d11b1a8411d8f33424124eb191668c07c173dee9a5e40e9e87ffabae8920158b69731d229f7778f9a0bdc78720846fc5be4d6394dc89c85059a6e87046074d594ef1109d4be1a23a0bfc1bc6226daee1b54a0b0770c7bf9d714ec666c47b355e755f4ca75da63b143d1fe864acd62ff84639d4151bf30a2ee25750df5795d27f67f9655b89e8532cb5ad795bd0368836e7fe9a5530c0906c29ad4b9f13fb9ddd9bb1184d079a0391ff3479c8b5fa7b4350b9f9f88335523a3fa3f66ebe6fe7d9b54cdb68fe2abb665b50b99972248bfa778fcff5b1113b53faafedbce3c1ac4fbfeb64292f4a466a0ace435f62bd91b2ad2892790262cf01d9253815244b5c97547359ac6630e0d602e35b2ebc671be99c86b6a3ecc550f87774ed5c92345fa9eefcdebb9dd615629e5eddefcaac03f0c91b522790dcf83e9a713eba6c1a67130d6db180b560ea535dc14f7d469dd519d3ef1c744c5ee0049aab8a65132a191800112e52e18a5766e8f8ca054753f5b03ee744a124dfb84854925cfe748a2f3d794bb1ac828d8fad4135b6243a5b77265406a4977e12c53dd62244210d784a2fb71a16fc43b4a43c306c3c838598e6d38c75dcb001070a283898c70fe19c202e55b9313bc0f68189707eaa9ea7b80753f28234ae3a3582a05eddaf5c328d2473bc69978daacd7e2a975116ace464e8cbdb0f2ae1f6d620bdc6aabd13e6a988ee5d30cfc66398ebb1be119cd8bbaeccc2ed17d2e0fb8465b50edd626d5ee9b3e678b3ef425d91f5499164e4474c3023fbd8408998b4276bdcff3878a340e09a10df8d8b5b4b4486302a28be4e5e2be211433b5c2688972df9184c199bfd85967f4d6da386d15bed2d8d4ab096d4ede79806ecca1ae27fb9001df777e9c706ce3499a3bc28c0d19927d7dbf1d71634281748e047b49a1506b7064030e3c29d4c09fb97c5cf68a19f457fdf4c808d15c2130233f63f2bcd6e515d726dd8b4333d4d7687aa816b024d02350269f0db140713d0be2d2e8802a04898d63a1b5f75b8f570637509a0c3f34becf92d9b79ee57e2564ac76b36dac60e07586fd55c6d7eb685ce0054c0153367a902149705b54987767c67fc1fa6502e30490d035d3e91a06327ccfffc770928d85aa8fef150d91d82d79b7c05eb8311b61c3d985a0a5fc0d89e9b0266a2162b23a3b0bed210feecf91a7e2d5b6ef53b93ebdb7f83122f5cddf4fca45ae718e78db7b767bafc6f63833d127f037c81a74ca00416c01748b0298a4ab77486a3a621d009272e07af78ffcbfe294ea9e287ed85f7a4740275eab81ab969f479cb66b79906f9ec506e749c256dc0b638b140daddd664817688c59b4041c76db727a645e7dce9166175d3bbb55e91125c64c1ce9b3d2993ede562667759fbddddfd9399c0767fd7d9ab00228293f3c2da5870bc44a90d2a55252b3dfc12c30996cec88fb45c05ec3d89d34845d9fd49ccc20229e10388ded8c8d6b4b3cfff2aaa78497787c55832aa66aef5cdab362e25576120aa74db04f563836e42322a773ec5287e79ff9a87cd4e1c5253ad2eef222839bb3d9aa81d1e778fbb2b7091f43f7b671582b8d6d950ec9ed212367a269aa08675598be484ca83334abb126b61ed1b6814c7cc34d157f45e8af916b598bfe8ee7246e04b452189c70aca47ff1cc90ce7496272fa17056b0a05e5809b0cbdd6d59b97a7de7f2ced24e0b8f4877fa7b868497f539ef180e45be6414ca3c30a9b13fea2cfa0b712df46d4fe113233ec509c74a71305dbd972d2d2e26a90fca5b0d9e802f21fea3acf674a5691cac86979773a3cdc67ead350de8ace013b6ad463f9342cf4c5350df68b358db456cfb81643f248a1365b0466ac09e1df2997e1d3a719710d08d78a3649f7f23b4ca452d8670be5cb4effcc214b2797b04858a930591778f1b559a9d777c3302739e91cc86f552870db6c8a464568c010a93ad31bbea29ed6ff2627bf63283a8851bdd3dfbfc9f655c9eb372e3894a9766cb1d2c61af4566bcb0065250dd66d52cb1e92817fa75b275d6fbb16f906ad42076a425edbf7e1bbbde3e0ac9f893f499a81c2f490d6ca314bceb859508b0786806634f02981aec3ab33a51405e69353371b50095159fb5435ee1020013d27895e4cc705c7f9e1af0b8beb1214a4c60730094e73c6824a2ed964d062d65dd0c9305422adf9024fc3dc5148e483ccf784a40dd55c77b46b260876eb738c05bd3972ec24feb8b50b3bbfb189738c2d3edbd4f3e13a501664ffbefaae0003a2ec55fa7082d75540b9a635656b330c6348e60dc470c96249312d8cec2a41df7e2a549cce4a1930edb9f112286d874079910f96d84d8ec06929ca8072231e96b639a11b14abf9f072b6859c47964cc569897192bda16c32cf9fe763d095325b843132ffba894045c655ac257b3bdba1237d136067b056d34e8e1049f555415e68c344db79dcf6227cc198b8e39aaf87c7093c4ce3f688aeab303c466dd394c79c8a44bec4e240fbb0fe83ab313fd3a5150890d8aa8523e1627f7d95a3cce8b1a89e6a1582543f55f5496ec946b93d17c8231bad2ac3402bcd6d0cd481df04bf4ebb596be6a6b0d857ef92d9228baa93f776b555721efd4c672f05e1b6f74e1dd29b59a6803fce1ba10a19d6e9560045f99f1f2c644c7167a7ee72f5aec805a8ecfcfa7c21deddfc83ac4dab3d777f17c998ab9d06f3d2c30c3b69ffe8de2075e15b99a1527a620d9dc3d6d09a004c1e4220c5b1345e52648ce00380e39b50462a3267f5ce3e98321bb19f42970cb1e21ad1593facc52f4360a7dfe1b1fb8b754f8cb929673a0dfef3a217acdc3b33f72febb60bbf047883c909d2a1ad4434104a05c56bca2036c0a47364d8164a0be82359d41c533c8a4f3e6fc0c7c00be435f25f47db32c3dc90cf907da2a27bc9ca883a96a5f04627adcd7e65ef597daa8d72ff9dc8e05f6c1e8c60ee7c05e1893e1c5ff343513e72a9caca49193c6cc4d1a49c33437e797781593312ceac13038ab2c00852d362e1a63951b7e1847c509c75c9fe034c346903fd1d40638da621fa43eda60efb3c2eb03c9cd131fd24e0a1d4f45c659fb59a1853d39ced91174fcb794204e0e1ed169ddb33c2a7f2328fe2f1465a7bb32186bb8cb85e97cdcad0fbe33839ed4d25275a4d9128f25cc222f396bcc4a73210a19a964dbec37c64c5de7c86fdf87e6f52f15f96c800455d55dfd78688190136f722827b35f5c133120d892ce21b57dd9a7d8e03bd2586fec9da9e7b36c9f4a6f7b822d9270b7c7ca044f7fc4726f52eb99dd42a668bad924c1119aee851865a450e85e71574a62cbbffa6cf8ad3e338845b3e329e66ec40ea01d3db849b872eff722e5e9ff010c6c994152dca10c330c6757694603f183f5a95fb129c1c086c4ae52d869a4e339eac66ac83043fdb1219e1dbfaee71cef340aeb3c2f42201cdf75728e4a1c5c47fadad01eadccaa21506b6c537b821e7029e004dffab534a1c223d80ee2b8d7e56da54168d3f1ecd1ac9e5c62d98a10c9ce1563808026f37c36138e9521697dab5d852b0997064b71f5e7aad4dfd12e825052b501ef1989c512ae190310409a430acf22c0bca64a87c063498e73f2165b085362127bba6d6f55b569962dac116ac1a0e2e90605fb6eff0c5258d1457c933d6a95db243aa14cb54142c394cbb531bbfaac5af83add77c0d83538b413543f41cd067a215877c04091bb9d9113fa71f694ddef7d4c1d590626475ea11929b9d2b5fbf941c5e664dcba9a7c8947edfc9ae56e63e9bb75ce373965b35b09a7902340a7af7576c4f03666ef10edb3a1f5482487d7ab7dc187b75e8bd7d30466d194be0a62dfa575beea7078989c1fcaf5b8db118cb013125de613fb80512900584c3862b3e90416dc7f873d51c8f316ebe30cdc343d1f4755839844b4e4433f5716592cd01070cb7a7b42ead4e4cb38ad3adbba299e3ffde2e7c05c2b35d60efc9559c9a8dcf4dcd7f83d6f1c819bd1b7661e242e8d3085c3ccc7f6e68dcfa598bbc6e57dadc63a3397b462414346fdecdeb6a73d403ecdd5f899655b0b7d4a196524897890e21f893f921675161580cf6163c05d78346e1fb8c05a7a813df72ff981cf95816b16181328ef7e0d7cc8f56ffd2ae5aed71fa09918aebf19c7ff83e344f9038c1bf0fa02765c3ea1fbc368b4b0fe92af4466832af5e2c3c4de1d57df70c517975f94887873f013e8e556b07d86ea09ee1b6105cd41853e5b15e042cf0d0cf5bc37ac2fc18b6254ac288c268a0a6892d121ef0a1c250675c7666256262ab268eb9c7fdc8a4029c0e3547664cecea2956ba1c220d9cb55e511965f2238e28f9aa674d9f8b5c28d596aba6fa6a6b9145fe96373a19980277085d8f3bc58b36b8159476edba7860b4db9f38a7a269643af788f3f10ee4110ebb78ec88d9e146cd84948d4a35bb4798c12af6b0a82b1b27b300ba86a969bda4968967e1b4994ce22ed500d8c72848eb2a01b55632511030789bf2a1ddffc10cec5a47bdf8c9775a50c821c5d86a68a4cbe2fb7ef20f6e8674091e5ac3916b8c2cb2a1a6b8c04d00f420ba7c8b84128fc07f271b9df617e374112973a93570305496ba80c447d9fcd9e3ba46878894c09b57f9c9a70fe3170617c5b8fbb073a0331125f8a2835172c8270c67a93a52af97d9b8d8950bea3e0321676825a01606f2b43d0ddaa8874b3801dd9aa165bafd7ca71178110229cdf7db3a125a95ddbb94c9dbe9120df174187c9cce040eb3914c4a603aa3352c0a238620351b84ae912aafd1460217b6bc811cbc5abeb14616d4927e761da777e204df17fc93e58e9042f4f1d2f6287d07418b8a914fa64b3946664ad0f439c5917859ee48971c413d9d65ca8fa89ebc1280262581cf819e2d78fa26615977258b121f4812e037e7d30d9aadd8b7e545554fa872dec749e0251a28f9e34a73e629ddc8c2df7ed598373b91509da0866c3a74bb3fa6df797d7bea5480d7fa807c9dc17d24e9950b78c541a2d3409c90923d1063642a1393f3f2a959e1b8eb3b7a9f10c17a00058f0a8407e61b4e5675e8385f37b8fb30a554becf46b790817e596d87409452703f92d912762dafee07c2c6a97f03c54a9ebfaccc8d275785dbc62fefa1340ce14db82f6eaed1c0fae26de7f0c7f0f6d0770bcb9e42c1942652ac337ea208884352a940ffd760d2d456b22068488df2d486fb5eb0028f1378f0c83f0ae5fe3d668f319435981c92946e4f4e9bb36d4f7fa51d6b14a27335f0ac64ccbec9f778bc1bc948b48c7bce56c6045aeb82b408e0cd09b5399b0f98f714cdc89020cb72420d37a13e6c041056fd7319c425570efba69f388f563dc7794e381b956276c0c87543f2155b1cdb8101b4ac8640e3ae9d73158ebc0e32b28f4404cee74a6ada2caf6f2e1f4eda8edc1a23563f561d4baafaa4436711a94a728cc525d394557d27059952df315e9711adfe146d82f48fd1118e3b483f5a76ea4c62d8b8df4bbd70fbd5082231e0c208c32f589c0e1692f939e8c93f0601049cc340f6fd25c4ee5d4c929d661848bace6a578dce8d28183b8e8804b27a7939e6579fcbacc586d57a2e48af2efd9ce634ff7422cd0a550ee17bba6f52216cf839ba008adfd250ba0176f4759f25eab6042577b41b5f22a514e29b5299f218fe7b0d7704475df5cd9d85ad5155a3688812df84e3670bb3e0f5b361e4fb3fe2a1b7496a4d90835f989ba29fb7063b3f5b40692a735395f1681f36b7bd5f9c9b180647f7e01ee19f78dbbaa9dd1cf6ca440fb3ecdf36ae710c8d2c0ea8dc12a6357881f6e7852b8de4e1bb3990ed042440a48ee243b8bcbaacad286886545f2cbaeee81dd9a0622f5c431923ae61d6f189c89bc5a36ee1870737f6c487483e41866ac0ecb6bad740135be7ad33452a8dac428b576998c2411c176c7f6694bf7f0674476783609f46f4f3b00138b55d0709a989fdb61c1cda714b1273e112640cb1fbc2585879e18dd1e631b632dc42940bb7bb1cbd4cd0f4c8f428b579aba6d91bbebe4bc69ae8b5c42b7bc32e6077d3d63adb1b2cf164a7a4dde4cd2f2ca2ec5aa642f78ee6410aeb0c205ed7e88ecde7730e228d6c5f263f2473f1f1a9acdecbecff1a277842f2f336834e082132194125d1097ed47ec633b1863bda49fe885687ed0b0dc6a0a0a502fdad6bc313401e0d41bd4e2609c7824c701c45657b94e974e656f5a16e88aaf96458071bba0c300fc095931556d800fb0b17e54d8c9e7323b3cb6e4712c9bef4adddec850bfad35b61fb72ff0d47768348a27c58a565f1165635395185399635014bb95274ade7d212f22f290f322a8d64578d39733dde6e09b008cde9718e8982307cf8b6468df691d6856d0fc933b741af7b914bf76dfafa48bfd036e28ef18ec6f67333bcd2353fbc604158ec0483edb01dd02f5667cf0d87a64c06bd5c2d6d3bf242c9994d43da7451cfde661e64ffada2ff3ad68966cfceb57d4cc805f439aa1ff4817696463fc7eef63fbbe53bb5a041d1dd1811e4421867b0d7f34c848576d9372280dd6d8412c000712235c31a4b9950b317f269ecb0702ee20a5aa8b2e2c4aca0d4751a8b28af9da52ddc8c33b522579e1f5d6989c2171b4363b402774a6265f4ca56b3795d94894226998d801463a214112a29c2aae81c4a8c55e1baf7811d3a309923859cf9e2d8d1f79a8e0ba5026f0039c5382de9a065d10253c71b41bac9406873e663908cf6f357a2736ead2bcade886f69e004c7e75def1f3443170a0063c469c64c0d9fa250e77c28ef8785b8a2c5c9b6edea85fdc68459d85a210ab447667b64b49f59138e7ca00a9bc3fde7a40bde149e318fb80073ecdf6ffc5ce62cb8c578387eccbab95d8519090b02d3bafb6b284ef04d6457283f4077153be209a08fe70c1f40402e2026110ad5e04cdf2829b8b9881c252c4c3cf6babb9e5371a700816e574c51198eb477b6059a81f9d0b40b6cdce9f90f849a581c8eeac12313bed92be72571d18f25cb8308664fc0fec5c279e3e1cb2d1b82472d832285068e2680ec427fd58886526c98ebde4f29ee7402e8658275970c025bb20efbec9b43a9ab0f702e9fd4e5f344438ee9279d410dcdd3d137a424038b505841d27ada21f86ca519f97f9f40d88a835f3ebe2e101c41f06a70bebc7b5cbaf7352e90fe5f60b14fee98f00f1f3cd02598e103c5ee4c20995284a66c6f811944fafc7a3881528f791b0ee8bcf152718d80f27db587a3ca22887bd8d25bfa3ff5b9e4dd13c2a5cd587a5b532aeccb42922d054d626d6588ffdcf5bbd68686e881cb7220dc4be6005f415dc1e033621c67a2981acab609e76d5f128c60d97b657b1110b2d09bedb12c62dddf571cd56299b318b6d88d0f1f76e6cd22348bc620610fe3fc696c72460d8f76af8ea81e3f98b7af339f22befca76286117e265d887a0477c71d03fc803f37cfc99641727f202cfb90a6c7144dc41b6554e1de52c04c4bed7c18afe64a5aa73e3871807506a6ca75a6d39544b232624dfbd8cc61004d738f0a88995d75d1ebf5a13e5a21232af97697752881f6c41f44fd6589b7a5d2ce9502e291684bea633544335a90e873a21d506f2d5cd8eebeefdcdedb062b1240224fef263edbf74ca170644b7789e4054d98e567a14fce5da0412ae1e8cdefba2008e989ea074129b0842b91fc5d198ec78c519824ebe3c598a5b7df52693c39aab7726321293eb619aaa6308e33606aca4bbb6746de7fd920ca9b5ab18152606daf6208c0062e81b6ea4275d4cbffc881882e42564a18e43d84e3c43900367fa00d7800f1dbe1d5bc0674588c2dec701832c4e2d06025bd8b3a26e21e0b364ed24cd2c9fc96b3601177f49bb57b012caede43c1117b71643b5151e33d2b9b31299f86aac97f3cf6cfde655c3dddb676b9589940f6d225a98f8c2bf1088d809e4067975fbe9250f1a08d36f8e43f6399280e326a311b6548a9c248f5b2c0667e2021262b315a0d44a002b5226c76ad59cfd072a6256975ef016a0b17d0a75b246a3c747b0c1dca2a0ed2560e7965834670d4a989f5330925e1b226ca69969dfc4b7b54558ac639576c831880d692bd2fca3ceceb7b8343c61e568c55a6d43c1e8a9ba0b0c0fd33a539f710239864ccca1287a4983781b88e1be67c99c2e8675c3c11f5b408d9a0ad3060ca2d9613a2464f04c54fa20bdd112b70760eae696ce4c274ddb4b2fd5aa050fd815547372cfaf98f20f0e4d9c01191a08cecc8d460c040148078b1c90dd9430fdb0699fb98245c61a5919fe5736f284aa264fa6cb947ee654f9aba71cbf9a8e459f36cb773e4c0fbc9bb01dd42bedf4040e4a15621cbb0fc7ea28b978043592edd891a37782b332d1365c072a88cc1390da68bd81ab22caaa73d50dd0ad86b13bc39921d47723faa88341073354b400a7bf62305ae09496b30259450eb072539196d3ed07e328b7986175cf56fb18fb2019607993f3a9afc5dfb98967e7b5e34c73315e5d90fdcf591848b99b815476471369b9f1d796b7e6ab38386f58202fa7e0b31bf6beb0bc839dbfc273fb618e303176718d84930a6fe8107eafa7f08b3f378d654ae83b09ba688e5c8bd1dc5bc4f3e8bca711581ae4030bc61504683616537f1853e12f173519fd71ecc76b0a40ae8beef22500e49de416ab29794ea488ef78ca68d4cec518820258a77d25a291c9dab18b665e00e8f42d031e5d65a6e864c54b2023a69947179577ba3f86cb0c018e91b1634c56ff802033e223011333c872ce3203542b23b8927a7dfdc88457874c54d381b2c22ab0d88cb018337bd4d9351d85fd6c4a6905dd9815464ca4c6087d0f0bfa2de85e897a2401de79c2c96d9a242a151ee44666897c897530afa51f11fdbc9388992a6c3aced640b298ec09da1425ed7f1fe3aa4c648190fbc21959be8278ead0924726d12c8142d467e501d7142c5903b62488862fe449522765f8ebb0fbddb180957b2d5c33a24f3a88715e35da4cc559b2857b8c4293ae543267d3943526f1f290244093708a982e043f2c33a0f54490f902d81a72116b76222a4f02c32ba9adce76cd0c16cce29995d3efbcee6a6f1bb00a7d99c456810deab06e4a035979266df639c29964698abe80411c04a0be2a3265107588844f7cf80bbdb44b734a67bc02ac0be10d0eba3acbd4209e6810ff6486df6bd9dde66e9d2e90128fed45be89edbe6d939526d8dcc1c2bcdd4d4534680c0a07f2fef76d65bb81993e2395523daafae94e8ebbea37a9fd74fc7940e50211072b75b8907b9179c613f56c939af85be29e4cd6c5daa01d816cf4b816255d683dc4ac3b3791338f7c404caf5b5742cf6ab2c9baec01b9d42eee0f8a0e31771405ce6bef61404d7962e47bf8c28a10553f700077d9693c65ac86bbd968ef38fc01301f208299243c8d0efc8c3e089ad94e738bc20f93b9a138202dafc284b14a93e37539930fbc0e9490f8eaf00c6a5c249a1927898efacd3b7fa25e05c0871da09261e7f1fb20c9a7095c4674072bc526844e9881c8fdb46111e413102b074756b867bf9254900ce403c9c0f8b8b77a3f37bc2260ddcae619807d8b6f5e1b579abf657540e31915509b014c4f5ed15eee1c865f46861b20315060e00846e1ceecbf86e52a5eb2e679eb81eabae245fe253d420f0811424607050d6d93a81357c1f995e7338db7db225241fc1914a92693e9e309cf171098f570c1def3b07748e2b50ce749262f3fdedde4533957edfda93f61acef1971f86ea82eb239da8b62c31c7cb60d1109e9c6c2e14feae892dd8ab68220f184a81ea3acd464b9cb7df0631d1103a404a55746b57cab2061fb8f6a8018a92648afa4dab5a770738354d51c3400ab54236ec599f004eba2ac0f84654548a278d0e56ff405757f4c76330b94747a3a087ec93b8c2e96e81846bd80e6583d9f58f6eae9f59963818d40b8442c52ae7a54d747b24d154baa5d23b2d6c7d9f1ffea2f2520d9477037135ac5da418d127e3356a196aee3515a5973713db7fde04e6d7b80540c2a202f3c271bb4c1e5de65873f5158053863e61053383c24299355ab70fe79c7f50da3a45a8323cc2ecdedee6f0dcfc8df91af155e11535285fd9a0582a95aca5dcb7dea1c66e733c6e9fb07a50a581ed4bc63e08410247220ceb341c1188aa7031e4808ed40d52bd78cfc4616b71cd67054881e9452f8e148968b57debde585e9d57150ebf510590a0c297871df756cb3827c316c815fa664cfb953f830ddb0f8de72c8851e38a1cd6342bc81a29fda46f407e755d48bbe5df69143c1e229862348164b93707abed6f68c98fb771b0a86a7bc4eec59555f7aa6c1c0cf21f1ac0b9c948e9d19813b5c80a9767a755ddc2b2c4c85b62810b1d12cb3796bda9452747fcc09b4ba8a07a28365508103fa68069f69bde6b85f02616bdcb4e8dca4109bacc0640bcf5af6cbb5619dc3315ee3639ae12cd2da4d9e0c40840ab768fcffaa4d01f446621c481fbd3ad93708489a15d316d08888aa576eec854844a2db0d74216d04e18feba3ba3cd5969401982d351cd921c0b9e21432a3310b07a10cf132dd24f38e2e07fc0e841225850edec56ec9048f574d26eea23fc26128eb8ff8f18cf30a3b051a55f70aaa1d9bca0df5723e1b3cfb48168c5b10672a6812d6b0b9eb0128a7724bd506d39cd406c8cb00ceebf2e6f6e1fa899e2ab7b5123f6e535e611301a3825e45b59bd0733954a578334b9760b0812335d1919eef9237f707430494a7f0702b3b84eb5c72389eccd130bb4a321c51e08787e3f8b891e759f91b15b913785f215db46d1c3c5c4fa005893fc3943d946910a329ac7c01def884faf193c6aad6b1903051606302346debc04f843e384b91b58897dea5b50bb43e1d6f71b617d6ac621629261d7aa240967e27651396caf4c276e9893d1887bcd50e708c1f01a142498e2349ff2ca89e9c2c6b3dbb0949fac7ae0bc7ea726516d6266316630a7ae3e9f274af2dc90a4cee1e384300567376654439b3f5916d7d73eabb45570e5e60ce374ea49a563e1c09b44b29067748baf4d90f5b5ba9285c3a6cfdb0b067ab0cca6a13eb48d4385ab8dec4348fde2f8ab2f36a3b376eaf01958bc053394a35f37020554c4ee4a1bf7780e9c8302bd2aeb092110f85ef28fda27d54bd019769eade509e6d37dabf9a2fcd8f912c4e2f78a923733474662e771d974dcd1b7e944ac0eef3a62917d3531eb5323c526c38a9d3ca7f88136b14cd4c4f4d497ebca0320ce4fe0d4a3787afd87b440886aa8922be45f1daef85a83bac543f83df315ebd45a805f155e3a657450cf94d7b64232b90eef0b6102ba2cd0905fe3415fc137ce9f59ad86a71e9731b61e06effac5c8ad6334d02925438c5ebed3234142a8a5c0f0aae6862cd9e28d85dac8af708e7dbccc80014bcef9999400f8c60d3390e0787f3dc564d53461b550184876e9b23aff2cec946c8cfc22c9fa6f2b76ac2c8085e0039d3fbbd16699c9939f54ccecc9e627b15eb9adc98dd8138706b4bd8ae33c76f352c7a51067cf327c72018601cf1f6cc36471547ea5b36e6a15b0c7681bde2c404bcb482d9356d8f34e6d5a91b9cff90b111e977053687ee6305b8862b2b3d6f7d3d729ff4d8f4879fb19a511f58a7fcbc6ce3e93dee4046cfd43b22d1f04d0b304287951ce23de43ba4a1bca09fb3246815478dc384289289054fbf938c32dbf5935c9b6636edff8ae2745f4c5fc76b26ec36f24921f5e15c2ce8d5a8dea10c8b63108526a27737fe097dda628f7ae34ec57eb7d6973ea995fcf01b50a1d0ae1c4c56805d51d6eb0ded5d4172f4780a2b2edab6bcdd6774f129a13999d94386473730089d183a4a54a1d5edf671a6d52cd270a348aaacf413ebe435656e59f5388a8ecef4698a1de85ecc1babbbebe157b93e285c663b30ba237dd805fb5995676dede556ab995fb1a68215558c6bed14ec073c83857b197f77d5dd1addbaac90ca9326e9102258dab5b405e9c1e93a8734c2117e8156372a61ff4f295db9417588417dcd26eee07b9dd73ac657f44c85f1c84c3449c7e44816436b8e6d9e08f970dc238aeaa7a8bfa2de092d2df08f87e9f0ab1976f5b430b8e13773ba596a35f3df0d530b6d6675c1630899be4391cb5437836cd9417f4092bfae92aa55a913d65b47868406bb96f6443916969c544edb34a29b98f906624210b525fd1f497df15223c1f31fb4f416778c1ff80fbb7750a383dfce07978ef4df7a118de4674403fe68eff4e603021d4161fb8d2d49d83bce5920824359e656f1acf31b2f444621e7303132fa8b2e27b471800d69f4a604828376289b8741c9010389c4ba11b954479893422dda62acc0daf23d9b822e7b4102c197ac2edc9800c90a7216c0692bb0134f69caec93e1bda4b4b8a4010624d970a244c46506440faceab45cc862883e6dbcd9628339c59dc2b83bc5d2c155dd93b8aceb0ea0316c00b2def938c6f2482b18187394547b7e46252e5503941ec18d97729271bbd16d91299b072e97bd7e5c0025781deb22ea1161ce11574ba28043170f5f4a8aaf702c306af4a5052efbc530f811a4aaa7d004b3cd2f8082147df8cff9685d1f317ff783379947d8c0b33e0f4a51556b5b2cff6ab79536a8dc3b29505e88bde2cf89c8a2fda8f2a868b122339c2957ca964547a8816b08daa629b5d380ad409c638e64e690f6cbd2f00cf639c887b8bf6b12e0e09e8a2df4573a7839a815f610d0d4a45dc789678be44e9c8e328fb14064bbef6f5b9fdc72e789c3f9ec7a375e6b5ac4ca42e2006026651ad45e03ac0a743214c1b946c9f835737239e121fc7b37440c4a4bb2b5741b580ca221297e08fd47ce47974b2d4ef03a6845b5682f6e393a5dae95131077699af472a10ed4f95961d9f3370cd7f3d746d1abab7981e0f7a8b64a1e635d8deb301fbfd7574ca324a4c5fb174edb93b4dfb4f6d9bf60e3d7f35e658dfd74dc7010f05ec3b304ede83198b2a97187f469041b62f724d552e9b874638c376f25d84d4168d855b920c67608af11a6672b92fea6f1be974f4e4f632d80286724184444ab9f76d8431b810c4449e9e64f032a653a9be7c4ede0add1e6378a55a72b7acb3efcf2c05a9469d6085e1120ccf8ddd5f0aad967886adbca0d04468591e952a6ae836bee87b87f43915b81a3a082ae63d4be941c5daeeb9bdcd417895dfcf26ff203a66c173ac6551ccbc7ab07110441888b0356f723a8c604babdc0efb52e119efd06a093409f1c02fc7697b56fd0b9c783d0c3a1ea3159cd68352f9899b001719ed6d5c8b79959110911966041ba5016d6b80e7f5f7a9d1d44617de5a603f8bbd2a5da1f457d16c54e8ab4272af1e813f3f170ba6ad47720fe7c2886b43aeb857a62b533ab38b55f04e4c097b1701c35baa5f957736c05b53324c01386d3eaff1dbe7b9759ca249e994a8e98aab686620cddba1f712dcfccf0abf938662211ff6e0b8e1f74b78a1f6e9bce3587ef090af16f2f6480532bdbb62cc0e877dc807871d6992f389ab7440e8907ec164c2b9987909bf82bf47a2909571d6f6ba3c3fae9abd53313038a8e974595b5bf89bce020a1a5a66712fe710ec0c4b24186a0cc4d0548c8603d14e5410fe43e54a27ea8757779d9c1c5e565f696aa04a55e0df46a07662f3604e850c6b6fd07bb0350804d439f14a750730ab45ad6d91f34d582b566cec063bf6ffe76533a2bb0fc74bc4ff118a6524a566ed495a94bef6a769eab4623ecc7c1261a0601bb63a7f1293a6153ac3c23f29300c4b66ae074fb51b399aea090d60d2719967b04cb38c2545078d0c3bd272cc1ce1a6d6042f0e9ccd3bda721f446ed9c6fd6cfcc9b030b6be497532f7b15dbc2b50c9e40e89064272e74fd39568b8169df28fd6db1e7d8fc6f5c625b8a3e1849ae72f982e346fe1563b59e3b21f46cd651a2f48e5dd36be5ca0ebb8806c5bf922a67b41c298096a7390d377ce2162e729826dec83e99ee89365ce4a4eabafbf67d42e85154d3fc4c252d0f58992c9787e84603a460268d8b10d05bf528c04225f3a41401d1672a9ef7ed74be5809c1f96a4156166058717489daf004f0b9eea3f6b8b09a983a93351935001728a96c3dd4ae9be86c702bc71e53308458f2623cbf50827c5e7753b6d2aa9ccbebf4c498a989921b342f3c9529ab16589904fe0864e0a6496e81ab68000bccffbb892f71774f5bbc8d7ab0e2287f09bf2415497a1a6822235d4c9803c89b355ed50e88439e787dd656a00372fd74fed9bbfe65ad2a82f82cc442c8ee2436333de916ce522afe6da060ec8b13386ece1a5f9b57b2baf659c6a678b6358995a26c678aee59e32be4f47363069a8376a3bd33c24da9458607ccb4a41b3c19f1b146ab25b4c22fbb6ae7d03709bd698e60809615e995797574c2bf994b70fb8ae54c31c25522c344a014e7576000042ca0e8672a2ddf2d432d98931e489d2fd365d76a1247a0cdd4b95575e52cb83472bb0d2126f6c7394a605b4baed065ec40a7994fd43b3d6c28cc4565ceb8d2b105319d289bc8b47073ad4660342e85d869662f45db6a71e514df819f6622e9f6ed89c367e86d9ca52c6039b75a724529c20ee034538ada3447c40d31e540f0dda5085d499fc18d40259f21a1b9b30a9392ae2a528816103302b9a55e6ca420b91d87d709dae9ac55259a9463aabd3021e2e3f2cca8eb5d18dea59229234278496b2dec258bc83a53ba8b6be062ac2faf8fcaa1d10e0334fa8ce99417d241082feebeee3fee617d0f77d7e78a0e780567245d0a82b50068085a4ac4f50f4dbdf86db6fde175c44e1c7610f163f0c5a031c7c29f9e9596aa1163235d10311c2e766041d40c86c41bbd0cd8ab14e7d0bde27ea23581f191a8e5ac66e0abb414de99f926d6a11675ae4cff01a0761123e5e08fde1acaa50f6092019d0ae4b3f158b1f607b7300df6e421ca190fb4c2fcd02286c5ea071973f6af6a52765a279b2f09dc6b9cdf639064d2f06406220546f84e1e019fd5e6c52fcb12689f0235ccd0c1d681c391255dc40dfd30f5389c55f2ebd20d1ca852cdafa1c773835b670985f5c4583568853af9e0fbd32671b851e7093dcc08988f302ed2d6a21abd5aabf1d0a7e25a1313fd4ea109da51d850f1d6c38c94d80b69684dae68510808f239502fe4303b60d5b98dc81bbb1c944f9b9aadf090d1bb3308f36cc8de72f197f40b176a82887cbead436e8d42ce5fe600ddabbe500e39a80e99bccbd891c683e5d0a3bfb189229d008fbf5b3b4f43bc5401ebee876178441d4783793fc45463cf23f171a6eb463d138d69484af68a2cb121c5701b5220964605562c1dee62a49cbe2be476a7a9ff8209a9adbe49bd6ebd266f2cd67a04db6b85b1f3aef90da6281f2376fb7f3076a71f2ef40c04e3a3c30c48d4c34524b5b1008bb22eaf58e004494c16a0330afe9f32b0c5749b8094538dedf17928565a35e789416e71c8e24e469fa7c077f4c9c7bb9e396286a4dacd2dc24b196cd2d42d3063dd1d1a84c821911b23293300c2b33c9e32e5ffdd2fab243def78fc99a4202f11100705bd577b804d8edf304becdbdb3e3de0c245e6f69f40070dbfd7381135b3f4eaa7c2afa4a4b0089f9dd27c3cf3d497a15a666f4e72bdd1902498224c6469b49c06afc6628ef333115804795f2cd790bd76086209c2a1c6557860dc2462956307afa86e98bc5054d5b809a713a5c60ed208f3ff3c209f72a703a2f36319f3ad5ad6d91d4f30d790c12b96c42828d552a427234db2635089ed41d210958e44243cde0c3c850723c72693fe34f5fb11c722bff0358cc38b0f832e44ad54e477aeffed975ad0c209d25767d4dce18963cda841c53333acd8e0a52a2eb6a63e03287326000927abb5ea9107c72e60611935241465e1d6fb14b15311267821a54ffd4d001b7edab78c1abe4043777a573e35db89b8ac54d3c28fd901d6289151736b1a5e0f1bf29ec6464354d2ac928299f7036b3ce3cb541017c787e76e7c370620b26fa383ed45179426e0ec01679746fb2af0b92099b120306a66f994bc2088450a31e223550ec616cfbcbb9765b1d3657d9469c98ec2317da176112d5f5e89a3413b4fcfbe735bdb9b52883d8d711bdeeb89e4ed6e5c3142713780c1686c0f384465ac09e380dac6b408eb5e7a9276aeccac2861e78c907a4f06b1084589463875073b542569da5527d6d5b9b4487084316ac40e2f7506a506534e909db12d98ae23c5b371e3d5c514a4268c9820a53736c7ab085c7091d30c8873c78b3c5de71099065f4bf498994024a99eebe94abe3d532d20a63482a28392cb3682a3307ee5f0a359d9dc3414db49379e3b249f18eeca6f4e852af47869a1bee27650debca6112e95df7ebea97d76cd98f36acb84372a1e2c5facc048ce92f7701e73074b704c8d2b57fef7f45885e29a4f33d55772ac203942a98fb315970b978a2598ec2621cab92b722213327f0295e185d63b54e751518dc51c06347c415a0ed3cd519f245460b1adcf0aaae645f8a08e943c5b52b2990beeecdbca91afac2ba1f2b5d9284be02bc25e920a85e94626da83e8129d86f7586981165655b456e6fbf4f0a43a8541f985c74450b2b39673431030dc6ab8dfbac642d93a1d26b3f03187055f16aa1914e6582195cf1e683f3e09ff0f5a525a457a96ff21725bd69eb41a288be4f3565acdfe8f58e365ef3fd7479c253b1daddf3eeebe6a4bed86d65a92f512a7f6f0c0c514bcec089bd1be3c0a832535746e8afaf3602095a9068c4ebb4188fcacd869c5fba1cd8e590a4955f252e12db2b621d35dc055bab603eb94e8639a5c460a4a1b6c8b2682c869bfb41665644fad1398c52bfb55c5d48e9a65958a5446a9f24a74f05eb536cb78a9b28711191b97d430a92aeb370aeeb67a44d378d0e8029ad180529094f0b48e4354ddc284d0e8c45b4b1788a09498aca2145e905dab54c505518c1d94153e445d90f0d4d88525734632246188034260712a5eda52ea9a0a9aa982d1aad33ca566676635bffe2e835fb2c85b09299f2c59640d1217771ed9f303b5d67bc8781e504afdf43738d92d12f3cb5a045a23be6d19d62207d5d4447a30fcae1f4cd58cb37a9571f6fb3c99b0093a989f7a4dfb6fba64e2db89943a0af022cb21c406e567a61cf3c6a5c8e474e25de231838dcd38d874d9fdf2b9df94fbf402bdd4121e20950269272b22a8bc48f5ab5b9850159fa48a09ab8a98999bf17ef331129439dc6f054443d5329ed368496da71e42bc6ec08e60dbbf65241d0dada2929d2451b523fc4e99aa58a128e2b0f01f3d63c2585b148ca8eb4cdaaf343854d3ed9d83774b0cc3ded7272498ceeb53c003f07816c0ab3a8c8daac6fbc003f69e726f97bbfbd47aed81be6122f9215a22e37b6a6c0a36b8072ac2540d0e9e23f885db54cd45da19101c5ff8e6ed8508535bc4b8da60362e8986b4aab8435af5847753e24d3fcaab752ac86c193c17de051a159f49da2e6c40c02e8c90219afa5ef6598fa020565329c132a70fcf464ad09d8469be231d2f141b1613216a78eebfa71f31d634cdde32d2b9ae53193fa41a32034b5a0f3efb76da27c18913a3f85eb9e016f59484a906b410364ac51e36a0a25cecac793414b657299c9d3f791d69cb9045ee9eb06d10e15c94c1af3255fff16acc2e42b24922b569590c3402640130ed643d8693f0eb35c37dca425776eacef01d77d90a033dc689572825d3afa0395ef9a6bec6ccbcbda057918924a669837304b059db520ad699c1211b5403e7dc3c8621df83c02e7fa3c954bc2a1a0e590f35d671af735d881373b93baa31dcf1b7468e2947c775106371d03bd394717dd9d9494cd5e6816ef3286725f4e03c4d43916b38673f3c365eedadd31f447f55f133c2e0008cb60573a6b4044508ae38e61a16708e369c79c1407f3330eae02c483d514d4ecb68a5284b4b0cc45c297270d921b0ade1ab3794e06f9438b4b8e876fc80077d65af030af98fc1c60de3aff8ab73015bc763668a619e3cfea1f2689160ed4a92fc9a9c7146aaa3a56d480c7a791642cc73e240b00b1758d491131b71457f55c3700e46909eeaf9b2db03a611a9a4a94ad20254893874896fa52b83d2e57ab3e08817edec1516559fffcd070071bd3ffd3a272da746e52fb395d6bfe8f3cc5f99b6af69fa1f8c2841534e59c1af8945811928a8d8f8d657847d509e8f8671548818cada980a1f144cc614c8ff1b86890e76aa4006c6ec4b64697337e9ece4dea6458ac0bc0a89aeccfcaabaf80bafab6bda56132fde9995ad146f43c9ad2642e70e6cb120d558a9d53bdec5dc19cb137ea7d046906df4b67f663ec4cc91ceda7d9edd95d00a1eb1ce3efc62dff17c21198bca4cbc37d4ebd06e21c02445fb5863e61ee9a05a93f1ffce74e406f3a0068f683f0dd3b6842257263bc48f5d812bc6c19afec82719e8aaeb9518ab46ee9e1f35c1549edbbfcedf6081294916f391593643090b1f3abbf080e7a5652236a0fd8253ef9f4f8afe780cb056b007c697fb327034a378f4d9a26977c3f6f16cbc71c8e56dc8215708cc3cf661633879d5c7ed5f891b99cb3c9d2e68603a3b1796b489372d0479960b95fc431f60f4a2dd87796b64d3a023423016052aa5c12eb2e96b1eb4486b6f7b084e74ba249a3b2c044ad0902be2d8a34b5b9638a13e1a8436c09ef5f01e73c97a25e98f2500bf6b9cb14e66800b92ca6e3c6a110116559267735fc5e081c9330f647c71a81f7b9d29c89512e0b075a7c7c82d2e5579fe6beb601b8c1eaea325dc6fb42eb345096e069fac01d17fb545751d7067870a70e81cd96ba901eb225a220f33c89a81fba8b436782652333bf6d2468413d12f89fafc5770c1f887a9a31924f10be104ebdc9ff142dac3b0838835ceda90c24b672a8194dcc5429bbdf041aa6fc4a9063ed12c04dd72ccaa0a50e8583f1f47fae58b1dfd521bed08329cf0aaa02f144c2da9a47200d063e33b012369a1c154045b1cf25f3e351ad1100b47a21764db08db56533c7cf83d244b248c8a956363a78eb147152384d3c1cd0774f278f7efde98350c4b02eb25e7e773429912a233ffe5300d31193404e20296989e23b67872ac15f45d76b8878ed7c4600ad53351a8bf82a50ad1741cfe68204d0cf60387ddfa6734497e14414e9aef9cbd89a8657aa2828ad5cb6fb9383d13ea52ded2aaa2b9ef179bb2e2ba4b3285418022939578c7dfbac9d818a0976c4bc88f88ae617d7de77d0111a11a94ab492482548700c78ac76d9a02224c07b2bb76c49959474a40c5c07e15ed51d0172b57797eb240f6c007ce4d60d9da76a37d60967c61e7a327d046b96c42dbf68cbccd90d2e32434303170b9651992a2e24a552594647ee851553c72afa83ea67ce8af94f4601aacd587eb913fc96de5f5fb59f0d1f15f8d381226150c694a2c8919885bee59473f0d9d23bd3f8f305fae5e8a540c1552e4a3cd6546eaf8ff8767f6f112346defaebb0a2352cb116cc83f3fb6f92582aa93c1abbc244857eac7713b1cfe999277eca34d9aa5c820fe24a78a67a6e3cd058324cb8f60d6c65da2833e4786be1a7dbf35c332b462cdd8beb87c4e08f0e91142aa234758b1432ffa866c46b18f5e3134d18b176ccd9634627e08abe68110c83c95bc90dfc0054f9c739057985db998f841cfd828db58a2b87931b3467af090870d4ff8b9468ca1a5079e2aa54a5d0378c57e39812a97027cd8acdf283f8e6524f925e3c41c4beb246843b90fd06a9512671844684dc2f252c42c41f5b943057d399d424e7c6ef2c23a13d0c35ff18e6ae452d5885a81079f6012feb5f93b1ded0060cb78627de9466fb29fba7d3c4af3c1867c3a0c80c59a2de1c3af1d52782f00bc2c02e5933521e0d292094023de104d056fa191812c021bc2ef8a9b4dd5055aeccfe89714cd99a254afa72c3fbdeebe05e01c59659ebe29f10631f144ff114a45470216dcb8de2019d3993052612f09a9187e8b8c55750acc7a22403fb09bf0e0007dab546d93bd80456c6eb3823ec437791b19a68e7122a50a8665b3026d0b095db50599816c9d8c04e520fd94dbbe204c3c605c0ea0867a485bb94f2abb4b203b2f77df3285b325ab38900f00a964676586b23ed7ee828a196e5320595b8c533a3d5412924bffa676eabd586254f881f3798d9ce3cc7dca0dae3e16f7fa62b3294409e703445a0cd3faf417b666d65168a2057c4fa5e74f5961127f8329c2fde84ed89033158df8423f32e20754c47dcee810759594fdc56db701870c4de42b097c581db1b3e5f25538cefaf4b765a410c9e955cccab0943e009f901c593180504fb9419696e1af44f1d340852e2879402845b44258fb11aa55a398f4317df16ea1cb0f06a1ce0f8dd94c19f8e702072655931c9c5624c5908237d6c868b7103dca330cafe07becc7ab409396b82535e8f055b54b0565e3e6d2d5badc5312670592902c4ea707b5a6cb8d8d3bbf79c10904391b7974591987e20d8e0ee40cb7b8816ac68d839c4e0a01dea3890f190798cb5931d1a7af8e7052dbbda14497454c629d1b17a772e6c0c134186b42378add4ffe92aa1f5df7028dea763404a81db689a146d640981c4ed57e25f54bc0ca611ce7ed12c4f1db979986b0282dddb42ae04b770a4238f949866932b4bb2ec6e680f94ec4daafde8523a538e85cdb965ee4a6b1bff2cf7dcb8b0ee9ba1b2780e800ffcc84fc020bf3f254390152c51074e52359e89d113dad8d3a8af38c2536bbf7cc919201b4ec1ad5f36b242e552ef9e8637ccacafac15652b1f4e77cec05af6a2b29102b1bdc10944813bb8650031d28ec094d24d10eecda1996787b2dc8204bdd5ad05400936cf6fb60cd2937dc6ed136a3a13b1296e53857d7476205c1250e9d76f5e3f1ced646223d14270ae07d83914839369609e92be89e90cfaf4d433bb5aa0af598521487b3471d39a1745b22e6053095c4110e9886591b2439dd110a7331c27030e20d233f1b78e470ee38eb9a69c51dcaf26b3f7a323deaa084cd646b8957770d12bdd651d2081ba0e24750fee75772fd6ce897fc6e116016ea447f743447c0dff1a811c47bf43bbc9c54389ccd7a3d6bd9c05043a86515e8556b487137cdb3a43eb2c3b960c0769e13693611ff7795b1d43d36ff59c62c154b2d14620b0eb7ab805b5a5a2545db3cafafcb2196244f8a984063081313cff6122036a1a8d102777b2cdd3a0afb2c8c8529051d8768b8dae7c1ca7a1bb75a04fb9bbd66b85bb28f00a6f2b079e890e2112a797cd43113e594d19d55f5048e9c3e227b33fab1f0647dd745f37130a5103cd6ab7c9cb0f5888dca8fbbc9a75325ce16ee3ac9944615e5b69d7ba88c082c919c60be2bd3fda845bedf62e518970c4e5648245e140b07f8b215912e388519283d655221e80ab0727ad7897823da15ed437fa7b1615c236a6564636f82dc21a6de05ac5de8dd8c5c44e5a0aec6244085a3f18d9c2621e6e77213488f89a0b6b6260974252852a981f81125edce30924a107f7419eda670166cc91dfd283ce88d677ea9b26066f4bb687d519b4ab1ec2e509cb60c042e9119a80380f1bad165c6c5ccb45cdd18bf7cee7b010e9f1ab6ee8a4b140d371ecb54dee7949c8fcb1b43cbf1d4629ee2d7d3b8493b6f1e3b1cc102d2b55ef42ba0eb0514a89290644cf389715754be309f8003ee07c7eb3d58de69bf4e8a11e70e7033810c9c770a8d28610efcb11878c4a493bbfc9b78f9178e8a327bd4ef9762afa561e191321615ae3a68e6c9c2f73fd3b76144541ba548751471178138cf3e257e4e54fd5bde3852f8800e2dee1a6fbee15c12085d0e229da672a8617a67174c6f2052832cedbfba8f093faaf7db2f2e52edee34964d10727be8acff95816dc42d462a1da850059d7f07a5838272e0c79b930b7261fa05e59ac9fa38051eed457130e5efc57fdca1767316fcea8a0d8e1f8c8cd9c0a6cabdd0742828a8353109a5c2023aa123dadf145436e05a52c7daf7e71fa76bb945e509abeb3825012642cf6ea1f6f92fdede27fb2a75e04ac66d4c768afa36c4c7441be0b6e831c0c86a77ff9e6bf29b292f7dc8406d0f73a020fc3a7a88616834fd1ac016babbd1af5e197aabb41c687fe1a692065e21e10d8a08c810765aac868e463bd02956f33cfda6b1caf4ff084c2fa4d49ceb10fa6d2ab724a01359ad4a67de45cbaec245550a425f8e25cb86ca482713ae00ddbe14216184009f213520563706ba67451224ba430e43e2838f136dc20fe60f787a050f70452e122f51e0bff678ca317f567171783151a954b31fc21803c45db5debc8f32be4bc8601838817be961d7913a600158d29423cdd58d16197b83baa78e561a9dc2b6e784a3b6a281bae1b743fda5c20007a88438f767ea49153f245e042a1ee86ee583eea109f28e4235fed6d3dd09b9081b713e10e1b233ea43c5ed0c5470dcdb5cfbcc7ddb86e426cc22b530f74f4b5b420f0b049ed8c591768ddfad40498f03c7c14564f570d3b34e4a015fd7ac82b0e74643640179c22b6a0c061d2c3c1c9b7db3b448b631f75685bf1e80746a869ec935951d8bcc460278ede1c2accf8d94f6ba438d42aababf131f5aa4cc3ced05b5328795271f9ec12a9153facda7b27680dd1b32ebe8be770e63ffef7f7d07942544b40a41aeb791e75ec770ac3e5d3c449baf36146c71a4b7cc71b26141eb1f05713bbaf75347a41d065e3eacbdd7bc022fcc08345017277d5214b78996f854878d1c526bfeeccb6659e4058f9180fb566f0087635fb73683b6ebc6a109a295fd6e492c6b85fabaa0d3148e30f094ee0fef388733aee228ee718c23536f038e6b38c62d8ee27cd67b407115c771878351af018b735ce39275af8ffbcca7b9d240c525461f172b2b81147d662e240d1d21184bae4545869437e9271ecf7f75121537c6a1ca1e9886e5f27c5c62d2fcaf9eda1a96cf9944cbf176aa9caf4f341bcce4e560698949d786c4f41a1acaccd3b0c49439bf1f8b93da5dbd3ed16a6096a783d248b7630c07254fe6f9f05f3409a27550eac4ac63836dd9f3b37032138b9a2ca8a8b79e2ab4959ee8f627c44c4aed2eef6ef9a97d0cd1139375361e6a2d64ab8b4f6dd9d35148731d5f35f01c9352d8b303a8be9798f3e9d3560372793c243931cfc77fe10447bdb3781d283571eed327ad0dc4734ca24d7c9b32c7f727990665f27a508a78638fd950ca84f91f9f343553a533ba7df8b4d9404ece39346089a606733966d16caecc46ca749866ed8a1b6e3269648f27e65e86e74b76ee7e5296403902053f79e3fe2fd058caad143c9af22743a1e625a662e8b1cd3a190eb3072aef5cb50e932acaef0d34e414b12b1c4db50c7fdc158c7f5d02127fd4bbe031703fd1ee7ddff68e3db1df97f21054a786f0ddc5cb17df99f9ab2f3cc104c97162ddd3fd677fcef6812cc6f8a92368f7f9ea0ffc39f6bf729d830575ffb0be0e5fc1f0f125aaeb14a2cd77bfe9de6d43cdfbb491220ed05973e8f04db20f163247dbe96e2f7620682d6613ce7195a22d392163590af2b365c738a3916cd7d3d98c93aec4e811a7a72780eb56a83ea472003ea2af42f71faa5dd1b6536b0dc4c1813d94116cdccf6607167301872fa0386dc8a005afd0a7d107d6a2708e36ca4ec2bf8f2b6c460cca20e10f394467def9999f692efa7464a9bca5679add40e5a7ebee7f2c7a41e0d977495db6d1cc490f3b1cb200d6e12d0798f9e7056680913e7ee52365fb167e75e3daaa4934d6f9f3b1ef9c94cd6df533e6e225e87afb75528109e36ea290884bfc798417c46f7c96ac31cbb01eb004e41fea723951458655f87f0ee3c1e29656c7c3e9cd4ec21047eff2952deaa62e184bc6627014309c5a95b354413cf294d94c0c04942c682e19ada8dad1f533211168516a0556afb24fd89504b04b4d80b6ddf2ad0353c300d27668ec86cc75c71307cb3f0cc6ffc2f256838c9b092aaab2e89709d4048315fc97f2bf1606412f594324e2d9f77f80fb0ff4b71d4f84dc28f4a26e0b51878166f09c26f2c820fbdc57c200645b98eee4b36c780345bde108b4251c8f30085f1e12a04b7afb3e693d688dde8d546f6b80a1542328c40a8f63f1c3671f4c65bd76c41225cb66a4483b997064aee7ddf7d7192836bc7e70d763070c43402dabe4f72a5e632a066854d7cf0b7014e55ac263013be3fbc8168d67bb33f3709466308a468c816afdf45f517a70d95b313cb5b88576a76e4b31403b71bc4ef7724084842fe6e5465f2f05466a274d5cd13eabfd829dfee99ae5a24746ec46e98914e5e5bc9a189b9d6f9758fbe0137dc7357e620b95767d39a0cb61dbb60996a1de8426df6463c447c3bcb464f408aa6de5e3e47264b1b9f3c3b88f83d659cd939be0a6de9e11122b144a08b31a831de7b0419ef6577700ddc79bdd16fbafe6519b50e91698743a610baad82eb541ec12b3537972f13c9e1a7e0204cab471458b481d70feeaad0aa12d2f799aa46320a748a4621991f7640c12187ba0dfacde25d2e3608bdc4b474eca5b5b1fdf184f0855d7dcc8abddd73db79036c19f5601158c62a2814e7680205a800deb7216d403aa2e4acd31270f26a1426a1a9c064366a94e1b663512e3669fa6ffae87e6b308c80f8c62253a56f097587449ab1aa785c13c0dc03912f2d83cf90b8dcca4325c41e0c4c1836520b2aa4e544b16fe78fba135adf9bd4653d45742241ff7cd50a2c58a8e083900795fa65557755726da18dcecbad63227e915b8330840496f02349532d0e25dfb2bf998e32a85ad1126e40c62eea907faa346de3fe84b26abd9b06265da20dae1e30e9a978a0c71bc9f78e85812d90eee6cf77271903fc001515ab217e01cca0f0061f983076ea3f52dae38e0b48e026d5dae2428564763566f1ebdf9aabe0b13a2c5aaf16eb9cccb1f59f855d94e7a70fbcbb35ea5f8d39b7b207f34fc191531bba91e64e0dfe3b6be304b137fb417c1429cde9e1b8797deebcba986fd30b6cffedde05c18e8d80fcf5d7b22202f3659e5897e6142d1d9761ac42a220757f4208083442df37d07777894f8a7deaa1c4d1ccb643def7848bf82d933809216a0fc91761aa11e03ee8d7e147e271e05aff79feeb24621c4a51296f8f8cacea7ba3c10114c500ba48a9fc1bc4277383e45ea01278e536daa70920795491d2f6d47d869fe9a71f5e53a638d1b27c410039e76c8ba8f341272d53bf681b05f84f4f509d3ca77adbfd157a1a347e1a36706b9a22b77185ef5c9b0662e7890388501481640d2fb0a0811d05fca193dbb23e0df2ed36d183ad0e494a79c80df55cdc4d09639c78e1390f501440fc89f621396208ba9e0065da2130453b22f82b7af0a9bea0bef4806f563397a08e838219a716cc1a701637a399a0eeab4f528d2b48560904862374f076ae1050bd787c33ee7d5fb74ec9418d9c563887698015433777af103cf93145a1edaaee55e2da855582e50aacf0c2514c862708373f867129c4309233201e0a2e6dc4f93fb1e16e394af3f0946adca9110e04530026107f2c500a53689e7cd0477ddb0c9d6921f3910f4eda9fb1f91c065306d25736d3f346a545c7d09c0bd4b8ff20d0b6f8dde6c7a852d1bad2498603f9e251c9509d3aeea71fdc25b4f7372fb046fa4e884994a03b1b38f5c62502770460c840010fa34b27e23c83f802df88512cb7e0407d89f38dce39293c057f759f79fd4e3fff7d790f4e59403168f931bcb3bcb5a86202a30b9040ca6b7b34911c83daceba26d2272dff406a4c0041a5eb3ab58209c19a7039590b3179feb12053d66a403473c98b850def3e46a69b7d7ba9a4438da1973e41621461ee3ddb2493c1501123a2a110d0c2f3e6e4d50a755c403db9f1ac58a2d7bc95758093be2577edbbbdb967b6f99524a01960ab80aa10ad5db3b498bbb8875c1166abf4bd3adf5da1bdf9bcce3d95a1ecfd6f2900a793c196b67663887a6666d2c0da8488bcd62f5d66a4dd8d6e39b4f6d229badb5b54a3d32b248693bec40aa3cccea24d8ac1ceaf8ae67dfee77ca020f5ca7a76816d56f335ffeddd821e96368686868c887153a6d6fb86b92bd84b162a3b686b6d8e2def8ec1cfc9de91a5fb17f9c5123411b2dfad6743b5bec64c015fbb5909a9640298d8213dd3cecd2ede2e20205e5a11583ada1c1a67098c0dee81bd43642878d1d2da50f97bd6917cfa5fbe7feb2a9228eda1be9a30bb7e6241f40be921034258a2d17c78e5b3bd3452caa7f052d5e89a2f89a63d86d19fe1920ea34dca05709ceaecb38b40e7767a8897f5b0b292ea05267ea4a316209362a579697f5b98e565c196a3f0f02ea4a59a20a957b31ad0e72a511e369bc1739f39cf367c3c2b6e23ecec497f05069b1c19d193ec69fc01d1a2f83ca105739f19ffe884a0678f28ff14754305c7464fce91dd499f1315e6600e7cee9653c0d90eec4f8194f6309ca2d0e7a89019e68f0808e0ce4cccd10a32317e3ae70b1aeb151fb392e64803b33d8a84373526a32bda0b4c8c55ae4ae7033644147e91ae28838a1ef6951d7c068d135319f922d47750ba9e57d6a3751edfe9104e347600b8c9f9f0e52cb94f1e30162fc88aa7efa11ac347e8cb13df7d108e569ce18a1e45e3242c9e5a82c5d3ddf64d228cbcb8f406a02c718f58585251c92a3d2dfbe1b4aac201be8a0b2924059494970422df633875c508bcddc6b862c1c4142050918e0400941f0c10f5a78624a143068298189152ea86b846850419f7b8d8c24069430a02c92505aeca7a00402651450be6450cb5352c2a4ab550a828e0edb9beefbfd8abda102a7b89905da05937791822ad6917b09515d3e34d495b2040fb4c9d5eb4009656798d819f90346c9291439a1b6126a4751bb25116a73af4d260a3a3aacc60b77e87eab915026c81cca28375d57de9be9317bdd36f2b7179ebae7daf20514d695b244121b6492d091873a1e7c5147e9e201171e439945d2255d7b53e4435657a86889da79a0f619e8569ac8789611ba9546f5b7f9405fbe5674a5f080c7ad706e274d975018aafc76c03ce65fc08eb0626f66e857549921605286629587ae3c034447ee15abfddc6bfec8bdb61fb917e85a4cd0ab2e221efa21aa3ce42909a551ad4448c9abc507ba5294acb64a71c115294fa43cb142774a0f98d4292e2e6a6a553ba5074b2acf1a036495cb0057f5a5e0fbceeb38dc46eceeeedbcfd1284ad770dc487a5f0a78a708f3806386a3390275e84107b6c9d162127494aeaef1aef139412251a6748d4301ea9a2029d435fe4278fe8ee61ce5b042399c97815ea4458bcda0d7ae5dc70575cd0e5c472779f366240ebd5f4a1a45d0ee5d73ce3a033803a471543f0d27d4ebc843da2701aff3b38f02315ec63bcc5331c213055615e3570688a94e9f0901082210510515a850f5732f4fc9f8fe13686380986a55317eb4f118e89f0f87b5800612238ce0820f9e1401894a8a92a2ba529410d551baa418e1aad2259fccea81bba859bd5002ed2079985502a1f64b26f646cf50ba96d0af3b25892a75e421e9daa4ebb4fd5aa9f3af8075cdf2503fe99ff2e81184d00dddef8006b1104fe96d3e1091a1bce92712f99242d22581be52107494ae9d223c101922c4e542738812c172d82c101aa227922ee98ae905bcf8d580da73dbe419d72c646a83524a297d19a15b27aac9a54f368895dd970b9bc7027d2c50c9381ceab5dac9e9a99fbdfd638172ab7d1050858eccb337d293ec8c8d6b5617bbd8e5da1bf771c2c34e9156a726cf4c310fa7b84aa3fa59c8639796854cd4a2abc566288dea77095d2f3ed02d1c978bf67114175b6c0db73ab63719ef8d3ff73e393e1ca580155db03539566c229b6e0b222487165dee0d93dcb4332b54d9c6e6558281fb68762c1c3b7d674102c4548dfe3f9055232efc7129568a8e8f1d5d7bec0c7f96e5785387c3ce346baab89759f665598f16c59d611cee699f76ed8c731dd8aac9389e577bd6d6b1bd1cf581271dce75c082d7ebfb2f34c2b02116f0a4c3add01215179e7e705cc444aa23aa6eeb9e28402d76f70071d0cef0941980281561b852476e0175cdd84b7a493ffdfe16f214c752657ea7bcb0edc5de685f7ad28fbae795eccd56a7c1de6c6d96a7b8efef561936c52c47ade00bc6e125352043edef22c6611e9ec1cef48f9d057fc1e26460bfe03fee3e3506264775cf2dfc9834ca49a3a0ec4cbfc738feece148aa1d07b28a97dd4938ec8c0f9d1a2c611c66626f34e37012cb33d81bbec17fedf9a4d0b1c5ef1e1b570f17760fe3f4939eee695703b54ff7740f77646b3a850c6645edba37ac807dd6b62f49c95cd92b13ca5c19d083fd8baafd7b80dae1a88051b86baafcff0f33624e243c25ff88aa4f3a47542466ee9ce5f39ef4e032a0fbfdeec700743f0ea0b280ac22810c3621fd07eed04841122154f43d70a7c6112aef3b24dfb33c0577e877348a406d700af6d042680114aa9f9143b0b14a02bba765b034f47f601f51bb91f0f6d1609eea396937ac7603f940c70602f2f9e9d8704aed555232d895bf1dd359ceda1b5afbb7d7de7c2cdfe9781d4bcc51271dfa2c4f432e1a3d093ce9708c341a7d61af1c35041d1bb66ad8b8574eaa2f5c4771f6f973e038b3f7c62199b34067c126a01f081a951311c4d2e02d9e1a43d026eca0822521e8e8acad1404fd2ee8167a2d6ace72d6ec21f1742f5392dcdc9ebfd12fdfe09f266e29b34cd3b66d72dca8ebb876d2d3c09969e0a669a0b6696036355072a0d791a66960574deb348f2369afb1c7331e7e80666b0201beea32707377776e18625dd4a3b92d8e167160d506023155489000f1aad10341a3dabe03f9c9d2d0cfe08899a8fd1b03a1f677165bb3cb854df1cbbba86bb88915fb5b280cb5df9f034f3adc12a9200a8f8aab7144c781bc3ae98c9efb51c82b47f573e1f4930e33f3386a4e4a6ddc431c379ce2a145f5ca44054542ed22d4ee4440c77dd9b8fffc7438f36f9488df24d25f2d6aab8e27b016b59566713c15c4350454be11c4fb93984ac0f809f30c318f8dcd9cb3e7d09067fd55d143848039c4088166bdb9636f002f49dbc485393be36f1a4058030a9539b4e83f2414d2a2bf727c1b7dd40ff48f34957bee4f5fa08e621b3a9cfd59eff0e10fc43fc79f476ce3427783e6e94e0f1c0d88543fa71b7c3ca20227fcac7cd8d5de6c2c8322b6a57ffc73ff0a1db70a0e7bc375049c8115db33a001f6cec0ce744bc761679a6b151c78562c5edda8bc124fb4c59c7e2bd0915693153a9a6a0616d55b656aa1f67fc1068721e8c8ab2ee4905c42ed5ebed1a54fa4d91bff4018cf200557c50222f981cba0fa910fc454b1bc4e8bcda3c5d6b24ccbfa77a6ebf73040fa259055487ea4641c7f6d9bc724905525b055cb38923b0a9e7476368889aaf46d567e9ac003d5ce17b2ecf4e0f9a07af99d1eba2195cbf7208900838af447545d06f6172dae1ca575b354e2289b27c126dfb380aca9fa5e324ebfba895aacd222ac6867fafdc5388dc566510467790bf412e83d4cfdd5a87efe2f5aec1a30a0a73afa6b6ce94876a6df86aeadc5ce5c21a9a0bff4fd2ee4437be341f60acb6fed133f8c5f15fd96fff13d8cd0088cff60fcb72ad3778cef98ef1fb94d2191167562c075d40bb84d4316ba547197a3fa5bc696c1fa148bc3517c9f50256a27b15ab854efe9eea19de9febc40c375161e5e64c47138ee10f37461a3ffb4c1df75f0833d9a6badbb3611b59bd5436c0a086f4e9381eef6a621c006b495748a5755a0da93a840e7fb32ab45242d25a00f027240b94ad7ecb069cc7df6ab3ac39c39bf394973b2cc49e72ccdd932e736679663676c5aec6a0da3da915868a90586cbf63d2067675aec7549dac29303bc6eef4ca553cd721ef26ac74881cad71159acd8370e286a080aaaa1fbd18fcbab75205b0f1e35e4b4c826916d963dce729065342e1e8d2574a4a1c121f33a028f1a7272bc09091cba0a0e303aceaad3a345229efa198bfd9cb3a78b8e77996557a30beacf8113e4bed3eae855cff35a74abfdcdf72f025c6788e3c5038ed4d1f367d96b52f31f43c74400c099325db3fd473b1e81ab729f9edc2ca371f14024ddffc06550919ec1d3045a35027fe861a5eabe23815d58e308efa4e3ed70ef75d373b08b6c3a209020f33d1509dc91f7a37027fc618a2baa1edca5fad9fe888afb2324b0fbd1f739bd53d45e957f4dbc9006e4d12a14502870aa578bfaa26b32c6e9154f175a596051a1665996b9532144e8b845423e1d99167680f2e7748d1f3a6e919415160ce0be9f483380f52aeefb79601c228d6a710674a44432abe31659a99ce7318e07f6033b53a3456575ae6251fd576c414424c465ceb05124a47bb6fea8e85c87f0878fa7a9aee27f3193ac337f7b19ea70afb9f7eb75a1911f23f3b71ffd72bf85467e8c6c3fe76fff83fb913cc90d3cc9d1eb6c3f7af9a31dee47bf337fd3baafdaa4fddbb76a0b777a084d8eaa1d7bdf909da1e9cea4d0adcc07b2aa23813b3f3a24d277dcad33e3e97768d3f5ce9123dff37f2dcf12ee94bee577e8c310e5d252a9f446667c3be349ff23e6bd9827c5bc11fa33663cfd1f315ffa9c3ea213836432fdce8cd1a63678eaf79af43a94547a2fdc89f9d2efcc78fa4754345e8c18a6f74223316f8a79d31b99f1317e55a3cde87560defb9c7e1718cff23f5ade253452fa1623f461fcaa3e70e7ebb8fcf73a2fcf72bae103d96fabfdc8791e49c693643ce98dc0bcf7a75fd50c988ff91f32fe141a21bd8c8f21bd8c37e23dcc289c00cc7b8f0198f034c2808cf03422c9780af3312f23dc8909614218185348e32818705531313131f2d75ffbf1755a3cc9eefb585e9ee5e559de88cb7f3fa2e069149e26e0f2f47fbc7c2934c2f22f4f43233f3a2cfff2465cfe7b0cb884a7c9838197f034436e392ae747a7f42ee10e8da3fc4be10a46485bc2076f98af7d77f2b18e3ae984eb285e39ca7ff87d9c6ec8e4671fd07eb280448278e0aa7eb8f07483f681ba85a71be46baf851fc842192ed72c5bf420319e7076f886bf4b0bf8e3b9d70222f9f11e8857fd7cdf813bec300eaff8467f0a2a3347e157a39ab55d24f0cd7c2a40819d8ada4fac3711f29416fb8945f57b5dbfcf7ef5305d828e3ca5c23ca163bfb0a0fedea4a546a152c79e7e6db5e713da44f730f1719f9ffdfd0a75e846ded7053aba8f4bb1376bba8256517b8adaef4a6caa7b1cd53bbbfe4db9cf6b51fd73520ae38271d1b17b7a3ce54a84a33fa9ed4dd4f627bac7c382411e7ab261dc586d6909dda745982eec629ee24569afbd6ba309dc9d02c216c55f34631c9ebaff386c6909a774901176a6bf9fd81bddaf9d89e112fe08f231df899e72d5fb7b0c38616618413f57092c81eb1d835f5d401a47b9802f8231a0a707b095da3539e9b4aaf4ad2a853b3da85a5a42113455cf073a726ce4d5697e9d07b25089bd8e3d8fb9d7149270832f4c49c20d82d8ebd807b59bb83047a180175c7410035cc26d1a46cf732afdea021dfd365949ba267b18eb4ee42d3fa78ffbf85c31c568518589dd9f48deafd474426d287ea005a1aec9a604d56ea9fd4ea56b168a1f38a9ed24af13aae17a50bba73ca96353d9919dbaff42d2b3845f179e48a49fa4325012ccdafd764e5cee3e5050a15547f781c2084c6abf43e9d442410556ade14f4710b0c9cb77a0fbf88b431122e46df666bf1f69be1fc5efc7afde9bbef7bc9f9e72792ff43e8716bbef3cb08616d4fb71613b82b4d8bd170a313dcc77df99405675a63f02f33a2f0ff3dec3843b3f5ea803f3a670c7e5617e27e65ffe888c978ff13f605e4668c4e5613e4668e447c7e561de48ccbffcaa4c200c78f2bc303402f32eff121af9d181799737a2daef34811898cfe9aefb17701d1513eefce8c4bccbeffce8bc7cccefecfce8c0fccb772ee14e0fa10b2c60a28a09776c5c5c5cde8547cbc384405edee5c725f2c24be81296bee5dda76968f711aadd12d591e5e9f77b248f447aefe5a7c37b4a9f05ec4a43aed262c7d57d76e608f4fbd17ddca7ebf763a909d57f749ff514abba9f9ee2af87f71d53e91aef3b97efbebdef587a6412f7e97840db87256c26ce04dd41a549ddf310ac76e1c97b23ad3a9e3a7f1fd2b1f086ac76df8525a00efcea7e252a3bf31161242bcd618042726801bfc4e21ee6711f9fd1119626001198474ab90116d20c447434c172bc01a6211391a9010da81d845b5064ae6c89dabf58a0ac692699bd31406d9386041da7698e2e59f45b501a51cab5424a29657041c735350e93c9f426f762bf73e430ed742743ccbd24c4125c3ccf7cc7090954be674e454ad96ff2ed1abc9ca8ef2fbb45716f3229527351fd1c572a6da3b8b1288aa2f86aa26b1131a57c130f959de926ec38a714ac8481eeced8388ad51cc4a2fa8b4882659707d63fb378686868686868679855c510ac688868c84689ed9e4baa06e837c0def0bf176160c20a6e60454b8aaaa9b00115a430a20a20242b50f5ef2cf1d0ed5f9a22b878096e946599ccdcfe6c08322a025244f9b91fd9fcb0352b581e625326c6c1e1823a76daa6651cce1f6d3c758145f55f81c5164056342d8a3b83a371300e6a6ff00751661c5d9b6099eb9994997f52e6304d162152d0915b0bb45bcc4f486b4d261662d24269725335994cdcb6d2ca30a22a8ffe3b0277b80a223011826aa7874d8b96aafb1e58093f508d9e03770e40846aa7071a545df8b37d0f01508dc21fff6ddbb66ddbb64d2e04766021ec0cb3379155760f1988a3709d5874b02b56e3d99b05eccdb62c86e52d188bdab09db942773927aac09a703eee33e4ea9a39619b69530ce321ab1fe0cf7efb5d00dd234c01c6376c35baa05cb385f99cce55b15fdcb6ede39706c447c002060118357b86c1be1b98c3138fadf3f9b7f0f4809dfee3c84f02ce3e7bf9e9c85e82ecc407c827631f5fa0d815585151855db1a87e58ac0614ca01318c5f1c05c6da1b21416cca03ab1e316cd13190a7b8708e2ab35873526a32ed8b610cdb563144b80d7f2f549c3f1d2f4d902f2c9eeeeeec7b61d1f9630bb926bded7b6151ee47be22b7cc9bdf0b8b8e7e649f6c6a1ef7bdb068f7e31255d26b9f0e6ef346df0b8b7a3ffa6cd09ef4df935e6cd19f666776a6bf25aa9acfd47ed342197a2cb51045f3011015a029527cd0840f5c95f781947a4a48c8b4ccca501b485566679899994346e2e0a743fb2473bb3bb33bb3cf6983c4b6853b3d3ab11bde0743c97cdb3c260758d85183478bbc59b65996e34db288e4ea2e1deca4c57e972614c441b539cb3893f11ce424ac958c22daac2fb4f07892f017bdea1ad682833a887bba07d61a0a621c62d3bfb5b040671d656a373bf9425d247061a5ca3a5b3c3d3d4e5c40afae193948a86b469b4dc9b6711256d72c12bc10ab9975c76d89ab8e1b1327dc1275dca0f0a07dfaa78edb94da4142520401b1c8809164437862719af5da1b6e218ce044944d496fad6631ce26838d062d84375b3bd323076af772ed4d27d999275bd32c58d1890c5942e870a74512b0167c83b7600a75ec15ef4a21b78d3329a4ec4cffe70059992bb3142bd62c13da191b2c24ebc8ddab66493145153016ea95d0aa57bdea81c2171bd2965044fd3bd9a345e90c14e3216c8a7b7c099ef205e959a2e630900a4ec038398c6c8d0f458c6016d4de2f98a594cc40fe692f41ce4cb0a8fe2b9eb193b2222727746420ff1cff4040da90162e33cfc213ffac3900a99b132693c96432997ca0bba6bde9ea3e563ee84162c4f9e0887ab4c8630425400111fec1018beafe9de98f1189c562b118919e21b258c685250292b5f6064764543f0f51e415ab8361c288f75cf7a38781f246b8f74efc3add89c30978cffd0f2fe4fe4717ca6f0719a8380a4fcc85270e4f3eb851c885b3003756641c19be91804d4d47bd8c38a2949b9601219a328c83da1b41392411902c36b3d88589c170a13f46e5c7bf05e5b152be8959d2c002e59751c453a2520a2a01957c18c85336252a25a25295525049a887803cc54a5a0950ed2ff9947c46062ac1605a7bb36556ecc0752cc9d42dec84647c813a6177e7b85017095ee001e261f528f1e971b22d4969aa7eee82b6831db8a03047e121f0482e0579298a264c64cd64b699a7cdb9d3a212192c0e09663d62714a417c636f3c0bc7521475642534d81b76062a05310e3fc1462845c152f208ed0df3ec8d97603c25184cab0403da999e91c9d0c4401a50c662201e1e1e1f576f3c1b0f4cec050beb33783921411588aafb9efadcbbd12d33b755dfbd5178ff2f99c506f2e83c9edb9c25970dbe98dbac1d8c26edfe7b234f5c0f8e63e93e35fa97959204acf6fbe0a67bfd2ebddf0b0da8b6e578078ec0d9a2583532745654ffce8aea3e1ce53c9299997d788a9ff067836b67fc6778021d6d142dcadf8998ee53c444ec8cbf8b88eacf2ef7706156b00cb12ca186899e5e3bd34f644399145d1db3573bd8559452dc19948d8b27ae7ad98b546578818e19940c4ad6443684c591c9a2ec8d7c01644e6c75cca0d4fe0cc8068d8ba300a4dcecc5c5f6c6e548287b8d8432d2959150f5c94409663e327bd5ec95bdb257f6ca5ed98b65680201a3d1aff9e7df6953d3625b6c8a93b09acfde2c14b5bfa9746af45a6c123a884d42fbb049a8dd523b6751fda62934a8a3cc2594496dd47c1edaddd21274fb715f3054732fbb3a722c871683c49674aa9d346fb1a80ea2a141a140b08e0be3d8c2620b8badbeb8c2c5dcd13e2de2e0b5fd9c94d6f8a123c762cc0533cef28d2b5c8033a031cf68704c7e9a378371788bf5020dae23c7966f689fd31f83699e4b6c464c26d68ac528115ec79c6b3a7c683d76733a639e1e5f478d6e58096c05363565a6d01492995c3b69045b8245c112619c1a46b1766c6104c5a496491e423e74a6964919c681c0dea88165aa280af1e052d06d97710b6496a34859ec66bfdaa62d615e8d1809ab66497b5d46277b739503b9769aa69d58034f1c1259617e8d55b033d977536ba99a4bd5b490c151d53466243b93fd57b5169a3244c4556420c00774e415959a097154115b53a4c5feccfb0c052b66990c043c8176ef6ddf12e22a28c85e08771deece30c9dbbe0768628bfc3b13ce68b17bef47b1f2704056129211f7867dd8994d710a16957d16a3c6a86b040b51333146d5c0ec5bccbe03d77b8e34b12241b3f7ce329095b49881423483d184669ac6acbde12ca76730144ddb56cc4a92f164d94bcd9e9dbc6a5633dfb4193e80649fadb28c7fc633ac4465b4652e2dbe4c8b3688ee8d3675f49d83def3e7b39a44538b9ecbb884331ecc01ede77efee8c7d981238eea08c5da492fd32a6d511aa13b71b7837d719fee9b48d0adccc8c5b8d0001bb05b5ecce3a9d63eec1e22963a6a0de10ad14b6962a576df02eef093d50aa6eac11322a6fa99cfcc33d2c8a1226fd67e8e95b1def3ac27e3a99d510199b0841bcb775650b985e3f49025ec96a3560e7541d7511d8545f5ff50fb59c251f4a225466bc7609c5ac25d14514c321942cc635d33ca9e26f2941f31058a213c13a61f4a54fb5b7a3cd5127acb53eef2262017aaad0492ba527cb8a8a3ec91e22345953d9e92d4444d3d99eca972687e414ff4fd4f37944abf75f4968cbdfc9cec318fc1889d26d0f2301e48cbbf8420a93acf38822395c6057c47f9bafb900fa1194ddde7f427c1d3f6fef259c0d3f65c59be2b81271a620046b82106b6f4be63f31a8e4e1a42c35247a02b69d19774172e99950359aab77cbb470eb9e6bc7327488286c00e8e84e42366e8473860f3a6b72fd999f6253d72480e798f1c72edcc149be2278bea37994a254e0eed8c9c42c29ac82a7a4875944330bee57fc0085b7ebca35c54eccf247f5b68833f0f593df13b93253d5c61b2480e49223fc271e03f4c983e5f2287e4901c1a924372480e71b15f82c9e4ad968979db32afa3735f8f05ea8dea4f626ab1392c32728b532c7ba3bd6fcd08e62f91165bab9db3809acf08fa83107158d790ba10722b087434d509ba92c891b5d8a7f69b66f89ffc73e4d4c063c7d6ed8174c84b98498bfd3d2db678b2223caf0c8da0503a4b25f0a4d3f2a52f853b315a33a082aa877e12f4851a473c8965dbdc27a77f72dc765b093cb150f044fa963fa2ea285767ed4da9f68f0debbe832daabfe3e6f73aa58711eec0f8d293401dfa2de14ecbd3ef6080dd7209bb154e4791be053ce9c0689e1612e90b27d0aaf6f1f161eee19e6e8d3ca7c0a9a504aecacb9e82abea4096ff08ec195b68f4ad04ae2aa3d29dc78b107f745629082635490c302bdc3d73cfdc6ff01f174c5186da64fbfd3040c3d58ffc1e7e38c89f4e5e507f96fcb1d0b0d0d0d0d0d0d0d04828ba9ffe5dae3688837611a576dd854feddca34185d105ab9efa6fd49acae0a9c3999d91bf4a10c30dea2a410c54d44e23b2d22c57ed9087ae333b03b650513bce6bd08ba2b640a95de735e8d253471f87349ed7e00806b5fb3c066970ec9248367646fe57195c255c09a28a59d059e7a608b028f9f289bfa9f2c7185522a0ca1f4b554a41220b31c49d9982ca16258b353060e480cadf6aa345716796c5c4a4d4400bdd4a0a124664526a40f422c506aeac59be7caaadaa2c421d5daa94b18dd56dc712e3426d97e5a97dd7362d360e9054bf4aa3ca7c8bfcd9773c96a0ba4b8bcc1e7a09a83b94a4a8366b4e4a4da67f516c16f78dbacffb36923f832cb52b7923aff33aef6321b19058b270cf9ebe976a30217521d3606c7599615d66f83ebd049328791009eaef82d235407bc3da9b0fbf7f198b6afaf52a6c9531038b15fb4d43bf5bd3b08ff124c8494c629d9e32b91174ec2f4416d2e775a3d7c93424fce310242daee4771df98bda63c8125519fa68b1abb33bc73ce632038cd2d7f8a61f03360f55616b62be41b0b4a2ff83216802774500803131313131313131313131313131311f63d3755acce7b48cb9cbd8a66d2eb5e01b2e8be416586e3296c14c6fc60c346a78de7f1e48f242160f005f8f23150429e548fc1c42d1aa04a384e3100f00e10b381ea92f1cf71cf773ceb1872a69805bb97ed1f88c4696f18d396707816fcc6739c17e398def578b5387add2f89cce6830f734625cfb74c0bc7f3a5abe7b79f9fd6ce81af3be8135426e95688033848cc4e56780233d81a358c766edc0756c96091cbb891d5b5d1e06dcb1b5f42fe0c925e415b34ea59093d090356d880509b39280dc6225edccd3047556e2dfadcc9c85aed448564d2b6931eba01c3970e0b06143466646cdc266b598a45b2df628360c06ab30df9bec73682b1426a401694c4197fb8d7f1cb244427ca0dc771dd74a6d67f1b71c41035c155bdcff181d69d779def759a13493d2339166b098583e1d2e54a0a34bdd2f955a5ab8a5bf6bcbfc4aeab90ce56b67b8c4023ae2c061c3382acbce6ad6e3807eb9847ab88458e5a1d70a3e78c206568879a1c4ca0256aa1481b503208288c29fb1a7c4bc0277a133edf3a7830364ed70dc76460fbf484dfbfc82dede182184939aaed0adbb4f2bd0a7fc26662adc59e5ad91b5bbfbb9669c05f92ff9e5cad30d5c37a769bfa97ffb27ac5b19d153fbfc947f8280fbbdfd35c9999421e537b192a6d9ef42192dd051a672cd768d7338caca43577e13ff7216405039420fb610020b24f01549995ffa3bcbada3c7dc29f85c4047b97575943ac8aa815e8b3674cdc2199537ab5e3d1ce255538b47aa5fd19df8d74a10b4042afafbe23edd37edafcc76f300c511aed4f1852a14478819d16304cf4701f9996a3a8a0c20a022c88b2428410628b050f57fbf28c39501622ade1b96dfb97b11dd5dc4506d0c643eb2d02444d6ff627fa5207eb660ddd7dd86a8650c6a3a78953ab89419103d488cb8669e216eebbad14876a31942f3092c32731db4d9190508715010e36cede722b9437ca507092df34fbdfbd66c8df6fccb1b458e066ce10216c7866feccd4c388a432b29b47856ac2ccb7c0150e46827798e9393cc6d6c56ab259ff7813b358e507def4929e5cf9d917989a75a6888a8ee78efb455a4a72c948582279dd2d32f5196aeeb34cffb46a3f91c52efbf6e354fb73a52d78d360a9c54242ffbc055c96d1bf5f7d34dde95f2d341fa6e7fa8f347995aa3ad5e5e0359f5029e74b41d1a68a0d2c23fa2dabc916f100332a20ee180a42083ea877e134d12350d130ad09445cdf7c2c5851649d46c8ab69aa2ada690ac98191636e3c26661f0ad326d837f035d8b46cdd740b7d2a8f939188743bf626fcc9fa1578101dab6855ad8359bf7457443c2144a88a8433656151bb0d42776abd829ead4a4486265606aa2d2273b95e84693c781a2ec8d6bae3a1f0c03d55e5d3384c52181e6449dd27b0b77b470a79dc0411155e6f33fc1821ed5aa7ef0329441f5d33f524f6699d795d62a0ea441e99aeeadd4a969c1459daf29692d4acb2d16355f4ed1829c684cb425754a31cc4d0e6553e6f30ae8986553eafc8cb537412c07231c69296339ecf405daaef6995ffaa1a3b66a29ad83a6da75de17d1af6eafb1be1fda6b2b474d213af6f25f4447df044eaa8e396afe8c1b94640655d4215a900d2af73d744c50fd501a68a0d2ac8c80e66b3e6c2a5342a8c724035a44a68416449daf05b5b6da1b5aa75645a352a736a5ce1c47cd9f4e289428757ee664b3a0d28f59941f3328757e49093a617842da1c036df9b15d4218a1178661c73c7552cdefbe88f22701ef47f9a57f09b905c4d13aecd84ad3e27c0778a10e0e8281f2cbb0c9cb7b3fd2786da5c5096b717ed7b184d3498b33943e2dce1f7551f7f3dbca9c949a4cffa2387f63fd026a2f508ba201b5389f6373526a32fd8ba20b685f69713e4bd85cb4584aa263b304ce979f1fc4533da7178ea68e796aee7a5fa993be8014941d9b3fe79ccf011a52e0a4caf194b65ad4fc69a2357ea8c3bae6fbf95ee45a304eff7c16d0b56871fe077a518bf349a05b69717ef3b5559daff172ed56355a345b2b95fb229a3d67ad3a35569dafed6bab3a75e85aa20a3aef52366dd3366dd3366dd3cbbd0da8848f3232cfcc6ae4f38d4d0737691a8d8b67e329207bd33a8808cd4d4848484813127a5941d35c4fb2a2bd59c06c62f9099682498f93915d40d9534f11898d47eac643e6bf3de7e069b6a669446236b89e34b18d9e7f8e7ebefb6bdbf3b6853b582f2117d00781956f05eacdd9d3b5cbe572b95ca2d744cac6b3e149bdd3109b4e0520d6c307101c821c41054b6abf102299ac1929cdcb3021a567a876acb6db68a38dcd368a6d6c5ef03b03d24069220731fe66c080e6e4644bc0529359524e606b6c5adc1b4f71bf35382b4a399feb217db478897c6ee2c8176d244d9533cbb2a6f17ae8d0a183078f1e35eca723270b743ef7aaaa45c9afe2a940c2f468cedc178f1c1e88744dcb68f1e8a10324480e42861055f945b8c763627ad3e3b839475de7795e3712a2fddbcf213655d368e0a47afa02a5a9291ac6b1c1389ba23e034d77b7dcb44c521b94dac882903904e46712f8da64be3761bd6a8638342a0aede5446df7421b45749b9d7d607bb3413fdbe2646f3224a230139591a8a42a7d8abc5f452f29b32c93742735f9b08f8f8f8f8f8f8f8fa68377a1b17931c786125594a8924ad90c35e1a28275a52841a5f6fbd0019249d6b4d065bafc6b8a0dfbf330acc8b5b96ad698798ea5f11ef3664a47a4c55512beb149a628d18042d76a5996c5aec08a7634e19e0b89b4be5b318c612ed7e87d549a1306b8ef420c8c34ded168f4b1cc5cd2a90b6ae447c77bee8d783f3a7d81fbee8d8cdefbd29f1ca03d3f6b7fa4e674b7031db4a0832e508105152796c08ab213ff0feec4a10ea7337a6f860d7aa0bb1735aa59dc82da3e6a168e3e682a6fe1e8a30ea1711791222ecee9c1385c85558257478671dffd0feebb1f2358ac5b0a76c1240c06d333e2ba5d9a673249e9c2b50f1d202d4e1c3962a3396d484e7e0d5d336aa39739da8fb450cc915303af60f5c3ba4be20871d8b0bb7b109447dd9e9485ff3bc75cb732f708dccaf1f06a9c99c7365a9cdd95a1dbb5628e818e4b0548901c1ecc8393220bb302abb230180c0683c160416044789fde7738a2ea013c1c15509b43a7f26159cf77fbdbf8f51205c430e402bad00aeac0ee25217a0b9b066e2a47e6780a3577093be3bcbb7c032a39c6065486a26a82ad0267e480da68f1f57a4d6dd5fffe7142a0a1d9deab375747d71db465370dad25b20d507146ae99cb6629b9a64544cc65b3dc416b16cae01b3be4837164f00ddea6a7b67046a3fc7d06cfa8025d197cc391484d930958c1aa7b8f94167851ddabbb4b69c1abbabf96491baf1965a8c05d06e3c870e4ca3832ec52e0eeee321c698ed8172bd536374e8206f117e2efc31f480f8955834a905519e8c3817035ea28bef4e12847edd8ea655926b7a594a40946a12257fb8b9c7476e41fd93134318698eaa493edcc584295fd11d58c25e63a6a55e20ef9d08618751e696e1ef891c0554d6e82a41f81ace2a6f61ee3748b6ff477cbf309aeaa559a67a49f3fc39d8d02062a5278fa31473fbd4e07573c1952ed78e1e987d7bda7b14045fa1e3421741ac85038891b18518588b256abd51d148eb2333674e5197ee8d8adbd522357dcf61e15a2bd61bfe229d2b3f8d843d41e626fb66ebef2d464798b4322cd63caa169f041c3212df60aa9627db822082c6a7f115b04c12193329392035953358bb4aa3f1d4568abd56acdb05b8ee2e9d999245a7ba55b3d3e2d1eee56b7b266e9e956e64dfb733a0a0c02dd21186c0aafb620bb40787020101c82b4c839bc7a91c666b562d9da12d875c564da2b7b25c685daef2123e9ee7cdfebaebbf3869e8362e5afc8cef4bf1841b5f04ca659c336662f35229916b5730c59a29a85392df2201908ec5a940f36d5635908b53ff31f4d3bc5257b429946f5f7d31a5a34b95c5dd3cfdc94ad674382b917cdf270b97e467e926488a13ac4132256250f5f21a15ef56a6fb2daaf8dae4c111ac217abee73ba0bb9c777b84675ec958f5e7d4177f4da6f1c3b4d2b5e8b3b982c94854242aeb0571c8c9df00df451f97908cd8939f0c49db3500bcdca3d424cbe5742bd1a0ab2335d5aae575ae633b4817fdb4e1eda504488a7b4563bd33e2caa5b4170aaa8a8444ed475410b959a1100001000002314000028100a064442a160402c9c05e11e14800b82964678549c8bc328c861986206116390110000000100c868d0003a1fb1b1223f2ba89cd36831727e63d4ec266b3db9cf9a7e06cc25afa8db78b88435f22726a805ee21030ed594ad3cc58bb096d4d321bfa8399ebc1aae75a8bc3547c06c4b98bc7da19a96d3d18bc98b14787d6068a6d466b108ca675c4a9d266e864e8fce1cc6a4984e154581187a2a2cb5d5b31b58f80125bacc574ee24e93f0bcbad0dbe7bcd903c84107a68b2b67b502d89fdc699ac222bc1d5c12532539dccb1653004bead6c39e308a0910eeb32b567161fadb2265a84925b261422f0d285a07821f64f666ea70d40f6cc299f22b8cd6ae4fd4f3621da50049eed9a59cf79932888815337073e7393d3326910ca2688d1cd0881aa53b1d16b612aa28d189751f5738a87824da67aa390e429ab793590f4badb619b12358423ac9c8142024101b7390b3a0264c43a0cec0cfdb2eeaf7b9d736e88ca38484f865825d8761c5c553481baab92662549d275ef98500a33a84bf419abea396ec3a16ee48346932158e2567aef5f8eb7e1fd792ea9da5b2dde651127b6be9a692205602b37783e6d3cad462de0735b071641dcaf79b9f02358882e227448104dc75d27239b9d2d67ddfcb91c4b42f3b55d3f49fdc8df249d8ed3f2ce10bc9b07ca18e1533e861b671542c2382fc409a7a1d996a617f694ce28f8380b43018ec7d3c5abc6bd9b2bcf6cba7ae668caf7cb1725c13046ca888b190b883a9c8c633e29d375fe79db76b8b6c2204614f12a39017c971d256a28096c02c3b4484302070fe3c4d3690e2ff819770a686c40c77a851be321b34d8b5151c5dfdb7f4a0ccbe42b753a3e7a998cfc60e8fa54af34a495d0dfc1b2d10dc94c0b68d52138645b4db80cefe8380675a0ef761725fa3883f619f74e14038a252b7cdcd7131696852597c937129b32ea26e36f1e72250e78ae7654151e8b4b8870373d1e814a9d4388793da8c1d7436e6171f9929ef82ed92678e2db810ed274dd5015af373f0abe62761df22e7874aa762d542fbe6816e79fdd6c1390ad452ff2117609cf0b74eadb0bf4104c0a45252f8c05ccdfea56025fd0287c77668d4eae6a0dd4ea3394121d717e250ab305724456e817278477c422f4845e9cfc87dc283f17c60a5a929792a780978c0d8c2a06f6fb534d2b0c0659d42c4a69f5baa421aae3a9984a30b90a540392370e6d3b36ed1084b0d13ebfa8c88e0d8be38417640291b8dffd00e801f188ab88c142d55230db86cf4954c0c8d92a509acec61ff84fca7f6fdd72c2521b086109be548c52526ad3ad706279ee950c97fb1aef9e5a4089291d9387f1440d6c26cbce84a5f9454d09b976c1dd65004ad69493a7ed37226b80c916f2a96ff7ee2da7830a5b839230e5e84952efda954b980a007927dc2a0c266df99d62abbc15d59cebe87d1dfaa924bcbe563b7c656e71d33ce865fbdf1a67f4c6cce4ddac9fec310c8f127435ec08a8a8b1f06986fc417a5a55324b5fa0bdf489aca6714694a6f4c52fcc3af232dad2b0e56f618ccb72e348ea2c5c94178d0c7a2ff3edb740ff153b2723a4b4c32f9c7225543511fcb8d6901b84ea8f98c459c63a992b05f692cb1982e85ead9c488dae711c9a5417449a9b01a4966d3a331c3436cccca580840a2672633688b90d90b764d969bf07b0f9016776b2477c401a9e683543548bfae79ea2fdbf9ba3589f2b25418a846538152ddbc76070a1c1c13f13d8c6a677d19fd57df47331d205323181da806a810b265fb886bedbcf497fdca6bd22835c71d10cac99cf97d5e48c39f0ef00d6610d888ade193208b4bb20390edf4ff77de33ceaa9e130c47a3392a834f71ba6c4541e2be921f1dd45856679c07b7a9c4018f9982c546321b24a2f2807f1f47c886418cfa009777b38a0c0073d8f82e084d83d85c57c297c6c4f04c8824f44d7e87219bc762eb0fe33a1634dd6af369833a691726f88d76625baf0f77c9e115e1de21eabf6e5973393a7bcaaefc58de4109260cec03726bcb8406533963fa3966edf32024d1f4e6b4c7c4900b8b99f59f29e8eb6673884a6145174a5483f9529e326fa481f3fa589bf3e6a22880293ccc83c7db87ee052889653ffa72c0d12c8fc61a7564e2640f43916d84d3c4a00dc2bc303c0f39ad5177e3061adb913274aa2fcb0616b1ca18b87a3fa263827fe8c800c6c279765c7c1e139fe82881508dae3b25641dbd9faa4fcfa05157e674cc2d7caf930e03816a1ea5a6fd04e718bed0dff0ab3e3712ffcf55cb10783dab854c53a3207526fcab5528bc1a970b969e692ae1bd246974cb8d7ad0bcd75a2fef9a8a5300335f6a2df7a0697fdbe7a4df8eb4554b5a99b68c9ab18a702c95cb0d68f37bb3d9ed0ca0b7e9529e1e0f20cb3aaf3633d2e5cf965fe299985d6d3bea1ccf56250b673c0c02333dd9707b05f4f3cf592cf9aecf2de2dce55cb58216d701f55d13a4fe3c8b2dc571ad8334269929dfe1f897e5ca3e8eeb79fd90dcf3dad194a71c6a5d8318925bced32ce2a1d9cb1c9a60031a4ce217f343c1b983a06268cdab5ec739a8fab24a3a4bc09e06594fe466ace69616e33913b98cfaa1c9d0ade73ecc28dae84fc61de020b9642caf9d355ba2a3f80f0d7adefa42a8cd4a2b9d19a8cfe4350b05d72795a6f10d9c6946259b4195486008e4fc3a1a46962f93db88ead335009676c317fa19eb317cd880b67b9c430a6916c0eb170f1303a2bc14fad284f44f1d40d033a2ce351f14832baf6d2518649ac9b0ece162edd4e1a8615a0d9c60356d3cc26dd6b440131e5d5add2c33ee28ab21cd54d9e1f797b5f88b6d00ab59cee04637bd2a6ef740f221c6e5a4dac8fdd5a2f9edb3c6bbb14f5366b25a1546e6f353b3bafc78d8119aa3849569e371539601f49dc10044cf38bd605e771745c6a643d6d03072172ef00a6a80d2e29900d5190b3e6c9edf421e3e676fa13266382f3814836def16d6c6eb0094311659a3b9f8428508d62cbe6eb073cd178acb8501413c8c6dcefe281d6b14b1236cdc9ac519aeb4aa58d8a0d3b996faa144336ce40eba5c4d2b4f8fa4d3689515fdbee31f26808e19e4dcc16d4b503d941e0a81f884745ff47cb79d669682faf0a5538df11a8861bc8b998298c123c4675b416130f0f356585480da6ccae7ea16d0391982e91c3566b236ced09ed2e5ff349fbe04e38117e22ac5ca07c24430cfb9f85c622ee62f0531be5f67170a3d376aafe5e482cb785021c1e9137f15e7141be1749fa0b1fb4dd27ad1f3c62a76a02f020c3582e9ca095f93a4eb2ace5548f1557b3b6c1ef19b1df82ce0cb9055be50126be3a1f47ad1a299392d422b5df2d1fb466f4bf24ff4f1f823a40c9c5519e821ddbb2b6934ba9e824bbf49cb25b7f1f038d49599f292fc097f986b42b4b4a7f082d113d7e0866f40bfcdb0a843ba070b40e1e587474a879ddd70bad664973bfac9715a57089c8d9ec942ca314e5856e1d9c7062fd76c34fc2b39ac06c8d176b4f228b0a415f39c3262d76242d8bf9ac18f47a5f5956571987509c3340121f8dedf68cf3666f61bcb64283b59653b1d0c250c9e6b9c7fdebccbb9fa19a972552ecd82122749f62bca6ba09151dbd253c4897253a17df4f2402ad4f843501353b111d6e19abfa984012e005a85c06107d79ad34a1a42c5becd99342c4dbceeb453e3e6b6ecfb557eaf0868c915ccb15ccdfb8b57917a6133587735a5c9a575e1da5754e81bade65d89c01b609be4c765af7b223e14a27307caedb794f4b54936f3738282f0c402747e529391856f5d64807c5555d908c4d1cd663c74ef9170d7710221f21b5a22f3d3302433a488bda6ae663afe7f4d7c20b5c33da3b5be31be901029deb01d619f4bc389e9ff2565e4c1467a91f97e405acb3a82a4106c14009ae0a6c534715a86beabf66edc0b809700c7fc0ec325c8b9ea2ff3e61ee7d326c3f7a7fc32b4895c8a6e8a9b4405dd1ee38c3194ccb457698886626f23e4d2a432c8d2a8d8cb404780bc85bb9189c55ad89e104320bef3c99c03fe763af2838f74d1ecb922647dba18f2189e83a7e489cec611339dd9bcf5175a85b8dc483244ee7afe000f5ddbe3ec5699e3a227653d58ed0a58350c63c5108a52c936a1a56f8c8c7be0314a21a3325b363100f903ed03d6c4bcc6758a745368e59486df34be22eb582a0fa5943370ebb64884ed9a002bba9a1332e87e7411fcba66a037920f014ccd2e39f71c122e987b9ccc29fead3848a9fc56dcd64c30cc2fef47e3843dd0233a88a1c0cdb5a23466a2612fe9c30af4b4f2c02df46063cf164d6d046fa46134c33fc582b8b610d5757da1a955fe38515b2333e4fd550ef4ecbc8483f87ce73d6dbed6e19db8dbb1acbd3d65f029705bd21496a85f73534ac30bb305132f6eceefdae4b498bc4a62b6659aa96d61bde784814757ad48cd4e51395b6eb8c5c81224d6edff1873368c9c70a21d76c4980d00766f417ef4d3f631d7a6d2bbf3983b076e70ba8ac6c3aa824630def50a465c67306a65738c6461698aa952fee0224baec0220b9e63bd6c3ce3aa273ad05555f51c956945450e960d8c92b78f07a28a707443f8ee10214d6f253ead75b6b2445a689043910506b97a6cd18dfe684db956cf286dd11b27914af8097d9762b916df6960eca62d4bd7316a14cd7f9d64d08162eed57860934c96e22bf9ce63c99756cf6125906fdbe8d2680dc010ea3dd59f18d505f6a61ae9cc8ae3c1eb0182ac2f9a43e012c66263baabc52e73b532a3479d4a5f1e08b9e8c084944024357323d372e562e833eb382405e3377ef31bcbd1e8f798ac3458df4157f975fe9bf9ba66342ba9d68d9bf74dae0903f8c6f856e5d4c18485ec1af2990f5e33a2e438484a2e9a71d08ca6073e12e121b7afa75a6e362e6248369d4112465a0eb5a9b36283c649cdfa8824e059fdbfdc2b6c54159aad5ed713e011956cc6dbee373a2684b992781d9b98f101b86b45e87f718a84a8e8be652208c80445db0e8a92238c736b5317840dee550dabd3c181700846f2be5826220c50093693919bc49821a37fd9c40c7d088fc1e6686af713098c02bf0c6d4278d40106d4ed747b47a1954f9546a633b348b422f95409f423633e6119e398fc701107c224af7b95b886af9ab89e24efe084381228e9cd5b2aedadf46ff5c1171a7015d70f757037f901f797b0e4cdc1d8f229430dd31c145cd70f7d36be512ea527550d0da847da0c260c0d34df6d2c513f3f0d5f56a2bc23a74c84687ba9ca74da48118f9bfa9832f4fe4528969f1a0500c9dd915f24cc164a0ce912796e27565ad0664c90d3451a7cf156a6135ec7e06fba35309378d96804ba14a86c4240785eb458fbd9bac2d16278e06da6a4c52821083da4c5731041f81641d4656da405c451313b8af5ce6c1be861473069bb47e5f7b73578b0c6477187b327c2589ea415bbc1dd9863d2d4f2bf1ee15b373b57364d2316a1c8aeb4ab7ae0360b886b16c6bd29a5bd0bb2f2726633c15ac30d81a0cda3d87d9f82ebb1f37ae784caa24715ca37541ff5beeb63d1b88f248e0821f45036074b6160dd168f9abaf64cfef00324c9c36cf85a01f471ea50c1eca68b24514741b8a6b949b121fbe0234b3a662aaec89a0854c9ee4805f07e51233de511c254aec8314840264c4c6783d34e829dc005be759c0988ee913504fc72aa9c1a48ffbb84a12aa52114cdecee3e5596794c9c76ee44523948feb83489e126399295061e2fd758f573f702258a256bc3a6ac4f452930629ca876d7c9014d5993ec9b6371489d0de7a3cb5c84f83c1bd7a0cd529209a98703d0724d2b1635ce2a69eba4477674129da18661d62fb50b655eb3b1eed8c02fef650e7060e98bd34e86459ae92a7ae39405c80b8e9384bd08745f08a2109fe845e0edad6bc8a42ac09e6ac4c08c838e76c0717e0a6dba282e50a68c6dc7288f5cf511b59895495210158e0ab9163db3ffc4dedd244de03e5ab583681e0f5e414c47d93659c230cd1de481d422226c079975833e3ae6ac7610c524f8871d3467b81cc290637d426619afcfd641cc7543fd39e82e1261c7391846ce3855767310d9f55c13fda0b714209863ac7851b5f33c9a837fa8828e32a273a40976d6f227f15e1fb07d9888f82f379107b3ce87d3f41180208acb20f0e9a65577aa29bf83238ea59319a710ff632dee3b375cdba1282517008e35cbc46d9d6d8792d00c48fe9d14f05912798f3c190081da2532571924a06b8d7efa6bd998010e5cfb5891b6f1cec552e2682dce990684318ebf7080e8c7ef97473a47c9a521ef312b0f8ad9207142c720c6e3205d3fee2d0ec2a68335a7d2cc4aaa65291c89c467d66f228759aa3706c4453fa4bef6bea7d3a5ef11d9a767c784f22a94cb22d6cbf0963b52ac17b1f783c3603ba44b8390b1fc080aa9e95120fccb44beedc674dbba041ade71230474d093e6a1be8595270122c8485a904287aad10238cea2ed37648f969278fbf34146dda93e06f2bc0acdaac39401c89f4c715498a74b9a010e296fad9d254cade699880410c8cef5163bafc619e62fc48fa042e90b8c9d670a46b8feff5bfd2238f700241dbce836fd9bfe3954dde9abcf446b88a6a1c177af49f6b2aefad35500491b70ca2918270f151af526501aad0148ae31ab11c60cf1536313aedb75c3b63dbb4ba5bf17ef95fcb8daaf8b4972b85313b1d9e42924027c4779721490de03c1a40b8dd9c51e5055437a713a430628cc55f02733bef3e914002546055c9496832fcc04eff024a6cb6ddf9408869bca84da170b498e4baa80c5889ba8a27b090e6fb881ea338ca202267289c7ec3b2d079724ffa8e0b0e4ee985eaea78011577f77e2c99f1084b391f105375878280d2df7c8be6077b205ce56882d53f15eb26e0d20503e62115f9245c37199e54016ee5ae091ef130aa9e618f01cef6028f0860391a001ec4d8340af47c44294e9f8bcb70fbf9d3610d4d95058918f4c5176b58a53a14ee61dd0c2782be10dac56a8c449b20e39d97585d6f7efb035ca8ccb8dd927e464d0a3c24d3f926f9772810fcdfdcdc05ab66ecda89fb0088ab4487d7935f057c447d28f96dfe7d0de41c135f322d79ff32ea0c21768f255a8d02c92c72eaa434427de2c0dab275449bd790281351a89f8c07e891f8f7fe31a86b49e3db8f9a647acdc10aaca73c219f24fa63895d550ad6a9f91245b233ed2732ba317046bcfff1ac5303da391a1b061be028a88c066295cc00617585b0060e3338f63274e94b49a3991268f6af222e9cbcfff772dee8244acc43ac02d63b0bcbcf502ef604e3afdc8fb915e539ac48912312f09a32b75db97785394ec5cc5610b421ba59ef7fd6d68c4bb18261bc2b8c31198ca3a162bfca003cc172a6d791f7961c3e013bbf1a02d10e59988dc07efe8cc145cea871f0892ed02b7eb30b52087c146f4d7f56329f76e4b3176085f9351abaa1313e310c229cf1c63602c378d59e14f133cf2e0a8d3853f1d4b42cb0700501c2ab5f8f0d520f0643b8d507c9b071c27b2c12640d64b74e9ee25d377e405091c2e08f1d27e6776934df8233360e7906b354789314436bdd6e6f472f8162cce2391fa9c9e69c02f4580e031a1691271b5c754dc1496c481e4f6ae3024a409c06bbe7407e7cb3a214ceaa8afc9c6a31c431c850a85207353f1e50b46c1285de9d635bf752664160278a44668c25e4ddc16a8bb3de55760bfd37cb598e5d90cac08bfadcb239dcebf303928a0a1d7b8c03228a0bd342ecd269ee4f649d231c1d919071032559a74b5acb1d570ba44a3d3808c45e2e00f9cce97311f450c2a3c80cdc55c4592e68cc161e8d334d512b5b2ffd6b544f33228e64e8b0f8934b97448b73f7537da7c3932411e678605ade648f0a14659eace8b8aac586eae5652a96334c34d982862634695ff6bbba5aa89535dbbe81b681ade403261369c2d9c91b7b989f56ccb31e114885d409e43654b083d4ffd061f10532b2e2270325983919021ac1dcd90d79861d261b96529ec5b4d93edf7db8cfaa380f88e493849e8cd5803b0ae2405599f8b1d642187f16ac542d6f046c71d51d81787c92082469869083b02e8d3407cd38ce3c809155959b68b4c522196b9cb18c7b918357223b0b36209b752041b86eaca802a6ac3ddd14dd9930417b52ecaac21f59036594db2a73739146e3c150ac3563dce9f2ca1a646951181eeebe1b9714d0bf09c2a2e10099dd7a95a6303b1e8b855e0f7adc9ec2e0de887e52516b6c8b109b9ce0e5de2c3355f399e8d2cb320d59ddb673ceca6102be48caaffa499e9803c1c2a6db3cfe94aca388d4565c7deb1ef582675adce798f3991237f9c8c404f8f1659dcc90f16ebba1d93f65c87c1206ee22a81400af61d80eac79a6d03d7b7ce336901c6d8445fbd06467e2f88b825c165f86e7196cf8647691a0f85ddb38e05b47aa506cded23588a287fa5020d5749f9e03cb929d3e68515513b6ab94db8ebce973242c1807561c4639f07182e8b97939de4aeb9c3ebd8be865f9b8c3d5213fd9de5c182fcafa95720524bb280fe1a575c8390a06c1710518a1bdd9fbc1cfbb2bcea035aae13f0e465fac8b6c2acdb4beeba0eda78a0c36186bcfae7aaa03678ad4a040e6c144659051182cbc704208dd773561d5525242fefa12c07e65a784f30aecebdaed21d7a100a2b246ff668ae426d0f84215d5fd60ad0ed405eb470e6b07229911ef9de611225a4fa573df8adaee7418c489f36252aa9772b1172231b6480fc0a6a98fbb001c0707d5de788f45e82cc33f3a18c1ecc17fdb0349264b9ca9ffca06632cd4c32dc362118928230a9c3b30824f3d8279a815e768d6db2d687cd31b60112d5b3dba02e5528fb4ce5adb44049bc00da722063faf8367188e4e90d9f413a51b17f54082f775b3325f45f5bfeaa9ecd88eca3d187fa29d3117c88a06c48a0689b338185885888aa0cc4f429a8b45fc1a9c1da95cf70eba4c9630cbe5c867a2c812c665f25b75f9b1e02b7fe62989a04740005b4a59c003498b1538f26ae2b8bfe52e3cd194e880777c61ea876546462afa3f0bcaf253893608cc8af0d970a66d04d701277bbc5316239540c208e10d6a03560c85434b776c50c889ae7f7ab4280209680575cd2c5337283721d7cf776696361c85eec8491d3f6cb5283a78b412da27aa0b9915b25839a07c2cfe15f4c85f296a9a9ac9c2f547d714b36e3b5c30833a0084717321531108333ddd5892cd6475c0fb4427e778d7eba60971bde231e30803674a5a8d72429d7e80b73e8628668f689a272718663bb8c36ea061ce8f3b569f640f1ed0ded43e4b06ae086f576ae43c9c8fe3e13cb189e356fd491369704bc03eb86abe5461caeb4c41757f84275b1429102dd10ad0c058f218c63a5217078f12ba15d5b4e49d654e1366daf0c3d7ac23dfbfd00db5accf85e50ba04d4987354d0c6cde99885cfb493f6eb659ad847457e96bdec8353d63eee230dbf10588d3e8ceefa033094d06022f5e4fa4d271c24dc5c44c14eb129aaf3750a2b8b0d054a14ecfbf810d15c376d699646cc13a398a7369be6012634783cc9eebfb1227796f5e899d7c82ba33e78897657cec700c236239bf404ac82494930cfd75e7798dceb5043ba0d2d86899ea210fec7016b4bb62669dfc458e80815b4f091e5809f8415850a405de818866c063151f0a7c9846145a0cd474337f32e097a698dd358fd6b875fb19b11c665929811f8a94ba0ab7c0e0f86523ad857d2b86664b73c97e0322fb768dd76152c54411ae0f66b5222da9e75da2a44582cba237629776a3631c40c5fc6054d71791d1410688c27126f2587709a351f6eb7ee824f02a361ae5e0f0ba9ccf957c34cddccec037b914bdd27fbf7fd9ca5bc71421f9dfce655d0a0d68f1d298f938178a86ce1b2d1d816d8254e309b5fc8a2e98d59a51a0200ad10193b28c47f203f90da304d7994b5cbd450e4a2ae0688fe9202a92dcaff5d8873ac75f086a0a3d0940c64a5b551778542038706bcd4f805bee6963be0d61d953b01d138cd61ea38e1f675264678c6a98983d5e944d45585784f5b0529b8784b111d2bb5da7f6dec015d7ca4427e69958db255db2efa6e758d01dfcf219ab57234bb0b9c2457b642aaedcad7daab3c87841389f20659ea80c943beda43b4f823c2754144cd1d9623038808302a5d8d01a9f9e47526aac661d0b337fa1d37afe3e3a9a8f2ed33e6055bd14c37d348c0e6bccfc843876545426b761da51da0417902ea1a3edbb5080713b8b2b5d4e476018c9e265650d171d103669eae766456fac5f1aa4fc051a9b6e1338b90100f60eb09f5d1eb3b177a1b59ff6513e7450223e0022a38aa8050a91590dce1ddd3c2bd86b747933b2c9eb7f8ad86569f136e0a7a4e186ad370e17f5ad12472605c8aee4b226567e3dabb31a3f3c03fcf40ee04c2211215d38785bb48e7397b39027fcc2a41a299f9c3bedef8934d4b21b8a721ad7f1fda68769818bf25bbe68119e8c987a647f42f04f5cd6af122f2aff4fbda3e0772642116c2857e2856eed99f482a2853941214aec79b9b03de9a26cbd5d1bb7970d5f2b244d776440783ecf43e93316a5bd94338ef6c583f905c83a46ed794f974f813a89bdb65c06abec26f1df66e17dc1fc395494dc658bbea6caa2eb189f5217765ced87917c8e76a3d723ce77f9d33530cad75beb6c8d7636b1288111ee2558dfb367138a81f84ac1cd08a18f038b8f80172ad61055a31afbbcecb30e9d3e4b19d176036a62db4d276027ad5f1d408b0c5be4148e7e41a418fb0caca683beee0335686c280b62b6065c2cf16a3f7c2f6fc208c0bb674ab69ffec8235b9267aa52f32642905c9639ba81e165921119b6ac1b4dede3a7f1626b900942f6d55861fc7ec3f6dc105ce04f5dbe1e31493645a181aad22427ab1347465b657df5c450a9716601a7b8e47833b499813d4fe0af8a539820b4fd0e0fca4c5ff6d8ee0f68cd7425837b5a7228d8c2d4944340f76401a02c717909adb4e4d4b57fe867a2af20508f623410f60728225ed9aed95ac07685c12aad297bb1c2b4d74a33ec4faa5220054c9d2f0c08fc5916e0992410820716cef19d6f64629c496a803adb4ec706aa6df8d4332a24908be79639f258aa682ddb3a58fc99e8585c44c62178156a310e2aecc97aa64f58dae1186f5eb241330e3119671147745b049992505048422ba9bb2f2d8fb2d88189ddeea94d9743f84b3aa087daac7b85ceb2e178bc1b4a69326966e35602401a2e21d3e58bee813fdcf6467ed63a9f1db91f9b31f35a07e58ebda9d9b2178a9dcd9818ad5a14fe01820c26aa752c3c951609af4e89288fb945b5d195d139b6b8e84c8e2e06eb46e95a2bc27df9e6ef5fc1810d7e0e77c2c02f866e1ee15d34b3a1c1adc41f364ed6711e8722b4bec84bd6cb7f3a8664ee072426a2fab619003abc80e1b404460ce24c5323ed994b14a9555ef4edc1e6350ceb5d97fe8cd35b398d7af8903d92fc3877562d6b720efa8b6fe580612452faa1a8046d543305c0c66bc75d40b154382d3f0fc59d5c0543ad85fea14c563a6238f1f12bc3aff21308ead87c40acff12a3d3992c2de7dc77e4769a589862ce6248413c33d1c0db2fb36a0920e7fb2cf8d872dc447de6506704b935b6b4c0983c315d8a5dce4ac613824fa65cf631d87449a3087e40cd3ae809154a281a45351b8a822921ae9110489fffb08963758e38cbdf7072f9571be9120f5e666002d342716b6d6042e5f975d773b009480483b31f0c5773a86d997fa4edb098fd41eb5d7dcdcbe4d210232d4992f5e0828ce1a33a9aed061875208500e39ca47bff0188766a48816ac92fbf22597220ed6ee83d340398ce84708d03e4f4982bee46e58367f66697e9ab9c58b3d63375ee001be6f30e0140beb42bb6dcfbaa3bc8518ffa748d1c1822f02228d338e6bb33d551ca9382e8a0b78976cb880da641f85fa94e002db3fd53e3db7628ab88f23f74d9ebf176ad0476fb53b72e64186b2822c6ddae58187fb828c693d4bdbb6d42a37f8db34d5ceb60d2e93493a30ba880a2263bed4ff4738f45cdc5acd71d4662cf77616e53336c07d6f0fff990836f6f9386c72c1d88ea3f82cf410b1350aa1cc776bab33f644d26e94f3a7d7331307cda680cc175d7907aa861b047f528e3048cce7dd9d8a17f1e8f06507c4e5abac370daba429d476b85284bf4d18ad79eeedf0ada8f4a70d4a3f2dfa964de174f1234d9097a83ac8a92a2589a42099aa4a43297aec236d4ba192413b7d8235aa888176852ae4fcebd384719a994706bf3013cfae16c214058dc6a80b1868f21ec8271833f271ccfe06f3c0a55fe918b075d5e7a94bd221531d4ca688db96b16e1f2b32ccb64eab35f3fb7533efc07b837977248c0718d421b8a8b96276f849eb2f57ac0d9703df00580496d4af98ced6d386fa519e3729be3c4d1e6b779000a4145553b04641d9be66600055e2e4d04da2c90a60dea4f27811622caad4cb22e13e42599f12f43c99cd15b53ba40ef572c8d7b929767aab3b72ae7b5b00acaa5d8141af8a13b49601e7d44aab7cfe84e9986706cb6b9caf0876510f1974b5b0f506101c445f0311303ee46f125703644c0af5a0a96c9980f89edbc2bf4cec6fbeb5c46b678c52f7cbbb062e6f4d97568a0315fe606ac64fbaea41a4b01941ab64e909e166b0d73530a386656919f438d10d6c1e118a66e540b9d235c3d585a3782d0a084e3f0865d8a817a585d3df7c0c2c70078d3c7f084cd6e2becfeebdbf107c66077de1db3d1ed286267e6eeb2c0cf82b226239eae229575252ed288ceeec8b189d8edb0817fd6c8eb394531bab019e16990c509fffdd38e8c18f2b81f45aa0c9adc80f2f177389da0656dd1b51905c98ba6844a07b0f0ebfdd27c2d1a227e41594ed7466fb759a484a9d2c7b89e7a8a81376c5b697d2b23c45e115246e2391a168e8b8b81c3b9dc986c28155efe17910cf06f55f41c1b5466ef5e8bc9593bce96bc7e93eacf40139d9e3e2ce1c038a2ff251cb701827616d230088238987895cdc5470afc2a119401f4b9295796d59ae0b5788779ae6bacd2d7d4cc6bb55f83bbd9e0b7fb2df253c533c8b0f172749194ae5783aaa289635f8119574855f1d58a1f12fe724d49abecfda2a6234e3c0ca56c2ca5e7ced50a8a8f37aba4ea4a71f28ace22892aa702765d4c6089a8a7300a0b916bc54678a54580b7ab6795af689ae6b9a8574c4ae465b75cce9c60c0534dbb85b2aadba4c98d69307bd70d53c1aecfec625a0f9cee8773c2f1ec6a030cd049838577e5d3a99ad23d24233b44ba2dc156641939c09543de81acee742e20c86259a4a7c16cd46a85c9c5839714f31b701c85a83157ce0ffab5c57a6136f25d2f7c74099a1a7af44ea225ce03b0f53cb5901a4203079ea17f5aaeeeadc853751cc4ba0c1970185d33487cd7bae7b126f34a5f31d3a4308d131983e4661f0d5753ee71034076fb63ce46fead3e95e5d73b91e708fff3fb019e0ba94620122f889d73e692e9d1c25d524a7b97b2ac2fdf444dbb00aac36d9c726a29b25d939c9ad0fd9099ee040f0e206e27964e05aa2817c39c30be8ab5b3124240948f869c6d8af78bfb3296e1c56057bd160e0ed3ee7d9a601d610ba7802507d6e9e2b2dfaa62d46384e7df64951b148292e83257f605d04302171dd42785866ccf87bcb433274f16d6f84e231fb64d9009929d9734db34fa804b571b30c345157674ba1b80fbdae3272fd257b4eb7afd01a332e37ad7dca3344ca2c3c81eb7ad04f79b5cf8c963d529ef8710ef06b9fd036a9d389bd0964c07452f7048012d3a071f6f806d17f07a9a6e151c468d3508c9e996079090f104a820aaa1b8bc91d85bd1c82f9e5fa6fdce7c4730b3d4845f76c965e40ba2f1c7b30d87bf537f4e25a3268c3543010c888759eaaa5a89ab30452d1a8a5df21108167fc30dc510d40b66a1d1ccc918168e11b081e8cb8c64e263a0022e7b993ea43f043f8a59a54146426905c082985993c7bb4ee41f0451d5561edb31b79cf8e4188c88d4432337c1b84992db1f3f23fb415541a723d1a3116f73d03bf28cb496df4242c68af290446094767cd9229de49c9df923cf3c7e69561ad1a4ee7e2f4cc2522913962124e21311b2ae42cf8e1aefbcee2a9694c5603bfe3a3c49482b88572d41293e8d11284bc409e9be20c95438d9168f1428e5f818344b1810c00c449766adecdee36776fbd07e1d648f53618864bcdecd67ccac7f996415ae5405fc2d551c006dfc3a049accdc0727760e81f068460b2218384b1599bc9144301dd8037ea57bc5da9b2eda04969d5b2bb98b787e3f25e5a904711634783b14bdc9d6779c905c814a7a4a7e21060ab0917830aa8a5a5e4fc12ebcff0aedb24b164e37b1c071ee4a9b2c942c421541d160249c07f45c04fd778b2447dd1529c42ef191a8261123f081c8302f8b702667073b982d23b4daada73c618454de085041290a423fd8c420de32d11198cddc56d588130828711c95c7c89fd840dcc991feb05f625a38e38ea8fe90b07d30a662eb6bd151e886868e648c236e765d41896ea1a53210cfb358eb904870666e5ac33b43c6b041254fc8acc717b8659de08df668dc8636d28e0063ee19b1af73bf703d3bd48f8362139404cdb9925783f0260990abfb1e3335b59b1eaef56d3deaf1f404c8500d9fbe55150a02f92968a8e113caaece1b4538b60f5fd4c3b12564ac78ca4550399123e406d4a1f44cf9988fa1d148f2e8d10a4d6d3bff8440bd2e64811d102919ae7a90b80aaf1e9af5ce691fe5646ab17665b24c0cfafbe6e52b914b0c66a13f06c85f81d0989c4606117b024742ec1c80b23a82761cf61508d35907880e48f12ebf74dafd96c2564eebb15f358d1046b24e23e7669651e73c4e27526b743fb3b8794de8d143c284f1a79cf9b59b523f0bddfc5635d21fd248d853dee6ca4076e878984b3dfede993bf66cab91c0157bfebb092e84ab1dcf25112a8420ee619e7a7da5e6fd6801f053e051fdf50601709160000b5620b806502e920434ffa1e43621ff46f4c14c91b669761ab5d49323a73c698929f47feba4076c8ba4a6ece3ec7328c5b32dd74a844c7873f2023f811a781192a1e55f58e712d892809b3c82e935fe6914ccc038e801e4e5941fd27c23b57cd2379d7fb5e8c83eeb3d0b85911fe05e0369912d27a7ce11956184e25694309fef1a1e839be811bc28f2b80d9d198819185fdc8727b4413aa096b1255db766a29dc736b494ce45bbb71d2812210ce9550bc38b359a9e1d09a85c419b4a7b3b1114088b97b27cb4db2834f23177a60aebc59c875b450710fd64404ecc231d79a0b78f566b570844706bcd4f0ab7e961f26cab6404757354e53890b23d812e0828c5113412f29fe9cfb0aa9b6366a0263b0a58d0814ea8e13d15ee4fb374e54db815218deac4d32094181ac93abce79fbbb5012f307c403b72ea33a6fb9f2ee30fa3ae23c3f824bc124e5a8e3c625be79500f97149856569a976af331a6b5b51370a690b0744e42bccfa92e6d2de9e9e0fa892870c4060a58097f263eb340b9235253e4a414e742588ebfa836eeea827a23aea2c6cebdefe6dcdc23693a2864b14f5d61a32009e44d3dd0044931fff56346f3fa8c58c9a9014e35542cbb1da569a80d5227715b8f4c7bf824312b7eba5a87305480d5c088b8490c22187ba69c993a31b1277f0b1d0df70fdfbe3b9aca395d800a0cc7c74ce1fefad2d2c07da00f706921673a3adf79e09dc4422f0dd0ef36c967defa95eb90caaba852b22485f19396cfb024fdfad51dc34ea67d5b1297a46911dd997fc11fa543082486cbc3b13affa2db2b8ce6310824d00c5bb386315a229a8116ec213a8ed69b78118b837921c7af2dd74c502cd46dedbfd6222ce635730c99fef0aba3157d53bff86069006c013c2a86e9de4a35eeb89eec6d16a9eb1957db0fac35208b8f78f302594a73329db4f8dc1c231b806aa8b444188e5cb2031b72e3dbee87bad510eaed6289439e860f5c46bc1e58c09bdab2c9e01851e79b4e22a784c92cb729f92e9a45b28455f54ce986dba1b9e3df059116feade6572ec5fe52742ea59dec1ac895d245c212f23b2025ba6ecf68489b949ec8888aeb02ccd4ef20fed640e13978676057745b63183f952a9f5c35519671a2ed0ffc19f328351ad0a233caeb4c7c1a24c9bcfe68b28a632b188579716bce0cbf788b6aa7e3361c8a369d325e64021ebe87cd3b9b8e9ccfdf5a6b8b093ede046a8468c417c176ec61a03c0aed5b39e5f91ee59fd137ca7a6e7285bfd60a3087535268f1e91a48922a5a3e09139f838711deceed57b45a3033e25cbb3fc7b854489fa036ec50aff6056c5faccd604e5d8f8bb0b7fba7f64fe9ab4db2d1137a96c10574109a0ee2069264a83fd4f5c78058be160fd332d038c0211c8ae6167770925b0e3c23f4e98b62ef67335b3680b93280081ffe4448d396d981d192a4214d0dfe349da20e36289626f4e7f003c9627793fb82299bb0926c6a9cb0f9812a128ffbf483190492da0c9eb6f756dbd0dfe8666255eb8383d6fd22361783dce7fb4017e02f9764568d53f32d1901bcb79f500c357fd564b09406ee41321cd30e6f547a4cf1a6b1d167ac71315a79bfe6a685222e5363e2c52053d50817b0549c1578afc5aa2d4c6f67c5f8fff2af0106e1c6f2e71d3b0ec8ce9caad8ddbb3c4e3d0bdeada08a4101eaaaf6b6092c5165b582458966761bfda40c0853f11100e0c25e8774103e752c33347608c4afa558593db2a2bc9eb1e66d7ea8b383ea5594bf2ceee1a2418d2766645c06f184d24e2f4c5c1a3119fe72575ef31a886829f92df40f71051296a65714e3d21b31bdcb834720c2360ff914ad87b643296a590de5c7c68850a3fe56d61d0536ecd13ab251072bcd24a8c9e1c53adddc71fd8882f9a5fcf3a24ffa82b20d4344b29fac35bcfa7e3bcf734e44a904956720b85861b85f3848173c004dc855d2bfa56c292c33a08e434793758563cb645a482dfed1905a58f071f8797a55878ca974e4db0a99c05814cc03dd625b5b148adb2941ebb1982bc14872e4e73c22489557df27b8c47cc986d78b0eec4568258eabf094bba8b7d080a1352e07e731aa55295a8b5080c5e7a8807b3baed5fce41f5a1e193b6cd2eba5f2ac73a0930dfb7430964ce75ab98d55c049c41145446607c3ea1ba5d4c027143c03dd69706228fb13decfa8bfde90a84c3fbd4a693c330bd8da37677867101274db35f9514f95a47340c3cd42401133dbd29aab1c0210eaca96c355ccab83226405ad2bd3310aeb4fe5dce125a83208dc94270453ec2c4cbe8d694bd1dc88a4bdb2cc31dada3acd151f0aba7cb1f16afbf8620768ea4c82058847443735bfb990109e706817d56f800b016a8e904dc6fd69ac159d4986c68341aba4086398ef37cd31f192b598177eed99daeeb026e104d7b081c6395bc3f361ddefd2dca054d0b7278413c6b4bd652dae6d50183a2f0cd32cc91eb439671738e46ca51cac003d833611cf2ca1cda0c8b95a764e92fdea89068f532d2cbb95e5671015e3c86702b85a7be125c88fd79daac87864106887099fc44ef2b89964c9b43f9c8209b13eece3338ac22ba1f17a759e87383a8e96bd9b0f40d33f73dd15b2ba238bebacca55a5081883f0e46b89be7610d4329995edcd7167a8034d8182cf69401fcbd49965f9056306289b8a5d906a0315200a72415dff2e6e5151960081ae4195aee95cdea702f75f0443d7b6b59acebf06384163c83f90df231c2df3ad87f3724e61a396efc7602a00e8895a6336d349336f3609300f9c6a258c030f6108edf2b962c020ed3d82fb0fad3a264f980f2389e9836ae3ebc32ae80a7ee5af931f0710faaef0548c666369f345aff4b451e11e030d6344db7a14f41300940a2e3db74758c46ae8c5192771b165a377b06a0c4af72fed4291718f21834cb676f38b6c0595cbffb56b40bc81d465939b9b31eca7c0f456d42dc350ac03208325bddd21e32dfd0a93170ea77cdb01b32096d48b4558d8fa140ed8ad6ed2da48ce5e429511df01b850611d0c0aa69403f22121b8b50dc4380428bf7afccddd3d8ca0b38f87389a8106e35fb570ea8dd9e3e12f210b288ce0a0e3c18f0037eaa79ab67529ccafd1e88419bac8760d10bb143aae3c624a23300b50c03d25d14088fc0196f55b291dc986f701ad76a07a71fea93a678af993e66d0bdfe0acd83c0f817f0505cda79cdc5fa57d900073565e27f21029a5d1761d499d334d4e2133c5c0da2af8d91697524469bc77ca5c66b4f528f526603103046921600a9596c515c3820f74d877da3aa5b348cce04d522e2d2723c8b4dbd8d27b35b093bcc7d1277ba360811ae34568575fd2fb8de4f6ad939b468f45015fb6cb61043efeb77fd1ae8d3f31ddb4ae0b1be5152f3fc8f39589ebf3662e371fcd64312e0af4e84a0ca07bcd8749c43a5b033ef6c7a2b46521b677b5cbeceb99990568043f4043e1307dcf9c5818510ba65058aa1556ac60f4feb76e29e7875c5f500320dfe9206ee345c0e9faf474d3a1f98147a7ac5bd462067174b32ebc617b73ac147bfec135299416c7e5ad09726c6fbb1b0986f91628ba7142d481747a30ac26c6de87ac25841f0dd2bb1141feed14e404016382a502ca6a7d87270f0d4cb636342f80aecd6039c915ed919c72b43a8b3b2b6433870f418879c85b159140407fa099c6752808a60a695a3e25616f72aba45c6a3577b01c063ab58b8a50d6d2101a34d153d9c1baad7683903065fc37d139a429d69c7e8f4df52d14ddb90ad1916f727a083e99fcdcea2c2574542360017042efc746072ca2bb2a952e0dfe48114b4ea82a3ee3a316c420a2cf3c2657c247ad31fb0868227d44759fe0efbf89e6e84d83ccd0bd39f4d882bb8d5533786130063760890539a4c1e6435cf582d3105a4008c0b16ef395692848845b0a1011f50f1d444b2c7cda2f7ba1986590c54037d904c3b77e0dff74c434852a0ff4f76ff79125c5d5a72b5584fb00db3955121337eeb497487bb246cbee8e999be7b9fdb0d542cd7cc13814bd66c482810c38a5caf69aa237afe73da1ee7b5b9eea60abf7a04dad7a0d78badd41dcf3e43e953c2d3fc3c8b4f77935c84b7dc6f6abc578bb8c3e0e410f094f73aa41c30351e419587bf34a2283bfc6f509e15a63e12c3fce4dec4e7923895b66125c90c897820c88490e4b12047e455a2846bf57f686436b450a1b68637a68df44f1d70117b462e24c402e11cc4014eb6405b12d44af15caeada12ef91cde197ea197a088d1a1fe4a8a1e53b15aa507be3b7d30725c86fbdf0f75b41885d582b072249d970531902cf60fb6e622fee5095a22139f6f9c6cbb90e63a1f894950d3d312ce4c66d4fb3ea4c112227f473fd19de60fc340deba05cc96804229962e9ca3ccf779173eba61c4ce891aea8b6a10d558b298b9d46f839a8b0aef91393485f951bc61589874318fca028676aa3187f3c8366c64308857458804b10ea708cadccdb92befd86859cd58ff891d14c80652210953e0be22e5d48aaee86db707d55dd528495e25cf1716726c127b991a6d245a537c6098f6b3cc10a5d180ee1c04eb3a26f82c75c8ec4a23483ec82fd9940a23c7d360ef18199db5a5f05c43b1e350a86b6ea0ac89118613dc1c83ab4eb8dd561675e3f8915a7e5fd3420fa6ca714e62ef7d434a67698e96577b3aab6eab73242a81e508b8584c619c18f470995c8b9721007133336edb7605a52064ebcf251183037fbb07b2f0e48c0d9427b9d6221f4980d961e5d2ae0a0154baa60eeaa8ab16b935833354d9baab59ceccaf01a0e554811c212cccc5b24c2e8db561eea4e93d85feca8bf3b5d36b0cfa39dcb77c25608694c9a63d33d9926d0f5a66875fa564670ecbbd47b6edf448c238e920f2cddb863ccd2d40697ec33eace910255a909522b38848d328c45ddbca0dc31a41cf027be12debfefeec4c67d3873b9d0a560ba5fb2a11492b22edd57b9a730394bc7252130a4db7ecdb02f33cd0e776ddd794b1c63ccddc06a7a6d803c0c68b173df2b67c34616f1b389877223b958ff0f2cef4a7f0be09af5b2b2c9e4fb82ed4028fbc7a07e5b48f25fb3de472ba69c68056254710ed14b86e3d7d031d052737df4f2390b45b03c79b974c4c5adde197d27259c1cb22dd28a35d2fba9bec068b6b84bb9b34626d3ea65b59a411364050097d0726bbbd34f3b513a27987ac6d1cb0a9847fc91c191c99ec0368d2ca3b27906a2336f8adc58311450cffd5ade2a2e8bd2920490c98e50d218b83bd58e5ef7ee1b3512c1e9008c46d44b394de1a95fd3176dff58a66c72c7e8bf9d5f716ab5328fa89d0715de1fff5d55c8e6a0a6d346b1057e38939c2dbcb8add14b9c02c3c169de0eaed224e2f17578f47be410da957b23738e918f28861e8650e0bb6d0beedb946f58e5cdb6f234f16423e3b6e60a023de9dd955138332c3a0470242e841986de87f70d3d762913e5d683152f7b0a6a6552f9364e2096147458f445199afdaed0be6a8803c13d4d0881cd3060c0f0bafe345a08f89ee2294f08b7668bcb2465e5bbfcccc5aa303613f3ef349a61d7ffb046a78b2c7e81209918908dba7c7300cbfdc95e6ef011be908e4d473982ea3dcf8070b3bbaee2fbc82ab896fa87915d4f36672981c2b5ee543cc2a427aef37362a4d5b08958c7a2d9209471a232a0b815358d79cb23de2e661b2a9ef9d1f6ca13070ca8775320b8198669b6e041f43afc24456b37497870a83c149df9fdca8be34836231e97f932314ab889c1f56301dcb2c5e47410e89b34cc682f5a3a074bb36443f1b30f28a01f357fcd98406956d4b5104cce5216d47b5b50fb9b6c999ccaea0630abe27313d6f6628f3677296552ba4f3103dcad763ff096b0b02cd53e7b7af5fed3fff769c19ad1945ca2e6f51973cc23a92fdefc87271d2c095d7a823b3b0b0a5e58415110157fa2b526e0040d54a28a0c1106489ed5402165ef08b95080a2715728f5acdc4af15476b4f208613ee8e4fab6197b21c15e4eb63f78afc6f72ce0c1444a524267e539a374de57a0939c7980366c3c708610f8e65a6d7c333e9973b50c0535aaec5d8a346ba2a358072453550117e25f8acb333d0b68ff675dfb7ba851ceca012db79584c4a628e0cdac6d17ca94794076786c8bf3edea1c01a921704bce8b0607896514d24ca95745b2819a12ff67f0a88729cea6bc2e5f560ee3024db8da077b5de694dbd9c06bcb39e2e318b588a6e2bb20b289a1d93fda9eb40ec5b821fcd803eae8a059df99bb776c2416302a92d470b91c0d02b395bc59e3c46fd11898e208ad58f72a1d6b8231111624c45ce46f0c6aa2b3ef8da43cf7b35c17c22fa3f21f5b151213b706908d30335b959c5149c1a606ce47093349510886374f8ab08b22e298b1a798a0511f686ec10781e46457b01a0b9ba11b22a9c45f682ca1ae00b26a9481709265914a6117c81edcae4f8bb60b36a169c98dfb54a211fd12456a57213791648a5f04a34af000d07f359516937c853aa1cf68002cc49a08abc668d992a9abd6959a7b879de5cd677221cbc01cf04505837eaadbf7cc496d214573f1f90a4e1221aeae5a46a227a4c4a71650ccb9c14fc116c8aa3693402cb36fae827d8622ca148b06de7fef1d918acea80581d076c4c31143fb736f33ecf491ca839fdf7012a7c70ceac627c8197e13a6b4e781fb5b19f355a20831558b12861cc591853d42937409f8823931a84b9403fd49608d2cda32c351e82a803eba53595de03d6f0f817dcd2ca26eb8c6d0dbcb00b47cfa5aed6ae8ed5565ed86d6257054e84180a1209f9fe6af46828a354296ce2c944500fda9891ca1dd1c057be662993117336fdf6c137144ef53b547696df32556b4601c386505115617e14c4b3bdd73adb434354077686aa823151e798248b7c699137de43a8fbc15d13c0a0fcf1ac1d3d0b7b3a8db6ebd88c2876321e3251e006fd07d7c5da0ecb27630a4d70a692a0c4a478a217c4b84014e06820b76115d962df30f75e7b311c7bb59f78bb18b0383042a8132b064c956779040940d09401daeb3386571244de4270fe8de3207f4800770d0073fb0034e281e8b2aa036b8cc384e06f8998a94a534860c4a4389a8d2d4a6c4d005a40176686120e9b5a2081792a238398aa228708f1278a6c91dd884f26088665fcd638a51d044f9dfd57eb14ffbe008716fe63ca366c62613d1ebc66e00037279b46f6aef2aa6e3ae4524a05dcf9abfb29013abcca1284b8402dabf11aef3061592d9d30f03fbf5eba6bdd2283b3998a29c4bb1f7fe896a59ea5244047f4b9c0da423ec4565912106dfeaac53ecfe2ae93479b7fd6476cf91f78b4bef538b3bf177f6602c3b4e159732bdc8e5cc203fcdb0a4caa67a8706368f9816abef9f573213e985f3e29dda5ac2048419e37e2950478f12a5c86b2ca09cb255a4db9da22b17ab18a83a141624e2c3f471e9ab0fda0127d658495f978c897285358b591d754e9d15502b9f34dccf5443a78389aca6aaf6cbeed37571503ac7e4bbfdc775c33517d21369b4272e2175843de44320e55f1d654e7a39083414297e6c6a517e9c0aa7386d96829b2ce037490c785e160094f63041e1e648e89c0177a87376fe7da54b5e633701c96cb622b15751fb3756e089e08d7e2cf6b035d42cd0add3fe0703f94ce0d8c8a26e2d915c2f19f3d80dc91138059849d27613388b4326d23623fdef88d10755b20bda8fb1efd2420200619168f2f9da5714d711a5678ce12b8b58d7adc247c683f13400a1fd1aea97a178b9694b6c7c6ec3632b1812761df28e1d148991b0c61e9d802ee8c83a08ae104dd7f9f90e9156272a29f0952cbd2d6d4ff7402c1d33c44c458acd72ab9ebfa6f8552e8c34446cbec89081e2c36c7b23be9bc6f38bbb261b54234c96c2b59a5ab810aa557b736802e161c3daad67a5f215d64a642ad53b8f8a67c0d2df80c2cfac0a1663cbf11ae3602a641ba9af8af71b4707c57600d18c091ec60551d1e863f08452aa980051b9f3c89d708b86badc81f70a72ad162f0586d3a20a18b33d55e292c39a8309b0d0451af3b9753056ad2e555ba94258d544da68f0e8b058b72b7cc48f13b9769de4f1492d38fb800da1ad2b6d4f026a723936ca6221c9476208e3b2ce7cd9432a32197800387110f268584c8687020e16a229a0a732e65f7b0b84883e499f77ecc69d5fb54e0836f8f683f402212082ed778066679b3343abbecf03bff890b1d0532b153eae9d310921c91359f14e40344d46553a11dc75e33dd1a1665b273822941e97f5c7c8032e02abc009a214c3c0ea3dd97777a8bd5894b2829cf661d292d5b98f1fbc7ea13296ac42c0f6020254c024a5d7c838c12489b81526d3527b5b01bf9150f7da8588e7e6912031a0ed37639262a66a24205a461be78944b8313c58deff8e8b59db4d3f6cc1bd0060e22eff21ec139e610e3fba0289364aa63737248dd702f324066e64464fbcfd9eebdd1632cd743222892dd9bd0b7819653d892d328b292c813c32ed658696f6a4d2a1585f098814076ba8b4356cfecfd214e4781dce742e83f10f0a45130548059008845d2c84688c4c8d3a0a5254013a80c6b660329ee78d2078cfd362e70e07ad44e7fc3eff78548d7278f58fdcda484daf8f4e79a95b877c0150d13916aa271ff8dd103d58d6ce33ff757c8f939665837eae2ed76dea58f7c1f726f8a4c44f9153b6b3318eba25938652f1aab33977a8f30222d10f1a9551d8e027990e7a8343d3e892a12251551d0552f632a6474662bb7c9898f4013b68cfa5fcc8fc28ab094233c14f580987ad540afee97ab9732504d0e7cb5aa80038137c554896a700b6f0a4bb8c43e2ebec15401ca8821bb196181eea9ae56f61631bcfe8904df8feffcc582f0e4ffccad320d20144777e9be0fd4c12db698d75cdada2151481d8d30df32260fb9ddc9a95b58503daa052e048ea73dcf3a1abdefb74c48b2f845fef455ccca9682beef3fee229d4bf45163fcd0e6a07ea21e84e4499cd09541589b588717e539e4dfdab66611173d8f918fd18d8cf54fce7fa97b54acdbd7a69056b8636d9850dc17f1245d7556e5304b623feb6dded50d14fb14071a775001c3efe82988a65aa9317336c23f503cb96973eafca31ed9a34f1da9671ae0da1147d3c901bf0a1c773cb3abf7f28631d5fd9a2809eb209fb12254d20b2b090292690adb2306c6ae9dae76184c9d823a4cad7d32ace7bf235d6d7b7bd5ed26914d64b18a578323bd112088f754c98b4fde2f52fcc870cf7868af8d326c41ff0db759acbe7a15f3095b169c281468707923b0ae65a476adfd37999b54259807f9183b4dea9cc4209638deff769104955d39ed60f127617701e025d32127dedda21047ef620174714e3e0249752fc92c49ead1e7a3c27c1f59e0e3788e5a6427acacde46c617040b59daa8cd7801e56baec749fece0984916c462c9f67ffb31f20075e6179075d4d4ac9ae3679c344255e5efd0ac5ea9e2a0759588233838ea11ea4910fedcc8eaae8101bb5ea0064f9b1a50f579892a9a96c067342c954fd2fd3eaf1eb160e149283ffe9011220bd3071ab6041eeeb12f7064b539c5a6849f833749297f73cc07de4f4a7e65beaa957bb70723eada634318e1d1120af16453c25bef5f301b54f1a604268f8895410274be8ea8415650a6b75ea3e354637f98d5e27510d22732c70df4d44380f17d5c21fcc4b59431ee0cbaec064191bedcc78cf03dc5735fd74fe05cea97e9e3df152269b55f3d5cba262add7d222506fa5b280c7c79bf36fd1ace35759492ee90432c094d5e7a79007dc43a1e1cd3fa7dc9cf396cc7579a661ffd45abbd5f61a9ae29c706c7e14cb68979cdd6709d9b51c20744b05003dd4fcc2ad6e903132f161051bfc9c0f57249bd5aba954d05564f2de7b3e80098b3c1268be48d5442b055b96d2bbdfa11115cee90292ddd195f5bf9d0cda16b740c240b67e24b39bdb47d5dcc51337a3668d075b251d1a63a9788d5c2241cdd88d8cc46b260b3ad3d8623a028f811e8d4d80d817da9d486348ad7860bcbbc650e5bceccd960d895c1fa27d5ee337504d6f69f4076054b050ad4ccb3cc0f38da4c856b073b57f54fd47206cc01d0873f304f7f791cce1ce4918a51271e5830598b67333d57a2400410583fb1653cc3da73b4d9c194de1892871c5cc60e867538211d6257f7c61f48d990b746f953f116945c19ffffd7a3c5ed55a1d266067e83eb2394303c2037fadfbbe901a64ef484236911b7a3adafde128e642c6adc07a83c574859f1c2232d8a8ec1ca7f3a1fc529440920492ebaa647dc3f0f7d6ee7fcc5ea847d9b623152df764fc378bdf0f87213b0530d72a2dfc91035a7373960aaf850220e6c17d894ff23515d84e1422742cede087242c08c0ae92292e5780daf74eb51be07b0f5d91e87034a517eaf3bd725772e29fff3fed1a174c21db607eccf00823ad6411a5b33da8722425f4fa41521b2823f6e9e20976b5b796f2c9e2fc109b1b8a6df345fea041e9eca8b73f5482563ffbdb792be09227a3984241732b7cac4f2fac41ba1bd71af2dcaeccb7e1d8dc9dfd0e070f10ccedc0dd48cdc2830ce36494e0da970402a00196dd56842e001887715b257f455c5e0cad4b88c971498a960e3c4657aac14a94f1c1558a4c3f37ef2139925bb726e111538588fb0840a25c5fe47d212771fe9f037cd11808a19bac59c2d9eeeb5a472f2dbd69b03518825a92ae0a25e7b25c6248ba499734c17d9ffdf0f61f3a2c684c7335b010af755e879a933d4a66d569a73b13563d67097459d7799d77e35d89b4d750bbe489d43beb1651dbb30d6f7c52c670b9f3e67a4497ef2c609d645bdfb6f029425d306212d7a1b6af788981a861e1d6a8c51fefcf1dfaf6b82713e83fd761fc2683f4b79992a5dc08622afd5ea875376e2f2e045f9c8a13af41fa28f984c04fc203045fe6ebd4473744cec0dcfebca5509d56b771595b96823adc8d60cdcb0465b741cc3d08220429bdee35975ede8c0fe1b913c7e0c5a05ca74d543f51522f41152cb37785dd24fa0b93534601429fa71cfe05b736e31ebb53832cdc06eaf2299c5a529e4b8ff0d5d32be80cf2e7037b29c27720438aadad50489aef03d79a2d87e1ff19043c95f22ebc087e1647b1a46ae58143037a0c02cafb26b97ba1d77221b0222420482e2a5fe1d102b8326c97e982f067c471b3026c78f69b1fdf0d2084fe3a59e11f1f1207020a25ab7bb4799117958282c3d7b7cf1ef42ea2b85fbfc448312bc4e8b7ad88f4ac42109bcee1ea8acfe4ff84d2344ffb2dc34142514fde74169e1b6967a18a791f27928cc4401dd6c117bf087822f7df3922116e914cf57b68b4cd78446448e6bba88a1510bc528e6b5aa2bd8c8f319b9b39acc07cb81bee1ae84abf36f14cee5d5bb62da8f2eeff137e10c0899d10043155e64c824b50244bba32efb027911ea40cc1d390633c5a39f766a7cbf93d0ab8b1de37044e2a43b2fd4254889e84b109469b4269416fff333f3a7876951da9d57c315ade91aa1a1611bed4e66f84d6d0419c29d626cdd0b02b922adcd068c88a0905b699dbafc4c322cf84f25909e3a498a3f6401c5ecf61ba7a4970ccb12095db9d88d81a7e0cb3daf94776b4d843c494749ca893668dfd0aa502c25730e861ce3bccbae56d3a35ad4004390801fc2dbb80239944c5233b3a2cb84255a614dd00dbe435a268410e9940317e3dc576029e132659cdda3cf4c464cf6d515c9915ae9703655b8b7e105824ae5a52a940401693cea298e679f592cca950272e940f0075c7a25b62071393e31e58040ef25e0107ea919035d62a63c535a7de7fe0ee8ae4cd8c00a44af71cb67e9226cb5387e34b8d002f3000697dfd5e2aa4095b9c08547b80cec0c449cf7a39ab34388dacbe6ef9f8d182285792194932fd7823949fa952a2e34c6d53bf1871250ab1e4782c89e82cf1ba8b42cd1e030bf5e63e93f26836158e041558516810cad8b03c33444b47204322c81024ba69d67879e56bbbe64f1688d8c1e5e73d77a3b988b2b42bda3f6d07d16408cb1800ff6b246436a3e58c18aa1590aa552f6486211de7c324ccdfb44ca19cd41cff0bc65df54cecb3c0563fecd09f131db3b241cbb0b465515b24716c84cea4fc87f0f085c96d2d599e4ae2d4dfc3f036335c08add5a5974e55ce41fbd775e10065a3113b975b2e310385affe6e258a69549307d58a9532cbc2c06bb98a1a9a293c5d375e9a853189110c404d065840735d4d198fb5692cd1bc3df3f77055942fa831f9bc3f78bfadc9ee0ace431595127bacd85b818a47aecaaa66dd498d0314e23dd1cfb6086d1e898e2c86a80dc7d4d8bb969591de988e774d14496f2f93cc38f890e68e7d4e9b25f81b48322ab0a5a11c9d11e9557ae3fa8e7ee222913227f1bf29fff1efa2165f118ce629412dc347e5ca4ffd910a6951ecb498a52d67b5c6a615355b0c20b2b42126ba52e2f2af4c5ea277d55baa617674933b59f05a7f88c7602ca764138676bdb42288efaa49de04eecbb1a8d6be5daeb8d6b4db4031e72b5b6b2b5b7396f988528f223edb002495da5f049b8e26ae98f5d2916d63df6eea993439973efd392239972b206d3de655864c68562ed89f931b17135d1190711a549162202f786754073878d5ed1213a556e0658d4c14e48e22dfa1f609b3c4ef3350d860655261c71604b195fe37cbc8ace8c2305c9152dae83421676c0a7461cf827866c605ef2a74bb04733bc473c1cc4d1213668df0d9346dd9d3079d92a119b759fa62463663ecf11f7c2a8d15cc087419069eb8103b9a6d326df3132033579540d597d5ef3f059f44458a7a9491e24491e92d0531ba68b1a1ab675b6483dba49aeea3643d6fd49523d0541e88e6713595e620f9eb4515d6065d3d203d5ddbd3ed4cbcf4cb3b12d673bc2f034f4933b45106db23b67d981cdf0a6030734009717ca6fb9a6526feb53a05de6737b5a41d7dd7ee2532a2f8ad7a0df9ad32ea8f44d8a48f52bb2c081975a146bccf90ec40a521b3a4caba43deb07027fc283aa83cab5abbb06f16258f1c16e0352e4ccf251f79320b60a3c410eb058d1bed046a16193c8e9388ef840093926b348051209e7b28fcc1f59d3564b851707c9af788f34a46356e3e20eecf8bfc36cf626144d529a28aa6d7fd70a0c94ee9c3621f9dca4b8856a09d483167f5d58cea5b9ae9fe30c5efcbc7dec09869896c02abf0cac2fc44042ad72dcb51a70214ea2b8896bae7875958e65ff653e0ec1cc7586a9465b1bd5a3b7bd8f94b4e782811eda31c75de80c03997f679d9120f56b656ee33791ab804d18a848d735438e71f9f0824c6840e42cb9c4c5228f5043b3d688dbeda9cfc4a676be6a49e8649b1df1607dff337db21b8f96006bc1d5e4ac3902e126aae25e18111dadd71eb15c57a09a8b9a2a9cec64be71ab0ccd1803c04b8e505a0512b9410a4ded6b2b2ee43a3687fa09f9b0f79a85010372940d94e9260b9f30d4f04f331efb057abe656cc2146f6e53b6fac628487f3649b64f0d8885cf8f08e0fa6bd66fb543a366630180283ca6199e8fb916e25f4afb4bbec0f0ab79d4638e38549a91e7e9b7e4fb5cc1be3fe4736f45e9bc48f25a04a82687815cd25d4ff38c76409f346350837d01ba112f3ac4d90311068f7493030b6fe0e6b9bcaa6262cf5768ef996109215a920d0ab7a49587d21960d617b3358d68d638b301a85730edbac2477301fb62899e5cf58e668e0bfda257005c6815262a5c36fe5611ee893a4ab8a7c62ab455c55b5f91a10b1be304dd6b81b00c361e8d7cedfabde9728a1ad3c54d7406eac0a0ec6a66868be35ecfb98647848223e0df144dc1356aa9a9f807ed8bac6fa27ab29fcc097f2354e650076caaee33c95d94ed1cf62fa2557ba70cc4ce253e6cbba4d223bc8d48a4acb9323a11f7c6178485c92ca7edb641bcbd74951c82253f9302aebb99482588a49fb825cfa49108c7151d3e30b75c2217816b103b5211d8a3f2000cc3aaf63a8dc05d19f496b3450613913248e0f92a30a2bce06817abae1f363b71fc7bc867bfd3915749d6da25fbf33d7fd11dfc1d087d5f2e93ea270ca0cf0c71659ef1653d56c103cc5eff4d77a92edf3e20ba96effbd1e100fdb4b48c4012856086707176ee14b0f1562538669021b01e9a36cf107375b14240a4c570bb9755f0f1d56fde904780453a073d2a1c612ea8fd1794200be61cd814fc7bc28d735117c9a45e6257ac918c85eb6a6da570a7a3935b3b7458863a93f1790c14234cb29cfac19d004d4b4d65995fcc786c4a460ec85028e8505b0c568fbb74d040dfe4c6603270b8ba50a603b065030d8f74d00adb1730eeb965f79626b429e83d748b2ee6bceb5d1172174c47eb53474d33bcae80f25ffff4aabdaf487da5882526a09ece22c5054911ca5f091695c1ab3aaf46f2e28c95f58adcfd11d07d46743d218128948b6e0a113d7a0838a721c36ec0da22401ba4d5d2ad773feb986edf0747fab7740e4ab8c8c3a80ae5122f007d9e619c5ac655488af2a7708138af1bad6ac1605742ad12e177aea3e7b02e65cfb1be98b84a38fe9bd24ce6d865e223e7980716d9d2da2a81be5081c16902c290aa9eb41882db4deb6ab6681870434c3e540a5e2494761d228088a65639f0cbb8ceb65868c2a5084d1b3d2f7bfb0c26f9483c403bb532686424edb973e1698e474b1249a15da8cc82485adadc5d6fb6c149f435f4d2539502268a8aa2972d7439da885459b6e29cc4fd56cab98eefb5317dd55d5bbb55ffcf874f806bef1bd8a3a8a82c7bcc9014ac78ce2ee33f4eb7e3d2fbdfa411fec23c168267b015ab268c30b9bebf4a40887494a7c2099882292f42e1ad4087cdd0af0809635f5d18522109908b3e04338eff79ca28ef8833c2932a76ebe74f50548284f18f10fbbff4847e6677297d9f1ad84f9c3be88850492869582a71c3fdf82c9d87989606097ff31124228f3faf1f30f67836c6cc4fff54ae164239b0b0611679fe22008da5c7f634ad1d4472a5b95ddce585627ebdff96856be7b4e1d82c344f65704891902f8b90a628ff3d8224f7f45336771c27b91295f29a27152b03cea227a09d9141d502e5f575053e24fe17a2dc36d406f8e6a9f93430c80eecb24b877344f1e233af5d7d8f23397b23a6ad8ed02acf01e43811e9c1a1337cb5bd29f538037f94a1dde71d4637e1b47b8f56e156f15bfece4e8cda55c0690e57991a76c890181f7a58f36f926651ed419d2ac0d3bf18ca1b40991d9a0a2d6103d4b0bd1ee0b4841d410fc9f0a2b2f28bd89ae7d011d9eddb1067eeedd621eb23f524d9779a2f826f8b3aad20cd8473116f52aa73d8a8305e3972c8db8dc651fc790698f1ab08584913291937b7decdd592c2c5c2f22ee47cf1cc7e8cf575b103632c86ee4b6edc9f634ffe8a29db3764becd1aed3c577d7eb2e4506ff9a33fa5c09377f2c4b40c36fc36ce31fb10f92d0352c6fd7379dec503e7fcbddc36db8089c2214a9e483e34bd3a0a564114713a658a8fb158061dcc0c9c0f3072c992d95e9c3951323935a7d1023c283fc2bc6c624526e08a838151e417c25caede9f92648aee054c212936f261c0f82a02d09fc8d1bc5e30bdddde664d5596b862f381e9630267537a77fa2e9f8f2cd374160f75341fa28948e71cdaf2693897d087e08c62b94696e085fd721f280bc9186a1dc4f530bfe3a58a995bf50cc548ce7e3cd1b4550b00cd7a96bd474cbc44213385b4fcc25af1c4e89743424c693a0ac23279b74fe65d34757afc3f4d212d1d709315dab3ed7b7fa270990aca457470fd74939bbc7c575a4514bd101da5bf3758a8e6b543472d07d7f836b29da4dd7410c19cad788d87688d695d0dba7e6b9f1e0709c1b9b9be34d10432eaf451de3625f5363d1b02219ffb78b5425b555a0f3498c7d983540fb7800bebedc551b390ee3deba7706b86c82c914973834ae79929d9265754c127d035306d7e1e25ecbdc97d2ce503f4e930709c2f7e8e331e18633eb374b4f29d658ed29bac5e8599051c05f2b749b07c880bb8c97a3d4581866b0012d75ba56a56e7b5e1c5dbdc3814b8f6605331c7e3349ec18ebac4bd9ee50ba3a715e2aa0ab4d8012b887761756f619effd0e0023ffb405e6045b320ed1cab8e237f6c323789668149d6a88c05469d8e32eaf59d8f9301b424aaf58d66049c6cdc830d73b3cffe1e41c0004d332d26c2b54e6cb884cdac60b1951f27aaf88b8a9c5480e944025908e7683e2801852afaad98c02e01107ecf37a6cc9830a397d83f54bf02f68f223dc3822747165471250feb65edc840e24cf6bad80bf20739ab32d040458e4ab2cdcb85f03942667affda566a4854ad9451176326cb9b726525c7360ad2df8a6a8c4a0fac6b419d15772bb89aedba393fe70e292b45fe20a94569cc05f510fa4c92cfeb0931650332d490f00e65117fce18888f79281610d8e28547d4e6c6127089103aa64f03b804ad3afb4ac8309e168ae6803d61e2e52507e441b55622f455e3d2a198afddcf8aa21f22f3762478a5f697f1a48e34a7da95f74a75d5c45d166565c500895587f40380999ba36a92138355bb39951d9042e0b8d387cbd4af04c4eb882f4c373d6092d765113ec1a8e4c6fded0f3b58ed6b6555d140f424bcdb7c46f5a96802884101e0b602a05977d70babefe0048b477db45fd14c16a33cd1f6234866215d8c8b6fd4af24670fd585bd008510f2955994620c7b813844a928706b324fbc74ea280e393e830b49614610c5bf57de096a0817289060e51daf7ab4627004ac5b520ca5d5918821e86461151e3f145d6dc32ab8cac7abe48c7ca90bf6026d5f90f383bea3c5f0dba3777c94d3d582c25fa1f4ec834e34b4cfa46f6ea62352a20d4d554677138614d15c74363f6939e1630eed32b67d5f130e8bb7c5515ed2edefcc6edfec1e7cb8ab0504eeee05b43f8f40be3baf93fefc063b6157d6ed11502c5ca1079f137a34b32e88584439e2395592a911c47113227358d6ea67f6aca1b6e03358d8bf8bcbf3454f75441b2e6f8738a17be24aadd89a54cd8965bf5079cceccd32b59764630f6f56e7a56c860cfda32f142d77edebabbd419b3799b22de4590a73971a2581164167e9da23e0614fff1989cf4133af88a217ceba688c250f5f243394a2e25b83b48eb04e7f94276808e59ac537ab38122801b1100cc27ea4dc8cef364802f87eb8572f34a992ec3b4d1b12cc2f0b547e590b21caa551a2095e1338d93d5806461ab6e2105400cdab8104c9631139f227679e2617a171a4bd58a78634a7fe46c8d7fe2501fdf113ea91cb9a3b16700a627f8f487196069b3c32e2372b88a2578fd6f8566a295a3c0051cf32de21f8cfdbe2a5fa5ab808c5965d0d6402ded71c8c39767b7325d046b2d1680a347136529b072f56da7a5fddba700f023f3521ff5e9b4958aad8a280d2aeed72953d32b7f4a4d4512da1dd4c28806a4b20c58624515dc9047784f99df4dc247832450685167ee42079bd7022a5b7d08713abd9cfb4a47e0b92e7d0d0ae87f00228bd8659db20f4437d3af13b14ce1adf91ad19987e95029f7a4747dd0203e14860bdc976dd75ac88ab2989410e6b016ffe2ccf6fd108e4c5680356102c17040d7879a847b9e43496ac72f7cbbe8095921c6f668d95414132edd362ceb59cdb3d8473ddd5050d1395e3362c8166c86cf1efad7822f4e75772b917fb0397390535e24a1f923b97a17c6f6df99e44e481d57b69a91806f162eac466379fd51f059132dc5a4e1b137eb4e8cac3fbe78156d4268d483ea896417b16e474405dddc3dd3051f5e4bde47a1ce59a212d77b30c236e0d2befb75b0e85a85e9bcb316d819ac4cff2766cc41206b6c9f8d94a1498f2f9f3ab5d23eefa37f6c6102404efe06b0e7503d7b81c94cb90160d85717ae6c989cb83a68cb06d0b77c6e2cde962e32e674fd32ea756947843127fdf50dedc166a7ff8d8731b96a212d2da9fe13d129d96c96ae10a576ea84f140c1bcabd878b38846b56b2b772c94c11a621a6b5d3525fc6a4aff02b72074912d88acb97d0cb70b7a53ae03b757f44ea197a0c63261e85d5e99484b643fb82685a23eabc153bb8a3803c3f37d0fdb2593274a2a915ca9f54ab11483402c0077e5ea84e4c2f1d5be1e7bb042f36cc538014354b3de3782f4d9f8ad61b5c522aa5754a728c86b2f6d9b31e920fc44f488bc03cb0ee682f9139723051ad6a3bccadd7d1e4f2ea12e6f17ac51a8cb05d1a32013884652b3b86efab91d206d458f9ecc2b7e970c52bd088aa0b40159005bc00f5fa1308e7b52615da0b5cde48c028c6f76ae0ddb4cc6d438edaf244f05e237e8cf86c1f92a1555173a89528c43884465a66dffeeeeb068c5519b07a0a4d475472f623213e70e5bc4f3589822a2e915d28613674b07ca34134e6bc03cce470910c3f7f94ed8fb41a64161b8c234080728ca30630d00486046608e7304c94c72191323bb3ccdb0543248d9a729fbdb180be1cc0df29fe85da7668ed3d2acd62ee6559db4b7e12c6e89ff18fea005d0c1809313dadc0da54610d2dff7cfa03ddafff73464e13d127f61652054b55ec5e11c76371108ef8f173581376e74966193734b89d9dff8d5468e9a2827a45a17328181808a03374c9b863a0d549e9498ff5fe7bcf56458688c274eb308743d2b3134d9dbcb4c60de19482eef3b8145d6baf1347cd69285cc498e0527f052e61bc0d10d6a14d2dbb9706a98b81b64a996a1f42fd363486f29a1e2d6da21b899dde9e659ccd161d4d4f374988ebe4ce90b3b869a8141e5d0e7800040cde68f260bf092e20d7335bf1a4b3c8918327bc7fc47b4ee66fff12022152c0be7afdcea2142a23251948ea17a2bc76aa2a227e06406e6579b1ce31595e3ab2793cf7369711b46dbd1d8703ffe56eeae721d07ad29760e28addc411b4ebc8e328e39c8faba1690dac198c70d2ca8265ad103f06b0e79e6ebc320220166f8681527f01c2181702e58df2e921f1f7fd9b8100f8731b84534ad1e2916989d096b38b1b407a5f2c89a44151e2b47cbb36540484bc484e9ad8e05022277c75a2cbfbacb9610802e1d0e447e4fd45cc35ebea1236558b0d690f14558a58c53ab95543fe6841a46cbff2001c9ae3edb63c4f1f7f022852cb4ac962b4fd8a0942f1d4689a71533ece71c4a7f23a2fbae340cb78b55c3ab0d11fec836c9c8f7ed2f315be0353058564b3736db6218e661745a29fc4df519c5f2a08353456be7def8d328385c71bac1c40052bd7fbfc920268a94faa272c30d218a1f7611ce1190e988e4e13b82e3fce6128e9d8180f9d4f3832577bb939d700476e1e8a57bf9f7ba9fe0c674f810ca000bdd13c6adae5371450a74b0ae19a9277c4e0444b5db24438766481261a9f89b766a2897043984a77f6e821c28397c725336caeb3cb9c3a3b807f0eba83c1a13e8aa8836953e4dd4caa4ea2ca73ca6e8ee056609509056bedad8035e2eac513576461354439c974584861a0b03f5ab418a12a43242c286f254c175199c4af8ed42d757c3440113951e47ca05f1f107a1ff60d0f1ddce30bd4f2ec2f17f41ca5e6400497291285aa4a092dd42b89de6b67607119d88daef4db6600dba9975b306e23d0abe4da37d75a6e939b41fbf7bd7e3000c2b33c38c92825e78126bee90f284b92a3584be412d3cbfaa4f0511a7b5dd8f19b8c27e376cb3e04c7274f1b3de7d1206b4615fe88abc9daaa9efa4ec888b1b4b858b2e2c3f584344a04d98fe1e30b222255a24956fb545075bb5035a4c6dbadbbd3c9bb7cd96242db9ac2e44f0554e05c2b78fba0a525f2f3bf045ef1ffeec84639f97d491502aa3e3f360dd44bebd908b458f181f19b89e80df99c232f9c478df6a21c6a12fa738d6ad029c32fcd396939df01e09e3147d7cada7c05b9b6aab6a77dfc99b0e97378b85dd6270ed336116b78c1a9e02ba7c34f23ec4d4545905671b565940eb0eeef3011e9e2dd7ff2680b415dcce778eb7140a5cb21e15ef524fe7d330e35ceb3ef49ba3dc391935032a7fa7c0df57109c4d33c929a3b70b42850922196d55120a93d9547671e2292d8e38828295e74770525cd8a4fae9fb1860d3dae1fb163c90a1352da6eabfdf86879d87a51fa158024136f59136ccb07cf57740d4ba61660b307d92fc4d38b18aef402dd100278255d5be37c01d3054eb91e860e031349ea5e7c29a086a5e831def54f298b19ae5cb5ba2fc30f4f60fef5f0617b59a8999368e68304800b89abaaa85a026c664300c0a6754e344a891b6c08d878a9f71f486ee406da192384ddee9be58310091a33aaa94df3f6a4ad97219460793f343001e4516e7be089148272483c0d02ec1c9269ee0b2727cb8765065f232bac7285be0776aa2168222241b89a33bba2f9ec65e7bdb602b74b4990b26a0aa727c06d254d634736acaa523c51ba7319fdfbd882445c997a2a21a6d506668a3a6534c954c83ed319a3292ea92fe6bba200a0535bdac9e8ba550b4ca8a568411d4e080887a96c77448f46bb82b6251b3909be472c4b23186be5a1f5eb11a59606736fb974cf4e29437182ca788c1ca90d294120085b14fa39c91a444fbb60a90b988117f3df437f8a2dbcdd0d7a7b65204dd8b69b3fc1fab5f104b4df1ae5c41f91cabf20a310b5578349aa89d56c7815de0230e98f76998dc138fe0dafb33e2f7e52223a4087967012c2c76c0fbf1ebdcf7161e0d90cc9de807f4164780e1f9fce52da0e6ea18d17a2a029b842f919f312257e815a16b52cbe5536d459107be4ce92415564fcb5e645e41ce9302f5392abd49c1411d583b4d7f60f95b0e1959a93d31248b26092c5dbc50069769f9ac8d2d6a10348343a5b8b7dd20502695f0b49be0974fd66200a9f9830f14c8da8a6120e8e764ec65711295d0ddb7e4de476750b583d714ce8acafa43a99c3a60553d34a64da3700f110c9c06046b0f2c13d934a1371c8f927123f9b68bc88e844dec2c004477c935eaed4e8dbaf3691ad7a3171084f46e210a0030ecf6363622cc67813193d98a3b7cf782af16d6616d285a40b982715edf79cc022186a4a203b934b3f824116026ca9048094f349174de111bd7528d77b8889e06c2ce2b714bbfb3626c0e1d34608cc286fab11036bd08988d988009978ca8261124a496b519a4d1405872dc14eb89629088a870b8bac9b2894cc0be235ec8e5df8642281d35a9640867a37c1ffa4a662f882e356d669222b94563aa10bb4720d037ea69f2b16c2fcafae5ed8a411d9899675fd985fa23f3caacf6d9f40f363e2289aa728f1f96a7f78a381e67f6aecb97cb91260265a09e007a85f2709f78947d41f5f3eadd60d724ab26043e825f0f0b79184aef86774acfdc77415a06fcfc9a553436df67337bb8e70263fb7d7ae7c5001ee24e7466d3185508567b583733bde86b9de9edd084e58d620a93f33864b92cf0c0995d58db63d021b8086d784a2aacd67b69d3d6859f119a5d61ca5b8daabaf274b0d01c676b0467a38dd34e911823296eef22eb6ec512ff67a19a97379dd00ca55c2ad729b5e542ede924cb7d591cf661445035240c38c8a63a3ac1ec9fe3f8e026efa0ff0dce2a4ed032a6e8f08e3631ca5558cacfbdec618c670dd6814c39ad230448d56ca63cf02138b84b058643f84b7d4b77b4bfa5a9b8201c78df302835192d937d8a69b112b349e301fee51668cbe4a748190cad60c4f741318fa6088e8523d3b153f5303e680b2ca8c17437c573fd010e4f0ce4a125fe93ca9e21452cc085bd8178afb86c742ecf537aebc0b6a1ff140f0520a19473ab43a3ea07e0d52902605a23da0d5701f24bc2415bd7af2b9f620fca9905a56865552ae9fbc7780d28ceb01047b29ef17cb1a49fd2a5e4b85240e8725b87c4a44828bd03752e5523a23efb97c0589ce1040eaba9405c8eb2e9f83754257a0ab55b5c0c00d0d21b573d9d015a56f934a5da16bdba4aeabe845244ca517b5cfaa401cc53e63cd92350c615b011a81560939f45bd82c3e9345e189bf5ac38406fe4650dec02c88c36c9c7d8f24fe18ad60ba986183d24f75d6c4cb2a58f6e968a0b00af42ba377f5812c03437c9dba82e6b9bf8ad8f48840401f5ad4d2caf24fb94f4869529248f54b812bdaa5c6676d1bf72d219b1cee05609268f2c210b544764de1b5a6a3fbb2c300ebd48128f9e751495485e494067c17c999c2516368f2196f11418d11f8bdf9e22fa4f0d51e3497e04feceb0b31650f3df72b3d22a5b98e3ce77f32b0fa817a403b61970214249b46183b1f75ad55b55a10b252442accf1efe208a9c63e7b8ae7b31c633e4f5a136750538f2f207af459c935f8ba55bf935c7b697c553ac8f8069f1ac8845f9c3f9511cb1a9ef527a1753422aaf35655ab86f1ed6376663ed11b89965fc1d392303fcf48c94bb053dd6780b4b2a93389c8976719142fc0737ddecddbe559ed5a4ab22970845bf517ce31cbe81b9a3b75124c13d5bb753ecee317e357a874e5e064a8c5c6f89c52526043da35cf456e8132e25c532d3ac8410b101fb74a02ce8358840d17960f8cd8bcf6ceb41c0632e4d2f58b36e1ab5cdab52c11849c782daabc55f557af057dca81cbd7ea0697acfcb5ce088d6081ad96a0b1b0ae6e3dfcac23b0c7213fc9cf562ae2887ff3e10a75044d9707970ac336ed5b4021e00b348d46067ae0fa695ab775bc78ab3b0757d1ce45ecf322526b3119488bdb4d132d3876998bc57e9f36a979dbd6b3b1f737b695070277e9b2da29cd7fa003e0361c6dbcfab7c9bf6bc07bdebae94bc9f58bcf6bfff38982f7a6c53134ae6ef436dee2d9f743063a528165a87f3ebaa8d2d5cf11d49d4d609f7c81cddbdaca9e85cf5bf514a98cf678fc606ae135787687980f6fea11c435c1570a37e3ff7a7273b20da3e23674b5aec2faabbeb2dbe0d32c13b508691f4e483da4d084b544691c98589e431ccbb0e7162a088a947fa8bb57d176ccb694c92fca5e36134ab1189eaa179c9c3057aacdabcac8bb54adc6c3a318a95970facd023d4c448ea195f48f6f20a5807d7284af850de6ba23abb8b603d7261ef6195405a6ac7013b25d354c082307dd16706fd2d22aae18f0afcb42b7532b4a396721522cad04f7c4864545dfb2ae87448247197d5641407b44990ea255aa5841b85aeb292658ca14f59b115f7efca979324595662952e07f3cecf1353864bd8410bb87a2c8857af0ec9e4d00734066029994dd87640961e9a6e68f6acaff4f975a3354e6208cdfb9aeedac4ff6ec0f7aaa2979fcf67fffc462b9266c32563641f8a375db61034c10d723459279e06df3928d3737bf8c1c24a5726f550c22bb2147aba67368619e5040d68152a6d10349d83a506aab4bf2673b3ace817d7bc2f07844d3dee8075117711ccea318dda389480286e5242620da5822dcb98baa7e76f94d3c2dad771334080acb7d9e6e9e611d6a3d63915ce9c290cb91e0f22bea4ab7ab88001cf8f02cedc6e8ed43aed6df4757758bbbf6b525e02ae6eba6098eec2c34551809bdc4c510fed17ef3acd0c5e461028616694531394312eb4b9571969256161a453182e917abc303d49d3ef8c3ed96fdb5584541737049db5ceb21a93354a9e4e333402b7c4c22704ab30d518ca0c42887cba4f1655165757ffeab4f62e17ab0c5c1e8bfbbd8cf9f47d4fad7317e7cb40b074a7eb9d514738f2eb694f7974efd87b0ba093a69100ab8fdc623ba0c4ce47ac758eaa98267debaace7e7481bc255700bbe48cf76da6036c04546d24acc001dd2e3387285101bb89f8edf315b40c43d1faa510fc815524b034a373a9d803a2ae6069d800664df7933953cb662444c3a813d9d97374909780908448a0b0a1348f13c132858344505e7d98512fd8ae9f04bf80471c0709869cdaa157a60950b56f4d1825c3292ef257f33d3d14543214033d40419b3ca7f297f0fa9d69f77ad28d4eb1c41e83d86bfcb38f6ebe0950b859d6b41f0916418b67542b88c6a144c7f3d8ec216c88cddc85e8e84f2229a71e415e311b37126ef61f549db3c4e207a1779449c330f902a714a110aebb9fdc6041496dd5813a1fc4d83346484ea9c95dd61211a874b71c5f7c4601e15b2501732e1f07bfe43fde2d93c44552e0e35f03a21612a9990ba64bf2b998542cc1d838a4e7550ed4f9bd1ec49437d0dbcba045e3604a70d561058c86ad201a0d1f5d7c12c6cc7cdcd91149511d392bd281713f48e7444be2975038f1461ed07481fbbbe7936c56eec2b5b7792e92ed49bfd5182efbb1f46c4ae35406c2fdca0731bf2f5936d84a83542c8de7bef1d270d990e6c0df4659371924826f386c35dc7e2023442db185f3908687b9cb6945aae2dcedd519d435f291d4261eecbedbe1d75b393a8e48ae7ce240d90bb45c2e126162f99ae4d096c980ee6cab05bc13c89ea3030e0551d95df108b67ccea49545fc5ac605e30cfcb5dae7ab9cb795407c1ab9ec4e52f3092e7e574954405f317cc33c59ee7e5aa9d17bca37ace8cabd555abf3a8544ff2825718e6b6ec616ef1adc53b2f3095aa73b9e08d14e7772a7539f0b600a4afaacf5085613de1f70f5f562b9d664a89eddd0c1b37041472e6d01717c3e9a873e738fa8a5c77b530a9bb2d220268190b6dd88d717a6208a019c85ac264095129ca9ce1f444e798466f9f732b5a82c424e9cad8f60040017ad1f10805496d3b87225878ddc42321847afb0cf3467258ce688d11dd68004eaedb36cd6e9a26974e424110f576c9a4d9ed5b8eb31c0c16a1af56128e8763d11a2b7f3639443e9d92a65a46a892ed2b2bc018c650cba12f90d66cdfb6ad817c4366524b5904126334098bd62401b96f07751b1cd0455fa86fdb4f336fb6a3887057cea411add94e979b3f6411add9c800b70de7cc9aeddbf62e4e974d1b424982dbe907bd116ddfe4b65dcea858e9edb2ca4f17441abdf5168f8298f5b6eaed124b506fdbb6c9295541609641b466fb463b67ba543000b3dc2eb7cb9f7933bf3dd26c72c2fc882143a3b30d4d11a6602353c2193299ac06453224ac0c6440d4251046cb1c024c414108ec944081402e09f60a903b9a57409822aa05185383ea02f0a5e3111046c000885816a498c124450909294846475284ba0032a3080d10ec98851943f50790eb9885194247306388235282348d9b426c70ba1039b046c72ccc38a36bc7a31f903ab3ba3ad1d11c5700a594b5d6aae16cb66a9a566b5dd549a5693a6aefe6bd75baa23629a5b4a7a4544a291f73a482ce396bad73ceda4fe496279a7419829cb45a6de34ea8eee574ea26305f52288b162bb38a103ae7e458ac13cb07c8a3274dcf6b58ca59ec0104280f0ab1b8582cb65dd3aab73d2756995664cc4222cd7c2d1140b4c17111ecf8252725d68e564f98a8492190a55939ab71168bc5e44ccebef8458ceff8cac9306c36541d679a120a539c4116c765ed917252e85cc59c17dfd55611ba2c7b1ad121d5f133622856bed65a5d52ca4b1db400f4c43ab42414db3833d79feab4f43eddd553bdd5c83c05b5d6018aedd64f2daf6c1999506c7313b78cd4ce3d2d4f5b48964ed6fa2a298d9672d5079592522a230594df707ccc20423a16a154460a38c39a41ea29952f508fc5aa1ab6414737d1ce552b64ba3e2a584b27d5360ed5a5be215525a59476439d38798a274c4ff4281f5db5a80fd43acf725e67c4b69dbe04f519f9e9c471db6784ba749ef53a2336253433ac66594558ca533b17cfd67abb17cfded00a6db6235cb55a2ce245c823a2d3269d54e3bc94ca537d4328175f31da13b869975bb7691bf7287fba383ebc2ee5c27127cefba8b6b9ceb23971987b5b5c6d388cda4e1cf872d6b7d1efe6e0d8a88073029436d366764c162dbe502b6dfaeec57bf986d00e866ad6c602d55e1c9b5abb2caad53654f7a54097154be686e78347e77d8f9c4e44428a3bd3f5714b58cdb0582f2e302d2f1641d979a3136be6270c0cc083aa95ea03c1cf4bddf0be046e9ff17078c820f5d186d6747709ada1355387d6a400dcf00b0f40791b8a345ba70a20ca7a2f647b8ddbbe233c9976ed26335e7da55eb43a1400e52313112c8015872764ded44dfba25059a08d4a0a69198db048505609445360964bf8c0451795b496c7f939a3e573a8e207207a7b9d37412296b61d06677f76d09655cf450adecedeac4a679aa69d791cf590839fa607e95936687a82319afab083f89ae7e22b8673825213e3a6651fbb3e52b0e3516c0bdc9452de05b2e40c3adbc4e25691285b0b88bdfd4e9ced79983f41102d7830a3b55569886c2c8b2d65a0886248604165b1258c96573281259352aafd4d5fed6d9a9e8b37ad8a9f3c2162db9e08d7d4b544034c9a007380227d08f9019bd8a694f2a03c4b3e7216085fc4ced8321342172938e20627fc60450b5b80a2ca0da4125c6d6794006d8a2839fd746b9c8935f6db5dc51a7bed7ab1c6bede185df6509a6b4af11358cd812907568c512ad4cee59a455cae00b38dd45eebb9e9729ddedada84f69c21709e351f391a4617697438518bd8e0d8ccb2365e31c3113243119d1d251358c2c4568d3573269e687917134b3491934164479c9d7858400aebcecb9148bc8d54be880d8e14497862129e08c619b14b16609647e4104586ae08abb738e64ff99c9903b2ee9a200ead99e03c4bceaa8559cbc7186344498151335491142c2b645145f465f174c9e68dececa4bed3f10538df9d09b4326b8588dc3e210d0945319ab24a70b305eaf8799d582054114515c5a38aa64b1a015e3ea38a6c9115b243aa9919445ba7847e023ad43b792889ba573f3f223a2ad55fee92259d9f97bb7cca0e78d58e6aaab00b86a9b04bf5cccdc7b03531ce74d11c5a43890097d0333972baccdefceec46b140fb2edbb3a6fb6c9396739819e9feff91c0a6b1efd4918ea34e79c73ced37d227bdb8438f17abb0d78f4c4108d92018c473d106ad4b7d7a69f37e79cefaa376b93eda8eda829e30470fb899ec9bcfc8ea0be41e9facdf370cbc8f431a2e1ed29d9f56628edc46bd4e5cdab3e3d676e46be96917a3ae51052b66402d3453b9de9da5e9b1302895e02c920a02496d033a1d751022e7591460255bc7d5a5caf2dd966bd560f9bb2c31d9f300b1669e61ec30db7248bb3b845710b07fbed3b75c7a68c80c4142eec6089582c861a6ecdebd09a19e7a3d0f9254ca29cb376b14518481d9b37710b30d2e8f8ed676a4df3266ea18434e2eade5fdfbb2759ddeb7c765257ddc330984f14254c5c6211a3a598b4d3dd8379f789775e726cbaaa7b98c7bbea58759ebc01757cea3184398e0b88615376c0c360180862988bd6c4bb6016c7dd8b2996ea31ec70e779dd93781e0e2e07df9a30b735b177edbb2b73ed3e618c2cda641c86c9a1a0a22119d6ac8c278b799641b825ef13d618d2f961fdc67d421b8fa1ccb32c924db0293bde610e9bb2d3dd3b6cca8e7df7486be25f306ccacecb350c934bb426c2a6ecc0fc05c3240cc6b0259834c2499d5197e4c91799bbc9ee5d3d7553ff9e64757a0ab7e4c7b59494f084962c08c56261eaab4fd951fd6b35e07bea3b1f3d4cb6f37d85615386a72ae87b9eb20fb7e87dc2212a5b6a922dcda61bd7c6dd5837764b5da43299cfa4293b5376beabb878990ce1ea292c836132df513d856132781ad19af861d88cc15264b8c246308f21ccf32c6ad13c8d5e1ec317dca278624df30937d94ceaf80108f15d86df5587f9949d97992ada491d06c3680ad3225a13ff32e4dd3a446be2bbdb3dd3a00e77431d1fe40a208f875b3be03bdc4ae272b0a5d3fd861826d19a9098420c6260148b85d488d6c4c37abacb66e81dc4ad996951c70b898131a449b426462984f0c1165b60f1304f4f87639f11ba4497684d7caba5f3bd890f5719ad89f7dec5d7b8004cc0cface351e73ad45d861d6da24b2adcdae9febdfb26a34d1d5b4964e85d86de6b10ad89b1b5e3fdfbc43a5a13ad89df6261ae411dbf113575fc368bdf8ce237a2adc87bd6963a3ebf35715d9aaef8ac31757cae4d1ddf03e68a5491684dfce956256ebb1115c650de5a5467461d638daf48b426d117f8539445926c07569420e363a70d2fe6f7439d947e76ac1e2000328e55fdbc31c677d27b3c93781d2534c65b3bde261ec715997a30c5a8651feda0a923151d8f760045fc192262299bbd659126becf1a798e03c1ef07303e87c66b9f289c8b342ade8cf3d1d0ddbbfc913e4420dee567bc280230c01c67393ba71e1dcfc59858133bbca2a86b7fba5947cf733776c1652e5e1a6300eac82bc92952bda92dc99ca95261196473045394d4e74deaf24c9c14992fd4e567f0315fefbadb3ad2718fedddd69126de63bfbcc8bcbcc4c8c4c4bcc8c8c85c29d3646262626260645497b9302f2f37b64b57a78b65c3c8cb557fc136a64b7515ceabb6f123aac75ce63651e1d6911a7fb9ea31b865a4c65f1e7399cb8f480d1ca7cb06ce4e84b40cceaaf3205be6a8bf3c877e97b9df5537f64b189da14c56cc5fee72b34fbba8708ed2aad56a75954a4625037363af60fe220313f3f298abeecb635497a9df9017ac64ba542f57a57acc8dadba303238fbb4cc55aabfbcc8e0275bc33c67be5c98c76f08cc3be6c65e5de6aa1e73c1e7d0d8f11bf2fdbeb8604c436c1506a7cb66bae49dc1099322b3e684f3a3928c49604b9c857442808fc9728862437e493a9c88db8cf13a461062226886f2db8c58569b85d24de29d786db76deecc68148bc5623d843c6cd08596f2845483275a3e67862c2d5f5ad6208d969c368768794f1e146a69032c3933e2d73bf1dadada4fd8c8e3c8df352fd317455a622470244e74020fa834908e473c9071f3df0fa0f61cca5d2880ace9bacd0ccc3638d9094e6db29da5e5180e67ed35d21f9cff7c91791b1c24cb830e83b31930d64b2925ce506ce710b9a09cfcfc11704a70baa60ee671e63fef8a5ca0f3910a993731faf081335d427c340d31c69c617d08919356fa79b3ea38a991d68fd823cee9c46b10074904759473523a27a5b55aab691f91ad24a7a3949866138d51d9e9c2baf39ce084e20961a77718fc744e784a4b06b54cc209f09af61aab32ca449b261151d1cc082969c6666cca26d00c9a4273088932d9195292d21253538f2aa0149243924816c99934924156b199117df984da4fd727b4489a56434d72313a9f45fd099f4ea7d3e974eabaae636225c4755960a188797006db1531a38e069a11864084aa01127ade06d1c3123588147836e8f9cfbbe66de6e9157abe9e9b079b985d47efa5140b99180df63c370fceb3e6efb291a8cbced5ddbb6375e704a751d83be19fa03687379cc19e4ab4867d7e70860ec648230ab31f1c8516578cb3d09246cfd758419959a7315df5f567ba2a93d5e8638cf1dad31869d374512dd355834c2e628f7a7a2712e40bb59ee34090c53a25ea5a812851ad43b48692c6688cca28100da24274680a4da139445434339af8ab02ecf84da4d8a35201d283484c4c4d333665136806cd7a668494a4b424817c22d1122639d46c638393534447498f2a60ade740d65d1188125da24c9436d118954520b2ce5039e8747822b7748d28d493703f714771a8f3709765bf596badbd8d3d8e7dfc747e389ded6702eadda58d316657b669d939532ba2a369ff020ced936f08603db501b260cc6bd3db9d611783f0c0d12db654691b1db7e842ac91ba087d4db9c127dc1e63fc69bb370aadd17eba207d7114670ea49aa6e1ec6a9b8e32c8411944e21cf98276ed2f11c8c4218773d8ee0c9f04daf94d01dad7890308d03e869c8e7625da73b417d1de492f08aaa311e094409605b187984f0f0fcc042520419411f02002283be8f024871080e0034e9a640f30e9000736a0810c60e0024b2c50010a4c40023844400904923c60c7013734400709036ca8e1c8028c14a181c890191410768e0c31244048102008c079ddfcf0710003c060f342017af020c0006a5c020800006876e07b1d3970ccb46ed860d5908959c1bcb880aad4e775a813b7697656ee47f670f3b624ef73f396d4f23d376f482dcf73f366d4f2b09bb759cb9be0e6ada8e54b70f346d4f224b8791b6af928376f422d3f829bb7a096e7e1e60da8e54570f3266b7928376fb196dfe166ada9e575b859636af927376b4b2d9fc3cd9a52cb87e0662da9e54170b386d4f21fb859336a7927376bb3966f72b376b346d4f21eb8591b6a7926376b422ddf819bb5a096e7c0cd1a50cb6fe0664dd6f21ab8598bb57c066eb64d2d8f819b2d53cb5fe066bbd4f24b6eb64a2d6f819b6d52cb57e0668b94ad51b6b39697c0cdb6a8e571b8d91229b910b8d906b57c92fb809b77e41d70736d6af91b6eae4c2ddf80ab7373556a792437d7a45c915ade869bab51aeb35c8b72256a7923b7c8cd55a8e569b8b906e50a94ab2cd758a64d2d1fde4c99325dca5429d3a4968fe1668ad4f209b8991ab5bc909be9ace583dc4c8b5a1ec8cd9428d3a196c7b9af9b6950a64099ca5adec7cd34d6f207b806b87932b53c0c37cfa596b7b92fdc3c93f2446af91e97c7cd73966751cb0fe0e64994e750cbbbae006e9e412d1f809b2710cdcd33767cb364ca7249c7cd32a9e5735c1c77e666396bf996fc0d3954e36619942550cbc7dc2c652dbfba59c6726c72b9392ea9ee172fea669b966781996bc9c5d2a0b3ce39b7a6e99215b669995c9594d5d9e759c69e799e7b9e4df00c7b26c173099e47f01ce55904cf3c3ceff00ce5f9c9b30ecf2178cee1f903cf20786ef2ece4d903cff9b903cf4c9e37f0cc81e70c3c6be0f902cf1878b6c0f392670a3c57e05902cf13788ec0330ecf107856f2fc80e724cf0e78de796ec0f30dcf489e759e6d7866c0f391e71a9e8d3c2fe09986e722cf439e893c2be07986e77e0e9f6578ce794ec0730ccf419e853c23e019c8f3eb19e7f9c7f3cdf3019e7d3cc3f06c80e7179e6d9e7b3c17e09900cf3c9e6b9e07f02c8067d733009e03f0bce399e6f93ee3671dcf7fc6f19ce3b9f53cf36ce3f9c6738d67d673ccb3cc33ccf3ead9e5f9e559f50c3e7fcf296f7be6eee3e3b3446b6232a6446b6257b60f0f0f4f524f4f0f52cf95cd63021398603382c160db0c76659b80042420c1565482129460232ac1954d82118c6004db5094285136a12857f608442002116c413cf0c0c306c4c3952d821d76d86193418102658b41b9b27778f2e449930e3ae8c0a4c395fd24042108c1520e39e4a094c3951d820f7ce0034920000108904070657fa04993269a9113274eb499932bbb89073ce001ad28e7ac11e52bdb031de84007b421264c9868424caeec0e6c60031bd08238c0010e68401cb8b23790810c6440936940031ad0621ab8b23370810b5ca0090318c0001306aeec0b58c00216585ab26489d2922bdb0214a00005922a50810a2055e0caa680042420016b3481094cc0ce2670654b20021188802dc201071c2c110e57760420000108d821254a945821255736041ef08007d8a024499258a02457f6031ce0000758d9cece8e8ded5cd90e6840031ad074c30d3730dd706537000912244b3a3a3a4a3a5736121b6cb02189010c60001203ae6c1b8e1c39528d6aa8a1863aabe1ca3e62c488915ab480052ca0122de0ca3642030d34d4a122458a54a12257360d43860ca941448810a94044aeec210a508002aa6c861966a8b119ae6c0574775318864ce195dd32c820c3524e4e8e52ce952d4302129080a41862880129862b3b01418204a146428408a1332157761004200001b4080810209408c8958d80d7eb4587707070a810ce95fdfaf1e3070dbab9b9a1403757f68f031ce00054e6c3870f1af371651f00061860683280010cc064802b1b86175e7861c9c6c646c9e6ca7ea1478f1e4905284001900a7065f720000108308d78f0e031673cae6c02d4d4d4cca2010c600093680057768d0004208039e472b9a690ebca1600000000801914800004600205e0ca06c08e1d3ba68c868666c668aeec1df7de268c3113beb2af0e1d3a96fe2bd11a295b070e1c389272e4c88194e3cac6d16ab58c66666666335776cb860d1b45376edc906da3468d1a432c164b887565d78889890992919101a235b23b18181819ad59ad565236cc95ddb9b8b844a135f2e525075a7365bb5cd99d4aa562426b24082ea13552f57d9f92542a25fbebbaae08ad919e97e375773a9d70688d44a16c688ddcb6cd456b24c7596b350da4949327f8a9e3b753633179825779021cc1d8ac401528c7792de7b979bd6a27f6aa3663acaf1904b1138f96415732de545babc4d6ca835e4f79ef4291442c35a2d3dec528e3b702f0a66a768c232148d1363a1e3921d415733ab4e265b78ca83a5ed54d94601e4aed2662f4e0a743f19c31c69e392518dd0e229fee5495be64b8a9644f2b898e2de17619cabc70bbac863fdaa570f535dcb0141f54a1f619ce9befc824f211a9d7708c30640ada23334b7006b325b5dad05714230b48b8a28426b08006156230c20649476c7103151c213ccdba0044484e1431850c969808eb6de86ba6075718a30ba42d462d082b11b6c4c4253256443302994d51b32aaf2a4041074858a209095c685921858c1c989145075286008328b84c11a93c210a50604217841086181e30aa82882fb61086163d98e205517c444c6c490a628909191a384020e580ca910d8490428a170cb1ea2ce8c14a052a524ffcc4d18334a809d46a6e1c76cd950d299d71c2468858123320c28a3382288a21820f8cf041063cc0c10fa268c119abef0a30b39a66d2b8683eaf38edc059ce4023075138e184d2134c102d01c5152bac7821c5788110292a2f70c14fa98e474f246d3d78a44b76e229d5a1075a80220743982901864f0f3f4cb185882b69c4c0ca49084868695ab918e91c4217e94b250321e247451a3d0863d3a7a50a27565d84d18a50188f93435fda0c8008e38bd4a61fc278254be84b25032684f14c72a02f17158411c647894b3d5c214b0d6144500a09600ca986208522551145302240135992503c505a421d85f1b2a98a152cc8e610c2f8194485e80be6288c2130218c47e30644f4158d5ac083a2584613cc3012b2f4041f84f113094b9a6c4a183fb72b618c40f415c30a6cf084a05983309e0e0da048a6e08b2a2c08638d281465914495e82b3a218ca74ba922949082309e36c5e82b32c95248c4d00812a2af2a8530be0e5522fa8ac105404c1146d98230da58185f8de84bc6a32b508102c68930be2ad1979c4212a4205b791146894515c0a042185f9be86bd58230dec6e84ba2000b404561bc95d157eb0440f445990812a22f0a8329d0a041186f87e86bb514c65b22fa4a0095338850445f305808e3ed8cbeb81fa3130b92ac127d812fa8228cb74b9689be3827c2785bc3822b6437624142f4b50a620a4344f4757aa268465f3052c88211127d9d7490a4445f314b30e28a305e5ba24cf4658b20c614610c63b44c0183307e93d1570c69940812a22f94114161fc36445fd40621440c6bd2161b127dc5a0022e8808e3b724fa82d94218bf29d157029a90832c61fcb6445f2b59187fc2f8ad89bec0583c17a3aff903a4593cdd80bb548879d18416171c7104338c5650832eb210832b590461a63a02e8238429409842152126642046137c40815219600c79d182a220182762e2ece70a579852858ca62fc279851e62313862892c8290831310b0680216637045cc40092c8ea8f494e34308c8fa4bc7a32252d0d98524b1a802881b5654995501e6870cb0084fd4b06207292a45ac8a404615416051d104d5155958445082aa8a19b0a86c4155042464b8f8ae48c246951b55a0916356444745105418d5a082e5a3028c242a952a70332562a844e111e18c151a546860e308ac620c227c45d00214ac2258c1724177850faa18a3ca1703192bb0d428e39bb940a3a20ba722284145450a47c58bd48f8de2a3020d5a4514b2e05941050bd5154a709951d103ae0a266c4590a5acc0e207b4c28a253e2d87b55181e588d3368342f7042ba228d298388246136733d490538475171158e8afe311114b9d6d1a4913f2f4b8d56c97978504c8eacc8a49df69d8ba2505f0f4ef5f4b2639fdc32d1d546be794441e05c14af8619e293ba72739e196444dd9b1479d47fb092741fdfb8779ec5118753a9de73bea494e29dcd2f9deba41b6923c8553de53913e676ea735dbbbef7a77330a59dd0f200c4799aeadfb01c8e9acaae0040e8462217d6c623e86d5b56486517e4e8b85ce7504c4d7690d2b462e0b68af690fff7cec58ef131d9d61f6dae77744009da9466fef3cfd8ef06091a0622d29149470a363152088ba8bd88b26a1aebff1784e06d9969afe469eddfa66d3aa1b41b680addb7496cf99310281a167902da0769bcef348eb79f6275be22c1b013e53fab4bcadab6ebef1f9ab3e333333436766de516f66e639130473e4c89123c7e73724874a954aa59ef2e2a88ba4a6a732751c97f162b8d3a0693e2d6f86f5e53f9a25c3ba7ed3ec1012cb1b15647d0cb06780bd56c4beb3388e03070e1c16878eebc0711c3874e0c031f3d467305d4ad5ae934bdc38cdf1d473e0997a8c40b24dcf3cb73eaf7d44e85bb2679eb271a3eb52344b2ad521a9e9148ed7388e3c71dc68c174a90e87054ae1c0d1e1c0713b0fc771e0d611d6bbb3debd9bb93ad49e796b66a541a17a4421a9b171d56d5cf5db7dc68b491dc70e3e9dda9264e34849d95a6cf95397436f6c56a6ab9e75b51ad70eb1256558670d0a5894b9ea32986b9aae7a15964231b4f396d4f55cd396b4ba180c70f66665de480d0a988bc100656b44f346f5fa1bd9022dcd1b1717146a7e445c8d5a9a37a8d739a711eaf31b82faa4326fa40441f0f1cb996047b35ca2e58ded726383785299ae9b659f4e57dece0ba32e82bc98f54b7645d6371d8fbc40ea42d63359c2681c1d8fac48d1569ee8998e475652d0dd8bb7dd2cbbce8381b287d79317c3ee7b50619c3f9ec85baf71d22be2d32d1a389aa53397864f23a9e9ae7a7715b6434c57ed3247c4d5dd67449ebbfc2eb3f7ccf5b44ad3c1c8cbbf471d8c7077b911f0dc3f9c5fb00bce4f647fe7700655d7c34f62e0d2f8ba775d77c44597a6abfe745412f3e6f4fa34a4d00ddc05f82ebae8029478fb027cc0009b708f9d69969e46373018201601d850c0d67013b287b0098590163388853d75898a175411f29000e613d21c089b508a4d3845de0e213b898e3be8d28e693463d8b1047ec49fbdc48c01bf0675d5fed8b5a5e11df07eb68ce1b2e40bf2f6de883ce4ed6703b8837f4fbf9d7b1a0cdbf1fbf93520863bf0c528211cf385293afa532ce4078c57a81716f5ce7a29141297879ae7b8a3501c1257a39e438fbadeb5bb69ef50d76ad73b7773fd8e3abddcbddb3d87721deac6efe6f8d4cd12caec89af70f2a74b9c7d389c6bcba33e22da659fe4fd7ebaad23f4dde94f5026fd90b8ba26c0e74c0f67585759650fc1c7190388613daac7f90375589c3fe84124ae9697b7bb77e7a778efe4fd70aea87bfa8868a877977b0e457150669619caec89a4a6ad95421ddb9b5a115dc458c0494fb3ca7244d37b32569bdcc51d3a00a7a78a6f69992929646c138ab30af4c649e0ec7884045947b0e7f65c650f376fdb306c7bcfb675f40977c5d53143b96c829bd7560142a85d4d41d943cee3640fb518380ce3deb33dce1ff361bdf11cedf9846ef1680c2d0d6536929aa6183fd95ad382e7436fc4d9e12030766d9904222b2c80f95447ec08b11e64acd3b0b640eaf9993a03a5c4decc744501cc5e0f606679446a80c175a1fb9942998a60708622570033f8316980c9ecceb080ab9c2d847a7e06261af0d1f3399c4769e6706a657aa293b19d298099fbb400d6406b40a473483837393241d1824962299a5842924c506859d26296a5fe4858942c4c3400332859002e6d532887a1a524642e1b5a63ef12520e92111112511211f8216891248fb400ea7929459c356c00d2ebecd4906a25b1c78cb3f9637ea60660e6e411a0ab8689a39c2ca22fa6a2a5a2a25910f72966cc76a1e3d1f9f8cc57e06956ac0dc715c00c6ac9e10498a3962a58382b46392e96cda56c9b33676e004a213903098402d002c5e68facc24599310e48fecc1890c533267f7ea4eca8ab527605dc641118924f785bf41c4e8bc2ea0e87612e5605676e004a3c9be616363c99e612ad69aa4b59cae451961cc00c7af5b84956b0e55c924d15cba625609e4b3d33c7799a0a665a86ec03c7353369cd94b50621cf2d3dc3d151ace77766ac1ee4ee017e00739ce5583c97343c99e87ccf85349123d20e8e104ab720aa472812ba395121b330a2e1a27c84a163bcf185e3125f2e5a333b795b15eb8054b44b0bd1241a30a322f6984544d5a56f5c018b44a41aa335730e4dd790f4ae7848415d25ea256686c009345d423a08ea79a2e2280ba01b68289568cd15b0125d515d718b8d0f9711947a9e479cd1cbcb440b307331c618a38c820cac19d0084ff4fc6a8352bf025742c44bdad2094188c11340154787121829486be66d6604231871ae8f186b8001d6d936a5fb9942e505e70f17cd74ad00cc1ce55e00a591960bcaaf7a93630269a4a954a993619705a3a27a659a318de64dae463da98847463f3d3fa96c958907a5f496e6d3154f298d4f2e8deb93ca34d20266b009ccd568064837d8815250ec2197688d129839ceab4cda16b572447289a14834233f6f62bda7993fe63f23c03c333bc620e0fc864489b3d6190a6d7a279e0ac03c8572954143733a01cc2bd6242242e7514a2995f3c7bc670350e215ae417a59685cde69708eb038a2270ac0cca386195fc4de213336d7070e8f4f06f26856cfd76333568aa8e58a7a290fb5534a392f0a6cfe98b5d302e61a9b52e8ec574b609eb2ae0aa065b24bf4653f63b2a902d9684a74d0bcc953d643d4242a1053cbef061a5a4c95680d5d8ab99a22ce67ea3c65344f9916c03c63d3954653ec41817a4ebb446bba2ca04dacd605b50852d4479a9a79981580b3e973954cb158ac88cf222452ad2b344020da230011207d8cae488560ca1e2c072a413d0f054a94f9637e003300a3406102c01260f6089002304726a6299d64a294521a71941d1308250aac5ecb0465388fac80a267b4b652597196b10b9bae29b1482c8f7992c9a2a09361a43103f4660ae64ba6d1b2a797e30960ac251fb33063888ebf41575f64d6ccb79270840a28664d9402a4c2aa722bae2354609935b10aa339842e1e20169937993b5191a3a5e767003b5e23b3e94ead39a6803845e828c929c2d158e322f27e12a5253da3ce1c11618acdfc31af4307604bde9b2edc9258c6c0f7bc6bcedb94713404a406eb1461f43cf7236353e85f05600a2995d7326f3c971bce6822225b7a9369dec423a860888e7d8316b4cc9b780423b4746ca679d3b282bccbfd018390c26216652c2106618f86d482909b3f5ce7302c5ac1648525843d9a9433422e0b20a05085b047fb4229e430cefc21ef1376d3e3b60d731816c27aba2e84db7b4e454608b99f42584f9784707b8f46850621f7138685b09e8e06e1f69e4d1646c8791cc881d4e20c8016cf1f92d5dad97efa69095cfc14853d9428dc74c420e430f8635e03e0e7cd90aad50c80348b32d268702585969ef72c1947520c1d491174248510475160e1280a261c4511c551143b388ac289a3285c701454c451142c388ae247cb9110968e8410469d33271a1e7268baac5cc27a363a764459cfbed3be7a8d43a1be21a96f21ded05b16f80cbadc7b8ecaaa9e0066b9c4129a76bda687024b2239b444d13c2af66cb2dd518f7e435242a6cbfac059e2e5c9a0ce3e43867413b77c9ade7c378ba2dcb5ebd3f542b18dc21509f902f7ede6194673cfa12716ce0148df494929ed62a7e9300258e77c4ffb9933739896b3134f29651ad30584b61ed1670fe24b36cd1a1b45db21da29cb18bfdb73db71a64b0718e0f6eca37d602193887e3873dd24a2f83d87982e2bfb864c2a6b347dfc8cd4e819b3a92c9ba6cbfe5b80f5f3a3f85a80353a1e0581a86bc679d577055fb2c9ab3074ac61d900e36b356b6c6da2af59343b9c678c85c2193ccb751b579e444d6d4f595db0ab22f2f6280849b4bd8ff90285cc9bbcaa73356fe85d2f1799445f2f7816cd1a7b17109c44499368baeca1982efb13134069ef81934906099c833424a534d5325277881207500481099a256a4083d9ed90620a2caa8b375d2b2b367614042c1c30137b4479b0ce27cc4420f427d423eaa46956d336195db59a40b33354c99921a9407adf0fe0fc1181d01e1d0110135f39b42602d94e78869bef28b556bbb45de573e8cbdeae9ad530cda4ff96f840ada5b1d2632228a5524a4a658db2561983646590f4224934fd4e9494d2787aae8c2ed2b8bad639692290c8753775e60b6646e3b2f121246786223f5dbf23a7b70233ab72c18921b8586b5589d66816a82ab5760b6483ac901db244b6b6744eda6bfd22ded41b449776ed75568d2a524d7a228cd6de9277a10e3b4bf3098f436bb4fb84ddc1df104310c37cc2ccc2b1610c4125b446d3e18618eac08a60cd3b2aa9b52920989758e7073645078561324cc96f48ab3bdd586be774efa77bf8543b6bc3b058ac9245b249d6ca74691cad42eca19d5e6a05f9428b6a945aa679335bbb9dcd970ea0582cd64315edd6cabc89addd2669b74af3068b76bb346f5e5abbc502882aaddd36cdd70cb5535bb7a67993b7a5d6be69d1b6345abbf60db9010d2d32dc96e64d3cc201157478df90580b750fa3de699efc744e475d9f307e5b9295b79769d89feea6446bb4f7802d89facb93b8b8fcc5e5e53c2e318c4bf2ca17ad23022d92769ba4ddce5cf0897e76a6f303e296d4624db446cb991deab6e4bba5968431b5f6d35197d2a2b035a2359a453a79434c97f62380a64b7b8d4d971663b531c618ad6cbab4fa335dda941b930c32b19dc917ac1081486cab883d74666e006e2a9cc21fe6309dd11935a248340975634895962210aed28f32c51eda3f2a40fb0d839147a54054483b5d62beac95b931d1d709db19c7836646d336a6d62c922cbb664a4bf415daedcdb26d9d4362750187ac2e6bba62bd3cc8aeef669471d6d4e9b5b78c442cdda1ba6b75f133b22d7587a77cc1da285f70e275a58f1d2b386f6c6cfaaeb8e308505efb9e70cd6df7b147ac157b60143a8e69070ac0cccd661c15ce88ab326f8c1a001d8f9684baa34a48ee7a4e006b670ea8cf5199d560af61ce4816a0cee88be3b859d730407b6dc6014d573d6e026871cbc88cc59abe2716eb2639a679a84840482217ec5b45625b289d33bbc982246490d89513ea6a93d06ee680ba724032c8ec7aee0817743d17f4446eb9b297829a90c91072df6ecb0131e47eb4d482484604625fcf21d124aa445f4b3288f650bb79045ab4a6bdb57d04557a04476def0eb29be8ee853344ddd6861bc0a12e4586a8bf939f8ef78eca6f888e7783e75d1fe29626eeddf5418628dcd2f013d5966e42e623e4ee83aa0be10f77c23e6c5bb66cf92e202f3f853cc754e74605a6a006e5574c40f3b3082df69892a78b5a045291cc30d2acada7d7acb55f1da201a18b8f34558b40e4ea3343d62b56194a4d0f7ebaa827b919d78a266e5bad9a3664da6f9ad5628f18743b80d821e525b6a057d3250d40abbd949bddacb5f5ce481654561da2e1993a9b553a89a540063d77849c914e2ef65082d23c63c39d1e87d3e8296d452033d3a54d1554174f7bab5ef6ec5635c26e7886b371baa611baf97a544611bd52495c460afa33b1c7a4217e36f68835f6903e74d1da08445e1fd365cb18a26d68f630176cac9008e4b107074e17777b1c1a2eb796dace1a0ec8cc7471a74154eef454b0d2927b6b6b6d381e95f1d3f1a80c207a355ddcb527b54f7866ba381c6dec117b44d994892e56177922a89693467a6f45d2451d22463ddefe74ee768f1188f7cb77dee51e9f33bd269c5646acad46c33cf778e73b69c3fcb6bdbbdb4f77c379dbeef430eade4f1df58edaee447d566fbbd386cf8bf273821e62adc3931d7c3a3e8f000d2e6ce91d22d2d01128e848bbef76d4939f0d1fce511a75ef9d77fb1141f54fcfa1d1c34d4eeff0135867ca350a37d93e9fb7cbc9d95b7d3a599db09f373eec69268b0a496d3f23a4edc1d5ed3d1a8b97c07896cb158680020a212fa253a1a848b0d2dbcf71da734cbad9b82542b66b60be68b85dc9bc89475488f5b671b171b1d979372379058b4a6f4fe416caa4441707608566e6f42e1e3d2210794a670edd8e158075ba5c3a5aa7eb86e682072ba8b2b4052d501172b48687093f2001fd800513b08471ba4897cb35852a5df112cbc563ce805318eaf995d45c34ec4d97c55ec7a329cc9a664e2b204932988874116b090019677454753b7e004e1d74ace2c3173d95e858a50721b4ab6395181946a0f8c0d4d9470aadb3088cb8a2e3553b7e00d22a3a1e7161a825958e476860691e1d8fd01802a585523f59826292413fe9497586f20426b094e80c654889ee099da108f104db79872f7c4000212075dea108a923178bc52d1d1f3b9e05b3b657aa4821eafb44b6b513e72a41c85a7eda2b4de6f30e3e4fe2962d5b62cd434cf310d33259db2b2def9c37cba6b7c9c42d23b2e2d6116a3194ae653f0d65f2406fd37b7b42e93adec7cad9842e5289757cc5b15ab56ab06cdce05632480482ab00ca273546b79051c91669616c586410b91446c7301e2583d4182a020182eaf858ef1281442e349d5c0d52b2c41eb1f3ec7a556d19a4062964c41762579c27ce3dcdc3ec0ee8207be5819f973a22434a3f51350f5c373d2a028943301328bf7d439e482332d64462189b94527254ca3a35574a5e433ac2d20ba72d3a944764506959436a066420d12b1b5da42f130441850f61884145065d8442aea08112ac34114b0211617c372f86026bba24193fbd8a5206e9e4e53764ba2a3733148a3a3d0bd57538773fbda3f49dfc683869d1d5fbe91d14da1b8a07fd8cd65129b5cbc920258e57c6ea52a74bbaa2e6e24dd7f6282d8deb4dcf2302a16d5fd0c55f0c05509e471777a4006c4263b3e3119395962d8f98a8b48cb5ec21f68a97876a04ec787aa5eb75b0e98a9fa8b674a69ff27bf2a6a77866bae4e7179dc44b2093f82a3defc52c479d69e44f170760059c0252ff8a387fc4c7540744ca13b5d65ae9008ebb036404321b00840c21f7d38784de5af9194181b4a69ebbf6a2a6916e0aa5b0da491b5447c0ce3e1108ed213b4c94b5d69e5097456beae7c98b9fb5f34342efa344cf6b3768ed3e3d71d669cdded3e59962dfc3fd740445c401a89f1e10c3139e625fbf1b80902144e12eeb70074286f0f413ea1b32c379b34f833d3f851299714a9aca0f90429190ae551e49e1880824eee8dcd3f47572b3a59fc64a48ada3e35114883a0a42aa4a2383cc7c7613f09f9f7836d11e2b0b66c7dbe4b3617edec4a3a5233a836df34ce326f4939b1e4b069948e6292e2267531b6c28513c1746db50a5e72914b2f47cf5503fbd7e355824b3a3368d9287a1e347ed8784a24ebd7b28d46977e551997e26e1cec3611eee9a47bf23d3935f120e072932e4ce2345869a761eed9b12ee3c9c12eedb69122d45d3c3b40f0a4f343db5bfcae5daf5a107156ed7700f2ad4a28eec74fb294f64e8ecd3a00a2b81a84bd93ea57b0c15dad7ab1ea1904477af4bfdc57bbe4d9c74f7fe9d7a1704ddbfbbc8ab9ed02d5b6a905885450076aeb1987ceab6ba6f0c2c7d3b1e6149630c2b4dd3f1680ca23184acd7dd56eafbbeafd5a56eabfbecf73d6776db77e4fb184c0d651e4135c53e7018e613a2b094ed32b49b879fd316c334fbed270df7587bedb01eee1a963dd42e7b78c23d1c963db4588a4c86f0079fd0de7ed368879b3cc0c7bed5d51e0e06468933dcea6ea5c4adce621f21692d8eb486ebd12627852ee226301e7181d4f328cb12dd9c27e46682ef5112ba7cef594d9eef2f2ff730ccc6a7e4fbcbf5e4e9f14a603c210072e60e4f8d7b8fdf4e8d7b1896ba8b7dfc94b8bcc6736695a69758a4687aba63e3aa7bf77beaf2d878eaf6c3e1c68e8dab302c02b9b1bdd31c96baf10fc36cdc4bf178bf719acb73e336beba3c30ef368e458645a8bbf80dd96e2f085046506dbf7ad7c90f87d457072f4feae0551796baea2e1796bacbe387838ddf8081a7b9777d7af32cccc301a6fa771878d6e3b763e33730cce59feaf2dc380f3ecf3dac8747c75f54072fec87ddc087e1dfb32e0f0ce6fd3b2ce62a0c631d267398c790e6f2c060df5d6033cff119dacf7e4a5c6e03c37c42f0352e4c8620b6772765afc23c2e577d49bcdfc03cdf53df3e0defd8388f07fb9ec23d3c354ea3c4c33edcb87710f7a042d5bfdb830a5d2e2dce36dd842c750ff7a042efda5517bccbfd6448834ce28261de3f2c25f5291a6ee2c4aa3a9c6d7afba4df2e08ecb5e7501f6e5c8561320400e681b50ec371d8cc739ce6a7ebc38dd3bcc685b15ee39d468450c72d803422845abbedda4f68eac8454b268095c5c58c8b98184d6218895184250c2c59c4181223480c99e7d9dbe2f091536b978dea6da923966da9b5d39e1dbf04fcccea13a6c45afbd65a7729eeb62c36d25afc8cbc70a58a586b4612f0336b6d0ba0d469304c86b01d18f6ddfb6118cbbe3aec62d94310f7e8b8f7e31e1d52a66c3953de2a640f5d8ee3cedc9eefabb7700ff81508e29e0f7bbf71613ea18d273274931ce50b391e25cd5aca9075650f611cec30d9c39ed4bdbbbcc685c9e09e142c06f7bc7c85650fbfc360d94317dcf382650f53f7b00faa2d5bb66c093f7c9454d41243f990442e5ae20f805b74b64d10b59388d4f711ead37783f70fcbbea7b0940ffb204398baf77aeebbe1bbcb41fa72c1b2d4412c2585a768ff5ebf618b9b6cf8013ea16a86a9d71e9083c9580c8c1267b8659fd29e73680db72cde01e5f39296f75e314bbef0e1f030f5ed785eeaf37a6ef8701354bab2d4f428d4515750d44379a71f127a9411034400b68402f6f60e65d33074a77912491379146a5e66d411fa0d79223f24f4f21bf264887cf76ef33af9fd64e5493b4dcb593be9e99a67e349b2a647bdf55d696a7aca79de3deee4ddf8f7a53c1c2a552bc78d80ad1c38beefc3f17d1747ca7e387ec29152c1b45a38a69556eba5b62ef3960af4a45ce9a04d3a5aadfbb9d0d6f71affde7db7f5c4ecc06f88f70ea6c98da36ed3301f911b471df5eec59bd3f3be2133dfa783112fc73df04654e7eee500717ea2c2819fc4d0ad27217ba6d57acec471637b48666b5edbae75dbfacefaf7aeca73b1bfdbf86ec3468d6b83a6cb5ee6bb31178301529b04ece56658ea6698b441f346da4baa655a41bd897679fa5a447ba2fbbeeff3fb73a6bcad8e558088425250d2d095a22b4357823a0f943dbcf7a38e61f7bacffb3e23b3b9d3533f3d754d8a7993ea140aa53ae8793a1841a1ba7347e1dc795795c48d0da652aa54eaf41d71c927a6cb5e9322f6df283c3d3f3ec6b1ff5eeef27212f53b45d33e245c28754d4bac4961c3a951388fa051efe28ce151de9e28b0bf07568323b2c4c2fbe31f290f7f0ee7fa1bc34e7bb649701ece74cb962d5b669f8eba513adb24fab3c1d52723a8a6f4d22681345dd66b7b2ba1680bfeb1ede5138fe1b7f5dbb9ffe9b7f3c3f08fefb5596bba5ec0e222d6fd213e7d03a5de88c5d907a6030fdc3528b569e79eb639ca131dcd491c1dab0091456f965a01f0c0e126f2b1ede97744004d3b550ca705a8946b16d699a0744ad1800000004000d314002028140c07452291582816c8ca6a3b14000c8aa646704e9488644290859031041008000400004000400023cd0066f320b51ab046badca637080fc5fc9c95ae09c717e5db215e65f6b44c2125e9a565223687f43470cc22a494c4e4e26b450d2c0f68e57b4f74a35991724d7b3291e18b622ad3b9c642cfad0048949210edea4ae57805fe5b95aa6b062535127e7c975a0d8b89813a1113b68ba5426676974c4c381f8b4fc5dd5170255275e7a092c9e6b7d96bf6750aea49fc2dc56137cbf823cfc25910de3ddfff56773fd4072df359558c37c14951a409d491bfa97d18b99d7a6835ee77dc739197c722a456757937067f4f98663cc673794bcc02bdf8d00c250d3314e48b4191becc7a5e4f91f821929bd4a7655079c8f08e45464a35b060a4a2e8d51d28259cc377af4159dc1b1dd277131cf028bb1da6c8c2bf416e0e9ecbcb810221e47c93d15919f7b86d4b38bb1e0b59cc5710463840ddbed2e188ba5176d37ff9bc8c7e0dbaeb349e2d24920d885c93599957dd3626e4ee7c287d40e31a8d76c248bff9865fd56da6cfd5215ceeebaf68b0c007384bff113d3c2bb5a505906231624fce925de48dfcea25c5afd0db877b6caef9d2f92049e75d92e300024c39fd847d08dca3eab3a67fe700f5f883e9a41dba98e0d65c960b93dae803998d0e05008126e9a1d0a6a3a27c96da6942dc8b0264f3f0711cecbf2d8f2ef31ec7131c56cf816fa4408d81a9b64836a90320a0e1cc7be3dec762a9ca32d6efbdf1b8122e76ac8bc80843c06f8ab7097d0c5069c4c4c965be330402e7b93e8bf361c5e4409a1af0d743e2540e8f7bdee6a97695c4a69421289a8e2a78bc4a40672d12b9da7c1cfb983bc04351e9a3d98371fc173c50b91b6740105994c265a85ff33dd6acdaa23726ffad7282972936fa312e3e46fe8191f54b990fb10eefc07cdaf1d7972cf8bd50355be783de606b92fbeaa9674ff9dc50020a064ede5e196d9a5797ba481a734de2c086b83d99b0cb4752fc4c6a86eeb6deb9bcae50dd56cf0680aaf0e646b254e520b0023034f4acec7ac1cd1b943e95f6e4ceb9db89577894ca8e743643cfbb06f2cc47f6babbaa3ef21e5abf11eff960f6c6e3833f7a4129da7130f34dbb82a660929a07c7e5e22d2b6792698aabb4a314aacceca1ce6e508764367f23b08ad1a6be6099993208de7acb0f7d7575ece6911f6abd4fa74788f6e09efd13e291343eb4d1c90c651415f15027cdc3c057cf15cdde8397647c08908b1c1b417968e7bddef1486ae2e1ff0ac157022d712da1412c5a5799bf0633f52d5c84db5640838194051959230f03f84bc7a4bf2c265e6de1cf4d18cc17186d5287b28d13cce6ca1362921ac223570c2230890f1764cbc895497f18a88a618c24220b691f61388acf8f763ebc6dc1542b6ed1cc59266f674869babc2a3555a3b60dd5bf7167d2d6783cf2cc3fa6169bd11d7cd1437cb3eef22acf0fb579882ef80e668e3a18b783e72a81b26602d38e7ba75b5210b3202f2f4bc11e1e6f0cec94188d8093c012d1e6c3ee3be9d79ca605a56a7d51937a0daef10f7e4137512126ca72db2df38f042bd00fe3836bd382cf5830de177985f619f09bc79521e50d64e2146bad9bd241e785bf7fe2a06646a7fa6ec5c7f0c52eb7440c99f69e47c211a98d9466fa4bd82a38687af3c45de0f46be3c5dd84d132fdcbadc272c6892c2fdce922e7d5e2abeb6fca1d6791882bd71d402721deabe520a14449023933016bea3a77aaba41717fd4b2d53d32fc848fc1eb36734c8d864e88a32bb8e0f24ac18047892f646cf69e6678e07f1786419ab76a3981e6dcab6c222b57dfe9309cfca33bf84a8d4b0dda6be687bc9515fd5d6b9f42cf4ca9d7d59229e933918bd8d0d7551d0f98a495a81b69e8dc1be7c158ad404ff4068dcad60f318ba9e7e5fa6a9d1a400fe2d7410245ff6c524fc3a82c6cdf58f71b0a350d32f8fa950de648ecc324b7d77659d2173ff529cbe3eada70b6db877562303ba7978cbf8c16db910aa79fbc9d2a8b76565a49ca3281146876ba0c3a5148594ed36943c69247796a4d0aa727f5d774e1665bbc276236172227e4787672f27070b6dcadd9e81a3e434b73422dd4e54e2408c79835c0cae6e9acc51b598f175d6f5adc01573deddef85a03d84c9f315f47f858c3cb1e0bab91b5e85ffdfa5b1cd1420e7fa4faaac2b248dc9c4baba432d419cddf892dbfd49ee0758c05b4b289e4ea13d00d1a1d8c71e0d850e8be9c3a5468b6cad8d2bc3e3a9020541624ec61a7fa26fa1e36ce1cae898a58acf61705fd7a01f328b34f383fd564e57255672fab9df50ba6bbfdca84d6dc0a787bc86d4d9ab21cbc9e46067be88ed6b11d1c353a9a4350243dfa1ce6059aeb18643dfa529e0bb163343ee54de2399c9a41d61e1c5171b46fec384a9d9b5d8476b72224d7603cb92165fc1e7380f503bc02700c7267a40ee12ea52186da26b7332f94c99763a0b256e692ac70f15e40cdacfbd303b73d9a67b3e864d04af020c82cc4b0ccf5712eb229eea834b60a96fbc25f7456e1d6f9ae486568372e7e9c28e0829996b68c34bda5876f5b826609a2574751922f98dd38f3704810b2a102ef2deac50a799911bb9a1668261a020d8e7b3a7a002ee2b813975c09721eb1963b1839e3f6dbcf84ad58098ce67dd13e6fed71f9532d2007dbe2e3853065a8ed08f6c3edcde9c417cca2f0dc5bf01b9979b93ad42b043d4062f78d1ee25cf7bbc3c64f26352c218facfc36e0f09196b2204d483d8268d7250e71ef1a6edc3aac5a656448e4594149d7e6d9bbd8638bdc8dd3609d8c30e0ed6e6949e5d0f33fd23406faa55f9243cdbf40e9e8667181a165a0712a17574b39faa1584d16efaf35ca5726ec87c691852456004c267bdb53af1965ad1a9eef51555a85de70d94f911aeb91b1576bcb56b50dde56fadde142c26b3d8f7b9f88c67ffcf489ca043f534852fccfa013e34d454bb144d5be0e62141aed8da4fd9e8afb5bddb3f281f6da7525548c4858fb32754d5ba684136bf8a24b8e29a790143576fad63e02ddd823c4d39253de42c680ceaa8e716bce5193114c10388fccea444ac936864806c50976d9e1b24b8ff0e209489aaa1ef2d60fdcde223f4dbd9288fb0208fedea06be8d721b2bd3df6f7c32bc06e81528ef63242d0dc16c1a9f6651491c86bfbb55df02422592e87434bd0819ace7a0c293728996cff4e2f7d6d61589fa44719eed778bd75ecc2f35afb08d40f916c4bc95362eabd17f11e6cad15a0f38b8f443ebe1a3d3210b1c4505eff8a88ca5da0d5f850c2dbe60ee4fb95711e300c8aad38b440cd1c6e8e6e178964aa4df29356af8405b537843217adba5f37805bc4680558be100654bc7ffe38918a67e9ea4913aa0855fedf63420b228b3e00cf24ae550e5d5740da8352b5b5902eed43a9c25cad296b5098e89bae726238909f4b83a063ebac551cc8e479c34fca558c1c20d0911ebe981abaade70c46b16b2d2db064548561a07db95a5a34b61a44e16998f23a9c3404a8080ecd224910dd99f6c22ca7226725f1c9f5fa56fb47418431b985ccc367d66ae8fa99fa8911499b5628ee374a758f42d2a6fb2c5cc455174bdc1603a4669f36ff3c35f8eff348fa2ca4e1c89921b1f505e2e6e8464bc676d7220e9b2839813f1bcd69224a80614b167e9d98d0abb64f51fd1b8d7f88ea94de7bba902f991cf6efd9b9eb092159993c1778b428fba7e8ac32f28ce30bf8edc5a5dc5215a9254845e24008f0f1a4b0a327192bfd2d222709c930cf0533b7398f66d665ed7a0987cf81aee22196878edd283a2f466654879f2bdf47a6a072fe1a0667f1608439992348c8a82f40f7d4fc444bf5991e18d45bfbcc1781a5de009d2113f0eb1f4369102344df219f414cfad1591efea8a6c84841bccd842f8bf20086b0cffcae752bc1d39b9b7c76c368ddf74f5bd16c16b65bf6d2275aa172510cc24ca842bde0018f109d4ba60c8b9e01e7112b79017bba8cfe0cdecd41a5cdfdd114053e4e994cfd4fc01026868b8ee96cae3c1a0c069d9d847db45ca5faf5baca33017fd7adee50a606996ed7f297409f9447b50359e7394a8b4f472d65d5c6e09488c90e839d06ea19cdb67e267856cb2c945c00751c1c107a8951e48008f003fc9c08bf49db82981df120b36d43b40ccf95c11854288e9e761983666d60a36a17553a09e8cd34a09d40b8606705831a249f039dbce7bd58b21fcc6c2970d791dfc499f19e9ce7a06fa2ce8d767d8f5d5368a10b42e73872e760d75af4d43b439c62de794578e583df96075cb6d2c8138cde1a215aa3dde74da60f8e01cc2326b63a4f7b678b32e996232bb4ac2cf7b23187020e6be25e209f884764a93d8ba442a37c7f1283166be8bcf310f69c16fa14b857e4fa883699a91f68a6a7536f5879788ba6e17d0115fa171f185fe3bc7e15c001eb284ecbfba470a517c4771d06214c25c8deada37624aec2c81280190dae71b514c9e8d01b5fae4ac4559444f3f7ba2932bda686586df17bdaa4d8063922751ac1e62220fac95fc024535be072d7434f7436134e09f49ce7189eca62de3fbbfea9890c7d95037c0aa2786bdcc82fa8008b696e8cba94f9110364efd639d57292ca00cc138b4e70a9e964c3761a84c5c6797f1f7302351119bbf24df5c216a2ed9e25a377bff7ba7b9a9402ccaa88a4b483f03d3d93b75830651327fcbd074bb921c4b2a1aed79fa40fa8dea296598f015ab8a84ad5e84707f4fb5119e5e2e71efd153ce6ec3cfea4b4453240e1c9d5aaa80e2063e0263392bf71ae00de5a07d5f74f177c983e0429a70f336000a669aef9a456af817cb4b610f13458b0696fdfa7abafe977c3db406e0fedcc292b90bc3e6a375fbf4b3a308791300b8f261dbcdad991357f4de4f3cf348f23377608b793a1ee23c8c76b31fc76cf807f8c9b977076fa07dad3eb262bd0f3ab277cc0574b3346be865232aa686de04333622dd7395adc05e3d8b9802db15cf69b16c03ca84c5b464b7999fe78a9dfdf51ca53719171499a55c70a123b05e14ac3bec317d50ebee167193135c7b07f92f62c8fb0ce32f06a2a479ba15b30ab5b84c5aee5b829c7949be78b92dad53aa95f814e1c4004548ac4fd7ab19a14e4cb9c9d6f91a8ffc445280b51e1c2c69fd616fa354ed5d5b9145c910450e48fc8751e55fabe00f516582859511e7f887bdf18a38542139214e2388fb01f8b99744f4b15dbff1a51236551ad3e87dde000b4e28dcb0336fbfc1cdbe714ba172f577136e1227186ecd2e4f3dee81b561112586491aa68fd4f2633c103a4c60d1a6b741ede6288935c99617c9b61531f56be4345390c41d21b0b8e63da6bd2152a39422b344c89b48cc46bcb287e3c3e4d6a9a6fe551a13252f3b05635bb7e17c48d1aca3c4b90ba05c2d24275499b3bbb33228eee75a824ca292cb279886c569160fcc6021bcd15c63863c669d791d1198c510a001e4ec7c66facaff53471b3f95e117d0564b8156a9a00059a786986b39da10451c25a0e3598be152a011a1ff9c987d7414fab1ce59c9ebb59a7b800f219bb78c9e89425c8eba26b1637e11957d372849ec7563b970f6f6f6490b1398128c35c3820db68a0110e3c94b7a119bfe9f63a1e6b08d902a87198cc2e3b474b4c3ebae5630b576299611109953f24a1e325a596dae8eaaf0d37b9aced4b7b260e4ff731e043f7a1fbc82adfab0570e472e3a2b9d7381b0de32dd6edeb9131bc81e6903a8b5da3513ca428d2f135204d65933a89cc87af732484ebeca827e5038ee6c260b89fb604cdcdecc7fc48c10c047856a05ff5ae7c8a2a53c27ae0e806aea1f1869ecfcca0640ee1d8a34384fe8283885b4548a93067cd9a63356d1833b3e9c5cf78c71d5a4d2256931dc11b169d1555d7b45a47d620ac29c9b7626e7c19747298bfae577568849341a04aa6fc2c3308a4e648065ad32864a39241f3498e0c6452324c986670bce2de2f69daafd026de5bbd35820893596adbe1124301d71400bd7634f827d84bda6bd61c70a725e24ef68172a3be87812d4c21bccd48d3168a96bd11b39fd58656e8158ef09689348dcf55c2480c9e070e99f3ea447f44470d75e88509fae0ae819c6b53544e3233ac642aeca563c3bd684c4e9b57729f7ee44848a12ace633098332e660805eb98dc0b7de704256d5712d59e877e4f769f442e166653ea0bcbcd71735ecda722ccc5902b21693dc254fc247b6be6bdf6af9849721308ca4a7d47763754c93f3c1d9bf005f73f2cc71f90e7a3ee6b883c14b1c6cb6c72415637d594930e4f13d0e65bbf8a53e60da9388b492fa98c00e33178a6371addca7092a9990f4a391683bb090d34dde2ceb030f2f4b6eaf6164587920feeee727e349a00e9e4f273dda7a26e6f4d212ac8c4106cf9ab056ce4350f379c1b81643aca12c316df4ac4462c7c81e000aad2023cc238a52c7850d7adfacd40d3e1cd5563c0a2c6147ae302dcf577743f882548110e7cace1c9663023dcd0f224a3bfe12335c237342c7dd25f46690e998ea49b906dd9752aa3810f8d66ab19fa085275a4f41fd142f9a20a0f44f6ee971e6db3a5d29544c32526138ab26cddb7b5556f077a9bcc286ec64456de91ad40deae81c20db567e0944d68263b71439a11e5fc8d72bcc2a0f86eeddc112311228c6d70dbd3893a8a40ad1a5c55a21f4a59b0461cf32cd4f5131c8f1dd5b399e43ea0ac54b4c57afba45465dc938e7819a4d2d63b7192216d5ef12695dc8b0d5bca38da166f90be3d8d3a19bf0d7bc853aae8fdbcd7e8cb99fa39804ec938741efc10f6b4c127cec2a5e8717338646c4a25cd943afd3ab010443456f4d8b904c472a403c40a5cfe069e61263e63984a63f840dd4813e92df14672fb892dcf7b47ed7088fd7752ca32bf4b1d75cde5863a4fde57db9e2630c850fa906d188c7096e4af3147cecdd2c8a32492b147c4bbf8336f39f9e3adc6015fa305d2a0fb541d6e6eeb7b4b3dbe4edebbac08d09dc2ae167e61adeb40be5a1c8d187759ec89cba6ccf73dbb1253637ee6f64521a02d4dc92a1e65463482711be4e3489ea2acac6c1319f754e0676da2ccae04701a7f22826049cf841d804644b55876c966df6bf54d5b3ca7ae38e9ec9de4687d38b3c0f433e0326c98644a0269c8f443196ef1d65bdddaa50125b5ee9030c55449a4bca4322bc56e3f28de76328da0690fff6e755cd4ddf4d8d3109f4aa6f6994792cd1b94708da04d29e0ab44e9abcf21a25419984cfd9be029dbb3eb3fb15dafecbc869c4bc9515ec0336b6f82cc38349f5d0445768961395cbab9a39be6c76f4e14891ca5461279b15294477394cfa8a275f87b893f1bb10f48b89805241d9c98c12836c62e778167da9cb69069f041a4122139c007697e59593493a99b0b716b8fcfb6aaf7be2ca54e6a423ae018accf051bff50de91351f1949d7b54cb00aa14f0d016db34d8b9ca18a35ede13ceeae9bc52cb934d04e1f481ab9aff3a0648f75191ebc8b84ea321b6f7e965360a1438887f7590c694eae4b4779c3936921fa24a293beadc7ea66c29acb28645e507f238b24f9dc6930e1bc53c9175bc54de0587efdd4ec31ea2d0346196a8c9e29072e8d16cd5892e7eec828ff5174b5407c280d42bbde3ecbc6a06f92d446ee426e68715000852a43b440e15aa4d12a3e3a2dfa4cd40a5da4a384d1655ff33458535de014d57f7827f855056943b771df68b6ef82b77757e91f27189207149cf636dc45234d054c2f4401c9413a72d107ae4176a4f0af56c757a3c9abbcd9c4c939b06a087d08e5c15b6a22265a41b3aa562c8cd5a517e3466876acce0d3bf29171b7f1da20b42687a64afbb617d4805895a559a20d97be1f0c7311af515e1b36d3f5e5c6dd3eb1c7df827b42cf512c2c3544cdd2ec730b103bc2b897050c5d1653c8bb6673c3577ad2915a6441c7006b45066f695645fe3bc983ea4568a3bb96361a5d6af37b242dc696ac68592c39132cb1918997534734df177e0af4b10d51ce5e2f3eec1c26052b5dabf02b19c7e4ad3e4d650f2e4dd453405cbca0f138bd8f800ef6e3caaac939716fe0ad4b3deca08263a5f6f6347a52caa75d577b854ed7b16d66760ee9eb9f533a934e1382f8030d192423d5829cc36285b051973e2db1f85a6b56b13644f7f390e5824b8425c9c1416eadc49d5e10e93e5cf4a4c33160b4451bf2ea7ca3df67447920e687162437c4ef583934dcb347704fdbd6e5366de1a83ce380688267114d4bfaf23860f31ee8aca3c250b86e8681d31faa045c1c7694705f2ccc85c5052d8c3df57bde28a092d670c13352c58bc17794764045f2159c9134b3e896e7953797b54b2ad472cdcb277947d72c5d4cc889a5171ada21d08fb0eda2cfb1dfd613b511a9c308c48be2465cbb19b123e7830af059cc2fef7286139f23c08205668594cfc20e6f60ebb333d60303b7e5e11d3cce6aa032e9877bf2c47e481d51ac437c9d8782bc17f82fb2024e93f6352fdc7225586e5800dcc00eacbc5eb828b24cc367888bb38f45942e77d2ec51baaf19d94c8db914756c93573c503b78eb14f3238b9cd6c32e75bad6bf6855c7c46060acdd6b8a3694f22fe7c774e9cbc0d3fdd68e4831ce0f1b786f072e035ac3a31b1ed0ede6bf8143d2c0f652b2810ea44ab50942ec9c503e082d0d6c9e39699dd5e0f05a9fde9cd63b68995a3ae8ad05250fcd3a50e688933000028be230dddc700df4992038838fcf969b86c2f919f4a78af77e367898da2b50223389cead2112021cca6d8ca9e89ff086eb84ddab1c98731b0b7b1baae4e9a1f3258c7c3c0bd8caee226faecc3d3283086d688bf245c96ab6f236900e20605b93bf89c2d39c90139ea8757e0b457c40623df92c91fbbd9e376611228fd265ab2a37ecbcfb4252f8e5fc35c5b2fe0cf1e6b96e9f271a638fbe509a545193d8a6876bbf6469d922996dba4081f5fb684f64c82b8dcee80fc0495b97a8be52919bad66288a09b92fbfbd48144ee5e03c013d2ff1075f8e4bf7aa6910fed8abb70c0d38a7ad541d49d41901613597861829dfe1836ab4749ddbf39fb489a237b7ce176d885b33c7970e16e643e0aa8fd503ae066f460fd01a5e16039fa0233174022c4effe03f10362a66a7995e37288429a8c222299d23044c0aa59c4d7a4c3fd4b6ae89560de6e8706a33d867d9473fa694ff7abe70b061ad8655311214bbeec19fb0320bd7f704f7b6511fecd970de1cea8da8abd6402db91440e14af4b2f8226467cc9119f1f06f42abd9a9c3a7d02bea5738220788612d5b640deb447234abc291346b30cbcf232327a19f3c06e7f04e5636eb6fb58bb2385bb54216a947e93233f4f1d40f65ddecb0316a5e2f6255dd009c87a8f776a8925ad4600a611177bca925f9534b23d13086def54f99bdad1ec1dfe555ac8b31811fa3e82894bdb0bec03c9e970811f2d3121ff208606022115b7d2adc52b1fd5e5ccbbc766e002e55ab2fc1e3b514b0649ca0521dcee75a0bca2b37d5a4ead127f4c8d86012030b75f6b240455dd743bb79524052936c72455c90fc8c2c3db8ccd57f1a8980732f5362f150415713668309d9ada7c68379bf2337e315fda8225891ff545e18d508f661cdd25433db1d62ba7a1fe4f4d5f77852877ae1f843732af03fd6fcaabdc77aca8c15094be907d774bc1db8c672825c2af3b289af29797a18b2e87d5e6284befa6f5d9732dd108ed5771f149490d02122e37b993491a2526646ce7119b62342ae1992e6a81ece48c550d569e7903591b9325805847869c87e3c2fe0dc5b35584b96268054e97981ada214a1aec523353da5fea23e2d3719b3e425a348ececd097c56109bd02637749f260f7e51a9bf012e5805dd54a90ec8825e9e247988e7f24e4a3a999143ab8d095e6bc59d77a0e45b7303d34070ef76b4caa5fb6a847282cc9e21636683d6ef663fa73e21555a04b05ffb2de60015896c0e49d083d2a83e8492a036de4ccb030c2d3e9dd42bd56a838f7cfdb3fd6e2e52421da7f9f416cb5711cc5dc706a35e04bc1f5d2c40b6b1e50e99f58ae50b32a1fee3aadf092b5d48e537b5bfd85910d79df42de0a28717a5448b9de29e821b205e6ee2920d963a41f558e88accba351bf7971379c62bb01fed0839911e14a975148dfa76da9e8bb13371078aa56c7904728ca76937a9df146a1b86eb2a0b3eade6a2a5d03c78164c4c287ecfbc7d6ae2334d11f49def2d85ff9c818a026bf0e1b783cc160be34b0c92f5bb31f36f32430086ab26e5a353846ea63f5b106a67fcbc0284dd174c23653e2bd3cc90b4fbd0602b931257fe39f1d63662a66c7c86e02d49d86c386f4bb29ce26d2603b8ec16375ae98149a8788f6470f6d1a05f8f458818d638bf1264d52067eed642cefce4dcc290fe0892b940cfd037f83577452be2019a7d52075cda52651e9694abaa896a70219e309418985e8f1cf30ea4517a64b46471be8cb7367cb33005ca742d33398584317942680c0c4aa3ef1c8115bb50ba6d9ad53b9796e6d68b65c142983066265ebdb72772b270965c7fa43a892aa8dcabaf5e2decd5763d5265b7f0a327c5a8c81004f4576b680eef7c72a6931f1c2af30053535503d46d7d475b9d8ced62857cc094404129eb9a5c051cdaf41718d60c8b84926108e0aac36c9e47c5320b64349e961eec1e72b03927b36efd939ebe09830a5d99b528c12a5a12705d78e447a78aa5e2cb7abff2c7421c3f1a3ce1161de0c21c0d14b208c8f3a1328de3747d7f3be6793440709353f3f4b228e8fc05c4d8f09a27326f83f938c0fdf9f2ee609b22fa87477426551fbc8f827e37216e56b403cd35e2f2e58e07e297616c6ece9d3f400ddef9bc1e10906498b4b7c0afe2e9c96e0ec41074f7ffee16ad1542e04b1c42af303e55292e10907d947d7eb5d02c69ddba0df97483fdfa26f59dd78cc8968c21c03b8544999b34c9cc39d33e012a26f638d8e62c93fdd301779f6c30e421e18f66e2106663ecee3c5da4ce66ba230e3f15a765c4a1939b0051540720cba39c295c3a85543de26f42ee38f5c23fc8f711c3e26fb78443da43321ca776ed052660faacfe0b4d91b93f3773e22a821d10c18c56b149ab74c70b920f911cf37657f0b7209d973a6dff3e5c089604fd9c00ebcf4c11227259db535b477935e6f1ead79f2939d43b0fa6b19067e969383e1d6f4af29dc5c16f9e9271ccfbe9f83548a1946d85c91159df59a233ea0c28190f3a67dd01b05a3817e1af2da478c3fba1723b7d1c51db7f6064345447ac023792f5bebb4925655cd14fd9a2f759845b566f5936691b062337615930695730670d7cd9bb9a81cdc1888bdb94b17928c68a6320af21a8642bdc7a2494c1a931201221dc34c869c3be78ef8b0ccedf34a9da93b848913937496fc49026c629208bf63e0c5ed33e3f3cdb978ecbbf94ac1947bbbf632430be1a9f1fabd933d8ced1e07b5136305b199863b3c7a4164948d95d227d6d3eaee4b72493fcf7c15f6fac158aea9cc01d5d9cc06b5a5c17ef1bea1673e354101dfeea46059e8f358f04b4ff805bcd0e5612d41c96025fa337f4dc0f8bcafe20f8b8adea479d21699fcd636ce315f4ef0bc5f1f0bb9ad30ac9bca3b8ddb2c74bf78ee85e99e6bb29413ba509b99d18d1b66beaf9c9d9a0c235b13b7c285fdb6ddab3f71a6e8f765ffeb0f8df391222e1158c1e7700fa48cf7d6fda410de4c6fea7719772ae363cb27ef74562b7f338cfbbfc77ee028601b8fd8bc7d7c4acee643574afeeeee8853c05b4dcbda14fabf8c7a399b8cd79568ed8594b00e474a0154c0010b5ee304f5aae249751825a90950b692553e0e1c2f45b8d9bb8ce8b806572c483031c9aa737919a11cc5224acfbd53acd62c233d372ccd63d94398b2493a7ea0dda4cd38d2e75d2f47cadd29512a78c52d7f823a960d12eb90596020996f362a61e5928f1803fbfd558125eb6469e335ace1de1e13310f88aa3af5c135dc958354b30c10ad005d859b827763375891902d05d4fd8377e2eff1e333945c04f528232c9ada80cdd10c1286838bb92eb3a2cccf4543d2b447c529f3d74488601c4b6a259f5a59778c6411af05e9cdf40ea6b32789817dd276e446e56b54a21c6c5b7c3edbf35c75505dd762a8c6a20fd3011e3d3053777db43c40610ed2130d423d287940997c79ab9277f553fbbaeaaa1dc42caab7c66256380fa2acb4953c7526f2c705104651f3558f4e37427d8a23bf7bf989e893d1ebe3030dd9536dab463333326c3711ebcf80b4e04eeb19ed6bc680161482bbcd7e022c18621a89f2a493c5e1dee3288a29fe48e63c14b06ed7c0ed812e8e93a619c72722c79cab3d5ab6926ed71727b8c4cb8904bd856932f7f9ac93f0606d7fd588ce5c54f18707e4eae754f74a5bd203bf097c5d9bfcc6ac60637724dcd3e7c4e42eb2ac62e5fc8f459c06cf81147abe4306f22e16073374ef760006d917aba316d7bc6341b65eb448e971d010a724815012d9608e5c5e88f4ec6fe9bf37e2de61139af9ca1103918152e0e8757862b488da5e4003a683d4962f758f1c7ce49e5b37dc39c1f23be6a1e6f0eebf7cd8319280bfa9348a569faf7d20a050972d2ec0b9ae66a64bb2b8ed3fba70d65bd75bf65e985bc971f116386bb5f509a3f5ca726afd83e2e0827bbf548e5b6e64e69a6e83f64090ccdf1ff0a63a76d3fa8fd648ba41856b05b3324bd582b8ab08c808792aca0bd5a5bf971c3f680c9e9dcd5243af0a6ae695e343dc733d26e580ee667553485b0d42777e67a220a6e9dd51cce35b14cc82e83eb3a87a3857d240065c5a539c16e9ea5d5e88b30445fd80103591347c2705ce008076832df503778430d658662b2e9414e96b0b277efee187ce37e8d3d31974b3de8a2d59579e596663a04ce64a24259d01849a47557c5e6492d5cb8a5b4354714be4c66e7099d539fce4cf2696f56e38910975cf0210cb25995567ee0be22351365a9cad5471f219996e1ff159e38205e6a73ed52543573627d965a316d5d3fa7f78db58c6a0b64f1faf78086940ca20c9c355f4b5e296176ec6779381c340d651b9b11459a790ab9e03df170827e2617c84b8b33581c394345f7327505292677be338290d6cd9115f8764f182a1ad465502216e629934a428020f82eba3b1d6823c912030a50e3b032be6c2e00ac9a755d18ddf4a74bf802381927b21a5a981a9d3426cc72cf02b6679065703c26ee8e3dd186670cb8eaa54d8bdd465527607ae4feef6891b93210233850d09cedbd0b938cfdb4572d68839c5949517f5bc49ae1de6053ced193caf4302b15a492872ac379530edd6f14be6ec1f4a816d7669e24ee4c8e47945f6857824dad57290ef61fdaa5f39629d2b400bef7822773541b81a4e934b404fecd30fd71dde6683471dba30ef1010fe169caa4c350aef48de8bca5a02fda2dd1e445a36c466fa5111f2fdaf0417783b133035ab7da4926341f5fc434051e42d1dd8e15ddc3c7b099d279e775381be83b4c4b9dbf3d9e94381baa2ab3b7fc1885fbb6c25fabeefb3003205ca284c4a0603b6c188e847214ad017bc332b58050455e85e73270c47b313e66486831dacdc37238f095193b17653490a45e823a2624f98bfa2c130ae7239ea204729c08ee2f4feabbbae5b49209b23ec00a2f72676cedcb508b656a7cc827b10b40a5dc1c76e72065dbbbdf40a3a903ab7eb0e8586c6c353556264875614e116b1d05a5a0ae7970ea6e644b84daf791faecdfb247c4bdacf280cdcfa9bd06e712aee16117ab7b858c05b4489784777e03608defaa38f8c1a9deeb953eec881c1a7771e7de824d673bcbe20063ba8eee685a926ae39ccd4b4575172e278a8377b9728208ad21a85b0670ea9f19c02d6a1e01c3fdb838a4a5b5b231301ad1edce7fc42ce56932d13e71111052b73a8f99b4a4aba3aebf7344c079a16d53e1176c0533a7aa4f9f36474d830da4b6a6a9550d74eb4d5665bbae569300a92dfebc0686190ca36356feb78eff004dd9881b08efea5cdae4e63d983dfaa18c8ec283a1d7d46d073ae8b783382e16d63351bcd60349041bb340eec3b3c13fe1080804110f59bd15ba255c0909e5481792519e11575f95be9dc32ddb052ba3f6eb5972093af31daf63746ba7f57d6f4549f8d468326df808e04934902e43a0ce17ea4bf318b0f1020fb0deede9286c1f9c8d203805abd2fa5e44f17cf0f4e0de25a5bda64fdf7c625c06002a05c11c08e40353b261633e91eae432776e137da3bfe3888bb0a03a6a78713433cb72c710f7a76c650422187f4d5a52cafbd4e18a6278ab0f62c59b2594610b6ae1bd371d7260ac0d4d5a6000ce23e14c25075b60433f03b47a949bf08553fa62333a76cf82cea77c95d008a379f6be481879f935a3ae7461f5305241b9e6ada4e0d1dad0c58460e5968c61969fb78fe1dfb5a029146b2a2d2e65d0797f4bb2f53ff2fcd4a7716b33b72275d710e2e31354ccd273a407f2010c93a1191275898540fb3f3006c48c4fdb78c326a6db32cca640d8b4c821705a8683aa454386438938f6c0f4dd5767c20c0158bee0d3c2c144875e92948e27b1ea840cb1e39da4912ab595f7f06d34357159009c38d2c0b8c3f2d20b5c3c1f999a1541b408a1c447884980197bbac8a86ed22e29d33a7511afbc83163c55e809d067df8a574410ca8a6e64011a77c60ec6dacc5deb1b63b56ccf3fcb9ac10cc15f40a8ffdeeca045bf1d2e284fdf374fb169dfe495622ee3cf6acfbafbc45545a652a6d6ab29de2274fc83da4887f6ce660b0f43e3fb6d8182cdeb6a40f73d41f01a456765b67dd922641acedaab4b98b335352adce867372cd88401c9c1c2298b24ccad591b14b7a30383a9a6b87eaca6d83fd6742942defe0c20b9ebf39d7b2da4158116cdaf07517f9717ecb4ebbb823924b7c626af38fc2ff28c6b2c4cb6de79e05acb2a9dee181485be2ba8e485816a6cb49ec72551bb60ce6ba5f42a1751605b613e9a33f15c16aa2b26f8df3a6db65a7855ab783c55438e7de12ae6b21c11e8dd4d54da7b67d17a9a9eefd9726c5e1b4277ce5b2724617d4aac46a8f6bb4d5ae243ef398263ee6d9749ba5baceb95987ee07d46d2fa576f028529109a01a3f3181ca1f08dc82b5b9f7e7df20ccc53763f6646e1c455f6ae2d083495008108ac160e1612450cc5130a98c14ba6a5b0cc6449746626f6353c6e050623a0bb1b4291b3da6d3eda4a5c33d020deef40284fb2840b22360583a39aff806559c11af8f0d82f16128e8c627887d6cc5a3360356970eff4fa70fabd05dfd1c178d1e894fef2a8d33921347d04f7734a58460e6cd27f4f83963aad70bed5f555996b9e0290c617333a777592a56aac6b8255063c0255c751be846b3319c374d1b63b4f5e20421c8cb4e689c13f0d23ebf1def7037b54456249a3c32c7e08ec40f931ba5c4d45ab30e28f28421316d8cbeaad9d2745ed71d1acfe9a68a6901f84b54346965e88b7a27dcbf21796e6d01cf161b0d44b0f98733b6500b06153bfbb5821e9605fd28cc71b32f70c7153dbb3308aaa0b4e84d0f24f3495d62c8e964e20bf676ac56d7420f6b749680ddbdf5686dbb7ff4275c2e55c2adec33454ab7e2adb2d2669f275f75440a6f0a02474af91292faf802afb47aa323eaf5d44dec5397b4e3b0357ad20397f69210fac639b3e106886ecf79101433934342a7ab973c717e6ee40edf2ab9e3eabc320afb66c175f147648ef3f61d014140a863705d94100f3468c5619a07d6ecc3dbd30663fb3e73f4b47361901a6a8d35a9c38dfa8f5c12bd70168d9a872c4b896b0f2c1e70e820747de10494b4adcc332136b462616ef8ffc0bb7e11f4857138eb7d0d01f85704c0fe0dbb49dd5151a42946acc84dfea775de6a65b155436e6e8c91662519f184b126056f4414bcd89e4a4d8b34ce6f622fcf768fb3b2f035db933a2887165e360d0a750982e0f9b70d267d48653721a9b5ee72643601850b2dc8e9a361664e5e3c05b309875e6c55be2e6ad04ef590fb2921f6e663e67f834d6facb26f123b30a513bca404adc5797717791f99ef9f7720098817416e5ea9150390cf211b5babe801e062c0bbc84e27961743e14540d3620ad2ef5dd00a6a70003ba2541260e25f4f0f008c8a3321ef15db55595b868c608c7eef40684c8134c61af561c7d20cdd8d38310c403a9c9501200b73eac745e99827759e2eff1b783c532a9a31df5ac34e216a096cf5460fcf3d3f9b41dec85b94a6a2c9cfbbd3384cfb8d1fcb3caa29b9a8c32e138d0ed108b36a59f4019bdba318ce4d55e2eb80fbe03bc871aae417cbddcc9008a7706f53c01149a6ff87845cb2aaf51bada1ed75581cf2a1cfbcc869191b4398d6449ad2c2f09a3d36fcf90ad97f421b680f3262e8f47e063cf8a623a031c5be641763e4789089f599eeabc40300ca0d41c483994d65c0570178f55d3911b658d7f7f730771d6adebc6072f8ffcf8220667cd0fb2d6ca87a35b6dcb336f1445c1b6a67903e6bef2c87edd5f79198eb10ffd5fa05080e0ee9ae1579f5f5caebe38ebc2eb39c4da630e01f5a813281bc518720d74ee2b9eab5b913600f546d48f137cee9cc60291eb513d9e41e639ae65220eb5ccca6755640e6ed39bb1cf8e95aa62d49aab13779472b098096666237007b7f11a792d80da0e54cacdd4db7f9e5845be5a9eb7761b42dd41737afd9702428c01d01eb7cb8688ac72823d0c3b579ad62c448ff0b9a3e2d8eccbd3f0542f33da094c0b351014b70cae2036394a2b049ffa5731de2cfb0ecc4914aff46f49ff0fedfd9fff68701838ba81399aeb924ee38197ed81e144994badfb00513d1c3fc0ac2811482d5c91f253cd92977d2a589d5161b845940f9ad8de0c0e892767f88583b6be5f66459a26e5746fd241b8b379c2b30dab6077e03fc7bf01070815110f645f2963b824404669b1b9069977c1d546b5ed978d03c44bf675ebef61171cc9c79cc0d2b1c8ec80611fecec24ef36e059141b354f1abc72ff3257f5778f0f70ed52b80998c69a2f35d8136c480f7fc53ecad596a8fe60094be8fc2341f28edc4decf33c6075c5692a15e1159fdce56c5c91520c41f245e8bd1f8ee84605c73b1260cae4af7d276ead5270d10a19c20826b966e8146ce883f8e5c167d51b1986e581cbb6d22fb57a37496fda403f182d058d76da341f72c71240036fbe74d50f641d43ff8ab26f9e36d7b1ffe1277ad9879b2f6b61bb05d75ca159c007b60ea4fa8b0a237c199d9fae96083bda6548225dd6d43de6e7b3b5fce1769b844e1539b3123be9ac911ddcb65d4a7de170a064a788e62bc7a6f0aae5bdbfdade6a2fe04724e7948aa814004d2c7770cc021210389b6cb43b61b8ca9cd1b7ac4b93cae3f09c6c44bd3ae16839194a1bae0b73d2ffe4890f3ab867ce8987fb68652395e07490ceb8a832d407fde85ba3fe23898eecb0a48977b67c530eecb14c0bd853b25bbeedd99b0c6cdb31f7e14318065a88e10c5f07c80741e347be65aafdb63e2cda5359e94d882d8a4c448af8195c50fc8281ab74698038216203112e8222ef2866caede02178325b27af8e1eda2df12b0511b389120e7f9feb834c7e346de7186cebccc6c5fdf2c12c6b5f93eadb2c772891f6ccde722ca7bdf63020624646e30e93ccc32bbbc53d4f3b3163283f75c875a762600a859186d196a4c664a3fb6790db7978cc280e4ac00fd7f99769faab4026a62977761d78d2f4742ef477e5e8a917d30278c5dc958f7d248c011c0af1200464ea3f076e6738e3a39d00d51157b26570cf4419c883758481ddedfc24ac57ca20b91a57affe0a4bab5187e4c9870756e7f4e4ab973a4eee06fc6670477c979579e8f72f206510a3c032910a47f9743130f35a08769ad794e2f11dd4a836dbf474e27fad6d0d3b23cff72e20189c677f7309ede8697147d8324c0c625620f33c5469e20053a83bc5b8ae113fda9587db3a34f584f117c4c447a9a59a93af788bcf290cd74da9d76159a90ce0a033d9f221d12137f08999c30fb89929f7e317ed69d575a37b1b16b334c5e5b1453af7c0e80898b603f4a4e35ddc1bbcbc06f02bbcfd7281826120b3adb24ddc2022eb26d15f9e181deadab574639e2ba757423bf55afeeb0ce3ab85b4036c3bb8a2c2304f97078c1fab2867459867789ca5706f8ac91143fba1a966a46bbb4c9f05d9fcccde3348474116228afac7898d4ab91b363d580cdb8139ca513dc000bd6a6356ada54441e92ec6304ac4e3cc8c7d9d786f774771e654ae517aa3cb1260c8e22b3dd9f45992713b694aa63279ccf3370acacfc668595281872a6b66b9114a1000513e99dbe0b5b17415f44cba91cf6e76c4a80972d93ddfab86ee9ef4eb8a54a5242c2c040c08fc83d14bc4d2d5fc84f36e1009cdf8e14cb0b931ce498743b70deac2887c93a224020ee33cd97254d65b4b38cbca91c944ff5f647038c00ca48104d5b32d470f4695380117d671e9a36c1c4759ff15bb2c6bee6e4696d03c4aa2dbe951b25b4a672753385816656cdcae62a64a6a4934f120ba133b14138057f34fd5855a7dcb32a7290ac142a56e6c6e2cbec3e4680d75e8eb30d00fca4cbabc4035cbfea280b2ec8e2e8fcaacce454de9c2f45ec3ebbb25e202820690dd8e5eb57b079bd5c4c5be56ef187d200e165598549c37eb31b2aa27d462df60a7b8b3a37da1e1e3635d7f4503752b4f52184cfeebadf3fd31b27e14323a1754e927f45d4a94c20e658d1b277b3d965a98af149675140205099bf6ee4def0e54ba8c7b390be29b949678d3ec6e48107dd0864f35620942286f97c4117bdc03fd5cfc60aaadaa8b42b6449714ef27b4f705e716ea45b6a4d78f29b1b53e4f028c70b10f72f2eaf42b94c55965da02f00a322ec647ce2db88bc6a92f01db4e7793ffde60af1c45a275a6b70978ee46a728a732a9058aae517409f3d183f711977bb5d816159ecb08c84040fa2074596b7b20fd3ba2b72490cb8899575e5690e496b964389ee31aacb07c1e1ccd3eb4f20cdd88931a668ab4cb3aaf08b787bc301716d383984fb14b3e5fad8d3ca66dcf7538916a4c7cac1d9c870806c3895dc20db33b738ac669bbf0b9ef4fdb5b819a9ddd3ea01261c2e8fe2b4973e4432b35a29b88160df4fa1d4b844595ee8a720ea8ea3962cf947807257511795ff2c44a54b040ba57f0948e13af2b2c25f0450738f6c69c96f81295c4658a4f4b3306a5d512f2ff829081587e84b95fe134cb94bd4454a7e08a7ca35c2e2d23f02527011b17cd1af02d4bb475a5ae28700caae222e2aff59885a9728960aff1294ca71f425a5ff08a0e43adaa2a59f851f15b523f946d8490afa1c816afbaaf1ba3ae45368fc17ddb56a995884b09b4ff643074ace10b9a339437c7786dc6ce7946fd53beae11a7c1a8816efdf796f0e82fe03a7a17a131a9acfa1213e110df9d9898664ad2855cdef8e867c0069483a9186c6f29286a8aa34e4159686841d7b6968d47d1aa2cda101a5fda286620e901adafc311faddbb7d1501c590d1d7dc2b01593b086c8cdac21d70fcfb8f2e11a3a848c8341750d8d0a424b7bb98362d75181761c2e8b25abd1e84268f45a3bd920d70d3a2c52e9767db7b036ee9ac8d7f7652f44c789d81796b73dadc7be636b0b682dfb2e8fdfbc4d98530472dcae6e4cbf966e8e83454f6f0b3f54736267e02e454dd5665ea284c108e4b98748cd6efefb37c3db13a978ec1b73187c044274ca0d277a1d37660e036088a438c3cf98492680b7206c9ac3e1236ca3f58acb8b63f62e9ead805e682ed44d8366936f3881fa3f04080d3e5958470ecf624e2b36f7b50bec26f718c9f2523a94f0fe111961906fc50ae01b7e0b931b0cdad8bfb4f28cf0d002aa6406d109ec6dae36edcd6443ca09e0355f3bcd0df243cb05f432479bf626b243e407f69aabb131447808adda6fe20346125a98607bc1da604cb7737c0303b435dc3f9fbc95238916534408dda03015918e1e2b32041d40d84a918c862f3a844e40188a4847872d128e6e204c854844c317158a96567ba2f5c01ca3e97a8b43a4c70154fe21316026d59281d83f4c534616989ab33573ed34f1418254888c911dcee394e6ca5b44c79011e6799aa68aedc4c7c80ce3614a73a5ad4463cb0ef33845633398d82030e5ff490339e4b498e3f285d5ce9ab4f7f0041e7c2bd87fde792b22190da64838ba806194231d0d5b44083ae0b01423891e5f24141d8030ca918a162b3a1c1d60180a91448f2b32843ead6652cb8139e3d37417c3498f00aaf84332cc44b28519b11fcc268c2c9837637366fd69a24105a8108d2d2bacc774cd155b898c2113ded3544dcadb89c69411c663ba668a5bc4c79609eb618a667b10d101f0caff480770c8b533c3e983bd9d856ccfe1097ed896b07fbff32846221aace8307402612b47122da68810ba41612a221d3d5664083a80b09522190d5f74089d803014918e0e5b241c7da2e6849683f9c6a6ea968793f8e846e2f439b850201875a2e2848e8179a366f5d64313861250f3477caccc01642d9445fe188f32ecc04dd87934d1be1a90341cb8e2478221e205496a111611c446602c28aa984ff42df0217bacd431463a8b71e82ed867c34be6067dd3696904e46fcc81e2f7200a32c21af3a718700d61b28c766cc1592a9d47382a6838e58c0d0e8696d9858208accd10f9e180f68894f0d5224c1cc7fcc27022b4f8fcfd4e3584a3c4318e4d896a2ca59c4d00df5f7f71a06d8255e5f16305c8bdb781ea3a88f3a9fda808b8f7a6d6b0d8a3b6469401e17b7ebf996e42945936943f4e3afd66d0fdeb4319960555a44ec842f236112d7823429c9e3d57d1d71fb4d5a4ab178ddaecb30bf5c26deb7e5dfe158074ec4d3b2b842d39472a18b237d030f9aa5b2093bf09d8857326ca31f311fd6a5104d27c38c845ed6fe4412b7a8a1aab05718b265857e12192faab604e5d06c7ecb1e7e5db9c5cca6788ceb43a9d71fc94ec68ac0a21daeeefe26dda4b6df1cf9ccb525e23c37cfd93f5a97c69b3968831107b932d39ce51b20ee16770fad999049a2d198065ec14447e2d8a94eaef44e31bc0cfc2ebdae6c8c6ed79316ce13da3dbc159d1c37cd223072611c0d16b6ee5ed3b6767e6f5d0605f426df4b987a37ce7e43c312832913071dd60dfe8faae018d1d0b55072b713d1bb1cd736ca5842ff2b178e0605f47d1941c82e7e57a3d0fd121cf7d7189fd0f218d630e6fc3ecf32018e3996624ce00851d4dc47caf2998134fda92d63fd9a6c177063125624f12963bb57e22ebdd49d30b5a88b05ef361165cb3cf2acf252b4afc32c47d8864020b0844e92d8a2833a363b42004453c7bbd646d5f68227f532a25472e1dd675f47cdf1405a11b2272162073ff39f20532ce894ec2f6066a61604c29848a9425c950b246ce39e4e252ed8015ba62f7956a40044abc5a5a96c24bea0852fe5cf5b0c3d5c6d638e731b597c6c38901ae3a5de28a024cd9e3c7b5921f67026eaabfad45ad25ea35e93cea9a0c3c58bd73b6bf4d2600a7952bbecc3e63f4d328388a2b5663e8329b5ea9336f69ef1ee32d07855fdfdef782c40a72b2dc8712dbea2ddc43510364fba6ce656c5f09d081564593124f4a7f9ad4be2c1ff16c45933ace15b019bdd28e0dea8669f0b294a647419e9d2b6085b1a5e5cb58abf62240b860758aa718cd181daf86efad4a8227f6cc4e2fd7801c6fae1703b34474563cc537c2c831f4b165bf185ec5100cee4983c390166c8c386702a703cc0609b454d2acc874989316bc81dd64fe61d5925724e54cd4ba0f2cc675d9dd52d0430d96d0950194a031eee0de83c09fa6f40ffce32fedd50064b5050f4f3571d07b8ad3d76e9e065da5a12e1b545ed2b19dd9916859b3e65ad5a987c69573836be26b1c16a585b552e18afbad29694877d6d55949a277e3ce83ebf5a2e2d4aeba2efa0bf5e3c318f8f7ad69563d4fa23f8cd21b64509123a8f832030bf735fed1cb3957841fe9473bec85b161bfa57dc720803f3bcdd4d8c70790e848ea3b72e9494c105dc2100050e80a40a951672dd3bb00e658c81ccd3cad75696ff606a4f70198cb585f3233278b95f65c087b5bf610afbec99736941b3adb3d87d8090061bbede2f827e8505145648a6a8852147d0afd42beaa04c22608bc7a081fa6792bbde4e62b57533af89c07dbe87288b7386e6215b5bf0c2ce53fb2d75ad0dc3229874663efa7012ab2dc5d041039751ece7e23c56960fe030fd63d3a77c36a36c090f49d1000aedc95119dad72c5389d1701daf414695030c5b35ef44f19dd59bd3866104c4496fb8f4aa28b8ad426494f656c6501be1ecb7a7a3e9609776c3294d8bfb2ef70c6f741d746fd5496df71e9ff6642723f017b280d3a2637b620dc4175d8e99079104fd56106e9b6f31b53f4b43d990d3ea125173e0fb5fc0ee3ba381d4e7fa252598b4ab6f91468fdd4a7ca9de1a183fbc673b8e5b7b105da28722d4870c9beb88552dae2029cc057469989de48eeb5e6d92ca045eeb3029eb5674b88ec6c36c7941151cb7505397fa427e20b96fd1049dc8118a54dfff499d06ed63c7ced367a8db1aef7730b0e1781642d62b666e68b950807dd0dd71d98781abeef7f5cb31efa1c8cf564a2b32a27af0a6ff48a8b367cb044f4605c3905fa7bae870df47d2c842aa05c78f991b3600bebb21e8cab9017252e1458645dae852928b97ef927afa01b623137459e905140e08261915db814eaa2e24a8e5e9b51c1c5438e02253ccb32970b1e322eb74317485dbab0901bf4d2f3224b4af4152246f605bd0d7ac817abdf988662e80bdab818d6b8c8bcd8c385830c733f7481d615c34266413dfc25ad6b053f59975b88051557188e2cb9a3a7695ede65b10b094e725a68422e905d3feaac2cc38a1951075de4572d34c965d14f087663a5fdce0199ca3c6513a4663bf069fdad9f959a2bf66de48bd500ac1194239dc37f58c1ea47de46a7e95cb32e3c4ddad107044268838685918c73fb8a2c23364b7ced03c2c8b37109a82a48220b68096a538dfd3a7c72cd04beef1f2e2a62365244fb2415ee015e15f518a59981866c6201c4052bf11acb145daf35e48ec3ab8de2752b3847521849b7d7b419f863a73b402e1c77b44ff54b337efa26348b4cb348b611b7bf2802f87b42e727ab6f95cde952cb21ab5f24485103f7436fcbb7d3e0346fc32fed087a70b4f437e681682da0f02126598a08e97d484a9a14e3f9bfc7692ba383f870f3c1c5163db422c248da6a6feb144ff80350177e36ca8a4a6e3a727d04ef83c8f58abaf2df7e72a92a7b605a0be314dd537d075d4f62489432171ae1c4ae1b47bb7b4f9f7d5965eeee687089ab60680ab49ff8c71c09a60001d4ce96cf09947962bb15a08d686c6894237110255b2a5f92b73c9240fb9175d77a20d431778305b19f70079610195b56b92c406744a4be06c58a8db21d18fe6cae9a69790841d34751aa822b9422953841e0123f1592bddbf4741763f207796ee2f3ccff061b1a2a7fd6f9aa96405990beeb34ce2a0a5fe592ec1cecd4197ca9a78503210b2674d41ce4eec1668ef4296bf1a8ab3cfefa32e8c74c3a7aaf8b49431e43b7a437fb7215eb4ba48557e60492b6532bd268481f5831a1ea708e3be81357979d641bbe7e771db9cb19636658ca369daafb185316408d930d35905b4e0575d026e49b5c528fc117b0b20db20b896f4bdbf813e874594b3681d7d99b19fa39bc6c8a1a67ee2b51885c5992705f0dae4c96d4ac2ab38a5a87ba9ae61c51634c981856aaed529b7fa50834f419497e2dbd0c876ca41fc7b02c6ea3a41de691e31699b55787496d094646590b3b2f19fec64de599c45c5873ee0639d5b8583132e4fc86c976c4d6d7a6153c050dcee2b10826822cd86a361e212a3cbbeaaadb283708a4d729872427f55acacf69f6ae30e938ba24b7bec4076c0d756d264b0402a98283a35a46fecfb8e45c49c719b64fb789f4f4e5a9321505bf82a73a93115b2c9f97285f54144be948f3044a97e2caa173a313d9a8889aa75ba8bc1277b06f6eb54a272710dc73e9f6fb4d92a837ef2d8ee15b44918e74310701c1c58311f5f3453c701fde779dfe14a5f468d8b1f7acb25dfad33c43604b08d6d5c25b42cb6b2ee793c2b28077e032b9d11f7afe9fdfbe2786db3a6a28024962fc204e480e08e5d4dd4dbbccdf2e92e329704aac9de04a58acc0d9b2dab7f362a20fb41a692034063e62d0611c2c645f058dbaec490daa7dc94b13cee6c8a9509120ac89fa458f82878260fa022ccd2b3f13ad445442469c8716895e15fa983993b7e2a0d87677b0dd47f4d465c49065f1ae6d262fc8bf4dd0237932cf89b5bb963a300396ec2a385c12be6adda5574bc5e2fa41ae1e0716fae9b885a601e06f4bbc56e1b659afbdf6078b65c8f5a94a462c9b84499f2ec30041d91cf0c84672b29b2fc9f4e1e66b3c782a05e3371c0d2efd2b12830c88ca2f8bdc0ca47a99c921da726cf45adbd1461f28cff2ce0cac534e2051fe9d71f9d9999f9c425417fcc6f8542cd8195216f76004e9a27bb8471817224752a82cfb9305886cfc4d5bc0e7b84f7e478c66c6881bc1ca966c763b529c895ac7e96cece5216b256a1d94ce0de32a2090daf8d60ca2b28671e172146a9c37935c0429d442f535ff369c91f9185a17b681673417266e1e1687f25370436b3f42dedf88749869f3f46db3cc3f4ba86b96a743d9d85e6e326664f35d4a78fdd030ad74e6e19ee4387c0bbb0b1259b0f21c1104cb9234cc6111ed474620a565bcbe87dc6303162621a2d444b2b13dfcc9304afcd649db17abb4bda39b756aeabbb833ace1acec8ff5680ebb34360ac4e0b02bb4bcd1c0950be995f97e40eaabd2754d7618f3e4d7fb34b960398eb8da373e16b01f3492df5a49e512ca7def33543b97eb23215a49cac39b54947176bc8c6be59310794121857794ef3599aedb420308b57cfabd286b0e00fb3527d04d18c6fe7423a09d81563bf7b7a5b77530b004130460667c9eda143d0f121f37d9228a6f0f33bacc2d6d1ef99a7b1793e53685dcaac909bd408cb4873ceb972c20202895c562712b318c582eb90e81e1837ffca4197f1206da1d00c5c5f47f385bb243d724053cc9e4e284d91a07cb0a667c58a6a6b9e09da5d3fd37ab2d204436f303fc63f64f23c2dc472132fd301fed7311b08196a0a6b01ff0c1684444200fa9cd43d705877df501b00d54abcb762689230c3715966c4b9f0c07dc27a791cccead4b29af90a982cea24140495b6dae82f016533441b006d032f44eb603a7872ab402a28517b3a37843e8619db11dca165b8412f6a42b4af1df0a768d8a73239000fb49e4377a39ec93c535f4fd693b876408a0f3773fa93021d9919dabc52ea42d39b27886f167db7596945d8c6f73c3a79cb6b5dde977ab8567949e079c6e4ffd88927805d11f9db882c842458c3b3c98a876d75e301a2517b065bef0fd7bf44efcfbed7cfc0e899ab31284b992c5d191a47eb39595894342331440a0787b9d146f352f31f1e59420d64514c77b5d0b7c483fef8bf8585358f09403fbf024e640efe8f1dc6f890d93f5a3d7bc25bae23303b11bc21581eceb8d5d5e738709e912752bd54bbf6cf5c54269c0f83c508cd806165193e085d3956b1a88bdec7312f51936312029b9e13fd73c14df15482b7aebf803cdaef2f6d2a2ac1cbce3d24c8647383eb1005cfa2ba7a5e5b7f5571bf45f4ba7e1307f512c864f5c750f4f39127232abcd4354047b344fe295175ca3319b765df504b7f6007aa92a65387a8c73d52b765334d8967311215b86db1a5f6baad5bd1f7a1089383d94e216593a5554bab023ece14a468db438d1ed38c4fe2c01988f1192ac032b50750a989ca370b7b03e74139a69ec6795768aa9de82fd2ac16a376b24d1b6ce2dc177c0be3dc2111f6193c5fea1b955396566dce1247306a215e68bfec5f52393abd25dbe1fd6cc5f27c90fde7d09a634f4fe6e3cf7da69392acb1faa16aa067124adc821e99a8866d7b0d4f97360634216aa61edfca19dbd8b89862dfd7f7ba125b5aad6de636f7274c05dc843e14c3a4ca04852704fb88430fb207bbdafbac35b1979a9d289b130d58bdcfefb7aaf404b035858fb70a095f441c52b79b0e583490d6b839a426b54f374067123fb58ab5da6489b45755d9a9b2742830fab1fd2ad2c84816c9e3d9387e29ecc6dada154dc776cb15a3bb5b626a4f56e16a0a17818a60e163f9be913b39dd9ab933184a7916108208f6cff2a74d35a038365f8873eec2eee75838367a80b99da86a4d94a4cfd7902192cc9b67de86203b609dee8bdd07c7ef38d39b5e6e2a80f20adc30aae7b15702c0f3818213627d847cab393aa81b644e716747b2bb90df1d0ede7e934e7c27f3806b8206d909e8c1a773a6950cc094d1947082be983c3e7a23e78bc25a43d00bbb8929f1b735c490af1a29368631e7a1df979a8e4f4f4a8cfc50fa6c91d6dc4a50f4c7e390b7f0382333b3faa3b1798df2a8d4c9d22f6d8e337a5534c09fd03086f8473963f0a52b0b95047c1fe4a4f47716b171f0b1fab9cd7bce7832868d53ba0a5a9f728af14341fb1e40229ab47c9bd229216c0e7176fcd746c258151a6da5a1f8cd14b9c13d9562c2cdd7c979a5a717dbf1767f1f4cb1ee95718aa0e64fe763ae036e477c5f664b74637f864fdaf3f8e94acdf25c5605ab0b4c4b5c8a320637998e1c951d15a865c4f48ed824e90424e8a92a60725ef32dc13fea88bd0062d3976c905b470e4f7d0d1ce9a647e7fcedcf7026a1fd5c9fb3382b23d971352be7958dd2195f126cad81ee25301c760d6a428d1ba91d2a6615c108586452c142ae7fd28e448d128f9e877a7b46b03a96e0c23c6505dcd646ef7108410caaf119ec4adff84b2d33b9b8986a61248aaa6662865108d482d4985e1f446e55e9edd421a697416cd8d83cbb1d7e133e6c79e7bf3d70d6f5d807ed84d0e85c6babed27c8204d3b069eab3a2bf3f1b8116039ddb997f5e47c5f1400080e4f4e8c5276648ede7bd4d338dabc1146c5be94a0dd9fd53571d56775009e1b5eec29ebf081dc0c5a11802a883e4bb934c0ba79b82f138b41c84452970099e36e8ddad71a56f3c9907b38e0bff00a3e2c9b6054f54f75d806b98db50428408071b35172278e29d51010d172b8a96db24c7e5985b96343e9676cdabcdbe0c62dfee27089a21d941903b7eea0e64dceb398c07dbb815a09a355dff21cb06ce3ab2294aea7cc3d94f6a1080380782c76cfa0ed99f9fe003f6d9d0d720c526b30c3834775d78749e9b1e8f078c5b0a9d191db1a49fc417925fdd13f149d92bb8f8d625575baa1091a952397deb1219802e4837c59724ea69adf8885a6b4fb7710bf4c0ccfa7a62f6633504ad9780b6e4298cc0610495e22686dc7a00e2922ebd018af3bbbc0216e1c7ccc95f469dae4a53d15318a7b2421910a0e1830416796a18981f89e00f1a997db054114264e75b8dab603afe7eac108415601b64f59539a21be3532cc37cabe84bb11a39ace20b2e45cdecd1f40dfd8df7688d6ff5ca44f2fc88c984ee5f586a169dc4fecf7993d5a72c7ca7d0fba62db28a1733a2bd4eed2d1791ad9a8246322057c1ca074a2468d338326ae314f124d9c19836211dbcffb8757864f4685b9a6d82a25f41b436c64c1626919351e9cfa7f4a7b33976454504c25a145302c13fea6a5a7d6b34eb87442656e5a99b2eac705a2a207c58b56dde910f889abaad8a5be65056cb540730ebbf0aa827bdcf693596c5f714fcc219321eb6fd1d1616202f7cdb8049aa363fb2df68e06d18ab266a5956f456923bd48281430a6080928ea77b16214685ec83f6f7bf159d4a7ba7c6d1a166db7925716206afff3068c9569be7a14121d384d692fd2d2c96a12b424dc72bbb79895533caaddb6aa3db51432ce190cbc040aa51f07bc0dfc42050bc37fd4a2277ac566f32d62629dbcef1efe9eb6049f35e3f371de82b8f605d7077d5588f4df67c29bb8c353154ebc56785e125fcfacd89c33f5ac27165a777147f72a627270bee21c719caaccd5cdbcaedb06d72e74bbe39f4251d73800f155bab0b824a3bade4bd3265fb31960aa5ec90961690e4fb584142f609d3f189b93f46c03e23535701f4d908a3a77e8c209c7ff21bcdf606e551e7b65a75d2f089e36e2b1f28ebb2ec26743f6b7ae4ec5ac27f36d7adebf34b6274b7e40bf939b108f78652fcfc2b42a5bb92bae3c32164e7ff0fe1053d62879086dd886d7181c8be7778b2cce82daa940832ac2adc062be1a275d763b5020f2b84d4e0817cb13960fbae10c3e855629babc72624dd6f7521838020aeb6f990958fba6d2a20d8b097efc0ff1b506a60f7286d86504bbae633b634f11800d570c900dc8d874d749e8e87edd99a23026a1854d44400f7b9c147bc591cee69b66dd2c22555c7ceed3a6b7d28bf57377a4c30952aa8a2eed8e23a6fd3aca0418ace1fb015ac58cf62a245b0775cdc06944351691d1e73c75b4b2fddde84bdbb0174b89fc8701da378b7843f673be2325ea78a44288b19f806ea9fd66bc633306a58b64887f64f2a74ef87884babd2210f3c032a33752c5f8f3feb45f08d82f35b4aaddba0be5cceda4f304238fc5872fa896383418163499d2291d4ca97554f1a6f37bfcf1dc7bbc3e8f18a60fd7c701add845ad91baeaf07eb4f313a2cc505d0b50278866112e8278720c8a7674bc5cf99c0cc0b0621c9a44d495c7b587ca80a0fa7e61c6bff775714e39ac24dbc4feed86f3e39bedd7b7ec1a3d7aac7e0508d2059ef54fbfe2581401a94ede055d0f45af8d3a80d34266faa18765be7ba88193622ddbb623c98853841682e6ed150c6a742623e7975fcd8acc60dd704f0e7c1673a84f28a4fc799e3d037cd136fa06b1017f51017498cdddf9bae16a925b1fcd9f52b13a1de24d8c4c581e994d293b058ef6d0fd1b3ecc214b4c19b9b68b2715eed9a85e34c2d75255dbabc980833912f038e1ee5b60ea78806e0c77ac352bad6f22cf9fedc52a9b802deaebc4552a3607005957452cae869403f2b862452d0f181732e7c59dfd8890997d55e9cbec282f94896cf25fa625010bdbd2c840c283d27070f1d0a7b0ac9a7dfd884c9d5390d0548222084c35084d84d0a0ed958e12c824b43cfd11c8284255e424d266f992882846916e4251633004371248ca6f982d6c22d86b051470c3980aa00b2a30e71b741109239ec0d5ddead02ed513a967215ad81778725c04e4092313b5f41be42e3cd71f6e4fab19dd057f6ae076647579dd7d2af4fdb48ad933c74220956afa64de3c53bd087d819fb12109af7c9b35a9f1b0759522082c4de7e5000032b13fb4f7c27a68138573c09f572f3f19a2fd2639ca5d8335375091be17b3cd04f1f06b6044226e131747b2b0ff90e87de7b07729accd5b57514908fe95567a483e12b62c1f88abe85deab5c6d198cacf0a74b1cc59e2b2bf7ec39cd96f5423bc611d52efb1e7677018ce1dec18762a553d417da984e0c046753a939d95db7f71edbeeec2d23e8f897fee6a9de634b1bcb4166ba627a82e5ceb554ba5870d2f6db0cb31a3ec51259e37d130d2cf9a98955b279fd576688c78b3dc4930fe50b39a82e242104446550983084e79310dee106349a4be214a4581495c7fd18214b734cc21cf4ea27f833f7ca18068d32506949ae2bafc29727ccbcac003ea6e0e1b90d16a80b10b89fcf6e3d310cbe7cfc5e99681739f2c64dac2c2d8deec97d8ecbd58bad6a2e86226a1f8ab8544c35198c74f9ed1d3e280413a87fb706bbbcfa813ae5122d68bcb4605dc87e196ba20741230ee1b30da1d62d8a5b8646305e34eddcdc0f52649d9a7ab6cd309e3618225308cf13bfb055bb4921fb427fc4012bd2b445b9b16f020ac7623489de2c05379fdef8eff4ead65ea3726d9d2d9d2055304084f2aff9ae348546e89268342129011ec263c0462061670165a6ab1e3a1c3c2c87883a33ad5c2e7762260fd7271258edbb93699bf072226f3a06275174a4f5e4c10421a8d1e970cd8a7b67f77c78484cab73c125c58f08cd2c7e52a3215c6845a10bb12ebfcc0726aa651226303b8905369ff4c20a2369da1239b95f46fda7add2a110139ebbc508801e0f16f4281c9edd54f58396ba5be9a7c167e86cfa91f8fd733227dc59bc0f64b732ebe8f6f0d07dea98904e263e48a7ae06320dc02c7a66006a87e636c102c975fe348092703e35d976404f136caf678c98b895329fcc589b6e6904421f40921cded6dad38fa2aefb4a98328624f5dfc6809b6b2acaf287d38c3b59f4dc78451309bab7b3b9f77c1724a7c73f9e0814ed7323efeaf6842e45930874bc242ff4f03798ee23339c621467af7a036b6a7433f46c8500dc1f725e8f94e1ff6b292a984907170b9f5ce6534e368eb66c4a416c0ef5d3ff078bb9c50d48390a07d97ebd3f16f9c97e0064aae78564f81dcea8211eebc69dd626a33d7d4349fa5c2c04fe9d084638e88fea915e2360560be6ff41ac48af6144a8a7c7fe4637eeb49a5b2779666d59f765f7378aa05283de2b1cbcd36ef28d7c6498beb9eddcf2c0e180078ad32b538071cb83f943b262da2685b930117d430aa180546d8df98af4e53dd284897ab571cdc0ad6a29131bd51804e2e8f9ec213698c96082dbcb14b0083eb5717057349c1b498bf252d07ef47b36ee4b471dba1dee584fd4ae169892189497527577dc46234ada0cd06a0cb69564632d9f59234624da9a7eebafe83e150b3f706fdc11a5c81f0ba71c1490753948001fcdeb060c210c694c6875c4d14b7d565e2a1d8668bbf98534c778d2250f9b0eec18f1316c0b1eaa952a8c485e0ca0640a3433d1c306b4f442655a0502be52b4bb473c17bd2ee980ce4a9ce278c8019f35d26bebed8520c4621fd8ec583d9d53a5e9866fa315056720541fbdd40b6809ebb59cd7ce52eee8a9b3c08412b24eb724142a45d269c19dbf27a8320555e50d03c5cf7d830baac050925010006cf7347467051b06b259af6a294ca2257ba287537ba237cf08a716aa5818c14bab2bebcf4618f775c7efb3c95fb184c0c3d65d776ec36fad48f7b7d6aecd37d44d934f6766aa53e550d794e10d3d0e5b717f54755bd894b8d0269ce4c099a18b673bc29513dc659acbc5d3347268b5d017a0ba4d49bbb1ad0a3b01e30934875ae0e0733c790a3074a8528647932d24d396279c8df5c9c39ba58b437bcf11e876e115588efc6098cefc564f11722c3c3b2d1b2f4fd9575cf1ecee5cd8cfc73fcef14d85875dc2e2f304a42576358837e2fcc51a1a1ee6b34a67c5d842d3bb6ba8d0168f3fa0623a75f370563da66c7f8b347246a86c30b191e7f9cdb5fef094a6f18d264402b6996629eedeff207c8b487eccef79a667494c3c5534d19039477770909139ad29a6fb9c4004c4380586dd803fd5500d7da0733c97df00acb9999309da0049165d4f8ced7a9217f3fce0424dae1a968944b56960c02c325a12cc4ae6cce48c662813f99c95d9446bc9719b4f9e83a56d489295e180ff425b117af47c69c4a6c8342e3fb9f8e0203acd78ea57726020eac09f413cf959199268261e5bdc8d7cd2c35303ca90c091739043fb33cbbdb39505c1cd789d8785f8f5bc6553ea4c05aeb07e687c8c826b4be8a8ae01ba35e7eca17dce85f4536acceedd0f053616aaa82191ad0a6c988e3755a4c0fe3808c5c6f00c34f45255d2f216aa6bec3f7bdf03971aee3f21f41e20b1508f42c712ca3407f197f9857f49d3e33c1615a505508842b0a93d4ec0786b8304252b1c85f16596781b4c34c01323d4153169ef389a089cf6194e1b2f41bec60106d2e79e9ba3453c487cab369355a5a8b5b93035453edbf57db0d8bfab5a67530323bea071f86f7beed1f3a8674ccff01cdbd2d526dbea0a937bbbde9c0024c922fdcee3c375a01037ec77544fca244071181dd6cd6366101a492bd1c1db8bf347288f94631cdd24bec855ea7b74e27541ccfacd3fb067a626f9ab098c4afbfa00c0abc9ec20ad94d6bc2b4dc1d0c682cde7ee5a7ddc04c0593d49d0d77a58ba22c3692c06969beeae6c0c5b090ea05aa8de6304367af2e32b167c9cf95c9d54651a7c67b631085563c38933b18047f619aa869f2af6e64b4be18831f475e313a1508063e89e49a9a7661560311cc9eedbfd67d10bcf672b35bf1272fbf4cc6e9c8fd95da81802ff13b4631d30c12cde238f4d227dbd7a47edce7144ca9119ff233c0ff415c0cd42e3e77ca9bf7e5b24f0f201a8b55da0f14c8cce373ecf36d88a0bcca88faa07ceacbe9912bc2b4aaeb2654a28449952dfed9738affc1250193d1ceda2657b25f08f9405c7540ca94315c64d48a76234947ce06c6ed2d004e6cdd8703244bae4cb802e14ce3dd41b482b983ce69503ba3036ee363b933acec2bd3de1ffdeabf6af763e47591d681230a9660ea021d7278c24c7c4b4a7f9d1d23605781e1734ca264bd13f5b3dfaf9534110565efb14f1c6a1d853a1e31bce0e81516a265f288bd9a7fd886f58535d73a23fd975609697e52e9b3a308e07f87327080562ced6d6afc775045ada1d063d14883497cf0ed5d834802f1e5765d8d16172e90426d54e02ce896e98976cb2b6da724206994d9fb7fb463166707343f6d11db63ca03672495fcf41373ac52fdd01358187158ca8f704c0b448461b998d66b43978161864e077b573742ccc6b1925a838ed70a5bb34e4ae03e1d96afcd0b68a843bc720182892aa13ffc0ecca3d318672504fa3679fbdf0bd39914135871fa2e9f5b1b283908ed95a6bada683d74783955621c70cf73f43f19e2c0ef6104e9738b880e0c00b909a370f0bd798610b9fe66cd44274506285248060b0bef310763addf67ffe2e036038462bf50d6d2e670e413f9f983072a433772fcde889cb360e0f14078784ecd815232a8c4790338d961db02a79b322a30bd0f3801316959e9480bdebd813de214f37b328f3a2048cb0d8e0a11baf4429574e7b6df14d832dd7a84882b68ca3389fc57972b07d72efab862381fbdf4499c1111ee00b3f21562d43c5c1e70924ac7056465507f2b9b40df1123b410b9ff0c86fa3716f4f1e254f4b7f2361dca1ea8695c9c501313878e4d03aee64ca5a2458b1cddde854cbeb517d2bccee084a698d6d26cd0aa8b71798d37a9b89ae6bc15116186cab3984cd0ca109b42828927082739808ceb037348182c5fae02695f505b78914c233cc5bc6aaaabc2b4e3debc36fc51d902ff2d2dd5679eb3e3434b0b4d39f32f0dceea61d60ae51d9af8d443da513d04f285650aefcc283182af6f4b4f8a6bc46e1e99a67eeccfbf31accf86596c05dd579a16624c2d8dcf7e36e8ff825ce0bf56a36360820c53a2fd4355b7b04165cebb62cf85f0f14bda6c8e4dd2043027a247babc439bb0b19b6034bde3b5f376673a0623d6853895307744762ba3ef02818b28a71877d2a802328e843f2a63fa92222531131da62208683a70b591934d599d07525ed87aa82cc312d884e2d581af677b930a1d2e854f269db9da2e3b0315d77aacd4af0c23a8c58bcf964c3541116e88f2e5d886fe42a4eb06b506ba7c016d67f52fe59e3c33387e0b48fa37144a2d7a01015e7b22424d2a7082997c127627870cdd8ed29612856698a7efd710c3a2cfef57fa9daf176a12b6d9ea91cc4b01375c4a32792d9b3aa52d5998bf3dfe507e663dca28c00feb8817683e6bb8c84e2cacb993de21f7db9aeb73cfccc50ddfe11eaf98923a6518d1346c1ae7ee5612a390458e4d1ccbd7b92bbe4024c7c09719fb8c604173d2f1f9bed6fb4dcb4c515ddc6055e0461d0f548c3e1a5fd2a4d1986c51187ae52787675072d1df77d549dee7e2ae405ab6a0cda3bf4edd1de1111f36e3433a5b36e102737bc5b1b66abe2d1e5e05054d1652e140b257b643880e2b348b8f1b8a4ea34d574aef4774370e725995de354762c400a2929328d870e86c9f26ead639d28952d3cb0f441df36e2d971a7e8da97a0548a5ee60faed8e2ad7d7f89fd79c8d44af42fbe2aa5c0e82135ab7db0ab4ba7e65fd8bf762b83e1ebeef89c72402b86c6b5708e05a5b213709a0ca74dbe211e4a82ff08d1e3d2fd61b0a6e9482ec67649ff17157c54fcd5c5ba3e19a4e3fe0295e3b26ee6d9820a32c1738836151b070bc24c2e4c88ec9df3d8cfa546676c837d6288bf4eefd20217d215db62492bff441f22b111767a22f7834505fc711db9fb328b707433289de6b4e77b79c3292ddefc48be373cd2f35239a1de3d96877ed7f058627b48cc9c5ae09eba864e38a953c189763e466a40fa8a72f5f68f8a1ae3c29399cb195ba21dbc71fdbd9150540aa537ec911ca2bb72dc9635d404d8494901ec7cd17c75ee415bc81bb8c64c6758b38cf6433db4cc909c4c52a9541abe427994f2e72cde411e3c1f4cf2222dd357d1e9cc115cb004c19788cc1bd3f6eb4e5697a57ed5ae207d9223f579f71e12b108e90b96694001847a7e7f9f03cab5ab837cdc2aec155764f120328ca168337c03637deae6e356ae1c54722b1830df6d7b8ff6a70221f50a01ccf65b0fc88c8b4d055ff65b855cad91ea1107de8acc4d14f98dfbc324f247b44adf858021f2678f36813d92da0930b623eccb92910a0340d339b657bcbb01796a0616f22eca869e6189c5783721e1d5c51105d6a0cb2b5ee0ab7a10bb7ce913cf2f1bceb76b04eaa194f28492c61477d91138184aac5d721828e5d39ffabd7c0402a44a042a3feba25830d81da503c64a43268ecc117397cb65df21b0bf52bd405330b0c830170606d10cc20c12e4e8ca62d6e0227b78b829ff7803a88f78145041393cf880a8eab7f1a2483029c9970b6769432cd67e49c8de726f29a59432c914b209a209390a92c619abd57d9d73fef41a5ed6833a748b8892e6b12616c755bb796dd5b4d7780d84a69a1ae8fcacd38a899537c0f38a0832af6d1b782a5f7aaba4d768a95649cfb4923665ad96a564d66d87aff1a9d5dc0df6c87c52ea64a8091226353bfcf49acb4def6659991634cb90f9f7d401e17258eeb2baa40607af503f45a2746a178707f6f4d229d63cd3a5dbe689b2c7bc35af8fe8605977737e653fde679645abbb242ec7f47ab955d42d79eb06bd07a20e85d4dcb939dfac5b26b7aeb75bae66e602d1cd5ea1fec993b9e5965b4e4db72fa53ea173ea16bd445a3569684c3434cee4ecdd5c7597d3bba34d3426677d7af5193a8aac50fbac5ed2b85525cfb41a8d69564478f9face2746a3cd5bdf57df84de26f484faeb05ba9cba45311aad5e1ac79fd158cc5b4dbe498b36e8e44063331a8f79abcd3769f2318d61d811b36de0af0d546c46e3a4b75a7c53a66dce617efacc8460efdcdd3af05e79da2d8f5910eaee5e97b68abdc0d7a5ad037ffde5441c102e077f759af1a84afeaa4faf03c2dd98b2e460a000b273ab80506f16a5070cfdb4eff0fc03effe90809ff6be48da790e349e0a507b06fa6a80c6a7dc0bec5c6217600bbffd508c94236b941dc6f782a41f7a89b623d6bf16be051ff4f418011dbacb84381e9e79d8482f4a427f2cbf9cb2b6217926fab1fcd27cf0f9a1ee89919d9f3707f811c9cb3b843a3f0df6c792d28decbcbc41a68f378ae5db103ba2b734ee263d4824813fd09f4603bfe74676fedd20d347812a7828782978c2ec6e20c129607e8f85d887feb41ce0c3cb8fdd938a13846d7f0e028b3dca6f00ecad05b93fe2865ce3d8e1d733a54d042c974e03f5493d5e1a2ceb5a1aa4d37b44de064439a9449fd75fce9b2ea3fb7bfda8d4eaa247404297d15fdf6de80815e848ae9fc83fd63651b9be1b45b60cfc51ae1f2acf77f42b72fd73783da4dfd035a9f70a7b05392c03eead0be4dce22d5408f391cb7c75beaabbbd49868e9179ccda2c201008e6b21ed3aba5610e3320d49dbbcc3a6eebeb58c76dfd6e137243d23516ee46c1422a5879e98f62446c8063908610795420fac8c58b8df4e76308110bf8cca0a37be24ff49d2918f1442ebf31171ffcc65ee251b43fbaa53f996a1e23ec421288048268b4bbcf5906c7dbf30ebcf4233bec8084ce30f4d8baf46ed2f9019177733bb857d70d445e20cedb5137d0a5c6bc65cc95975a7cdb3c2c67b89babc2cb2fd8063b6765d806bb24621b8f87a75614537655e9437f69994f6de86bad973f9be99667521efad5e4a15b10a78ae52d5d8c79e95bba00f3d0b331491e7a855eeb9093da16fd599616abc3627d6faa0e6403847a744a69908b5a25ead3ab7539bf755d19a65b6e613e35f7165074ebba8440bf2ed0cc8440b73007920eb16bb925b50dbe7493f6da0766177e8a4cee03b30bd2ddcf8e8769d70d3af2d0a4f14fad9849e39f4be37f40ac0b9439f4cc39f3adfacb80c01fd5e5dd32afd7a63af5e89dfdc8ae4dbd40a6cbcbe9a44033c89b9372f6a3baf45ab50d731bcbd9c6ba32c4c7bccacb374cc8ab77937e39a655f797730f9d3f622e47f3f03b30f8e840e286aec63ed0afc7ebbfbc88caf36a696cd49990eb6196c648d90c8f7ffa478fe0a9901d4e62c08ea7a66666174b1b92253e763cf5b1a3c70d1f84e4b11dbd80a1143c9561e8c907d9f0d46bbbe6526943f2e4a533db9898cca43b9f14bba895fde80dc94b41cb4bb79aff80feeee356c9d7991018f41ee86a00f542a897d7b90d900db414a450e521bd40cc944d2546490b9aa7767bbf20d3e17552de0c444a6f06bac8cb804ce8b5835c998737e8c847d7460c679808cbf04d9c618ca3c4421c3b6346b89568e1614f97da36dd06c874e7f356d6717ebd8bee9c06657f26a4de8b75da117d3bb34e370f1faf6de1e13d751b551c22acf35a19a78976abe5ab5b5bb6b8f2ee7eecda9a15850cce59497fbde5b5f6e54098d7ea99c37fcf99b7e6881a32eb983c7a6b2538837194eee6acef7856b301d257f7f47eeda5cd0ab9def21996101bd6796edd19ac53f21ded883eca8cef6868ba0fc8f2ea9be53cc35014d5d979ad965b3eb31f965767a012eb3c37b1ce237ac83a4fb0908887cffcc2bcb3921b094ac033eb5c2e24df644408fb929bb6f7989bb0ebc23cd38c5ca5d285651786ddcbb9e7b5ad92f77e2cf50ca2e210b1c50b7088d862ca3bae71ea1c8cc36961c401ba35264ce1bdc7cee9f0dc1a0e0f4fe83d7477db872ccb32ccab67599665cea9cc8b5a6badb5a6aa18cbb22cead32dcbb2529613e69c73ce39adcb42ebbec95c74d67078808c83477b3c82c538783c67172adf29d88dfe343d7fefbdf7deedc199a4da2d6379cb164e54527a43a9a9a9a131794d4d4d4d8d124c2653c933c7bcbac9643299bcd45a2fb76aadb55e20ebccce7d0fce586762da2d63a5b74fcf1c1535ead4e89c8af13ebe61ebc00473e406fef2bd030ed75f6edd0dc953df286fed451c177fdd1bae21d8ed1076f354e868abbabd7adf6dc73774367ade1285d5b3f7851b8d58e65450ea8fe8d1e39bbee34d2a2b8c5ebb1d883aa5d439079d3ae79c5378839c734e7b366ddaeea0899f4faf2ef3b163fa8f769052ea9cfdc0c1061b343a750782fea01b11c23e2801ef5807ba90fca0047cb30ef48743dbf014da80d1e1a5ceb9a111e9e6092acb19ec45af518621e77e2af5ea9ef3113aa74fa72ee8bdf3e94137d3ebd4b669cd798536ea39d82f028978f82d6892e16192e1a1cce740bfa53fc6a66fdd177a102dea81873792837ce739cccfc0d0bbbbe34d0d7a6f4133a9853ae8bdbc363f9c7b5a0e1d74e4e1f359a7f6fadbb7bb512047de5da0761978063de740eced4e7af9215d4a8b9dd9f2cbf9a4a1640e4e32d0c42ef7f5f21d1eee6e40d2eb352710e9f542963398439c21ecf38bba963b57eb65513a25db688f906db45bee0661afd946fbb680a128deb18df6050c45f1cc369affbd7fcfd27084b0cf7fd8cdc6dd20f7f30ee0759e5d3a51a3438fd15bf82d7a05a2b00f7116ee9ca5f424353fce4f0f8b7cc4e2a174e77094d823ec3fce4d39e59097f372a44be8d3dd23fe722054d23c2dfc128844c51101c788029628a0e0e115df735ffec9e91b929f45de0b923edeed489445869cbcbc8177b0e4e1978f3720a0c8e8e33d9202c58d2048e1767429ca117624a63265ca38f9b1a210b1100225983ce91a4f5ca08508e2c05f3e0ad18d20484124115064448978074bae1ef8cb8f7589f8cb0ff3962420bc90fb2844318cf0020f2c8188e887ef11762437a0000921f04086c8cd20c1082bf8a28888e82748cd37151c207c080d446aa84e367722eec6f3215e87bc778570e4ad7ab70876e63713d2739703966c7e3ca8b997334e97734b0f8838c038a0bff7a383cb117fe216dd46c2cbab66232dcd465a568515565aa75fd6b58973d2099f70514b8dd1fe80358e4305bba1e2352244dfa5665927bad366f846f4d6a23ff737c4e52e954a2961b73e6a1eea3c975fd42fadbbb40a095b2106eb51b7e66d3d7a77775bdfda4181a15d7bafac305c73e97dc438c434cf98179ed88d7eb430779ae550ebe1dc82d1bb07dc038f5e4ebcbeb51090f0b197f0d1d91d0c8d066d48aba2ed9ce8f6de0d76a147915e1ad68375501c873e621c5cbac771cef5c89697992f2bfcf5adc3cc76f3959875ae5f5a1fb58a4b91ad2eefad52ced85669da8d9272f7439aa7fdb9ee2f474fc43cea0889a247510b0052663c68786dd804052fd704d504c226b48b854e7754ef1c864393ce89ee9c4bf160a1d34b5a0e331e347c88cb7179f406300ecba33b80796eca375ac337fb3434cedc3339873a8ddf4b835a8d94d54fa1b655bf5c4e9c1a387daff3859665593707f7f06e40355e9ad386d2524e9af6c840a2366a55f41a5a67e99ca8a2eea3794c4e95584992bc1c08255eef49797408054a8153601568055e815860bcb0096c029dc02798bb26a73707f7ce6d8df5c6bc9ce8e37237813417727ffd7a63340d125ded919918d6e4e544671c2fecf41b6781c97c740a3dfa11944777458c43090b7ee3d15d93190ec8b9752048f4c8b42a0ae900af9bd2fa4ae744290fc3b73efae8304ad7c600e0ba38b42a5277df38c9c667380e3af4915286f198019db42a3ad5e093564587993ba271e18d6f9cc4c206a8eb10332128a72e9b6705c6c140504eddb2ee36e3959f05ed46c3b419da0a1ac328298fa1c1d04eda86d568345613726fba31b42a96322c7563854934ba0695550a523df8c020331e7da5cfcb14915da560b583150a5647ac8e4829511d5114da69cf55008929bf4202cab3119ed98996f7aefc8ce23bfad2cfe81919857946291f78f9cd21c577485dac43723c1cd2e696c038825c12f4f9653a21964324e85e835a0ef3c29724a9a8385f58eb9db01d970d216cc1ea082bb20938462882ba01f540cfa18c109ea895f188ef5d76405859f1c25a3b1d7c708a401d918f0f8e17179f770f4143044a94715205172b721094a50a2db030f104134b5845a88187095d7430f24024df8b4830b24e4311247598f75e3be7da790901b4a8841a43f85ec3d71d467a8c72e66dab20845242c9ccccccccccccccccccf08a07a564aa7a524ae9de8bf0bd075f54c243961e6a0f7ee8ce02ad92d2659247b4e8b41062cccccccccccccc1ca950f9058b318f9c453f35238e6a6fc9578719f9b0848d7c18f39c3da31fc63cf398f0e6ad8b0eca2a6acf37d383bfa5c6ac03658410bae8605c52c305c6d59ba9a155f5c2b07a599062768a0721a4bec113ca798cdd764208f9bdf798e30fa28510f235d3cc0c5ff79351ca27dfcdcc1184b4551036942fc2f71e7c554428b1b7ad7aefc5a8f18befbdd7ce39e71c74af9d73ceb9e75a0b8965d1e30c91565dbe4158e1a979a2d37414d9e8d479b868695462d87baf637c0f3eec1b42975860ec41e94d69c6b62ac6e8e68c93bee8a2431e4e3ae81874e79c832ec228850990be9aa0c36fe866acaa316c6582a45609f5c39aa7e16d3e4198b61075b5b0bc72a2e46b636e750232ae2f8459604e850dc146e9953a075dca6bf323877e30f1e9c0a7bb71ba6c495973ba7374c82979d3917cbb19ddba9745c479a76c44e8527315102cb5dd730407222222a21f1ffcc701e15e700e8f5ca7dda00dc9e300c172ab1ace0ba3104c5e7b5e0d9134022cb4c26ce81d0f17a4c64ba52b9bcc25f26e974f9ae92577494a307c5e3417c8798defe8194027af713963b262bc3ea243a974ffda9c25c34b25cb6976bca0f740d263f88e9651f218ce5910e93164d0f84573ad19b73da8934f942cb935637d8371619c5c4e1957c9635c1834d7ada9d1b699935789e1f86062385658a0198fee74675cd53cd3f257badb90dbd88161c6ad76f9d46ccddd68ee8ccfd03cd775cf32956c0d36d0607d4673f65aee3493ef782669594cde89e0794582228a01b13c4289e3037e28dd929be170b19bcf56921e71acb0ce47c7f3187cccb0b9dfa475b7a1d510481ce69f4ff3f06a882e8e33ebba24ee0674103ab8510c5ad033308444e5dd841ade24186da2628824efcfab2558be7a349564d4a494323acc78382058be273d0aa9ffa2cc7849abd8f46aaa92ccaff0bc6a82f4f561f10974f29a3493788924b917a6c43db4fcb14f2193676edd56f2e84fd35164adbb093de9f35ed6849f5d20eb66d2727937f6125f666e5da0e7f1b3db42e23f69c56add0d7b295dceb894d9867a4ce39fd168dcd2a6e44c060bd3dcd368b0366659cf34ec2db71aec1ccbabc616e63b9a5ba5d1ce717e69f6e669d701e16e3c7fd08390bca1ac332d9a1cbd009e574da07c57bf2e871083188661d7a509f543e91062d0b1cb29793edd5d20eaeb233a984cdfc4954c187679e63cbb5ca81f0b7a6fda903c10e6d566d9bd9bdb7a66c6617ec9084bbe395bb3ec5ede5eafcb74deed4d2d87608418c8514a23be1881c588295f80e7551163e47d434788b8242cb5cd053d19867e3a74cf497fefee68669764c90b7a9973ccb24c43e52013e915eace3c3a90bc9b7bf6ca5266b909bb42efebdd862e8b5e7ac2b29e2528024c11465f4d31c276a11dde1551e55b785e1591e4c7fc0bcf2b26597e737783939d8823e27cf23f6d734ddce6d837772f8fe9d2dbe45b753a7d46e3ce998e3937cfe525b71a774e74d3a5575ea157afd0dd86805e3beb52e80de4e4bdd82d757c4175eaadf2f11d9553ac8779e6dd7e50cf84509fd12d874ceaac1a6cf2ef024d87fe6a747f3d7db4d3d31ff54d285eeaaf077520eb6ed487b4ef5c972dabe95ca25d66a4296a06b5408c368fc54b50d08974d2abc3e679523a945a5e8398e696e0d0eea8df7b8fb1f7a4532a1f46a1112e87c9a5b4efc9f79ef5f79e7cef3d4bfdc9f7dedde47befb9e93d696ddbc0776ccd4d5952f2184b5eed7b97fa0e3f5d6af36eb007e6d29f93320405c9921dfac1c7de7522dd3979e7ae9d735fba67c739e92e4e0f6c8ca8888aaf8fe800e5b7e742fde3b91ccefb4227bf3d5ae7f5475da861937f0e297d40ed32cc4e7f794a1fa51645a3536f77d74de57326ee86748e977d916dc7eecc54ca6aadd574814a59ad1588e55856a55f1aadb57a9387ef9cbf94615634322a659835a39151fca9bd2a569e7000cb952a52b60dbce5f208c9288bd106565d8eb4d88043f492c3973e4347918e22dfdc93f72413827d7d503a477a24e21ce9b1dead03efee4d79e9a65bca6292978e41239c10845f2d6fdf84e023bdac17c8f2e9b49dbabb36a1f8d6b52c874ba0112e07f370b08945a78c986ba188308ffd24624504949f6ea298b3a0cbbbfd802e5d4a27227d5e4d62ded461d6630ac11efa84547abb503bc4a25fb055d7dd849e15a703d11ba77440b81b0f0a21c6fccef34a082d8fe5e1af964cf96a0a4fe38c07f33bbe30ca7b32700e46b18fbb3451d9b50658d704a8384b74df9b1ca90f1cad5c8084a5890f4a4086064f680211c470982568e1650924f822064d8c5039b5edb4e038dc434f74002ac71963374fa96c348f7717c186141079a0082274c1042966a088224c103f28d3040ab6c070a460a1ed61f8c3cef6097d3a81b1db7cf8de7b8c038bd975cebe384ab09bff9c271bcd93529d5037524a39bb87c6f94284d89791ec7642dd40081f7407b5b09b7d68218c310792074e167643bd4435cf86ddb87415664fcda3e9289ad3b9e96417faa8f3937e81a24c8f826a15a594ba370fa5aea218754b2dcbda691e746c9c3076f38fde364ae9baf0f202785eb5a0ca115af0848a988782652bc65841404db234de7b4d60c2046a7c49888ec276a81d05bbbd6fa04ac53953f9f236cf2b2a5a9e338a7385652bbaa8f21b7de651b1c0a93df89dc3718275ce2ed8b7040c0295539ce120c1c21dcd989029493ef5bc62420a32b66ff1dafcb851a247a157f6c0d9c25a31c6ca6fd062a99c0282e515952bbf512a558260793565cc630f9338f503cbab29589ea75879c8ad7a7c1bcbe1858d0e61ab9ef3235252685650e5ab293e1d7e3bf2cee4f569a6bb09bd7b97af4b72643797e40a92162e18638c31b6d17eefbdf7321eefd43c345e934587d7b382f7c99d95e64125b16146b6c2e5cec94c5e1ff6321e347e3a798dd65a6b7de32e26530c194333324e1ee3e4eee43b1e8c1391d7e3c339ed9c6533bea36be8f3cdc7c42387179686b399db83b6aaadc9d13893bb5269a654b225e79c59dfd1d5e44f736eb2efb9e9594a9cd32c3795dc5ace198faa6dcec9946fda3f4938a755dff06e3bdf4c8869195de2024edfd197c600f7ecbe888a8e220bfd72e72fe3e1e0a55794198f7a6d7af0571b2cad5ede54284e6dc793f1be2a75abdf902f946148869411ed64092564c2785931cd94959455142c0f9d73ce39ac5590a6b4d8e7ad0386d38d5779e8a9b6b1b37ab804d20674800d842f26f64e99c07635a54c6099755443524ad8f7d8a18d56714a090b635fc6c0a44af0fcf2d62e9f8e723047cadd705e7da64c60b1cb0497b7ed7a364f4d95c0ce39e764ea72f870371c8aa67e06d6713ec47db81ccc372c77288bddad7f4b5961dbdb882b92fae8986603c47e74fbf152687271c59a23c20c9939328c107237844d24c608d921335ce23621089b40232013b8041a019bc02646548db99d219c70be43f2119620ccb34b666e66cdf1531889a8519c7c7558b5425c9999905296398d53ca63f2884598f5887e11e1d1efc6e78c492b39cf34ac6a40b81bcf29118717136bdd6d083a47df84ba7e7b21e280b04e9a801de70776a31f79627486ceb91158e8f1c68981cc8eb17bdca0e3819cb7ef3c21dcc3573dde54e7b477d3c609024afac44e945a945ada901115bd42e6a42eb517e572ce22e080702f3cbf6e12ffb9a25c76c3300c0641bf9a906c4e32b8c7874a1f1a2777385c381fd27e6a9e2f549280004c115db8f8691865aea88208a0c8228b23fcb412be1d75b373e3c396117401c60a21cafc0cf530a5084f68220957a2f4f06365b1ea6e2574f07dba49ad94c8f29b0da7849527c0f34a89a2afa65a31a6520a11fa18ddb3b4e0cb56c5b7c5bb09fdc65e04b3c0b36f434d24e5ab29b5c4ba77ce4dbe76f66305e5cad76c1918dae8a31c35c365780c87cdb382c7f0193a8a2c10e6d6311abf3493730b25c95b5f614c12603ec9bf551244ff24c6d98fcc4d346e729909b18e617f5d1b9afba3743137f955f24cdb669c7d0133bc620c703f63c3bc747514419905a171eb98b6093de6320b72f5b5b11132e325eba6bbd9d4fb63c6649d5fe84d3ee3b2e431f3e17e865b6db34e737514597b8b605f729390195eba4033bc5ea015dc9a66dc6b0520cead77f663850b5b85ba1eddde2d86c356c5300581e127e72c080c3ff986e44f2677729705d930b7367cc96516e4bd775990cde4d8dd76f8934797990cfd27bf82981cc3e14b778b2ef4feb4c1565d6eaab9dbd09f6e8dd7f8a5d5dccdfd65edddaca6a328ba75aa09b9bf7a504bc33cb5c4dac850dd72ebee4d17a83a6672e7a6bb5d5f3d03b250c4bc8de715142d5f5d16a4ba65bd5aade4dc5a25d1e52daf1a8d6f426fe3333e53721b8d3bc79aac97b4cc4d5a0eee691c663ffa69dc0271343495462bd1dccd9936ecad63fdb6dfdecd99b419c7b40d7bcc5ff6c3e43316f359726bba58ab4a17a8fa86dd22d8d76b39bbfda96d28a1e722d8c37854635b9268f4eca05f286019e1a0523728af818621439c0e4c7708aa0854e8610a1888f96106586a0c618595325894a0082fb0b072026b8505f7c65128394515b8f080105cb4e0f2849f7985073ff080910baa90f433bff4a085188cc1a181c8d135e4f55c17359d4e2b580c8c666e76fc4643a58e880c89f1bc520197249a84ab79d7b3c3ef68e81ce75106867a55befcccf3ca0549cf85ddd868861876f8984eb582d2f418a6e6634e6cce39573120c1cfe9fec44f4f4d894304993a3d54e7381c29581f3bb0d3cd0a092c2a48c1e33caf9020f35b2a09ae61679175bc7c09234605d5310e88237a269d111ed259c75bd537acd3346ec415965596d56ac5e53d511f061907d63d45d4e7e49f1b76a15dc3f97616d80032a070a660371dd05bd537acd31e3516f846b7cb0981dd747ca35c976fdfba4b901c70e11cf642bf84e11cee2218848f8e16b8c73db9f1ec2cbc1cec6e58e0f568dd8342adc039ea65b976a2b9419d684a259f71f7d9d474e32894d39e4e0bede94e4bf340d3f553179568cf19cdb9c6b9a606d678cc78d078ad3164c6c3fa65ba1b7c93c3f0d38d6f3e0f99731eaec03d1678399071c470e89171d83874e972cc70e85073e828c621c3e1dd8ae8f827040b2df04a54facddd68bc8d5683759ecfd002e06e3c5f01a569dacef5619de731b414eb3c4ffd708471b4966384dd188c3b0d2fd19e45ad32f90cbf6b41b660e11cfe9246430bb2250be7f0530d005a902d2bcee16f8d052dc8162e9cc32f35181242281d4aaf14a3d60deb3cac792494a71acd51ad7a0e516456452b252b26379adb8bf2c13e8798d3823d2d5bbc6cf91286c788e9c6aecd341b2010ded3ec8c87c94bccaa924b0db2aae4a61b647220ef4d178712b4a1552f07627240664bd1162550c61ab1387f36a4ccaac98fd18b431b29f21c037ce3f9cb647032e5c4da78e8ce99700e3ba150ec14cee10fb245c53cd2a10d57e5abc6579eb5ef796b8e6f58e0f59850d3df7c327e321897fda4d746ab9e8a759e0bd11fc03fcfe11bcf19de54ab28706dc809c1864ab924303460cc980dfb1764e58473180a9dc21b83f9202b2b9cc3bf7551ab8e66348d3295539bd3c1e5e09e2122a2e75d74ddc7a3d45a94bb4ab55a62ca6f0ea68cb01bf6904ae9435fb5672fcd927e69434fa5ef781355844d2d61379ff7799683555466185ca7c6330b39d89fbebd0b73d32f0d6a34e31bfdee9e580706e74087a1059d1a0f59f8e894d2d868c8d025976cb90f920d305efa86d29e7a85ecba64ba27d691ee33cd32c69421aba46a2bf2cf623fa7bba023ffa2d48cecb04e7ce1a3bbc037a2f7b5f144619873a0335274b90f3b3f6dd985e89636c306601736191f7d6acc2f6c303e063951580b3c309a4f0d28acd5728544670b6c3b8c7ef9e8e89fd7a0c25abed925429d23fd9270ba22285f9cd6d1d39bc30472248b189480e8ad0b243d3aec097149ab0615cb639e46e1d4516439cb6f2e498d266cf4cdf2eb61df28d02aebba1b8ff98e8eb38ce00729c67ce4a663dee51e1174c21725f6ce6d5062d24bd233cc24a797b4cda21ebb46e02c823dbd90bd7db0448ada250ebf9a22f5a9c989c256bf6ab49c2868b4196f8c72db54662acd40ea56db509b6adbf9ec1a81bfd18d3a854c69dc6bc1e5d0a20e420821bcdc6d3e0f1d73a86177f37998da7c50ea6a4c61abb76f3e58e6fd207c2f07da889b0febba45527fe40a149220e5e30d3e10a9e6101f280165ca94f9e725c72cb6a36bc5e1ab6f3b0f5b95d1566537fa97a2c31e3662a35a37f720679a358eb0f654c4e74b37d56a51abd8e5cba94f6dbb5c3abd50deebb00613764b451b963795cec5223e40903881083238fa087f6af60606f3f102612d44650855ad82133296611926e5f45a775a0555ad822c678ca98f2e9d22f918e43e42df69081dc7528a75a043be998b49f874c21527c2f0a6ff7fe890e679f2ed1405e6dde0802e63c96f2acdc8732339d0670ff2cfa13e1b3dd103e0673c4ac6c780f1d5c2a076fa7a6115831a8d0b3b98c5a0667d9dc16830a8c5af3518d4e0fb0a038b71aa81114346e91a11ea1bec6cf4fcbea85c7340e4bc5c30b37985832b2ff4fef15c23f8f6130e9488e0371bed4f6bd661afcf4a825912a2898b9c3a9856165a9281952d71994c50b310600f884c4b0fa531a64b0b0b99303323041af8831a0c07a72b0a185762acaa78810c7944ad6184b50c6b2c81cc965b0e371b0f06ab23c539ce2d6b5ace9ab7ca59b7e985ed5e10573c2c4c53ac6ef0f9cde781a23ff7d11103d3a7840a7cc1098656f9ecbc472ff6de73d414ff9efbab3feff17b285641fd766a694c01c4d33cafb28cc11e725183881a43e088c005515c5005232e530c0561841144b99282252481c515c41391c410aa3031021fc8e014010a3460c2449513007101d1969c734e578514cbea9b6586184e37a9217eb381f4448d205a20832fa024e9000446fca0004bca9c00882a57701103022ac25051e667cecf9c73ce3959e84288274c10c940092f7ea6134e7021850982c0c507c45c49a8309aa1a2073653a830c10c152c80319d5e3f4c21c644850764d4785e49e18487f1bc92a20b941dd2e806e5dd3da560561e0d44babb67b0c2d190ee2c5f6ab274e168207234e4284b0f5659bc1cd150c31022400882942856524849d241a4d4b243e9b05dfa7320e9d2a5bf4d7a94f099798cf4eb7f398cb87e9701e132651887507f03490074420d25ee8595108410787165d505a98a1f5601099e78820bb0389164cbe5430d2096c8d2e40649d40862688924286c39e28a0f4714fd3496275694880215251c25e1fa400d216a00b102162992e002085e98dca0014ec0208a24b808538429ae2229a048a184144ebe6c9112938a82f5c5e501279dca324b54d7909e50371252a94129a5348ae2a59477c3604ba937289753ce29451096144ca89cd3371d73da008b920db6a8c2e68ac754acbef4f024892258a085bde8a28a10fc6024c5053de8c10642d8000ace743a2f1e7e1a65f1b3e6a7d1147ea27e660cd2371d3a62984e2f22a329b8fca4f99953eef84d0c291b34a05c150510bfed585d92e66fa74851a79b39e7183b9f575178a00ad2b98f56cd207de32c31b4cacdd03c72ce39859f734a1baf9d6fd602369c6e52329e57505c01c5ea371b49ce05503c01051dc4fb100a508042d2108764c33ca281e41ce53c55c616497dfbb46a0a163eafa008e2bba1f881de197c3cc1f26f9cc5c64e846c34031205a0f0a185203ce10737b082065168f9699b20a0fc60650a3f78c20a7ebacce926258595cf2b2888929c1829898204ee436ab94179ea0b4bc406ead6174ee093d38e56c5a043470c0d002b464f7cf74ff7bc312459fe4d878e189a873f5505bb31971a88d840c30a0a2750ae423dafa048e26b9e57502cf90df51b4ac6400760c0a456608b784d4a453c48a368a68867921291508f7628807b606896306cb90286e71042f8b8b8b678d0a9cb0198bac5db61df500cc85041063c50c952832f580741c8bec013cacebb033e2d569004299c783102296cf00369bc006383275560811750fcc02afc13589ec84116838fe9d0e7b54fd8e0091930132cff661d910d9513607e53d1238c2216314e7c914a82dd3097faad48ea1fe6d32a1a58d0b71de9d0e5c566d04b884e487182074e48f15bead98888ba49df60fb26a554bd1c08a1c718512fa7db5218d66925cebe4c2ad504984aa5c2a45247c03a06f6d981a155ae065ec048288475d061809a0f8c1242e82827907808ddc643b2fc1bf63baf275ea6d009250f1fba330e4ebd1412d8e8710da2f0f279558330bfa59030e5057e7842450950c25c71e4420f8ec0620917267e40a20b1828218381189c2ea67704832dd9cb9e57342082fc02838151858115ab092f349042031264617a5ed12049763384bd699eed4695524acbdda0f996d51102f1152d6fd2bca43d20995bde2373cb87de69d03a6770e8a1e64c26e9250dc334a68e3a8417bcae695996766910c209af695d1a744b9b6c29f30071ab7cae6a8a04363a5fce55a37f69d85b9afd295f2186f530e656fbb5f981da6238ca877e75e5cac3f0bc9ac193af129341e8b5f901c3a7cfbbc970183e7475c663c6ab7bda46ff49ede49c4d79ba2e2fc140c9d06268dbd063cf69b468f558cb6b2042a3bdf73a5a051d8656edc06e276872e89e9a3969dbd09f80386fefe1a836ad86e19ccda70dfdd484fa61cc389d714bdb74f819dff14e4e8995aab5ba73d34d299db3692fe9973b4dfa45e4e95b4a83e6dbabfad49c5f9a7d15d34a1ab5b079e68540e8e5aa41ecb979a6737737f6a14f31b19853db2a07c3614a2aa736c9fe4211b6dd3ddf52ff9e1726dd33fd7913354f51276925af79ae2826931bfdf32a6584d23cd37bf8c70d3e8c17a39c833faf82450b17a430714cd1122752ac18adbac82fd5a41551c1e2ab8c5385e831af41a4c3bbdd8fa7ccda67647a0fd70f331ea5cb7c63ab0e6487c7fc39c6f3c2ea59a6f14320f149ab6e6e84825ac18f08e5c627779bc1122783a41a3198fdb884b4531ed6a55a841297609de7553a762c6309c629addae121bc510aeb3c67c26ed1c93f8f4ee293e681d23c2c93280c64a0840c993b86574d84f90d6bc2cb6f94620edb2921a992bc04a684f4eeb91252694c29494b09ccaa84745a69b161ba27321403c9c4a2e7a884c9b3c72a3650296b227a391645b995a4fa2d1299889a98969892b8db4c44ff0209acbcaecbbbd0a889557dee04767347291ebc58a589bda66cb10a94e691776bee1d1448c238babb0996462a92b27a494cbc308efeebc98f9cbfb4c4d02a9fee8955b694951489dc8dd76268555b49afc7472472399e6fb46fd793eb499589425936b29214c03a3b58c70abb591417bbea9e2cf5bcddccd0383fcdbd9e744efb0ca5d65a130a5572f7d7036f7c4ed8bb7b6a95eb25bc7ce517ac94d1dd6fd4be3084dde013f89a5d2c3da97d8aa2726acb929cc0887961275e60f348f822fc697f464ff5e07d46adcae283a65f280d97f1f8d1e7ccaac7ec9e43974554ee951629508a881ed2f382e54a13262da6938e5653a42429725f1c921116274d7410a261c88e0dd661a7ef8e5653a4c024b0e80b921196e7e435192386cb519529ada49380f992c5c83d714e8ee8408406d661878175d88f321cd47a64193a2133a60b172b55de92a7240c182d59a0f4932622e3a5cb152b6e4952111fa9d491751746276aa6a9a8a4cd35a53d2b19a2190100007314000028100c07c442b1583c22ab92a61e14000b9bb2445e4c1688931cc76110420619a30c0000010101809999691302697769172d7589a8e97e3de69ccbaecd09054bc7728b7050798063f37084e100443346dcced6c27946d07b993571209e7fcd9e93890cc808e2d2d1a5972ce6b4699f0f507fb275376db43c07df112baecef5e5fd28e640d253ea998bfe6126c6966b7cdc1fcca80163a61dcd237c716fa1214c65cfb708403cad54aeb565094a4a5994e61d681651ae8ea8a41ab9cd5f47a2a07cf7239f364fcb1e6a4d866796dc010205974d2e49a4df970edebebde92800059a334875159eeadccb811eef5b0a03a4fb16dfd2acc2896be9c34078f5e72a836be14937320890622eb4b96ca4a89e80b556cd219b9c105b41892bb16a7cd5d4d7153ee20f3eca87fae8e1bd3a92ed35e22be59a6f3e82f04ba75fcfe915657ab92707b287e31a2e5a658c5057074e0d10d5eae824b9f7b486a30d7b4ed6c84b1921644a499defdf00fbf0d5e3abe930f4343f8c476ada2648eac23a69f55f651c2695d3d62f0440bb30638f41575d79422f2e0952aba3174326be84cde8f65438d65d5594571d2834ffd8ec047bd0ba6117381a74259bb2528b12ccd06d4d1f7d9bf727a726474952792f7379837317a31c82075bb5cf2a6c8e52a705653b5a87c0749a5c200c5e0c58f54ee1da1b04c2a0df892d61d11eebf35951ff113ad3336e6b6d39bb813b7cffe5590a3340f9f72065b9214523323e3bf1dfa7283a536bb4ea7599c5666766b72e5de4c52cc8ea85e4cad01c8724d93e2cd0a260e4b56131b3c498c150272f6cf18ef63c29455a388678d2d6276063965a058b4fceb1e4a8a520dc4b885b18f46f33622afee7b67b12d3595220d5969f95a9376420139e786a03e2da31c57e1147b8f7c0c4f451ae8ca0d1992f738fa201a2c522454194d414c64f3447183104dbe7484f24d1c5f4dee85215ec6f61a8521c9052f4cc32f36b2b3a61bd69c805060528c17d932aff495ca86d16f8e4d997e04f3caea98c4c18a20c5f08007f39d67b9c78a3ccfea92cafecbb14756d7e1582e90c6ebe96fe527b10bec861a664a262511bf4cb22d5714afe07354a15ef1dcd0704852bb04a732839fa96178b2802f508c862b920088946b36a1b3441be9ae2e01b54312a355c009878fdb22bb2b3c8ec82523e592ee933594f9ebd7705e09ef7ed72819c9ac1e530a552c885322206d522a474759c85c23a2d4a3de15c644d7f3ae980388a4f9876c780e96c37b1cd1129d48b33962f18aaca334104a02a7fd97a752727aeda77cd2892190c088ebc2d17d978841bb61024a1aa2bb26cf0a0b62df7e34fbb60974513ccf30f25ef4353650879ed4ace0a821ff64e3f47df7166405298364f287072913ead213cad1cd232fabbebb4004ea0fb12dfa07d83f7675b04f47ccbdca0d160140ac19d7cdeabdb0f2e7ac12c70525fa39250c88add2c53502afb8f87f1293058de3eca888bc7eb1700b412d2bdc7dd1908ac7c6e99e7d06da042f167744150f2469c76946ea678f7730d2503c7446f7b622779f55ea803ebc871f1d8c1818e316473fe420c7137fd1ab4d888b0bd99a11f98bdf0ec3af28e97ec053f7ce12af745bdafa008cf20baea503d076b1791a2a2ba9651a72290fb29d5a6249bee6e0d813b3277c809013d0dfa341ef363dc67f5201cd125982aa8220cc136c03cd5f5ba795d2d70ee1daff5a0ccfb8b6314fd06969478d82e3f0a29ce3a0c12b93bc3949b769c5fc8fde028431f23ac758b088efd4eb6a08116b014fa71d726fc3a3b9bb889dc6b65116ef19ba51d221e16ae9c7ce9eb5308a574e465b8768cfeefa45800c2d6196bfffee1831ec0722441bd5318767a983eb896575b85576bda5edd8daf2c277a9d5a56a6edbc1e10d119105fcd4a2815b638c3b0fbecdee57bca59a4834c200c82b9889eee20f804bbd9fd2574837ee6c9981a77e7ed2cffcbe4453fd0e6a8b9f3caf803a430ab1d7eec10b30bce2bcb569ff05d0e1d5463adcb9fda7ef772c9dfa179bd8ddbcf19bf43e0b5b6b39f43fe0a4bab6dfcc694180a93a4000a64ff9bf18b2c692490fd6f6a975970203d97e926c4b6420374ec2f4b3482bf8da75ff37c7fe94afcb4c32d5bfb6f3d48584360e8f8f081fe70e710699ec956b0570ad72d464e3107c1287aa7243ecc320746749cd3add14e763dea0a25a9629287be0f52ca99c3f1dc441152e5886b6cd84e0aad430f786961da51ca3d5437f011fbd83851adff2a994ab8550ce182705241f50597673da8cc0b785701b43ac9ff1502d4aab206dd9e63b46ab3d574e8092b23e78bc7add1903d5681d15682bef80fbe7c3d4e6cd6684b40e5448b522550587262959f12a3a482a643733a0d2c13c0d5f8f1e3448801b84acd02dd810cde735d7028c533eee52cf12eb9b223e1062df76df936e1883d48b40cf7f2ba57151d664db7a7a7c04c769018ef6dde59351f508f6465814ccd71827a9ac9e9053ed99742b548d6676d5204f92481c7e4506e491b4c4c67c3e20bc1563e1cec22b94de902bbac3f05b1b1d8913d7223638979d8d39a48169da107df07e32f76d90ffcd330eb4e12a18f735719657562791479f5d20687779dc241330a95aabb51cb9a722db927ca06822bb96e86681ee2bc279a74f1c26ce5de6ab5c537c3d0fb877a539fa3cf2858ac9a253766b06d832bd42609242df043bab1c7bdf30bdbd259f6008e39116b121af34b331d863d756b0c07dd5f45ea4fedd5a4a4ef301b95d703f47ca47ed758c375844f2a16caff2cdbca88ce903d0568b8682e8d3dc6a096845e22dc3f83367be3bb6bca1c22607774fcac0e919e8e1e725201f5fa167861ae7431e8ed8abe7b70eee803257bc1bddcec9978c2296c2005e714a548c4903de27e12f5cb9e1033dce7b0382221d88f00230219eb6fa14a4bdc32bce6d3887069bcf164ee4094517b9d95102b5f854ebb580c24f304665c921102069c553854f017cc6a524133b5f6bea3860dc8a8b85fb0a2d52479c2f467ff5bda8864ddc3e8958994208d079c53be377606f3fb914abd00816e4190d1e62418a50e1c23c6ffa2318e9ebd95abdacd5d02ce68ad53cc7f173f43e05d4499c02bb2a0d672ab4267acf82dbb55f08c2828851825813348b27a2d9f3ead685ba5baf157c5eb33c41bb07a021b3549516b8ba91c0e3c2d6c2706c67118df7678694883e64becf2f9ec55a809ef19ca91014f0450a4b17254296c949d3b288f7f90988002dae49967060c2ace4547167780b6f9db02c05954df629136e8454b2561e6899872c799d0a263592ca5ac39f4b35eff185280dd504ca5801d50162abcb68f04a5bdf46cb84cf2b4bb42c176c52b2f21fda2e9748d0043bf4714ec227e88c217182c0cd59357b2b75712b0a1de17b6a22f54de24df2fef1d4ddfc7ad45e6447f4f8d18be7c9359dd8ddd73779c085d5a7a99e5fe4fa99c08d032c6364a28c47e05d08a8b0d0fe865ce0188fe22c6f16695e14500a3151e87b3fe57662e29282ff4d32593ba6e685ee2cf24c9d87251c4277642f71801db17cd31f040399382a6cbbd465a22f6d64dd17ce9fc5d949e85c274b3aaf62012ad29472f08e4ee9dd2d258584dbcfeb1d8aedccc5c42c0127bf0d99908c5431d944498163722dd6d0911a32015d10d718fba0318c4e2670085f45901dfa48a6e27bf6099a00b1cf040432122be7925e6f8c1a9b16fda5177674a5eb9031c2379a813874aa7e38924ba1b330eed943dbe860e76748159447ee5d1a69a5af7532f7d506ca24b22d2cde960118a809f29ea528ab1bc6ff54b9b2d897fd066a983d13240588d378dd2ac87775b8c63e631c3916fdeaca2b71a66a7b7ed60f9c53a4412dfd0a75a2d49886c9c8d166889b62f36b9e4780251fca40116fc9d3a3318a9de41450f60dea30368748e6d6989bc63b267498b937ea501b81485556d3b9396f10383eef3c0dd7d9d3296f2e68f0db5b508e313752704fe352f2195198f1ab166dbfa99f9c132ccb803619687a46494b1ee2039512a267a3f2bc20b5ebee613bab24cce93189cb0e89358fe7da487a678e0363adf8efb2f5279da90b9ffab23bf9ff15e303aad65c54ea19ebd7f943e38c49b97d20fc7f76e423d0e680b865add3143408971a2a58f4343b37e2a019e1000dac8f77788b6863896cc3a329960c3537205ffe3928ddc7419d490947ef9a299e391c4083219cb006bd7207b61ee17c2034729bc831ca4c48f08fd881d2ca46446e44cf984b4d65e7e76816a625c125dc29d87c43cb815adaaaad93029dfa773478839fd5fe88c21d2f3e0d0cd0d8a014be46ec0468f1e27515f33449f4f6e2ed17b73b3896e15ddd7cdebb7f18386f0092fa132ca4fa1d7cc7c431c3981b72776f95da21294408f9a5b7e0ef3779ed2d1c97f584ecf7369df9fd55dad63aa27dfc33f21cd5b59a0c6417f9085c9a62c09dd9ccbb4b4f566fa322d099466f8e6ca6f1b0f679482be4a71a886b717337f22982f905ec4fba2f42908dbdecd2444877f469f08207052cae46232cb6b1da86f52d81a6a093f7199480b3a0795845e885925a9354bc855cb0dafd2072bf8c6ebd2c16b4751427b30a1bdc5e6de8d2676d486a13ae8c18c9e8e9dd4fca24e41103d9ac01f1115b340f8fa5026cc8950ab735c711030efcafc4fd742689c4f5f8131742921ce0f02e9082287dd3f6522fc18b6cd3234a42ae7e723620c9ab3b802b8887620ba94d25b734ebcce4de569d14ce4987351da4ce5f95d4c4c74646143480a9b6698c86e63f9bbd395b25bf2236cd0186c76d66f05165e42f09bf278bdecbe5f6e37e20961313f8bc5ffa7653535acfdf94a8e788930723e479709139b33cc4ab45309e8bdfa7947d954fe72c0021e55d0208c6dd425f4ac40fa2326fa1403466a12c2b8b9834414238ba26a12f29b94286692c48fb441ef98da83a20e4a6cb3854fe98318289ae11244984bb1eef1ad834bf0350259aa4099f014e8c94948702bc29b5d5e91c5c746e4b5432ba4838c6934d3a0e5a91336aad5f057a782adabb8220dd2ef53c21094cacbb16ac46610fc566eb7312a99c9a0002183fbeebbea0e57bc7c189499851fb05dc3c9a347916146ead1cd7aac3dbc4c94ef6550955088a02f73199378b5ec7a1e639d28a7cdb2de52303790d9fe1eda70c536a0d8c79a362bb4e93ba0871ec2ca06c53bad2e2c9dbff4833b856e546103f7f290daf45603dc0f44b6970122f1c0696b3a8170b0edc60d38b19797577522c4a2d9fac3267306486601c8057fc8bc610dc0988acbb222d6d47d185d8a5d3e2944982f9f2c58cbe18cac94e6364f087da0d88c0eac6a506cd86589b8e291d13f8514b6265fbcfd75d2df33d4810c80db3b7a0194cd3b08f1f8b7435377967d30c277cc073e4f30d5765006b3c5e6e4039bb401374893a6fcaeb21f8452b6a5cd041e4555d66fae8c24383a620c297afd3faa984dc3e8850ad7511c57a2b2ee0a8933e9e0fc5199f5c09d084d6adb6f7ca0653d6c1d69241a0ccebadd1f86dfc67ba411234988f55cd679ad26ebd1a6477059df8627e4047f71fd7ffbe430623654c6c8c2d3a1611c5f27c7306cfb82880558a730655b00aee8196829e5509bb4554555326723c299865387ffcce0eded275887a7f325b4b37e9212625fe95718a3d9d8d84183e5273b71eb3612fb8eda95a1d9feac262c1c0d83f01d6547b7c708cd287d31d11fa6338a16b1fac70727106d9cf8a5980c20188ecbe8d208fd6cb4590fd879b7c54ced3ca20a8a90b9974803394b82f0938698692e775059cd2d620a55d8aabd252bb1ab00f9e4cd6e012e5044c38c412b8f8b404d8978092433d4d7e08106144179916a317749f2cd87a0233b244b29ded9bcb6672bc5d9b4f91029da45861b805772dcb6cc6b76c560cbf1348c5d880fad088955383cd05b6cc4dd73c13f1c841ce38e39c10e35057834dfad1aaa61bc3646c30ee29caed0a74f871209c11fc8b1ab63e34bf8b7425be84052c3b7ed163aeecbae6f48f9be07e35c6354bdd58fd07e708158ab855f404076a28aef751717cfc5797c81d177a5da86a4ce601ce057b63fba800826728355dbc302d6e99ff77f64ca63f8a965486c823f7c1868beb9388393a6a58ed304e5b43b9c3232ac47683e42d9dadae31de7576c2be129b87b8609579c68782b491ab37409720b2833631d851f58ceea27afc3b7b93a2cf43906c3094c3b4b0d7ef19145136590cf3599cbe6a4ac3054843734cb03c819d33ab41e7a420e75778e10e46599ae5fe2b7dd04b912bd37a3e1d0c0a1c6f5942a77fb18c62afd0df76b038838f05ad2caec904caf3e19df22122d1f3bd7d514d898601d1c10f2e632e3745d8ae1d60a91231194f81089bcdfc752ab9909e20db9ec3b51a697ed113fb3cf705f7b2ff9e8d5d950602ef97229ca5aedcd394fc1d4b48f3330b346e368eaf6fade7c3ac1c98de94a20ae01f5cdaf03671c713e7bb7293d371bd47c76eb6b67208d48ab8a6c01381160921d0b707522b91dea6030dd0f1883ca1ca73bbfa10caf4ef54ed70c5aeb627fd817a98dd7cc092980aed3f01131ef37043a4ad4f03f90c37f97abbca8dba3862cd3dd0ea322b87ba1bf75846efb25e2b6eeb956ef3354c5067d3087fd8a829688ed772cdd4604283e1cbb62bae0e0ef6bc8f456c4a30447245a744936c5da21114ec14d3a37036742326a116aef3eb88facf6301a55e50ab0c7b054509527203cace928a672674fbc94391874c6cdbc408a7c2b66551c04b9aa4bf7d0781cfd929e602f0076c545ccc1073ac2a53187c62a544c09835ff085bcb4000c3a3669e5bf21c370b0b178f2a6c6faf6073c739a5aed32a79df610e71299581e654bb9861f955963974d52c44e2d7744edfd172d7aa0594bde5c6042277bfdaa958130ec7e6fb49312c32bc507221e6d139dc15a7702c252c0caaf4c18f6a6030d480e080164356d5663694fe795e012ca94d66f9f9695b914448694febb8416e8969e56ef7a5b53a9dda50904666941a64474a436913e42c7f0206091b0359a81a741ab7445bafd47957cf2b6759629b6b8f8c78d5428c2ae5a9e9f8895edc24bfba31f6c850b3d3aae012b6a7b6fcb49aa25a7278b07483d94222966f19c64a42730b8610d692e3d65fdb16f88d3fc7366380c5db80b73909e17cf5d9a2fa484d1d8f7c123e4631b5ed53be6c1ed88fc78a55fb3ab72a9979c1409dbb36bf4b48294c88c5ae4a31e095f46581a9513ffd1742a062ea6956179928cc7851ddb9a2d883c42270c3e06159a739ec01ae8d513a1baa253328ae2821e0866bea8e4f89e416a64f8164380762944faa38bef0ceb3e434d6d5720061281936086d9bfb7102820be5c27ba6cdc97812721d4dca3a913e52e3cd21642443b6a855042610891e0299abb6e3da2556205116a10d6170c4d7eefaa0ec22807cb8656df828f786948ff2e48e75de8a913089a4bfccfed75be7a0fce8369e50eb40d151f83ad080cbc40b65387467916d341b7fba0113c9bd21ec3e0b85fc56f78152f7e3daea79e19a7e81b4e8d2f0f4c1ba3265c41cbf8baa9331be111095ed50341966a4e45c23ba33008c03c8fe2815790c04fe3023247d81997be6c00b4078d6244850ab74f54f34f25a56e98d40c6b68a6ae5212312dc1613a30059bc19edd37549b1d8a0b03cf8654e63f509d465666e794c6809308ec723fd9357cee5db3540ca2ae387db71ac7beaac487fd4983f36a6139aae91bb1da6d6c4bc00a5f8a2e260e9827405c8addc0da90d6fc69ce13e277311d59aa8f676d99097e26029973de94e500e007bb19220533b3e3812e90d4b857f7d8162130468e37d63976724860a3b1039bfee830e1033e4421757302b141b333156e43118d57160b0030cb52f42c7bbaf15a1161c64c2ce87d928b88a9f814440e8d11886f70d45aadf5a27685984593d182624d6c968e2719f62502ed22fc33581cb92913176c0ef6bcc751a357fdeffa9401f173633388cf5a352888ad5257a3009baa1aa9434a88e57a4fdab622d226f1dbdcc0f0445395ed45da59f974488d0a3341887866ff819bc89cb16f7c9a1c441137dee62aeb353ba2618eda41304c2b9020c78c45c903addea8aaf113cafc4f10f09f9d67bc0cfe13e4458d7cf73b752a032283138e2ec294646ec4728a217103b6753d8d40409c344496dc0ef3d9da424f96a4176ff5953682921bd4bda10a9f7663296249878d24f002a4c6d439421fa440229bef6f58d1fcabe250fda143d9e3fd64096ef0484e967e9da76dc2909dcb6d8b44315cd3c4b142b55fc0f66c02cb5bc41d27fc56aa23c1ef205317806fd1e7e5d22bb6c8753d26a051b9704f3e5021df992d2fab006d602955f8e383bb8d1fcb98b8c35388614c582879ff1e1380ec50e18b28c7a392be919b714681c71d8327879f2495bf3180aeaba78e3010691553715043bc97820941bce30284b2e6ce308e13b9eea565cb38f2fde76a8f165a0691f53db7fdb4ee53ce7def4dd581bbf687db729992c565b70074d8cb477f0aed6b087f5a03b7bf1c79bfa1847d4a3a58f532a03f5d37c4ce50031cbde90dd580fb5e2d5e9693e743eefb6ae977cef41e9bae0737d8ff48cb0699ccb1c92a1bb230d96b846c4f08786ff608b8de74679795b63f675ae34f513c23ae83a6708dfeb4daddc113cfedd9881e8fa833233cf7fe7d7e449d8cf0631e2bcf0b7464c4e5fc8291978d8e1d12ad34951bf0e028130cfb89ed8d226ce767991669f064f8340dc0d9ed0466456f8c6dddc9c25ffd62aef26b12a770f5e266b773d7373b65c9145c5219f9c856d8a7c7a670d336c544fa1766b3d7e36098407efa2ad982f50841579e531d55a71ecf969f4e472e9d4658a388fb8ffffd1806152f0e5d3757fd61942185f5a38f694e25b46ebf88b5f1ec70224eb3d1ba9aaf0a356a61cb2d32704109835d49bdeec524ec82c0ab8a682fb45df884ff9945da4a78b2f6d8f5948c2b55cc33842a719ac1477977db68b5ec43431f36ab3b5a39b01be451c6422f97cbfddaae1ad332e9c564860d86ca884c315bcb1a5a3840234ad89a290a83f54913e24ab059e1f8468dde096329712eda729ae07df5e4615264cd89eb01b879c13cb465ecee1a5dce1674e6f221d8529eb5857eda2371b52f0e75ab7efa645836858b01b60ac09a0a92c4ce4627faeee9dcbb4f305f0fc1dba469685555c43796c713a0517a45d693b808d2893b0329d14f70de0de9605dc9c846117157570b4a5b7bdc9ea69365320f878cf74f47f749edb05f4a90330067572ede0128e180cd5b9114f562a9a26bdc5fc207fd3346b11a1a0451906f0c5715a81702e48d71d499edb6deb95135d1717a4c7ec8826e2ed2743f6bd5758229151675192ad68d68d53cba870d1c09a0117f3a1026b81458f61ad643d5c4c3c1e6b092b5165072b922d0ca8ab1e14990a66c8fef7910bf25e6af67136c8c4f42ff2382f084c9f6bee8a0a0f60c1a7525275bf6182221d17578da016fcc9f63960dac32c676dc5dfee411f12c23ae4860b4e0560b3e71277c1f3bedf6b43630d69e5dfb1f1a9d9e9e6d0e1cf20e1a44a9bbc829d7a78f2f34b7ee513447fae5344a11a2951188d7ae2ada7d9a8cf1ed902c469eb06caff4b393b9e18fe729d733a3e37907c2a82620cc54362f4da77ad3e88bc162db174db5dc61d9e6067a2b0d7940db15ceaa52a913519e97cd8171b9cc4e9d7609d999c5a881ee9f67019cc1b1ceffb73e24940427671508f40edf3961712e9dc3efc003a6cda9f5228b4edca8725cd9eab0cbf24716970640948a0bc3eaf0fb412b4183279ddfc82df071e926162d0f9fd0cbc4d88e156dedac5423070d82054b7a915b96ef0d8e371878b3ef2be01f28be886fc572233ef60065f50d7fed834d06e678d681ac74513f7a7474030b030e0f7343509f2c2f7ca20af97574e278a5cf14080141053f4637bb7a939b73542744a8b6a3f13515f877e65ffcfae90e924ba82af303015a88755d7bf5c21b10bf11ad6ace056087f612115f82b2c52f46a7a2b2255ac2c3236dde4057234b1681a8c2c1031e47450f802ba86f585ba0fa9f24caf6a71b37f6645d7cf7bfc973d5042a7262757c04d4e03b6214fe649555e179c35fd047ce1d0305e067831f609bfed1772d0e0b016c18eadc26cfa9cab758e0d4d59c914e5670892014deb7762ae75f479f27112179f2a743c9c9ec42b6ed9a4159d4e5396a5f3d560d86b909d50607c5beb27e0d7892e3d2267f7e0bfe306417f48956ef61f8481e23dd5ba1426ee144307020f380e6d44b58e441daa30c23ed6213d699abf1f86631c808e746c5f64de2e50f679361d662003c10198e64e726dd091cbcc3c34a654313fb090db86336019a66b074652f7e15f06d196f27d55bf68d56ed26dced009eb34e440a1320e22a4808d8fbf34bca90d74dc39be5e4f6cf0ca9732ad410098bbc6924dcb22db54bc4095049aa42b33bac4453e5f4772f2b2a3cc1816f685d3e1900c79abebb2be8a4d24e8b83bce7b71720ea53c7742a85700188abb873d1b7e679abb48f14faa1884ca4e1e5c2daeef475215d4a9d23cb407e72c4e5ee756380c5c039588fc09eeef473a7df85b5ca8a55e8b623c7c9beb4cd5937e95e9c1991c2b5b5fced4dd8068852cb8d983803b5d0c70aa12f8e1d11341517b0aa32b6310209428a08dbefc36288035b466f7c008862846dd15b0e20e09badc01c89f449767b5d034baeaa7485658708f0ba117a68ce8438b629da033420cf6eb2cb08f309c4e50b37df980169df074aac02875ee35ca71b4856bd12bbe89f83080ea0dc198e47822c76db2b612dffafa832b91e6b0151f0c9a5eefbda1a612e89c24cff7f639740cda68d915788ec68f2b296c25725c279b21aa29d1d8ee503589f3799ec5720a6889ac50badf22fe1ce6513733dc7c8d10ee95cef83505398f636f572584f1842e2c2c8b76856b05f4047d96180a9c01a650d97bf142c97f9b3d6f4fd4f572a88b2c955281e27279764444f9309f368c2bd703d02d7393ee810a2a707bf7644a84b127625fb748861ac48271213eb603469b489be14607725db753b25012e41539597638f46ca53eed8e44040eaaad8b998c636149a4ab8a95651fa6d1cc94be0d433ebbd09fd10c2b53140d2266b71f0b3f5ddac614f16e6372fb53300e81e4e95aa3a1311276e283f547a1a4808736487e264c202445e813b70c21bce7e9fb5aeb5163bd5f0795d738903477a9cb5c391b9b0b91b5a870f912e0bcc049fab748c9bdce7a1ffae3a22f90e6806df76113f5129f0f8e52538a9ce07b9e38ca5cf4d8ca60fda09a63b0d7d9e1794fc3d1d3a04f6ddc8c78da208f7129902a4f0f9a8ac63b9727be9d72d6aceb30f2de16f4fe678a0f586dbe93f02b829ee6e327b8e5b7ec7dc175287274367fa4c626e70b0379aebb18f01084010afe3c658a0c70b72c182ba8c769bc62f31aaeb3c18fdadcc42bce2139c637d3506ee591629841fc1019f67ca6111045ca493b20c231487c55236a1248857cdb22bffec50b22965301723c1e8e95f59860270f097c0415194f110e6bfe2f001d61e8a833072f3c165d2ec340149c63cdd12c1f5f32d2b9ae0e224e9746e75101c495a61a286d9e86bf3aaa5b9acb6f9437a51709eb519ee62d23504aae9f2c4eeb550b74e887779c779b31a42dee71dc79bd508792fafb86f5427c4bbce9b81eb06ea019062cf00a59fb5b309d7ee23e20790fc84bccb3bee37ab13fa4ede71dea846e8f779c579433542dee725ee7483591bf27ec958892ba6b470151cd743d6e2748a008e8b79d29f0fcd7fa7114bfade19133df06c120fb28c14b2e8cb59964f85737f04068322888cc85746afe31a25cd56928b9e6cd4447bded193e7d77d831dedad970015bfeaacc62f61a61f5a6a4dc70602e88f23b51665a5c85318ada88916389e027b3cfbea0843118dfadb5273962ec5d9cd229c5b105d9fa4cb0090aef8d0345b1c4f19301f3d609ead96e287e093006f38a15ec45e201feb8610112bbdced598be378478428a1ccc020806f06d8f5f27286406940f6973b858773dbfc58261286c7749ac051183518f2640c2ea07cea1783cc4aeea76a79c5c072251b3d4a1b77b0c6bd06029d0cd4bbacd10f7876d636604941ff47eecaba77d2740826b02fcfc6195356885f00f6ccbe8ca4732376d3e505510d50f892226370ca97d683f8d782e2be16f34c37c8c2a298192b20b012fd38bfb9869e9797c47efd5fc04c3e81f52326d4284bb5c79ef8314518b0ef43cbb7c85e6ff17a88689502b99638baf8706679204636207799126f8bf6a3c4bd360e2a73aaa40e8d83faca8d5c7cc12e2159b29388f6cda900f78431b4228d15513aceedec10cc8cc225b3166a67edac12807c43831cc46aec373b294ec9d293ad8441afff2fe94814630595247d2692830aeef05d4c645c731593d94a1bbb2b23f7123bf6ab74e5e93b5352a9352c867ab1200a02a16c7ec544e851f4ff93df7b7a14de5cd38d34293a1ac67a129c518618c726fc3edf0db6d48d19c44aaa00a8b994bbf41321d74485916ae09edbadb244b3caafc1961851c2d8338430ecc0a6cc7fb9c194b670d3fa1dc730da9acc2dd581f1c4d82a42b35ee40dca7dc48f692102abd8af03f9e15a3c5355929d962dd744be819ae1c34836131428eba8158df54718c512729021d4fdec74ac0bcab4c79fb5df781e75dc9253a83b6231fa106e1a5b8d72e305d0c106caff5a96972f45e541909d2af75f7cbccb4d1bd0387d1e24ce39fe9f905de0bc309901f5e15b42fc8bdef10cb706c3ddc4b48ccd6053d9049ab5d75b88e0a8e57607fedccf3053bdc7571654aa9a4a67a44212515361334a819f1443e26f507e4861c7d9a747dcd711fdf2b7ce1cadc1157ad891ad9411e3310e0f298b3774a78b3f89a34b5b9db9fd62cbabc220353d68668510db65ccc0ad55cc6cf987b4ceb102fb82b7cc079a351f5feebe35322627d7ab757bb1e69c6ae74a907cf490f2e5dd292265f6887045256a8c9ca412152e90b4d6735bf9934ad559e5e95f867a16afd127325667fa89b05e08194952f36e8ecbdb32442ebd80c91f63f52bb375e750703cd6a35f4af0851d03df4bcf324d43e14e607e2061e07aea0317ad8c5aaf76cb83b3192e998dcb77884e0e3b61f606f96b5c3304d3c6dfbf4b0f85186f4fadd89e8e6ba72888a727fd36d12ed2b720b2ae0612b9f2ec73fc3ea3c1986232f8a5de6271e99d0237fd786bcd9fac3ddde23c2a649a8b8a2802e4808163c5ff22155399d9a9a64e8269177e1fed5778ab915199868ff2fa2703035fd5a0372090ddfc11a582e7e924303b96b82d524cd743073545be0bbb162f4e95e5fb47f2ca1618c2ed708c8f4341c16208cc7ea59939f1d5a4a90480e5a4c507b08895fea703ad928a702d141536ec63bec2652e7e8faf29b16a4c89fc92143da07444638b17560edfb7f55e25e8c058ca793b8e8cfee3d59f3ef5e19e5f4fe44064e0eb7e6a1171358fb5e5b8b732e47dec6e7a94f0f9b037d1dd11ce26f3b4f350632a50ee5f4716cbc8ff21f182eec7b796e3c373f6877b48a3dbeb9632c4c5038caf89e8dda29523993178f328a2d67404eb4fc37fa259b585de2164729d4620337565f701ccbfe606288c33b987f11545de14992c5a014238a3763ba84af6394bcd908f5dc5ab9e605718d76d4d1ba9d9170076776b5bf6d7c78bdd210fd55f2db30f19b88a79304047652b664f82f112479848f476ebbee4a82b7f423961f96cb6ed42ce56bac011216b3881791e801fa0ad78f084a103efce70300a448acc44d085a3f6132f55ca9b236d6ed2525676ce8bcb3ad248a60ad8368b1e7915f52f52e9212209181acf60253c4cc0df4200d321807125218b1d94d8e7bf5849683bc9b86435c3bae3d5c0093c0215d84876e42a81d2b975aa898c8be6459c26f802d3175e3342ddb5b02716f669af3e948859c0839523a24033425cc2ad0eac8547d59d407aae82aea7ac7f43104696871a9600142792bb36931b182175b0866cc18de86f749920e664adade04233b7f4d719752097000d428980b83d69cc20ec6546f13149482904f0f83162c4bd98478247589998c080b298602d6e5e02703112d4a051a6a9e083ba613d136416d03894c24ee351ffe16711eb1a4b89d2ffb90bbf6af04203a5c2105b914df50b6a6972137cbfeb984c8801266274222523ca2fda233c9778b4dadc510f0889b387e6039b4f6ca32b5440fc5dedd18581d82e83444f5f3f29c892030336e4980d90160670e7891de3c7b74f2ebe7f4ba95bbc27ed44da2ed9b6dd35e13e9193113273ef7ed2be6ca3eb1fc81ac9ad15ce69fe271bdb969ae820da4bfba0e0f29ea712f7d4cb74dd0b6065f00dba254fe4ad62efa68cf2aaaa312fe580cce40203ba65c9466802d3c5e4ac227ab96f854e5bb6c5ef77028505c2e0b7b1db8d36457aa977ecfdb010a23aea3e35953ba322086a57e27b9bad9b5caae80a68228a5fabfad43d0dab6c34cfd054be094b42d1132f4069dcd8493baeeab9c7e295e9bd2bfb805450152958eb881a0ae0faf83d2e78ce7f5a64a38890f07fe318330b55edc3a53193891e0d137376e69691d01e828f3f70883cf27d228059982239c01ac86dc4bda26e2ad778d98dcd5caa10109481e5e84e34a9660b1577ebf380636d21950b935c6a120ac279e1305251168562adb44f19f0a30e33b48e819d31a4db72c8fa46412f299bf2ea853be8ef6712eb184e3d7cfba0f9d436e6763be956b76eace3b54a0cb6d1504b66ba338ea40478a78b127856784142da345a2b1ef4aaea4d942d611ff227b607adeae8ed683f98f10cb66ecaa9ce58daa1b85b66a52335559caa06e4fcf297aeb8ee6fccbe50c1ddc7ded2e11bbd63e9074eb1a6d5793182ae9bcc13e6418b3968e649d90bdebb94e1b2b7fd71cf1d46cc7315515e544004a06367fb7c1b82c06f9d564c255ee9b7bd1f55c695d554c624915a9e052b39a9d170bd8a67cdbaa0db298383620cf502551171ea07f4272333ee4c653a3d6427f096da84b35866937b023199431efd9480e9a585cd3349e93d49d60c5ac075295afa7aa62431b28ef3573bde8812baf7cd2ea03b5dbd8a0998157fefc01dab94ad6dac98cd5a230b90be8383db23072aa975c62a0075143df2c3d01c1276378f0a8ed26dc4ea1c9c552a74109c341eb8e02281872a9a484bef365987a1935d4a2c71308abc045433438a9a2242f6b0fb2302407ec81564545fe7591ed648caed870ce7083ef058e67c0ec5aaf5d07b035e570d725319a807a40e168b1ad47ac557f3614e7192c5f9ca7232c3d208a3789839635c44857e01432104146cd5de0da4ceb28a837449b11269217c78b332e070e00134ac3b796431e5f48bda1cfd6ed5e6c66134ac6c85a6ce6c0ac2473d5377654b0db4c5e9e873adc57c38b42b82260b30c0de56c134fb436b427f75849f6d5ec542e954eaf7c42659520f423d16a894a04942180b16c67e51cbce5f8d88404bbdae9b802d6d09118361d045d9a391f0ba14fcc602b4a09c96cd6352351dd96309d01b1acbe89f336a9ef1b39bcae4e9731b40033ce314de8fd2863e8c029d36a4161ea36671818ed15fa1bd0b784839b2fed3cb09070e5ea31da6d86675a4eaf7d029a1f973b791b0207d6abb02dedf0fba9fbbe88cfb621d8d707839b7ab6df5057b7e02dae894ad040d221865570d2a64b13f5da7278cb941611e54f8d82f29a68791796461b6979b7bd7e69cbe3daf6a0f0360af9460cffe4e89ff9ed0432d6ca4347447587a6ad950098962523ad27bd47fd5edabd05035c1660973f693c1b5e16bcf584c9d2a132432f53f6c44c4ccec3fa7b1c4e44c613af69cb779306bf72a4b67ccfc43fa115adf295c02a568074732538dbd39cda0b0e7cf42b391df73912a1fd352fe1df67e38ed53397aeeb62e90e23950eb785c95ce868657d1ab472f908f1ee43458f4357c33016925ad0d5201779f2158c52d35429485e4ff057a3f1d99792df72b6f654065875bded02f80cefd8b13a75a4e1ffb513d6c3b75befb63cae249e009af36de79b42ea67c551224f0c5b4d314fa45df4bb1bed90be2bdbc82aadb2aca9b72d57ea457c08ee359b77c3635489ea403932f3df88bb1f25421960138c47def83c7baaa356298942ea1c4f6096a6fd8b716779113ca7f66315f898b821d929febf9c8d56e67becc3e4f3e7761b1f80b94c45ca8a584f5bc75c1ecfd60c76d169b5efaa6c2c947ab76a6b87e13837fc683b3f76f10d663cb6994b20310194e140ceea66c3caafee9b5abe37a9e509744275de52d19d36f62072f6ecafd4002d33fdcf795f9df0571cd010616664214f97dae83fa37634df802ae55df3c88b48c004a0aba27f0e14ffbbfea6f7c7fa1855156381401d54409cabc93f388ce5e0051c077b30d083dfe741ac59d29a80c67a88d69292ed8376ffe44afd0cce9128c8bdb47c4f9a6236f285cf8ddb3d0d120ebbc5a131c4c84947bb75359bba9f4f00aa2ce2db80c966862540898f74c50f3f7b4f11755735b78e3ce61f9938f1c31295d6ff8e6367bf653df8c5393df776c3ce17d66b0e82609d9925d6d06e6bfb874bc9d732d3f5be0fb72039d8c6fc36e302739885304a2de33894abcffacd24a26a963de8ba5e191e904856af65462347396920d75b8c8042fbe001d661113d71fb806e4380db850c241f5210a340d05332346688605837f0457d961b13093ae7b031f7dc2098b7b357dc34ceebed439450cfd4eeabae881424b736810d99aaf34ff5bbdc30fbbd7a3de18f46f607f7f81a9567c022e6d26ca31f59e16ce422d02a32eb45b8ac5559093017f22168cd14631aa70fc01404b44437cfb4eb092b8fd07323c172fa6b8e829171f2671927a6dadfa35af946e965cee5e557519b4446f1f61372b0b89356a3aa44a07793266fa353e281d8bba331057e3608534b4f87165862c2bef571291e6e2da62aafee51d9c9571a64e51e3807e112633306e7380bbe9d6e7a6fc97457d27945d35c24cfddfa71270723706d0307f01a86405abefbd456f4c0be249280e63d1f33f9c1ce0e844e921e8efb79bd9449bc8bfab60c70dbdd2f86642d44f05fbcf339c969282b9da1ea9cd730b404a3c2afa745abdf8bd700586c11306d71042cb7dec45c5cdcf0b91b8738e3a693a808ba3b0ba36361a0010558ef1d9182273b37c375b3c28be9958de09f16fa5c4f6298862701da5c40383cc66d5b4b14e42ddbf94f6ea6652eb5a5f6443b08464a02946a24410d9109bb0b1ac248b12da39efddadacb26aabc474c72c0b016a0526980778245782bc66283ace53bb6b26ca5f6778640e0c9d0aec129c604515fd302db64850b1461a1ed2600421262d8a60df19d7808a09e1e32978cd957357ebd7835b224d40c272e4dc54c6744a63722720b1c2f27ee9afef28970180cc4cff2231a6e1f30d5da2b049e0bdca513bb3fb7c4c567bd3055fcef913c3d7ac55ddc79f6046e74dbbcadc2070378bd6c402dc97acee463e3182e1edb8f48a90e60e5977435598783ae09514b462dd12101b8f388f3bc223d8eb0392c6f77c4ac87e17de8c0eb4072c8a56d8961eb36c70d7aa2cf35f43bb172783c61a6e03a1dd8ab202e6348dfcebed5585d896bd34cc451fe7f1ac11762f7e5464c4277a0d13d078f293ac58e1c688d8c7429f77d81f8747a54ce3f66eb33af93ed4136e9a80ca4c942ae352548618439888c400d3dfbd2c6d38c1340b5f42f526243a4a9783b885e609cc193fa2b9fbcb60d4f26ee761ec441d881e787332f3c733a3db725043ff585286195e4496d0bc15b360ad42dc24c5d435d079d6f34ea22ed3f71e9e9009efe39a28e1038672c408d3ce4edf1983a3d370332fcb183e9b0127a74ef6a6f6f042b721627ea6a92ad7b250c14d06d6ee2f7f5d3e2f49a112b24b6f6b6d838436e5c8b0c3ac054907e26a7ea35c6e88b12563e4f8d89414208a051de1e58734f1f5edb61a35048f514fe883576ea5d81819b0d911e1f23c2ac3813915113b0a7f06efdc040e3eab12b6a69c26755f63414a7fa17e21a20d06ba9c8c8e18f498c58b340918ca28027f60a7f4b3966a5970f4c79b163475cdd246a5046ce375beb16759c6f02d4dbdb840d9608fbf758716a658f89d4f738cfad0c732c3e06a667f758a30932f9a47a648e5c1e6d698da3664bb4a6b97c2721af45007e63ab23c6ccad4808fb01193ecfdf79cf4181ec2ae7dabb22e31041e65cba5b20e97c9eca6cbe4c077cf6b4682051d7f420beb00521e6642699024888b58282f814317b1b945be4efc0072cc256d852b4b67a6c1e94f414e8c099211a8cd5f998d07c663ae9ed6749dd8a6ca54ea5c4d223105abdbec827822117619e147db71cb770252b0edb47f328d197f32c3fa10ccb953cdb5ba279d6a41a27ad0760082291fa0ca51588ee674c6478313f4cc7d727196c3afcab1de42ab220917815365a051c62d3c57dd242ebf21e948439d130a7ffc0bfef19e3338721178eb9f60212457c6c57fd14a8e234e99ee7ab4b670e044625912810e4d93837ab3209e780c22614fc3f65d1eac31c801bc090277f2e72012c08035a3044a6654c947881036d5580b35389d829e072f1c97e7075bde7c7a57f9a0f7a40b375b57832fa49ccb29d1cd6cf3423a215815f47234b87678bf40925b7d3a91916a95a9a1964a814b8f43f03a2f99a80dbfdfa8fae3dcf604baa79217892b37f8925fd73e40f52f8cf339567fa34e4da303999f4029f38866ed8eb010e5873e0a56f2a01c2cb52561927200de432de631f714bba52af67c846b30b373b9e3ff2726f0abce00dc6b92afeea2434a9c1f434f58091cee00607e538f474219c19ee900659f5287832d343868dbb6cd4e67daeca0b15545233b95b9e36ed3d14cda05fb3b71a97082307c9d4f5132feab52064e109feec57528228c2173cdb355c5ee3de52cf8c4f4f64195b2cc8a727eafbfb5012ae2eeccda747b9ee8aa5222760c5bb5d22f949c3fea468bed156a81ee6a7e7dec193321fe1054bdd1c1ff6e0feb2922d750c5466d0088c20d54de28c4c692c418f0af2cc67f7ac22babcdb8341874f454d85b9ecf3d24285c8b99c658b4dd57202158d00b304bd565b868a8ce772502f3af47a91fa33024fae6b5526180cb4a6909d5a1188809e9e2e38e534119b7a5747f462459001ea39c82cd26ed60f47e47f7a749312a6f1ffe5ce579d3cb0e455df22fa77daf7b1e00411c1d4eda71ba09ebdbcaca27968501c7a2ee3e4a847a385a5c82fba952c6d46f3b04847317821fa505bdac3ee13e2083ddcabb57b3da6aec251f646bae9a65f03f5d04d7685881aa7bf0da9a0e71b0a0371e2ff8299a999c08ef89e3c9ad524692b907213b596dc8770ea46f425453e2e89693f1848c0dcfcfe32fbd193fa79ec229e56f51e3e20c8ef849f4669dc8df8b94444b802a84ee943fc86ee6510fc991a6ef123f95550bd5a135e2e118d67d64b65188df497a4924eb06c8cc0ea786b8f3ac664f6827bf743b686c339b61cac880cf664888c5eda684df2b2003cd1f812d1ceffa50f77c9ae549c91ccefb762a27e57ccc584dc6949d7f23e8bb5683016e593762d63e255c62af338ea90312186c5f42181824a13f41fb38e9d07931743ac12f6e6fecbc54b6a7704bd21bb448789a2dade32b3274c42b322c7fc57ce3ae4fc7cdca09cc28bc86ed4a657e68680f411f78034ff95f42f96a60c6e4f7495f1e59c4b52defdf556313c194bebab80290c5ab0dd93123b7d5d9c2deaec9c4bf5fc4297934f7731e69c2d9f318c58e512ce44b019fb57f712af002bafd8872d4377ce492f7084b8f49949f634ed5af84d45f9cdb13940914705681943360e3a83489497a143327ad76f277516a94981b532e2602cfd363c631fe819e05069ba02627fd812c588841f1bbb1e8029f58df5ab63643ab611e4c0ac1c29b75191bb4077dbbb4abe5e4212aaea6d96bafd8740ed27e5fed2d9db364db62d3d98bb6edff2b26f448dfead7d26f8037ce29c5ed3e92fbdeb6df45b23a67d69d84189c739320face224037a7b1d3d3c0d2bf74f53a9b7788a5f7b07e9dada2656448bbabb5615b9ade1c927b2b1cb3c25b17265db27b092d8ad5c1a8da2e901f59ba68f187a4c45a43aaf8d473537c6442a29fd1f3a6bcfe246d4b95f4824a6796408e39a2852c17af5f32032194127219cdf4b6e7c2bd87fa55e6cec2a918ea1b23b0caae3005f867d964fb96beb24623b9834bd2ea0c8c6e8e9afdb0a260be2fdd4a6d7b5505edb8adfcab8cc2e75fd7765f02b70695d2f1227e4fb3bdf4da1e97dfcd01fa6d8bcda22851ddd1efee1f58ba804ee462976443b69a016a487ba6491d20387942a4b7408c96b215d27ca617495627b861e8979f1eb1e6561adfa3b383faa4e688e27a76819f1b8132bb641801477538e61795206fe352d0f271126814f0e9b48b806aa83d7208264dd9c43c138dc1244207830e5b4925de1be0cd58f1e3a5355bc12d623f7f53f123bd4fe0bfcca53db0804d30536186ee8024568ba1a258a2560804ba3a327f955fc10357f979932dc07cc349f3f216d3935d029418495a623da9591be397e67ae5a6a7ec5d2c86446a44f8d0c7a439b36ea44a073a8249b4bbcabb479992f082c629ce8e1d70442698efce792d367cc942191f3b3e747c5cc9830df1ceb8051342ad910a9d65d8956f7b7486324e9c60bf5fa44d7e06ca61da2ee4f81aaf41724b70b0ac09af2553c852ea5137f2b9e0c33d718736468d5bc7999e9e5aece9911ef8a523fa09d5ab86cc343c70171d47c767f7e8a130c743ec56a756e88bd7e847ac78aa57870f2b4cccb7c64fddea8f8450c940c86d62a040ab827e9e34f27ad743332b9823be1f610a342f2d238951c83b257ee6c7910f8d128f267927abfea0f02e9858e6446987d5cd821651853898af21bcaa4f8468d303a360ade6477cf84249273869f7873efe8bc8a65c34940b2cd109f3105fd3e068884424faf13de526334ac0534d63b6cb0dfbe6a5c0f028d2774d8484fe9c2d11401a431bf163b09f3e24b3b6219cd7abc4330e1ab935de8fd86aa0d1a5fb384322d315a6bf4a0730c5bd0cea7d4607ae5fab5cb95854a8a9d2c8fdc50198437058a218d832b7ab16a61c85c9c6e05ebd78196a83ba494d345d940ac0e9af30d1a0aa332f4eb3f7f61e417a6516f1a9189e62d074f0a60e353e16462646d2a28a09958f12b7a4c707b745515dcf49c1e7e73c4bc66ca95a61caf611a07ed77ea920bbf589ea2ba6c8a4caeb5d6b6b903368858d92a4471e256b5211518d143664b4dc003140d91e61329d73f2603d0a8dd347c6539078723b6c85a29e2696786f765c96f4c0b7724234f6ac2af5d2a566b93b20e3d6457c0972429c742369109ac07f116490ada647052fc13ab07078f45cb3004213410b13b43fd70e0d2b1c6faf55de14dc0f6e08f8d2f3bac0e8d62e49482d390300f5329a6284be9a9b1137dce59481d6ae1630f85046814db6944a07c2b1b2c31b6c94c63c631203af405590e1bde52a189b467fbf5510f5c111ca64e5f0b148f55a618105b0222b0d9ba45f8a2774d3e71caf685bd0f2da4fa7a76da1519165e2c7733ff57526d88ff68487653b84956c8c80e80cce037736a6f3877a00ec3027848b8f59a71148709b1904c0598616bb0b2b69e68ed35311a723a0b267fce8f2e83e6dfa593952fb3991ec524614d88ea7f6991e2e5109d4938b4f8db6fcfa9aae5b20632eb2a5d35ac7c037a2be4c4ae652bc30c9504589c78f630b32525585fc95b9bb679f923d62d12ea9ff1d8f9e0ac958f7a65b18132856e33489ca34586bc9c523176c43019c1c8e1644ae89ad039934ca5d7e131008b2927769b7282089925115ce0b482c97dfeb0798f3d4015073836bbbc87f3586fb86d41cb8ae1a7c5a4a4040a120b568700c0f89f38f3a73de32f10f9c1234f04b15618f814148f4a0b6ebaaa0265aacdbe652d5062f38c93237d0e8bf201116f20eca42547d375331f9699ab894faf892b28a255664c93c355483b563714961575a49b3fcf56893d94e35eed779a780f59bf744aab983d35e897e977981be68d0f140c1535872c2c1939fa33d4c24d42f37420be6329b891437a6bde33bdbe6cdb37bf88f84da78508df06da52d0b1225597b901b5b9ab9725ecf3c358069acae9c8b99b2c93d94fe4561e241f4a218be13a65c272209e497a9abea110553b388645663596b93e372d9af64d9b1db803f5188e6559ee2b2b36e7c90529834f777f41a8629b10321fdf60c7011f3bc664544efefbb4698d930ad415ab2e90f154216db70a85e4421743214a0461c32230fe44e81bf6980a192499cf69e520bcc04253f93f9df13663f76eb2845b3c54e5b7832625edc08b1156977faa6d4bf3451bb98773bcdfca5df6521c8de9571b72dffdf65216b93361ddbeb25215503f4b88f99f07fbd55f71d95785cd92acb99ae9db0c7f9cc4be74d5528ad92ef1e950afb7b6c6af3c3eb5a918daf05f9be2015f0c00ef48900887352e10e1838a510b042f85262c2a1c967572da2e6e64b33eace98e18bdc0643ecc9202af60a9d5464f8a99b1b49acb046ab47da3d6b7bccd56e50e6dd3cb2cfc39492b0368422bd40b03e70dacc2e952107565c86f1858e9a08f14c5b56222d615f3e4a2197e74019d065ee28b821881116b1c2c0b803b67328d300e0e5e8e3506485a75d14ff8f3a98f9655de85d50b3bb70e272e356441d2fe79f42bcf175603ce4954018f2ba66dd77e08678d7063548fa9f9144e75771a932e63801186f343767397a3c8bc029701f554ecc6d2d9e63569f0760d6098270f559b02f10e5e0f92841b7178b9b59a9b91136b66e5a5c32183e6ce1109a8b9aacbe2a561344d19ecee360b933f44c8f71227d04eb56cc4a1ceceb4bb0459b723a2300c6972b3c9f15a736adad17d2bc3e49b2e0e289d3848d38199b8a338239c559b64151e8bf38b30fb611ae335791a3b987c2bc11034e99df627683e8dd409a67b8a12a74a77d5cb4fb7d73c28de115bcad02604c2e3826a99b8f59cd0cba2d995016bac96253ed757a0392f9f740e0868c5542b70cf432b16334c269952d8172e86f455bdba5d20f7f15b8fab804c7122c0a3c50aada05b66a0bcc69917323fa4c559705db105bf5f7864d07c60d2144280d9d529ca1dc588326fec42eb293cde280acf3789289a352866d70bba9c4fca02f08a638df03f0e95dd247481e3885c623fdf36eaf9556d8c6e2e3647b991ed48c8f47961e318ca2f5e6d7b19d4541c041a9b696803d61e0dfc0904bf9ce74ced66e514dc29f197255b53fdd591cb216583241eb082a0adc3fd7f914c3cec407315e6509f26b02e1c588a2646a8d5c246a402e78acb4d187ff4ec4f4c8e07645e0d0f3be21225398a8660ea3de4aeb41f7444dadea83f16432370b03703b145261d37eb7921126f469eeca1e561f512cf13d450610233a9d56783c1a870ab8cb508b44181714b7aeb9f0d1439094c402b18d019d72daf17dfd721cbc82a3492625da415dddfeb056fb63943ef4e22c891aafb50f22f22c369c0a5dc078e6788a57ac387fa5b8182578186638864e05a5a180dea8418eafcd89c67a14a6342ceda151e2d187e8851fb0ded6c1c38505afd543896654af460fc0038e29c64b73d4f78dbb53185338aad5faddacb7fdc40f6485a71c8cec12378409d2adc7a99163d06d3b3ef6081ad413ad61572ebb5cb51445c59359555509de718e47b52a4a51367441de1d1a8c2111cf7e94db2c37ce028511877549a03d1a1957a79070e8a30c7432210067621579d360a4ff4d78ebf8cbb514afe61b24949fa41b4386874682a20efabdda356a67e2b5b8ff9bc730d86383507d639da1c02b88180a1e53846df1051d3219237124154c0413f229bf66b7cf184d9dde626f7dc9ffe99d302b9ba1dc9cc84a7ecb6a9433b05de931c6079f46ac4f1b5efb05f7bb6ee6bf7ffd98fe9c134e99d6615021ea6072c57b7af4e206044c743dc3fd21f4b8217ab2a5af42133c9db6c5638e5410b037e772c280f068b06b4dd58cb4756e2cc453275c989eff262faf450b145469d21021aa114cd3db89417b920e345ead5260aa2bcd0832b6e3d1ab0eb1148773a5e7abbce02a6bd4c016e3779994b48931bec99ba0a1d09cb403557e6fbbbe76d01b6e450f2bc36fe3d055a595d4bc204bbea6be845e9bd53fd2c2c46718fbe058dbdb6e308b7af5496e131a16c4eed56125598f52774bc213a76ef53f00817641efd16faf4344e2de9f991c9d0af30b084faf4b8f07b195d49896f08fe973024a33b43a2ec1788d3bf842c9cb03deaf2b76254daf5328b75e2bb61b886df9207dc12e12f4e268334e057d462769d9bbf0c697f096af58791783bd05878168576eba2e9215f8c16336a0565c898b25eebda09a10c06ec8219d435abab43e40e73e4cd844c9d684c2cc9b6cf8b1acbd059bb9dd0dff34df4ed26b43d9d0c0f73ec6d40f64060f1f4876dc67e2145cd355eb3ac3770f67898d9e060a7ff476a0c78a3e8bebd4a36c06c3e254d8e5e3adc99ae5f2a8b4a9fb2d2b21971ba8e198e42dfc9da416172a058be181bc4469e5c9ef990c1460ac2b8514328c121122a4bfcc44182888a37f02a084a9f9e78c8671cc9fe14ebfa24831fbc63161a6f1bcd9cd3f5f965902af5a2b9921751328976dc0d7ad0a0cced9857bac13c0f8fdc3885f69fcf98cd7b48d5a11248477894a7bb125a21e30c45f454cab5d32807e03d908edcb3e84b0d7e9583d368c0827524d2b67f009507894baf0a3a56e9fb36981c2c1f7a667df7df97eb3809a991e4f470d7d7b6120226caff5467b5adff959a674951143d88b2b3251acd332c1a3f442a65176ce6dac95eb704c0f3ba03edc87af41b02cc073efd00d1a8cdf649d5321b42235cf4c16728eb023a001fcbba8280b81918a5af5ac3c44ab90225f42b8cc7da250d5ded70be20d474aa251b52bbeecf6726673064cdd24c1f1749574b9cde7f0b9dbdbcfa2f0deb92cde6c16d66f08bf282efb57473dc0c66d542b58f1268d235f6f3b0242c38b84c4dc48aa2d4800a89d106864dc957b956ce7275e8cca5a4d2243d54988c2508c1846b7c16aee70b28d56b8c1526cc161d229dc921ad0bead090b6098cfa45d595393c42f3ecd9d478141e7c8b62a4177bd51740566f496a0edf90a1a8a156aede2949ed3dad355cb65bd17168fb30ef291339f8a344848395ec4b41bad5d9a22a811b3c676ada5ca7c9c7bee2f63dafca0f8762df1f7ee3d9b264a39e3c719ad5ae2b938b88455102d6ed20d54d5ff11ff3367bcaf249029d53b09f575f110778da427c2544503dbc77bbea7d57028c7445f2989bbe8970ed8033cbd7ffec9b11e96e8b5fa9237406d424b71a3481b6fb6efe4adb09e782cf91450608289c0fa5c0db9286e248982785cb2e7349a5b66b1ecdd9e4bf113e31c50cf5389b356166fa850c4ce97f1e5ee245aa0a5202f9821b84794bcfd0d7934f26c5fc2e1dc43f2f8cbc28dff7a647fbe6be4b757d9a34c0afcc638ed4fa84f540a113664ecf0cc84084844128441f1db90957aa5b26140b4424ca0983c3569953f5cb41a9f2736fa9c0e65867bde52cc03d6e65509c8b33b92aa32e17d5443f26dd2546cfd739756d974473d7987e5227456dd3054a11d5b103aae45f79fbce09a055d61c6991fc1a6e81f7548c688916f1b350de91474f5901fc35ba5ad2a4ac20056ab08758de7d6d8d653761d5af5510c2672ebd438bf8a5667fc7e5bbd44d3b7581d4d2159376cab2dcb4ff662709e5935ec700551d03fdd7fb5887ead9e0bf45c25cd339268f4f2ecea9f4d2e3df19094ec30152a55d5877ee2499888c4e11326efc73778066d949108024aca3d3af63d5d45c565de7d09a03e69ceccd313809fd1c8b0238871c99f0a86214cfb28e594254cc924d4be5736e523fd07301d16026c3fbbf6a41703fd81af48898556836ca2fe836f618c9a6e530233e97bcc12412f1f0003afe4c8b5618d30e7262b30f19d2bd75ea85762aae43ef11e89065ca254b3e58eeb38cce167bf98833cc1baff0c88c875d23ab77dfb19603ab383d68f23356812bf3c744753968a58bd87644a58f6c8ed0681a0d95a451fdf7b917c0cd7b97a842d2df04eb58e4b4deb7f938c260b6c03036773e64079c1bd0899956b76e88db4e6bdbf065b664e217555c79a5963e4ffab665a04a29e24928bbb5bb0e06b6850bed647c92b325a11999515ebcee3fadbcc7b9cc37a1e9d115300bd8ab11d11e91d5da5e29e794353096b06cc6d20b91bef9563cd73c99fc48e7299d5ebdf3c3b5f7616c9b8a82e1a0d4f2b2b9371dc9ef3f9ba94a3cd210f4df4d397e2e012ac7b06051d602980e9454af4b48e752a9c6956d2e79666b637c02ac7dc2be6ac9ac6eba1eafc131bfb73223495f9700d538b8777365c2ae9d6479be1bcc839855ad047969b590b05288daf9e413dbf48295731e1683a9873dc92de8b3d3d471fdd0110631949e2d5463908c31f32648e650def4a30373e58af0ce5810e9081f9bb07e21cd1f3fc53f27cb7b5c92aa0dfa44884aa82e6b2adcb41e4fa9939988ad2acce761d3a4fd03880ddb0824f89b096d02ca0a622c0ee9f6fe4e0c104292628a3c8c92ee6eeaa63a3e91208dd02886dc27fb66dfe9f8275840553181b0290a17037d5789268b601b1009fc90fcfb9b1cf10f1b258b91534c40daec824a7b017d4044960e5666498980804c66c120f5536fb094e617a8d431a834bc702ea447486dcc68e71eb12b9091d5f908377767ccf93c29d0e353afed52215737a72b2e8cba612abcca1d565c44b4f764bad24c16d72f431f7a4b1f12cc9897a0bdff2814c22bd1a13c215ba4443e1edc3774ba20fc159d554bca6b76ae6e2de0d9c1f86177045231923a7f456158223d4c07a75d8ab66be64808ec87bee1011a2699c9042314ae1e375983fe6c3ded96fbd38aabe39532c1e34606621fefde404698a30b01b013e0c817fe8f073a369b2cc3b50b15ad6e8049aa873c2ad1ad1e0f146c7e6c29f34553de87f437201665e27d02fa32114a91fa02231444108646a389af0342533a45f705c71a9ed504f0e710a03e0adafcc68fbc1ef533a5e8357ad8819bcef72128b52b8ce4d5cdcdd5602aa005cb8ba20e98df2c14db27888423e4373ab53fd642ee725615f08de90d49603f65c2c30a6054236dcc7f4ff8e448cb5eaf40a935a70ad0bce7b5f26910961a0e24a7c226af84030bd9144fdc8acea6231646fda406728f68bd4f68266cf3ea72c1d6b9bb10bf68ebb29fa8287372e4241dcae2b86e5e9c6b182a7831d24fc6e91869af15155e592037608a831e55c86e9e4c60e9a63475b946772b219479aa01199e2b4dc5d50f99e94b834647dda33ff8511281f8a8ea86f9e3cb5586b721878f3913b02e6f30b8385f76ffbffe40d2600a0ab405ab8a2df5c141798b1ecac88b0ce36eb406b497b810afb0421d67a057fb42b05558e42000ecc1d813b8eda2c21667325d14a27867f7eb95720941065036bb8199e330a782289e02973396c028a5645c5c3eec811245d275dd1af6342d888836a0971f8a8395c35bba32998362bc5573f588c5b7eca8e2cb29e77e7e01b34718f84868bdae68ed0ecb48c3c23c79f54624b00be00e0b0be5a41c3021d1c0528cf9cb5c07db48bf310b3b13342a998ff2fb3738bbd2b193d674cc06fe23412568b3c2b07aadd8e04cc31227103fa3ca041e8475b67da7008a9b62e6cc0f738831922e41a07da56b4b1347471a2f0af32c95e0f2f82c4e19541831e8baf1df531ab0f1957d674d319131cc08b6e9a5563b4b248d237ff3deaec8e3e5d2a997b1d855a7a47cc1553b668b98ddf1a09981e60eb4c055a87603fc14f0b5faf2c444904a13bf2a531807fc746305b0b54975b0275f6fca5d3752f310dbdbb804a2cae0942486d9a36cbbf2159b6b5319f9c644534fd314fa6888695a980e8fa4d5cc8b2972a1f3ff48573075c35daf93a7524f4ca5bfc3c3c2018335c9ebb4bb41891d7d4bbf35a4f35713fee4a3c633ff5c724ecf51fe3acb86618e3848dc4c85cc6569c4304f31b86ded4c9b109e96f7e9b08804f7b8680c53d1679f7008d5ee631639eb8f5e822db0393e112eda5d9cab9f24fa7770b58b801fab1536ac5b83672e17b82d2efb6d0170d0a85a5cf5487c9a6a7eeaa368c2b3903f1a75a422e64318713796649f9325de454173a268d812b96be5ed5ba08bec5b466a420c940ccdb7029ec375dadb99923d1cb8312c55a9b4a4e8324e634ea21c9189cb97c362a2d739a84579d363ec898164e1c48d2af181510754b308800af64e08e0a458f5bb419b1387545b86b839b40146ae934700aedd804afdb26d5a1210bed96d9e16a568b6968da38cde1d132e4cf9bb40443168ec3006a5b0e012e9af2a1c6cef57277bf46f921b0787ce0c96324e3cb08393819bebd49b1f59f2ddad2ae83896398f95740d143d672097a1135c507d2030da685fdfd3cc3b1ed9f7ed54d8f31ec573be1e59340321297a166d54a84d435f44242bd9d0047f4f8d5a2a96a4ae968f492a909ea1b6790229d3c1864ed1fea37b11673f682c1ef456ffb46e8937119900c86ae4c8a611504176be8dd5a4b7814c2aee34f2e4594742dfff23e20f8d27bcbf963ea647dfc749f2b7d1f02a230d3e59113c9f0820c21f174321ae5a8d76f95865feee57f335000bb0764c88405c05e2bb0c7d81ff147195b1f48f9939c0382c1239df7ee3d27b0e57ca77d095b6eb6eb646b71704a4cf91e9f67bc92f35dff9aa01bc55ef9abd9fbd8142e6e3c8e910b039a58ac81da53fa3c3b7354442fe3e00d1caa3c571b1e5c1644b9fde78e000ea4913c849f36c366594c9d29313ff78ce6143153a6b86a1afa5fac411c63a2f3e2b38ee194094e4d6c94047f848de0e249433425146da2ae825f141d75a45c278a882945732aea45b3cae296586cc39224f3595d57ff6734d7b9cea5e128ea5c45edfd912dbe39d6edfcebe6e9344e285a6c478e550fd705e4d032507521b179fc069e8f405eb789c57da32b19a63c959fa6328ef183a938dc32c27856a81110d157fa0bb250689c3e7bf2679cba446d76b08b64719a8df5e07e565df4d53c3f90853df989f6b59ecc1949e719dad46dc713bdc91b9785311251abad824a757b43e1b0f15d85f666f4f489be5bca417fa73e4378f1d1ddf057f32260b7ca98b070f732f08362b7536b1de5086055a9ae303cf1444983c9504e370f0ad95499671c97340bc28f7ac8d1a5f4e859cd80bc622565f9784bd8f6552342acb819e5968380e1980bc0797abd9739a66c8494793f29a6934dc5c392c0161720fdd6da37700d46eba4ae98b3ad3851bd161ad4c361848a4fa139fc11c77b2eba3e5886a402c723204f4d35417273193a4ca1cc262a3696839579aa06eefb809f229b2abd381d299a246de8a9a70072fcde6c6dfe148ba9a89ec4fb9551e0bc52fd2e64cc20becd36c9cec047dd2c11795919c713d7d00aec276a340be9324dd9388db18aae512fce83393278b2b5c33df1b3f3e289d7398449ac3b2ae9579d8d4c036048db134d304c780e767250af421be8fcbad73604928508441345f27b4cce2626b4495d1b4419419adc85ebf8395772ffdc5a162efe15c18eb2ff7251bdbaffc97896d4cee3db2fe21e308242ad7d21c982539183067d864549e4919876c029c1f8f412fd3c7ccb0bbfaaf39a224498a34eb663d4cc289830770b68cd65b22b975087264bc57473d55d4e138d0cd5e606f4fcf74a126b2f6493e6026f404ae2df306a29612fe98d21306dd5b254c999cfad351dab9692276489f4914e0c821c84c9ff94d659058fef75c3c651d34934d1dbb73fb3843ddf25230e607be5552a0a9185758064e2f27a23b27194cdbab568ebfbd437aeaa22e0034413a2d7652ad046297e3e9bb8c54eb1c34080236a37c594d0ae9ec2223ae5d6eb0d9ef65544928d0576c5838299a2e5856a727e447b8b448c8595d4c6618366d09229eab3a3eb62dce7b7b1a9687048bd53873d7a9c3e6f880f7419e8142f305904dbdce81f3c3018ef1d87594b8b5ca77f38c3ffd0c0437f218abecc1edc7b8f474f0a6b72023e35ceb879695788e98e46f335103789208e420fda28761f9fd5fa626f7c541d110c1c0aa2e636d910719254c7963042619b05b01c5f01e1d3895393b5c593367080a083882e59119acfd9f9cba9d602ff7970ad8ab91f7eb4ef0a9c15f4d84e9b2630cb9e2ecea01130e0eeb6a6b2f7c118de034aa8fa8a49013e3c44a2c4e631c82a7ddbdb6a6986e84f01462562564ef3002b83963d709cdd2c36c46a1e9057a21ff605ee3f750853c59fc4a03babbed33eb6ffe7c959f6c1f16e0cbf9cc60c67029e0bbd9d4e6a6e3a24df9e3467c0f8ce41864d1fb67064cb3872351da6fa0c388aa9ab0bb4eea0f3a549cc0a9313ae3fee2b292b26123bf0bf2d1da299a6773b4bb54fe0842c8bcf625515e796b692a4e5d441ae844d2d51ce8492014764bf2ad8d4c7b00db997de27fa09c88c10d0cd94ea449cd988dd395d2bf2e506b55654391e7828a349ec3652c4fc9f17697f1a6c4030fc15e29365c6d3fd0516962450170486bb5fad159ea7e58dfa06893627a73ca709e3534c9df555f9302c92624dcb3bb1410590f42f7c83dde53c86cfef5665d4dbc90c3bf1e27a770f3597539708e3148631e5169096ad2768a53f4b998b22a15e1e7de0473d3983f6faa45a91a830b4229c90a1f266acb3eba970fb94337069a261501ee121bec22d526065e466c9892bef4747a1c32c60c3a4232f2b856626826ebdf5a7c939c448df806f3d887ae9bde1843393a59588f27ca3fe8f5d07870c19a9a93c51315411e2fc2f2fb9e01bee13f07e3449c08b9b32554cdf0771c7a9f23fac072b1407aeec65c06ba7dac296587b00cae354f165d6d3e4320e4e32c1c245916a4949c19022147d46baa3650ee84b8dffdc065729819492faaf0c7628f45265c132e9943a1f7bb042df363e15a37e926ef109a0654210ff83532346581eb17c826b042ee555cad2352949aaa1310a3a3ee4264bcedab8f21ed89d9bd9250962cf2d53648315e593b3ec4c7e6830772a36448f4ce667913a71cc435266a5dc170d150c5cda9f02a550303480e13aa375cc4f202c1b4776bb20fff832a160f6105422646f0f2681242be9be2d654893332375beeba55cccf164208038dcb5aa1264d1ca7db564daf1b9085a4a90354b3dfb9c43ca470259bfd7453a86302e1424b7cb520cba0cfb28257ed2d9216cb2078a3b7e72ad8c494dc1a7c59a5b7f30b84b9ed8c15711ff0adc091999beb5b901871801427777faf6889973bbfabf8313b373b11cffaf38aefd25ba904788e062c70181dabd99be51c9fc64799c4f37b615e08888a41b214233ac78663875007b52a655c8608878df7450701711da124ca736bce8aad267c710e68853ef0984035aa553a3aaadf7f2a709f6d6ed9eeeab16553b416501dcf046b66814f98771f556b32434c2b76c33d805609a0714c1b14e304ffafec943f749096a586abe61f788514e36b17a990c504d5ba8ae601b8e0c230961cefd015e100b3bab6e70d3dbfa751a8a9c1f4079e477c8675b65135f7853cf42a5ee6a45f2a28c3e7f4918055dbbf4bc2d268400c9c651c0758ff9b55463cf62565a4b402e772a5577b85410a91218e027f1a913de6097f6adf7d63b349b5ab34fae1a309e87952e9ee3df19c8bfde722658cc9a066dfbb268b17d3cc844621487b0033623258bec4644ea3be268381041bfedec78b2a3d91e66ffe03a494c40ee281718bbffde7b3f95a96826343593161af73e2f850b20ec44cd2d7bda352420fd604e06ef16aa0fab4370e2b11c646259603fd2ac99814ecbdcc2cbe9a9e6cf576f9c1e0ea1d077278383692c38702a9c47bedaef724d9099e567d6d2458bc8f2b58d071565759513c016005f96b14e3001febb7ef037d4515a25d8d4eb975d33efc3b7e51a5258062d18ab2a202a775b9c080f0d718a5fa018b41ae3a5a4c8ab74ec4ac94b711c7c127b9acc68e0703762ddf7dc0847776086d1166134c4e7aa78de2d8df1e1ec17cccb0c3cda6445f30e1fca2f220bbf1bd68bbc7281914ac0d4090f424a04019cf68cdc36ab77e0b6a43c8b6e0b97169dd2e6b24268f1cddb05524a565e1ad9e3f3265d254ab52a713536df9ce26c3b97a4550b1c7267cd00292eccef0d61b76409caf20ee79ab48d4f04219a3899f7aa0241eb621d80b3b3973ce9befe92fce10023bbbe311e97386a2a34c621b981c0bcfceb6a5af568f47384e9c3b3652249c1d2e51c7ff6bda516f2045c2c35aa771046d204fe5ba2cbf3fced4ceecf26bb025097d0c28378ab7641c37437f32d60cacfa6e362ff18b2db1a02131bae62e0194591dbf9f2763538a876e132957aab5e39ef6383f8353b4852a82b00b52c2ed2470c0655f01295e1cdf2b76d7ee701bb0222ad6e948737feefa9156585a8189f526ac4f6d729f5a4cb9f3a11df0bec65fa037be27afd9b1c50aebe3c52fe1d629bbf915dcb924968214c093b21cedd7fd8cd6190f43155488775229239ef380feaa4b7bb0f7be03259fdcf358e4803500044ba48efad9358e0213e8771321d40ba87442f9f68ff4063cfc3f20e922245eb6b4b8d03927cba588a9085e33a5f5f288ec7a53b94b02735ea860241ff8f96df779909f5a62035ba184ba081b33b7f293510076260acbe097d6364590e4774ba10d1bcce07be202bdafaceca6da2b093cb2461e1fc3a5cb5d573e7289232e3b48bee1ec7a654e013102c343b431cd2d226542845733bed6c5ddfbbf6cad95399f52685b4b0c36edf960973ac46023e34b99c2c76b0a232303501e83b06eb98a5b02a21af1efaec43ae756b414d01573404dad1a19343c4456834457eb0c5aee8af9e1427216b88d8a5df39ffe5ca25ccdf4cb08ec68d6660f23ff5469bf8efc995a5f46fb2d7a43b5d2580eed79c96f777a9d1f1800f1a4fc34b3cf4996cc70af0dab0a17e615578c9557b97bf5380e2f1ad8a2e10abec7dbbeef4ec76a2faa343b28de14987d77d4a8d4bda00f409b659b201183069bd0625e51d6053997c07769e8e90998f9161eca7552743304aafd07a8db2c09a33a48adb983e1e3f5d89196a02638cbe0dba42c129d1279b2409e976875bfa5beabdc4125fefde76ed428d77ebffa5a46d853c035f919bd8117a8085cdb45fcc24620ba94b059e6fc9ccb3b5d9ac5d37007ae86c6e2158df1a7fd3bef51da5de9098082b9e30409160f00dcd2d658b5649d5135fff13dffc0c7a1526a660a98563c7a5991b0e77c603ef8f9111eacd1f38224d5b802b3fbd643d16c00dd3153ea6a8788f2b2269bb4e9b4eb57bc4d50e4c5bf03908408a106633d4859e9438f8c0d54bb64fb5573837326cf9cab7f1ec2f276a6e9805cb9e2048856202ec5f2e81cf95472dc3927e3a64282c793f26a1981d910f7853879d11d783cd08684bb9b2a61d42a6e543ef2750a464ee07826cb29c17890cce2aa4da544c6009c7f1cbf38e44e2cb9d532911f1485435ca02a03b3d6540b66300181047a65eb20fd2c38b222b3b26067446cd70a93a9a95462985679fc71105f4eaf94d13e726b8f0102c0cd41c205845e27a3ec3313243d8d23a6d782dd83023e127e6e4ef2463ac10eca52a3940cec380cde1c6e05e96c0938079de0f62a06caa17ac49a599c1261837eac7fb3a89d72a7d790ad1f7d184fc142ddb19ed4494f4eeace2ed7e32fc41a380e1d666cdcb3773ea523e0c7593c1eb6084d082bd8aef26670377406095ba39f680bda211e42e49316112dcb3f0dfeb1ff61c14464768f3eef670b4a44650499df6baa1c0e53467aa8f28e713a70ed3f5a8669633c89fb8b2456258b69f452139bd279bf01d49a9459653508c4340a2e2946ba07240285376ce8923475c5c29b2ee0db901cbbf099e68d359ae41ff15bf662180c2b814c0b138869f468d31be6a397701d19b80ca3791576a5172c1f4cb265c6e4e2080e8ab2e5c04213375bc8e416cd9a7ab3fe400295ad83422fb1bfa829880f65d1c3ea7441ca6f0ea3bdf92e62ad11098c8f2c2788b2301bad7fc184c02ad72f81c443792c44d1399c4ccb71b92ee3a17bfd17dc6be766df57dd1f414d4f395955d634076e4343ed860e1127114cc88669e468640f76b5b87652bc1628f07b2548e2af08c8848d7fdb7c35fb868892442f3e43dbabd047db401a9cd90163004a49ec667a600542d8933c1c7e118ae8fe08468755fcdff31ef73fe373fc5a59052af3f64fd9dcd400904afc8b916256d18b14e5d89048944799229fddc87694bf5d650b0c0aae9266d67f308b42e24dc326409a0e35ae6f55e0d042cad1159ae90729c7c41c6bf499c4d7d88fe8582c4e77badbeea78aba5b5f87bb1b1b96cd3127b426c683c5a63cb1341aa9075c83cc2434706f4aa16b73ae8977ac6e8b402b371dfbf176f6c92fa27296c0e9c68d0c5ddc8c3ce4e06f32aacf2c42683e8784295feb408af0b086e957b694c7e41cc5a821c6a7a103b7dc9df1f1a3e7e9d6c896f770c920817c24c4f8c8df1824be98dbc0fe361155bc831201b486022a04e6695e3012329bc669905ee9fafd1a25b26d2b8a0816a1cdae8e79d58d84e5a6d4da6ad5bdea2a4d546d7e7c31dc0d86e2426b601069580cc13021c61dc0c148e7d506e0a7782e3901edbd8afc1a950b1141ef66dd84841ad97bef2df796524a192a06be067106fabe6ef0370e425a726e1dd9c6dcafc5dcbd98bb1ca6991c67cf593b3fdafd5083ea50d5a10ad5a0aa431daa433a223d62ce9852a6f760462221387a3c765e45a6487b11946dee9dd8c3b3ddc59c124345866c9bb2c1dd921d67c97bb9cb89af34dd3bf20e8533d5d98b453aad57bb1d8425dd311ae4f95aa3e7d12f36e6cba96b77ebcca56d6f25ebd433152682fbb3e13d533664d55eae13ab6c9e3a85b12125c709c9a5b8553565c51b7260f761f165ad7e89548bde2ebbdb4cc5bbbb4edf2d561a1c5576efb63ae6824cc11c1c06d32e3663703e765b7b2d27ca2a7e016602d80c0c4fc471167033303c156cc69021af80e7da638cf1edb87b6f0d85d0b4ebba6b6329c8f495025a4577cb7b456f071eb3de7befe52ec771f985d809323dc771a257efbd77d6b009a2630343266386c2eebd9e0d46cc28d3c324edbba482b9b4efb5f7b620d3ebdd246eea77db72ce9061c6a0ad5a3355ab54be35ae8ef370cb842ab3a00d8d18421d1381f8b16c3eb1953ae11345ad03dbe16b6a051822ac98628777ebb0c81872f24c8a06060d1b6ad96a54bdaa6c9ca18bcca932f6978c41880c4483a8900c3ce1c1db535b0c393a622aa56d6a85d68f1af0b0c3df68a1ca70aa8c5e98cdb5a3229e9b33c05fd8ad333249d9759916e472def6bd0c0a5eb3767ff9d407559a97aa81b07c6ea5ebd2e5786f7f9f7ad51ce77aada87ebf42ca189157bf7f913a55e6faad5dedea5bb5ab67d567d75b24ab7beee612ef86303246c43c00a3b9a5cea49253752eecb66af7c4bdf7ce69f5941ab12099923a367bce2c525a6b12dd3c5772dc3c373fe3a6ede69c1fc0d65a6b3bccdd52b6e7634454ebcd19a37b09b3e78c3167ba1cc209ebe8b5af142e8723c6824c39ee526a89b03c32f0e07d5f7bf09e558b14ce6929a594ceec1c9d2ae3389c14a59452dac20d2a28543babd60753511251f6187a330773f49cf8a542ee0504bf7bff74ce1c71c65dad0792208a1d2501e425f183e5dff8d7532d777171e522ebad9045aafe91999e05b5595f5182445311a8224faae79e173b7c7e974a40ebac717fdfe7d22ae4d821ebac7facabc872f5f996bb58248bd5faa77ace66bd4b21e0ab617da55f54c8b157cfaee7b776726c97a6c08bbdd22fe167aeaf1ebabebacbf5d5ea393bbfc522cb15abe52db26cb574025aced2b396bbf46ce52c9d71b39ec9b2a575c6dda2a766ada4c67367e9d28528e63c8e633eeb216bfc5a67ad3ed6f8e5b756f9636161f947b2b0581f8bc53af8b13ed66347f90585d39d59f9f4397b2e2f89244920799ee77ae8a2f79058da9e8b5c793853aeafc8722c7376ab7cb57c74791ef5eba5cbbc595791acd74bb3b8e852fcea2db23b0b59ea8c7be5e25d2b2b7779f774197ee5aaafb8684a851caeba592b2ed78b45dad567f9adaff25bb3ca585ffda55975b35c64dd2fadcf58cf6f691278905f6cb09ecfd2a9679dfab843ede52923676ca92a29499c9a6e782e994b306eb168323d0d8b6cd3bc66f64b193b4cb1ccd81a5995c10767565ec1cf94b842be481a5586ef225b640b5586cf226fbc40e29831f03dfcfa11e3ab34c6369d518731c6d862b29cd9f8de2b4d784c86bab4d9589ce18ab4914186a48c11322a4da8d2a0f530f66054193e2549cfd3a2bedebc3c84132696dd6ff7eef4b32e46044724e908a5effbeebb548a2a0dedabb4efae711dff625df220ed4e9757873a943a017f3a7443df6b50151aba5509774155763fac69d4d5250245e4763bba01dd9c6e493bb422f7e316591fb507dd9dae4455865f832a8d50a7eb5095e13a548abac3b7ae77ba541d77dd5d5d3e8b7c91b3cae4aea54b1e95e6b91ba774e55298d1df8df5ecd3e28370fbbeea4049f0f44c3c3e37a3e736a73547b5e674598776f7aa031d00684bef6a3c13c3beb4497f67cea67a02e3fe3eb37d780b84a580d72df5c42aa33d5bc3ba7d3e06d23a470269dd45e62a766f91b3ca549a0e85ef2d3a69d8fc75248bf4ac8cf5ec25350d3beb900e7400f73936e6687673dc55559610b1108cb648f8ca32980c066ce935d26a2fd7ad622fb0e1388c31ae25504a2f8c83c19cb399a38c2ae36c746a4c03993e9ce50cfba5463975528e8e8225e06230c865d6e13657ceb0b9ef61101905d0cbb1d4c2d8942cb3e7e53c8ef5fbee89b5263ce11b77008e08716473fa857b8ecd690a834c6f0b3b84de9c41c395d1a6a7dd60ddfb8deead9f0024f5999a297c4c95f0312582066969ca44a5da529a0ef134758a9264490e8efc1c37f7293d431135ba32509b95a1b4070d1ab2b49a0bace3bbd03df514e606e2bd76c3473c78d66ff8ac6ec99a7d3e975fa3d55c7871e10355afe1a874b632f40d787141f5d65bba02373e396e3c2b439fc2dc3d6a9195a1cfe44b0d2da9807903a44ab900febb0daffa4cdd106fac740db232f42afd629fd227eb90ad613ff2c56a1c0f6b5947d2b03255e3d8fca872d8da4585b3c65c00068bd161023631361a264c1a0491021d0ce1a4063580329718e244122845dc40ca11950113263e2651b8e8ba9b04840a14b71e4c70100245c04405229318b83816a65dca9abc181d76848181aac27cb49da6619508d9d6c272a051a3ca869418ed72e494f850f2c32e6766409da031b69c5f3e7caf31676b391c426a420dab73b59dbd67b404a85b72c3b687592e468893a13aa52329045264a02889c9cdcf0f2711fc38320589899b6a04036bd9f3a6c4b6f39eb729a2ec52c6d44111ce391da003282ab6e03c1ca3e3ca88d9618a26326a72eda6d0c18dc9612a71f74e4105cc144976296312a2e36c686f487fbddb99bd674bca1d5fd1eeefa5dd5dddddeebe4e9794fa70a7bff4958d644e0aa8299876394a41346f5208d9fa9dd3256767f7f4337b82c5b8a3db06c791b30e0731a65812312542b1d29439c25aed618c33433e1da152144e62b728944cb0b5561d83ca4621fd7c3856d99cd367d6a83556691ea7051af6fc0b95a6d60081371c7c60cfe7e85cb1e765a83479cf5b92247b7e864a63ab1d4d5902bdc09e9f40f60c62c79cc87bde9244d965095b5681e0717ed22115707bdea048f2eeac501c4151b4e70d8aa13da1a8617f7bde9044217942a264539ba6bdf25e69eef1f586b6778c24c624d7537c0f76dcfdf7c207f58b8deedfbb7f5ab49e37c34fd9c0f74888ca58cfb20d8c804ebfb0fe61ace540d81d860479de902ced7b0e09920d80901ccd7aeeafb1e47e3f6dd4a752a07bd23dcebad7ffc53dff579b209c15e8de6c4074b381edf64454039c5892840665c25162e2306c8f5f82c5e18c1509eed2d8124f2ced7232e1d89ad13eb1828d31acc81328d81863268c9f100196f262cfdb1337383125090b28154aa5d2d8db91a03d6f4d5476596fbb3edcf3d654c5aeb7705553816a254af28492bdcb39c4d21760db5402ba4d758d19a33e860479ee921689b023d344d8916974efe4d822ecc8a9182132859a31ea4b5a44c5a569cf9b13443147d90babcd065f4e259aee459c0e7539dad8fc3219a64533067d57a937e9bca9e310265694538b5d61ccd40adcb6ba0661ec072a82454a3830ed3a9303e5440ed4090bec963d17e00410a5404045f9f6bc39e900ef79734ae2d4e459a72527252721504e41f6bc3915ed92eee9e48393052ed784164d346922074dd8a089256e4d0c49129b386a22880dfa483531d404d04a9c24083fe47963026a97e2bc311165e71b13497a302ded796302698b7bde9830dae09e372638b0a9d762a2878b89a11787c48d09db0e8e60418f507124c9a60722cfdb11a65d8abbde4a3d743b92743b82b4e7edc88fbde7ed08109bdbf376a48702f0e99c9ee779f596bda7d0dd2bc5c78ce4aefb3e92eeaeabbbfbbaef5dd775dfd77518e35b44130faf89860b42143b65c408169b7eaa62538e00c248086a2032a4092d6e6e930e230d0c11d5c30fe00e46a4f08c54312291f3ed8e8c3071468ea490a8fa5e234b3124c419ec52a683d0a3208c3030177c15e6e3b8040a60e312471dcc541a65cc784b746097335c0f469094508a5131624535f2c416e19608da77cfdb12403656a4eb8c1c1143020811189118118ee338233c2a734edbb11043418d1a8a76907bef9ddfcb3967c97391be0eecba0ff4c8b93befe1275985e8002ce7fd92d66e6bf1f6bcef23f18d145a78a1ca98ea101c3f824609442cdd1b84a9064c9f9490e7eea95fa8b2597aa79aea53fd62e37bb141efa69a7efac506f8efdf41f05eca4b691c1a21f98f7c752c60cf3bf6748d2a9bd7842a9b5da767aaaccaaa8cb3b0ba73a4e8bd85f9f3300cb23067f8cc18a40c3c55863a8df662eabbd79db361c1a6068d580772c0af562a522775190765a068378ce78520ce640b381bc8e063d0016f6fb4f0024e0d8e8708a3caec6bf067ac2897e2e62c12bd079261541aca953ae3be38025b4130b74ee13625d4202fd30ee1849534086ea1d6b05065700d8d2a83eb85c930018f1863ece19c2ac3322870da5fd529cc5d447f50a34ad3690a546547f933c7e26a6bb2f6706c29e377e7662c276344cc472ea950ad173fc68199d529c5516535869cd48c48ca1891abce8c511ffb402ea9d0c6a73e2a0d3ee6c11b3c3e15020335aaac3e04d204d20492064983d42479d2860400f9013943ce90305c90325246b2902be4c9b748982a1b5f2f12fc48afe69051ce16f524eac9d393254fa278e2f4e4f664c89322a29e10b1e7ed89d1130e3cd9e1890e27583871e2640a273670c2e464c90992931238f9e1a48713a1a7a8272afb69c9d36dcfdb53d25390a7209e8a9e7ad427a72649508640596a4093284d96ec796be2d4448926372848508cf6bc41e901e506283a623f64fa29cee43c053dd9e637154f0357f63b27d4562b4a6775c9bb595502c3cd6a9251043fab485ee0ac3a656f569baaacce725699ecef16515697b34a151c24ed72568754595d45ed597daab2fa59bd55598df121b35edf9d132d8bf5d2dabb9713ad51077a22b61f88616ca6afe344d0c3a087af25a71313be46f5ebea1011c63632323232a236239b8ddaa88ddaa613b5dde0a69317e3432e6776ad453aeb3aa4f36666666666661efeabef3c1f727ed67548cd57512aaca774398abacc19ac9ea7cb715ffc981fea10aba3ccb835494193209a1435196a225473b5aa6ab7b849d56aedadb50737e2b5ba6a9f9feedd57f6f572fff960eaf5ec7fbe73637d3d0f7af3d3fde27bf6f3affb2e3cf703de9e07985babebbdfe877bc7fa8eff13b6f24ff850c503bc49e91d2ff27d7880372a15f89fef2dcd83de842cfbeefe877b7d90cbcdea3efffe131e9f077893f54aa57d3efceafdc7fe3ec8e52625ea504ff0fbe5fe83efdde7873b077edabbcf8ffdf5f4486f7c7e70e7f3c35dfd63ebfc0f8b621684d71ac0e7e5412e3756fbdcfbf0e86eec8b1facc48dd53e3c5437f6412c3797462fb7635525c8e5c6dea7e53cc01bee5aedf3933acb4d90cb8dcbab9555214b5cc1bc585a5915ba56ac91a5f5caaa7085e57ab1bc72cbbb9d6b257fc0f26aa9324cf861ee3fdd2d900f5e5c7ce43e8ee37d7e3cf0c5858bfbfc80d79b3b18ba81716179b572f81ff1aafbf0006f5ef48e1755aa54b97171316a9f20979b16edf3039ee5d5caaaf0c3dc7fc4dbfbfc786779b5b22afcec7fc47b96d77d7e56debacf8febf93e3facabeef3b37a789f9fd4f17fc47ff7f9e9cea2612b3abff45dfad5d2302c3d663dae348c4abf521af61f513fd419d4f3d3a2a76f1d818e50eff3d369b18e40cfe99fabbd3a02bdd5b78e503ffff342bf21a1083b726d9ef69de69d864feb4ee34ebba7ed0080b6839976fdce09b5f9dad4e5bfd73e5dc278af79ba1cf16b5897afeeb54e97b9ca668dd3a5785fbbb3566febac55f7b06caa61348a70569a1d7cdacebd77bad39db6c3ed80a7edd8a7c4ab76f2eaac1d57ebafefb0acbc65c7c569f43be377604ea39af662e7e51fecd0d3aa9ed568341450a0bd9c369ec6725aebb4d569f6e257f8bee9e7dea1a751aa4b1a7df94097302fbafce8a24b17a32e61565a74c9b2a2cbb1f5d2a5aba5cbd78aa5cbbcd26516dfe3b255ba4c69da0bd1bec76587ba04ad2e7b5c36f71e97b2c7657bbac44a6c4c7b51a54a8fcbbebad4c13cddb6ba8765570d83a11787b0d20f14bf956779ba8d4f3bc0ee79ed8eb6da3d2c9babf1d4cd9d6677cfb8a986d99e0e831a06fcf4985279fa956d4f6be31e70e3cfafcc193d75632d5619ed11f79cd17377d7a3da5c4fb7397d3fa857bf3567d0aaed51382b4dadc6c3e10efcbce7819feaf36228aacef3ccca5fbd3eff52edd6eb3cdd769d8765d356bbe5f3a3b8575eebb9bbe53c77b39ce7b56907d82faff1b4f6f81a0fb85dbcd6d3ed97f3d4ed52abf1e40d80d778bcfdc161ce336e9add2f3e0fab34351ed5aef5d4fd4257fa79b813c1558a65e5e572d102e3920300d452a1b3eb9820d918a12062701861a6941f3720c2c7164b644029479011380042092372185274c4e406263d904c747c32e8a6805458b1cb190d84f39306d9f335c6865c758c0d79526dad2dbab707a543dfad35280694f36ced6ad0a83228dea5e283f9385e0b8e600991d41227d5b84405aa253280a1364b8514bb9ce9581096f365594fb9773440ceda5899b9f72cadcc5a7b3b5a99595e8ecb1cc8d98b6329c5b132b3d61a37890aa46e7216bf38eb801e4682e4200a10d450c3008c4c90815b0e1bc880135088251db04b3eb082a79d4a96ecd79e372a90d8e19e372a62b06f10c6ecc8a5b7bf57fc559b530d4a7243048e1c19a8110d7283c3cad4e76312a702dfb19679e40dedddd3335606b438de07dec3073d4cfa90c005fa6488236c37e1f17d7ef4cff70afc80f8b81655235b83eb511dc109873259996a5465f4d456715cf02e7b7101ff3bfea767ac4cc5b9676465eab9da05489030010262b2b4a405500f809808d984a4242531818212f2b4e3e98990901644444f6e372d9696908888908ea28e9a1cd170546d4e1c493952d2032542a0a2a0b080aa018a88062221484853a288a6f8f03105094948535311424242969698f8f0c1e409ea098ba424a4db0d49891221515147474290d08004e9e8c8e9c78fa31a8ea6203d3d61810405e5a4c603b2d96e987efc1022b4855091a424214848429a783429a1a2244ab5d5cc9b9691a424a4a4242879ee2248483b7e64212424242a8ba8274d4d4e483a9090a06880424282240b201e00f9f0b1833c3725a1c8d292164b4b42900421412a1204057553440f7a2064074fb71b112222294574dc908ad48044485292d3163fac583915b1fda048452c2084944516528484985439aa3a86e8810f20202652a44c51a2e4c90fa81f4845763435b96901458988a2a2b4c848b72a489814b1c1471642a084aac81e91a6294d57e449c29c4133f7ca0908680a955b16796e21404580a27810c52429090949c82d8b1b9529b7294845783c619191b29072e3819227796e214568589a92916064c86078304fc402c9aecfaf51261ba564991018d94dfdeb615f1882924c73d0ed89dc611c4d10994be1d33095260427ec4d0ad4ae95e643001c20e14971a79bd317c67e86f094e79e24cc5daf41d8a500b653382b0f4c30dc108121ef4c11e84109061d0e43902c0a110c861d6028ff2ccb10b8000c251c60e0a12404b3214904ca9ce738f380d1d6d4080431e990eb6337c86c90f190eb67604321ec90eb676038e47a18d1ed21d7c330c0c3bb80780be47a98d02d72c38f2ddbb388057e6c590e21dc3cbae45d71022510cccee2aebbd729c1c2e90ab90208917072188b215734fda8328a2ebd4d0996d212ae00c2daa820cf8d65d42b6cd878cfdb15b65dcaee0d430cf152350a758b35df61ccd49af0dd6d6a8d5893aac95566be7b8a14c99004c95c3d6c45945d8afb6605d0ee9e2753a561cf1bce1a1a0144825a0fdde0795e6ccf56a100ddde69346cb6cde3daf8214896e0698e0d9e50e37eebaeafe4ac2beb692ae4d89fae3177379bd9df2e05ab82fdfd5e75771ab6923d7405eafde5e3c8cbfd7bf7f9f269156ebdb5f4f2d05acf8b6dcf433737838e7d6b53c966dbb40354b256df33eb4ecebadf5b92a7e3e9f46ce7c59640fd6bd79e70db872b10cc4fed81f9f96ce359d956cff6b59602af033020c74dcd9e86abd403a10f5745f31fa8a254450948d06fa876c1f7432b5743584469a9d86cb65df6bcd07095fa971c34ab6bbc5c5a2f47bba95431bd5ef5be9b41ef619e4ae2696a2a5515bdabea953cf9669657beb559a8d9f5fafb1a7d6d166a6d2ad9d7d7aacd56e359d92c58cd43f7ec85bbbdaed1174eab706f5fbbf5b5177ad166b36d8f85ab4b1c74972ff43a5bd7ea0bd5363e9edab5a3cd66dbd9c766b36d1e965d75994307cf6ce7c5b66f99592d01fa6ff7b46cfa99c2c0fcd43dcc4f1a4e9a9b9e8779a2791a8e4afab0a86459a7d2dec19d2eed8c7e6e9c1983ce17ec39336be89095c9b3863ad9d59c513f0e51b2196595bc9b0ed91a19a68cfd38e61ca556376d0867cad88fa39397c70bcc1856b6e9637ac825758a21728a02ca6d5b2bc28e4c8bc1401e7f4f87549a18ec59eaf475b6ba8a29df4513eba153eb1f12d77192d741252b172b4d39abb0dce5f5f4a9d2b4fca5d220e5547a2179aaacde8594412475c89c1870bc70a3852a8bf1214f958bd3b790f489a44ba892241409499d68134999e84d36a9cc505f479a09afd797d07abd8cd5eb652daf87c1f215d73bd6b9f1f356faaa87a987d987ba1caf0b3db6b0acbc5c2d565ea9542599d233689f2aabe190a7a910d6b44ea34057a0d4070ff9be9c5476cc08f208b2083bf2dcf7d3d2ba6d5f45d49eb72a9eaa48b267a02e34040267ce98fbbe853983fe6a117664daeaafc710656b77ba4ecf5ade727b1aa567ddbb9defd3338c77c250cfbe1d51d4b3702795d23351dc51a9f42c953acdceca8a9ea954b7af3d2acd4ead7ab6f295db571f3b2d9a45cfa8a63faa5489a24524f5417b5022920e51a12a0322ca2565a24c2d34dd707a01098e243128c959a2f32443149e2a83aa3434aa672fed3363d8cf3d8306720903460d05aa32d6da1aeaa3ca58ebd2a5d7d26566d9accbcbc2db8fdfed33befd55ddde4b5d3ca8cb83f7f64aaf506225b64a531b0512352d0a35f5016adae3d394c8b3a7614d8550f80a9da63f2e496378c8b4e8b3219cdcefc5f7be7b0f0f66d557ace7b35c6fddf5facae7612d6779cbe7652e3edec5e7617c7ee68379192f0e80bff8bc0df99ffc7c09205c1f84cfd3881df6d8e74d08e1310fe1f335be2373d965be43a37a46a37b47000fc005f0799c3963879e36b31ae70208800c59830c9651a804ac976c8bd631442302400000631500202814108844e28048388e55c9b70714800a889e485e3e150863812086511085410c043180018000020c310019820c45aa010fe0d664fee6ac4ce37dd586d4701c345a4407ff8e632d1a7816632ae76c3490b713ac84e7231cd66377505fc112eb380e1a554c2fc67b90ecc272dd3a6c3bb472568ecf6689a9e4b0e368d17c8cfae6641c0df474d09a4a17461c164dc72a3683e49eb996c6521d435761bef71e72d80abb751004dd9c8de34738628cb35a30bda99ab46c8402da6e6ad50e3bf814f649351a1f3a684d44a6ec835a0b16e6dad10d68651607fc697a54d1e90eadac8ea060cc5c3950ce5a034a87d6e91bec73b65f70840e4ec69c361a19d7e058ced948c32e25ddfa1b688f95e8770097768cdf2d5f89d2e58e47517a17d3a0a4c665aa03ebe9dfed395895d981313d0792e580264d1fbecadf39949cdc414b5afaacf3f8e25ebc2a76d0a5d38178f170c8293c4874a498ae45ba03b16b9baa031de2a6fba3410df5352df21e3463b4ac7bc73e836e02aba758fd70ebb01e35c1bf6e3ca31d7eecc03ed5e35953d70ca04cd2391939ca92ec70315d3fda738019a4cd070e7d7abd4347706d1d0305f1ba9a6006870ed6affa30ea2045dc78bda223da7735ed4d1b1fa909ce015676e0558fa57a81324c4ae83ad4abc6a16f50b1b4f2ea75d0d0dd26bc51f389d6e563ce5bc9de6dbade6148bc9ae9eff85ec5dcb6d631e437aaba7a3ea063dc2a1585591cc51ae803e669711dd545919ef1ac64a89784c5f9b35991eea0bf1b9a7c59ed65c7c88332497372237cb7ff10c182fda19b336eb5bfeda163a0ef2957dd93e3d1bb7574917ba5adf334ebc7771daca7125a0dc79e36370ef1b9ef7c1069cba478bd0d4ece1c606934c4aa1d54aca26f87d3a2e131aa1d4a0e8a95c64befc881fe2cbb1e476bdd05c373081ec4cc2928f84a5c407db371d4d7b5177971565c313e0ca39346d4c54ddf941bb989182a810eebaedaaac9098de133a40bb4751e8876f086516b28404826d0840e45acc3ba29b62ad3d805e803185c4262a53467727b0295ef9dc1331f3074870001cdf47c55a12c61940ded2282fac7c43c70e50055a53a71f1ee906b5d5247385a2f35851e481ae1d975adb260581842278d685b3b3ca61828398ec68c77e5dda1a4a15fd539e56013f8c4e6dd7926b62517c65cf891c1192a264fa8eb886a1e0ce4944144efa97f377d6318704e1daa3806167b24c589fb052b141f92ce296617cc90c428126a4002361c28e82f05e33ce7a599fe1ddfa177aab5e34c32efc0ccfa98f83098bb448fc4f456294f58b2a38a6b1cef39ac2f40860f661b27e7a95a2f37471cd19f81753df8afd33b67058defd56f50594757200daa18ee0fd5516a1dd90ea75589c571aad859e59f1c354e63b03aec0136ac3871fce886b19ca8351d67cc961083a3652967876f378cda43814662909323b40b3b7ef9c647691ff953b6030c0604a72a40b05142433e35b06b9cc1da74f13426548935a47770ff522252ed52c800592261b5a84eb3704102da1b26a1b940965c79d041a002ff72cd5caeabef4d4479ae1d9fab05501836a2eb685e17c1eff51a68727b80ff1e7104e8da0db1c24f3664d3bd07daad0f020cfed1263f64b2c49b1da24286ca2e211b1de53b37b99426b192a0a20b338455af31f1fc8b581265a0e4b8d43bf60005977b96f62a75e31461d2619d5356f198978ec0c80b9a809bcc8a036d1a698d7d73329515a1036f3e04b98d080daca95fdb33c3a2f3dfe3773279925b1e9f7fb43cf030aec9919b16da12062733fe310540995ef0a80f871c19e2a710495ca9106432aa49ac6f829647ce6317c17d3a99e24723d8eba10c6d2376e172f91f24a91ad87beb883b30c5a7649413c1092c3966055319292711c4551fa2239ddb46917a1b3105c78bbd6a8ec034af41b5dc1a6fdaa26b6c0a23a4a8b05830e5078afca689dc70faaf13794e359e16c26a24be70fe1900ceb8105137edf871da4982043bde464e53562813cf081484216df00a35417cd41c7e53ce8f327d5cfb100885b712c306ba978553c81806dff047900ee4968bedbd7a79ceb072d5cdebac96458a5b8883cf8dc91ad7b308c9893b702d5d4f247b14f17741b799e1aef7bc2ea4837270e9b07ec07e4f77cf6d4adfc170d6b75f83f79d9d85cf725a9779320a3f28d0538218568a0e822c3fe07ac4b0de33602f6563ed56f6543b9924576543ed4825c67762fa4643e4e58656d3a97cc071e362b0df626e6ffc25221bd3742d59122105a82dcce5243c2b8dd895c33e71d403f68f79e95aabac054f9e2b8d13aae178518684e3078e2aaeb27177888bf5914af5587db67af17df13e94e4ffb3ec118b12978738d4a6ccdbf6c3824294c5facfb75dea38bea992013a3bf3fbcef87ac4a1fa51d0553ce957cb26fb03cb007e13dd0e50c68fe34ef359c15d06828adc9dd714ff58afc3d54e3b6465e0f021eb223b90557760bb56fbd4b4e320808c2b4c9891d8f9c9c648fdb0e34975f8e7ac52ff3d126038e21cef454d6c36fec8e1f55f4439653d0ac6974e83c819f589d6b463d17d5d72a8a1cf4294db576e95d76712ab12712da0d3533e47a818e99fe460072565e3436450a350e336f6a4edaaf8c976c20aaafb7fc3c7931b64e12803b49dc4a511d4fd851a1b5c838bab178ffe5afd5a7de8768295210d526ce572e2a7f8f4e753be6026384e003751f2cd09a6bdf6e94163d2e50cc0604ea0d1686040d2e755465d63964a8244b8607f5936923e0329199e5e0844db3a3368c101a2259ed064f439260c7e2f263d456828bc709b8153f0184311f1287f0c21d8914eb09d51b69269047d8d9e3eb4719a4b3a34eab8696f81389c36a7e82e7ed6e1ba77ca5520d0f244f571b915cbbc85c31dc4eb7c44bc29403ec74470b2c2985f6e8ab1989511f25b14a36c8ce5e907b2f66938c64fb163a053d1e76589a30492c45691bf405d59c942639a9367caf9682c14e48eca64938c711049780d011ea7fb032ac14717d34fb1fabfd8c88e3e7d1b1c3f097caa4dd2e1d74340c06b5e308c0964e9122b877cd987e0fbff30287c948d7a894c4461073bfc31ac0ef59967e00dffa60cfa43333cff782d04985cfee87320a6fe40e72c83c0b0f83b44582dcdb00cf56046e62ae1bcaf2d4a9568dc639c25b623860a7b8b951ff521f94b3250d407ba06d6a61b17f033d4c1cb8ab583336e7fd6f79b5e0b7a3231670ac26487390a3c904a29f5d077b5def295dcc876ebbfe86bcdf7c10829e82da3ff6762b61f5afa0a3b58e8bb3c4f3ebc56eddf8c7242ec1282494461cdde5c119c5b8f9c3e9733ad89b4f71a178ce9e582e46311227972bb3e815bd39a734fad63192027dc8efa79973353d7499fa91521f5ef2301a9cb9e434d27e0fb90569be09729407c4750b715069619e3fbc11e6dc795a1487307991be4cd1390c97e8871f4f0a055b1865d68be5391b8352adbbb829cd7eaafe1cebaf0f5b71083a48404cdb84633d911079d372a4b6308650861afe755b7a248434df5bca20bba5c89af81111ab06137643a600ba0160088f56770a6a6b63518d61d5ba425640cc7bed889c27ed87f37d9667e129e2e7d8470fd1ef1313c5d7d58f6238fdba4b204d7a791db8a69de199a8658d0bed998b874b7599b380ac25b119578dfed3525c57a9ea1c46bb4d26167125472fdf40264bb7b37973c9ce2a76019ef14e3f70f2ef74c9189fbc2821e9620f170b0a0d32c2ec7344ca7ebde76291b5e5dde77ae10bbfee902ba83a4a5e6767c55cbac9c7a76d90a5f19f875bf9f29341da74723721e5f92c475cd8742871e40a7c121c19e63d2594cdccac328f8cf6eaae57f467189ef01470618b2e3e3325032d7ee98a5492a04f4877f5946b3c6d72138280205ef2260f90390388841c7f233af5eddc51ac37a5663113191c1a17564f348e1a2cd8a4828590b73723944e24f37f78b9187552e2d926d712617bb6a1779f35c3f34fd3a8f6918c8c2b9f389e41fd07e6f0acdc745f2b137213c0ee5e811e8b057ab59736f9c71ef7b47ab7124036e63088b2b73e46f9771d844b46f947537275d13296d626149ef65d868caf34e69dc6d23ee0041080b8d78b0acec813a37a13f3751d16770b0ad6ea2f4a900b7c8a98af00638dc746f1bc20df4ea91f1fc46b18b6471b3316051f586c998e8991140f93bfd40a3a8fa6103579e379cedbb3dd711dbe756ee25936d100985d7e22161f0c5358c17758939e4d019430fbc52c7cacb31adb4078727cdc408e73d3946a42b10f6e657b01f7bda36bada54a2e84c2ac1aeff6fa7b774becfbe238ff2449b96c3d43d9222d7759568472bc945d120639df18fa1f110e29291a8d8f7500ead811a581c477b96d4c82fa34cc26ea88a05c938b9f0f53be51208298d4041c0cb650aec110918a1312a510fb362a1cd71e6ed478771302d84fa413bfd0d3ccbafb7d21587c40b50bdd871d62a04e726a09b6e7605dd7c2b537c6c9190b9fcff82eec520933643556800a71abb0348d4bdbb9d985d30ce053c916834292ed2e156ad66eb3904ad5a919af0ec544d7350f3af10b088a0a00db7bd4ba0b0862d88e699d3480e8f620256a7c3e6058721f19fba93b6ee8465b6ebf732ddf65c87c5604de079978923dd13ece0e487d8538bdf77da6b3ae4bee0b2fdb0ab65a4866003bce6d6f9777e4a5aafabe8f1e31dcddff808fbe42416e3270cc54822da485be9cd2e01bd42c4ccc0840dc7528b1483db0cd0200d908413ef34b9bfb1ca3e0cfd7d460704982f18bf3e318a3f78cf50f23d41a5d56f6c58b73e24ca2c80bfc4c381714b24b9999576ef46664f855124019266b139ae867f2629132c8146f98757f9366407030817eecfa9a2c15ecfb1854612d5012d64e97c4c6c913564a665eef46fd321afa0a04c5879acd978d2bafa44f027442fc02286fcac98980c83815ec45ccadd6b314c206250a095ccfc212189c7e8c1efefef0715a6c9e69f92c2b7d07cfb5ee8c096aa728b4b5a10764ffff32d98ce7963b87f7689b0cc363d2e2d7c86427f90db1e9ae586f5ec4aa10c899e3bcb83dd01304d4ede0e05a39485aced4cf7f5dc0d67c1cd9a7c16edd9e8f7779517163cca9bc7e5dedc41c178a34c0cf006c68e14d3bd08181fb9a0c5716c415e5e2507a6bc75e3658c55244895d65bdd5ece1a1b9bdf26aea15e2bdfa9c8db0805b077e0b8ae131adddab0517b60b829ec87f179f1e1ef21befe2f0e14adedbcd7fdf1c0af0cf95b1099c0d9b030f32d1f0eeb6d26c385f01507388c7ddec1cb7cbcce7fed4a1c5280e7f22cb55c6fc93753f2130e18b1069ba2c4d4e1a585e43ca5047cb06cf52657fa23119e830b73e19fdc5e3244d4cb768d1bf235faaa7d80f7619cded04f736e9fd6c3d8d61a78818f37d3703cbd4e3f953cff10029310749e2a5e1c975f33961ded99465ed06cf2f2f373821ae54b8785cf25f531656c0406a465ce5d19a02492dbb1d1e6136433763873ecef4a276aac4ce43b8333a9b7901c1726e4c394702341296ee228d619bef7b3342eea6f1b0a1bb3296b7b21fc1d5089c9abdf45b37ac0b619fd1ba73ed48ad27a22da1b3052570114fc311d3ef7f271e1147249954fae96119aa56202f670191ff5e9d7e17aceb7267e482ac81f270c58daa4c47399f3fa2bfa0133f6e3865fb2ca54a3711512aac342b828e3c8aa263151d6e2a30a9ad3764b433e430f2caa691fb557d70416af4d360d58cb8ce85d05b4e470bc4ad61b8401552c5ea32058d58ece65c3943f1ce36413ca8cc90e9712a396b1ef59d51090881bdcc90b96e8efec119a93cf67231767db4c93444016d1ab563df82e72fcddb8fc547be3f6ad61a7b96341b3e0c751921a87cc0ee95e5aad8d3f96403021cef0a1b2bd4826c77d69619d3db768790b943200815d356a7340a134ef6edad09408042e663f701c36b3b52ab7deaa5e38d342dba417d457150e28dc5867e9ff3ac22abd7718badf45110cd53805deda4994b221ee9370fff223df3cff1aa47afa5f778fafa444631ab41623cdc71f9ab47be780d3415d73523af2d38d7f3e47cf881ae1ecae1c4edca2e84037bae5e4ea8f3147acef1a445c160e19b42d112d1390c58a12061f27e56a55f08aa5cd14a78a67eaa7909d56da71c33c7ad9cf8f2dab2662317fc78c738b165e1f6f964a762cab2ea21e6d582c732e7d225cd02e54c0c9b36ed7b3b82db07948684e6bce5a8eb224dfa6514e602f9fc85071119ebafe3e23c16a9bd23e949705f3d1156edfcdc4a7c2d630c9d3645568196c8832295d42bbcec7d36d501eb63956f621da802543039edbe16da44752c95e03519241eb17588cfe11b684f4ed24db02a3ed620056d5dea6521a569ffdef2b7355fe94b13eed4ef8a5b5ebcb4c7a10d126110727375768ab40a7112c5003995d05a3a1a123b60327b1b3931adfab7e4275928a6266c38f2dac28eb5ee31ef429d523070d9d3a5234c21aa17571790e029007c0b9551896d380e2026dfb0ef4b1dd46dcc8cd2291653b38da9fdccc747fc66bd6d246320b34150121f7bb0b9a4453782ed0eb5574a8c1d6cbdce5f6ce429d6804062ef69de897be74e68e1fcc6012141954c165768ee5128ba2c82b2ab2385d8250d702bf5e6f7119e58d5d0647028f0803ba96ec544402ce90f840d5ad79a1fb5fc1efa491910fb764208cb59b894b4615534a495440c725fde3f736fd72a358761a5446f6faf4e16cceaa0cee6a3410a6d0db6bccca1022c8623118be64c3b2f5caf0f4d59a69a8768883d10ef575ebe6ca40684baf7027f609f3da88c1867a1b9b56908e7f52d69127b39e96f7b7eee2d3b4d1966b998817654fe0df3ffd24dc09f423c832f70e25be83017a289f3326e69de199cecf67fe83d2d7f4f3ff1d33d84822b08b5640e48f2eefde152a8f243f7d131f360b0ee2e53ad8bb3492df5b9cc9e89059d7c98774228f7f52293e2f41dda556678d770550141c30a21be55d0fdd53aa9cb210bd1e417e3199677b044c0b3a6d48e662875e68b767633808d0d58f6eb9d729e817bb5c40081a67f37990247432705064e66ad0342dc1af96d5ba32b6a125467b9c757c4064c01d73a979014788000c7f8d8f0178e2b1f845377e0912682d4ab76ac532b8177d01c805c37442acaee096e37d301c665921a6385409870302e500e12306895fa7cc423501166314879bfc9dbee0e710c54a507c797903d491fa41ec4a2bf5a337d34a3441ff7544156fec5a4abad3fa23eb13f9381e18ea2ee37059c96c17d36aad371442c18b8da690b7be8233970baf00f061aedfa54448400f28cbe1e75ba6d0ee61f942cf7b31b5c9c4206444d3cd8044e9a2069697e6e092450380811f744616207c59ff0752b50b615fabe09ec4c476f28812a01afe8ea7a48e07c882a407fc616123d67110330783692043c4c319e5620d613321c20b94aa4227ec38ea510002fff1227e5f2ba7b0fb902be6ead38c4064b2026f409e5e035d812786b9e07ffd6ab2d8359db2aa1f56d820578b7eb8ba036bf954e0e1d9c34c52173b6715f05e9e179ce442eb05ca127e7f700afb37411b12055aed420dc8b1936d0629dbf10904f1800fdec4a09d3384ecc20342c1b4c1a990b7f941035a373fcb7c584812a7322565961edc797b0f3dbebad19ff32c5dce9c32a9a9212c7c3db9e8372f9ac3620247797b80c71b258897d41a4c5f208d5d460f32b2bdc965b95afcf7387b2474272afc800dbd1a6b41ca3b9569a710dbcf068c4903e79bfd7a34569f6191e4464eceff35e93ab438774632e67f42b4d38b581b92a622b20f8ca823665ce3ffc1b224f13a6b11bc95c5c6574a7722b80904964d105f65448011f283c30bde90eed0b1d88d165cb1262a969b05060abd1fff425f42b741b96a8b9cc75ea473521c023f19124d5aabe48891297ff23856b71cff4fd39406bc559bcd1c0edb2d2862fa44ead6cd3ed3917737bec5674bcfe2350102c31d1f0bafb8d7adacddef748d1fb52956ec4baa187cc74aff51fbe6a599a92f29fbe15367f9198f62a41b452a584a1aeba2e5f8ce1f1b6cbbb934de425e7675e069f7584b100f316e08d58143d55e44c842b83e58cbd99599b92be0589014a0815cd0e6db42b69d465551389ad3f2194d2c0c1f3a8e122ccd94a8d730bfa9fb474761c73032408d731abb13be016309aa04179e853fa741cf9648b64fddabec12d0e44fbb02000289e81ed046ee670530c2a19402a947c88800dd276be738cb8df8eeae79961010ab00f6e8d4917f2d14b4507a40109b49f5929e5ecc2b30b333979f57345d3f0cf5909d124993e0a6eee2371bf8f08c515d08de9100b0372cb6e89d60eb755a84d8e72f4095ef09806cadbdae8f4cf08cfa2a02d579f616d8e846d80cb0feb93c242cb51ac2fef19c16fbc7f58dffad9f3d49f14d87f360cac5d5e300fa5fce0852af9e1fede8b205db15afad1fb921daca023ad2a80791d48f008128f26125f465c19dd1f3c80055307b3684d5f1ac72e3f6c9ec777cf7ffe3c58a00012d37cd9dda0aa3c5af342cc030c25f2ca7eb9fb63f44f32a43beab554357f824801a15ae1d9383e234c644655a55499d640dbd7bcdaa23600cf391f378fa4c0bad5812e834c459f72e3eee3bb4650e705faec7303419b304833102c845f62ccf2eb74377f2d2dcaa93aa1327d16473c7ead9b3ebfd14286ff9f24f07e27cdb3d4d7863477a11e33c6b5b800658ac6383d97fc5e04edf0680b67f019afa660a7e6ff0e691ea6d1feec99394e0d47a1a1733a92e6c6eccf9f8f15ca05564bb35e67110ea7ffbe7f0fe142a421d372c58a89443e4a63c0621a5e74623d93639afb25990bb291a5423926661953b66059c5e4f7a6b89a322b7824eeb858a7a5a438b03a1ceaca61cb8c93640d22729e1936e4c39510c6873baeffa683dae34831ceb892fe080d63094464427478fc96f5268ea00a8d81456be9b91f6e4028140b81f7d3a94de48be71a51df6f9592660f08f76c327ee1b740d4669b711a8012cdda722086cbe9aad53b6928de268d5e233bc7754573cec36a3236a673b43cf1792c63a88dd40d504fd922a4a9f4a39126ddb89e543115dfd0b217b864fb44ba4682c813202f41867437125514d2c41f425cfe02e185ab7f077541ddef3a18e87e86978991d784a650a09f5f8d8a4f8011248c30b540c59f4129690d196692fd1a52db2c1ab55731d5ca7ad6a2214598d48f647e0c18b48ef61f5caae900c64d50cdba2bceae519f6d45ee2d34ecb4ee263bd8d90c11b430157d04644f63b13abe3c6b39d8d857698cef35841afefd1d4a6d1468068213600e63258dccf4da3cde6c48e6b1ef33db252632f61db88b23fe8f45ce7bd0a2c68a5df397c3001238ab42de4d289952d794101d2817ef8f0474386866e3ae28b774f264180b902e6e96de4c89af1f1afca15ea25b57721a956364ab7c4d6cb1d08de976ebdec8d44818d11c55327dc6825fef77613d65fd26a48b50f96faf13d32970d129b269ff8d6e84868908d88aed9a092731791e5048237312b8730036cb9a20207900967ead15386aac331cfef69aba2c4b52d48fd4cc9783669ba168a7653513beb25d92c90051d47d6c1a8a986ad73f684b5f4198a11193478f504d31b11205345b41c0443dd74078b1cac8e4603677c600324b9da26f0dd5d7fedc65bb9247cdb86bdf4d741684d9cbd55e86242cda432e54e284f298140433b4486982e90b58facc9bd0ac27bf90a2b7b5cfef904782f3900ea5f3b4a64feca7b1ca52d97d43f248dbd4236800bd28dccc9330fe7ebc8adb94861860ad8d60bfdc00b68b1a8c2d807741c05c8b0c3593319f0b5345fe9840081d93ea555f35686b44afc381bd661074e9389aede837611bc16f2c21041cc0e31de39cb9364d3ba0439984521848214f74a39c24e75ca60754a31026f4bb3fe6f56c3ba0f7efc6a6110ebf7997c5a8390e45f04d8473b85455bd383528f4d4c96e088630e027c042bb1f5dc1a584eba9de2af205e630d42296bf0a048f3bb717da133f9d94f60afe49fc446043e2a915e7f33ee62e5edc2344643958d12082e46022c9872d8094f974adb21937eacd1679e6698adc61858b94d6c34baa9326f8d619f6c9d1755d4ea52526bac6751550e9509860883e5c6c51f08a1fe064c060443254bdefb33252d5b9353e7345ef224a13220ec91f2190a9eefbe1110784b280e46611d83d23ee14b07820872ce4d18abd3f4bfa2313a5d8c2e67509ff1789209c3c453c81b83dd6a2e04ade6bb4848c98a18fdf93718e4786e181dda8be171f013f0edd71caede40c5ac11774bf169a9b30051e12b65759813d0ff68310e22dc3669cae226c006f4d11c1071cf8217e4c45044036e0064cc086ea00015d8bc84965df4d6ca602ac76c0eec3157c9d54e0567d6137bc1d2f50a01f6032682a5692f9b458b584962fa1b746be284ef6970b268abb902d01edcf364fe04f87e7027b269a0fdfcf8a405f97047405976e984f04309c847e38bc9912532b869a9e04732a1555ab0996ba4a0e48fd43762d260029a03c2ea7e1ffe31df7764c65062a4b092c72fe9d21670007fef30c68609cb872b2162772b43460c96106fc0796d1aaa6fcc6ab28333b5c3ae5c1acba7054da3aee3d604c0806a359480b0f726f003345b614560293b9fbbc9152c8b543a9d09c1b53156597389676590ab0078e75a312255481c37960ccee60bfc7a9c66a4c73bd5e60d044e5a6b890a9e9f4fee5d71e6ffc3d00513987462513b386f400a3da3029c87a372a57e7fd5b77ca3e436c1ff524b9d0121e66b0554d96411ea6426cc5f45328809c20898bb3a8438aee33ae0c7b53ac820f2331f42151f4974eac41bf48ae0fbf939fdeb477af6741166bc9b17d6ecf5a079e5da3c61f4a1c7eb73c2b295137b83016840f7f788ceefd2d1ee2ae87f6e733908032f8605751a04312628392930833394ae372dfb688128773b9c2143506e12568fd366036344194125d1a6a8ac32b2fbde6aaa36038bb35fde9f6ac494be1cf86be1336a1178b5919a303b251524bb1471865623563bd9e117833b1a92b64fb413747af900f270b8e95104018034b774257cc667c717c4fee2fb511320f450b27072b358cff5fd2f930bdb68512587a5ff68bdbce3ef3335165f80610c5a58d6fcfc417b13fbf3ffac1420bf5731e0904d210e442cf05a601b3d4b2a7bfd8f6571a5d3cec5c46567b9b636265bc2ebbf4201dc18b1b24933b1e66c0040295280ab2acdd8e85d5e21e144b879d89c98c0ba84f01d35646e595a27dcac642c7ba217b77e9bee796045fcafbcba58018327ff6b878f056d63d353aea94c7b85e409cd2e56defabca03dd31844565ff3212c1d1a89c54933dc4b80e757c8b31f39237390e984a2be116ed1ace6af21425a200cb58e90672629a26e5c2c6b3b961d84a4177e2d18dcbb5bbc97812cac538afe376e10877d40bb3280817651681a8e92b37eea808032a9d3c1e414df353c39205012234ce1312c8ef281a0e01dc26b1ec44283fe9ac27a29d502a457f505157b0f816db2b89a525fca6f620bdbdf08457eb9d62af9e05280e66384c82575f0787901036ace8bfc7ff48351a8e0d977cd7bdd6983e64871322f40c324f028c4eff3e8286ce7f41d7f44ef26c71fd181fee1c21eb7cd15b9a050608a701aa9778f9859dc8f1b43140e241159cbfbf5b3288f86508fa0f272b60105879f56ca70772ef6f044fcdf94a42fc2ec0a9f46d1d1fd02afee498643a58e9045baf6b5e2fc57c84208b61628d65ec0cf6e1e922ed86f3e504eb16250dd3772f02c7147183311954f428f0b57323d6d4e54c312f042f722496b76909774a384dda077a5682516910e99632aecd5f42ae79faa4fe149e3a1c7a0d6e7ea657c53861ac8e4b6b6e1c624e5b908bb1810d58e90205974aa4b8555cc81f84eb9134307f660dba8ca191aaa9b0ab035759db7e21629e4910ddffe545cb362616a0eed820b9caf85ccc6af1cae5102cfca5945100530af8741285006cfc3411ee6544b73f8e72b028d0511975adb4c2e113300f52057a8dead889114edc29c8852b55bcde5d8aaa68de19f1e32a4779cf79365f1b3a6e68cb037f9122b58f3ef62a55c1d17ede043a09ce065b4a7b0876192a608851ae201ae4e6d2fbc4915ed0cbb4420a6ba24032811cf108684f0fabe0df2c5f398ec08f8975abc90c507fa75dbbc689f4f283f703c31040591a27ee6bd1a6a915b37a55e92d141746abc30324dfcf7ee033d366e438b6e514bf1b1eb16a842c004f7b6689db6c1510b0ab5c652b82292f0ee4c6edbe53c1369e05c37491cd86822d477994b185cb06531a7f6046c647fe2bbeae11f489326c93ab35598c581f75ada1055e0942d698646005ed52bf39fdf8f7307b977206e4902285a3c3c454f89ec83c5a091c5b7a397961e1a649ce98da5c213033e5d82d0a01fc10e23cf5b28af204e486b79f1dac10176c0a0524fbe0ef89a0434e26fdd6268b27a0c30f71486ba1f13956bdce9bc25ac0815668c13d833d012bbb829fc66168234958c3138ea46d6ed835fb03d64f2471041ed090a324fca0cd7eae525faad717f1801cd5a24c50fd06221c7bb11a8af78de9f822942224936a85d43572ae1e0073927b5ccceb9d81e5fa9ed8ecb7beb2892d147371c926a2d49fd8bdde71b31c75aade525042dba2a96bde5f83d30ee4269a26f54e9fa850ae8e5464bda1c94aa0e1e0c80236a03a2aae514ed4b40289e3f7c7791eb3573ae49400b907e0b6cd7e3326186c279ba81e4048d29cbeb5697d4ab2ca08b6a34f5147460ebc9ec8690630721701bf640e7ed01752a380c20585500d623b19051c6986b001f6be5645faa70be2e9d0fdfa6de290e69d2bb870d427eda4daccfe9802690e45506d9cd95af0e4c473d23965d1d267debac5c475d4f56ec99c908b297e1aa4cd8351adb1f426ed08528b6d3ec0ed3f39afc728648cc57f0752d528a20e6b64d55d5b989dd2de2a5f2789efa34c817ff9640e86a0d20ae7ca58e7c8b4ecd135492648a5a54484ac5d5bad2e4b1e98c7e7315d0b0154efb223082c6f30885356b5e02aeff22083b94017cfa178300445e8152f1c079e23f49e0e3d9acd48836468af0ae80b6cf7e0bd0584ec7d4567e993b018d0a084bfe94206b2860da8c0db0d5db78e4eaa68a830c0377b31f0ceec2820d146255c03d37d561ada28291e50a32aa6e202dc9a3a704fa2ca9a25e2edfa26b48238fb05a81103bc485d9ebe19330439c921eb1f9c71b65ab2ca5809a02122401128f23ec310533ff9171615cdbb175ee5fa6b8af98e862318be8e9c7be5b0548925faff9d3db64a022efcc1e3bce12eb983ff024d1748e259403d4e3185285c702322d6307ea92032c4af3a9005eeb139449175ea8774ba0dcf89992b75cec55b5ae875f09e300da572c798ba7e0fced8af448f4dbbf75196c662f836e689f0a9e419f1c033f88182deeb7049b0f81e52012b61cf2819867e8606f803424d7daaf71021538d53f4d8620a31cea9bc1f7bf87a8037d620b17e0e7b71576327ee6623033c8f32dfca3c7010b4a0fcbfb179f45619f4242717a64f92d2ae08e716842c07a348c7fce318c9ceb41b9971ab70a7629a26e32dcf2ecd7b8622f5aecea123cf22ce99c0935bd05bd6e0d3e0ca350cafaa846584956a6342f18b03e9205049ad2ddc5863d93e4b2af4b2e10a134a72cae81632515f07ecfa68e45072aad23c61a62ba258f592ad2125d35f42b015b1cd9ca639cf31e11ce238296dbb6575f80af99c623c01e3fd6da40e2694fe50acbc44048dae7d1f6c47d6568f27e51e49d949aee23e9a5a61664cc8add9a468c990c9ebdf79244fce953bfc58188591ac8153a2168274f32f1c64b088b2611ea2474e25cbd27e11fe80fd7f6464d153aff744370c4cb2d5d7183f87bb066af17c6c0bee12ace5441db7de58246bd218e0b44936ce9ee3b571d8ef272c0d8dd7240c2fab6b224409b3ba598373863de17d3aea882c21f979f78ceeccefd2f2a19f018491976a50effc8dfeec48d13061e8ae596d0c7b71addd4008c1810ee13ea4bd6488aae8010c1decc79be3d220d62ade2b7f02b11688efae76d08e3a37eba8c0ba06a4767ed561f6aaea5761c6c299f7514d0cdd2ee3de4a8de04d0bac121bea19d4792a31b7138b81083e3957874bc8861c79b891717d27d043f7b72688ad16a1749dfda95e29b134f5e4fdca351983e730f6bdc01a4a7907c169250e06ab25e28d838712e85c8ba62e6054ceb492bd2c302f6ec79c561240bfe792642ef917b75e0ceb20cd423cb9e5c782c2a6fc6069ad7ae5efd9a3e0a5648e12e27d2b58b61ca6f722a55f83e8a3ef89fd7b97428b562a046593674e4c4722bc08739adc4eeba31af0c76b93cbf00fb24c59ce536484c7e80de55b947f77338eeab176499aeeb73257162bfc781123ed78580dafaf5741a4290b4b67176bd8262f84854ca60492c34726ddec17ea6d3c872262b66cb3f1b3cac40460925e49ac52655cc52d0654619e2c53490bfe370fc8cbae63372c04fc179f16f3ddb8f4c119bd382ce930caa7d47dba6f380df61db9a2f6f5703a0a0b0a64431d20a9cf32b92de5f061bb37e54627522fd48f5ecb319358f7297b2fb6395c7ee32e563023d48eb01736abbfd0cb96bfcee784f45332e74acfdfd9f8d8881ca9e58bfbfff53f28f5ed0741ed3d17df5263e01c2e437ec49af192cd4efa7fece01e22e58ec6c8f9efd5c800e3d2166d30cbd42a9cadd7d4e61918a7aa341cc2ad7fa7db93614ecf3eed4c0fbced75aed9b854f80bf9730d8d89248c1305581cf9888162e16801119025d1974a27cb4506d07c19039a3407db5135157aca7d15dec691107d0149f802b3f402ce9354d13a9a06960fe21049fb4a3cd70332456c78cd762a94a050ff6b8c5188a90fc8fbfeff254a3b6e72636160093622a9d306073af2fcd211cfcc38d8e35bb268224814abd97d54b93ed6498eae0019d50301326d06896c5cecb7614f15792a86ebae15fe3405407bc3064b51e802e4e408e641d18f0382cbe772dbbd31743a050d131ff212a0a43e8259f58cf00a4fbd7704fc2bb5f8136568a049e2cdb18205461a002af26a7c91aaa4c4a8bde9645fcc0892b3038058475ca4638b41c282caa6c23be4488b17f75a7cde20154909ecac080f623a8ff683fc2de0169484e0b70c669b437253feb0584d64e2bc0673792c713d57e05413fa09d31ca1dfd1b3d8d7f187eea102ba6bf8d742f520e60b5ede1092c4151d5ef06c1842e7cdb1f525a4cacdadc84f6c9446ca3887536716c9d9490fba3fe585ade4ae86bc5f9656cadce56902577823e6f9f50a11b9ea7ec2ecb132feb5475525b213594b1ba17ced4418e47379ad8018a9646fda0422b0b30174eaca8396bba195d64e9ac918d94f381eda56c86476ba4794030b535175df58fd92a7ff2b63483da3973558faceb0045048336adfac093d32d5cd9a2e41f39f99d2b0449cd90735447333574116010f84468e93afeb240a7e370b4d6edcab84281681ec3b707c4cc0b4f5af5d32085c54bd892a73d3d9a513baa575ace37b4960baeb5ef136a67c648a5c6c528dcaf50de969661971d6468fad5a38436673e479f902786a7d358de7244bf4e8cc5e22a31a91fce8d03adb1361b84e0bdb4afeb32b706d5678e4e52634bbb209f6a9515e22d402173ccbc419d206356d49a7ad5e8ab953b6a518591113e60e2529e39629a63513ff2ccf1a60623172a06b790b14c08187ffcf844e9b98e28bb5c5f98314a2b7940f4fc3c91117b25acb2678dd8261453bbb7ede6bdfb9988afa35b3290153434d087bbd2096d7607f6a67239787c8ff8a213d149eac26b9e148b4a1fc44a3780525e91f419629989a25ed30210ee3c59023aa6ef9fdab82359dc71912424836119750abaf51f9358a3f570827ce00343a2aa0b8828de94da97c1cbb95ba6bffd2f788789e3f7f6c939bf274fbf2a73f30fa6bb821321fba93c12a73e426486aff694e43c05c0d7a925552589a88a6672c84d18fcd7efa19b464acaf3195481ec79d55954ec8d4724896822b801069455d33eef0bd320dc70d52aaf7055eb0eb006d34fa589c82005f4b39a9eb807e4be4729a8faeb927c013e09dd3157b2cc76b423bef73be066b4b3ed1af990d16b264b2c6026c7d8741a0fba4338e137e2605d376bfdc3e5f446d206a2ff810dbff5a261b38ce38acd3a47698cdc983a849fe3ff8c447bcad8165726274032a9cd699e3d12e39916642725191719bc12307727d0edd30f8009b271028703876f17b17a6223c7e543864e5619ccb113c4efef05ac9c978a3c94d71e96945ae3199b53aa50228eff57d69dabce34ec38b8e562e2607e157748f6ff10aca254935ba3fdeff005e2e3fc7cb61b6801b343a6aa469be976c24b04b8a390c70c3e52bd2bfd2edb401e6191c225a00600c02bb27609dce740ac8eabb6fd5e1eee336f57f5ca43dec4ff69510d92ef36150d5913aa9ee7e3625ae3134fec8ac0bcbdaec508090dbcf8aa732c2d565618f8cf906b37be2755c7b1f7fbb8320915fb6d7d5a3b284131d0286316480f59f0820415acecdd4bc5b83ff1c0b3857d5dd01ee952fb508658fa8ccbe6444a8bc6c868c008056ca21a597fd4523ca5fd75da4a7e7ad00eac09a24c8527144b0716015d75cc6ad71cd7135039c475c97bfd129fd2a2c7786b3859f1caef8bdd5e1d599ebf53f9b67d7a0e46a8ff09b0e9142d286ae376f67767691bb1f89ede85045d52aa9f7bfa95ab075f4851f01e027a539ceadf50b982f9f7f4b45f6bc500fd1e4b8461d68c0f5696c8eefb1de04bfb07d75c4cef2f88b0c2728ccf56f8447a9a85a19e2eafa37c22bd3db9451f6fef7464a7292d799cd51421ca401fe2b55f56c7a1c14700a8d27fc5044095c6fba162369084fdc088b4827e270fe89be0cb471aee856a48f6af2d8ade558fa2bdd2c06c1c9011ba049a5a626bd37ecea1bb4cb6c03bb1d6b0304a3b851db259feee29e8cfd48e670082fb8a57f4deb5d46abc87827edd95bd0d70fca1523a351cf6a2046123104091ada7dd1c40e59411f221aab554d0630b1cbf266807b4b1e8474544ff00c3fc3c6f65d456434b13a41902359ab6f5d3cfd22696882ff94062cec8cdb8cddf244d8138b8f139cc469e19e7971b67f889dceeeeba7d8679ebe2b627b59a986e99b3ccd07c2be9573e338cd4febd0a230e5620609c7d373713b44f861d045f1e52aaf1596e22d2a3aefba97cc3ba4b925941114b1c2a451ea8bc32beb75c66659792951824a2e03c15466c42a7c22b92de25f1a162f046e658fb286f2be4f713b504c56b03855f8182a515ee04fa5dd2ee205d6e176b14a3de60787dccbde2a08281cb3153ce03ddeef49f8a5afdcb89cfb561cee3ce5f383e1b1fa08b51d8de9a3a974d53b201e6bd113a6e23fc12bfdabb3806ecde47f181195c4f006ae0a06e5d57b5e679a813c6720e2c004bcddba10ae33305a8a5ada45d42244498ddb30b2348406293e45cbc570a57bb0f2137f05c09183c5b824de491591b30ffdaa1aa6221ba725bbd0d9d08c9a35845f531cc65a76817b0579a8329eb0b607e5c4f0b647c94307a6310344a854503fdde538ccee5e9911b8985534560399e0141c71bfeebfda0e8faa5ffb85f10ca8d5a48b3f830f7a3989437b5cc52e6480074de84ce525d7a11e0b3478caba2bdac72e787613d1c8302305ab07c9dbf6fb4fd36349799f0afd783901b41e66bb4261e965c23fe3f376cd7279d42e3deb735c8c666a18d11d2d452a38a7ea482ae6ed258d403a7e12ebe0475b7a231c464648502de86e86317bb2d365201e90d16a7bbe60821f1784b7c31eff476a927ed52d739ab5ca1be1ef3a8b7502dc5b142aed58fb9e4968a6f27ed7f5402840fd6e294631ac36520b7dd9c557de8177003d5b04dd009e7191b968716c0a49f9316b321c08fa94128490b9b0c965ed243b112e3d2ced0c9f83b1c7f161b9321dc8f0af6a6ae0fda968d631b48ea99f3f0a67fc44b2f7caab38bee78097fd66f5571772d8e6251d281cb2460d925f6b7368dae17e5c2dd31df254c777e52974797b65f71f0ac376bac8fc0d0bbecad0236a690ee1258066fde656718edfc4bf40a7c7d2d6db61d878052aba98fb44b774fd3d248490ef7ee12a3b89e77d94103ffde4cc1ee32d0e76a689fed22b4c5d2de7dbe955b12a4049d23ada4cb6e7597b67a4de2b0bbca104b75fb79b2e16284a74922d98f076859bf5dcaac5c5cc630fae5458f8136e7b0d066abe24d68e3b6593c8a55f3000aa85054b8abda86985b28412d0b6af4c0cdf843e8940daab076ad392e706b35c65ce2f5eb7a1870d812db23c35ee7721a018a1230bc0db6e61e7714e62585621875e579409cbe61a3f0a61aeec638c90b2ad92f459ccf9dcf9447677f3f149ea2f9499825699ffc582e61aa43e1fd87e6022158f321fe1ec042b5abe86a70fc2098a8138312d81a88017dee06afd8aa69608e430f6e9628f59eeb414a5aa730601a5e7c0cc4fb65bd45d6dc4df06525615a8e21d0475369961badc54c204e639384ebfbd7d06564a0c6fcf6640708ed266b212c236512992d515388edd393264a61947e4265d1aca0c63d90e47c8c38f4404da4e7c22be031dfd7c9ef74a3839d64fb5fdbc5009e1e125cc1e37f02d1badca310c7e3942629214e6518b12973b16cd189899517f7154a7abc97f3dffb12f02bcb1b4bb3cd51d49a6473bbf49f8c98098b4c7831885b3025b567216926986e87fe30778259180c9ad750515ba38a11df9da53199645750744a96b36fd64ec27ccc9a81d2c7f1e57b97c75a203359ac06c109abea2cbe96d27c5f764e0afa5d5ddd3fce76007f801cab74b0d569a218fb86d72299fed52d2e591b1e3102b4b5624b3b8589744db806e7cc59eac7a9240436ecfe2020a6e9c4b2d465d8dbb60205918000ae62abcfb5d9aa6494acbf063c1d05adce57cf5ca770d1bb1b82afd595fadb3f6912c2f0eb443a17ebaf89df45241e50072011990796d9036d911104a6536820a40635f6b4b8c31a16b3b1ee7773375fa3d38282920f13e1578536164704a1f896f6f444cee54e64a7b7d6644548e6b4132f4f05d44e42212441e77d60762c0b5b4fe755fd1943bad603c79250539f0a94b9fe7500610666f6cd8472cea8a46428394018439224be4453e65093e78ea3ac75e42ae3aaeedf9e5b5da59ff9d170d9c3c1decd33938eb6ae4fab4bb0f7db7108c29cc985fe2e2e166675f4e87bd7b61a9e824bc426c0124a9081c1bda837bbce3b1f02d225cb2ee4498149017cfd393207b9b2325e4d175f0ca25082f721e1bcfd6528cc5af7eaf166cfcb2a57159bb2db1f9e929fc85a99ba52c899e3b4fd4c3c564cd6aa1892320514c044b635e7619ba327b769599ceb680644bcbfbd3b16bf933892d4e52802e9c1d99ef74cdf2e5174e6ed0dd45902fae781695e3050b2e206b34db45f8b53cb241a3777ea01ff242a084ebfa5b4d0470777a952f32bbeaa8e96d6494aa38e6ca27359aacf881f0eb48002a000084b189422879880f72c0f301b36030b3e55c2eb66106331d2dfc70f99ec1289dc29a54c3285068c066a0640fd09a35bc7dcf721694b13239f8eb94fc98490721da38854131317f44ccb3374c8a88a8eb9179bac2c4164583ff7a1ad8676ccfd094afbf23b16f531bae1968484a463ee41296e5f325ad2b1ff704a484b74ccbd97a9e4b7850a259d7b9e737929498a8eb9df3d2792958ebd86f9f4276cf0f9dce71fa80c0d6704680831201986e01c010d495d7ec7ca30430d528cd2501a8aa22850d1cc8a9b597133ebcc3ab3ceac33b5293bb44c0b91bf637fb4b88181162252bb152ef4eccec0dc1998ebbaaed2cc8f566fea4d5555751665bf385fc85e9c2f642fce17e78bf3c5f9c2e7c51067b5ac1cab65e5582dab65b5ac969564c563a52c1b2b65d958292b65a5ac9495b28ebed5cb8aad5e566cf5aeded5bb7a574bac2070b5ae70ab75855badab75b5aed6556d35c5b44257b415baa2add015ba4257e80a685574927157301977059371655c1957c695515afd8432aacc4d4695b9c9a832aa8c2aa3cacc64a28832a78c4ce69491c99c32a7cc2973caf8c80c8d316d4c2ea68dc9c5b4316d4c1bd3c624c55841c5a431b69834c61693c6a431694c1a2314739422df9818f9c6c4c8977cc9977cc9a598a04eae248e5c491cb9922bb9922b5923a7a446ed51b499ea04b88eb91f9bac63cd48c75eb4d5504b5228ed7864e8a6937e7cc03142277dee4d5a8a767f72c0c141bb9f7b50e3b4d2cf0f938eb9ffa8e8f78705a58eb9f7744ef5021a3af63d672a4a948eb9df309f2680e858ff4063588d8c3ace31a021ace878482a12294a655b28861c562084d59b7a5355559d45c930278c0ce68491c19c3027cc0973c2f8c00ce936d7e6dab66d93ac6c17a9cd456a7391ba485da42e848e380c0943c2c0c0c0c0901e4992244992244916edd8445b8d01669444a5cd5aaa0ce9d8eb266b4b15a39b18ac9ffb6cab9d5e241c166a9f43694f2f4e4f7b4b6299e26629e9e575117b795dc45ede97f7e57d795f965c04bdac2fb897f505f7b2beac2febcbfa527b99b2a56c37d5de50b15d9c92666150c2ee0bcc7d81b9aeeb2abdfce417f485f682bed05ed017f4057d415f805e8a76507991d4f773dfeddc5ef29ee8d0b17feda5acded49baaaaea2c8a569d2a99ea54c954a7ea549daa53e5a31afa1cf79c2c44241102cce70bc208a7043eb8cdb5b9b66ddbd6ca8e1f28d2cd0bd0ec92bad85c52179b4bea92baa42ea94b7af4b9f65d0c0824822304105e712b6e5dd7b53625b7a0b41694d682b6a02d680bda0254a4dd1698db02735dd7556af9d9ea4dbda9aaaacea270969345c672b2c8584e9693e56439597c5886bc36d7e6dab66d93ac7c3db5f5d4d6d39ef6b4a75de8087c7becedb1f77ddfa51e645a712b6e5dd7b536e59442692994964253680a4da129a0a2d04dc1dc14cc755d948b524afd8828157543a9a81b4a45a92815a5a266a82823ea44c950274a863a5127ea449d281fd4106a6cc7dcd88eb9b11ddbb11ddb3169b4921ad3d136a6a36d4cc7744c47a1f1a88bef1813df3126bee22bbee22b2e8d412ce22ae2c455c489abb88aabb88a35714a8b888a34111569222aa2222aa2229058e412ba222c744558e8866ee8866ea824fea84235bc856a780bd5500dd5500dd5282fe119cac23394856778866778863ee1908b36d7e6dab66d93acc09c52db29b59d848ec8f7147b4fb1f77ddfa55350cc8a5b71ebbaaeb52932269466426926d4849a50136a022a5ab926986b82b9aeeb2a997e58ea4dbda9aaaacea2bc004f50069ea00c3cc1133cc113f4018766bef6cb7ded97fbdaaffddaaffd923e2b9fe71a3ce6ef5a5eede2d8258677b8a9f5b5bcdac63724bb62d8832f088fe93df9c55adecfbf58cbd2e7423a1d97a01d4352241a74ec674610b47f211382e550a563ee5944ea57c30e1d73bfa2cd50bf63612ee01031fbdccb3459bb0c7094583ff731b6daa8748345ed734f42694d53dc4cd17eee616e495084923ef72ea4b8de510d1dfb179c52681453fadcaba8bcbcc80807c6737c09694acf694a62743383f373cf02f3491ac2e773df7fa04835f4739f8a0185466200fadca386a4631023a08efd28134acaa163ee452215e9660bda6c03c1096ab2823368b17eee4db69af83b1606178c6edcdae71e84d22201e998fbef96d4656084c343d2e7de93e222ddb4c0fddc739c52e802a399d2e77e5379915a783ff7dacb794ba3144624f0963ef7b9e74c3acfcf3d86f920fdf87cfebdf28b753adce3b4a07f3fd0dfb12fd43eff1dfb82d1cffef5c53ef7383d74ec5f1f3ac3fd5d0d102f10f5f43469429463216705952ca858d1d303650b2844c4624ec462ec0f177e2ce1b6c011e5724386e49672396c0e3d3852e88c04d3e0336181506181bcbf6381b8bf0392826ffa1d0ba43d40b8c15ca3c4394137f91b1a2c5faa0f7a1064f96ca37b93e7273e863678cc9c5c03f41d7bd0ab4816df2f3073ae5b02e8e95be77de29a972c90f5bffc07fd07b906e8416f82fed4820f822c90d9073fe843dd8d0808b1d6e54afbd508278ff2219c7c7cad7d0826afbd8fafc2dfa8d66b8fbe1b77d67f0c553104cb00546905a08a0d58f6e8da1898a0c22f51283aa2c602a52c10101338361c14ac5ffca0c721bd61e9dbe41a1a872270ff2180fbcf049e4e27af4d60fee9a61607bdc9a44f3deffc937fb28fde40c2ce26ec728d147883d2e7f91d7b43119fb5c1b63bf083fee7fb7cde9feec8ec43b0e500ad3b512c7b6c9d7fb0072c1eb768ad5bbcd6bac5e4b5d67b7b138b49b7dce061817c581cdabd7d0e0f0d3002a6960072e40fc8eebdee43104441edbf962e5f3b0471efd4470c04407fe36ddaa6fc23d700bf8dfd2b036d8c3d56730da25c43f4d8f3384ff457cef77c0e0f0d1a3444bf5baffe755e41850c8b691f669f0c7be51f5b8be597d1ecb10fbdc984fd67fa40ed4a618bdaefcfb4b72ef34f86ed57cf3ea0e7bd54d99d7ccabf52f0bab3942f1f6211f754ca87a9d6e7512d138b83fac38ffd87bf570a1bf4a24fb540eeba493712923a60fafca9c5bfeb26dd4848ea80f72ab95224a0c481502435b9ff077efe8555dcded0367264d7577a3eff78501c4bac82a0074710c0af1cb14c109c286edcc08962638373b379cd703ff7a1a7e61b566faaaaaa336651f08c73866cc6394336e39c71ce38679c337c660ce536d7e6dab66d93ac680e521b07a98d839483948394839403a1a3fd72107b3988bdeffb2e7110c457dc8a5bd775ad4df178501e1a0fca43e34179501e9407e501e229fa765c1ed88ecb03db7177dc1d77c7dd51e2f90177d49ddb8eba73db5177d41d7547dd99ed4431ed9c3bb29d7347b673ee9c3be7ceb9e3b3337492d1e664b43919ad8c56462ba3959164e5f313de5d8c095ee8d8736f12c1239a74ec41553f22a563ffb1c8161d44d0b1f76c7cccefd81f2178d2b1cf315553a874ec370d1e288e74ecb5006ea894603bf6f9831c444638b2d500d9e49e470d3dc8a09350c30c4ebaceaa83d35975703aabceaab3eaac3a359d293aa80e4d07d5a1e9a03aa80eaa83ea00e914e5b83ab01c570796e3e6b8396e8e9ba3a4f393a3e6dc72d49c5b8e9aa3e6a8396ace2c278ace2b23a6f3ca88e9bc3aafceabf3ea2cc9089291cab0c94865d864a4325219a98c5486908ca30838c0c58a11127d021280a902a9888ebd2ea1023055185de938a792ae0861856c72af422aa948ef395d24613b73ce9923cb3973643967ce9973e69c393e39433a461b2317a38d918bd1c66863b431da186d0c2b18867d68180a02fbfc40c11f8c706640318c3706e38dc17861bc305e182f8ca5a018690c5b8c34862d461a238d91c6486308c538da110342ba51011e92863af890e615b7e2d6755d6b53340c940603a5c14061a0305018280ca0a2edc280b93060aeebba4a307eb87a536faaaaaab3289eeb74c95ca74be63a5da7eb749d2e1fd7d0d7e6da5cdbb66d9215d04c6d666a33533335533335858e4caf197bcdd8fbbeef9219745a712b6e5dd7b53625c4416938280d07c54171501c1407a8487471602e0ecc755d5709e767546fea4d55557516057573dec86ece1bd9cd7973de9c37e78dcfcd50aacdb5b9b66ddb242b7d83d4b6416adb20dd20dd20dd20dd40e888e5dd20f66e107bdff75dda20a865c5adb8755dd7da14171b946683d26c501bd406b5416d808a54ae0dccb581d5b8356e8d5be3d628d9fcbcd4a835b71ab5e656a3d6a8356a8d5a33ab89e2a2e6ac91d59c35b29ab3e6ac396bce1a9f9a2198b22d73655be6cab66ccbb66ccba4d20a59a6a5ad4c4b5b99966999966929541ec5b4de32d67acb58eb6dbdadb7f5b696ca2099d6dac2b5d616aeb5b6d6d6da5a5bb5d694550b6dd15a688bd6425b680b6da12da05611cbbb2d98775b30ef7ad7bbdef54aad9f175ef537affa9b57bdea55affa998f32e34f2ff3a797f9d39ffef4a7f7f14334342d4d8ea6a5c9d1b4342d4d4bd3d224d158f134298d8d26a5b1d1a434294d4a93d208d11cb5665e9ad8cc4b139b7967de9977e69d59a209fa7c7b1a99908bdfb134b810a463ee678854510b211dfb17b4d9880b41c7dcb39aac2d50bcebe77e65ab8947b48ebd0c94f645090b3af631f886936620f243e79ec452b03b03902c3a86c138ac34030988a8bca19515e7f0d2898a11131d73afea39918ee8dcbbc07c50541811e998fb961f687f02e947c7dcb3c4022c2d2d2ea2cae5e5f4f2a2337e51892e2e2fa24af5f2e2428471419e4852674cba70418a30e30e3c82364992c78832630831abd36aa5335ecd882f5ed08833337eeff0e52e4b9d712923c30a59e26adc8147d023e8f0853833868047307d5ea2a0c2799ea74913d2d0ec920644ad44f81ae7acf5de9c7bdef781a2b9a49fb0415636b30944d53a1db388fe227f07b5ae03ffd31d4ecc9af90489a976adb5fe44d01be220a835c65ca572e95a6b6d1e3185e8586bad35286a4f630aa1b5d6a6acf3e014a16904f8caad69c4e7f1adb5de5a1bd1b1efb4de5a6bdf813e3b9defad69e22486248c98308938f74cd05f203f3b1d5d6a932662cdf3d67eb738cf238f0e04ce5b1cdcd04fd03c5174ac763ad8ef20da2bd17d0f4ed45ffb67719727e45fc2f6a139046812cd267af6e651cf5fce9cebeffbbe6c7aafe57d399b431cfcf8f7f99dcd2f6795cae586e7692fe72360087a373ecfd9cbf9e3dd5782a0e7f17c6e0ed1b3e7f9f33e13f015f0cba0cf60cea6ac67bf43dee2fe744ae17b252ea16b472321087e9fe771beb7d6399b49529c775a6bbd318fe2844d193cf26d8f736f7fbaebc0dc75a60edad82fad4f21aa83376cac4dd9cedb94e1ddedd384c1fc696f73bebd6f6e516b6dca3a53d7759d093ca156229c50f078608970d924b8b6bb7cdcf326f3889cb3b9044b84d404683ac9c9aa9ccda24e4485a8f65fe6a68234fb2f5228a9c6de3a7baf3de875a9804e0758969b052694deb144402c11ca12f524d5d85b677de58a07ba3b01ffeeca151d9fefba0e08b069f8c06cfad0f5ef58219c3087f4fc3b5688f6bffac6321cb14234c10a516b8584643f800802b636bfc7f62f9bffda27f0c69744e4346ef0f0dc40727a1038b3b80289a0229f163e688109ad8a294ab51b4e5920f1f190fca07840204e3b070f57bb3a3e82c0c12341a356d19d431f1101993fe09183c7aa6d80ba73bc84dafe05761b0708c247bbc0bdf766654a9b46119e21a12135c7deab93d17fc083879e872538e3ec9011db48ef3ecf0d99eb6d64456443fecb9b726a0d714c08d8ab639140e974babd77f65027bc50f091f106f0095afc288245127504371dde10178e041104103a40390196c18859c409d388118f35e2b245acd08197e156b5589c03418369972c9287de6557b71a59fae0ef5823ef7f817e043b04994144703fd060dbe80cc81fe4d86473076785d6cf39cf3185f46ecdaeee83456ad905825fabe39c7bb2fd7cfc9c2d22c5e7a20ece4b33ed9d4df70f2034d3aeee9326211688e4fe8b34c2fe30637d48e287daf7d81f6cda04f243143fb448660ead0f475e7cb081247fc70ed9624816bf15f19a03e48111bba8224515ce060af1fb3e768894ff7d5f174d1b5517492f8a2a16dbc3ecbbf81d3b841d62f45f36ed110a80a0d8551b14bb0aeca4e7580b106c75602737be221c451c271c261c208e0f8787636c756027bd76f1dcc861d2392339892a92e5cd9c0d8a5d45b23cd849cf7303cc3ae71e3628f6144bf79def2a92e56dcc1c1e1a370450e35139c6486c50ec2a92756a756027bde9792340a546314cb53ab093dee4b99183070961c8e2c0c1bd560766dc444fb1a04631f49db731737868dcc8f1014b4fa15aa437796ee4e041820324308e56e410070ac788e384c3e4718038cc9c8c837bdd02b52b078f13988f109afded750f42362a7cc5cf3c107d1c38b8efb4d72eac4b71eb8ca5e8f9fbace8fe3b76071afcd3efd81d5e40e37b89f6ec3399464072c50a13c000071f72d0f1f950620227412f60d1c21053e8f8b018c28b8460efa44ffd8edd21ca7f9955e020919e0997252cec0e4184385090407a93f53b76871abecbefd81dceffe2f1843eeb9bc00ae9f92b1358213c7ccc4df043c365674389feea210e0bfae73bfe31d8e9f0ed73e46ce6b045e3c4efc61176490203460f6ad0bddfb1290c7f7b2fe627fd708b45df6301922458f0bbcedc9ef63a8d7aadf07987443ac30fb197b1469d7cd892f9a656c70a81c1efc61dfa9fca15083ece3c720dec3737791f97374c654bc8096236b70d257af73c29902cbe4b0c64938814062e8d0e0a0368ac3a4bd54936e8071b24c58142434566f345b520ccd13d284215d97b0e7db4e6e8df77041bc484c649ea39d9a533cb06c789ce234727bdccefd82022f8deefd820e77f992e91d8fb5ffda33e3eb9e0631c837dec5528ec41e71bc0ea30d38108ab43ccf33ccf1b8007001c293a997bb4d6388abdf7de3576ce39670fb2935d63d7d834d0e4977c5fa88bc013e723ab03ec776c0e6a5d972874eb37a1bbf25f5deef7d080cb2f8126490a90fc6f748de5eb3b1d28a53f963d59c7c9773ac2b2d3ae1eba7c69ef953d42f0f1b5d780ea97b0001e5ca8e2fe57467d6cc0f65f1b60e2b75ac03a427f6a8920eb08cb95f6a1ef01cff3f4bc758208f9873ec40ae8749890baf2b50fb7ce033a1d274fc487868e930f5ba7d288cea760562581e0e35cbe40f033de7e63dfa384cd4bf081e4fdbab4807fad807108820eecd2029d941e25787dd4c3fa53c0df334163a03b42ff2ef5579e3efbdcc2be1b21c0b36ec31a9af6131092024f81bb825c423a2fd3c82eac5d41faab939d6d420a7bf4463123ba82851810b6262110b6092a20e98a9166ce91137fff8e3dc26d11e2302cf1a8fdb6e1c110a8fbfaa8fddb631070c65a1cada4947efbdaab74a76d802dafd311e231019d8e9ecff3ecc10fac7044019d0eedea74f0e87e2e51c81e7bee3fc04b5f001f1f05ec7b5cbdc7f628ec3203341f7bec73ce44b4e75d30b85c608ff8afae25a16599b40c8800090e60d9252c91cb87c02633d0bd89eb02aa7a27fdcdef58f6c796fb2f53bb62e82a6cb3772ec239f75de6fcd33ae717fe7b05eec38c43526753fe4c9fd61b83f805fa4f833e3c699d3fc761f92a4fe0e6650fed370827ecf5b0ae1f970dfd4543f4022059a1cfdee6a44dbe860efa4e04d073ff52fd1ea3177d099a8c08103d2882e8411308b64410fd58be4430cc58f478fcbcd8ea817df8f9b1f579b175f2dde84710b41f5bda8b2d53689abc90b34b28fd17b9840fbbc4c9f10882c73faf478e00eec3afe579de12e1f35ef9eae1f9dec313bf560fcebd4d665325622f05ae1f2e1a5c33c050a302ada980eb5c43fa2f1bbce6f056ee8201546593add93e958da9ea5e1455acda92ffb211fa7078e2040885f8a4767a627a12447fb203ea890da2cbefd81a91ff329f34698da070c13ecfb5450c4d00d9a2674a4dc7e7a388102a1547fcc8808a1ae8f86e50020bd593165a5040864a205929610b9590a1bcc2060acc112f455ce0d0e2e485b149162e195c2fe4e8a487f91dfb44e9c7fc8eadfdfc979902c2857a9e4b06dd69adb5eeba1650a0f30958d4939cc48b440d7868c3e746eba732aba86c4ca3f3bb7ec71ae16024c37fd9348131e6a9417f89d8bb5a20c914bec75f9c738ebfdd7bfa4bdc7b6f10ef97cddff885cb950898ff9cefe397207e55ce5eced9d542d7755d0afb35b5d848bcd97be216b3a845efdba0d642720ddd8db045e0beeba0dbd96795f2737ef639d97730fca1b7c77b68bcd4ad2240b7c63b78371e407bbec1be3bf3c5bd378207f8df3db8d77effcf875b84cdb706f2015878277b6f3467d0f37fb158d883ee83a6ae83cfc3dd14338b1878e00ff308c20679743fefdd1eb1b375a66486e4e3d90f41663f8ac86d10978b90f24deec75e86226c6c11b5100311e2fe02bc828f6928c0ad1a1c684dfc27db438233f998a511619636845b3536d07ec0b4d8ef581a8cc915265a7cdcaa09f27eec778ea265326322c464c8ef58263ffeabff8e042c93f3631fea25397609154b6eb85b622b028b50b197b24b62e2efd825e8b7e4e4555e20ab04c72ab9b14a927ec72aa9b14a5656491256896c1b61e23ef13b76098e49134c9ed4347112035e22bbe0d2c2d253a8510c4f26f0f3f8d679e6770c947ee77b608b50b608965b529202a55d693221a01fac113dac112cb0b42d68665eb0563231248c8b17954b0b4b4fa146313c99c0cf9bf1dff9d977948018c2ceb7e48095904049cfefd819951916b32ad859cf0afef73b7616c566674f7cec8968a05c5bc242bff33949e8026c1133cc035bc4c912f1e6d06ccdd66ccd96358f4c766fb063bb2e37d6dc73ceb9a9ebbaae4be1eb52bcc2716776fec5bdc739e79bef5d9aba9c4527042c9229f062f1c2111aaad058f0d1820d43b0424b84ac38c1490668aa89107622f3e10541aa543112024457650a1762c032813e09018c2d4208e8e444a589cd368d3cb19366093af83b3689145b121590664e9228823012327a9b4c74d5efd8244772b0496e80717205a6e5772cd10bfe4bd27ff1401176362f9efe6c12d1c38ccb383deed859c9b4b494697805ece3a3421637e7fbf3be6f9b3c1134cd4ce38e1d8e7b1c75c6232886e2e91486dbb4c7d1270504c4b2595874c62c281a2d95da33965acd65bbb8e88c5d66199661192803659fdbed7653524a52524a9261d96c86856678868556c8ad90cbdb07fba8800d60d37adc8147d0b5114c49def63c9db1a743ed99c4ddfa3ed0640a4fe2e9248a61288aa831754aa574c62994388e2911854ab1f496534b8bceb8a57796982ca8e4e959b84aa8640600080802c3180000037118c6611c46611c0557f91480145780243e3432208a44a211411408040882b82cc360240662003100116494c2a8ae00ccf855de32bc761b02dd4e8fa84d577dcc065328da7542c9fb0193e6f6eaf856d884ed0f37e81f1c1f545ef9e065cfde7d364f266fece7d5b0f16b4cb7c52e5581708b96eb4e3c4e9c8892b9a56150f21991b3095ade76d2bc04eeb4cf735bdb9f338bb2b30dc33a2e134341b9adb47a6f96222d274df0c2e20e04f360854cd33fb8dc23cea6c004fe6d614837887c0e2632fbeac1a899ece26b1b1e72dc0ef9792e59e2be8d5750b19c6ad173c8fd4321f814bffcf96df96e51ad1d9a4feb0f5b5b616cb6b1dc11c7abc9d5a6e784155684e8fc1610deb763afa9a67d49e80dae8ef889d169a6d8a60d01e7cbc9c9a61c3ce60c3a2dd0ed36d41412d7fc087136335a75f9c1a2a488ef37ce5402c30979e6bed5fa3c16b8e46af63c896b108cb8a5b4871f2de01ea6fd1bb2a64b200e4e70131c1e78a5191777252e1760e1ef2acffcd5410d01d3a3e2e73fc2dc5279e947bf629d962a4ffd30c29c4956b094c1073eb1609411c5c0b60ed32bc107fe784546bb51c55d2da6a04e04a79bc80ea16201f7752c0d5d0a43e198c57194144d3906c744f748474deb84b58c8e2869d749eef5d8c4196f73ce8a8814dfd11fb763908da890c32c97df311bf8ce26699670012b8d885f172f462f74899388693756434c7434a5f2051b008c3a5b3a217a73bc8ea658f9d412a0c167cd5a6980c6b162bc50627038fcbde3839aab7226ff286fb7400b4cf7f49605ab218c4b4ceea3e8910ac5d1598981c2007e5d277cd27aba36cab963d525b5f23f8fce7b56afd3221cdafbe467771b92ecdb343adaa3d40173083fab847998fe5c02a4e2f044819eedd0fed71f76005f72955d66647d3c489a5888993598b5e5fbf35951598976528f67b8a0081dbb49fee47404aaf9390a40f495ae086dc080d21b535f0fef05ded050a919248465f89ce1fb1303e40213243ae88de1e33c405190dd8c4a2f22b938c310091a9a79011fbee43d275b2a530dc1ce4b59bbdabe5dc8c32bdca569f367c0841686b0fe0c288cb820f0eb409d3540633798ad3571d141c6f652726d20624aeb0e21a43612cbf15774330b74be34890d5130d218923fdc07f4ba43eea84a9d84cb59907176cf891c29041a87a7fbc3ec6727b8bb6a9174096b3bf6735787d03840a82527d09261b116b17b8f3cad3ebe72a2e278329f8a79cb6f52b85d5cb153e950fd16abdb47867195ed2dd1978710f1c7ceb9b83cc13a9ac1a4751669e3c12000682796018743ed32278a7ae242833c5d5028411a1bd190d358899c4caa3904946d37aca74d7b9c033ce45ea7ba32394223d6075ed6a7ee3ab19f554dee5dbf4820c9f5de7d41fa3950c3c128fdcfd25474e676e626ae5e2985a01d4e6e691e6a0c33f485a2c0c7cbe2ff3f22387a91baf50d2494091c55057411e9a29b2b1ebaf7e2550648344b08b1e6d6578f47bf4295a4248ebe56ec3756026449e0bfc38e88c52147bfc292a4019d886a9ed3882add394270e99d51c50e678407eaa1469916b37f157595765cfa6a03294e635ce94bb9d9cfc14543dd827a5359fa76fb426687fd75deaaa2de6fa4724845af93127f8145a32e18fb3c4f34b054e7783b8177fa95eb18699b663253c890341604872aeb7a3b142c51897ee9e26f4fc8122485200d16d0a39867ea351ed793c24e6e9222970852cf4d8ce4f2a53fa04afcb41a998906779a868b3f37b4427e3ce175f198743a01c17afc1f38bc30b64252478f39633aa9ed0c392405b42827937c6d628a152b10aba5220ec558627483cc233670d028619af4e9add6ce4c17c1a1d356cff304078cd3cf862fe47dbcc27238b787490fc586d085b1b9fe052622ff36ebc1a2e05908f3ed8d673c99eb2bb165485b914c490bb3f366e5cb979080d8b70f26c3a17dc16a1fa7f4b4c16447bbbd671183d99017b49f403272a2d826f876e3536bb81240d609d941392c5df26527b2f7fb1a4ac006d5a13b56466ee450ae8c14d7fa1ab489d2c8973c2a71e77285876a924f685063458f7ba63b134062397425d77c4f534ca69a8de34c550e110ca1e4c1220946505c39060bee666197a531be3739f1c7acd7ea835530a7fd0bbd86d3945f06e07fa2c8d648edb6c695c1cdf7c040e10532ce9c06e23ddc7093cbece9e0f157e1da59606f977b47a38863b649ad9a1486350cbbc1bc49d839ecb844a7932318f37b08ac71536710e95c375d2d3d1811877cadd4aa8801b825f7bc872effe5a1baa032b840eaf906142b242ddc1d8a885b0588ceb40acba2a015767aeecc78ac4315a8ac521c718d6bc439704db61ce3141a5fc66b98b60921ebb931bb656e5c56c6a0b41850766342cb786f1155f783479f86e577b2a3888e392bc33ae247cb69a48c0b43093b16cd91dca2aa632f45cddf039995417488ccb64a5ae9a602e8a705e7bbd548233a1b7196aa555ad482c6e6947156d53a504d5284114ed26689725318bc2e80082ae065280fdf90bb93098f7e7c2e2103e02f99ab82a393e6da6dddf8d6677c3772c949f45d3c532973040a761a8b0df1589b7e5e9c8b0bf3444bfdfa2b3652882ddb3da463c766caa5f33b7e1132ea55f30c5897d38223da0d8e16351677714d474b1ecc74ed6746d2203efb77cdf1c2d956889ef4a9a4258cac2c06b070055a7b9f30db1c1ea5d4909d0aa6cd6650d60e802148845ed865c6cdf01b01ca23cb5a662525a2879834b391c4206b039537e9acb91bb0879bd757ee0f1eb71d794ed8b57a9cded18bcbf1bb9d234b26326deeeecc060c3f18635af95ceca8d25025ac761d81fd23a6623ce0ca7d6845d1b1c4abb7c89d24954f82ef06dc9971393b848be518db46dc8b533bfcbf4585fea54e7cd7edc092585e24a0757c325ff008b0bd705253c899fccb5eadbba41035007e341fecfc7f9fc0e17f0f198a0d44d7317d4f0c05c0071520bca4ff5e66583b947a80fbf70a75ffdfbb110ba759f7dd667367133e55692f6d5bc3fa27b98fe17fff71c338799d7edc3d84fbdb0c1c71e3cbe9bfbe1e0f9d75d04b50f5e82ba843ece2875a7bd9d56dccfcb2214efdab8a922cf1bfcaedc963ad7114861a018bee8cb0e0e7e9c9620cc798aa6f3567262607294607d4052a02082abe3bd326d1e6d948f17a2e504cdc9695fb11e1781bb9c84e79511ede85eb92882507b3dbd5d5045a87c5b3046330491bd2e29b8f01ba12a7695f9508efe309c19d8b56f971c772c14d1ddb915f02e6d9fc67f55e1e116b7a440b2fd69b7219dcef5a28d5d1b73256f1eb6148a46e5c32013134848c782c9e7ce0d3c885355c75df2e883c67206d70b893971c39b80ec4ab2bd45b0b296388f951682f1973a136d673390417084fda40777d32140f426a40d31e30538a1cebc3de35836055755f7dce69d243c204c9acc4473aebbe70a72edbd8bcfe8bce640634308f4ab78388c3ea5013e10544f463962af0fe3bc224d11e69f9ae7c6ec27b4874a002d43e71159365cba89ab654112091047291d7eb3481044dcd645f7f7a132b541e272a309e098705527713cc3090a768db1e955f3bc3de18e3b06c9c9021a3c3c209a9bf0cf3a053bef007e3f5a130896ca367bebaa2d14d19424df08675852c9c184b173d42c18a7355f4726888d4a853269169806018786a1b5c53553437429db42a984f01996a0bed1ab7a79ef01427a110392c041398747197f087a60a8fb04f031cb0e7274bcdec13b7167e0c0a47b17902195949619872835b3060dcb3478808e0a3236c2726d3a077933165b00e21f292f5e753fed9727afaaf9cf53b2ebf20fd7133294420e2e266c6f447370c64e7f3959dd7ae81588f53db2e0e532ce09c722b1a7c27aa58d8892b932c2713c5eea0f275319231fb07b75f4230483f17c33a12a441ea517d5da56af471419af0a012019810d8f1ec43d0eb8e6ba777694fc3342deaeac90ce95f45e9f747035eeb96153ad0f23fe0e31501e3a6100931692bc03e7ac7c5ca8aec18517d26b35209fa334c93e26b309e32d7676053160afdb26ac21c253cdb18724872f797d5fd9bc8c919acfab683e8d5f27106d35c3a0ada3193f38ba507e4e57be701e22f22717e89e6f6451497af22dcbe8ae2f00589d8d064be4a3a81403673ede440d344b1375c198a3c4f6dad019bb870d19650797b4cd35d26bf866c60696c89ccb7a085f0fb201aa55fc118c943410d0de7412522a0a79459a424d63162f5c023e25f45737c15c9f18568ce2f2239be13c1f5a508c75711b8be889839c047cdfd732c29d7a8307925c380fbb27d49ca438cd23fb935bf2a5889df5ebafb98789437487f0c378406d5e90b443c3522934541009bda19c0d8b5c82f11a79e5d32c80947615e59adba1639cd6f29c6757b66ec7b2e0d86141c7a7ef9c6936216cb28fb6a21b2418d1fffe06cd8daddaaf9ae5b312bf413b39eec4291ff9c098636fca08a308266f52c675abf8c1d0b290735f1fd781c8f6547401cb4cd562edfb523e54805c0207df1e0967972a152de04c11cf4e72d1ecf6bdf6bb7468c791d9a51da90e32df4c809469b9b6863c6f046417f47fa0c6da2d1c68e85582d8a4009e6c7d8ac4e3060d9a0bc3a664761f7115d792405eb34da1449eae3deb9dc468570b568165afef27e0cb1b16de262710a759b79260a71df3ad9343ef43a7a7d5e152c727568d08e34e0166e6c606ee678673eb94eadf4ebca7b5ae597e24b5727d2ad41d8f41c4da88f6ca3e06a2bba8a85b0a19bc928d52c46e9720b1052821b662d5abdc6b8c039bf6d6a4694adba88b26d68f64d14867556e81535527c920ba4bf92fd330f4c2a7065f025969963697bcfa09cb4d8932da7177f56bcead221d00512316db87ae0597aad9ccae45d1e9a80bc3ff0451904a56c317065faef6f13265ab769d0984aa9669c426a2728359e5998d45ffe88883529f26dbbfefc3a72ba8aae34978af9e33fa008905e3a3708fdf481712285bba391ef8be7914218e72bd72ad3be48b92d86d4d465849062f047b403215d648c2295eb05793dbda75f56e42bae7411f5d4ad11414bcc829afd112fe53f46079260200defec8c6fbb72cce2060a91da5bf90c634a06780162c9dbb6de071cb3230d95f33ef40d0702ebbbd22cd11ecf2bd105df874f44683212681e2a9ebb67d4c0b917e677631a2c34f7755c85fe0da3c01dee6123d0ab81219a9695b62298336ce5971bb8121716034f93c0871280882ce9f73b069a45e9d0caede5c207014971da620cd80cece6a0e60d408ddc92fb1f870b983f440f2cce763b873ae684e24a299868db6850a60b34114bdac516f21ebd2d093d54814d06636b80024de992307871882ef4d2be1dd04fca242a33ff0d643fa526c65c39b573a4b770d835a7ed9522c67595eba2a8cc8a2c4076d0c3b6d731aa579bb245877d074d819bf80bb07f29bc8dfd86c251508e0a6a865c79d4c606c10a5ec249578152fdd0c2ad6e4159b2aca6f3a27ac0ca1aaffc2e786e7937eca85b68410f9b16582047f5c9c178a77608066e10eff706ffb2d902726f93938830337dc2b79afb4d964a87550d7fc9304969e71a130242021e3d0cfceca1940edca375b078ed96d8fe67f82cf8ce7b0d5beeaa8f2b541e34f3af84cf258f3083c424246cb3b0949ecbf942e97db4da0e8358bcd526cfcbf789cb9ddcbc78e4d58237f92fd01dac41cf7182cb8bf90008e2edd254c8a954dfe745960803cc623374f6b240e21c91fd0c70a2395f232effe5cc27fb6adfe67d69a984f25e5b5b33ce837ba77449a4b7385d9a424917e196469e23f59b8954eee49d7698b10e2396dbf136e989f0d2b3b3185fa8f8c4833bda8e52e3a7ada2c31d0bdc5d982c1303d001eea8bea8ab8e0ac57a5c3a9da30696784271c04e13732dcd27c7fa3c7ff551fd37933579534b70ca42d9c080b2d4c9bbb79e86de911c9645b72120a60af331fedc138346a8238643b11678988f7dc0a2bdd8d9a33ac6131b47d4eeb8592584721a861848351a3ed0219b8a8d1bab2f5007a5c96698376ac69557fd64a681490b62ed0813698e2b247cbb1358d5765d6c5dc6aa790c2bb38c79255580e37337efe66a202a846bb63de125b6ba488b4a457680178474b0f11a2317c814b58099eca294cadda360b35f66cc2316eccfdaeb50c10a50797c29d3184b20faea26a73e51a24e198b6d5c33f61f3997456084f61c640958faf3298b03f32e72310db40f3056cd72238b44a8970f0c85f4f5fd485a4c9ca62d3a65c1148b27169bb660625b5467b70090525f11bbb5822f54044f277c25f7e341ddc73e99914b091ced16f47e7919d28b049c1c6403088465f7ace4cfca89cbe1f525e0627be8374d5267fc386403ec7efb8dcc0ceb492cf725fb64f3391c26b1b85eb7e619b07bf4630415ec8eba35515d10e57a4692eff30970420af9f694bf4e8f76f9678f91bc48dbf79e1f2bddc549d647d5297b4412a3fb80108c054b9c7b7dd379416ec953a73211a7cd894b30301dfd51e30c41582f0804af17c0afb1dc2d5fe990108688eacb2c1d68f503e582653173a810dbcfa21dee44eeb35016d543fce8ae7073349063117080ad9203220ed61e6111b68be320579a4d5487ad0fc350e49dd2500736f9cac9d838aaa96a10e89c8a82a4db0df34a3690d954e6d76a1937385958f3f622e66bd0c44123ec0977bbc67e7c5174c91ab25e64a69e2a11016fd0e2f9fb445e1f7caa6f2863bc3097e89d773abd9f1ca14d1b73ef83559c4b0fabf864ddf737e0ee0d1ac67eee5b988c040b53800a029eeeef2efed377d9358e2d98163621224c53859722c862ac3837db9deda8a29ac8ef1d56f4e4366a01d88636dd1edee92304c5abd3a9ed64712ec948751ece06a4c95fd745c3a5197a0ba3ae69fae05224c3394a7e85853a27766bfda01cd70345186a60cf1591ad76d6d4ec679d8e304072b384dbf969b6cf48f32127732f1199c25d69779a315561c214634e821ed971a4dc0206942adb0c37178c7f4d9b27d814fa7598fad0d5751fd2686244e446294abc1ef370308fac656dc8c98b3ffef64a0b1b6a63fe995cea34a2aebc8bbafc99f12610ed16ad9e26b7816ad65d49589ca4114425f14fc9f0df03ec4c443cc1e456859d69424cb1d3c6f23ba795279a2989e381b5b43074e609cd20e66556ef0a6130461aade9a1831aba0cb27c641e07c384277ec94d2d387d7981b92898a074ce3dc774834db9532265e5e20dc961ab100e76781a0a23b94515de58e36c19061d214b5f0d61853c910ed587af2fc77d802b67cf15bb5a7c39135c7cc1d1bdd488c308076905893ae54b2625ad103ca26e110ab519cd30aa31350295f88fa54e65cf52db9aa0d63a0c1fc2b67add3255200dba8251f6ba7d2c8fb8cd74c1ae8042954284f7c7aad60014a0cf09f833b8daad6d5253378d9c9539859c572104f99b323954dc6382ae35bb64089a82332174734c3c06b3c9fdd28369a7808fed7c2f50dea5d7ba1d1b9455b6edc26e7c1857ae5976624f2844388dadb2ee0036fd91e573b8e682a9929e2ef7c71778da0af68e6455ad55047a22d1b693e4ae7ba9646708f9c113e68b6cccb9abb10c2b34e84f184b427a05cd1864ad615682695f65496ee73a8a10fb1b56f5b6b8b38901b475c2d3908b9da39bfa0cd37980e9f5d9c06cbb4f0cd349868f67cc37502574ac28152eaafecb5e1d83b589c67c1ceba309854ec674c78be619a86d95ffe948e28f25774e0f4ca0a7a1c6e34647be0f849903496828d0701ec54cd16f86eeb2cb81d661a13b948837062f381b6241b14ca754addc543dace07c49f8ca95f6a0a9f20e161af752e4772f87c1bd2beb125de90fc44cfdfcc239523a51ed370cd0153d1e8085d75363f5522c6913b6bbca98f7a76712154d143b3b26c89326f7a12e16b625efd9b160db51feb675c9fe4283f519040ab2246614698cb8bc3a2c7e5ffca0dfbb8ebf6c0e5ab02cda1f3f27fecf7ee8b7bb1344d37d2ce79a2cede35e3ba0ec6ab30b154e917c16867d0ec683df0efe04dfeee4e1ca713f684914ab2f18a0789a7d9b66ca7048e18ed7b0d6fc161b28c157a86074a807d9bc5873171c9653d88d7644aa8698713e7d6f211679eec9c2a2e057ee91c28c209546f9b0e25733daf2a50643afe226ce1ac335aa946b1121f2f0d4b9f87fa4e1a4e5ce5f58e971d97d56749bf736f82f4e8185ea2a4d1443e62d17f3b67eb37e99654671862e22d6d08cb7978140e3d1b221f702821e2ed32f1d34483bd8ad6a9e013abf664e5d249f47b1070752bd647306962f0025c5f3046f22bed1d6b815fcd46883a00310bb640766d1ec2d6cb23227a864484d6a958b15a7b7044434a7066230cb16d595d3961b042771e0a340cbce2d8b14c803ad8b4b869f1fe72d234514b313ae51b882efee6f52c3d5f52793c85d90f20dc47dbbf52fe421767bd786ef2d8c49fad2afe43ce23e8b5180b47af762526c4979c16812b801ba41d6250299c1e9ca845d8a7445b0a111fdad59054f7c0bda44bb1027247bfd4ca05ccb8d4bf1b576c0a51314bd3325557ab3dd40636b78e188972110ba1051ee953c97fad4885d8d61ea8b0a6e60917b51b251a11b47225d98d4446db42376df8c93da4b5ab85b9cb9500ff3e9d60f304a4410283885ab583a7473763d073e68bf096ff34ffafc585267c84da712da0d0ec1786fa689b42e4fa4c76f23ec436f98f1f6df30d6ddc1ed1ea7da2133d97aa2507223659567558375cb7c3fcbe0b83696089f176050bc89ada9af6cece6a829f5981f95f2b5d5b7d16f745cd6451306ef09bcc9fb5361839df36b7121ec9cf575195c2be5952630effe63145b96b95172be6b5d01a2d8613ffecd27eedfc0be2d3520999b4b45cf3ecbf8cf997e7ca82e92b8a58905c8784fa85618ff21ef12a6a7290238ad48ecf60229115fab188d57e8d56f6050bb50920e76b8c4578a21323aae116b169a690f57195524b7e819c62d9bdd3e456fa367a91106fd0069a7d35980a98e026c445ae0cf82a22d797f583e2f7a30cd8af654a98c9cee9ba21b65d772180d2223281ad2c25b322a17bbc563c161a1d2f5fb97dcdbcf4db8c14937fc37908857dd0b50e70168a5fac7a82fdf80333e4c122ccfd8d162cecea1f963f001539be36d1ebe03edf7d3f50d8a53f0f1d50849e2cd4afa4cadbd9c10273fe4de7f88cf5776b4c948d4ae4df4f069a5e5c293fa1ae812a226a2ab8cac41797bc0a246e0ee7fc55ad701895ab29a9fd75b9088930b51a67a4666076edf8f1d92a15f7b6f0e87a7cf38fbe0aac4d85282717feaa90faa3957e4b55fc7b8f7d1f8ed01512de0b3536470a6dd662157537f6c08e489ce8bd741115bc849ae19bbe689463c8b03a775eab3e09b9eeb8202fb6116e8813a75645c1092a04d6986af25492d6fc6f89203ef8e45871a5bdaa9bce429dc57495c2942875c059c42ebfa6f222e1de77a6271bf8522137cd62ee346fa32a5496bd1e3efde89bbe2ac83071ecaf9526831023fea83ed972a396021d482b05752e870090f827e41581c5dbfcfaaf9600f5b8dda334ea8776e421f90d4e1b4348cb432f7a635a19c443ec02b3648900e90ce1a2be40381b8298bc74d87f9c16b4bc2ec7d3ff62beb501085921facc5a2c8d88ffc6ec74a96ffb6b8d5b9f4e47f9ef9037c47b22615efe41e4e81a6e89d6664fa9fdf4e60d1c89f4a672d664bfa7f26b5482ed803794ba6c9df6d575023fe4fe2433c8118c5d77ee245eb270a27760385b2a130fd5cbf771fc6f69334b34f28067c8bed26fc45e561239a30d8a27dbd5b334338a8ed4ffbc0607a21ca2ed8589d75e5bca9f7033842418149c8af0e5879bd0270e04cd33c923c6caace0026cfeec8a6b96f58f4a0533230a1fb37017ccf5d49640ae40accc5a18f3f61a259049656170bceceb6e475768c022b9e01078c25066edb9b82fa0cd8c812fe4f3cd6658853873d1d964b3b5cd7dc4e4e70230e4b141649e81f0bfab366779993519904b04783c6c24f3ff418f074184c55136d8dfb29bcbd6ba5261f189d3eb1d0d65d9290f3045808cfb6cf1819cb432c0ca01823bf8545a94bb356c96cc93b3b541986f5855c29a0482425172867f50c3e0e8171d824275587c823c8e439e70be207aee1df1a7ccc2358e0c4a8022a4a61064981c4c81e771359d8a2ed8fe9fb99d5a8c729dc5ae6519b456a74a23a250ada22aececf5213dc0c08d505159e5d305126449229e044580eaac1fba6359f30b2b3086a90568605938785c71ace6496c31270ea4e815bbf8c95e74c2c68ee902c1d6fadb8ca1d8b089a1550b140b68638dfcee21282699dc47d7cff9e01b4b623451823c547701f98ac1c606b3bb494586457fde91f1d67f7bf87e9001e8eb940f1a69f9161ce8f91f943a034e7cbe52a6a6541c2333e17f79ccf9011d09bdd74d066b1887833792f94afce518d64f305cff5f356812de8ab5f59583e5e259312d765c06087a4cba518ef9a80fe1b15b863b43d68ab7810b3aac584993dc3ff98e711199e5624c9f46415208a513fe82e2aa7e5cf91d09edc18eb6e3cff7d02632d1ce8732d3cac53c18238e3fd63ea7f9fb2db81c067142e7f4a08f3cbe4388e385f1530a0bbee409a370c8031b928381e509d0796b23474c6d36f9c7c5742dacc660cc53e457133901f7acca8af3986b4adde7997cdea929060d341b176d5506809feb326ee7ea791a2b51a210382ad2859032f7537384b4c47befe9c5eed069f2c7f7a2d90121934c6241f6c27c57e155fec21408f3d4be78569fdcc9824816a45f4ff31f5cfdf98cd3ad5c7be2407ac1a0cc8c2a784a5167318d8d0f6970ca6d93ed52293fc83038ecadc8000e1cbd09b298534cb7c4f607282e6af52ac482004c89c1d192b5f8f61d4e6ad2f2d4af84b397e01424a27100487d5ffd7869d6264888c6a2ae92899cb1f00a2c1562c816ff5a235d69ef25e18c1a6c978aa8508f9cae105540e0e94248c48943b10ebd2a4c8b911f92c604789d48254438b73243e8a76fcd3850094b40e9d4cb0aebaa826d9ccd72da38a08f514f296705fd1de2745f182007b61e2c9dead7b48d89c1cf72fac665727f92441954bc99600c52ff0b5bbc96def7cd9d2804a2d77c4220d3bc9308b03a3cdbe5145180f9d12093319813ec86d2815b75c2ad3b7e6fcab3e63ca0d05fd5e9588492e352d7352c093b88cdda588b181fec6821a9df901494dd9b01f04c3df372118a4ed1acae6aed7361f5a52f6987a2f8cddc5637fe832123a4a13b7c90b4e2f630eb28fb7408b3fb2692bc7ff8b70ebc7cc584a11612754a217e4fe8b6d885dbc0e7dbb30191f00ec443b1dc455027a1e4b32a2c69f0a87b2c64321e33441d611a7117dfd24343563b1c542813354b20fe50693ddecfa3624eb34a85d7d163e601b3f399b233adc033677f47e39aa99437a7fdef7e4cab09a86b23d8a34c7b334dcf34c0ef15c5a0b75cdd9d90e3ff77e2e3307736b138aa4e7674590a4f7a99f13b9af17ee02271a9bcfecd8eb3e2c3333cd736948bb49be75529898cdb33c4add0d8ce9944e2d29fdccf59328a2f373c61b6609e569567d70c6caf81a90fba57e1fcea2994b677329dcd82bc5718140265e2f889423a89eed426d5e2d648155c4fc8992ded0526a1d766921864397ffcb21bf70ebe78976b947e1e30ff307bab546ef68b1dfc97fa310c577bb801f1899b045ca9c7dc5fbc16a6211abc1f3d42a5759bb04c9e4741458f0d014cb10ac75fe69921da3b90ce6f07deebb96d05fc20efbc8e058add7e4288b35672b6b6fd5214839ea03672998764c8eb0007fc88b0de20745dcbb78320fde6a28cf05fd5a44ec866cb72afa697341a179967838b708fe02836b21013b32052676d8a9b6c7328b00c9e6cd65ee8b5d16180ea509f96030c39d980b29ee422e700fa13c5805056ca1f858e22751ed92aa2cd615558c27a644e9c16aacfb6a461f6367b7514370c23a7fb2d4fcbcd8387b7c5a4cdefc61f0b39b67a96eadc02a30e59fb748705649618ac7f322d62c34ac239ab6376b125d9f2b0a306610b174e6075fdf4a774067d05248138ff2f506dc5e20fb93e99c8d3f1ee3b868ca24fbf1fa768ac5e37301d86207578b5cc893120b9a4dc74379a325c514a1751157bd2c7113b2c642802334e9e7a90ef2e046585b1ef05ecf44627779c1c36566116d45ce32fc7bc4d2bc428f991b910a70834e4c465befa0e84d7256d2fd4ed8a1591a71522c808b40576c6146e05fb59ad225263a2d8c4729781211374d6e1c16968c7640e8bb4def63ecacf930a62b0e69a0ed1659dede95cbceda02cce05808094c4f632cc696a914b85fe482862a30c8e61a70a0d3ce9f75a131c3ba2ca98cf861fc3e134c90f8058d19b18ec98667185408a131a37f7e4a1eb191d7979ad8430850fb9a7b43623c33c6b93343ba13743345f30479e8c65a6800a053489af76a1c81790cb5cc907795ed7ce996b56da65cb2d94855d46135032c11d0885b293d40be88299ecb6f1237a35a96b7dcbabc061ed26a861ead194bf8751af2a3d13acc7f06afddcae5e510cfbe3f199072f2aa61970bdc7b90d060226a3044fb69ea68a766d728e93d08e0435e5138c18ec3a1bcc22979d17ba49c74c43f33efda1aeeac23d5f9d2543abc3cc9d8534e16fd085b8e4e22d2b8206acc738fbafbc314b841f821fead709c58ea2f4736d5fecf35e2ed4fd7c607196415afd3865a1799d0f88e11fd0aa5fb3c85a01a1914a1da458c119000da1a362d0e22787e6f0f6dc3598d7b25b807059079b2827bcce16cce3a610750f132d87188c222c3892215bc11ec1550db031111d3994808936a7b80f279c76ff51f83819e44b9b3e4ef9d05cdf6b0e6d5c2b53724bfcdf6b87506ccd0b0fc864aa29e36a43d5cef4c7e3040b99f8d40a62f9ca4018351319f11a6bf86274871976d8c0864dc915ad193d004815bd94841fb161f8c251fde99dabd7e33c1fa4dcc55d94872377bdcea69efe83b4b274961e0382fe62d64971120bc9c993d5a20f25ca4900edf765e118682ecc2983c4400a505ca31327b1077fd8478993d68ada701ebe0aca6d7e6b23d7699b48f8be67a5624acaa21188a8ce102c9cdb56b304ec6812f33cd6fd1d52dc427b28475343b8a17e360716549eb1ca688b78bdbdd4d5128793d64d053ba03351bd402aa95e4e9090b1e045a296bb68a6e9853884d33037bb0a0d75c3bcf777a4840cbd99ccfe4eba157cab82ea57a2c19b95bcb1b00bb8cc1c3876d1ab7c8cedb6022db66521c5e50a402e866e0d8189c6a8ec7eef2de036299a4b766f4d05dcc6f9dc5d5a3aa766a1773cefbde9c7dec2d5bfa837c1e7e3dd860ab89b31253f078853f28be85786eeb15c3dc45a2478587251aab1a6c7983b9226fa04235ca4b0e8917acad93a86f02933b16a88aad071eb4f8e807cd9a191a9fbf81a444a4a70dcda9087dad18d2713be4d1236281e9cf6de2b24a8f9b120d79a5804646a0b516c78cbc4f9700acb1a1440dee54147a618561e7ab300c2b88e88408377904bfecab2da2fb0eaf5356d8edd842cdc3e276dd4590afe8c8aac0f28698c746157fdca4c3504eb0ca16a41c98c7903bd6ccbd254c34d2139847fb21fba9058dd301f348f9ffd524746689e09ee97c6c30965d752c668607fdb29112e72fc5e7fe6d214752ca6d023de3b542dc5eae00443988e31d6c41e395ae773006307459fc49d657198e8e0976cf2ffc64413cae84ac1d872485a8fd3f0225301f57edfd07d5f61e899bb207c61b683ec2c0074710d7c45adbbec17bb0c2d67900dcd4011364eb671bca48b7f4831a81e9358c2bcd395847fcd2e3c07818e4487681d50b7fd451f81e03b852dcc375e23b351e8c87615e7a37a0a6f001b99a53ff3370815d6a4149d3dcc8e8f91d0c2e12e8b8cbf79f70ff227e640aeab6b7121413131e693659f69c6f3fdbcba2467e84a9ca9b115d1e8ff14a16c5b22b4cb701d11da38f5d0cc6b2d148f97ba65d8efdf54df1a47d1fc1aae3d842eb7adbf669a717bd948f94efe8938fd9c94fffab096ff622d868380b1e8eab9f48043887a821603c0470a5b883bf84e38ac9d9f14a528edabe3e5220c07e8df32773833dc4c497925873c95110b9e1fad2e2c37b16e74e73877b08441521bfe048a414b3b78914d536ea33b31100322ab07ced49cddc91f674b4ca3bd4ea69f1f47a9e6f2a75bc8a87bfc8740daac519bc6d576f77d166335a7368071e59f24dc57cb6963db84bef94cc05d198c6b1ca82afe9fdfecb52d45af7f8d10b990fd05fd83252bae761440f2cf1a08d2f2792040e9d0704f999195914e119851ff0dacc857fc36befa0a43afe5361e1bf85f3256d37d208eea8cd044885b5219818a4b47041e673a2f913e744e6d12a5b7ff0eae62370a6ef407b834c213332d008e88a484bb37f701f73d01a4701375d6102b67cb651a7f0490d05d7739033d539501b7e8137dde102367ef6b1b3f0055832affa7bb8dc277e23a0ab92d626bfa03dcca1358e026c74810ddcfa6e239dc217e46276d9dfd44597fc4760d7445a9a7d03bbb183d67108bcdd091764e7b38f3b849f3438b85ee379e96e81daf00bb8e90a13b0e5b38d3a852f888559e5ffd3cb2ee91f815d17b536f904ecc20eade310685b077cd0dd771feb10fe201733d7be66ee7ac93782042e28041a632a1a73ff476de2706a3ccc07219e74eea0a6f04d0f01c373943fdd39542b7ca7c7c37e89e34be60e6a09df3430f05e47f953dd61b5c2474a14e687288e24a7b0bef04f8503ef75909bd41d5023fc52c7e17e08714973086a85ef7458309e43f9091d81fac23f6d04f69318870487a05ef84f8781eb3d90937039e582f5856f7a3458ef030ec92eb07ae19f3a0aff630057aa7b58277da3c283f130e4490fdc3ae2139c9c331a42e0c65980cce6b95705a317b40510446bf3bcd0f7b1d7ffcda2125f29118570e0bac6e55dfdb4dfb413881499e9f413278b9fdd5fe25180acde57a4389ef3f33ed2c43fbb52e50ca706386fd32c5027ca89034d8c5e2de0faf2384d6549638103ecd9d7e8ce10270ff85ff377a421436413078cfa7927dce6e29642f74061a6811c4c5a509cfe318f2bc30e2ee92e9c26e60d3886cc14be076470ba68ea757502de006ec296ced0adf7ea83b9c5f5be5d5f79a615e7044b71f90007325ef4fced3fc9a7d42b3b64d62cf89158c71300e23957d2c0d3440c0048fdad01c52a1ae000e443962c5f7ae9ae73f77d960a14db322c3dc0a29f2abb714dc04ac1297c288c77d7744b18d733e6feb369292b70906fd63850b38b850fe9d5ef530ff051db9e8b2273311a30bd1513b1bdcaf61765f1390eb636aff47372b77ba4d9622d076bc8e67f338d49c42d896cd8b5d5d7733cf78ed7f0820fdaf2ddece0731fa3876272d6bbdcfaa22861852c0a3d6ad276c0630c3d2ab516f9a6fc38377c95999df78bff5be900e57e712564ef1c1396622384ce8b0b5ff468d8ef021c925ce17ae19f1a0abec7406eaa7ba84ef84e8d87f920c493ce1dd414bee92160788ef2a73b876a85eff478d82f717cc9dc412de19b0606deeb287faa3bac56f84889c2fc10c591e414d617fea970e0bd0e7293ba036a845fea38dc0f212e690e41adf09d0e0bc673283fa16305681035c5e86b2db81e8939c88d918aa71675ce625a5245a5720ac5c006f5060aaf565c11acede9c04f4520561cd6073b5fd2691700d580de24bac602f73c600ab2f100815340d3e3f53f86aae999079617e3068a3cfdfefdb9a07c5a9deb13ea10576741282006dc080c536c3b0132001e5326b301c44bd6a469808df211e264031463b4d926a4fc9e31b46186df77d58f7ec52cec88b6111b4fd05cef993812594754b77c026a579fe0edaa435db8b8433f40d0328e00b73b600336fcd08632d0293e401766a8fc797405694bb3f2a70e07947b993f1492d9df64bc4a53ee33bc1523b1bd97e537a672b1b19bfb7e8c0f8f900f9f9852389d7eebf55fc275c21bb5b566da9d01a7ba8c9e621d27c20f3dd4c908636d93058c9356af920b038b020bae3481429d661a9d55947fe7ee7a3fb98a33173e138033980bd5a02c8bd9a8c7bf084ec0deef768f25f7c42b25bfe34ca06022923d5309910c4096a67bb302dc33e94d6bf6cbc758ca48ded020c6f85448c4f22aef6f94054cca834c4f41e20a641c422b225e55c29ab20224df147f463e97e10cc31ab858806f6dbe14b088c97cd43122ad8709def2d9015a5fb7186a6f65f8a17854170092408e9ad40413bb999ae6662396c7ce56ad50325985d2ffe611e9a01eca0024860ce5879e20a46c6fb2df025aca1abb908b5f35cdfff3c0737fac2a0f4c908dffe6069bfb313d1427b25fca3e0a482913819202a90db87164cd9aef24308eaaddfd03d7166f893bdd09c61f6806bdc981673017225a9b7e81fbd882d63c0edcec0613b4e1bb051da50fa095d9e5fff9eb1eed9f015dc8b5b5191f8ac06589e94ae073a4a16250e25e0f58d42a0fa7e3c37e89e34fee066b095f3430f05f23fc53dc60b5d2470a1ae68748203ddb188bd9dfc396728c1a07deab2077923bb046f8a18e87fb18e292e600ac15dfe8b1603c85f2273882f5853fda48d8a7310e090ec07af18f1e03d75b2027273ad97c98f5ca474236acf754bbf66170b1f7b3cf7a2352f5b0c17dbf5dac43f883accc8b4616a1e8b786f1c4b23c84bbd3173dd45f22cbabac27a473fa02b777c205d9fbeef10ee1076261e6fa6bf6ae87f866902e422d5b3ec1f731c1f63802dad6090fb2f5d90bbaa4cf3444984f419ca91d606de1831a0ef65b8c77c2722e0a05702242c780cf272c72d471dc596de1409539543aaee95cee7599e9ac334101b26822cb8598e0b3fc0d44fd51213af3f445c016d4f38caef0eff66501197ac1a2e5cf11b8dcdd291e343b2837123d9df42c6f16cba2573b4e7ee7e6e20f789f8148404b0c344b8ae9448093231697e4ba77d3fc3ee51dfcb558015cde82c291ba1cc127440bc17c49013d0c50ec83ac8b662511e391f11e4751e2515d0fe5922c84238aaae2dd9c5c6804afb70a27a2d1657820dfad5184d6c9782d566cae278d91a5277d8d1c29753caa66ed6b9c82db440360200b38b1176af1c3e83f661ce55238537083cc6b4cec348061a7d91b0b0ef063bccb513a193ae56d026e6a01b6998a1700a59f0c91abd8db0f1e8ba25bb5430929450c0754bcf6922e4ab6546b79d7b620a0e819fb4e01087ce319b5eedd1fe98a14257dd8e0946b0ff47d9f0e79cb687f0a9370297c6d23a28edb43df00d5518a26d5abc66a597ab6bad560a8ef1876d0235972ca4a9aa9badb7902873bcde851f708ad2395d050a41e125941347f994ec71b452603b167571f1d831e6d915ceb9d83bd8af774404c37a5490ef7f5798702a977c6d61e0697151d1dc58d4a4c136cee1d698fd26f117aea2dd3ad34197413133a9cfa026a48d2755b3090ba4a075953d1bbf57c589b3103246674d3e08f9a5763a2dfa9bba3bfc6b3952733575542b6178835a9c30c3f5b71002e86b90684615c70050113fd5d866ab1165c42526d41d9aa5cb9e1c5151a7d49c8de5beebda59452ca1419071a074307af2670e7e08d154d0a47eec8dedce00083aa8bbad0d31b30cb684629a594ded4af7bfbb130a8839b70ccaf3ad5d64fe87588541db95389e8d4da43a4f496925714acb9f41b6bb307816393d82436913bb189dcb1434d62ec47f4e1c2d16959da9b9905a16f9dbef5203d2541d7d3af9fd0bbe48ee7c325776cfed12f0112a42b695acbc30698ba65bda26050fbf802559d74de80376fafea76f7de6b5799255fd2a5c7baee79aaaecbaccf3be73505c7e9d607ad73ceaccd1c56ee6f570ed2ce69066d8f21bc72eaf950adf291f95e90f6b2b655ef9959d37ca4bef4205215a516d81ab9a19a6f5b27ef757d8c9c5408207c0462c1b97eef03faa874ddac19b9f9ed849bffa99ed1b7af25dcc579021deadb763db668f7b1a48b7219cbd6eb705256796d8915c9d4d49492075e4254db33bdeb1d358094f059951f09d23544d69c4190ae1080f48ed83ba20714a7a68ddc99335ff4700f64feba74f2d36b8248b74ee3d3c322253fbd82d27f546eab77e764f503a5c770e909993eb0cbcff3d89de35acdd513725d6650e886e5f908fd2a5379f6d5609ff1fe8dc6637ca075ea347e9d26d760af0932e32a9f71958ddcb1391229e936006be65b39fe7c847e956f549ff7fd743cd275730f9bae77c48f1e164579159edb3c97d3f391655eb398f936b5cc7ba466fd887d2d05cd8f5821253cd000803ec872370e2b9d4e975de7449f9eaa73743a276a5234f3557737cb32b7956a9ae6b252fa4527a71a5aac42b523f43a2139cd24e9e4b52e22c52ccb32a727e9c4e6f349b7ad098a524a29a59452aaa9a253fc5ab8d56196cd8d6bbeacb33e9df9b2ee7d3c2de9b21cd7f444691319a1312cc4260ae51479641eb9cdc108f5315689d9a5cbfa8b08839df50eb3582cad690c8d484d50d47b52ad667ccbdae6c518bea93ed0a92922d178f448e354159d683c3a451e2bcfbcc750e69c7bacafe76bbe9e5e73a25995cf9cdac75fccf2abaf2a71597272ca1e7f7129cb539393537dfc45a588e5b324a7e8143db0beb93675cc1c919c9ea253920ca5a6effe7ad2bbbe4322272f85e3c6860502e5e971afdf9b5dcf22d849dd5b5dc7e5c23c9a835b053b1ea9e372b9df7933682447148db221245212f210458512ee00f5dc8a8683b2d65ab74ec7c89de8d669d48fcea78d929a158a94d18427dcc2332e3b96cfccdea8c843864f1a0ece60cddcfcbdf7de1bc3afcec7c83f76468c7befbdf7761aeba344f9047c874452df496fad6b1d8e4fdc2f3af9e21397cbbdd5e222959a6ebf9b41faa3730b5563426558200375c7fccc609665339b63a2c7e9a04e33f513ab98239b33e6c865070c6a5f67adcfd10edf298332a8ac8ccc32a8c823ba965bbac664f266507e075229e93393fae9386e6c583c3c5ab6d97ae79a83383731717962298b12961e3c395ed379cdfaf4f6f881719555d676994659eb9a7b5ff4990ff4d5d7f1481e1e8ec6a3099346794ee35a65d0e5aa0c7a57a594524a49a39219a4e9549d83f4bbce3d1a07e9d33847f359e73e6d0b89969efbcea59e3e672d5ea9bcaed67fb26955d9ac602e6f7db5f4d6554a6fdd4b7aebdd96c10dbc9d4fdce6096a36994be65099311a3061c64117f6d593eac97b8a3292e33bcbfa644cbaac534f48f79d1c922feb52defa4c065d3abc7df2d657196c35791b157974511cd7d1a8c803d4791e9cd452f26e3292c3488ebf9b6b0e1ac9a1f356f37b39793348bfa3aa5454f4c0e68e110b10c5c9281bd05ea22623d801d5324d41fe0a0378ab5107e3af30002d7a0d682ff3fba9ae3967bb5983c7140659f89a06ccfa535d7e378f66427a2d77f060751e657075303e0e189c19eca6290f56eae003ea0b071ca71742d39c827ceaf1faace2c1f82382f4f1db19eb354536d8f5f8d2cbfcf68a6457d00e4750bfbd22360437c06e91050c15917d7b45a8939429d8f58a78108511dbb75764328599e17e7b4538804245094e8e41628a2dddb757240021d8a1c90ddeb75744e630c40513454cc16e7b456674f1c185a7d5b757247aa182050f26989a825daf880b4147d5efccdb0f9c5f0a41e85baf5ee333c48508bb4010e0fc7a0a2a08bde62334ac736e5bb9eabbee7d2beef35457b57d449ef74cd50f11e771d7572aaf9fe7f603f2612390cf0fd1cafb8dacf0445cc6aef9e42e6ce537c72e4c15ab4300fb75ae7e41e80aed15c9aad88579f9461254397661d8b91cbbf50b628007893ca2eb79ce7daa5904af9ccbb1fe02533d273beb139c4fa4e403d80376f840e7f4830fd841497bd03ffd7e41d75f1082cd38373bd587e44848e6d3551cc70de9bc470ac9fca7de1cab30a2eb3d737e42dfde8f1fa2ebfd4638f044b10abb3ee333577d25cc9754bdbc1cd4a3ba8da5e7205ecde4a3ea1ec6832bc47823cd040f5b3ef39f23222bc7de13e7201456314fc9735a96626ff39120f3a7af40f346e893113f6b678186745e5df521e95ce563880b2f08c1921c514fc8076fbd3d2092494c9a2f550e8a4b5c53d25d6a8a50983818a104bd20043baa7e7bb410d5a967ae793fdd585fa3c71076399d5af9e954e9a76f5c7eba7dfa6d894c5c4207252d2a27e5ecae730e5e97de8fe95cbdf64ad775ceaf67c30a0633cfb42cdb9ce3b8cf4a9fd3ed9cda082e840d53a0f042441250601b10ed7f369f6ee5d623b78f7a9493baa4db57e7ae7bceb13eaa74e5eff5ea57caab7c4629cbabdc2a31fd75ea7d3f32dcb31b8ddb0fa4de39f5845c07a90ff519df3076ead869ae99e12c573927bdcc9be1f4c7fa0f762fdb9c73fbc9497fa8f76fed0951b9cd3533720d109663673976ec3f847ee5de579d7e2aef68388d4fc6d772e599af2688cab1ab1ce7d5cd397e54b9874b570d161a2024f43483d51341a808ef47a5418f6473fab1b009fdf4a477b9ed4b01e883effc887da0ecbb73561d92d7366f8e85d76edeb296c1ea96d3bae8f9649ee51c3a9f67a30adebe432d643ed39ba8ca215482294ea14496ef3009291ddf6112569e5be5d06925bdfc28deeb0b2e4104221d2601e5a5bf7423bd63eac0b2088e68c264b8e4bbd7170c85d3d264f31d6ac1a2c5072d39dc4ce17022c70d61161030404b0d20624091e105431d192c544c4bc408a22b02c077c8440c35bca8f90e97607a1a70eb3b5c024b8dd7172d00cc2a2f31fd8a8a513ac1d9200a95a0e47c81c1333f9d6af1534a1d2f05d0e934280ac5196390db460f3b609f0e7e009c0d1a52f8d14fdda783b7b6564ae79432764e943e1d7c774ef489af49e9e041ed4bf80393bfe13989430b0769e5a5dbe0f020ae9446f1d1596006fec8cc4f186cb13c052ffda6f50394976ee3853f2cfd54d1acd385b341838e0d1a7ef8f29d231dd49a6af1039326777ac712ae3df42186d08721a42ec084485584484e2192142152961029298810490a141dde6b212dc15a4b01d3e50d52f3463bb7e250802b132d1552a942131485a2b4f90947ef900a936f6fd5d55a367ec341ef50e9cc6fe5184f19259d365cf76d7573faaecf255daa8f83cee9beea35a46f5b576fa52f2aaf29983ad7954e59696c4de5e59bce99f8a59741a9c957f58ef3ee3b429fdbf211fadc07ac1e43db365fcb34a965faf69bf808f066f0e6af5bcfc1ee35fcda0e4dd3bac7ce6a55b7e1bece99c19e6b37cfe16f76363b125c67599cdddd3d3f989abac16fde1fd85f9ee7c1101e28fe964fe0f9ce3f994ff46f6fce69a7c3537d39e44b3af7e9c44fd3c970c857e65bd66597b67d608e97f44a1a03ae6fb29d585dfa9309522d3c63eca521544aebddddba4bee446dce7814a593d2153b1d3df3355f46188c4fa0c81d9e8f514ad43a22592b9ee779deab0af6bc1b1e70d5e68b3aa5b8bae7f57b3e3d1f5e27192019a0c4619201d3a9b76ca2a59df7792abf1f88c25fefbc8f537d234c5f3947bbede3bc3d12a63782541591beca725aef3ea1e78ed088d449547036885e3dbc8a5c3a4daaee6af6850e441ef5d5430ba1942c2115253ff31d4ef18286539e2470144ee1a271358453947e4eef450496547a4cc2499779d6ca6c32cd5b59ce58d29521e156054c40e14806324d2a9ca2e43b3c627280ef504a97a755ab7846224be98b084c3dd34eba5e3e60107f1d428484c8237ef5122a6082dc915e999e4a5131bd6fa24a3543139dced07c4051e52b14a44b7a8cd8571763ef3cc618f1cabb0f88858f1828ae8c101121f65a019e38a2132ddbb85788dbc156e2e20714a722a83dee1ee30cce7cf169be5711b8f10c9ef9706ead549e0f8efe46ff0e31c1d2155f5a709226c5b5946225f3965e083ddf402ac407f2a139909ee2379f73ce0aa48de8ae7a426a14f14014008a53de1e903be435a75f0e9d9f8f0a465741c80b0200a11b7ea3e2b7dc9d53356f9f33ca675e13847ae6343c73f2999192e7dcf33123c6f4ee9c8a7d7a423207a96b3e6638fd64f8fcbccda9c65def47e62c9aef87731ac7abaf668603a1df8cd7af66c6a5e1f7ab09c2390de79c46ae99e13541563ee32b9ff1199fe1f463b9f596a6f98c4fc60776ae39eb03bf1f1aef8f1954b53e9aef47f3998c41cdad6f1fcf8d74093d977bd46c5ee9a7c246b7ebb3476e9a90d8f43453cd69e7685e03848ac880e2fb645de7d44c7d7a2a9d2a587e87529490b040a90fa7b985d40c06d5f8b453ffe91ed9edeae833243743534a9bbe86c0a0ceb74b49d1280a45cb44a46eda4f4f610f4e9c9a2292d3d3d317ea2d9dc34e3b59a5b7f2ee09d2d7bcbcb1be95419bb76d9dc3f13683dad3b6d6ea504d070cf61832758020420f0821d4ea5996d1aecb3541a477fe437ac77d9b5fa1b7397eb3d51ac1d9e068cf653d9bda76e3148885974ea79cd1879539ce4eba71a0f8728bb44b26a54f975ff5f9512829a794524ae9734e49bb76e9a240cc486708048f9412080cb25ecef9318b1329517e4ab158d8c11c3f71fcf426a59d5be7ecd752010659cf922e196772b412c3314d8b69eee5aac5409d078de4782a81ebd23d4f55abe7798f547952519bd7e717bd3e091f95ba52d215ef2dc1f3c17906843e23410217bc21a1b9b072b870586b6d34c233f315a82f60b4f2044f162c2f3ddeb9f0343711423109a186bec33063c23060c2304d4e8708a324b99652ae84586409b160b271057761182b528461a0b059873bd60a30d8b1baaca763d98059e268b2804b026394391902cc11affa0ec15409afe0f21d5ea1d4e115465c51a5ab2d756c1e5d23d27cfb868e249825dfe1d393076dbe5e21f59e59af3a34af2e5f996bdf91f5f66ca4abdadc92aeeab57644c83aadcd5832712d3b4a71886c5a328294696200cb17498c38028c245c8472286289305b86d8a2cc932174c8ace041b31b0f6b882b74b0820a0b32ce0a98279a9321ae585182e7be432b96245551e6b50fc344f90ec33879b095422ca0be2cf9e9d22ac92abecc172288077388609db3dd4f7fe9c256db0177f8e5c90af1c1c622820ca13da00e5a9fb9478f8c990787e7808873026c7d3ae87adbd303a7069e1e3d499a6ecba6adf30d65bea6c70865ea984d3c3af6661043f9e9b369ea884bf3359d874707d471f56c6199411c67d34f2127bda37ffe448f319f4147314f279d335dc6a5a7b1188b413106eb3992bd951e63f9c787cc403df5d257c86078e931833db8610dab39c660f38b8f0e662f833ca00a28daa5d43bb29fdebdf3802a64d0ae7eb05ff0d3e9c7630af717df0ff6162c86bec8324583173228c126106196b8f05014b2a0871057a2a88c7142ca0826b4035118443b9019938516b0e93e7574133034d90286981a5e680226644307a488e108197cc1e506d8749da9630046d44005454891048c30b0e93c53474f2105440e31d840e6882f60d37b266dca66508212948086ee28f432143a8d400805504984e181112c5132030ea61a6440819117303b441e422f4513870434dfa117274fbf432f4d98e0c840450422086950256c4aaa2a089d622b9c1114e03ba4810cde7e873470623a88e9773442c386660e3a1a421d465dfaa88180cd456a206073752511665d3a919a835c88b0ea370f25f900665d4984d50893541561f41b325f9ac7af04cde5f7f45af4860c69de335f9ae380c075e64b8b937acf97d45c7ad4660ea2f9e69e9d24a5d3e80d9bdede9021eb152615e5a482eb1b302649f7e9f743725de5dc87e488c8cd3d5f99ab1cc9cae5779d4abfbe65229ecf1c143be7c145c678be325fb9ca414ed2f019d8693896e132faca89445fad3cfa9689b45a79480e3a2232c3630ed299afcc67388d3c2307f5609d209fafcc65e4a4db7d1cf5eb44e8e6419c53df3291e95e0e8a4ce62b8b99cb4128cceb4147442291eb3207c55866223de62019630ee23ca8f3191d9a2530c658deb02c061899d0af61f36b18eb0b3a1a12230745d80a09e7d7673e244744b81ca1cc57e6d791f0e0025bafab1c91e62bcb9c4717385b24d51b0646a4cfa8abbee93736316982f25ccb962aa29a21d6476898f522115693a6ccaa34b188984c505f7cf61d76d1a1053358fa2e4d1e00dfe10c9a7e8c44ff2278835b1d7614ee6bf984e840ee09f73b7a6d67328fdf611719befe1899de9d4eabe3913b3d7466a0f4d273d0994fa04e47b19761501c17244e0bd997b069088a330402cbe6a6ccd7f80e9980f8ed3b646a7a10471311384978787060c05172c24d480594b08bd16b2a0b55155a2805d386f3024eccfb0ea5d8f2abef508a24299e48b1844b996f1a56969f34d63a27ed3aa753da9452da3dbbd26ee9544a4f8b1e44ef38e524a2022740b3465b764bd923bb5dcab62ea70764bafdfab58e7a87e99c4d7b52da9452da5d81e6d7f6c9afc99aa5d3dc9c07ba638c318be9a3bbbbbbbbbb5bc280ebc8237ec7aece2824999eba94910718fd087df03a78447bcd8fd0cf7ce2d4c7f99bcb7be7f5bede59a44fbb933bb6da1a5ae375709b35b77acd56bd26ab99354659b5cca3f7038a32555a1b3cb1e4abd37b1d47cfc7b536cb6c966599cd7e54a72ea3cdb2ac4702c9b199a40753a35dbdd603afffb4dcb628bcb9f41feefa75904529a5cf927aa0ec57a09141c3ebb2afa5e256ab9f2ebd2042574630f5a0d09558ec559848b1cf720a4a7729f6d739ccfa49e6c14e8a3dcd33a20793153d98fee2a2bba0323cd6ab8bebcfcab20f4b97dc61dd185df6bdc6601a3fdd7a3ecdd42c2b8335e37ef259d7678c3d8efdf51e59efcc6ae2b5190535d7aed770d76bb6eb35f55a6b6976bfce806450407df484085d61127b15848a408afd75eaf94c2bb1a748b1a719689289fdcdaae841173de00247fce4677a4ebbd99ee9fc3aa5f74a51d1aab22a952a53692a956a5371aaabea88a8c00974aec9f0892bdf39e568744defa577b30104bed76ed65a5b33195dcb1d5abd734afd3ae7921383af73d77fb8209d53e700d075e61db67e6b6cec9919c739b87d355cf6b95f53b3cfad891a0d7adad1eb939f637ace39a7e075da3960874f403d777d03e5538f829b73d60011d2a254e24419b0baaca931e8ebe620685dfadcafd1b2cf95d9e77eb4d9e7fe7fcf040a7a3969943353212dca19b27865d1b06ed6ce96275b963e6e91462fdd6f6aa8cfaf992cf89a99232004b3dea114427c875254f9570e1874fd07ba20d0536462b118199b89a8599b375e4fe0e8a00bc977d29cf2caf7ba02ebcca2b0cc4fefb81e9ec61996a8f2015d8cba0ba32dda8ba82576e84151c4000d4f5630454a991ca48462a04202304eb400d5022f436396a089d263e20d90e832170a236bada59ab5599455510c8c70142131458bc83485914e911779adb5d65a6badb5d6da9a0b34c8bcfb30b5be6556ed3a106eb13463738b3a8bb27c12c185518ea21d4544188561f481c67280216eac1879a151d4c4884b87892d88f15a323232d202505480a226a3255618a98a4eb000218c3218a06470020919c420cac5246c82ca131324a6ae0519ae92900c1258be506981c916192491e4031837cce049178381eb61460ca2a9280ac5185189595c20682f3b4551c9a807232e2f30e1812c26a394318a1bb08118a5254a434e6c6025f1214907ac7401828a2922883e58c208a7e82b6aa62471a99dc0014a9432c2a80a23273187ada8fb052a9072031bfc8082279e10a10a17bc6002a6092a5cdc800b239a2831059d94458bb9028a065118c5481091b6187550d41465064d1811c0a6a8092f749a28f1a0c50b2d5db0c02c18533871624a18191471618c990213c1c08a5622ba608a09a3308c4220c588161911b980a205a3908b988cd26509258c6247d12ec842c988c8a855a480a230464e460828c2c2a8c74c910d1108305a8b1a8c8a7252605d8b5872729046b4d65a63acb1d6eadddddddd1dbb5d7e347e9d74cd2072bc94ac4ebec664d9bdf7ce39e79cf3de2ce3a00a8e3d3290390ad52597f96d20cfcc7ccbb4ac2abd744a244a49d71c12a3535cdf80130a074860302ed9e9f9eae9249ea41b1ec0a04e19cfb125255349e77368c66c549250e692dee13997259e4e7281d1497402e5793adf3eb06623ded4e5c8c4257e7102b256c8fe87bae6aba9a9a91b4c70e6d9c6fcc612ecb9e63de6a313b94337a92ef360d468066d3e927dcd514ac6a709458bdd10018eb3b10541134c64f1edb469ada224ca8f75693d2a99dd9c9e872033ebde076ad9cacffa0d1830d8643e0e659e81a008255d52b12932452ed2f5a573c6908965641c235dd16d96659994524a50e7b558263a1317a8a71b1fc0607c7a3085979e79d18ec2d4814250efd8ae16d439dd038274c525a2ced48142cffd823ac7880972077b7b05e48ea6e2b22144a4044a903b74ead0a1c93ddb093c7f63b8a6398ddf1860084f43733de2f81819d41c8334191b99f9703641f5e1902e196f24c12036d24fbf3966b548181282fd44a8b46ee1e6a494767777d34a69777777131992fd74a94d265cc6ddd6f7de7befddb48de3be7e7ab59c7da0ebe85c87b6dd508235e7b2f4ee6bc9d7756deae82ee79b468dba7938ee3b8187cbdc7ededd15eaff5ca76e1d87ced4a1726bbd19fcf57c7159f5799d97f09cd30f741fd7bb0fe4f291fa9c5f17fd6ebed9320ee9d2bc476639f3b9857623061cc9fc8f75cdf3e9b29126f33eacdf6082e3e69d6b5fe799760304188c314fd3625e4621d633b3cfc6315b93799a8f643fb316934e7046fae9bbea94524a29f513fae97ffa09ec271adb4b321ce46139a8e3f365bde91f83c73a8f0c5606b58f91b721944a13642769beee9c990f7f54d2a5a77eb1e6b56766c5cc082e7771c3851b2e68d64e205eae02100037e538209251e61b1c9d852877703670534b2d65d1e93862b0b5d65a9b798f9c34cb1957b71d98734e1ca90eb35a361fb60187a305bb4ffc016001e0a6d306c086abc143473127719826132077da069214fa1863ccbdfa98ebf411923ed4a503a44fb75e9009e49f3f54ca3865d43c2031d04abdd65a67e69b665d6eeeb9069635597efca0869305c7a9439d944a1d9d79413c20d3b369ad9d1967ed4607403aa5ec62355bc6c814a38c5272e0bb597d54b07201006ab186a79641dcc24347362771584b26604e9c282cbd932f709a86417ff0feedd7bc9d337348d7741de99a8eb3050671e4e8faa5105fba8c32521af807ce27fe0c3c5d0627a5f41d8ae1f2e0eadb737c876274782019b847f64df770acfeb81834b8bd2d3783b16a75a3eac0eb38225abeb8839ad569b5e933b4d34e1ba7dcf0d09175cd2f75ed4e1f3a8a52cb72cdf4f8f525169c86ab672ec68f88469a333c3dc2342b5d9a83adc61183c1aec39a56ed962dce7ce8a86a4b6aedf68a2335e397427cea3413594f8281099d5f87525c287e81f3893f6b32b0a5e18418ec3acc923bd4e750f59a8938adb647b92cf1d0d1d57aa977ac7b1ff6868ea2731fed9764b888a70f1d75f46e71dddacc0860442db07c7c9c2622b7e563d4e2ca4714829031eac0d13b76d1ca0c5a54712efbaa03e267766619d6e40bd9286bd04287ef508b260f7ef0d23bf80ea5beb40fe742292e2fdd5d517aec0283add89d335b49300c7d27c1c0e4a5df00c59f9e42fc49147d3ac1d5596bad3786e4f418e58d213152fda5025fea9204869060812b561cf183952dc460e9285200e68a295c968c408b28acb0501d8f1253703c4a2c65991351502558dfa118265259129c23b22cd3402035c58b9328532b98c28404334c119144135b840096859f79abe8b3a8291c28818498a128324a49cc24b42826593c791d2d931f14d1840e603c795ad2825826045d4c20040e4180814d2d3fbde5493a384a509d9751a4632e8ceae1651805850e292dc16589aec51730f140032576d8d2450bb4c01e3044982b5154801455856322cc6209ce149c1ac2e0dac610ae61c30579019c273826c0b14168c649bfa0d8c70ff4a0a0c43e84d2c1052f03998ba804cdd6a4410d19a311110000008314000028140a8644029150301cd0c3b4ef14800a92a442664898c8a224c85110c3300c31860002000000006080210621a3f00187d1dd557e22de7f9f42930d059451be0325378f52e26f0ae08a328bfe4ece4423c9b392878a10b80e10399a4e4385d24d0aeea3e8f1e04caf916238ba9d881936c86c945c09da77301ee3c4eb640cf2d09906a71397fbbb4aa4c6b3bfb3a2f4e2ee2e917a27a5750afaa180181e0cfaaaa30ad8857f7a11b8abfe6903813b5fe62b20b7b30451558a2b2d700396e286397f399e3a298d3b899f72b4c4372a5c1bda91d6abe11d413fd975f08948c4395c948e48ee0eb9d694d642a9c75780bb44bfa2f1c9fcd8cf4d4cff0f8ad13c686534783461e3d8feb267b85a2a881e0a153b934538fbf8a01e5e6147d1e965e59d41a7c4157715ad6054da15b47a78e55d68b5322f14090514313c3eea0014709b9258d78e12657c285cbaee6a5929de77b7457130ca6ea0ecf3e6a49b512c2d253c57772ba380c7e4ee6c2253282ff4bb8a96b8acd83d74d525e54e54351529902ad60e7fe945c05d9f2200ef2fa58029b17cdf614d76685bb981715b186df84a5df1bbb2944f52ea2363ce7c23215ee0eeadadb32d5356ed3c4a1a42990694b14a390eeaec462ba290d285d85d3f656028dca070a7d02fcaa34749dc6a6726694ebf2a26162bad1cb6b753acd84b799d926e0a312870a38b036a833b59d4116e523043eff82515d824fee88ae6f34dcb9f45c4749a3b298859ef42567a31d9d5ecc4e5e9eeec1393947547194394ef29bba4d8134aa2a5c0b8baeb19654bd39f7848a9f74001eb28b3a8db8d9a58a986db89f41a1fa7a6d7ced8a3b9043451bea7e4020afd147429ac529e4e8ae26276fed501296f43995c52c6d3df59cef4a21bdfe6ea93479546ca7429639d22a9f476a1925246793176d7570948017729a1e1dc1448cafe16c0ac8802a67388c69198aed8a7bc064a3aa0109302ee531477ed6aa93a3afe9dd6ea1e5312ebb6a3a5f4b2ef8e4571100aae947b52127d52b08a5154b9fd6db0d5938598ae864a1aa99a52383d05c6faae4c623a94f543292685dfa41c5df72e942bc4fdbb6a995e3cee8a554acc7197ad154cc7ddb2565c3eecba6542fcb8abac542d8e3b2d1339a0bcecb2a3acf40b05778a7e51a04d79eb090c999788dadf651f6a56fe79f3bd8ddd415fba75471949106fc4f9950a4aacb9770d5aab90e4b81e9e08534285485a002c2f6d0c60b04fc795e6945c1c9c4c3308e8119573d057bed574d2d0fda8d51412d7ad940a6fa3836d35162a76b7667ce46e747ca727e2a76fa92af2bae5447fa212962fadd02003354765894a7f222c9220546c08cf7e1efcc163152fabec042d86219c9e9316f999ed342e817cee7cf8febb733e5f55fd24aac21037794ca06e8e96fabd7e31d3fd84c4c0f0c37c69588a4c2aa7cbcb1636e223893a5372d452574df2f5330828685c3d7d3a3d56913dc3339ff80101d5341ee91e1fb31b806873ea8b1f3f6bfbcbd7d400bfa12f528b8111e86533d9e25cdf12fb100e90bb0adfcfe4fefc8224f798cc1a7f49f40eb5793bce2551fcd66367ba9d534b4e39c3845195c299248e45ff71881da7f35ed3ef4459f4156e67e5c769e2570d6edb8a09b97b1e86cda331ffbf329fa075e82288227376cc0150dff7a4d2f022b7026760b7652c7688ee0d8915930a2381cc9fe828aef78c90ef4e8bec41c732728f07d63dc712c0f5c3e6464206c698c98f2512e54bcf674748e46a9ed8c34b2fb7b8b76575441af4e2ef06bf2f3d4c0cea51a1c269508885bbb2bf1e2eb9eb45f8ef2fafd0afe53d867b82aed68fa0d14f38cf531a1b7f4c92d922ea6784cd1c2c20fd83f807bfa2272f31370537de8c795dfaa427038f5b8b3cfe19cdea39bb546ea9e5a75c6f4e86ff48a1b3c080d57fa4c64544d990f3025bf565c8d0115e20ffc46cd79c1d1e5134bc26f000d83135383718eba0779e88608b7b3efd8d0f9800050a469b6e8291ead2fd5e5f15cf5aba96ccbe1cf3246dceaa0eebaa3870768dae92b463aa6628ee74e82fa68ef89329aad9bad8ea385526ddd0dc15a77fcf4020bd9241c76310ac7f4a5175ca97bd129dacbfeea4fd399914732f2821e1394a29b893e1e559303d82445eb64a8307ec3d8cfb1b0c864862c8f36070f3502e34bcda1cc82514271539ecaad3cf5e27b8d7b74a4e8271c9832d6bed84086fe61db3ba47dec9b8846be3e8552963dacdd123c849f37f518eb68cb661ac73363423cc674f14495fcf8d81a14a3c57cd52358e2e8b08a9b55ef21f348d8a4834b463a9cec06e7542cbcc21aadefeff41939165556258344aaa22b526e1d2ae4d077166a46f36729da925ea3aec952129c2cb4a4c963c33468049fc5b20c0174b4e762fd5bd097859b9b53c4ee7020b050cb85c1cf12898d3204acdf4498d5ddcf6fce55fac998a0b5dd06684a8d3b2eb06542a50caa6716158fc5ddf650e8a769bd2f2ed4620fc052431411bba41b709ccfd08ff5a288e52cf8d3b63881dd6ad8fd7b9524c3c3f2b905d422d81f133a25c41c266bb9c79a73c8701c66046e80d41f95184852fa24867e8a868c13a55ff4bca78bd496cfe75a7609dab090b96d4fb7e3b23d767a5dd376c72d19bf20a686a90f89c3a65c5e673e93f552872ec09ac03e4e0903f3b5eafa9d7686a94ce85a0bc63c12b156c13d423ef085aeb98e8e21893478caa13dd0e126c0e0b662bbea6cde8278f81618ffe6b60f0c48f6bdb1b1905199e18cc76db516f080fcd914c37571a246ee13fa9e49c19e823c9f021781cfc389b20603b218e85a433b8c7559e8fe245ce3e2097522741015cf2be5d11a6da287865dd3690f7c9bbf70362485add4e0d3683e2e1f2237af769733b89cef995dc15239c674ba03946173a7dee713c09900273c8bf823598abdb297d32385cf0667764bd11e434193538eeb401b0e7388c0ad9164373cc6ba751a3746c084322ba2213f8081e9bccf227155060291c5201142bfb7669bbc69b6911665e5c1529bfd02471129c0693bc8f012efbc22f8e59df4e5a7c4f403e080f0d48ca292e9482cc5cbe16427dfe00034be02659a7de16ec4e3faa0c53328837b8c449ac07c284eeef7428edde48fc271f447e57bdfd48a4786cb8d457b44d2a3e22343c7eff53b0783e1bd293234a2f0c8ec8b5530fe1d8490c6a2d93ecc3c098890ed59955e5c48ff70d46fa9210bafc046218298e38b7778ef696a57fe402b120c7e997ca763598b522162103dabb92f3ba033a4ea2a8080fa7e388fb7624b778ead92246e803a7a2d30165d4fb975ec258b9ef143dde6b0de605ca95aaafcc87de7f2d51e90b8a40811e99b7d9845cb319e4039e14bcb4019e2dfa58271b0d4e2cf62071d527dd94ed921d15dfba988fd4b34ab6a18cf5aa8b2c28386b1bc4c38ae7464e26aaced8894750e007203d9286f79ad9a414d9676aeb708b7620b584eb12637f0e85939fd5582cced28cb68d8182121c6469ec416c70d89337818051511c0d1e852d2d3501766b06a8090d5003a664ba96f57ff06bf02c704e75e9b2ba096c463618700d1905644c5d2988a8b6bca37b8dbb893f0cc064182965cc42bc6bc4375e16a51e410331f03dc01c261355b2a2884ed245a7942a74cf75e9b4b204a7d764f6de2f49216e12b14310b48a2689bc0fb43e72c943a8524416557586966a95f947c8c48a45e4f287312fb7e4e7c7a7a3abeb55439f10357154a834fad8d0872f90e7255a99d4e0158c672fbd120a155e050f638f373dbfa1c001b57289f708e9241a710a1c9636db9fafd07fd31ce28b0f80060ad48a8a9b0241245ddeade0425ed2e38d73cc14f605badb5b0fd27947143426545cd7a2b71535df448a9b70800b817c6fa8669db243f3386dda55e3b3b84ab027d551dc46a47f89d0226e013dfb521b0901dcacc2f953d1b0c87d87c344471cfb9c27fab97b20b8c466771a4e1c0806b428564a848586cfe4bc2ed88348edf386c0d4a59473a1b95ea0159061488dbbeca7c9fbea8e08ba941d19b4902491d80c769e0363fae3d307603cb3660cf5c866aa0be78cb387ce1726433bdf63a05654db0ca7c4d1cd3dc1d7383182de4e9fbed7e9f4f568e616af0b90857ebf0af02aef23e0408008ec59c3d64c013dc3b8d5b8acd837ee85928943f91f88cef536e949902107d62cedd20a25c7d5e49ffda3dc06dc588a7b26430911fcdf484d188200ea8ab5778e8ef4f910b699fe521997ccdb744c186a51823a773e62b5530e4102730887b85c97fc5dc2d2e8b821f510c45c7b7a667d7d57ba96b6894d0fe05caecfefc8e6dac981d5c39e353b437ed2c2ac41c9d9a2ab33599c99424bc83697606154e5d20347b05f0508afc565a0c2adbfb2363780da4231e23ab64449efb87f8da29f1350cb10c665659cc7ece6b4e2ce76952c3e2980c667b09c8574f5c096f1691079bffb679f286a7c8a10045cc28fe8ebc5aa3828c2a72801ae0b4386dfd1a5f187b7a5a2357f8ceebdfd2e3a43cd7b12ae3d3940f33afd8b2e0713b67368de9f446c51c0ad0afedb7252ab8957c1cbfe36553090d8ab3d0a7faaae6b96fbd1053effc55207a559dc9bc1f9233043ea1c3f137a617768b90c2640c2611b038ff177b5c4a9118389f416511d7af077e622f0911cd38d427ba07d44284ec47467f03696901b8f0f355cd498b46865cc6ef2e4321633cde396af39ea7b39e8486f400c0ef0da8335b05be01255cfbe7fb8cb4bc229a8869ea99490959994167a78a013223718db851ad107138c2ace23010339fb837fe46dad401bcb999b20d58c4cac6eff99321f93e0673a38a74011e6800d5077c39a9a236ec9d3a433b9f80208068d1416ac8c37f2183cc0c3a5f06501bd1c5ade1097cc7c78a129c53cd7314135e88fb4c603695775361e1cddc19b8d21f29115f98afc4f6eb7a59075e95898bacefbf25433ad2385db1d9d692894575cc7f341ac6d3e4c8cce650ad04551d33a931cd317dfa148bc9d625008efa595c3492bb8c54ebd83415582be14a9aa36d485b9855afeee31981c8a32088840e02c8be12f790824ab98ea80e13fd52ce172d8cc9705cae0012450d9b1b45839532c184dcf14a5b87deabc6feca921ef877a1391bdb13eadcb112a2328ee066839552eae246eb5c8d948f8d46263f97c48b905117f41ca7d688f5c164e93926323e50544515eb8aac9450395f89145e61745c8088c7d3f2e907921a8f340df824c8d616c53b5fc4664a40449c8954b5db72207d1a19c800b5dac20f2e5f1eb3340e46b680b461574eec1ea1ec632c35010ed54b0420c129599a4fa7ba9b15fb89da6225f841344a05a207605dce8b5e3e48f4a3a4eb8916f2004fd8eb4c59d2a7c4c12e72d1bd58d171166f4e2a1e45c3915e06b63bcb6678d9611a10d79a0991dfc0a56d0389c51598f6ec1194fbeb92c29326a11ff47ff34ba853922bbe42a21b474ae4ca0425a00cae632b30a27a140d58c98f8b073228caa9bdfa01280727aea39aafacc51f5127df7be7b101c6a8ff9c19ab5e28f6fd4a802a03f15cd38ddde12f8b495519f6fcb62808aaba0610c681ffac0962f04c77eadd01f20f8ac3e3b150bd8dc0c4cd29c63483080b0742712127502b449321527950f96b43c1a96f99a785f301008d7ae23f1d1bc348496f9651f3f5299daff8af25e841d5727d48903913537918edff8ef3abb3166dceb4a3783d4c41c939ecac59985fda5239527a95023807ed61b1b25445d6d21be2bd4d201dad589938ee36d3ad373c5d0ae207eace1913c4761d299c755fdd8107d437aeb1d3f6d7591cda02321c9456e403e471677a3c127df6570c2f756fbc89911f6daf19ecc836fda79aa6d5f0a9d10569ef871c8d8995f644c68b9d1ea82a76a541f598fcafa5c04939f545e4648f3d3a1a126e6f18013b3959974aba7f8232114d9c6fe8ec933d9579d801f65c0c5335dfd0626d0916855904deb8b1a3e5e7faab05214d3296cb1d14578966e070ff8d4df82e6bb36acfa13a6db801ae1f84bb60370ad205b7c1eb993375c64c2ade72adfa50ee547a07c53ca5e827423a18a9032d8d143fff7d42c247a92c782b7e28d250ab8076cb54a448039ab0fd8156069ae2d998886e3be2538e2f69353293786abe60c5dbe9ccd9d74e60d24206114080b81b067ed95bb19d25d11a08bd2d6444a350af683e71ef6b992b5a223e8e4d460c687f9419ef0e4d01885df33d6131e7c1e556892a0999ecef1acc08d626004980ad75b9ca0dae9ebfe08e123b2b6a160f49608e797539854bb4722a2a1d138106dca2b233928304399954f45fcf3a652ef0a3d7c379f50767e4277255d524dc867cc6e3a68809ce2edc555630eb8e22f94688a668dac67de041ebd51d8dee070947c7ee8dde18d2e6007aebbeae5d82bf214b54ce9fa0db370df71999258215d1f81c1ffda2fb1b76d8b95fcab0c7bd67e49cf41e30d01523b28e0dcf02f06292331216e64ec08e2410385c5cd2b84b496348d65d48b3df5835e811b39b9f129f285e36ccab7e15cc4e8235954dbc31e12365e0dde1011f35130e17c6038ca45bcb2faa2d5005fc177f1d04e00c37f29dffafb42e53c4bf0af849895a0e82d242f1664c10bbba7803e9158804a2293eb9b9ce5693c9c0cfc0b2fb9950dec30fb5668b1919adf27077ca2c6ac1c2c5acf71475f0eb781b611a20d8af71c9d7e5a498b2595efb9f6f634d3f449c32471f5d1e8de88f56ca60bf71ca50a802fca813f5e0e07cc24a48cfd533dc5182907b5ec8f2bc5bf7320035c1297fa14745199b5d4a5f221fb91f03b1f58fde1eae7e934023b28ae476100425d93e81662e6f72b7131f6f773c6d97aa9a51a6e7e4a0c8258bd8bd88276bc8ba526660d9bfe06006f4062abda12c8767d153a68a3d549ac9057afbd35781d0d223c4249169f5bdc3abfe7d5fcea5b5aeac0541919f6b570519d7e21d8adc55dfadf0a1ee04007a89a135f0f61b07e639c13d0978e8fb3187629ad03aeab5c990f17ac8adc329e67fc303a7cace88a87f633ad1288b013e5387ca10785fea652b70eb997df48f5ffbea034ad9e65601c3861adec7fc2af0be7edc7c21c6a05a13f23cef77ca22cce523902897a2e5f5167dbb533f28dbd9103ba1843e80a478800a6cc2260c2dd051b39385b3b4ef6dbef1b174c4356a0349603261c52ddfb74115ba02d5c573900b1c38c390caa6948ae7065437d03ad66da9e234ed726cc9e529d67888b80c6efda60861961f837a27ef1a9cd0add55dac9a08ce3464b998e5f3734b014d6645ba564d308a611e39b2ce062d5cb8606a4b4c30cd00c0cf8c4cbf2021480f6e9bd30d450a9afff13983b177ab60d37cf409262397a8120341fa11ca700340535e0f367fd6de530e23a8557b4876e7738552aae55fcc5100c3fdf961080f88f4cd9c94250346a1315a7a3b9118a65ab4b7037629a24c3e026623a7a183ac388ab967900b84ef6e23b84b09f3650478db702811fe103d8289cc1e587d061a2c8a15b1354a89b01c612a08845f42982c66472723a12f93430b60459c3472528558d0715df6557d748acde66a367efa02b6a41dda5c345798dd0d02a396e0a0e326edbf368f98e6fa23802a80f40b22e176b85f6ea350b962fb601d7880ab34c2162b1d14c8e7bfded3b0d8f80f2dda2c90d99afd9cccf9c25914e8f97769a58937451e038277b6547dbdc4457355a276c3d5fbccf9ee81dedcf0c59146b64a424788c888e136c9e48a75e5c673bd5ed9cc45d99732e3991b48e08ed809c96fe10593e2295edd8f8352edea1741e40f7e06858d793883cf11431010dde487072d62cd444afa7ad752402a93d2e20f95ac53589d45761b38a1efc6a02e47699ddc07a0f7fe5f02e639f05b2079ebba4c43bf6ae48d44b02304ffce3068a7aa2769686b582e7f045eba2bdc10a02321207b5a4450d2cfb6f13302ecf0929162d53be9e0b87aeb78d7633e9761bfccd1856a997ae43a61762fbfbf28714e2899ae0dd772a73e262c7d2a5b772fda2d9f449061a92731a2cc55601131c93c4d2d8673a03846ef05013fa808f0cbfd298ea6d6f682e90925c82b7bb82fdcde8350988c6af45b685677d6524087b432b6d884eefd14ad490a8dc1762b381cab4d65277399ab03249c1f4683f6202506b2cc0d63c75710bd0ba9b1eae0b6fcccc82d2667bc490d49edef4688b5cc5ae3c8d4e97f4cd45927b336e30b8fbab7d4545c4210887a009594ae4fd7cf4df4b004131e3ff47b12702eee4f7a88ba4a56064f4acc49356b800df33a4d22c9292d69739412bac78cb296697c3150492df86c16e1f6d9680552b166ac218cb1413d67f3f3acbff8a6393599575b9dce718a1cca972c09ce3d013d10d031abe24e09b46556cde3d7c8e7bd37ba8d1a916acd2cca02f77aa51a1ac445eaef1a1291164ad5f8c66bbffda4cccf618869fef277dc7aff52b100b1058ab065dc31000cbe24412afc311dbe60526be7a3abca1d53640e9dcadc1799b8292f5630cceed648c4d89876a6d3d05c2b8a9b68ed085e250d9b614b1fda40f8b9be23233e54c6c72627b8fbaeccb19ea4070d2c0973b1677b69c28fb6a5e1c944060aa9bf7676170f48ba0d7269df799f7888596868792baad32283c34d4fd6cad4d0783d7e4270340d7eeea996677fa2c5ae1009ec5565fc26181e4d948384790cb037056ffeeab3fe7e392edf66a5848c8fa6eafb9ed55790da49b75c2398d7aa0b24d59010131117ec349f925b4b966f6ce4aa0ab1e2f720fa3c4588433edd72884b4be521ac4836744112c2c4e6bf41ce07aa247116a5b5b5fcba1ae29236b0a57993e1f514405d6e323786012c123476dae1522408e203523a0b8f988e37529a70728ebbb562af304224fc59b56c29f6d6e203914f5633c3b07a11b0a2e465e5907d9670a51f04e4bf02882b136922b10356b0a6429c8c6080b71e959c5782a72d029060343b5c1bb517adeed9b831c2dbd98c82909e8c28c9b7510581b6ed71ee66056b6a2d0314fd008cbbe82226a5a8c5e7db4198b8c2a215e523435a4eeda27cd1dc886b7ed8496e66d9e8cf04879508c00cd5190dd8149cfea0c7e9bd4b6a307b4d0b4a9e8017445db6031a42ab37f6b7893c182943427055aa527b0c89ffd01d75dd625d49d875e48bccf3c5280408831b85f60c9e67edc88ffb1e8f719514807912b66adb3fe1bb713681a3bdb41489a974bdc1262a3dcd1c41584d9a579b73b48fbffebb796e12104f02b58c092f8830c7195e34e3e114a3ba5c9c7f96765b0635016496b92528aff3f6b80373b330161c88d63f8027deac142332e1bd20f0641424bd15cdd94036e60c1a4bc30c281f09a360f58fa7a9f9aa1373e429913d90db84ece7f39344bb321807d3b4d9c940a55ff32d0b85cf68aa9c7ef19535dd035e947f2d02f53f5df9239af1a232cbcdd00526b649b4cdbbdf4e1acb75f32940aa87f0c0adf9749217bf9099ef0a028a2ba1ebf6df9982f91f5868a38332eb2ba461838b088dfc61ede55bd0205790f8fc2223b4fde88f24cd8eb809dc517257339300ce3454230721e79e9b2c12f61992460ac1612f41515e4613db17389ed1e4feba499851cca53abbf46eacac72c457a855c0d29cc9a6f1fc2c31f055d3dc874d360e6432a6bb8812bf5540ebce2f7552be8855484de83872ff9fdcbc8dfcad010687db8cea53db1e1f1589ed807ab5bf9da0b6d1184cdb60e8f5bf7c5c7748c495cc75039d13ce992b3521b3e8bc99e7d32cd8dedff6878b7943249a217957f596ed2a051c8a5120f08e6e4f5f88cd5848c48d50e683201f0bfdf0e1d419b98ae714f76b7e625779bcf43ade4883b77f7a04e048429030d652d528b429d565fbdf519b93d3fe3911040ce693d4f1756ce23033c8cf710dffcb814d5c55ce38b885d603af59e5f02dba257b72c6381376750b4f1d6644274062f57b7beeee4c536c093e43e70f8e7aea8a487d9904dd1ba33c8d4ca3660a744aff63cbd61aa0a0bb6d22f67e46d85b7b965006fa69364e8578f76893277712bcff501b65de94d5f3c1fd316df39bd9a381cb6bf089f05ae675a42f56913c975afc3ea529948afc92381f0a78d998b205cecddf050beabc96ccfd295dcca2771b7ca44a27da4656e1bbbe30633e1b91b8d488e36a5c68787ea144d14611ced8cf2394294027df2bbc060681c62f4848e544723aae05922f5e33217bd11bdc5d4a400c4c7274f4fade12d4617ac0c19eab9c40553004a750b72610dea0614a3f77e50a061705a955473024851099aba5c2f65815a3fd9e9d7a0d541ec3df661b9fb42775526fadc25c517fa10241299058243f3146415774a24251135bb2ae95599d78d7f41935ec54c322fffe23ba2942b089709f92d3545c29cede936481b48a1d2083ec043b1be1b39ba29d48553f6f7c2fd58c49eaf4bca313fa67700d33bcae40e675207318d238009f2c7ba0efa4b51d6008c8959b0ff1b1be2c812c43cd353f775c0b2126a76c42ce4aefb0170fe9e2dbc616e2b0eb121202b1345f89a8dd4d558e968683b65cb65cfe31f1984ad319c5418c153e22532998e5cac6725530f8c5e6e715bb04b984b7aac477b12c79782fd5052dd5bde8e2db52284de449ab08d4aca60827d3d1e7a2097884a16af78e73edf18f59120026996ee16d13f38b3ca7266897ed391b912717248c2ed84d019c38cdd140b70d458cbc5a490d838a9902c9d9116993f50b64c013c46462d94e21d76716eb612e8753fc73172b5a6a22d616302547ba1574700091787bda908883a0365d8b92bea6c45e1fba25014a99b9d01e002caf3cc4f0f2bb9ee6a6191d4b08d548cd26f93517a9b5460087cc2298cdc64130f8cce951b071d7eed5030f370ca3fddee7a693042e8706f5c5b2bed099b0fb21a3201247b242100bab8cf201481e1023bca74011438000bf3fc92e5dd2335cd383e36c3c9b03c125ff7f711e0c8643c03dbd4e95af6fe61e133ed224afba0a6357ef3caffd674c3afedd66720356d15cc443b08a05161b101eccae5870679dee12c5cf1e323816cff112ce8e690644cee8593f4ae7ef12a1c99ed8ba8b3eb3e78b7dc047bc72d17041a35ed9dbd3cdf7a0b92401cf661e52c871eb337ef4682872c304afece7fcd2d63d815ed51c956cc78761ae50e0a1af2c08aed7986cd6a11cf0b6762a355073cd8aed68a240c0ef9408b540f4d25c64565a618fc61a195ace2a7a64484a10164d9dd2305f75e7838718def24ded0c392953ecc786b4d49ae1acb59e4e2c9b61a83a8436a193a4db7c3d744f13d08f998a730084df8695201c75e1b6f245cf1ba2329ec38fdd2982b958014391b1bdba2394e237d5a56c62f37224978a6c9a9f454e014463e796252afe4e8e358da6c007dc6e7442bbdd8320ec1bdc0ea46fccd2d8d331d0e27b675fe158e08efe41d4a03356f2a96cd2f864bb994a93cb84479b61f90e00c88d8ccfd2ff0a6f55e219cedf19a05561325f965148c36781e2471db0c801e0ec3faf7c6f99a99903c818298771fe731d9d336f86627d00be04c899c08385f238c4442fd0ce42a71e12d8c874b634239d6c40a404f603dfa8c392be9c698b4961ca1ec57a88e3ac0491f202ee64785bc8daef949d822cfcafef764edecf9f90d3ce436ae571cfed810e5281d1da70e21792d81e8d8071d5f4568ae40c0eb2dcb70f20238fb95a39cdb7fd7863d3fe1ec4baf88c06093687ea1d3c99ab1e6694553711855a768737ec964a13f2d843a34343736c759aa077ef9f25604783f4a65daeef2da3c24906647069b9c1a1a416657168c8aedde5a23227e51e60f2c451267f5e9d72ecc6049c8fca2a2a2dff6062842f494644434db9877472e5c9971185f97c418aea802501d7c310d841261db506d0fdd520ea6862c442281fccaace14e554196d1f4b717812cb75ce41e5067a3de15c1f909c00d3e6cc03f003657b00fbba0a0b20ee3b129d8fd17c86db966a43544ede6318254b8f7828bd083c530ad4c3799d2cbb6dd7a1eb61bf9a4373ed895706cdd7471f520163e8a2c1ef31f8a2557b6ba60a12e7987df1eaa2474d94be183a4e259f19f904e7c52115ca4f1805e606bd8579501e354c02478d02d7177c9884c50079871810f6670b1fc40384b825485504374277fc3a81829ae908b728ee93afef515d2d23fe46ab90ee06b6383a54d698c360c751539d6ca282829e380d2e9f19141aac0853b2247a1a197eb0be6c558b402fdab9fc9fa5e3ccc66f661306c250c83b6842983030a0c1c34117f25267f91adc0f67b52a9ef788b4606b5e80a37f0250db70dcff3b0ac05b1f870ae5b8b3d07e63c2f262b89cf7f9ccd6d615998e35d27c9a8e45a0b36d510b18fb43c1592e740c418a01d4bc43f1ae5fb8235c52ed607ad1f1023898556b2f63c713f7530785c40eed80151fc04e6aabaad634999ac99008d275a349f805aa7c946724aa2c49dcb027a61d3fd1057cb4e40361a73214bd5c6ba3875571e2e5e93e26705d7b89d8fe57a3044434c141edd22be318347f6bedc3b27e2a0ce8236b46e0898a6191c53022b9d5598e7fa5207d07a688d7354ce529241e4a8c175fbc7a5dbcd1c9dcf0c5465a82ab69a45944a6bc1aa248c96adc23bdc04636cac0ed5f487c3810ea96adcbc22b2de65f5d4fe9644571cd86162d7907770a84bd5c4c4b6745cabcf713ca1b763104f47f96a68490c473dfe00cf52dc7b949f69db6ad4ff0f728cfc8e5310ae652b67d1f51d7dfde62f5784649941a7d1908db0cac1e31d2c894a13f024ceabf8292bb6b7b49182d84f8f3b9b62b7344550c7f87dddf116c1be42d7467f420df29223906eea47e0653b86830e38210c9f09804d2295b8893bcf799e060532f1562efbb733344554cb92ff55cf6a7e8647f4757a06438099e6f84d7526507c606f81168f905a9e66af0135746d48b150ea9e9f0ce3e347d1d141846cd9fe2c01e27da7a75c90e7d484e4782fb8e109e3637ec2bed26f85134b586406be84fd036fc425097c2b016dc33bc7f8d5e71ef2ba4c9148c6fe994415621e33096b7bf25c6353b96640d3f9e135c384344e5456f7e2b82af74608d0de453985248b6ce6f0d1016b72614d884988ae88e81264844d1a3d35bfee692309f65d592b8e1aa77bad7f31631635011c22727eaf70102520d64c3557fe05d1429f060c7ed043052041c68dd5724ba3bb8d039288f965c580e7a5d96f82e5fa370932cc1305d5a83a8f43f9d76e6a91dde6826feb089abb4c373dc285ccaab5a823c6203ae4e833c01d3da12ccdae92bab012a44fcc94f9cdc9220b7e96a0003b635979d7d247532e4fbf51ca0f2690b6ca87a49332954c6725ddc2d99449e9270eb507646fa527c1bbe3913905adac797b0fa1d4db8722f1c61bc6401f6161edf87f34700829b1ab6431182084a0eb2d13f8737419f3cd13f0ae1af5fe803088d5e8b40f014b541705fa6f34b324bfbbec5b3f8921ab5911064086220dd4ed4e6bf4848b6f71722fa5fbfa9d9cfdeca36273f8e471b0d31f02b09b5b1606190fe809e4c04ce84146fead07004fb305008fa91d296cce87660574262cecb5efc8b1a0bfe2d58690eab9854a393e2dae2a16831e533e7eec032ca47687183d305ad9f1d840b0b020f6f68327551f2276b0b74de9ee29fc1aeb0967be8046f6353580840af3c4b8fc2b5ab89bba2797c897c8cd5c9017807996de5fe78b0da19f530c6f8bbbd3e6fafcf74e45849a12a598b8b1b097bf674865d34e60bfabba3332330e49a15140b0cb4172ef95662dac88300856ee73766d0db0cafd1c18ad73dde6450d85710bbcb1ec92611d76babffe00e0dbabe9194388bf67a3d18f8677f068d9e2ea1f1d7e1d50c15de08172fc142cd253bc8fec388037794ffd1963e4052a909b0860d4f7bf7a8792166e1e0f38830d0a81f23a98d52a85ba6420277a5013dcdc5ab00f449aeae25eca533344d7f99417eaccc68ddda717ef589af3fdd89021f73d29050f1d2b7122e2b8508b6607ff30d5c2d05e251c507f0da85a00ec7a389da3f8b41768079f14df4cb7745f7523aa2ad18e91332ef1c955c155a1b147c1a2425211382436ab6eda134bac62b943afe1b12c32ed132a04bc02f3cb1b06ac9f8677969b913689f6b1e81b5f7a277ee47c84272a76c23e02cc8ffc4a364a85092a9d512d7b7e4e3ac288adb1c9f7d558b4afd5fc437867a762b2565a2a2bfe19ba882d13deb84e3fc8eed639229b66c5ab8cc3496f4885fd56b80074974283e13b002216347144255a1670d6d7635b0c8d6c30f8e7816ae8030d8de2b0f0ea940db662e27ee4c2ef369b5a504d8d07b7c51a2e10a96a215509e930a87b90aa7b008bd05eb505b9535bdc2e5d5b6aa5b0b4039b86db2f729892c7d6f149f2c9ddc53a984f9391dc16364dd8667018145ae4b6a8fe19aa97b2273acb3999dced080e32b24d30753067ac1ecdf3dad341bad00b06cad57e3f909874a0a7c698c8d5fa00758767dd6dae7d6ceca7e35974d85eed14080ec4dc99530bfd016818e58f727d12c5e60af10b7790068bc1bac0e8b06f845111f6552d95b60a74e46c63eac7b22182d793baf0d7e32602effc51740b02cfdf1ca844266bd8606e5d1657a2a1533e78b67674ec4f71e6fc6b07523da006a31262441e3a3b71967abde28d8243aee6512823aff3fc96e740e73f61a0e468774abdb4ec8ca0bdf981d0c46f64f82041f38a16c69dd9f90dd1d6785f91292e472829027ab23e0e7143fa5792fc0ac50186651f4145fff50c447899139b3e93258b4bb3f84bd90f4a80993d63ba21e28d4061a7be2fc9a23abce9f0061116cbad22ac48d562e12d08d6a3224b2ee765c8b1c7aad3bf2e501b8a424eb44873a08ba1fe8bfc935b94d53a68ffb9203876be0fb454a95dc17263f92e6dc1847b7673093f6b4f6a5773991af86f4e1b1dd8e30ef4bcbc284a21a942efc6a69154b7a3291ce130a0225ee5a7aca3c04dc57b2f6238df9868eb0633586ab62528a5db434b681c0e32500e45252ca4b228a83cf3302536c7a8a679ac6b7f18ab6ff9b6e303564878a481c05dfbfdff226f1a10022803e0021e910087126d1a569cc6047e86df6f1f133a76df023a66f7d6478048a8f8e239d08e643834f10c87d8561cece9ce81232a19e1d03b8152d68fb06c0a28c0f661cce45ef1e0892b1284f09e20eb418c4e74277333493cc4d060de353ccff1a9bcd7f20800ae8890751a1f388d4e46bcf06c1d6996e4735e2c238c4405b32c5892ea0a910a52fc04263abab92677145c00be80bceec69ba8d3aae12c03024f0dc7e546427d670b85de81f8ddc821df8e346e3015cb48f83c23102638eee5a1d94b86bc5d702f5e8a5486a5a9340fd5c38b0266ac93d8322e27d3bebb184c6d8912708763f16e4fc031349f2e641064af18a85bbc8f92291c115c3f195812ba8636399e1e3f973ee3c324cbbc3d57d9ba92135e57ad331d9e854a16e3a5907366d2fc0ef5027bff9d4e40f780c8a00a6d8b65c4aa0b65ce3356df6739a794133db7a14a860f96b0c834a046fc4ff1a07413fc7695b17e44d0413ac0529e31182a4d75c97e937ac5bb5dbd61af5c5ea549d63fa83dc6b2d1766f761e9e21ea624dd6bc4759f192a3548f4f4624d12dcbea6e7c314380478a2ea9e0147f1e8abade52bfbfb5943333ee516a529d90819c7cf5c1e7c65c861cebf99fe91b90a57843b7b270b6c0cdb05a19d207da1d57792565d3aa4d393801a04e4568b1ec259c984dbef3eaee358bfb12df51b7f031548165a4f5663163668e72c1e6f4e76916334644eb2174cbda21e80972662bec32c5ae68e65a56d045c97a43c596a7bedcd0f641a9bde861571414379486462112ddd9157cc14fa77bb69ee6b158c055689e0e48eb29dbd6b238482a805550cabfdbf87869376b41c56888f08e719e0872e3e002d20434151973cad4f6bbebbd7e7037916e8f880204881beb02231e36f30da7c7a9b7d5eb0e216cc2c6c3930c0147d63b1be5fac9e3d8a4e315dad68d3a21289900c8036fc458240612dd2faa98c430bc03a0335d99e5c7b5d22f96cd8eea49875d4e987da7d77c569dfc8f0d531e331f734710542f706083585a87982de57cb466b44a21729df94ade559c38b2c67885577443857390d3beea3a51f757f0d4ee72ecae968a37cce1976f41e0960c0c58a278343ca0090787ee46e49b6c70c39432d2c585e98ff65d6bc18a8c47c06056f07fc1b90c6671669cdc4a0cd9317b23651fa17ff320183c9542a452c6e34035c723a82ed54f482a065ae99c2f1283cbfa7710504e2feec1645b56c37fc66aa464f5f71bd4ba2cfab45e6a00dc614a0d8dcff6a311bf0522b2159ece091dd8d6d53c51fa2d21880cad50d105fdadac8baf42c0ed104d330957316fe5c7cb7d31bebcdbdf3bc4bea36034ef7087587542c2d4658e9a5375a41a3d528c9b96f7445059e08a8fe32d7a8d7c961217ca2504023d4aaf4884fb647a1fe4269fda4bb1d7a53c9b504a648b237920bc8a64283cfc63fadae81ed06c1df914d70aced2cba2823d53a27a3e19dc4db7bd631a3318de178211eb4decf2963c332a341d9b6feb01a2129b648ef96ae404a4df174853524e0048f51a8869fc018149507ea9395f166984fcebbf324302f4b663e36dd142f147b17c30d222d6a70b0891d67821a9d0e7c9115219045f3e75ae5a0a0156da7c991912ff9dc33c6f079804445cff34e89b3fe0dac911d6301fa109efdf97f9fefd977072b4b2cbfbeb890821394a5b2ca2009c4cbb82940ecca88cab105e73852800ae70b855886335878dba38cad870c6b61154e54fb6b0b06005358473f0308e7746903b9f63cd2006972aa2882186cf29cb27a62eb76d041a9579d3b477e3aa421859dd6509183c13fd477d7b148dc0d354c67a649e6f99b9a93de5054c3e0090d808e31bde0bfafe505ab3f9f796f72d81af3e0c3f3f93699b99bbe35cdf5e67849a109b627056c5ac9510b8eef598b18121eff2a4bc357685ca9ea670786085bd4ed04004abf774f051698dc3d7074d6d88072c405f8a86629e0de143471f8651495f9217bab7fb671203fa8299ff09d2dc39a2f61d9e42b780c9a4f9c9f1627ea75be5bb2f862199512167b8450cf2b037072813f858b84e065f8b29f2fee0a5f6a07ef160c89ddd01fbad298fa60f824053622046dbe755f545019ef35cb93b4bb793eced14b559a30202cfc0598a81f7a06386ac51f32470a48b81b7d872c647f75c5c5c0fe23007688aea890535812602b69df23705a6f4e51f4225bbabb9ddeaa52cbc92f2c134bd016ca3c062deed3efa88e409ef59b9b810a2a45c401a67ccb54aaa04c95b7f5316ca9c26bb079278a012b361d7a0c296d7de26bee61d9567e792fdb720f7dc3c5f4d3bb6ee7850984d31c4fb6d0db847246f1cb0617351c22e202af11c00a5f602b406c0572dd8390b29b4b68c6dccffa2c9818ae8a3a327618baa6809fc58882b0ea121f8bfa730b5ff0ec76c8791b87e56bdafdc0fc8e5aafde24ac9b09ca07f3c2084c91d13fcff6e910b8fbdc454b427f0155a6af1fdb643bf686c0743c3a82e053fc217d22909c00d53dfebfb005f449b08c67b67880f2a4f85861213a282025cf9f8e0c37eebf7b8840cee436c22abeae77d1f2d1189d322f7f927f70b82632907f9bc59bd70f4ba25361b238e3a0f7320140bf0ae60571f62681029424ae0d70fc66a30ac7533299b5b9667316b19d183849d9f18a2167297e389174f828276e5e5626d3de861ff80a5cba4cd2d439cfe16359a46709708137f18c47cb02c5f7413be7f53699729d4064557d5b7769e43a40c5c50394d22cd64f23bc13db61c49b9280979004ad632bc792181174c4518d224e9fc3b2e033edfb9b3acfc986c7dbc76d32113d2fc8ee1b499d6cda1737fd814bcb8de9717a927d1b0e8284844c23a4fc74458591978049dc4c93d0cf90a9248310ddd464bcee644b73784d890a882fa1eebaba7261d5a9eabc365f12022d77ebe2cea87359c7c1432925f1e998d0ffd50047c5ff7a5e506e4f1520c8958fc5126b444005971601a95e627c7da38d7afd207fe7145e083a1f91105a08e34b1d0bf9b5d865eafcf21ca72e99cb27c808b92ba07412862f63c91527700de2fc1d6f655634a3139b581ad0a3c4444191c82badc4cbda1adea072a912e0479d206ecbf5eb22075c0f924b0828ee4ef27eedeb8f057af385d0b8efac534a5856ee68683de000e1fe8514f8704ab0231f5af407c1e8f1224df824a4cb7f59231e83fdfe71c08d1937401d2146b725cd1201f620023696d71c80dfcd39b44d3f20e162882ff0d56b6bca369a2e69c121ba5529fc285840d6ed403481ea6293334a041e296395c86764b0040f8d2fa50390d90cd458d1a39b5d2004a7e479330f75494b8138f9ceb5448cd735ac262c6cf55eb1ef82abcc0875c3af70e0f0887c4434258a167aab9d4dee0de1eee6982986b8dddfa73e62afa9514c273076b65e0e4bb816d015898b94d53791aca1f6a05c981e4c3caa44e80333a2efdd4db2bac9005a1c594305300865254aba4c3fa6e40639289de799f05e8246a0b6bab741c94ce6b4f3acb55b5c86bfaf12b44679f0c4a421d9e7fc7fe0646c8da09a622953b2db567c75d67b3784cbd364f7560ddf1fa9907cb927e771c119fc681bbc478965222e1a8d7218b7c7c460484edaebf54bf5cd4eb3ea75925238aa4b725d9c639ea93f81ea02db56d1c4049db7c0ba14ad175f3aab633aa7e21f94855135f1adf9df09a10dcb65fa5e5c8653718e889b22cc3a1af2fcd29b1c6c9ad32c56fddd756ca9f895ae2f8cd6638ebf4bd87d2cc9a4edbd65a46773b31b0eda025c465a45dc4d487fdf16729e89375ae5d4da1ed1bbc1bb64577d442ebbbf2b168037ba971e83adc18be2d0b9f670167ac3de158bb4d09284609a3d1a2cf6fc9a027843986182025fecdd00d8cabbfe53a5462b4e95b9cffe5a46c677b131eeb60f7a235114743d4baa6deb25fe092d74ae341738f367a21bfa40b20019909e77f066f82bcd6aaacbc7b5cbef094d6b2a46093f255ee4b37272126df4a37f8905888ff2a4486acc93070375743e9ef77bf3fc05d3795cb9b355c0620704ce3f937a9df1e86628b6dc65054de9909656776decfb10a27dc15f177c721fe9bb8f6530c3efd5cfd03ac1d9c8c70fcd3e716e5c28cfa99147195c6e53be3593228e50c9d00897034b40107d3d9ff1c48740e379097aa13c7545a0dd44f6052d89eb025d108a7ab204042da8b6db35cd69f787bfe6e0ad79e2924e687b4af89c05b14c02e2ea5d866d6143881325c144136917a4a61239e9b0bd8c9af777508ba63613c8f44c8173b210fc1b9b2dd7274758e062ff2f44c147d5a9c9148fc811809c94676f8631ea1259f15b88881f6f987a7bef598a44cea00ec2707b0ef74874d18044f3484ec17fe190773b9802164952616a0028e0f381015695faa9c44611090851569dee183d2fd289670ecf03b68ca2183101ec450c001c47136d66b5d0b84d82d652c396a6593b21c585b95a0a25218f1c1303c75761135bde8c117811af2e0abfb09f8f94ec2331d78efd2525034c699f3cc7becb0a12095df8ff427672cf79f7ec46e215031edb9dc6322ae970ef1e8243fea2ee94495c3ba4868211f32a35c11551043057af8283e29b320ef78b64befda58d4d0f9ca9b005c0e1330d0cb5ed59006f167d959c5d4d8fbf6236bbe882a5525f1e8ce0db26b64c495b2804958729153b881527135042cb096e12f47632412a8389fe5c917884b1ff23e6c8e4901387da92c4c50052c5bc63307d95685cb4756f9671b97dc423048caebaef3d8a103624461f9b901bc9015f2e75cba4ef8ac4a51f641437edef5d6595f361310191402b288401d1d67df9348c1d42492a8cdc1e0e3cf4b9bc3b235e4214ae77bcb51478674e78aee2d3c42430906fd2c7a46a6fce11753e15e9d15e2f7cc2fe4c1abd4eeca0d92d0ab6c1cfb348ca5ab9a63d7e1e537fc8ae049bf18a92a8f88de49725172adf192c1ffe20b9a55e62b60d2c686c7611c9a906ff093b38dfdb721b65fa8355bbd3e6d2138037c9082b296518a82e27733ca85f702394195ff7a75fccf23618fe9ddb97045ef7abf7e7ea6b24a4b6fe4bb4647dab10328772dc63c9b62c78e24524a80d46666c76e580bbe03ce214e415149e9f81946967377cebacf7047cd1d246dc58d2790e60484b7c3e1d350169ba40108dcb1fb538a80650210b7ba3b3fb663a7665c812c0476f5a6c9301ca28e1d16488db97af1aa262f4f014864d2a507e31381b0a16377a2c8765889d4dd68294617d33dace5f190d5a23976a4a6a61427e240d0f3f0468c33bd911ba013eaaaf1b98be7a402fd8f818fdc73c74327d485372aa83b8290abb2e6fd3bd5263f19be36a6b1030864304e457e53a1a1ae2e68f532690c10ac13285c0b47920fe17772036f9f41702c43d4f3f8dbd8b140c0c08982a4a431a868630778ae8bd8e92570998940bc3afc1d3439c1e3a9aa84a50c75225d32d1708aacb1bb9df9bbe3bbb0479b49eda0fe33d54c52e56ed3f217a3b22bfc3106815484992255e0607a790193631a02a542c853690538c27ac29a77ef08821698b813c376552ed17a01c78eb3590edbb5425951072a4b3f5938396776a4f16fec6c9b21d72ed95904ad03c8bf18bb45a07803d95d05ec7251b0ab986145855de8ce2e42bdb123babee08f8f9831c1f45b8ddd18510d06e080a9577a8a7318f3fc98766307c48ddd5443a120746c02b263cb42139934cda0387d4461a8b163afa28278c9bb82a5f2e8e52f9ab1d36e9250f98a60db83f85c3c68ab0aca97cbae30acc924bec14aae04cb44d6d855ba7755c5bd08705a6bd0da9a31604b129cb438050124330236d31b3e0d587467ecc882ae1cccd87d8338a49028187050c64eb1490105a38dd18c8a8c1da4d7e37d5563ec1e4cd057a83cada991beefe62f768266186c276d6b27bb1c35c5d845781263471c3fdda9fccdd19795e6fb183b4553c02c4c29c42500838ef580830781ab000ad33ce99e106dcfb057130e852c2330dabba2a376350dc23b63739aaf8dbee349c62dbec65e5bd2cab016b530781e01ae6a2b109c86bf308ab97195fa69007c6d2a429b28dbbd30b3dd7785e7114907f98480e023444f00eac0f54094dfa3ae833df15d6f4170a1a6972e5846376b29f0596e4a53720be5ad750aa5b782e4d9135403937de80eb8fc81a1190d939a3289fe16a599f9387297d7500f42dcf6ec04771a4acc4e0e69e0c91a05f8d00e1d64b15aaeb0089ec6c62f48da7758f72667d945b01c85106b1be248c26a2641541e3e81b7b6071c0f37021cfec819fe28bcf04730aa701b1bd0fe7b008014dffd2a50f718a9fba9300d21ebc97720d69a33c71cce162b2b2c8447b836283b8501ef4cc98c3ac04079d551b8f86f4ae05724b16b523e96c90f399f1c334cc3bcda6e5e1b3b0971a021158e5c73024d1ad91a0a77430928e1e6dab2dd6e7b829a0d17b3a054783f0fa542ab574069270ca35c7947d2b5bc62c174de4efca7b7ff69725ee09941c6a970361da8c6f82eee5223c7244f400017e1c573155353d229ea63af66681c348b90bc9ddc50ee2084da482ac1cd117c99ee74513655f4912fc56eb0a43ee35cae3aae5e5b8e8ab32a526990a605994d21713b427ccd36c4c019723eceed855a77c643f70e32c03b8c3e770e6e9f6c270929eb40874145037177fc323898af5c5b268c315600452b6e771605511dae0eb51ec22c2a40d1f1a17cbc386ae57d0def64b1588fceb511bb6f3a2b0302a7d642ada6f324d4da88794b2aa1ae3071eef941549a7d760dede3210e525d9ab81e77ac20f8ceafa2f612b8d593bc8416023c5d09c05000f27132fcaa1e594214bbc36ba3149a62f841cf519c68d8359cb88824c83db244d11a24ddb55562579195dece6e94c16bb395e9b798c3b9ee34f0c36b9349498f316e4141676d2e39cd58e98f67f28d73b37826601849ca6868b657f6995a20c84506678bd78bf172d9073213e8345ed736059839ad8df837cee8c6a5083514e01da75b577c73149049a61703165014d81532bf4c2b2210468db0a618b76e5d85e3216d4280cb3cdfee372cde79cdb2722d8d2efe4fc1d47812d27af7fc009be118bbb6ac6acdf9268b7b15447a95501a41b9f4e0d172d6178b926b836232112101616fa0f9c0e6136d199478f218be6c1740013d131bef1fe9a825552424eadde34428d1d80cf511ec52f5ffbabfcda7685b1b701f86747c44ea22a9c0129a54c075d26cc65655375b5b6ba380f0c10706a5a9d156a62be22425b90a0d315588e67479c3dc4f5ff7397e8d9b184c6d381ecd27535f37e6643eb3b075dcd85cb8babaa771e522602833c5e85fec6f4487a1ac1f09b22e88e98f41959d3e09fe941d00ace8e87c0fe80cd962d04116a3ec0af59c8ddc3e7b06d0c829aa99a06c64b08c8ac6669e0aaa9e0fb7acce071a606df1c390f58bb231b1f1fbbdea514b66370bb41d8dc58bc4e43da890855c7c190228a9fbf7bb5f7df42c78d5668cdc82deaaf9d7a6369ae9ae5de205031d140acc282d41d1b3141a2022f747828e890f9efa95a2ffa4d148cb9dcd7d678e8d16526cd486d6fc9e9d3616fe33ef230936efa7ac9c29d82ad024351004c13802d492b40bd0afc64c8ea39f91a39eb6208a79a1e756ebd6a27238232849a92d30d86784087dc743a41ab86ae389abda265b295ba361d5960c2e608406aada60dcf14ef84505833aba4b905fba08e27920d58204397f76e2c55e39fe038e84396a29f45c2552abf7124abaf6c665f5fd21b5e28e60b7780a0e8cc6a592bf3e6ffb9ae34328497d3fdacf30f6d9be5f8f42b547ec26b6d3f389cd5b02b344213b62b73e1d04d9a2b3751d1fc32aedbabfc3777a488e8d77b887b87d88cd362454bef6c7bcb4a736262e40ee24a1474123aa3449d31e26b6eed89c5a0c420e14ae4fba2fb96f4bbe2546a528716e5780a71625da2e466066f23f9f44aff6f33bb7e06e4def4341d07fcf3c35a3f713c9ee9e397a48cdd4000afbae96c0af5e1d8bcc68486db788914c526376c4a6f2df8ec57cdcaab62bb7ed5623a00f454aa3f415c06d6a5ca8ed131303782c8937a58b0e03b16c799a69354085a9200f031d9e4f615068d9d589b6d42b5fa7b6028876a8db14627e947be061654f701f680e35b18168a4feef4558c776ef0f07a2a57e1e8a967fd65ffa1bc81eda4321ff6e019912053541c3261c163801843ef65b702fc7a582a5d4b72c02616ec5170fb74e1971ae63e1bc1cb0a84afbd4bcced9251484da2126d33a6a954233ec34a4e53539e24ea6c3bbadc5061eeb0478af236634851892540bf07d163f8d6fe62f5587c4d36728761fc7a51865164be26fced0812fc3c55d9d426e6acfd2192c41a10f94f3790b2b49deaa1b3b4f6e0f0abbe763e6eb4d3c1703b8ebf5af776b866f040fcb502652157bb847df53dd64d70d327b60752ffa4e38da422b95f3fdbf2d426210d75830bde76196826c765c54d0f3c613bf4ce075a915b288b66278bf7c4b917e5f00b9f357c75a70b4a80b478d1efc7219adadf24edc6cd84f35872847b4f7e7a8937222b23ce1013a6dc5515840cc209e0352169170d58a9a03f518805eb9280c6b5f506ea83f5cb2123a2bb9524ba22d177b47889f7c27a4f4d4fda7f65f695dc0ff68620f0208539e8237bd8fbe20729ab3da2497a820da14c14d498894292529534a0158059a04bf04d863cfb5bf5f13d58f2ba06776db9b989f8311d8802f0af6f8a25c0fbc426d7ab398e1ecae32040edc067030cde211030d0b98974e098210346ca0ecc08a2f560001860c3418fedbdadc7df3dfd646c83f0e7f548f231cac0d8d552966d4e962bdacd81c4f3549ab5590b1840e7bc3660669e3b232e9b16443581fb995c65b1035760799d85718d69a026af55962ad86d8b89d55460dcd4a552302c9928d81c796f801a4638dc1b6d506c158955c184f48b13dc9242a8c267a582e1a9b95070d89154612a2226c501d0bb6c3f863a3c5998b30b6176b17959026366954f763247102ca448924132cab8f234841ee78ac526e35d258a0196e5c6b53d58c153d905e52dce444cdc8d898697942c2ced8b1313e562339d6bb1a2c8fb135af15c5155bc582fd525abd84562028d81f19132e645e56ecb12c7727e67a28d7176beb50991c186b97c5c2459921d58856329eb5464c8df125668471872f8f08ab47b7eec0e1b4195bccce62b469ad5f532c0b261245c61c1f7659e286c5510226449f91c588d106c853dcba77e3071a5b236385db328e68c112715adb8ed63820f60c873d0213634401136245e6ad60428c2e3dd070ac2c68b04562545dab8ed5902723494c4134749c48cc209170d16b1a9223a77c9ba1f6826c55f1c5aa61898032a6589a1b6275ecb052236856bd1122d0d474c996a929de3a476704dac16edd58976943c4d8155eab16d66a238a279957c4d2fdb02370562311326b52848bb1674f06de1a5dd88ef5ea468834333176c98b6d8165948932de247714e1f8598970a65e6480bcb8ac457b3478ac111dbbb723edc63a9696438c85f25a8f60ad3d512c56f244d11af4c3bee1b0532e32ab9c8b8b11660f076ffda133b123eb06bb93a624b67279b145b0d81451469fa45b11dbf24387b3f2b5c8ac592d2e6c7b32786c103abe1deb8d1b28d28c42626c97d79a046bc58afa91348a2812f22384c3c2849059f142b81879f6aef058173a766cc7ca73c348932624b622f14ac332c644b1ad8a2659152a5ab4b6406b9fce0c0deb838411a765617142c2e2dd9dd8d1fde3c97ad4679a669fdb377d05f3c4ce6886318abd699a98386bf3c4a789f6478c31c618174d4e6ed4578c2dd415139336940cf2e95132b070b7fe714503879c7359121b39670db9c86148d535602439fbc7bba59324ec1f3360fb54adbb852d6c25294ad2f38f1596f87e04b7f87004d58e7262a2f6a1efdda44200fe2de38bf18f2766c821df164fa3826891ca79809befc4d67c23faa9d74d1086cb207d09b74453c37eae84411086cb15c0be3cfa01f31228fd892d6b3e5ba7fefe2d5b8af8c7e15a64c962a76ebe790069485889a8fbdfb2bdb222586ad5a53408438fa237a60c0e49369d10f5b23da26e24ea2827266a1ffade4d2a4ca8f9c713b3266313e7782d44e80ec0f9dd5e3616a1662edb7bf94714a58f8d9aa8c3bbad2162c624e77cadd2ebfb473583a4bccf6ae90df947d56c0f4dd40a274626f578cd3200823af44586feefdf323d1f7a6d4a1d6396d1c898643c3a39e92e20b496352c7044b500e58010da61e643e726c9d05427b181956e621c12f3d900c8b7e4fd71e1d2922bb2461200c8a096bd244e52237124c59234c93cd506722cd99146920c408a61180208256f1feec13635fb46b2883c71bb30100f1b4997645ed2884924913092488e9203401e00461275598a9b93c10349c30507ad2f1a1c2beecee646e0019528b55140de39a4e446be98924b06c14657ce2ea90112c94d57b208c6da492200295587bfae9120f226c12f6d12888cc377c909c81403241f346464305e3a2e7082ee06909c920e4744119aa42d1a68c9b8a4a6c142ef02246ed31124795b2835251780cc8034c1735049b2bbd780eb232bf900a40ebe4a09c06c969cc10eb4d65a7bae39887ff2a3f6a03d0e207a330acc8131f8f92c3181b84821f51eb0dfa9e7fd7ff83a4589207e11980363803158d08300067f5ee88140e271f88141a090b8e172384f2f2c0afde985c523d063affd0d0a857ec3fdc22285de857e7b61d10c1251dfbd06d30341fc94b83204e28cb6b379cded8738dd698aee8d0ed374383c694e8e66983c937336a4fee7cf9ca2b3d63e6ffd88b78488fd50e881663025ae6494f4fe7e69f198ffcf6755fd6d0fb4fffd86ff9ea7ff9a781ce1ebdd8110386494d36338b5f63bdbe8ae534d4c8bc773c3cfeb999ca639d53ecda9f6692efedfeec5232ec942a1c64510d4504f8fe614adcf7feabd75cefe43fee64f3d86e9c5ab3d6834f8c1af884bf2cf67e02e0e3d689ffa6d72a65e6fedb3ffa55aeb9d66affdf625447c3cf3796a946b62f0a7fef34cd33438bc410a70ff2b661a8c41507b94b8d36cf3e33f8e02aef5c73627987941c17184cffdb61901c3e94fd59fda1320af1343e0a0fdefd2a440fb4c83331c31c6b808f4c0fdf6c79521c69cfb0c9369f8de766676bf7fedcd3ecabf2d90d27f4a8b1bbca83807e7609eaed43dce4cb54ef1d305fa5f5a04027f26e6c9668783e9702f5a209ef6c74730a7f5599ac20cd3955dcee4efddf799532e4c87eb71393f073b408b17db0081e618d134cb28262ea29c6fdeed38fff9aefc75398ec2e10ca8df9bf3cd799173ce79f77c6fce3dc8be73e271a598f3db14559f01ffb6295830d0dfdff4c0b3c4576514f3f7ebca638ffba1396f9f8980b05b41ddcf3ec37425dae57eced0e5e4ea3ef61cfbec25e0a2694c53f3504e3152ca29fa2b9966ee76ffc8d1df2fc3746597e33f0fd96f73f7b87fec9e4fc8719ffb9ffffdf20454e543a8e7f926b6c9164c8f6e7f5c1972afccead1e497108fa7c9b78dd0e31fb6f9c75c251406732e0a39e741ee39e7bdd8e1300642ee851e286c81941ff8798f1312b107f6b4a79c13b1d97927b84b14cce48dda61254e04db8c0094c7bece43a68560aeea70dc1f77dedf1bbca82bc3cfb7c75eebe5dffe886d42c828dbe721330e0e67e0c5630a7e87c318a81d6e39f38f2b7779971f5db9cb99bf099061a97af0c795dfef775c1966980ed7e33a9c29c417b82153225127111329111426444458302c52550ddd04de0ff4ce020e38146d69e048782dba66c116070deabf6d0f501a35f439688d6e7b60b8847f5b9e234a75a3e769ee37bbb5ace59953d5a11ffedbf29cfd17a04e4dd3cc7a09042d0bb019083c502744a9aa0e3dcfd03fa268b39df4d7f2bc5890e6755487baff6d77ee7448d8661274187a7a69d3c5a6e2ed0ed409c2d0a3f87fdb9d133b2c2b80142c504451d302f625d870ff86fb512ae406dc6c01a0fff95f51053f7f7292fa93936305f334fbe75efbe34a1f22a9c5e12e0e4d54d51c02fabcf8d830fddcf6b0fd9cb10781b108c09bb3bfed8d9b098b7d9ef9d90f330b20fef7e4ba5b46a627e0cd99733001ce8149859309ffb637313ef0dff626eb1f59258bf6c6a8e724b0b8779eb909cf8e4d48108fb7b62a950cc801c178bbb1a75cea3077727775257c797fffdbde04c538b1daff3789e83fd19ecfb313d5e26912cd7f89e826f60f3489b79be47de29bb5d0f4280f78aa8d9b9c5e55778cbb8dd4cc4c449bba1b4d0d31a3d4ccb35d144587e2ad02e65c4017512b05c61710e3eacd6b680dce93c5990698650beac52ff9b7857a7abb107341666324f4b6bf65c1d43e555da8d9317e9cf3141e4cfa124107a515d3a6c2c1b46880d0091912a1c2873ef7c3acafcf39df1760345cb061e1f601f06f0be50395a334715b164bf34289f3c288acf552902a73a093f850dfb0271416b0f9186169a1159427a4a25fb43d54373a8c96322a5ae849e67caae17d1dafdb99e69b043b73a8414d67adb75219c1dfbfed0aaa2ffcb75da1f48f187e792b729c862edf1abda747cfa0735f207182326c5724a5e0270513120a99f6a592a1943c392c3a278cb0f4a0a137ff6d57187d0c2ed09ea2ab68afbd83d301353325e1a7aaeb460812546c404be3d2638ccdfe735f72f66dd30b635fcb24d732b1d8b548651073a10b2c1a68d07dc2f2bf162ebee6be6d535dcb946744a26df4d69adc948eea6a86c09c7820c19be2c3e93d227ead538d04231f6b2ef1fc00fcdb26e57effb74dbafd230a0ba0e9b39973bee0672f82ffdc4380a31d2ef8d95ff0759f9abdf90111f51651a39e4ac18307fcec45b85b7ffbdbf7cfe07500f7a71f0239850e0ff8d93fe0677f729a6bc07b534ed3ff63f66731e794f33473c9bd19ae3fe69c731601ff1ce29ea7df3ee7a17dd7c2fdc7920f94ecae85fbcf62478d77aa00ce0e21f8d89f683fbb003ebe320e09b275ea0fd92c33fef890c75a25e5bfcb7f5ba4b8ef89289d8a3df61138fdf1434641f08f14b0868c831da41b80374d3dea8946a5faa3703df7e9f5fa638fde9bf7cfffbb450ad8ff7c4a34e2503ffc238574a57f5455f50932caef074c3dd0bff7639e417fbaff88f82b2ba368239a7ac4611f87e1b1a0d73f9fc2fd53f109c3d7dd6798de7befde24a7087deffe0c76d0b1524eb93f35117aadfd494ee9251a682072d0d56c01c30619456ba39aea7f3e484c7defc5bb8106ed3bd00c76c033f087a269ead1cf891818d473d6c7a1dacdd35f142086cf4146e170bd875be470c2a96358fdd9737051cc066460bca11efb30a7981d6de39ccafdfdc7931314369b39fbb48247d133c5f9844b016f2ef2688fb2da23a97fdb23a37f3cdba3a0239eb628ef04e8dba2977f5b15397ffdb72592fb684eb97d7d7d7c5f43dee045ae280cafea83fd4daf83bc48a928e70351937fd3e76212ea6f70054395a61d8c80f6a6d7fa7ba0fdd9217fed4df0812388ff8b27b0b1326c878c34534bc4d612997df4df96280cb74455bf8881867ac430cc79c8a621673c3c8726f639457b0cdc675fe1726208d982c9c5195853b13f553b35e0cd4094f37ccc79fbec77d143e62d91527a063be06aca2da6fe887a34a3742310357bd4039a1ae1d4e3f9cd0adf44fb2fc5ed11ccdf7da7de284f7f55c2cdea75c087fc51fc8159cd2922648ce20c22e0ff217f0f6e5fdf473d850e380268ea75b0032752488b1d30857ffe0e27ff807233581481e38bc1f61f86bfc3f9c17951b63fcf60077db1994fe1698453b1577311bd2726ff2124d50a31fdf33c4d7c7f0ff6e1fdb877ec839df8f340a5092cf68cb2799b6a7a94e18fa81ad9b03f4161730aea4fafc1c4410e5802f75330bd07ed516f1633eca914f699f1a9f1690ab907de629c7adb20b97f5b1fa07ffa6110cb3f51bf3dfffc77a2c47e6eac5c99eebdf789eebdf7d651590472cb2f9d3ea4b82095ed84362303ca85cf0b7c6585a3279dda85bec0535f1209decbce0b12655b10a02297b0237cd4828850e934f7defb44619830e2e24222d163078493199b8e09253018416408af1270090f83dcd90865d9f4e8bb89e302e3c202abeb615351c26d7234ab5c6cefbd4f3478032435c2ad855b97cad6a1a3889a5312191a91183e139432208b284da8f1edd0b8cbbc3bbca4222e3c1b304210a3832b0595d95bd60ab4682ca1f8d07eaec036de1b55da2f7247b4b6b86280701df1a165969c593b02d6bfac602660e012d64573992e7b2046080597134f901011b24c50cd48a27316e665c2efc6e6f63848450b899b96a0222a1b6d8c85e62eabe8acabea28e5513d259c73cef9e97651a5a5f41eb990617a4ab2418437b6768554a28732c894082000cc734359a10197f25a06c772174248ad0606607ebc984aaa29e3e95c555b13f04e3aaf8a3a964dd98cb927123840667d604992a0502aa1e85b554e13f0941270e904b11442481c59d26b06cb08a0d4be6480ed4843c2405645ba99db4e76129e4a1e20c9cc9afab163efc80cdb4e0b0790f8d411b56881797a11347792550c20bad4315684678829c80e15ddf4d4f65863629b3a52d15deb6b29a8afa5a88690ee802465f89270547489201c39546a506f2ee6b214d3463b4a516722884789ad1d184aa4353989b0a332cbaa429b70a24f54753882301df180809490b019563fe6566055c54d484ac952bc377a2a604dac5d0ba2528681e86183d1e311da033274d5a22c013a8ff11abb084dee9949d02a0967e715d9ef9e4a2647adf408714854acedc49c71bd295f520069d11563855595910977efbdf7668194601613c45721242c69ad35da35139ece3385236c720869c9c1c373955e3139b0d07a7c69554930336bc69ab8749669317030ba4c9ca14591189b2971a555b2847dae8e2ce75c84197913811165d1580f1b672d90e73e039a03a22308ec47c6d990174e2ec0b0baa8c6d00c0881c249023262474943d2a946091a3f2e3efa548be40192721baab5d6a80bbcf7de26140ab06c807ab4049151dd1a5d545b3735665f46a4829bea44777ced2be4db252289050c1d32bab8560b1915226a070848544f095dd10920446c58304925dd98ddb518e15b1283e2691b5a6458a24c6cb1d508a129ce484c0c3eb527ec5225b4310b1a7cefbd4fb44fc5100d518e1e657a287d69342e4ec4607beb4f53484c5035d571ee2fa911d99463a3f372b331f642651fbd592195927288b4ace6ba525a002dad1d2e26a33ab51ba348ce8dc752919d3e8ca34c31b054d3e5e388901da2b6a520a1a63b9914647d45de4666d15ca69370d515b394b4a48ad340195bde11b1152e8c3849cdf824d33c3b35179f9e948a9e1249963378cbaa4b4ff9d05a5b696d13f342fdd428714af8c8b4f7081dd40f509d9492071e712398779394165722418f9b5c0dae2f1b4d08689d8ed072e8b0d1205bc25a6bad4bb4d65a731393efcdf4b71fcef87b9b2a374d34735445ddf4696ab40be9b36be1118414a3a4a2f1b49214ddfc94b925f7cc2416a03b22638657138e88a3abada7afa71d234a482a34091935c940b7f6365764cf2b49454f599d755179b5b4ccf5a5a836ae4c4dcea7ea4c1fa69f3dac236e41602afc9245f18521dda9d520a1c2953e975a7ede5392798c1e77792d3b6450198728eb0d662d4532296aee73a9225cb5a18ba8b67e74a8d654523dcfa43221c4a8541dd68bcc949ccd8ab53898b9f6cba90d494a2ea8b5d61ac5da20724eecf0e16254d7032678e65323aac666e8ae1fa9dca46b8fd85cc4c0a0189b7a293bd2f3c1315727242c09604ac756f29c9f9c73ce39e7a77a4d93e151fdea35353fd1ab9a005983874c5d4b911c14183192b506a642072d9206a8a4eb5aef41a60c294701d3170000180c0807e34892043186a5837d14800753de7484743c209c0a62713814c33010c2300cc3200000300cc030000361244cb998034a78ee8081311c3927acb05454fedf7ee794eed6cc61389c49b06944d7efed6021211902c720fd82ffa46b4da8254bc52a5c93e841f8300c697ff391e1a2e61e8ad88f9d1be4cf6b836579bc45db53914a2c72d66bb2c2b2c42e75c0dd057ef98c23c1772648ce3ed63a74193490eb96dc5d587a06fef1345bd60b4cf49d526c156498edbc23bd6863c2f64aef7c4919d91c9ee61b70faf263bdc5829484013037559be85e864ba26de2aacff76ed3778b51832775e2f70ffa1381b8083492697114691ae0f5b83a4ebe707111a655ded4afd9a024e67d7754ab331acdd476d1d5149fbe43313a95da82eb8366fc6b291d71f94f27a8c024a337eb658f1a61a124619a33cfcc2bd00e7ac272a6e9698b99313b81599aa800d8f41fe7b711c0db244c53b2781bcd1baa3413c547cecf0dc64ad198d478f198c4b267c879a689dab86ea9e94e10557df4acfb1291a4af32ad8db9e1c70c149f099bf4b8aff759415bb8a48caea97f5da393d7e812e207967a96c4901705e08c78a46cc8bb7b52ff55842549336cb24241214d0291898d20613337e79b70e7367bc1c5859a5613076a78186fc0d32e8eb9c55cf3a7d2d7fa9cef431e839efeb374b1542b4d5cd8f7ba3ae4ed141183aa3bbe759eec751e779fd5b4bb52c49eba46424312969c18681a017fc3146b392aa0474a6229dad8d257c169093b521e71fdfcdddee990b2e46b5ea2022cad0ea0c7e9a0b7e74ac735c0ffe88f1799477bb4dfc0f561baaad7738fc6ac8ebd6149d355591dfe59c6884b0d0a2a14a93950f6b167173f35c3917656341694ae9e8aec5e4a88fb12a2a356a14832a76012bb7e88cad4e12664107c3ad3637dd48c761265789c23ab0e41a1c769f6496ef955a3d11422f68d1b7884de3ea7f9b8ad3552d819a9abff2a8ea30693e8445321aa18b4932d22bb3d88f6226a2668c8089d2935011840beae0470f155fe754948d2e04a0b77ab3ae7449a6aa08f542bc652dcc479714c1eb472be22313f173a85b7bf21f2e59c2ccb339b5a419c6c0cfb0992c3769d6688c222f8dd15acbd7d0a1119fe406eeb6610e382b8f4d244d4110ee12815be617fd2e197163b40648159cf9bcb72f6dfa5d0459cc77e2ccb262f1904571762f1591841d812c0af4693ffc7055c13941cd04853dfa35ae7f8fc04c04d34ffc9db63239fe8e73b2d8a878b46b38ee492c8f5cfc509cdbf4b51d89eefc0df2e0d6632efcb0571f36629568d14f4ee67c2cc735093d457f00dca8b32cea59437947e07142c2c97af85648fc8e1bf0cd4202c3ab6b1c7f37754ad53ee0e0a389e756613aaf988aba3946765526651a8c3c575df39caf6de5322926e0c7a8802c4d22e65f490afc7907c0c83909ed159193f52b147105f8533d79858956ce902a19e8cc6134f3508b3f5bdf52aef1483687d5eaba9d84951b27242fc300e5e8d415a1c49b03703da63af3326e58a01269c9366422cac985e2a5822c9921429002d3e57bdcdac1b8c6d8e11ee5406096ec972d31898912e29a922838f924e42bcdd3d494675895ddd483e157a2d5ab973a31e2fe4f90a58ba3d3f1f59052bd42cd612dc782add2f32737d177439f427ab04b544e56e9d9a8607ff395a3e6d8db967c22a9124e5dae9c4db1b639569e027d516abc85bb7384ab72021c53923a0b04c52f46105d546839fa23235dec312840da66eac5ce1a7099549723e22415309a0338f11e0e4178ca95f77638aadf03090b78049c0a9c2b1734e41c352b618758679dcb2a75177926159b660242a8b5a9599f188be0162ee85d1b434b58b9bb1108921a1e8c724d12526428e216e87460e432bb955b686308dda58e868f195cd5875c811fc7ad9d40512a029d5d5a52a35bab618415371dfee4f5fe8895ef7297a64d23f67d3cad6c09d306c6d620a80de26bd0c91504c4802ed60638c63e64e79908a6e6f166994e0ef9665d824a1d934d76b5b5736fabda5810335d4400754cca1288c12db0bffb4c5c345b2b7d2699e7e5917b96eede8329ca4216d920237a60b9c1219bcbc1ac50eeb7bab3e2571b49edc5b87129272123c13003c0308b91431613a224f6f5d079348fb45ce55bb64092c2837db7f82f416a9d51a673d53e3322c2645c7ce88bc790472325dc4d36e1cef647063455e9f31215281890d3d07ce42691cd6389a347c6ad33d9ac037049b67104df43a39151aa6c1678516e509d34566a5cee1538037e291b0c683deb7344f2e837482dfb3d0d0df1165b20b7ccc485550881650f3478b00e531508814b7a32ccaafee7b4b0189c3fe1179020f5760e51e6cd95df0dc0d04cfe3767a088b4a1e4262dea10b6406bd93e7680036608edb85a8ad74ad904359bfd93a58909ac08fb32de0095c73b2f4f45b1526ce75c26227380f02a82499ef0b01a72d0c135da50a1f93de17cd563a72d5fcb9145bc6d2227b98c9abefbeb84733b9d2c95640fa1907ee26972fa68566c555211fc45ae71b87436ac82e03a61c645c9810fb22abb1dc2c28471ca1b6ff2849e5de80270f5491a01c807227cb124fb063847f783c2549f44326f98a0900326fe790c3dc8610c6cb91e42b2d20a357065d399b3914c07ae492ace1456d2c51ea67b271874dc29aacb004244f3458701bbc2422e60b22bcbe50a08ecb0c3b2c8ce7be8c6188a9907440975b998c64f6f4fd9a330f05f325159c16c00c855e8ead7d8e0ec380cc83215822637bcb6db89b570bfeedbb8c47851f8da48d8b01ca756bad0c38c05b6e4bacaac3d28f956fbd5628b1983a0642f41b1f445df0993809e1c104fe6eb923523fc65c75bf6ef65d68791c79caebe08af35bc97b5cb2470aba96596c3d6b38db48b2c5571767d768bc530d2bd9ac39ef0db447e3e86095b323a0204f3c65632329c348ebbf83b39911b588b0bd9232fdb76c2c1aead1be8e41b35c9120d933d0707cdc964a3fdba6c3a282182c2bc7499787c8134f54675653539a991ec53199121bbf4a263693c23a266ddc1ca9591a16750d9b96229f064cc1b2d8a4f2cd6f81c8926476d9c97a0daa57a815acff886bd990b65a3972fec1c4614e927bc9a277a2d00c39e0ad32a4b8fd6052c92aa533598318286db16f0737a1fca68a428ec9b0f7264d38775a5a23c0407cce9087095bd4a96c53ecd2d99dd9976cc150904604574a97a9e1f127be30c43de1c1320a2928f1309c3c8b5d098fc4995d22c7bb5960aa6a93d2e182e5eb5066b962b33ac97471af2668f33f2f33a6798761dc80acb0aec02520bd51a11ff06ce56bcd326f9c5657c670805274d964c96d3da36edeb27efac49b562b4296b6453808d2f1fad96e314a331a73d08bc1a830916539554dde1b93e3305ad544191cfeb76b9ae048c971ea906098ca7128f17d9088391f0dcff411adf7b42487f143eb280529fcfdf6f25157909ee71ac267ea77a27e075110d0894a8c8f6672877f33b4860cc7c3affbfd383180c18c944368d1f253b6565a134473550323e810f04413a0f36c8d26f816cc256f64eed88ca74bc6d0501fd71a194d5174fb5d6e6028c3210698d020969bf8b7145a7db57656d6b2ccc331a79c6cf73f015e43a90a542f03988cf91787028a1020a1c0b152c05b127f612cf8d6aaa0de1c727e898dc417f4e086c5a36c4eede760a9e206f038a0a33aa2025a6ff0801e46f11a9047580ce66d2c1d4b03777689a77aa35699cd8a7eb4fabd31e74559fda1228f1d6408758d43aa503f5b370f4bb500bb1c1fa1ffc3353fe76c553cef46702f0e967f8ac1e24f1ce0f1b0bbf943409262724b3fbeff8e8cd3e0c70355bccc7da460222feb326bede739361ffd43970b6065e46be3aff37d88d31b0764edfdc022cc99857ebb2889f48cacee88443d22f520eaa0f8fb64d3a210f2d033ea25be9aa9fd1034a3f753ce7d81cea7a73dc95207a454d016606120a1ba670cce5d710bf030120a0049c2ba9f4d71ae0d34043777807a721129ce05a61311eab2c9e903387c0579a165438a6a86ffc06c496088c95f861e5e19b8221a73d302aee822a9c8657b12fc3ba2e18d62c20f709b285d70fee1b5ba8245d3a1dc4f8c09589f4b98dbbe7cdae2ab6938d254a073fc75da17153118b4969d45bbda492b6f3726b2bc3ccf021076e63b6ce2f121a6c4c640af155c5138ad04cc812199768f33ea333adb643becc6a695d02643cbdb106f4b0868292077e393e685c8ff8e3f5c905fad6077e7345c3ddf9195116ab234082618510a23527e6054925256476bf780e70d848702a03d044987845dd8b29469a36461921d723a27965b9655e33d7ebd2a03e8d7c98a3deab16c1c0e712ac01822b6929c3c406891b01004a1722ca377da004c00d966fd088207948f73f5da19e105fbd327c2e805b6d0e733934e01f872b98b2cf25dc7ce7078d9c41240f6b1a3ef1ead6b306f8a8937951d3653d0a811cfb2795943a81da27f80a5b79dc2cc49513410197a6b1a4a0af59d67748e70badfc51523ecc85ce1dbe3f192d639f15586b0b76e1be00ba9a43a698540bbdf1cffc2b7b8cd9ee4658e8508a8a8e61ec5ea84da9d9dfc801fccabd6acd30ee79b2b0a0d18349abf0a1242552a9d553cc6816f6e5fa536220b40b37bdad430c8815a83b7d56f67887a079ae8a394f9cffdbc7c1c255945d7c06b83e14da2a9ae1a0ef49eac9b976abf25b8f31f0b74b51841861e60cb7ad324708804682df9e6c32eb476a56ae4f374a0d757630022f507fd0c81a1ea63f50e986238463fe529504a2cadd6fb4feabe30a818388465f09d02180688159b90a67bce489b445e1489a042cccc57914490176a695b59f701d11530abf4db041cdf4b57d05486269ec07cbe22a806e33b604644931ca58ae741db9c156350af5f82b334ece018512b3f12885eeeeebf4a831635b8a721615bc20d0f3c87b1664a2a83324800c382736872010c94a0f0867ab185b371d28ced3f360c0ce175d263bc91511af72bce3e2356709f6abd81a74525630bb56a57da903c2076988b13e4e2a78e0c3106e0478524bcff54a48831100253af558713d4c54ae086b891b0a0a6c07f73ae28136a608351e7a44652e7500993ecdcff614373046292ecda5a78b4280a49f7d36598e76aa7ab9710c35b9b047d31066aa659fd38dbdf9c8cbd6163fa4bed6c5e820d4ed86d67f0b506445d1517e3fe058d5e1004715691616077b918b8f4b41bda4bc70ea3a07020dd6719fc3d1f66df1e3af0236d4f13a3be540a410a9ffd481a976a83ad94a12612b22e2f16991f8147baea5646f956c746d9ce6439070f92a064ac20623c420ef47a1f5cb8420fdf56b76bdabeabaf72f19186576147ed42b5b730e6ea517aca6ebb94d08f5cfea29de3b107a1248e8ab6882262a15a49afc7b8c9e0ad2f39abd2868cac2d54cdef11a7e29a500ccf13a4977db0fd1e853018691a4314da7f0f8c33622fca875c5ec853e1eabcd39c26c555217767e5fd24d7e09ab4cf078d470d29c22fd4af680a9d43c33c56d5d2d82c0d21397e61392536b9e524a6e3a804b69207b2c800d4518bc4530dd5f86514085c5feb2f6d7b1905c76f50d757bd16db09c434ae47b4d77956c278fa67b667da398bbb46a8b332a360c3d3df783fae4956c8a4e08024816fbd3d2d8584d98253e898cea68c31b97f83897f2e0566c535268eb543266d09cc5e506c35da10f16d08c504d4c5858b15d9bbddc4bd80d115cc9d6f52c57cd517db64b1f6bded7e53edb8893f2d0266d78087ec62c89b71a8fa6175606ccb6e3101276b3ace6ba70af5ecea049563444d0b3673d5e3094fbfff2cc7784433671ab82dab5f9244b7705a96317743de0a156db303f5682551bde92a17492da0ce4b011be77f5c5763cc26d8d5e927a86fba742d33e1613ed3d59548c61b5fcfa4934b985bd7ff5f0d0a299c69f41edc54424c9604a0af8dd611f7f9ee87e82dbdfd3b39bc93c81e4526da5a4006b52b81b676a506f9d5126983d683175a92dad119216e3bc13a0dc42b9622608a75b9eaa2b5107b4a8b4c8ec7bbe6b3987f6fda0155158ec5fbba080c2aeb5da9328b252080d075a60cd6e42d08a1706a91bb243db5738095f9c7e5575bfd853a5daa140c0757f0506b8fe68eab1b6f9a51c6a90f9f656a8927bd73a534b8d787e81f023be5ae150699405a02f6e191b42703eb103994d0aa8423f4be28844356df21f5764014659c8529fdd31cc709617d1f7001e648fe47bed11e451202e3e80432cb15228c197c65e1bac93a0faf3615aece89f0f78c994466418faa086962892e97690801ba8ced0bd49a754e138fca223fc9797458da2719aed0f3dd13fe910955eeb4b207ac805a47d4453f01739f33fb8df0bbdee784cc726b95f64410341f9f764872f7588324231cb5e8ae6cc2826e20fb2a3470023f575f62807b56b6ea67ec5cd42134a5f267f8d0948f220a766d7bcd7d85f73d91c995e9651fb4ea2f3a9fdca6e65d183c0be6eef88331fab2c0e11cd03ae2a3d78d37e8dae281ac50c314d06553c3054a300944e139e6689a5f39cb3af2132562acea8189888681a7a5daa35db2b84a541f0ab36fac378b8d3922cbe3dbe6e9351a9be5a1f236bdaf6eeb819fbb9c821076e67c4d3041100a1cafe3be20ca7353c9119c443544b01899032cb49e79729af41d0ad325e59deb5a3cc27cd993e43dde6cddef9faac1e294e8f9165ae2a2b271c29e21e58863f44f689f702fa56973ccf770ea928dbb177a9f3c330b5df859142881c83d2141766ff156d56d4df5263002c089b34131c44940f6994f75359a841e9d5aa22298168b3d015617aa7e0e8facc372873b0363c2096f1eea7673c22f0630c0df1a86ac71f02c7d1aa074cb57167da465df2c90007c47d865641f6068db66c644ea20c9d0e568ff06d304631adfa1b83a087f5d1b0bf5be15e58a532383871b1f562f15fc83fcaf8d6dcf94eaa2e103ad1c7eb3cd42fb2163d9809ce9df4f62cf4b9c5f007e1a85f4fd403bd0e0301746175df18ec60cf9336d70c43f2723d6391831d233748589ebb0b14965e71a014331e542ae279fd6126c9d4f877116662471a4df7a8a56ce6072a2a1fc4f65c16c17da9cd142dc24248e86bd2135e42166a83d518c230568c4b20d8fade02c3d1afc6168d32db189e88a9089953691cc9fed62b2c18756b5210174d63b4fed1b8be0b61b05085a299f185a6267ba34b044046b3e6a3215d6fe71ac810ad3fddb90a23ae38c85822d0f30a77bdca3ebca3e7e80e14fc9b75185a6755bdbc0c780c4d844f092919e911754f5645db2e3a5eff7e30c80447a89c7bb40d8beea1b5068707260134ac672d8788190a270225076dadfeb2063d13dfe7a66611fb94afa8b67ca5d855ca2907aa583fc31ed45d98edd9426a69ee69f37a8d78165d398ebae5f60e89d0c69e23aa4d9ae882dd00dbb1bd6e42be61e83fe47928d8383171808ec80b9abb578f87cc80e8767f9b314a734775ae8f9331c8a90428a3d02ec14a8c0256b8ad7484c8608fb489a3e65e48927b08517bb609d5b82e4adf01e32991575fcdef71f216edd88d1dd518439e03b2e82f70efb5b2c27c890a4ee5e572a3ec94ee1d831ac3dceabfff004537dca0dbb8e3f1c76949465f1ae548f32ef3333bf051692541f5014e3b5e1e84873a27dc01757fa8dd1a83148cdc53584072a062d93c70d571e52111a16e172e3b7a1dc0ff9c93f6120d81774d9cf7e96a6263597bd5fc21c4bbd05c43d98871682128250ce959068fe902617610168f518a83e678452bac08046617119ff61d318ef5c8133246e64bdb14942dc43868f07030457e8588bdfbd363072158f29b328c945d999ad80096fc5f16a77f4d6217dde9e45f6204c6df8f17edeb324305744084d21645a8afa191b1201b8d621d182a3c9727946da77c657bf24f077dc1f66537c2d8ba3654713e9d7987c4c0cdbc8a41ba39c7443b7c3c737add410c87b12c36c6e101ed9ad157f5acc0b9e9c168abfcc47d2e19d268c18582f1bcc6ac7727bdf7d0b168bbdc08d8bb824c8937043e15d66b52a27d741d3cd5173163d431abc39dfb395062a3c947ea9d9962d1bbc243916175cf4f9d47c7ac02bdfa50049a6b701429181ad6740b725b6794f74012d141388353b58d850f85fd4a7c1647c4916c9ba3681d18e239b6b3f6a404522f1aad497c4344f25e4a34e411cfbe61e2577054fb1cb62cb2ab369925dd128b9d7dd07ed438079a619f087fb756d6d708356359a2f0c4aabcbbd24d8b12580cc7782efbeedb33d7f777bdea9a4c8f15bbb8a7260a96385ca32f7f17c0294190b57edccaf096a1dd309431bf07f76097a558296ef0f11f24a016a6fe3689bee7684759824d7a46b140d3b414ad41954f404dead092a583040430bae1dd65fbf417bd0e25fca144f908492c026b4d33f2c0f2c91022236591729545da80607f65e41b87484733b7fc370c71b054ac40e9529f1c83332d4fdb833afbd0d68d7bbf8ad1fdbfd318d538458e4b6c05afd9bf44ee1f90d9c9c591181be2b17f31c4ae5ac90387898543ea00b1d08a408f5c55df81b689fdaa08e3ece878f2e40961c6644b2f687b384d06925ee4f21375b77f1566f1f66304babde9e7530cb4445f741898967913fb90d890b4db706937e85f986a991da10a1b1f83d4f16538d03c87724e8c431cb3211339efa8e84c2bbc54a1a3de39d5c25a631dc1eca6ff3951e432e20b044d844ac682adef9a1dd51557ea7c0f7b6f472f58d92f2398e0ed7c690886c05c569ab2bf795bbbf316492fc48e4628d8d28f646b13a047d1917ae0029372481be4f33712b54b7504389a1cb3870dc1a1d13210738ed26c808b0ce1bb73cf79914f0b6828206da54bee16fdcb6d2e95807bb71db34bd1ea85dde6575221f3cc2c267c7234725b13912750ebe921bbf68a6528089b83162e8d1dc954ceb26a0ac504f749fe4769dad0cd0726e2a92527e0dd88a0b08c7529cf103bdc44ff1c217ff71cb8478e6abb5cf0bc44b04d89e3bd7d3c0f5787783db54c321450dbd7a9f609606e0824e27afc69816780f4aec48bf5c82c45b21b6686012dd0cc65650e847c89409b3ba920af4386c8d32c3ecb02345a54171521cf5a78100606e8cac4a7518066e0dcf59b28d7b1a82483d4c6d6c6cf6d23c7ec91604b7ca9ca2d4d297254cb5e37d323b371d199ac4bc7b6a30f5198052c8b334360957b18c91a1e45af59a74fce3c1e0f38e57ed245040626320b0ce757b9edcdbc413d1ba772b9e3c0c8b80991c36f25fc3c3bce3a3251c1f4cc35cbd9bca7ed92879a8af48f7d64d6fc67f0f3b7f5948dfc1a6c09423f6e8f3aa6ce9d1f8059f09e262df6d0c98907ca6bc0d2a29fe952e909b31a0eb96a1ccc3d8d41373d1be2f139410531ab51c1dc2a7a9ef2903897524c8f6ca770369ed463d7365f84f09d784193e57ebb3801e9e81f66b924009ab581c542a4af48fe48ab70264624d9e400903cdbb096b467a4c4fd1d9ea9786ab7843ff12059a60cfcfe98c43083a39182b3464f63659d204a604758b228779ebd0744091dabaaac45b022e179e19741c746f9932a62f4d6219730a385c64b8bede35de2c89e177ae56bf04f7280e8ac62641f4416fce014689dbe0a6d5405f94a0f5338a02e649cfaee88d5c697bfd34e3a335a27afe80e4996282082c2a3b00b49752b352aae6defae09790c6788f2c94cb27293628673c772b71eeef506b0f168632114e00034b391f95580dfd4a981b89871b9d70c54268c27297369bcb78ef5b8dd7c1de9dd86fe6a6121972c29db872e637d1450d667ab28fe69dc97f63cd0dd63e4ac7bcc332499de9e363d9f038b612cb04996e6ceb398de70db9c662b4d70e53ac48b2ffaa9d150ba9e520ddaed9271a82fb1adb1a91b63125b8de28491da456c1c58277f5953a1265f56c08d41ea85ab72883d07090a0a2db9596a44ae1e29ad1864ab151ebe026aa975013747eaabc09e46c8dd16c457339383df7d6188b57ec82405238ada1efe6588239e25802ea4647522dafd5ac2ed516ea714b80f3acbaab61aea0a0dc8497e0187d9923827f702da4dec39a2d0972f1f7c1b28428cf1eb0e4d1378213241bbec709f565ffe9436903c90f2463775075bc78cec142ae4fdb5631c176dc6ffbf467140840c7adc822838f4f5f72086e458ac1d98ec416658f72b5eb5eaa12496132dc07d7f5358292f668770c4d9b48f948d4965422336869e555ba33379ee10a5c00f001bf96fda8e934bd69e0ef3a8fa06580cd3172eb37332977b13f5ad1e01ae8086a321ed12fb59f56ed507fff9ecfd1643d850bd63e3db4084cd068dc0e1fee255355c58a1e02806fca9d7a4b4cdef51393aa420f11a6d691db5c1a624c39e83edf229877856a2ccaba04ae34b9def0652b0dbf20326070e099757629e07cb2110888a910ad66af8a584b8bec5d36f09aa9570de381ad33ee0ecc52c627bd6f775aa4d5ae46043bf72a15497c0d94a0489a10ca9f7281d44202c0fcf6fbb13832a0fac11a6d02802ffcfc3cacdfcd2f30f90d7dd35f0d6e5382de9a8172dcf6b682c392f01fda3362576ccbbde90c662d037486c8a19780f005c8f7f743051759c9ec1ef03362c785d6b3083382f7c2778cdfd048c55cf29a14e9cfe50ad97548214ec400b99ab7ee442f38aae3cc6c2b958e626f2193e601afa5ca4ab638239c01a37d9440ca5d789162c53239ea331f1c728ab3a284b07097c600cb6e7a81e0c9122bf8915f8a40a670e005bdb2b32e32b73435cc39f47478a9b49ba2d25c9e782cb49b5ac3cee326c5616df90ca6c7b9c6ce559e679d9d93dc5cd2db29ff5fddd9c56c50390ba63bd92ceae9bbfa8275b67f9e54436eed6d7ca936a318a3d6960e4e52d3413f5df5a873e8d8a6fb90876108bb4fdf61d0d580c7b1adf49c5af1bc55f0705a8164160542a9c88bb823c5a730b92d442bbd60b80c3606631453a3f0f08e2918a720ba56b496e7ec40b961923556629cc60157d7348d00bc46089df2431b147bd691fa49ce38a02d1d3dbe3323a6d26980300db0e383893c36c634d0813093edc9c5a8842986a9df6eed2682e8fead0be27ca773a4aa621a9483f27b45678d105f33b77376d4edc98e7326d34126031b2997b86fa401c4dd6c23f8d674cbeaaa7bbfa0b512994c7bd91a145c64b283533753b8bc0b79d549a3e07efbbc0f8dfe44325efcc5355f3bc5903d8ebe35f3f74fd65160b17f89449251af4b474466b11ddaf2b2b9b1515546f275e4983a20d18f381dab1bb5607a3e8b4b545e17e2881b39293a2c6b16f53f5050be9594a5965fbc089c2f483ab88da46023f48998a6a2030c471e36402077f78387a07b2c8ba2720c0aa9ef2c7d124714a966bc5a91636cc3914477be620fc6f4fa9b5ca81e1e184a99c525d48ac422cbc5446715eb0835277783c71c52c2d17ad41ea93e6f3ace4a2f893ca3f802a7be11920b614bf51d52f70a222fd4052da319cd6adf9bbc7130108a543519afb5cc8847d65a0528fd68114a49873c29194c2e464eb1c44d6aee4c8b90442d1e16afce82ebcd609475e9fa9ff310f654b3ae9c008f8cf54d409e4c4fc9dbcd38e11a0f337b0e35f34da03d88dd9b758e59f5ac361d5f267b0eb5cabadb6cbe5fefa274d45e36474c8f2f77afbde57bef8c18b896d89dbcdd8c99c8b1b307978eed8d1cf1cfedb5ad10f7e8e75ff2fb1397b85a8bd27bef8c18386f7cecb756fec5f6bedebafbbbbd857bfbbdf930b9d35055969d7e7c7bafc19759eb55e9e1b9b5069ffa3add6ad3e375f3a6b1ae71776f83636f063ee5bbbbda4363cf0c2ff975fe8e3cef7f533aab2f9b335647c6ee8e145dd5fd9ddee2bf7d9ec3cde340d7d65d84fdfe38e8e531c8ea54d5f864827ca770eebeb23ce9f9dc777cfdbd14ebc161bfb37d72f496acba22562d7d193befd280f8abc8aa2b1bf590ad1133117373edb0db78ddf8de377fb9fdc44a7cd5169b75fa65fbe9e569c80cd6c620b88fbde3ba5375def375648ed1ae29b60871bb7350d233deefabad1497f99ed7ddcfd610336e7348f84a44ad45e9a1205f287156f2ab4d8c835a1d63aabeee9663b6665c8f3ebbeaf7361883b23c87bbaedaa8636a8c780d1a3b5d2ffa78d02dff6b7f784d0718b0591973915af7483d0c3a9c072d52d233bd5569ffb5a9ae762287d8ea95d714f1694708c1b61d80656d971ecc6ee6c5af96045d2859d6509700572c717e1cbc7f7d399e0a3cf80ba9cad4f60d0c61b4395516eb9c606cf64b74dae99e18050286bb731dae13594456ad8604e511e66126ae50efc42aa8d3f8915feaf68268d550e480f579a51b2fd2d5efd33155d265db9a09e8d0d9725fd14b4a05ec3faf303464c013ec47c4f5853b742b2966853cf72b3ab03b037d2bbfad1973199e784d1c228b95260bdf0105c468bb450584ac6f26249f804173b90125f627c05df64001c4fa86b98e6326af8afe1eb3387723c1a6d2570f751e522df0bd6273648177057a31d896007d45a524410eba0eb43c11e959426cd119a8964e72fd376fa8102894dcffe651de993614bb9586453d6afa82f402fb57dff7807868c1c190b37ed2204ac9d3e20ee8f7039a643bbe9373ede65694b31a99546b4c7b5ee061ba53f63a9bea84ecabcfdee161122614ebd9e8388b51031e1c6534a604464021c905ed2ea95304093850ffafa07cbf882f09489677a508b58580d164a9125a6dc3faf954277b002892ef71b6f5ffeff554779c8eb695b90ce60ff5be5327eb43db5d45b8cda15e6e84908729fd3408ffffcdd63d91ca96dbfb5a66fb6fc84e83047eae23950cc19788732a5d7b8334ce497bb6f59e70a6f47ecd7cd54b85e39abe4d43a9fb9af491e82e508db364390ef49fa3be34ae4d2cf57a62185b21a0a8090d6d54036acb612a140ac3c7978dc59824b4c00730fc0f50827c02471293a5b16202f892b0f27d6dbf4a9ca8c93222c70b11212f0b7a21faf8fb029913a5761505a227ec1ad40c2f3b3c093f830b2bc325e7b5e67f39e4e6e64b7687adf025e09e5731ff40c1558ec566353ef65922555ad04d2b5d7886b22094423bf89db0ca394310ade7e89529d64c7e83d411065e35df9be14c6db2548578c87557d3dfdd8a082e1d2f38e9fbf13f47640746f857962e6a3b17046df9cb19dd6985a2d9c20c1d62b63a0c61411d15d8053f06d1fe2499ce1c6638aa2b1d07c95fa63cc270824f6631ff4dd1735b5f0cee616dfe9c4b03ca79253006beb0a5d1d73e4681c437d6be78f0502ad84ea9651331bb712c49f46b93c3e7104ff90018c607b5a76aedb16b45074f7226cd909c31ec4867c017d42e867c935949ed042be0fe7dd9bddb3a5c869ab469cf4d48010b3296c8f03f7daa0a3a25c0ef4fb845c570858c2f35349689db20957ff1664ccd04ab1ace07b33cf23b064a7dcec37bd118b4fd3c7070827aa676ffc0bf96ae3435173395c0abf0b9f36d290e5c85298784b2b561f6bd1ce4a3df0ca4fc49a8d7b6ce04295712bbb21b918a096de3d8577660d09d9329b3767380d00c39c62833bb7a215d919b5c41c26fec985d7c2cd9cbde8e5194e2fd8e52da1905b9a73cccd92d21bdac7753a4d2a2deb1427a59ed08955a4ae54a81e9eeb2507159ef4821bdac7659acbaac7644500faf775cac76b0de11943a4a9714b83b8561d6d955a1428b7ac70ae965bd63c42af16aa7c4f4b2de15abf550b851b852a2ffc786603ca75450f446d99bb287727a4f878368952ddfbbb5a497979d52b98412150a74ca884ae9126da78a4aecb2ab4551eac56e49aea154e4efc0624ab22ab27477155f75e9eef20a3a52cae2b2f353dac2df9993f0499905dddfe865914c727f6883637f077fc1b6d8d808ae7804850bfdae7dd2e9145bea76b54d2f52768c9a4a01fa942ef577ac920ea52e14a74be9709d1d65d2cbd48e55d2532a7d4a97fa1da3a644413a29b6d0ed96492f53bb969a4aa1e7b14ea543013a94c44aff10af4d5e120da5eb53ca52bf6bacf432bd6b95d42858fff5895a3e4f5844768c24a49f2026071a6246929d55edbbe5ac80535a3c2565e33bda2bd181777ad2409f3ab44861a7e8f1c0ea1351b8a0ed9e93b1949e960283be73d2710366c1aae680142dfa9da1a617dd4ea813e2fd8e92744569ae29e3757644a5064a370a5728995b4ae2ce2e12d38b7a47a8d641e1b8c582280cb4e002ea14266c5c3012424e07facd0752603289e0284a4d891439d84deeff34fdeeab5a4c7d6fcd869c40411412cdbccf3ea4baaeebba5f1768831dc3e1dc5dc5b8bb2a193bcee5bb099fa0bb880e63580d7b1dc670f7e61585b4bdf7de524a295392328a06b0067906f81e51d981cdf10585758f7690e55fa088e301980c7548f9d9a8bc9eb8aeb70ece64f3e475b1b5d60bc6826f950ca256d05a4acabdb7042db8042818060c4658094c30884b408231b6f7de7bafc97e1a2c888f2ec79711474db655bff7c72865dff93eddbb55e71a1e39a3b7ac94e4396cf36394b2efed5e499e8f39e6ce8f502792d49b91a5e739f3ae13398edb72dddb33ff73bc3d5c7be68838d222ba3df4e38266cfa1fed238da8b13712263c61819850903064c7fc912bcb0e93d1127f3b8bee9cbddeef6e47e9fce01bb1772f718e99cd64d323b8f33c65a63aca92bb846548e1fe84f9fceefceaf61adae65612e6a8764bcd3e3641092b28628cb6fec9701459cfe1b3de0566bce783d2d49df68ad4669491aa5b51ad52f449c7eca6a65507b8145a4c7c86b2f449dc8b9b4b47a621091a37f8c453332f564a6f4a7e5ff0fd2d6fcee94183f19a43eb9df7ab425bf7ace8a38d2bf67ca90dd7ab89bb65a9de3d3e70cd9bf8669ad1a1ef9f45772c8564a25a11b1de2eeb429a594cad8f7f2ace667fabc777a46493f1c71e2e36e75a74f4abb5505a27df6456ab7a243b2ed56f3669ab6659906e4befd1f59d7ad61dcdbe9b461dc5c966954db68f7ce96afd6d1ef80701873dd8f7b81bb8a3d62a6de73cec9537f76abd546829dcd65b7da72fd7c67cbf3bd86a7eb76b2db6924fa9520cfe67ab06da5e662ddb1fd9eeac1f6abe1b979fb9bb7b73d623e410cfe2d36edc119638c316641524a2957366f451e54d45db3f5ae4f91bbd36e45a715ea396bb79af428536abb9557b0fe1c8d20f502ee569db7df2c67bdd40bf87ef659b792d9760ed832520dcfcdf66fb6f6bd55c7c37d3f3b33acd6937b284f14c0720a14e86e32bb8225c7948dc56d1127a505832754a7e04059fed499924ae8445a90d6644603d27e1ad5f1b7198fde106ffa693c3a43bce9d79ac41c8a24a29ab61ad537449d4d0651878b41d4e994441dcd861aa20e0d51c7fe9d418618a2ce8b2451c78424ea9060883aa5235107b7a28ecc929907e90ead8099efdf34205003b25a965fb72c3fd3ba2cbfe336dc31e2bcf064c9cb92e6391a2da3f96b2bcd2765a201e4cfa799d994ace55f16dee801839a4fee7ecdc771842ffa4aa1b972ab50025c8253bedcf35081f42a685f829b5570f11dfdf198c8f1e750d4991f4fa79cdba8b60fe3e36f341e0522def4c3f0289378d3bfc51c9a4344b928105167e6fbe90f51e7c5f7531fa28ee9fba993a823f3fdb449d4c1df4f7b883af7fb290f5127fb7efa137598d01da28e8befa73ad0253487a8a37d3f9d41d4d9be9fe210754adf32013d2f0402403a8402607c3d7707cd77dc9adb9cb6bb8c6e49f699d0bcc963d2a3da01e35f784c7a72ec80f12ebc186dc860185faa4ff24c7073f765f99c09b0094eb97e329a009be094e9c704c6cac2f0eef4666411380eea8a37fdf7ba30755114ec7f8e19b43b96a7e6683f55a3e42b835917ea8a65b088d3af7a02f791ff441ca9b9ac0fb68ea79394eeee325ed216f9a6906070663924cb8e47833239622ce577b7a23fbf79e8e77d5ec489dff7ed17d13e7bef6a805cab7dd76ffc662579e427234ec4316530478e6aefcdb25a7f5c20d7de2ccb328cb5d349c398be3ff54927b5937e37e2dcd2096254b79b5bf65af7e36a5d8f98e704eed601b9df77fd66ca39e79cb12fc9ffe6f9edf4b6923cf28bd766f44720b7e0f9b6c85b986dfee35bd323e6f89d2006cf3c646e7456ff1177102942faee8b70bfbdec8090bee840b86fb5aad95772758298db4343397e7777774360f6cc9e1cdfdddd7d7ad09c73d26e55bba88b727c4a295dd1da3ef16badb65b4d2bdfdadbaddc4bb1806f8a056cff7ed6ad3affa66959fdf9d5f0645abf1a9e9bebdf5cbf0f04737dfa8d406e914130d3ad24f3ec78b48ffec49d1979be25c1ce8c5c7f67469edf6a069d91eb3787228e1c8a38f137d9ed6c915b057348d69bd113219efcc8fb7ae2caf26f06c1165f289440f6a77d8c68b911ac228e8a282a8228cbe75e45e820cb8813592f283f2f284b727c414992737c4139827fbca054c920f78212745f35085f34c8929a9282952aba34b172050c3b6c84220a2a5660a0440f9058d96193c8d6b7d8acb537b0dc54a8039f5ee6f832a228d7e4f87a5204ca0a1944114131bf55032e3c90020b2e5a3618aa88b1c21a5a489010001359a408204a3c542b6d7c58e18a15e0c002d8961d74c80c5e5e2d2401868a223feca05c32a5b424248a245c6082861c8e98c10b2b3f607ed065899726b65c616f0a528ab0c28fd01626b0d8c2050b11a07881124764a18508272e9a88712d7202d9ab224ef69a67a351d9571ed355548939022e3158733a908c4ce8c285cce3dfb077651e9c536608a19c819d846660329ecc272e582637c64390310283c081a803c921381076bd0083340cea1cf93da66fe8674432a54ffad8f43b25993ee74b32fd8dbe7694e98334ccf2eba39247f23a0f3ce5ec390ffc9ca172967de07d92fb5d3158568b1450d9511985fa16853910a0322a7b54a6b6868d8b6f1c2faca6a190e0d293be7b2f4082340efc6f23c471707d43bfb1376fd53c1566ce66b8c502e09990467e955488a3409be6612f1c159257e21f0cc33f8ea3a3f807ffe01ffc935b66eca54e2d86f6da4c9841cd08378ac020c89125ab7e8e7c730644be0f6a46889f7d98a8050c5221a2dc424eefc598be107da1dcf425aa512ac80c6222eb5d9a96fd61db54b27d5213cd8c8c30b81949234f1c0c18322e4cdc8b17a6199a4983438f1cb01c4350405d14e640402c7859d152e18612377070a34b8d1a1d107a21ca0f0b7040c2021fe1171eb4c0820a1e803820c41f0c21085eac18c2d08f0c5e500173a4892b9470420b0f1aa029421440205a824b8cc80c42065782f024074b88e1a238c01047783d99410631ac4062e186a02f43444f4c1122037d832b31384182091fc2f8b4be2851840e30a081162ec9a4e777d097f263426dfae43627ee0472281b2a1338fa977e9cfc58379e601065c23712a3294cf4604a972953eebd63a63c31610a11539a78099984374c51a24293189270c1982798a021f2a08aa32c545861aa08f38464650c30d9d40895e02ad75a6b03fc83439fb015b2a41ca1a0dd7bb3c0388a1229302951eef89096b2069f1c1251a1fe847ba24e9d4d699837428d51552239aa114f52c57bdc48df7c74a851fda91d3078238e8c7292dc7af79b4f30e83d9ea473c0142850774eab7326f5dac356b392f2de6ee7b87ecad3d77b252375b9ea8ea7fd46885752c6feb49af828b8dbaf0f24fb6b6b762de5b87bb3f9c37eb79e4e269316fddd335bd38f027dff9a15e5a1dfefb4bf1a9ed9ada4bbffc671b6dbb91989be1c335bfba1b672d76a6d96599b6516d5f148f1803bc50306bd8709ce3ed081b27d7b73f65bcdfd8de84bb66f3fbbaf7d8c31c618377994ad7d29a594b285b2b5dfdddd4e7d8ab27d77f75934e7a441d9daa7b482b3a77659e6a59c60eebb2cdb3ee3ec77b7ea78ba6f28dbe7be9f6cdfb38f31807d94edd79f6cc114c0720a0e94fde74e6d6d436cfddbce6c94e4389f7375efaa3481b93a9d1a772788c173ee4c1f448a6c25dbad4aa91fb2ee762bdbad6246a24f25f5d9e6c71aa0b772eb80e9cfa3eeeefe392a127277ebed532434e7aa4e4a2905a50f8f5ac158c463726e6dc7a3074c1fcc6c46f2a7353c56388f13c460f936562a9c694a072c7f8b5636698aec3f776447dfbb1eea1c3060c28431321a33662737aca5196dfd5b29058434cda8610d4bd93e27c69472dcbd734e5abbf91d01fa287ca74649139578889df36b78669e2fadb5973ead5f9c2ff3b4b16d7ecd7c143e8ea39b96d56ab9dfb8df1e08b76999b5d6d21afb28d4a76f552af9368efaa8bbbbbb855a88fe367fa8ac4156f6f458fa83c13834f483eb5b0aa2ea5bfaf67e6e3f8fbf53bf3ef2faa851d65a8e8e79a353180ca6bdb4b3aad45b5f7a32104004ff56b986754efceee8571e51b64f5a6d8e9dbd99b67139765c472a61991c3b191739762e5ee4d8bd30e5d8996672ec666872ec6860e4d8c138e5d89d62e4d8c590916327a326c7aec626c7ce86841c3b1266e4d8cd8838f2ab4723c78e46c4919fb7c945c741abf44d3f97eb057fa160320d5325833d26d6468d3a921f0d1bd57f230996eff467db4ad14b7ba1313651fc5e0204d42e232323a358ac4a952a5560b010060b6592e9d3a7bb6c4d9f2e8298109fd3e7f4397d4ef71d19a38c96ab95038d8a602e676dcc62cb9b45195b6a1b6ceb76a28c1dc7715d94b1e5922539c62fc576e528d339206ba0d8ae46c5373232328a35ab59b12a5560b010060b659224b2255dd2255b92036044108b4422880991269890a3bb47076431aa1a45ea76a4247152ca9652b66c295bc288c19d4e32661d043c4bf95b0d2743868c36d3c6c65bda78f1b719ce3d181c0d4de700189d03fce41d043c46e7802cc6d91ee3ca6f494ce9806334618b3dc5c8149674bda4289162440a91284651c244f912c54b942a5164141da228c9f6270c99447112de60c3581826c757f82564c28912b02d59dcb0022d6ad8000d3a788145831d5890f2c56ef10e7be890124a79227cb5acb456e93b5c22e099e32b8a8f15515a370a4b0bedde7b03e6727c4131fa014ba1031428a0f8c035285e88b4c8a6d43044961b6068e1288b2d8008420d433d60294203f77a0194a02949024195a8a8c87d5ac86347472d63d712b8f78ac1208e612ab09530b0a12e7807d8095cc5676ab0203ea28c1c5f56ace42cc7979527516ca5526a0a2ca7b711b122f7113a9ad363474743f65a919a02e7d414d87fdb48a4dfb0579a2ad0e41a8178773ec9f567900d5344e4d5faee5354bf85e698a3984b27b9befce99c92ebe865fc226510a29a01ae734a5fbfeb78d40c480af28400fdb843bf7b1d4eb9dc79b1514ee4ad3076c148146199a6a6c0f35b7a42a8c0fdfe7196a0b4f2ccb8d41458d21e5b895c14e64d96e7b123a0ce9bea0806b955bbebca2b435b9c1425ff2d7acc06e5f6bf2e29ab137991bf8575536ff9e4f6b72cf7d9610bb57f059ad363474d89286de9923ffed5c364ffba821d324c98fd6d8c32664823ffc6a424adb035aab91cbb67e8a9673a35cab110b0f6f43f4093e78b7c1bc7f6fea9293078b3bf88c8fe9bd73dde292a3077a777c12c5b4f05496fc479c05c42be931fe993a4ad10b1c2f25898f965880a55a94200d95715d7ab8a9279abf864f9df9190142d8ef039a2c78fbcc87ff06e951132a662e0a6064d41b4d6d8dd4d79a47080a7947346f942c3142fa92770bc5f288b956a02cb8ff35bfac002dcbf55e181144206005680e38bca920c0025f23b3e942d6ea5b7dd031a20e58c2c3f0410c1fe2926b07c9f2186d315c41cfc94157568fc091475fa632cca4e5dc8f1b378023522531e75a4833134239a91f6adbd19b9c744232e647fe7881ae57fc3065cfa31224fa04532e5efb42883d448f6df8aa4c83e692cfdbc188a3a3f3f839841641350d7e2526330a8b5b257f22e25291d214dd194682d2d89e6a3d1a0d9e0992892687292fdddc44344f9fbbf60a22444e9a7e4a404540aa25483f96228e23858fac9fe251f2ff964ffed72a71ed0907d49064d4fb20399843005451c37111153fe6e3222fb839a0bd99ff677228a38ae9980b23ff5ba96ecd81f298c38fefe5bc6a57280535e707c99e3048a3a5e8e3180b230818338a2d292c9f145050650e6d7113f35a69c4382347fa3a2c9555360d92acc9c02fd6a786a0572bf949e0ad446ce4827a986677620f76fd189586b79c0032570e7f89af2c48505f13125967b4085a5d282ef8dd6ca5a9b529f73bad3ee5a5269c13283f7eef8cbd81f7b0527badda71374564a6bada59413189c40593e3881524e78cb5b1de6584cbaa40b8c3027f0ec7a834ae552feb89762fce35eef3a6b69023972d04add298f2cfbc1d9ae7fb88c7d495d5b4a2fe2c8f722ced04a26a2e4cb4454e30f4fe007f61b1ecd711cc775ab1ba5763512fd685dd8625eb5b7bb0ee65c514a69ed56b5d65aab8565f9b75d597e2c1686510758465ac482dd214c94e3c7504761188661d86ab55aad9610d4d0c34e422ac7edb0b0a58adfaefb83814e411fa284c2300cc3b0d56ab55a2d217ed351a56a57d8523592d83dc2ac53cfb75c2e97cbe50ac3300cc356abd56ab58444a2481473c5c296c797e115c2b0d3d013655491cbe572b95c321686611886ad56abd56a85aeb0619d135fb6a48f74c91f20d7b37a642c0cc3300c65cb150b85dc221c3b7a56cbe572b95c2e198bc9988cc9988c4522977c0135f4b093100ca672b95c2e97cb752fc6a7d3c74f2d8165c36010002a4375fa9cd3d6493d24b0ccf55a27dd699ab3649a38eef588f8800022b862af5a0eaa23bd4919a5ec769f93d25a39d5111cdff6bda4f8a08d2c85a4b48d64badd4d5eef8f858d72b472d73d538665f66b650b2fc8d4763cbceb11b946b130a3ce8c388ee7e54adcc5a6133e992c17bb0668b3b5206fce7dc7c365ba1e93e497c8b5da1272e665aea10b17ee244be741c683be24cbaf79d095d83ce8494878d08d381118a78f61c3fb28e083e6413c5f87e3f83ef79b9f46758e37b1402c7d877ed37f677ce0c5247c20b6f96a3ef065e0f71c8b78d34fc3f32de24dbfff748ec7da9bc41cb722a2da8a988345cc91f1fd2e26cad86ec7a3465a59236578b1510ee44047eeb11816d1b7880888f1068827ab1510a30140992c6344007e9ad7d14f83668be1cdfc69e669de649aa933a61949e3c5f03ce6467e74f2847888fa3f9dee7b98ea824d2f93e454179c7d23c9a92ef2b5771872aacbf6f3484e75c1dcd3564e75e9fe94eaf22ee454174cf3337ff3ccccc320c3f0e4d3cc98e407baf8bae3e285e7ef621201a70b481ea8eafa390f08a444b9b68862b95f0221040c61e908a44014285b5447d2b88dd46ddca6512019654a14dfb2c5eb3f73d8c8f2b38c39b8512d7f9e1c7f280244547f8e9cfd76920478d207daaf59a59cb6750f78ee43352a321079abc398748547548ed852d323ce5ff9cb1f12619dfdcc93f274c2b75aee6a6f6ff63a9acb32ed41996c5f72196eed332fdb8e870f22454a4ffa22328f81c8e0cc4aca7524d266b9adfb517a528e2ecb4818974ea712c61cc76ddbe5eeb55d0462b62a15a9bb09604eb3a527bd8ec61d90d2179df4ddd7d15dd7f1dccfb88f5df6dcb7b3e5eecbbe9d2ddf9d6dfbdb752bedada669d9731cf725c8da077e1f58827c3fb07eac991f8fab600ed1bab48317971718a21c5f2fd8ebc9eb1594e3ebf5f37acd20bf5e3d4984f9222b1717e29e58277407f0e64882488e2f248c7244428afc42e2d50507195e5d5a7825e1a44b0bb2982baa78c18a7cd0c40b06cbf1050b5fb01abc603ebc92e879c19650ebdeb4d60a844b39be5e462654f1b2d2b5d6d7935c6bad35e8e533833134f88243124f8ec0a41c5f49f8f880040f644062090b0be203d602ac05b586ed31d60181198ab000032398881962880d3500010749befc6421042e425daa742942d638d9bcf7a9c6c9664aea4940c1854a119722b80001864b0e5c68c820be0197245c8eb80f7c7a2e3d58bc943ca9920586a467870502961ca2b8e064072c38313168d606c1e032c06453638b105b7ad062859629b6d870adb544602d536c6965e99245488bd0c4d1d92d576f72f97a278782c1b7d15fddbfab65db637050c4911e2725c58853a3ab50f9804193bbbbc7d8e588628baf0283c154f68f1e98437ef464bec104ff8d26f83f0c96df28aa12c2b695e236abaa075c3f3047bdd7da95ed5aab533ae75c4deabef2dabdea5c3d9510ae3b5acc481554e5fe40fa3e3db0474e2147ee778a24d600fb4611584ab90029a55449a9434a2965b5daf708d20b88391888dabffc7a9020a23a47042f5e8647c2d778337ef35cbc8d47e3336fbe10c77102bf31c916648fd7bc7ff447d9681c36ef6fc229e6043161c1aee20183cd2241ccc14044f593f032bec88caf79d263d2e31f324bbcb959c92c11d52f8fc44a5ac5f8d34b29bb9d9a637c35ab78c06024aaf127e187ec90e1c9781a0f44c6d3787f1a5f0a7cf00f48cd93f0a560c6d77c0a481042a4fa01c3f8f9349f7dcffc8b3fc1f098d0781a8f89cdcfd07869d438687cbfdbcc9f51fa58aaf9ce338994130403193f884f40f3f567fa644fcb16624e8c28ff5e78343c1b7d23df050958b6b2482219d38260a0be8d67a36b3c193547ae7faa554654bd9f17c160b05fc8fd3e5338c05276f47b76b74edde540ce6fce9f37a07c5332d9eec5f874f21b4e306abbc104bfe330cda7a626f8fb663efd3c672a0c6e196676adec8068d9b5f74a6bbb56a774ce49dd6bb72ac4361a15e9a3eaa78a3874ccb645d93e694d6253f180e347bbc5dec2d262859629ea16a22d5f727c6de1b2258b7cee8796202d405a5c5a7cb4f4686165896529ca3294a5cb96a32db13bc406220cf9e048890c4751784c5821841f1bb4a04872842dcb68806da04e266c5303e3d36711d292834c737c6da992411451d113d6f690b51e54ebc4869b83b53688059b139d77d84347161b64104574842230c96084a558599460219af8e109662d212446c8c86671610a0d08d87a31614bb685b38918080591c1089302cf208c9012219f1974056e8263c045602c4d28c6a7176ac996d7dbbf29bdb34f4f66f9c98025879bc540ba585cb0168b0b6e15b3512264d3e6a99c4e3e3a08998f203f80219ab5896d0b75d7c1801e5b6a0d2a5c1f711b9bb8129c5c89c25d31c2331d9cc9e64a970cd680d5201f40825c09720712840accc7e90a10d9951bf0151aea0d2a3e4e8fbaf2822bac0caa6c0f9cac727ee611698108582c16abdaa8d65aeb944e5a4372e9a1b2f5e28eea79cfdb39373976c0754865dab57e3bf7fb31d11e27c74e02714a76edd3d1a912320a7342a86a23675e9c9f797100b96a5aad15679574938db065f2becd712a811bd9bf1bfb46953baa400ee99645d8628d495ffed61eee786053f68e479c53ce49a23b03c8d329d728197d7e26539dc95be5a647b2d76b41e9ca7bef8d9786341ffbcdececdb6ec726df892d9e91ad8c3c079069649344e977a61f58813cbf9aa741bcb068f1c24245518e2f2c4358bc60e1f2c2f204cb0d5e58805e589aa8b0a8ae6017219840d8840b0dbc659d3412e1083978410e59cc60871d35962811050ec4f8a00722b8d854983d40478f1d421d1807bf8112bfc1912d22b18210505c463ec06ae00122aeb0011416967822083618828a39c410be3fcfbcc31e3aacc484a01072a20b8c304fcf8618940bc330ab04442222b5ba90263681645c185602cafd9144eac2dc1f6d9e5e8d233cc7b936d8c6d28032221a17518c73c1621b4bd63c3d1b239cb2d60dad7555d80ccc5b998de5feee4af3f44c47b8b228d0246acd74e83e8972bf3b9d1e8705f6b063aefe199b3d3d4f6f1601cb784194fb29b5aaea2274717b661d8f09ba087768b24c6c0b960fcac472ff07237c91c565cd9c60a8448e153635cb5095042080000a7316400020140e8944224190c3592026f70114800c6e9c3a5e4e32928783c11c8971240552c618658c018000030c98a1a1991a0400a794302a7b2b9bbe2db4ca7607eeb25d9a50d51508d1297aa3a07e223f7ceb6447eb262a2ca167d4f824c5e71f43916285ca8d0fa5f47af7fc6607ab13e486cab7475bdd6a96ea270549d14c40c844425018f0fce2949e62021691222ca666402d43a9d63986c4f1045f7c02e985be221f3c703c6d2a653618681fa551092e9f0e1e4412a7bbb26ffc1e17ea63de84e42493559dbcd6eee23c016a3fc5a8bf3f2dc18458005d64c1a0a9af0b248502151d4c061d238b4b6c93e1b66800d87fbb4e2af2f06de822c7edd0a3650d841a6912c7453ee36e8ed1faf5d5562d4ff8f28491125f4fe9970af7235f82161d195e2fe94fc4f467d6a80434e6429cc83e2f28cf343211931fc0fb6b5bee1e58bedb3638c7748c643a6621b7f42c4e67a01f46a80082933e9a1f63079a84e89633ba1f26cfd2e563f9fc69c1203eb05525fc0f8499078490816ef9d65b62e55695dc8af75c30a4326326c89a319cfbeadeb41e3b9d134fc45aeb684bc93230e0e32de89edf40ea25284e12c0f4293a60ee2905beaf67963b600c6727b75871f227f9d918bf2242ffb79e7776319c3d6838e0be82d28e58a45bf3fbcb788d765cb4ec709a5dc7be97c89d5edb2875bbf834299241a2c9ea220dbe905d82a8a6e1379d5a4d0399a095fc8af842d2d41299744229d9c09e3b8d2f647e54126b9e7985d9592bc71898c34ebc88818c031fe97b1b7def8d44d1a6ea0501491e6e0820efe20b8978c07da5cfa0f86f3f7ee65d5932c57f7ea4e3f14a2cd97b1cdc34d664a501ee4c8593ab0e1ed7f2edc79d39c2e583b644b9a2b0876513933dc5ad1419410857f266f00c63f01a833be41a99c0faa0f1a313c8810df31c6b448de8e243d6f125d5f74918caeb0f91bdff6780b6a16049a252b6e43956fdf7263e2d0a746af2eb414e01f711d58772c2d6e6dbfb54b80c328fa2bebb6b6db05527569295351930ab7ff059635287e619fd1537d64822733f4a1eb05d8dbe1b3d0750577d96931b97c5cf1ee8519134e1d3492369739b4801eec22dc479da2e30d4085302525501961ccb3e2f0d38ed9f88f3104141a8929638e6ad24d54e7faaf7ce13ae1b2c4e307aca4fb9f3e145505edaa6600301fa4ba8e055c24fe1b8681f6a862eeaa6383858fbead675255f0d82d4d044cf34a572bd32e1e57c88a8169defc0c9a490a5e983754ef46cd6706e81d1334b9587efa2a577bc505ff967a7168d84687d586c12c8f3a6205da0aa4e45418f28718e15c52e5eb0fd6361030d21543c073f4ab8020fe5b850e2ccccb79433dc573608e79b9fbdbaaee038cd008c1acef33cdffde6a66d27486e41c368cce115f50bfe7c619378252c9eb34780450f7bcaa827731affb2f9c9deac3adb9f1dd0fa11ae4d74973016d2eacf735b9f03a127ac51e6f8dc1097f136ad88107d5b485668bc0d96030e7cafe8b5b57a5fd3522dbe82f56f8b00df90052a2890e529ed0725f46a4dec92a78dfd30fd3016cc58c5278726bcbc4043e025fa22d23142257d14c018e4da8d0d07eaffad69b87e419cb58818dd9b27ab025946c191ae046df9f3e22ed2e2fde4f4d0b59bf1434fca76eb8d4a5554c09dca00f23ef48212cfcad865155dfaef5e1874ca765e1c5eb9a32f6ddf40ab972331ae5edc118ee5af7112173a29f1df6946b52f9b4649b474a3491e9fa62497f05ca1ed5014579b4276905f7e849bec21470af25fc4c753847aa1727ece5b062310a6c890c508fdb759368e0b38982b38a98963478f48a88f776cd292b1c582ce3cfe590da4f42e0163df58acbefd3948e565b18e0e63959dc044f4ad3bb7668cc6bf5240254219474aeeb399b933970a2e4887baeec192388013b16c55168ded96bfac05c7c5c3edfac896aecda1915160f97ce7104b1e9ab5ce965192428cd599c69e1e83eae09b6d30dbf9284872c662fb801bd8b79e0bd6424b72a16e5196a16cb49faf3b3dfde62cfd7e7c9f4757f1460bfbc0ec20e7f27a117c2d9603096b418829e944c9c7174f3aa09a9633f37f6d27713c9bac80e047004cc37ac122c20618acebb98b7d03a97d84c64618bfe15755f610c5d22cf2f08a7e5d12d9cf676873066aee0099a2f03f74a6cfd3f1aa75484fcb25f3172c02ff8b3b84e5ff9a3cc62cceb280fbd9015d41db304d7c0619b8e024bf0c57ea32678a6bdb955225ae992db1d511a6a0999f2be48168fd549afee39a5eff4f34ab3659e12288fbeee96c26428d328ab3a4913a319aa5d8c838f9d42d821e714d28534a59e72a066c46d13cdb3eb6d6f6e625f4aed116a4d4056ef002d9a9dafb69113be826581a474b3873bad8cd01ab0d9c788de24509d8afeb94ca9cc1b8491f8a25d6aa25cf4d0a53cdb1e4a3a4b88a492611fe75a6703b56157acfebcbf2d44086dc1a7a0d923a919c1b8452aa8588d660cd5a8266abd3fd0e464a88d66f09cbca7267d543a1c4d995bb936d146e8cf9b07211f96ac91909f4ca831fd9d977872fe236b7cfe1162851d6947685be5c9f020f14861cda3d868756d607c135c7f4d835d4aac3fa273f7ea93f6853df03bbd7d9eeae588ebe1a8fd539af2adb712ea0e6943c9df3a1504bbb882eaef0b53e0570e279741db915add94034199a20e81526e0b9d75157dd15d00a70529efa51fe152bb556c318bf47d0e5abc878c96320ea426ba0fe6504ebe176d98713be6b0cce0737040fad90cf9c052ce98c44a0021f2da838c85682e2f9f457af64290844aa0de8b9add7791ab85d02f007f1ea50664efd623e879913baf288756279814eb1a2989ee459b822489619825e4c41b075993cdb1f8ba04b5e71d46a82a76d0485d89c827bd512f04c8922f9c309708b3962656a6d902cd3ea3ac808081c25852c179ff1edaa6b5f68e88220b197a829af3ce5ee06e82ab3a35f63f2b5396643facf21322571c6b2c0b03d0acb66508bc3e406db8ea31fc2b0dc45ff5d94b2e46236d828ad7bd0e3d6e899cbd20a1f969ac0a19adefa79bde00f53d002c0412b4bdbde993d8be780780f2b06133922580b33c28f4fba1d9bfbffcb24f414188bf83f39699285b5f6b14360d7e3b1460b5fc2ad61111ceb1bc554c4743b8eaede0a4a9905ba30fbc89604a911a24c503a05856debf0b85bbfeeea564759e726fa5d6a271895fb388ab5bc09b2237b255cd41d992e516e8108dbf20d42bd85ab6131bb794098e70c730151d274270cd80e31eae04daee10d8d6b593daba47d9b149bd18fe5c45254d9be544ce4e7b39bb5dd848b0bc7a483599c93a942db4306795d515357e2eb489a1aa22f304014c781f003b6137bdedfbdfe4a25095be9dcda98e899605a0b6d0a2cf874f6a00cd5aea878ba13d2ad5a49038541975c2040610627f8e5fabb711a2560c6293bb05322da29e7880854bec5e2af66f34fc629f9735ecad7ed1111d12c9997437486343aea6288e94d4539c37a22af7e766fb012eb03fe9d7420c8c59270d0afcc604fa60fa1cb152b083df89881ed4088b73a3e7c28805e6f2e615f37d20fa74834bdfcd491d9a0e46b4edd24d7145ca022b1306647d9211d930e61e8a520f6aa855ea6559dddaa630c06a3be9efe5e9390914f1815f057eb5b2f527156abac39de7956ab31871c5655d7a792b486e8061ffa5fa398b2be6d38daca495f8cfaafef4fb9549d73e5be1287d6c325d9d0070328dfe217164bbe8c1003e1732425011b9ba6501a67794a6a545ccbf44f3b36f4124bdc11da0b9fb408cfb89c9c7c4e773423c86e5e972b648d7a2462e1bc15d8948de7258d36fa22f0909945848235f933ba5ae37cb6e3164833957fb68655e3c851aa039421d192f4eea1d1153b01119db3c8aa2a1703f4b1e9148a27cb2804552c931de674150697df1cb37621232bf661a15c385ec9352a03cfeb0c0d8adf9a2d8fe48cd35dd502a1471335377e4f0afc81f9bf8bd3186c26593a6fd53a3ce7f3efbef96963eb2b21140857986e6bdda1b5c6fab1b94ce71f255e3376b0d5b1fbd4c876166e16856d7eeaf312b920881a68210a3b5854eb495588037ec118b175b8eb7ba72b79f846c063f7596c72015be24500b281501861e2a394d14eec9faafe848d798a492e1a97a580a0a6ad1e4ea45e53b27542d148eb3295b1ad03808c2b2e45b858989bf2657ae914825247c90a73427aa44c6e3fd90d57863cc5ff0ee2b48d093c31f62fdc4a1efcdd612d75595c0ee44026ec85326d8d18d6bda448aa8d06e241c0bd1941d79eed8d92a881dde873037aa42794e0f4e7297a138ba338eee3b6af6bca01958b20cb9cac6512da8aeb839cd1e7eb33d10eca1753262dce5c643733b01682ec8c88794224d2aad80bfc67108a919d995e425290fb4ea6acd6046dfe8ac6f81d34124bbd6fb3c80694db1288d2cff0041c1b6b0792f716e7076745ea47692466321bf56bca9c474408d3e21dc0c395135c881079a6a7a2d59f26cb4c75e99ab937e718a7eb1a75fd93a1aaf67634ad467812d1f533d89194d76365341038fbee20faf985a1baf3df1bf971bd66c074f7ee0b972a214a54518da7ec415495ec25dde9b6fb6ed93ad2bd7210dd5e7f422bff88a24b08da0538a548b9d93016d8f935fb8e79bed39107ff0c37601c5542757daaf1aabdceac7df606657462865e6e5abd161a5556dee87c097348157bc9206a9d50d3b5512b492e970818804b1ed3608649889131cae951ad145734e6d14b7697a918c2c54b80052fa193cc157b375787fa69aaf87123453cbf8d0e0dccc2cf6c6abc0e0c95ffde5522a770c8f26644d91e7b691a8500cce91a0279f4f9cb22e7f7b22177671bc800acedc6dc837312274c5802f814ca5a00e09f4eb68e8b63252f072740eae0242e3a835c6da15f8f2924f7a052714903e247cb04de0a8e6a90f54a2c8a4c9ff420105b03219294b684cecd37e3bc5927b17262872ca01687aff7d288024df4bcdf7622cba908536cc9410c76f53181541cbe9520ab04961257c7f7d0ce99e3886015c1aa11b7400501467e2db826a57b959609fb492163816ae8e9014b2714162fa50261be1204d80ade080e86d740953d5ddebb95564a145f6b811163bf3e3fbb618031f123d952c2c3bb49f03d00ab751228d9a429a0d1cd6e86b192ff6771534a5634a6975207ad35564b6c4bccd631ad183ba509f89fb0dbd88a30fb12f8a6a3743cb311463e5298930ed65a792a7930d61b1a8b12226dcf4ee28ede2a2564ee7c5853b28833010f6b8ae8cbef9b6f6296fe0a185ae7807fb2a01402b3b5b2fbaa01d62aa7ff972ca8dc63ba843a8c5f892b9f7db3a0fa98aebe456713c099fc14593d5ffee79fad10a47bfa5dd1098cc3b9bf53ac55b0f6783c3c2eb15474d60862611c45650f1cec5ed95c01feb2e726ad11b1d5930a2fb5c71d85ff89a057072aa68f3390292668cc782394388925a02ae101338cf2ad1e0adf8a612498935220c847c5836a295fcf88fdd68b1533c6ccdcdb313ad9040503b0432905863a975936ab2fe84bb9c11b6e0a56289b2496b9e67eddbb318c64c672149c46ccf412643085490c409232c9d868acae14065c0f0f4c32c6f0c52de48cbc9231bed73303d2e5d84399102d5dc043890051a94cc6f37a7c9666c07342a538f71195e0e32cb2208e400113e0490b0fb04ce18f4a54c80ba670a1a717ca038c59e1bae99585e628e7794c0d92c41f3535f76105ee4164c94079b5c07b0c3ae139ded11911165ed5363ed1dbec9a345f485236cbc9d8da1ecfa55c3929194260020b4d2e75101ea81b9f9c375532adf66d7286d2b40bc2051d56916b859b0ca2691708fa29f4b57936daade8b083d9ada1109b61d2b6592e89b4048676a1b0108569f0ef41a8ceb025c61a21dac0f5ce5208b3e392229154ff525a2b341542de738395f6c1d8a1e69008131248e95eda7252bc1f883f1252eb7575ae8ce4135ebf3499772d7c151eed940526cf6db0964cc7ccf4b6f2cb7707c8564a365352592a1a522afe5fe65841d09488638102c4546f8046a1e9c8df3f11a3e6249c94cd42fc2aca98dd2341a0882735e270e91377e45ce478f2d8eed6092ca1243a8ddc0e78a7a6f74a1856e5333734a3c3c282b848578761bbe69c1dc103d544d4b7d3cb93aa22f590393da6dea327e4ed513d688ecf7762b660e9e01b3d66cd376fb7a5b1c935ec36108c6ade9486859be8a60be50f20e27bd28e8de5249e7c3673584e67393096b08e8d45e0f89b22eb204b44d5952c412c85b951522a8df1c9bce331f6d7c6f11260b8b1e118110322ece3522ede77f4d547953eaee018b598fc8fc84e480a84446dec44b3704d5badf691fecd76708c51dcd688e69b93b4a7c4fb4b18cb4816b10daf5589b5c2f654bab83652d48165648b780f86632c96453686f457e034a167dfda6302e9375ec5c61c63f1197d453a9a8d10da1b635184d7187bcde618c7564da6ef03e51a8d3e59e71273e74d90cda05a8978d3d05565c5c4a9fcae744e1bdae0d99858efa91a46ebb233cde9aa73d6972eb3f45ada6d35fc721a7acc1cb5ebf9b09261d3b00aa3e1e0dc04a600776958cf098fa9d91331260501b6b38ca4e9f2f12ee9b2890b0b666e1228df802b61ab13f48db906bc1e358471f1b77451be7b8975583bea1413be975c423ddbf41ac4f9dadc700e5d7adba7e75310448ed1688f7a879ff62dd1744f5f9538ed8ac4a2702059ce0a7287bd12df1b147032495de130a0943bed0d59058d57c3ed6692c0199f4189a5c370dff063df6f1070166b5bea795bedb323f132be5b473cdaf4ced19752da6c888590bde719d35f6e98653704cd3d216ca1a8eedfe660471d13a51da0755509c5e99fa27ed4b30a61e9da9d6d7eed4f8d429a0ee1589809df39d085ff6b52f54298fb29a019d17edc83c6cabc7782f0b0a51a7a80d348bca0cbed81b7226d4bb2a9f4655d2a0f319a277b2452a589cef0d76f4e4f1eeaf836b5a35915a1b771af1540f2584ba86b2e738e48571e14c83a405d7dfe2492f64c2ee255fa671cca8efead4645a518921f710ff29f406ca389154f88cdaf5e23ede1838d0a9b399f548d1ab5f56965ba6cca5140947e77b8c64dece68232234fb9107a12d420934b93cd34cf69643e1f35f892e879ad1cc236260a0b14b8ff6c1eee9035fceeda4ba6c9befb70ab36b9982c58ef23e6f72c834cdae9b5dfbde08830ce06ed990dc04076eb898cdb7b17b30e7435aa3679e4fc79e9d083fcfc533ecd7ef040089e59562ed0b91016d62cf14f61d4db43843d9eca986c021b2d53a0c3350b2e49861b8ea90ad2855e11b573f399c630e435bf0b6f0a4ff07c60a1d7f841a21145f8b62aa3f83ac3f4c7a0fc15d5a12f63d5049d8711bf000ab5d67e4499fbb579afcb2048815a36f13c72391ca41bf2cb0b38205da4e5dcb0fe99975fbfa2b7f4a026681ea6dcb68b8fa2fea5d10d840b2bf7612a1c86c14777d358699fb9e062951a0ad09d2633d5a2b289f3f9e7e3a141fc5c57aa6220a91659838b33bda09300567b7401b2eb2a96d9c48bc91ed9b2ca39832703ec7da299e4377310d90cf30a15d2a361a4f4f6472093042d3dae5dfd597e2bcaad4fdc2854b95205f2b98824ce1b80eda7400ceb456c41b25c80c6c2e67dc0937bd3a4f162b02d6e50bb7219dfeca7e7f421da8bf8a712101c7fc642485ce3c7591426b33e6ca762fc9152cd5da3e44eb2f8a4a7e84b0ead1a3d8fac912928a220b1b54937c344766f0a531b71481fef9fe4b520131837fe1c0a39ab7c283c68007fe2019639b4911f740a2798ce015c2161aeef2334e7f87902ac037abf1fa9c1f399fb5eda883f2d6fc4d4f3b8a79680266ca61fc876f6275adca48e5cab269f94e94416171c40d584e04e217b5e395dca139bfa6c02be53cf6686712283553a4f08e3368a63bae4a94a63d067e69bed5809278cd90abafecc53e40478fc857eee1e649da57d00a90ae54ba2756beba4f59adc5a48021a9e9be5f9e07021378f9b06af1b00e001e142d16424d80edd20c20676018c92c5701d2891b79da64f407459df2882caad11733ccbf196107cfa08b616d39d6c1ca4c3ba80a5f75a57624fffd1c5e55eec91c775a72c8c961e025e91e15ed4e8f3ff30a56f710be5b9b899c26b40b29357f9519816f8301eaa66cc368d818674eba3a4415d699f53fe233216f86dd04f9657c827e4c51e771ee2642c9bb89fbf5905b95d1b68df33833a894daf6cb5711b21a4eaa89c34cc3bfb724fd08bea84e62730119023bd10a137d0df57a887438a132904701fe0feae0009828b55e2a779ffe33a079d93ff06d45b99fd09e971d660bcf2278f53c42639370d0a6801bc478afc12a493f0c240ab90eee1d97e02c7b24ef566a433b372aa710804792b16d76d0627e09f6b5c491193efe4e71a4d237bf4433d0fda356f829335af8e134728a50eb0705b9ec6d48fd294085bd1be3ab342a53721f6bc5c2710ab41c6d6448713f5f16824474a61bec57f7dfc6a09299b444c7b4c479c8d5435f83d7524de23639eed23277ea7ac47aa1b34b5c6de117bcc5d4eb9e61c919d57f3466af9df0416b057827b309141bd155c6b78b6e752de47b5725ea21806fab1e261933917947e4050a7cfcea6f758265f38aa8b70cb904410eba0f180f312ecfc14a83fc6195650dc8c6f84725043b0e90126aed62a1fd46f48fdad215bc30362260ad4154e04e8f04f1b21d278f30b3a545ab01e9251f8c8b80b3c2c81277a51f78b41ae3d44ce52bfbd20b640e007195a88c7d3355ca4bdb1b64d61ab648638e9a173489826318c255c274d764477fbda1d0f63e8a82021ac4e9e8d28457d0c0ca80d113a308a0ecd19b02ccd10eecf8c5455feffa62d78a6de96e8d4d263a7a6c0a8550464eec3dd64db4318817a03eb3dd1c53a1e4b7eb2f838d48531d2d9fc29e32483022d44800894e0135fe80e5a51586852f2b932208bf1ba35dc56cdafe931990750bd9221d531ac5ba5e8e42b52752ca51e0b6f62f0047ffc38655571ec61345fcd291aeda852fa5381bc15e2f3f6a0981b378cfe34dc815b49ded4264e25a42c642a58527f9692399b2b4e903a74f36a2241d2e2145723d357200c8bdd123327a9b42e40551e3a83d2bde87d038c8829e83edf7885bc548d602ee022dd93f096df94c26b0128714bbcb5fc63b09ba9a37acb9705ddc7c5e99d5d538bfd8b02f2860083d5f1173e748310e90de2fc90ee943c4f744e4d5e4797fff926276d4268fe9206e6699d7ed04c587b8aeaf3a036d9e5ff414f41def1314b0ee65974ea115a46c5265846b7ca0947f6c2fa2c1b87a8648fdad1394953522e8f135c074e5baac99025c4bc69322648f006c6583afd1091999801cc46b8136722ed820307aa6a1790b62c9e595e967157a7b69e28b37502a2d37e219ada8c03cb4fb8767bb3292c25bdc656d426fcf0c82dd17ee47f420653b8ccdea5e4a5e779fc0e77d767d7e4f4823b47226764936a55e603d0f5074a0ad82a514a378a9a179082a3df81d5d09d2db0bf4fbc88d7fefa416919b11635dc3a235c6a3758ba6edf3172ba17ba11fa2ae7946b82f1b8c179e86ed4741570b7b2ddf4f192324086ffc854490ad839c531141f6056379e497c5409e08f4897dedb1524cd35690585275d114f40896deaba0c946f6e7eeb3f11e6d6127a3a8260728312598891be9d489b4282b9cdde7c29296059c7cd514b8db73b5872a6f261ceb9c2190ae837f66150e1f7e426c0ecd88739fb398226972befbff061ff01ac63c55bb312e4afc0693d17fa6bae0a704468922e51fa13398fbace020f45900dda357a6a83f6bb16ffaa43c12865e27a4a778ff8bc4ea858d17c9dbfbdd61cf8a002caa818a7e9267da107627c1207977803eb393c7edcca04f16b85e2c18b39145e6abb3542567d4fff662c4971ae3a30cd50476d3ec6910eee605033e825f39f865bdb560e692f149de43f9857d2a6076524e88d161bdfa25b05f4f7ef9864a391117c388a2b1a007edb238cb891636449fd8bc2c5aaed89f8e876f7fc10039a72dc6bf0d60f27c0136403b85e78ca10fdba35f3343532c6580c1d8b58f17222a879665a3ab7be9d34dbc7423f36aee1f9b64cf019167766d6ee67527e2dfd70552b4e14c18849fbcd17808f877a6815e90d1ecbe7fa5477b4cde28045f443a6fc0a28dc49596338b3d88b1942c2ee28ac82239c00b0061734bac56dfa900e9272347574bb0f57118c79facc860646181a0b3b71b08e2eda0ff84cf18ea3a2f2fccaa0aea05e994a85474ab8e6cc428e43944b99738a9756622157890696559997595646d192fe3e3525a5a4a6256f970c84466c56b7cbc68d13ad8a61091f6e7cdc3e47f2c0101830820a70ebf63581d37a4362c4c747235d12260ed2a9a3835e1dfd3af5d135b5ff57145b3ba825f3946845c0380514db8e620b5de4c41c58333b10133b88fc353889c5d7a9ad310155f1e96b228a68e8816fdcb85d0c238568cb18d2df2ba69b0f8e1d1f7c7cf4e471a230d8b2eb50a1f41f8143cc1781c914f0101a8b9b8462e370a2739fcecc9d10d732327240861be8c32053000742ba4f7ec70e3723c85f7ddfb0b78df151224ebd1b74b1957765357973e267046294bf1619d34f22eeee2743ed861cd56cb3231065eb734610a9ce74ac8396b0247bfa51080fd3a353e34dafbbf0c27073f9a545e1dc39066e003ad100ac02fd1cbe7d7961e1250af1b465b5f0e24fb530f9e96dcb5856f193ce582cef90012c446a38ec5ab3d3228c87d9379bb87d46f3e2809b6cab0afb0cfe36c47a96c7bddbfa71dd1cfd682c14a87329733e8225e5f12ac6c79339346be27f1135ad9f94b135715ee3d60732600863bd927e325d45697aaa9e9e2892f56a129869647e0a5f5414297199fb00a4157974514211759158074ffab188cbb728dab417e225c2a595eb5a2b7b8b95f787a52889251ad8f86ac313abe43c944a4f7545ede1175818b6e9cf40507a71f4d46460814f049192bdc1462a120540a9affab85c67d04299ea2731ee07a5b47a203b0321e178f066bf3e7340badce472995a8e48b332f9a1957da207d6b10af4230267e920a8e0a830505328b9a8328e3687161cabf121bf149026e9e82440f30088c68664c2b5082fcfb3010774196303a7232092d0b888640ee0c21667ac214141e8bea5aa5d274df418aca314c65a102dc7e05be96b0c95b084435b1a51970a366d4ee0aa2728b92e879c59402413d6e82c42be5aba8b5c4ba91c29a4b344063f309ab8e373c8053addc065aa3481b5dfc843caba22a4300912d47741a7e8f47b511b6f7cc4020d1f08e0534f1c51527a985e5b37546d9a24f3c7a34a13cec18acba4e268a23ecacd0d7ffea371ec740c331abbe9ef2bcfa55bbf9d9e81718e35434cfc1c5c54e57595c9220c2f9b023db058cf63d189e85dce6af44e46c0344fa34f35462b380d04e754cc7633f7fb5b30c0d0a1347daad293bdc7ed03c42f105c2aaf067f987fa650866fa9dd7207cd72454c05e3b0a97d42ff5133c29483ad5a683099220d6c557bc888fbfcf369fac94e6b2ec773eacd4fc4a697a84cc8bc7713810451e7f6ef389d65f0d420d525af492b1e60bdc165e832ab6d022ca69647df2ede054f97ad0748fa8116cc24d341758840211b6cdac70835e36615205b74b89b472aa201cdf31d9aa59322239f4279d321926ac1ef1a569cd7c01aaa6ec07a9f719e06fcd71c2d830fa4e73d43d171252dd3a20546d70b717fca68ecbb90ff751437a5582485a27ba7f5181dad87b58dc4e5297aaf308941bb6eb53737979baef2536dbe90f68cf65a63093df2b722ee8eb9fe33c3394fa0c43c78dd9a0bb97a2c509fc18520ba5ac459cf82405eae6e7ec431faff474d6e71ce58512530a3e55b69ebfc2b45026ca3b3649cc115d7699c42ffe1223244e3e3dc6d80f49934d03e12edce1e45081356058519ca4b05cf36ff46d524e37b05ef150046c1cd3e34cf4dd4ea307f67d9e3afb26434053f29d06a6e9d1d3fa9e75dc154cae6e3d42775b15cb30b192c738ba4110034640270f89557395ff37f056ff3b47dd547c6b486d21efc47faf408d68dc30d19e53e8c4c2380a306e67a4b3add7d12193fa32cb38a146a326ac7edf96f63148eef29f0fe872c531e96bb14aac2746a6e51493baa230effa5879c9ede89e2ba4a8010e76adcb06acc6be20bf642e7ba77173861880278453d7da5202ec7f9256475ac4ef84172d6e1dce6a2b52d628ecb39971af8b07a1b44322bb6ade5d509da25bcce00f69c66188c421af80e996325ad26a85a91a332a65783cbdbc3163cc1a213c87db358a49254a9664be3bca08e2bc750ad9b97d1168792b6245dfaf6e9eae2efad96e81c588661284ddfd9282a18572642617dd5eccd4acd455f22dbdd668374cde9ffb0c6dcd8d8a11395e4850a54912bcb80d1eefa2cfdcd284aa0bd42479bc7ff064edda14af80f9525f80163d7837625cb01313aee5b66833e0068598aad3ec44eb463eb7b36a7d85d07b357442b1c505fc3f1c3deeb6befd78bdc83063d1db04ff6236bc165837031070557ae142ea7b7191ff8c197224c8fa613cb12111b695ba2aa370c5a940767853a48e32aa71842064f36b7cd159a9efc7d2d8f0cc676237b0ddc3136ce636257684ae3792f4f3a37b7aa9eebf33456d346b0302630693ffcede2af7141c76783b8c436b6ea615d63f1a31796db0eab6f1ab4434dde9ec42c59db726b5ef359c311078b4cd999fc0dd4798aa00e752beb4754d48506a340e9a3d7e85965db8b6eee021ed3b15a1ba10ac7f9df38b3b8581f0ee5ead7981328850cb4a21065328ec653502799b12a7da9a8aff777501841afa5ff96113a83656f6eb56febd59d622125a9cd46d851fd86f8e79e82519833fba0e151af1548af0d19cb03aa19a0b353de283cde28eacf4bbc54d6727f55c7740696c70a06113425403330bbcd4cc26aa0c89cb1e56635a855d1c6c4a35c16bef1294ae4d8f1cb76ece623f03bebe57158d8f865817f748456b50d3e6ca05a558a8bf407d7280c202f555137e0673a0db41f744a76c173cd11f5c6e7db5df18b94863f25370d2143e83495a7384c9be68c3bf1bdc939c2d593525be2b0f87e0c82cb89d7f437a47308a9f7e02e45f50727a7cb4e888c8826e95c2a2ad7b5e88db94f004a2c27fc3ed9d703ccfc99635a995e3080bb03d630369efa5606f19d1236af9e07a3f111fa087774edb38ab1c5a1abdf5047bece81742bbb5f0986d82c6ad149e4fb0dbca095f7c54678c7dd0e8667e79f5df1a499860d3e42940897e260e5326cd43502070126fa3362f311c19ffad00bf0e72da375f0dcabcaeef710248105fdf08f868d811e0760d794b0018894f6dea8c66624762d1fb65776a981b2891be7027758ab75ab4a8fb16f96da510e749caba9cc201cfcc735717f285f6474e00b44e539d1993ea7a06c1212d78c02d180bd97ada975e44bdd35bf7657fdcf04e1a7aaa1b226f9bf62f4f25cf4fc02d6725df4ca12e85c6f65970baed5530fa5dc4acac0e460c2fe8d4b224121b682149949d9e1efa462c5fe0e54807a895ada314e63589bdd1684e2be8f38423ae53ac4bed2bbbbee5d8c9b62e4f9feddd8b14e30701a3ae52604bc4a86a8182ac3eca7182bc82cf1420179ea522c50c123fea55b424b290589d943f3583686ff6d20cf3867d107af219692ea2e93f91f143c90fb53546aab082a6a8cd7ddd7d70280f304a8620ffb217392b9e85d9507f23c9baf3582a9317948a602ba7413f8182d543a66502f597e578ec41a577f4d7bdca0308cf57d1ee9709ba7e809ebd8181c3e0cd0535e300e82bea3fca38f1c1e5c86108b5d053ed386a05fe8d313fb39ec844d6ee41402c4a726f7241516a1c98d305d2044bbef31877927d0c33a422c85de9d928341068f049a2c6ecc0e3c2f6de9cb5abe4b045bc9437af4907ad13c001d451c880374f97b2a8f59cce2ef2055f57965be864338506b077cf265e8d6de3bf102e9261f1a1bbaf8eac716cb1a2053ddff39e01c80387cea9241f80a76e6f27cd6967eec33afda115610d15a2cd7c053a63e9df9a1901a8de582c9e453b70158f9d04ba0e2c39488118344b808172ef42c6893efbe97bf693d2d19cd0e514ba356fde6562330677d5312a678df6b0cba8d3403ceaf6ce3b80a979b2109079075f86314c5b0f62228b34fc8422dd8df7270fffbdd959e084fe0a87ec4edfc93ba489715d2c6702e32fad1bb6b05b769454695e163687cfa1019edba711ee267347e295f945a3bf4357b55ba5d0ccd99860868911878339e01c08cd66a8aa64fb94b61c08fa33971d34791d2605496813a528c5fcc687b2607754c2d2ab3eb2774a9e75ec39260608c4dc423fa15f70830936293ed8e74e42faccdc360404c21cdb0d79620a262bcb963fa7d8895a6083c75ff6528552eae190e8f1117b90b06f3c01857d4a3111cee3154463e046b601f738f706dd04d954a0dac2973d732e4bd233d5b8e707ce6e1c4a51404502a5991101c75548f1cea8ef893a3f1f9629dd5d6f20182193bfd3509a436cc7c320584f6dac07989e5c89b29b838a8ca3e4e6ce53decb10201f17158b12189940f71f72e13127c03c189d926fc41e57b36e70eab86194478944d720bdeb0f1d241cfe7b7411c401f45c5e620f423e74b8ac2cb1ff529eb7e4fc026d212e156ebca36e7cfd0d1eabb7fbbbb56b54bc04c0ec8fb32b101cfe5a1d5dbc4e7aca87e3127f9e349d51e00406d489ed038ba81ea6ce8780a56c2d331c38af7a01cc712943e461e7422adeb3cea66d327e98950a4da6833e79590648e9817e634de743f29e3c67dcc97c65ca049586fb24a575b463d08bd3cb7d0081536ee97cfc8da888c220cd3b8abe263cafd69b79ddab78ad00d2cafd5bae0c6bf9abf9c557db522fe2273901f404556f5626d9d9c1fb15023a0a21a1b5188c07a3a3b538d301e2963cb7e78047ebc6ff5c01a55cbafab8145b278e4345220881cc0c787aa4224a6473c6144b7a582e97826bc737752b1f2052cba24dc910f17c71018285049682be16c025ebd9e4139484c91a3da2c10a9189bc87eab915b0bf839935d8e24fc80eb4967b87be07341a568977cf18224dae99eb4a2e3e24759fc3605702ae8d0274251ecd8774c6e3c93b91b9af46c7b0cb2ebc06e35864326e754d72fd7a67e3ba3fbbeda36f2432e1864c3b50a4d42a0e3f2cd5432ea9f61ee81c93b63ccdb6235cf02ed270a8d00913d44512ed02f48c56723ad7285425da31e7e584dc5a31a55edd96c5e29cbe386f0e2539e0ff62a42ce3540611abf1603783c3e5bc13303c98d36be6c583ec333e1d2fa9a253fe29ecabd0b941830cacebd6a21a3f660677810a8cc1f29bc13a4d289f72dc92b48f663322825a49e84242b1179876de4a845f623f94af1cbc8f4c0c0f4d2da8f5551b7598e0178ba6dca4c6fd77eac01ba887c71914113ac7539fbb182a6b70815c7a0937d4e202302e28c41623faa9c091eb36f9260726f669834a5cf1f359542c2b52c201fda6a24a514a5140f8622c1a0119055258059e8b5f10a617d6448f33e260b89c8e1125de2b8ba859823eea3e3c26b896c5939994b8a3748b5390cb63f96a76de6c2b417d7c63a095a4c86ae92203675f1e3ae8841aa2c02008456e36a46027d7dfd8622a6d51b67d890501fc171d034025d20e7297c51bcb821a34d7b91de055b971d56e7b8405194e235a7eedf444a99e9d6f33eb115c95c9bb87d11b8fcea128fd7ba0fac80c3b240be33c7ee9618a03427df0881d61906905a59660bc58005fbb48f7f5be38bc03a39c20a820e96cd83c25fc977baa8a4e7d176d1b5f83588a38fad293ad862434e296c697e1606ea1b77d0909de262ea29178c70b108860fa19359ccaeb8a516bd884581601e38438605c65f65324262fedaf5902fc34aaac46b131561910280a9e2d7bf10da68a75d8c5a40dfd121d05faba8023c34eeafabc367fb85afc86d6e5aabf42a883f9fc7a025608108da97e4749e088338b2cee8942734f118ce752325b01e0b3e381b35a4c152e34f05cf6c89f2709c3f47813a0b7114817c77c214426888547dbbb43889083525e30f8c1c7201b4359ba957ec0919df2ad1e727b1d16af01c508560b8c4eec0709ecaf6a38638b2663fa4b1a2b5fe544ab468b4c88d4b1aea7da5a6982c23a717e5fcbeaf6d236b8ad00cc6f4dd3a3a561c89d3fc27561d25e28542c33995f34c8a3926c1da2985887ad65ebc8a575ff3ca896a6003a2d3228a5988b24745256fbae6eb006d09129761e473741b97594a5afe179fd95de3c310c1c4e165b2b29b99e3183eeb6d2fbb28746599a137fa34d863fa7388efb2c8002c1d216ecf539902fce4fe8d5a41cc1baa7a9d6e6d1870f954c89b6583d99a804d9673564a8685d267d51f99b864f9af5d520521c39fa32af2b680da16f98a3aedc6b0ca7dd3d754c8c3757518d4cf852f676f9c849100d59e3ac38ebc74481bc358d3da11adc6aa529e28087b10df5856dbb5b9d29815842c19e519c973b3b51d05492bcf70e580820515830ad6c3bf37916172b301f8caea5072216520b63526b05800da59c59454ee196838303890448c3c2dcaff504127fafa8080fc8a3cb3edf46db09da0ca96aafc611570fec5af8d34e820ce4410b51323f56ea727e719de2560f5a1178e3c53bc11b109f5119673bda8f3b309af5b48a93f38c35493daf3ede8b79e98c202ea547ba1b1131f09f4e23a7595eb4283444aef20dc4e22dd44023b93a064b5c5df44e84602dd18939d48a16d504751dcb6f1e162425db4b30e28118723b6330874b6709ec59e0e6d05803b9597ee3c1c36041409cc4393e2bec1fd8dce9b9d94ab4efc0dfe3969222b392634a726a1edcc28703dd29f6b2fe1062e3ec416a1f144f8afa14eea29cc09e9699119111d8f0a76d89d8ef3e8f4756c799f6cbe3dc61f349279ed5370682d7e6adbf13feaf4b48002dd8748b85f4504f4d9dd9b0f1b2767a53d84b8493df2b1b7fe23d0dc88feac1d8405d7fb8f3525949c4dcb064a79502072dc32050dd8837df6735ef0a2901beeed06c09a17b9d189b9317f98c8e4869a7a72633ea7dc705e576e94c333616e94e6991bf6bacd0df5a673c34ef53f10619e0625c4576089780b18d1511ffdbb1fbfdb4ec0938841fb0d6017bcc28a3cffbab404ba951922d67deb9ff56911de8cad90c264dec7fd5ab473de6311e595ec152be20c89d929f29d2d1242f6c7ba8f90450a791850a1d92ddb459cde03aca12621b126e7ac2b7036ac3cc97c43c6ebdd88e2bd8e3c8757d44eeae2366deac813596a031af7edbefecffb3e519d9be74b6cc1fd1031276567fd1b39f94e821d4b06d4a519a3dc5649db7e27652bbd4edb6f25eff5ea750bc4e0ec2034f4e624ebd4bd1abf771ad1981457c8517fe368c16d3c84a776edb20166f73dc30de402cbb880af5f3738424355c0adb223fadcac345860b55e9af72ba4e419aafc0ca39154b5ed44594323e1c5fe2379e4e2021bcfc3c26723807e87248f332951fa722570ff6b36aaf262a2c7f42df423af824ec69c248f64d50a96900b3d2dfaee6a1956e1a02bf26684d713996593d29ee362df682b91b0dc4df244e92af680e74eaa59f88dda244f5f7a9ab6e465cf4f248eb9491e2d73df757d3418e86d967c4c297936955f0445436ef53be95a85bc47482f798fd673340024261ab96585a24f9592670508895362ce48ac21d637598ca99eb8ca1ccbf5a5df1e8df54a1eb95691dc4e4b18bf78fc3adf74249ab5ebdef6ac7ec3e4fd0b2c7948eed602fb1ad58062b359eae5182e79fca5ac49fa20e258a0b57cb8e401c4b85ce96d674d6ec5e9069fbd83d9a221d33b5949b7c26de77bb32dd13adadbb25cbfd7a4b53c061c806c54ce992f7f799f1f45d70dfa1bff37757cb8139b9cc5a1fbce076ffd1d1420f6eeef6834ea125eacb681b2481b8f0df3a6bb2b41e606f0e6f94bba912005f103980f0851fba34c983c3cec9082f62fe9b2116f4facc09c42b4617504d0535a31579fd281051d78531b8cba0ba42867269a623842b618c758192fc17902d6095513dac3d270956261b48b51f66915085721d25ca4d91adb95906d8a6a427ac8343729656f1325286dbd0385f8814dfe81009b98c40d1d42f2f2457b595c03646c45e90069300d009cfda531828831fd47324d7e9643cea0678b010dc188d7ec9212b28e3fdf5800ede065165fb6cb210c477ae0915fe2744ebea420a1c9a6f60c347bd406bf5ab52e3c63754380869ddaab50684c89e129b63a90349b5b1d9f8ccf0ac588e1391ea1e2ca64d20c57bd75189a9c3f7d4dc9f35c9b7324f38f7ae8731fa21da21fe2c228e4208805c80dfc7160688f884b4c1b8d22007b59b955635b5ae287aa58c8bc70c63d05836e9a544a942da8925052291d76c1e006c32f732618425fb8e62a307c252353d5d36c3991c1ee9801d29c141a86174a2705ba12e672f28f996b6e918b7355a14f84524079fd44f0c4d545b32ce08997e3a24d916d842beb9c0843d98aad34fda5bec8c5e0533a928950cc6354fa29c3c2e4454fc47b8670166984a39db68f369e2fe0fb271d182aea3b10cbb2fc95b4f708852063fc389f854ec3b4c325a18d6afb74360680a0f3001df896225a7e408f023a2688189f3e4a82b3e562c03e481444c0e0c0831c79f3995c5168def18974f0602f518fa0effe68fa723ca3dd2108c6ec0849e439bcff6a43bda16ca5acb3cd7145befbea8af0b3793c9f541943e56d78acf4ef9d255e682667bf8bda81fa46401e6d7e3c3b51e8c11a5b8a9153cb4f67f5db8e1a1f7d9e7aed7553deec169a57b306144ad90b70c67b25674500b2b50adff7843b0b153f9689ff1746964ca91160d06d0b6201e4e360ce44205d577db79e5d35fc5768e4a90638d39709f20e75cce27849c54ec0fef9f5b6890808e5c02628bfc0b72aff0081bd27e27fa4ed71a45bbd3ce0cb57d02284d15a80e5395a3ac3d47045d98b56e3a25ff088333e7716a231ef06e41783e3a9783d3bc0365a5d4cb7ffce462bdd78639fdb793bdf120b92d1ac061c67bbf43c36e1923b1c600f01ce48c920825f69b3f766bdcb96ec90dca6e14d7e3cea017371853b177926dba9f78538e6081307352076f37b61966763ef3dd22c6136e376c4859b6b8c8d59248c98aebb8a979d27f4090a19bc5948f4c8d9c6b16169070ca27f9f0d5a46ac31bea535302b84197426dbfe84e4821922864650b04c8aa433b6848eef3d2e21b609fb232c830a6bc742f96ec35a9df23e461a78fad06e663dba4f40a9cba911068ea5c751b411497dc552befd95ade3cd6b0258ff31463ec69c592544bb46ab5b19540717ea88750e361571f166496db424f5fa78cfdb7b6e88038108c3d966bc9593671c423db26649b616771a8048fbf7854a06b43f364914821c7b9bd36b2b7ab7ced1775477ba223703a917460d58b56ac6057b64edc7f059f930fff3290c20f4c339548f7d52b84c9cdbc19a0b1e00d959898c07abce18d798eba0f0c47b4292bd6b81836578dc3c77c0ec63ee5fc05c00a9e8b2d9c8cf0451955b54138524cb3446966948680e0f476b406dbf782087aab1d1571e61806e71836405eb574133bd2bc442c897016a63037200f75b9974667acb84778f4bdd9d9679412c706eea40c98ee8fa8f7e5aedb515c7945a7364c002acf0da4b93bba207274c02f153dc124434d943c46e2f9f47c848715172f44576e1c1415be956b10a91241f0409ccc6227a89419644d2a2e068a7491c9ccfb99816f4376f5ed3042f46dcc5e0cc001d90686f3a6ab92e23bce21b42358ca2a74d9d2fed3a2600da8107944afe5296f86d92fe39e8a1148226076ec140da8cb0e5159958cc3d20446d054399314e970f710a9a7c753fe43579e8b43940677c59b165b3b9bee92739c3b95d70c042e24848888965a1aa810bba4c6a273e22bdc94888ff6918c529a5b745256a6a9f4cda5829dff38216149b60197bbf8318f0d12cbd9082adf765c0ae2f488ccda3b7b5452f4b942a78e1251717c7d4ad2ae2726b4fcaeab5597a2f0e9140635086dc55a27675f522aac10e7c1c644e8f3bd45cbd9dbfad2317a85ab96f4107c3172aa32e2945641b302d1bc52710b2964aaf89f8dbf46eeda40e9a9b6c529191c508bc696994935feeaa977435777ca4c6946461be310fa8c2c1176e975988c8a37d4bc6542b40413ea3d5cbc07393baaa4b923ed0c527b08f8f24a056f1e7a83088b1831453d7f31b579c393b3770e25b7ca1f9d32cfc0de5e65e540819991d4b0b6b1ad8a29151f5881af348686575b3d24b3728c7ee96a8af15012d99869d6a48952cb358914cf1c8b057548d6ca6ae45aab995a633f6977ec2ace3b9f260f27009481f1a312c352a66fbcf32d9ef1e1b5a503ac3347372120a4ab1450cd47a00a908cd5a7096d22286e927c1bb18f127bea8cfb5eb8259a1a5f214093a41cb2e4eb3aed6105a2d5a92248147a58de38bbc556cfa82f30230fa31cbdffc7150d13bb31dc2bb53fd6cfe985acc455411f7ce217552d96eba177ad853833bf331ecb1c3d16cc7d7fefc1b706da9f39f89e4618dc6fc0919d878d5a8edfd5332aee9461f1709b6298a0569ac448015f85bb78f5d0d010004dcdce1810c263895c4af92c539424398e725f957b5d701eee8fd494e0792e8e5ba1fc9c0f0bbe4ab1c9472829408da6d7c2e1b479a8bfe53fdb47f4b2c7348b1764497fef792c2b6e7b22e93be546efe55f9c8cff36cce6c2ec3b00d22869fda8aa4ab99f545452a0009be0d93c9148e80405f4e461d4c7a893f31c6c21e08a5356fbf7c1832ac443fdd8f85ce1097785a03671285eb9341d84d18aba770b87d5b908825f0e5c07d11f3149f8d36189c9c230b61a463b2c4c4f534daa6e88d085b79e58de98b93c0109feed41a6aa9f94c5e28319a5db098fd472e4d4dd28a6827b55a2a49d9f95cd2b71f43b0efa5ecfadeaf319011a57555eea9a264764fa41b4479843f64a6bc98bfa25e28bdc24908513aa1e0d23491502dc294a0c741ebf6ebf24187edc9138907f3c0dbd3011ec4c2b888db719f8391fa1c4a1a13a5a711621d1733df1c71edd9d60975e3a74c90a755033eccb6977ade1492abc23d61d221c9d1c35eff6e4e854679560f7709662ca9c434e8dfd9832786ed1d490f80e3f28dfc82c0d5a4ff3eb1af2df7760f21a55a549c312de4dd5948052f1ed78c3001d610771585dcc935529696f65b60141284fc91e3333bb3694e7ad76e17ac0dcaac04fe1616b23dd4e25d448ff0227683d0553d2db29b6f4c6b761cfc6bc21971cac609cb217d95e3daba17476f03ee09349497745e7ed7746e8cc94db2d572ccaf916bde41a432966322e8f60ab373bcfe2fcc0b1a2530a80071f6365f1227583f39a664927d5a28b5f59f05a44aacab8f00f8f701999323a70c2f6512a99c5724a8c71530f51c1502b0feecad8309dbfc64866b097b42e3ca1e8c5ca90df9b0e8bde7e5f3e56024edbe3e5efc3d5ff15047c48488d8fb027c076bed8507709e39ed43afab80fd14472877e6031742b26013f5a42910c21c611e66ea884535723cd04ea22f114bd981752caccc5a3be826357f6b15811eba867d27c971fb1ce6eb631dc5b9235e1b0dac3806b43bf27164dfe4c4fda7f50ab7957427afb1530e78cb70fda31b8df396df81a34bb05187296958275cb1e7ec6a7113b3a726765420ad8f40984a207f7e4a12847753422a9475f335c1ee580cf23cf7293ce0cec3fecf23fb6a974345b8d96e78a489ea1ddbad025a9a010897558f1e5ada3eaa1badf3ca3e3e44bebfbbf79048c78cd651c6a129f85be2feab257f8a20e8ed80ce17632fce273cd88fda5200aa216e920b034cb30c48da3c8e609df9b58c436f77b84c95de5fa4f1857575fd17f75c7018fc5917c5e724f4f98f238bf83beb0ea1e6ece64c7a70f368d3570d727e9eac61c39bd67e17cdf6514013fec1a7d6ba48d8eb39c6475f1ea5bcbe2a4427ded2245cc42f8aad2c28480e31a2f96b236f1ba50c516e7cdbd50540210c022da81c785b4c0787c237c4252855d9633c004754f13085bc20f4e21625237dda8a0646afe37a04b4e11617e44f7e8b98e32aabde2f5f0808757fb3a318008022f4baabdca65ad181791efd6feb97131e344a16c0e6e4a715ad59a30bd99548fdc943030cf016f3c51646868acb5bc6306b0fb6c2acd107ce93023e809d29ac2595886cdd3aaac7f8ede06751601465a9e0bdcda33820c1c09ec5891b6aa19dfe3e0d8eb8896a009051eb953f897abe0a94c9b305393bf0145800ef6c6ec96a352770ad1eba627e8618d713ed7e501ecb70af6b272f230976501cd0cdaf74a1761d0f755b855d773ed82419ce3e9b5b63f24d690b2cb3b2eaf41423f0b477fc20a04f7d049ac6d144d9541dd3876a0f63541d8fde9842ee2673e68738409f76b15504fcb6525c3015eb7350939039c22aa5fbb284ad5d58c8168d2940475295a81e4a7e936fbe55f5e04425d86b9b742c5741c45e38b3580c3fc3c8def51c44ed40b83a0894f1d9e266aeb853cfc9925cf1f072d0650c9c49fefca6b3e8e6ec768062c06178f3cdf0dd0b16c9aa85e5750bf1c608a7a460f8119bde89a3a6a1d1fb02b2d560930cdfa0201fe0b2df1a8bdffaa9d7b8387da8531a528c0dcc238224d6512ec6e0bb90a642b267de54c447da58540ce97e7c8d2177410dc9cfe3e13d82f6b58f706a10d963f863375e97b55cfb5c9d6fb6e267ece074b4c6c7a24078ebd98474b4573d2835fdbf210de5f0c895a2f29d6919d5c67a1361652c307fa2038c267d85316c23a5c8430a0ff499c6265d450fd06157a84615f9bfe32dc7e65344ed50edb8419851b517f09b8fdb355405e467c80ce99871e2a2c2327275f091c55db21b6e6192adffa74c0050bb3cacaed120f94ac17bf2c42a0a70e971416068e1f0c3625f446bf7ac39ccdb5f15d59d89dd46877abbad8fc5d5b92c627ee4eab388d112ac6f8452e2b57a89509e45dcb1dc740cdfd427355d5eaf6e6ce7c213d6ff543848126ee0f5f223d7f12b11c7e9c7c425b4f008913e4c2fd498807a1f22911b7095593383a7f063dc1ac9df2cc3c4543c62c064884515c093a9f9aab0f215cd1cd8a5e800feb9fffccb354791380ddc155cd9e3b88be175713113406f2fab74d13977e426d5952ea00d77b838fd218ed5d62bbf837604419ecddb0fbd6965a357f158e1965c39f3d097a3979df3c122b3e36860a104581a438a531001ecf202aa2d3e735f40925d4d1b1ad1a02bb4a1dfbbfaf7aefebc88031f3b0df8f47854817eba5595de1599ba359720278c2539d9a682df99cd49841e07b5ef20b90bb46eccd5aa0dbc1c876389f2ec188d5889bb231375a99cfa78b355b28d882412d9ddddbd03fc0688070b071dcc3e758fea50a040f11b478142a15028d4e9718e40fdecdda9fbf95d878a19d162464450bf5131228aba7e1477f98ea37868a3a35ea2907956ccc3a8be4ff1baca50f1baa39ee6eba847f112f5acefa8876975d4af5280214e477d8a060c75ef7e060c350a50060c3f1618b27af73160c8fadefd0b18fe0a0c5bbd7b1518b6526088d371ba57c165b539b9b83ccac5c5e5f4a81aa8efc050c785d38e724181e1ecfcfbdafd07863abda3bd43d1d0e91bd49fd4b1a13343bf1e4335f8d5d027ff1bb231b55e9f52fa1666b4125563aa967ac1bcc07afdb99af5fa7325f6fa53954abd7afd796f0a17a28fe9034219a17c4e413688e642f4317d40282394cf2908634e43ebd5fbe98836d306a27934efa723da4c1b28673e63d42be7b305695afde18c389f2d48d3b4e628f44f26c24cfa271361a68dcb8446930903f5faf2529ebb1410daaad7e7ee6e5b1e9302d26b8591c91b18be300646563f05e4617a4c2d05115bd6843272ce49e3626be594d55a24328c449667332ddb6633ce725ca593935d7c6fbdb7de5befadf5666bb5b59bb59cb518890c896c3653c96633952cdf1e97eb8aa26b080cdf8b976a7aa9b679346adbd6b22a080ca67ac160aa9796617c31be185f8cefbd9f33ce19e78c73c6580f8dbba31e0d8fc6e8c964277b3a553a4fe366976ab52ed56aadb55a552e95abd6cd596b55c160aa5795d5958bfb91124f5e0d99125fa9d7b4433335da9a1a6d4a9692a546983e5fa69652351ea66a2a97cb82a9dadc415e38c80bc330be2f8c41175430d805552f7b3312952ce78c55b29c41175433d54c25c39f7b5cbac7a545adb34b8ba28bb6e86b3ea7a49bae9bb69bd65de655775577bb9b5db7bf4e72c927676364cfa7cea6e8e65b18c81a636a312f18198ceb05b69a5960da0f6544d6d8e9df985a0c8cacd3aff46555b5fe3e164b368ee3388ea2288aa2f8a2b384d1596a0dba2065f4b37496285e50a0a874a2c8b7ded9ebd6559ea2bb8c5fed7ba16428d70966e9cba536de29a25c27187d512058d048f41ac7711c476ebd992776e3aeedd7ace6cd3afd942776fa2eddd8e97fbbb65f352617157f5ea95aaa96aaa56a33159ce99c8c736d303dabe2c87d9c6b83e9d94824339ad15cafd7ebf54ad14d145d9cb511d75019d72c38c5f9f38205b9543295aca6fbe75c840e0459742e58b454ad56a5b3c5a20341162c6a6a4468e142e5c245a5d3854cc72f199533fc92cd87d5604cb0e982f9c05c7afc8858b20f57ae9ad59015ac85c7421d6201db5d7422783444f058a8a30b8fc6ec16d6d9b4ec6a5c8d23d81146a8748eb0625d57ce8e2fc4e9d7b5825519382bd8381211c9647dd5424597315d469411e5cd8e6f7e2823766a5f770bd36566e10f9cb5156bad8dbe207eacd870821f59be207c29f886f02581328490218030049128163667b48a958eb67675f49c18be09e6c49013c3276f962448920c2519bb8c258125c9210990243f5dc692f824d9818409090dc91192222444900801420204890f243d427d84e908ed085297b12348ba7c21741ec48ee02087233338f23a72c311121ce961648b91252348468e8c14191932321a81198181911c88f8f0030a686a5ea0f053f302051586b081a62636842b9624e94709624388780543b8ba6cca49927af82591d2e77f3a09942ecb443eb4911f459c284188224b14492ac2040745882872c4888f15ac193d6509605143c37a1e608c7191167c1ccdb358092862c3de282e22c3d641be2b1857b90960e18c3196d13ac61863fc04d7053000532c53a229cde31256f09500e50b592cd6b78ad0e08a1ec23c8d34eba06a1ad8fd82ab02217e14c58a68d019d3ac73b5bad3b956ad350d426bad73475b3d4c1930d3867ed8fac029e3cbff75d209005df7de95a334cd19e39c313ef5d03cde77bcc74787c7fb1e9aa7dbb3f378ce3e9a67bfc77b7ae8f06c2b4770d6fad23ddeb3437d6ffff6b8e4d93013773d6d7a681e6f9329cc57d1d9d24fff73de95af7aaa7bdd7f57b94baffceb1b9fdef77d1feafbbeef3b79dd49631eb2c03e3dcff33acff33c6f73dda9825af2785fb509412e6fba3bd9af3c64ddd87af8014e278cf95cdebce01855a71c07ce06c2b6f6b6c0657a69d4b827ecd590b225652b74e9974a7953bd156adc04f4f0e0713d1ad85b81db5dc7715b017bdbbaeff3bcefd35bffde1d97f3fdddf5ab805377f25ab8987bfc9d4763770ef4bae9c9cda3415bfa3bb75d69b9dc765054947f6fe9ad9039d0fb5c233fc7595beff56e785cce35f4738fbd1bbaeb6e689d71ce398333dce7d7d1f7f5308b8573a618638ca7d427ae86f79cbee1d5f040495bdce6b8cf9cde397395cb9ca79fb35e0ddc82e491decc025cbeabf5b65be779a7cee3bacc5b402d407bdfd79d58acd3f775a86df33cafc6f69e77e2bcefba0da4b1f5ee32af614373bc05d4f7a1740dd9b9ffb8277af73368ee505bf71cf799db76d7655e837b306faeeb36dfb44b9131960a900f53f141a547f84d619a429b82d4656c0a922945537a40639a120446a9c9a092c9b9d693593f5594a8e2445565499558951e54a141151caa9ca0ca0c557a9494948a50fa4129480907251b94429084134920a148e2884b124249b8200913243143520d87da0a665470011c822001b26487d00c1e0f44628841090e34e0d0030c3c1487e2cc2593cef0fe70ee8748eeccff3afdeecf042dfdeaeae197f3e39b1f7eaf265a12ad098d085a8c3644eb8156833e7fe71d748c06031a0e7dd25240b3a1c66835f44902d9cc33bdde7b6df0e1d003053d455f0cbe245f28c71ebef02b41e90be538038ff74a89726da689a087ad2294c6561847e820861f5aa0831d48438c8c44d0831fb4f4b002227d03d9665fdbffec0d7ad0ada52d2925a8abe8322685e8886cd217add5d14ef1ca19e6e10b7178e0a116e5288a5197b128443e441912248aad518eb0471cd95b54896c47e4c342ee0bc2ef881f9d8ff039a2a7cb18d2121215a459a7916448435f3502bb68ed7169ce75db0ff1d40d8ddf0b4c0c4b06850b36d3ad563d2e1a0b03e38ae954c488e28a98152b2a9d2b5c34dd9c734e2a036546335a8dbec6711c4751144551ac30d745425d2e97cb758494b4d4d469052d4c832f7cad288aa258290c0683c1a6cbe572b9562a5688a39822451d5261352b5654d87f1deb98a2c27ef44b2fbdf4d24b2fb5d4524b2db5e3388ee3288aa2288a750693c1603098d18c56abb3711cc75114455184c1603098eac71aaf3351858a152bfe39afb55a9ba9b31afaac315117f5f919c7711cc75114455114eb6c4681288c06d191beade2388ee3388aa2288a629dd5597d2e8e2b56fc10ff5f2fce45107cbd64c412f4394e22d9349a89a35813455114e9388ee3388ea2288a22afddd7686b2cec901d6b5ad85104196dd198718aaf075419b656ab8de3388ee3d8711ad3591bc7711cc12ea7862fa7868f73bb646b20e872b160616b35352ed78bad3da0cab82f4a29bdaf97ad4db1d5fa67b16c4dff7c2f16d07c7dacbf2f5bd3180cbf8fc5026bb6d6e9a3eeebc22e2cd3f0aa3638dfd1f064029c2ae36afd7d2cd64b183420082be71255d24e41177688f8f083f6e9618723ce59a3a97981428f9a1728a840eba1a979813424262569478ce692e2849c49411ad265534c4a524cca9498942831293f312962973129ae1ed658142db128491f7775b5d9a84dce5ae9c518c73e273e482e30aa411010dff8851f95cf494ccac9757a3ba574daf47defe63921b8f5f6fa1ee855f2991624cfb5af81fb2ed6e5b22f3bedf7ca1ec385155da3e89ad5750c4c00fab6fb259cb65ab0d3be3bc59dda4e6d9d7c84beedd5f246fa8084ce89d0b99ace599005d8372a9c5d0aa16febd55ae99c734e693bbdd129356e3ad2c2447644e588c9d110474338fac191d0110d421612dfd1088e9638a272c4e46888a3211cfde048e888063d47428e801c95e068044b7a58025b92c3121a96c4b064879226254b4bae2c49fabccfe33dfb7b76a83f7938a53c95afe4cd7c8ff7f468f1bcc813e6f7d089e1a9bef1e712067dcc59c816fd8ebb9032a40d15c0bfeceedc81e9f2378bb636df7834cfcedde69967eb6e73ccb3b76ef3cbb3b96e73cbb377b779e5d95deeb8d3ccc7e3759db7e99c511fab722b8d57c85ff989db614683376cc7a00bbb5760ee5d811a73056bc3673078c3f60cbad02fc0f2b14186aeaf972dd64394fc28f9a1048893d109cc89902e634e80382181131f273d5dc69a2c35516a8254045213a326444d829a00e5d0e486263fba8c3169d2a3091326494c8c50c2c4481445d1054b7a58025b9243114b4b54b0c4044b685812c3921d4a9a942c2999d2654c8910254d94182921524284850f7e1044118b2120cc3004263b60b20313a02e634c7e989480890894f430e171e4c491969c588e109452ba87e0b1c308871f42441000a2c7d08e23af2138dc40a50c514ae91320c810841cf0d8e1c40e1e07a02089198208820d9c08f17e6817050812c902b20e124a29a51d0d6c20eb94529a16cb0695453ca1345604149a9a227c5044500f5f0461cfdf74b3945316ad7fda26cf15f78df2faa69452d93addfe83fc4f2201ad780110120f17175094508900854a8b9e73ce99082845f4040441c522e804ce80e32ee8fe866d05141a38155062c0299a38d1d4f6ccd10ac5132054324f7c60f59c73ce99879c737ec2829c73ceb327297842c3ea09084e2a2b5f0acac98588ee1382431931b49d8c98018c67c40d2f9d1121486d261407651bc2d33fa0f26c071b9ec1e0e5ce54d0d9598f4c7592c472e2c473428466b1beb5e4a8c77419434a01920d3dc4692dc10042ea8f5504502fa1cb981153eac327dc610e63f936fa3fc638ffa5aaaff8b7ed61970ca6c0f00bbf0c861f7eab85a3caa17343f939743a153f7a6500d2370ae7081f3123212860645ee6e5673ee62d8dc1fa181cfb4fbf79ea517c9bdf35f5ee594931228e9a9654bfa51070fa5d633e81e2a18ed6dfc762fdb75a381d3593fa7e7bd4cfa89b7f2f9f002f9ffacdbb97de01667ff919b4db8f3ad940fdb6bbdded6e77bbeb66be3f81e14c8df944dfa7dfc070e60369cc27fa06431b7dfbd0463fbdec36faf6752f7fe2e1de20025ebe0371bc7c0ac4c1fa2e874edf600e1d9947b13a960cccdfefc0702626060606a6fbddc1eceff6074c3e5998b2d4b2ccb2186521cae2032cb22c3e6419c262080833c4aef880cd1df48007392e2c66451af20faa948ba5228a35cb90a5207dfe0274b48ec634e092169a9a165dc69690f4930966435e40ff9b4200e1a1e3e109fadfac214706830725ec20b6140b62f6b924842e074b433d7c5153c19ea154cea982b6b6e29cb39625b1871f0c967a0c2de1845e425c424acf5dc69698992047862fd45de6c8f0c9a760f873d2cdd2991b95015408fb308cec158d21011d7a65e8047d746f3aa461ddce39a794734a897f06ad31f286be042acc7ee6ba4b8f85ca43b715cc5161fdbe042aac5b10d4417f4e0ebea9c3f6319dfe06823175dcbbfea64db4e95ecab4559fead3eb17151515191911191911252525253131d198986844881021424414444414347d649c319e3eb601b4553fe38c33c69676d6e69b71deeed6e96ddf6d31b7bdeb715d87ba288b8b8a5cae9151af44140805427f281005a23f49494c4c3426261a11224444414444413ea68fe9337fe6cff4a12ddb80a35e7904186031c71c73cc33cf7adbb8dd7927d4e7a2ea5229d5eae5e28b5958459722c55dd1a9f84e850a7c2d0a8f85fae245af9806a7d0b92065a2addaea15a4946708f29f6c4955c458f1f571e40efe7ac2bd39387fc72ae30410bbaacdfd18d7881e9131ee12d9ba6f0238e2f09bc3ef5d22635c2831eeacca55ba49dca44be54e913bfcef5f24e40ef8f72f4deeb0f8fb578adcf9bf7fa3dc23e44e0917ca7d728db833b9f30207e7bdbf351a009cbfbf71387661170b90cb7ccdaa850b1136ed5e70171246b08151c2cd73fd82bb9030824d8b4b79d3bd8b9c1721e75bd4e43c8b7ff09f3fa8430ec8c2e1399c556deee3ac5001a3e9e33e88a6bb6fcba09849b1e2052626a55ab96871ef4602dd985cfdd2fc348f39cdd79a5a57d4afbc82f56913957183aa0d53d8ea75ac36f7eb11d9ba29a0b093e2ebebb1ca38d5aacd7d7d44c63851912d198d71a2d11b546568a36a739fc58360a8c1e760f8f17f3064fdaf00c35ff12ac0b0a5e26b6ed04681ef2ad2e67e0a7c4b9136f74f54648c0d45b6eedf3fd1688c3da3ad2a72e7c5dfdf4a726784bfbf93903b24fcfd9d24776cfefea622775a7f7f4f913b2dfefe4642ee88f0f7374deeb8f8fb5b8adca9f9fb3bca3e42ee98f0f73792dc39e1ef6f2872e7e6efef2772a784bfbf8d903b30fefe9ec91d9cbf28fce9a554c107870785f77ed7680050f8fbfb54bbdba9365d70296f665e042ee50d8a6f21f32d1b2ee50deb4980e9f74788f9172c7a0297f206e64de052debc7c0e97f266f5351c876ff2e63e0c2ee58dea4be052dea4fe864b79e3f2db762fb8943724a4f023a4f036ad14de45cd8bc02ff0f59a6fc12fc0ea35a00e2980a8ef65640af7537c0a9e7b0afcab36f751e037c51bdd6701861a04c38f8321ebc1f05780614b8551bf8f62cf36b1df97183cc1288c177cfb258d517752fcfd14a0943734331c050f532c1ec36178e89dfafd150f515cbf9fe2e1eef75d78d8ad0853f4fb271eae3c1ec2f470cfc28de3e16948bfbf71940b06ed9866f084103210527294c3031f3fb072240a16257ec82c59a9599959915929b232a44f7b27cea156a248cfb0018490267240d302b4021df064a954244b0d525c576a00044f06ea39e7bc659c73ce3de8686306eb5508b112c44a0aacd4608547cd891a961a95da935a113524ba26ab09a1e6839a0f35a18b3136f225fdc018e3281f135f28654fbed79794b49494d48373c3c7e99c139cb9c1596be54baf5febcf7ea3be9c13fcfaed2cda9a21c0ccf32ec3dbe5d7af60d8a24b30e36baba653e6ed6491b6ac09717a37e7fc3a2bfd9da303ed289d200ba4593d8c24589272a7ba923bd65e9cf5c67905d8db66eb948aa7fcc93b2bdf7c4cadbdf96b687b69d4d0b4552dd8ddfa32b235730659f266aec06d308f4d737b6f1ba7009d6a537f06b7b9ec8fd585dfc2576deab3aacddcb8e9d1d85d7ef246cb1bedadb0a7a700af055d6d66cedde6d1a8e04cfe308794751cf5ad9637372a58df8252ce3612ec9c3a05a8cbd8949f9ed3650c8957975a26d1d6d131ac53989e9f7bcec2a0f2cd59a441a5cf7e4beee4af3f4169005c6d8ba8d72029d3516b36ed249f61213f7e0cd36f51fd5c8966542ae7133dcce0276feacfb0807ba86758b89f3f833830a875d81b9455723a7cf3f7ac384d3efbf731c618638c31c618633c2f2869134b6358e0beb4fffbe5f4748fe7d941ffa6db5a1878f6ed3aae5d2ed70e9e9d3b3983c77b58bb67e8f8f6b8a5369b7d2927bd27fdb6ef1a2aa3478e3bcca701f0d13c5e0c4f63fcd318ff3406a5316abca77d76ed4d6ed3c1dbf4cfce79556b3e73a35b69337f73f978672dd77c6ed4eeba096adb719d3a6300dbb76d4e7b5c076f18ebcc9dc20f701c9ac2fc8e6f5c851936aa8d75750da6b20a27062444247c20e183a48f9400a2440d5dc6ac10e9e155c28795279288240575194b024a5241d28fa41e2a4c5468548ea814512142450850170c75f49b2dcd2ad95aa8c32a556b6b56a9564bab56c98609457cd32a4dd7a51b067b6f1360f870e0bfbdc6e0ea325dca7c90faa65d4763ccfa5fa54232c789af86183061c98739d90e1f32d728340a8d42a3d01d85ee9db0a09113b25db767508e4e68c282264c68ac4d98d07883264c68ac4d58b53f83d6f7f8c6a1ad6ac2922fc43141c9577f06c5e9f5bedc5876d2f4fcde2a83b5571c1a637fd5dafbf0ebda66bef7e51d23839573f7f3d62f572d602d60fb28340a8d42a3d02824dba817e4f49bdf7bbaa7d369efbd4ff74f9b8e54e8fbbea7411f2dfabe09a34174e8fbe8101defd739c130c55de6fd89424d1425d251212a44855034c37c90f411ba94f900d57defbe7b9fbebe40fbcdbfefddf7f709a49deb2aed400656ab70a3563fe769bfe78133ea69ff0b740556a0f6d57fa0e3382160ced47499df444d6f862ee8e8a7ef3ed4e95405ead4fc50a7f7be7ec7add284b14109867d7ed61283635ebe4d8ac196869b28d3d24bc576096319f321c6388603a009e6f1bfe4dcea39dbdcc53cf729629e26e667621e45cccbc4c480210c9843a7bfe88fe56d2eaf3a18ba99a00793c5ff02dd39f7a0f5187bc0ba095dca78346550470764fd0993e08c9a2b7e9baf474347d7d382b388120dd1b1e63c677d9bdfd6af40dd2f5fee17f6de9c058026acf787393aead5c091c1706e2f57ef9d56997aafd2ddf3fe859ff2f7f9fb5c7ee5f2a14ee0a64a71205e75af79a8f95fa0bdd65a41aca303965679ed78663dc15c6b7d61f5fa95fb98af0ff3abd4cb2a63e6bf3fd1705967b8ac325c561b1697d526866b4d552e60c802c37fd0c3e9150c712807e6d0e975b35fad9255b24ae30bcd3af048e23124abae98c790eea24b190f1fbd49d643f4e9e8809eb017260ed9a5bd2f2d1df50a5ab2684bead75546ea35187a5f5f76bf3d75497d3efd46bde6934847bda4dfabb8a4361fea046a50720d86393ec55d3818e2af58859eaf03c31cf8371c1cf882159a7f637ec66007ae5014fb00ff4ce3d456fdcaaa5fd53ac6dcb6df36bd7dde1e635bbb5ac72a69aeb7af7f37ba6ddbf6db6fb44b9b3ae9de7befe42c4d4a5ba331f2cef64ba97e579799d4e1dcadee5d8138b8efeebdf7de7bbbee5eae63e5d8396e2259fb14a07473dcb4352ee76e5e978ea67c3fd3b7b4a58eb34a1300f4345fa8e8a53413764c202edb24db6469dcdb24ce2e71dcdf7cf7d30eec401c1c0d85d90ba31a194db8d2a936f633c7851c972f7dee7e56f11027c5c3168a872c6e027196a6f3853a3a9abbfcf46a6c1d571bfb2e382830c4398161abdb0e0c591cc7711cc7b9ece70ca07f835669c270f91974bb64ee6dcd85cfdfb8eca893d769d4c9eb74900de47bbb8cfe5020454344860809629570f5a1328aa4a7692989221d59250ad8b7386fadace974eefe8cb62ef713e8febdb4a7a9df6e02cd6d95260038ab6495e6ac387dea741cfaf1eb585b2dada6b355aab97841ad775dc320ebad2e65300075aa599dd374e4b4bedccbfa097177731cb8b9ee13129ab09a906d810c044d321014d5642e981794739e33a8ca78f9fc274d833415a263eda4f589cfa7ffc257d4067fe63828d0d6d63a6b39f36f5bd69b0ae59c7546e9bc27ff8e653db21e570b77cc55a02d8c5fc565b571c93468dcf66fe9515be3f4f9b59e321d451fe8f937a541f9f7903ee98d57a076adab0c95d0d3211ae3f4aba13e9f0e994154c6cb4f135c5f683bb6baeb709729a5f967d41cead3eb900ef5509f10b04f1fd251a35e7f1b1dbbfe6f7e200efaf9db2c95f1f21b4585f43f9df5e74fe14da987f2bef7b4468138b83f759a05ee4f20159a30bc4779dfe74f71ad3f4c7da636a8df2abe3d190c9ae392e3b7a7f86cba1d95ff947fe70d509feec273c72575356920c567addb8eca483dffce7fa9d0048006430e742a3461e4f7787e2af479e6e8f4cb1c5de7402d4485b047618cec7dc28e1376d4d75ace9c27c598d67babb5d6de5a2fa6bd879ac6fc9ca66f3eaf215b38f246524a2365f4dc17109d52998c39b144a7afc20c225e8f3921a4d35f809c2b8f4aa75e11ad5c466142084c1061e2064cecc0840b98b88109510b93169a96d976d4270d5a88b40ccd0084142d454d4d4d475dc69a8a9a7ad014d434a4cb585390a615f4a61fd336f534c1749ba0194d4c5487baa00c745d10ea267e34e1ea32c6448d89284c2c61c2c584912d5bb628b1454a13405b9c6c21624b912d416c19dab2832d38d822a4cbd816205b46b0c5a7899ea6271430011b44a3444b4d1c872bb22b4474ef1c2d395ab40cd102d3f2d202448b0f2d3e4c4c4c4b4c484c33261953111311a6202620a6204c2f223efc802509cb0c0b11ce12240b902e63597c64e9c1d2a4c495a02b43ba8c5d0972a5051d08eae4759bdb74c6d73a8105075872c0f2ea328645c4e2034bcf95a52b49578eb8326312039f22a8b42db637a9538806000020404000b317000020180ec6812cc86118ccc3221f14800d5b983a56463611cb64016912c3400ae3204a19651030c61830668468a42a00609240eeeba79531b77ceca63ebca7720d8e48e86ea608df8b9dbbab33e82c8595d19036acf08ab1d5a1a58d6868f97843b4b7ca9857e4e796e873b8c2a90946fde0707ffa00d83f9ec3c02162ddccda0d4b5e67aab1f0638550319c1eba12d144d47f516a99f4f927c7b70a2ae01d40f7a55e56336f0f3010fdc87e6630e67a87e4eaf3a0dba602c9affbdd1166b1f477c8d0d866ecc6f504dc282e533c427aedf89de7a522f8658fe36f059df68469568aead00ee06ca148aa63f3e398ff8983d018cccd7657c0c965277f4cb11b098a2254dfcbb1ff1aee41e9545f545f0988c75dd106d5ffe64fe6bd4e9a64e1a62d9f7f2e2ecf70feeaf706189d1bdf4c662fe1cbf245bff93418f50e88a4fa1c46f13c20031cba0cee94ae46396755bae846dae6d7a66d738aff5e38fe9c3280983ccd3848a4bbe115b42115d7747e30f5f569df57271e728ea406bc75f055ca6f797a46f16f68ec3e1101a7aefe0a71630f03a009da663f2ee5458d8b304213e70738f980d8256e86115c87772552186b6abcd68e699a62c4047305de1c5e1d84840d52ef96e27b84ae7d88fd87c8848f709fb3305229810ecd234c8171a28f04b5077f8e905c87478199e5d5d87ec63f3baa842799ec808b20c193e360d0cf6f2f11f7d6a50fe1330e6009654799213b7537db5738baed8f5fed4d936124fbd876a6b18f54bd93fa03df22dd43c88270924061585411d90d4022e077f1546569ca7828c929ebefb0480b3957b10fab28981c6ea9932c605517a6c70a46022a22e4b90e5b28710ab5fd06b5de48755ae644f9d80616a34c63210a3f09ca0b4e76f999800617abb99df05163fa10af168a149d0e0e084286aef54c7c85f59cb5f9b3f2911796d1c1e38eb62e0b3448e79ff1d50b49e618ddff3fc7686ef052d2a310669f1a607b9d3f310235d801467c97e41d642f3f297e0078980f9b53abfc342251acd4dd10d2e6351a2e449ba03a4aee36b92a34801c34b280cf63774e54e5765a397adf6b436f83b4565df46fd68ce11fe09511066b49a0fe17e42c025ce2b080ed23b8bbeabfe7debf5a4c307e18c24c9f1cf0fd2b6cf943e5cb79c7ca628447ca490d51f74a86591a84c2ebd7c4ad74a2513e8cd1d4754ff87c10a45f5f7ded65a93a24ddbf0e789493046eb15d4acf0e9547f8ca3289be8974284ea6174d88adf4ed030da501c048a64df0164582dd90204f17ca00af400386ce86c33a48250e20d0809086f2ffcf2036626136392d324b132f334d151241a697c615dd835c9ff9ca9aa6bc0e72c440722cc8a2f93b68e2e0327c81b3c519490385eb05fb1eaffa9408b6a5248083feabcf038b780c5e4678edb7ec102666026308e8bb11ca9d492ce55864ecba30dfe4e01068a2dd996eec52262182a5ef1a9e4197f5190ac7a6856fcda41993b86de35fc54bec551783bff6a01dd39379bb8eb6289c046449a1bf3f5a96d8f5c682e64fd70db4fc10ac01cf680e41ed9e1e4dd439add77841c7a3c719bd5c5544dce88ed05007bdfdaea1b3c1a027f254933e4eb1e4ed33e8443268673c555a355004bde444c697df92eb1e2c06f7f848110bd8a4c186ff5447c40922fa9da47e2487d1cf7621a9aa21e1bfc02358e7c2e8d276763479a7d7c6e129d7d0eb17c5f9711c8e0f852a88ee89c9d1f4428db096ba07a48d7a2d71d9e3107054201a7302fe215baa83462cebbf86caa7a7a87c0a2a3d47708c1d979fa8d7c9a76f27a6b8cd63c9db5b0d3069ccec7baa761df0f375ee3abdc4c5562baa3830bd07557eb369dcbe1374dbab69ae51699aa4fd5c1d1529fed61c450379089a3501f6a3aed7509e05ac4c6da63ac0795bcd9e0fda8bf7d9a3f82074bbf02f52c8cd1442b223414180c2fa56a2f5ceda77da41a3f14349194175ba9bbb9b93628aec0029c433689629e89337ea9e738e1780af814669f62c723c6815e903d9919ddd48b650777fdfe5ba260edfa1c67d4149f0f233c66a5e6ee50e77c59a2f394dc66d5247acfe199075f5ca33f9fd5f2e4bda1f5697927e5ef3b97000af16b0314acb3b38567761cc5f51efea8cc35322b8a0fb8f0f69725c2779440ccee0bd0d56173a5145aecbea31217a5db4aba5039951e945af520aa10cc5af2e2706bc7ccb6570a4e307c2eeed9f59313b103454d993ab2955568749944f9e2ebccb862bd8b4d2d538c1bf596783a5530f0c25472611b348562dbe8ef541a0ef3781beb5332c37575fee830c51b0da9ff2bcbae0ea2e34513be844cfd921930f4cfbd9497d4a1650ddf3e33adb127eb59795c2a2f89a690757ccaff33f219bce64249bbc5d850396059c9476d972591482f7d5b3170a4dd6790372f83203424b6e3c808889822108b542caa2dab20d135f0c8f76c7cf107ad0cbccec6fcc92690fa4f987c4f670b65276e5ff74a95804c13cf2ac431225a4eceac8f111e373548ff3ef16eeb9fa139eec5ad71e2d1942afaf072eef6c30d2c9c7fc9e0037bdea225037f66a6d0e2554411fe2c8e00f926a692aaeae687a48c2925de7b525a89501f7728858641dfd3b36de03ab82ee2bd48e3682556dde0b3085440dbf156e2121d35c278c2fbb0eef34858a29e675cd71c0968b5ab8a9ea7df2f05ce863f96e86993329dbecc1bc696b75725cf17cd310c90e4618c6285cb04d7b78f64b0f4ad378c226e4be4c65da5e59a8e1087c6f5c08a0eb8a5e6086a7688db9173820b00bffae764043c2a15a8e810edf716d7e01581e39979e51b4bfab38273fe82278febc16f7d196678c90d0d4a5a3edb719306b1d53a5b5e87656051515e13177264318eef1033e932df9f7ca9bd5bbafa33e6ef3880f495c1e15826a3eab08610ebe59654b6a3e622249518618e6dfb73829f0140bd9d731ac42cc92dae300ff77523796712966cd28a337eecf0c84f8e2f3d9b40fcaefe91908e5d8feef1c6571aebe3af37038fd37f5fffed6e4016d70fedff78875f3fb9ef4039832f49e68cee5f5f74fc3f6e336f969b628c4909a02a273d93a528e143cc599bace0bf7febb9abe2351868f39b4b7e096707db6aef9b474504c74de29943a4b603b4e00e7db50c026d4f71285f5769a31ace3e642a602e11806d3011c6cceffdeff0400ff674de09ecf7654fd673120691f0c57ce23243125191fbca39b06ec7c7407652781d7c7794c735cc246196b3b2d146d1bb9bf8fbd634a532ca4eb1950322a340c880b3a17e77a87ba342099f7335f8ba4e82a56661891938710d3a4985109f329d64a7a765603fb6ffa48b13122619bcdb3950682022a106cc79d2b2ab25a6982983b538c9771628d4f79c3e27475c49610a587f1937a70ce1ca3d1955c9d0d16912bf93b93e918b9df780c1fb3c81b5f367b52a613d127f0aa3f721687e51ee78fe9d25c2c9730f4c0a481c150ebf87e78bb85fa77519bdff70ca4d487fcda0460d21ccdd377ab0fc859e2df4ff448ade4dfdb82f43e71551ee4eb8b55a903981e470b57a4c2c185ea24aa17e4feeefc85efdec75077480ed4e68fe962d0d6a14cb4d9d331fbef2c00fe95d54c8dad37a136ed340d2cff7d19b6c8ccb80f6cb6c04c725dd7f7d18810a4fe3bfc4533c17bd3b717cce10d95464d11ed5c48acc5c38e68f912d82fbfddf2b4b74215af85449e3f86a97f14f0b9ee5925e8133807766ab3af2521ffc39a8915306a0881d1553b24fcaa0c6873f0d19b583a08d2e14008ce97fc56387b2f6374c4adc24e4e37b2ac706cbf3c0eec7268149e762106c03fd1fdfcbf9f872efe022f0a4c00283a479dff88a2e129248545fb3308978c4c1e8f712d1a54a32814e19ebd21f370b0dff154e93604d114683d3d91a55c07e81152b0efb97354d9ab5aaf61e301b86915880e5f80b9f3493f834a23ad1a2d7572eedece8b7791191b4ee90a8d81f7b9c7b2aa05db268761bfeaed006a4c6fc00d18bf44ae49c4705b99b39d8210c1b53a68ea58c50bd2810b8cbcaf86070cb006940e40800cbb27a51557e3cf959cd59032025ac70083e6e0a6436c2acfb0c82b7d6b69994dc902f56e1ebc7769a5a66c1d27521d90320ac494e80c5f72183d7753c321d139badfcde41a49412e6290886e851ded0b3b921d9272d469de2665703113726646faeea003377ad633f8f92ef85c4508b33de798def74e982af55fc0f7e21adec3272d9753b7f5dcfb196b84f25ce85bb773171a729a09782deda58ee7cd90080b26ab93c42770640b9bd173994f495376eef3f72e4c252751557f7518a1386d66694db24976da0c7048200ae92bc3cf462d8bbcdbaffd5a6104bc8a116a5127f17df1b4990a67fb7fad90e86b1f9ee02b864a6ed59e589483ee958f7ca8a9bbe260ce6f28b3e8a28208a5b8eb60aea8e47682ab518bc60039dff236f9606099916d7df78bcd106097041f912fe09ad100019b1b7f0be6b1dd952f867d9766423b0a46a6ebb83807623480dc1c1d083df4993aba8c8739f950bd00df9ad0a80e4769f4a36b00481e5d3b8d2f753069ca56a5ba776140bd5bc8924a9ccf59647c61060400141a904c62af7f2026e8825658b97685db347fd94e6627587313cbd7eef46621ce0fcca3d3b48ebed272bcfc3ed05a50e8ff523799fd3bb4592a60051c4bf1ca22d80cf89d8522ac0d330c084e0023d0b5e8bd0addf78d47a0517adb7742c74ea5d529194427bf030fdbd214032badd3f92a760937fc8635a91aa540191f0c996fa00b29c0e0d3039f00562073668c403f7d993367ebb46750ca4447a36f18d4d5a739a4e22fd2e4fcf2b72f85d3aebaf998abec3a33f2db5a0ef197d8c64eaa87e56ba1a60fd1a12276b9338ff2043b1d6be24df2f4b72fe0c840beabae2bd22d80700985eaf73361fb2237741bcd819c301171ed89375ae3585cb2e40cbb5f7b49b5bbac0ce3773995f7f6e4293480b88d4ab5013e12073d3b87fb6f7210d44438d495ae19d8990914ea1a4ba49449cbb3e88abf0c594bebf23099c50ce0a9f74566121056043bd38103a75b35e03b926dc5b1d5043986437b9e33cb2bf96c11dd090a2b85f3a44856f0fce65f2abed64523cd2a74e9c5835ec3b97a5f240f9d77594d95d7a8b9dc95e0e31422e832a033e4f40d705e1ec413f452358d68ad11a3be5cac8b6abb2f2954fabee855176088c7898db28d758ae9f361431b59a7da067e40078d62c805694474e47cd9fac23e227e3b4df7a256de2b88259e338b3102c921a68be8b83d9de6f0a6884aed8d38d335233f3eb544a1c1c310e6e13892e02caa936d381d71ed6fceec954aa7b931795b5205fa047c73ccfc772101c10befde3ca17811d62e4c9c98be59e499f725cd887385fa85d1c59116546c3106710e9a259b8acb3d1eace1b55c084758e08621225fa66ba2d274850db46f65ae3e045972e08c13077d0ee2bce19c233c4cc54faa8eec7f5ce82c807a3b0744b0e66455ec255f22c56797ec3dc292456e0a1f3e460e6a347da9a4272370ae303a4f99c73df5b028a225c1c9bc4c31de9c007504ef27bc794b15834e1139e2e4dd9ca2e202cc9f4068c9b5a5bc9b9bf37e4d1ef3ab846abab239c2ee35846e50cafe6d864235ecdf7730f6c84f129a42b13da5f92cc9ddeff33565bef76d3e5704a7e02bdec8f7e9650c40b6e3c57e56bf3d1fd77d94156571ec40f3a99a51ae16ab300baf715e814b9ff356b60647d49443392f89890e18ae44942eee4087fcf5d95425944d9485d79d29863bb8a979ee402f8d054592fbb59d636a7ee57094ac4fe1ff33eab7356893523ef358595b0e7cb04bd0d6a067f504aece53c543625e745333684358f4b2949a3f5cd584c007e3d9b78dd244a2a9780ce1869289fac9f002583c612836fd46eeef7e8b5acc32515a70aebbda18d776ba21fa1d41dda23c9c46607b4a56e6412482e6b7c499a0f6dcb3377e059c8c5925d63e19619369598c47a9752f8d2e93312b31ee4d236c3eebfb1a63c0ff94b0eeea01419b8216589260133803a056277b56b4c4f2633ac0b43e41752c219faa203e155b5f2190ce3e18acfaa68f6a3b728461d3ae5800f14b975e4775e45d155e2cd4682d0718ca99d05be5e7340d047c4714a2e473a5d04da23a99d88e412b5576794d9ce58e3ef9ef2a07078d6ccfa60f2ca831b2e4656183e187bf34b87003ae1e3cd8842fbc96dd38a32d2fc8e99fef21f4416976ee21f46f304a392fc310c43157782bde6200aa0271c5da07028ba75dc98d9b28f12ee216ab3512096598f08151d980c43395210b071599700ffc962d625988fabd38cf7ee0cbe23bf7502590ff915fdabf5befa97c86a297f8827007fdce5e17a2c2fcae5f9f52392dcff9643a1188b8ad20fde234dea119adcced9ced09602fbd2baac17f75cb2f5b76c9d2cb9659b6d4928573b9642d60e203b7d031a8f94d4524f756e3759d6f605b05848ed10c8b1490b497d3023ae008d828e69df4ad912940643405901b386cda386e08cae188c50b8409010fcd01f1ba2c823b4050f5c268a742d9655a1b883c16cbb793da30f2b958ba4ed786d1e7d2d27d5a338c3c17cbae93da70f4b95cba9dd407118fc5d27daa3658287890969327f087070075ff780858faea7e15352dacc0cf21e726d225c69642cca78e833061ccd0c74dedc75a2b78d32cc741243d148da02803772ee94312fa40938b25cb69ba10e2a15cbe4ed78691e7e5f2dae0a481f4a1236ef343a415d20f67f0e48b1745ac2579af62b88bf34f0f085812a154be9cd68691a7c5d275ba3e8c3e9696d6063761273e60651b2241d38487f720f616d4f13262c0eda28c8817eeaeb82d4d53c0d4eb71e9f24616e90d950e0914404a2ee2d263dbb7772ba328f686d83ee0a1fb868a09fb838798f7c3b34f8f781e35ba2a82f8690e2278403be84e6e75ca31d940b784de699ea604d74096012277b146151bab5780503a46e438f82be08cd81b7b01d8d177cc93ef9d179c2862dbd00b00bd0482758f9c8cde5b626c5607ee7f0c232c5ba8b34619ac4fd05f2ff6167004215bfbb8cc339ecb8e6699d1e85a35775acb543dbbef83673cbbf5cdba30f8b668371ee7da3616e484b25fa5b677fc84c2298c3879c97323fb537fc7bac8cb63614ec5179bb77eee324a721eb45570c1ff7fd5ffbc0eed3cb578c77aa69d3df9714c3735f2d39f1d1e38db6b408ab5f3b44c4e9b8d6c95e3573375aacf1df6fdc6e67ff2e8a35820f8ea536b1486d5de4eec0f895c471a5336017bcc6a763864f605596efd591e944ca94d12bcac53308e4804d75edb197b849c8a313f7758a0bd25aaea6f838115f7601bc7ce01511d90a44b188e7c21ecde3fc58a6a97e5dba591470797dd0873c890805e79d4e163303b959bc314d6b7c235cc3cf9d60e90716b0000126bc31188d097d27552d6afd363ccd3a6fb11c40c4a7cc80a0dcc8f8af49ef08d49f7232bfc61caf6b43b8db5c24023d35fba2c1ffec07c3697dda4a8dd04168b6540eed147ddb090aee8003e6cfa6d5612fe764a0ec0675c3490e83bb0e9bfbada79af1952c82d7cc11eb38dced71348b4ae88655a38eb92bf43d1665d75c373b33cb534ff841afc6428a9cd7142f2ba85a83d95f83fa1a0da860465df772eb44fe830a5171b19ee71d7e30a7f563327d88c3e4d53e0f982adb3203556c557c46a92420c323210fb8afe8cbee9ba58960cdaedb25fd587f60151e94054aad9c03081605e9f218f508748e0ffc1118af63153576150930d1715d010b89af40e3584e85bd90836500d01fd88c5a12a94d214fbeb171d2cecbf16d8d27b4b04a3e06fa21c65a9c5a86a04300f8ed78f08388031843ffe1f920b2b10761fb05c6f130e9789e0c04b78fbe7f6724a8439e02c9a8e8f20f10a5e8036a8376603fc1d43374ceedb62232aecb558915ace3d1418dbbc23fc68f57f37f483f1dfb3e1b0b7cecf0b89ff0b4b5573e63b0929a485b744144cf34e14ffb736a5b40e8612cf4a5b2ded89b7856a167bf402d7fed7ed5ae350f37ef0f1c11a800c2bd2fe87368ad6bfff36edfec7617aab9a3de97f966bd70692de4259faa1597fc3b71536e4447c33a4a0020402f023fd6f91939b930cc9aa46e1cb057b8369bad4212a58e773422f5621669314b195d19edc1bdd1bdd2695625832dab17d6972dd03d77ea09d4e40cdc7fea09f8f1ecba59c322b1433c7acc05fbb1a21856f131accb2b4f0f5308c845df8fa3da4c516da87799fb8cb1ef87c920c30e9e7fa42c03c2119b72daa02709a05579713899f46fa2c0e4128c9b4c4c058d9d6c8a49878bb078c98f2a4ce7e768af00a80ee049e2004528624b6b4d091fcd5193213b079e9978567177ec8a037e8a13b989b5d354afe4f2ffc05df51a8420c3e899fea3877b6d42df9dfbd7de9f78cc2ab59044bc1d44d2993dfdddb9f22ca2afc10c620f7d01d67db99ddaadee4ff8f0fffe5e4bf82cfbe5f801e97b8dd7f61afa2f73cf94d8e497aac15f6dae169047428be12dc00791543e7a6f6a619caff4a79629a0b5be38fa1fc65788c7ed3fff98aa13051fefe76f583cef3804248f965e2e0f821fc8093a5c1e91308fb84947fd04ce370269180cc341a3f48f9f14a162a5cdcb6f25df5c94cb4b9ab31832f2880813d548ea748fa62d270b417badfa4d35496974f6a51ab32b7284927ec53d74fa7b9c16e978c0a10e25a8159149ab75af4f65249c74a6059f2cf7e7d2579030d3615c575ddc043cd7e2e8e0eb376f35bc371f64adcfd04e60ced680891be09bacd9561543d426a5334bcf3083d8fed000acf6c83ed9a5f6ff381d00c9d3cdb7c716b22ca81f04113bc3be5a33d0afd8fce3494ab55457bf95d8a5b775ad36126a5baa545d4c3e5ad2139939fca4156952906ed8d9f7fa64b1fa0778e2726edc61f75f52f7b9ba17b388e3fa723e16f15d7051fcc1fe3ae88a6f1f83ea964a7d0e8ac4740827a83e85c07a8213fa000a8c707bf4fb319858bbc6d6be3096c7aa31812e6ef450a6ddc73ba5527a2f6f293c697f23e3f36c5bf5119712fe4d9bbbe69742835d42488ad59a2eb73b631c6b9d80fe54546ae1e143a4b9a60c68a6bead1e2cd78c4a3e3dee7d8203cc602e499472a7f9c768b0f89c58798fc3f71c7fd4be0b6e4b6e5b32c68e673f123117466d38842a8b749b8fac9b645d0cfbf7b8a6ba2ffeba460fce9482581198ed6d80b6dd9f1ca95942b22c930025f54153a867e7d01d03941da17b01a83a1ba83cc0f409e4fd85b6b1904fa93039ffcea59b1aa7c725d84d7921a72562835c3dde5172e92a77c0c747670170f2be5554982f27bd820cad936e75e14ee94ec28df10b20e0165c3b4fb3e39810cd1f6e42d102ba97f458b378b5322b2d97cd471ee3f6d4724f34164859e45cf571ae96d9689c0b967e5d36a62f6e648eb24089610798355e7727a7c4b226a24499c4b279268f1e96b5140ef5f8b156365a684c319c7b3673fab32773790323a229453f7235b2b98432d22ddb47678e2e481a3dbfba43b08047ded8ed06e6e13c1618efa28d2a24bee61c9b1dec74466590975cf3c9d6b327d229129493d82ac25b7990febadbd5c49a4ee940c055b365766c3970eac66394b4135a58e0f7731208ae2555705edb3f4c9987f332dc030df10ffda4b42009e25f47c9f5c510a534ac6f3ac9853e557cf37335307de8b24617c6091c78b0c3dcc122740a9d5505ccf372b5028dc229b1cf088b67bdabec265215b51582c70bfaa51ddaa683b17b5b677c78de802fb842d9ade6b34e6056635b66da9481909774881ec03ee0aafb9140e6ee1550f137eb0465832ef09c5f72df6d44a91dd1ac1c5a9ce8f2de46f00e277834f9435cfc5c1ef91ba08cfddc5623a5ba0d491a30f2471aa6b78c8022174f641f72fd71c57e9eb1b875d1f938632d32aaaac45733bd1b724c15aed8936ab280e9d747c18910c53d428e355cbd76797fd88408c97ad8a7e8697dd92471dd6a8e2c44c5346aa90466ea64509017873da937155192479d1d9d5a58fa3856b511d5a214454e69decddf1dc490ba8c5182bdb08bc6125d3635d71f68bd75294bb299ebcff9b8e5e4b5c9dd14f7624d637ed066c602e9e5583ff607d64b7ad664891f721a5ee50353145550bf4c4d140df4e058bbf1747fabb3e9308debde47a2fea908bbb6b7afdeb81e3dabb176091f8c849badfc1030b125892546b421d3ef93a6158b8834238e2310e8cfa1c771137659c34ecf2c6e6ded9346f89b0ae6e33fce159ea53ba7dde2aa12f0ab03eaf60c2e523d6b136c779a2075003fdfa720a7fbd3b8db4985d4c19975b1cebb33342af4f686117178773dbde88fb2f09a3f0d5400124c0ed7c9b482632b1fb7d8a87db56b2611e4dc4f4113e825e463022656233de07db7a1b940ab105a28e223b1848382c17e1d47cddefcc92ea2b562d2122a40d249a265e4304d45cf28b607f4cd911a494c3e4d809ac22986b4f2f31938156ed4dc4a827c9ccb5aef1105724fb75d8dd0dc03a8f6a14dbed358984d99b6f35bc2c63542f036b3529cf731f5eda30635c44444433622e739cda2a83912c38ca04c28a2da73258d1be2725baa8b2604d5a7d450b1781de838bca320eb89b72efb948ef08c3e73521d38c9fbf31cb1b7a8d88a6da88d95479f2ee1c2bae66d3ececbff3616dff97bdb5afec9d987c4cbe11ab88a29c0de5aa8373834f3222f21549508627f6e14db2c509b69bc0d9c7a6bfdcf0a544c0df22aa94bd7295148913d3962cdc00680c8b34c01b7143c64990a83856bb3fcf97536d60f5dd530d0eb0e214b61aebc5bf33149f28e6b32300f1d568c41b99431080b3112613d5aca206e5e05c07a339cfac849a25e3ccf97bc8ac2a911f70f41e608af8870bdd70b2cad18780eff7477d5bf925f7bb01934da39f908501064d2e5a08d402e5f6c124106ce0d63bb2b19c17db2b57b5d759225fb748f4a51059e1641f6844e1a127d20038295996135c8a6fd9806760332b3da62b55fce10239eae9d824a3d5165ff1e444cd612a8e45d6d55e9aebe8717c9e849424cd1a383741729fdb142319f4c60fe814ff27b4ed773979459203d28ed4c5912f76b4bd6d64118972854c190dabf3d8fbeaf0f2874a511e7e141bad9ddea4d5536b0e8438d6e883d1cc354e1419454e7bc5b8d6a5d8655075ecac38ae5626250ee37bdea10e61595dcf687999a481f2cfa07692f891baf6424b501e145618444476bf403a14213f52c4c42d195b295f4941b32c828b8ca2266a8c6d826b1ce44024fc92087d4163e185827446025a5b25e1ef5962aaa18d65cc465031858317a35f21aba8f5496c4326009b4b307785a2b4508e9ba2c9f4732f96e629c126fab40ed9fb7261aa5f5a5dcdc228b5bd9a8a806291ea1637c32f15a2c4a179e2c3c76178108451f42ba2d744b5dcb73268f5a5d23616c6211dddbcaae822f214db58efe8305cb2080b8793e25664b078209cc807edae203d9f5cb2fd188031d8491ed9b1234463495adfdd9a1b0af8fa4cbac4b0c4c0a79808a74cf7f683916d4b5e082d1a1f809bd120e72b66096b3c9d5cd190a30ae9f0dbf89e3383b8e15f10528f4e075806ad2a03df528d35eb7cb162c48a32f80ba10557d8336f736a1b3528af200b0478780d0f08e97e965ff0b1b117b75281523aa02059a8801f4e837063af0598ac76456ad26a1cf8166f4bbe9fabdcc1c295c24b0d69590f2aaa8c9690345070afeba4c2a2652f978b932e23b2e47119e201aecdcba21029bc10687b46111f3a42082984b51e2061997ca2b94dfc25fcc902e9c6ee0d1529ba6d60560973406afa7ba73c30a82d51ee03b1abdde049fe9139ebf68fa045138beb5b17e50d37813a1b766d0b3879b1e37f9f208d557f60d097c4722c743b0f430a65883f97ad3010f75d3140bf77a500fd9e5502f47a5608d0e3592150df77d5017abe570bd0eb99b5682df0a83b8137bd6ee46e90cf286abbcede0e2e5c650770102e2e50cd8f5e27270da423b06cab07b9128a154a7ffce94a3a060f6c503ee2ca9341f62b8563e66c010147e38c7956b50ac82b2d9a1c4920ef8b37c70a39bf360039a43b71b0e1e792a52e484764c999157a2ebc25a83d51a2713e912a6e039ef0007d3074a20c128392a0db98704531377511f316fefe94afb65be075c31093c8254938d41c9e5a05555b8fb508a772fdc380a938d120a92a2c1d845c600e84ec7374518edf124bdb47844319647fd33ea15575aa2436c0075d835a643249d483bf4b17dba32e5f1f138e02acb34c9ad35b528bff7fb51eb865335ded82bab6a2db988b9d6b37e061ceb64c22ff2ba276167e16a3c711b68db17c135ac46ca7c75347f7508f9d687aca16f6593a631d07af5727f1788b6788b0f674df9fd4e261c3d2085cf268a9f6b3f108401e99ea65c139a9e6281604af028eb75378163c18ded6a42c2f15bd5228a1e192821d6f6b1308e056323d320d91e61839e71544ad2dc5e26fa74bb65d73d64d4992aea2c92646db9d043fbc2178790549518176631bd423130a8fb9995499b6009540be3f4808360e782b33ffd2d31536bb6d8725533da072c50feaa420e8f5ece02ee1acd788b43fe249acc00da5fe4fe92ba68c8d7e9317678019bc639f49b183476c88f6a87ad90934366d911a628262e6768c9c6100eb036da1b607bc2c358d960cf1f50029f656605335a33c460a30fdf9413670da21c8e007f2ecbc11b1ed7c8d72d90d3eaf0c03da66efc6209c712d12a893c30e939f937272e48a4533bac2839358529c424dae08e73e912ab5116a6721ceba477331e87e5150ee11bbe44ea6bd7149665d5a3288522aa269434a8f12f0b8d2162d1146e7fbf7a36adc29abcb256838dc6d10ac13da4ba23114cb93902cd393c75d6063ae5c31b36470e7e3b536872484839d771e395dbef28b2a3e6b5b91b64d2f0770c2c98cca2e52feb57526c7e9ccf41ac1ea8bb4af8b4248885cf00b2434b2d70319e01632263c0ed286af2c70182915dc032ae5810a07e9682d7115b7de8819ee90b342e3205fdcbc8b7c76043450611d3281544327d82f4c771361b39d8488828c2a90a9d0871821411ba9967f122d308d331321f7d35ce9217c1948f2d5f0e55290cb2a5161c45b80b7f276d74f0534e70f34d4ee3c6240df7d60bfec0e3aea2de736a97448d23271384b4dcc94d90f8b9628512d56ca5862974b4a1fb0285aa2ec84582963085cde2989cb13c90570e1409c76ead4c113b67687006843529fbce8a11f67a39ac57108d8745c060fed738703e261487987b40d0249f0f84cf27b96b36b33ed7dc268691e716a2cbe3f9e51a812084eeffb6c8556df7659085b7bfebbff182b914b2d8525818e12436f11079de9321c4522beab450c4d2798a0acb0e1a00408f44442017d4b913806ec40f40d220623d0bd9d0b368b1cc41ec89b09ca3f811546831b9152a7271b76d1ddbf2504563b4c9fb4d0aad505b23f836e0e24812f132c96dc20bbd184cc08f7405db41c407aeab49d3a1dc137036226058afef5a3ba97797dd18dc00f22e072fbb74166363fa0c054c54ffdac9d4b2caf6b6db66700cc6f09f9bd8cfc85bf83322deddbf25bdde93afd3a79f08d7307bab150cd95186aca210ed5a6f4a545ce228b0e6c3c5c6b0c840e6f0027b9c0930d1b7d945f058378c70dd7680673a3f4bb2a02406dd508376e4e28e9a095a609d409a74e392dad1a2abfd65eb438b8fd2d3ed4d84f42b063ff814f8df565b01ce43e5d36e163fe68a2392b52899dfb22dae16203c67bf3124a96860224343c5e2e3e2187d35db1cb187e4d36513b9e6193e121b5f51eaea2391022441fa6ce2d877958ea069b4a0f1603193c0284865004983c0a18b76793319651a3d405203a0f3688c57ef51a8b4cb5ba13f77c1960db25a779375f62686435e825ad1a22bf6eafc8b40034509e38ed249f1264261ad373fb2a431b09edf7c909e4df037ebe33d6a8181a45394551aa9d402165affc912a224e2c4eecc57b13a79eba45950d8016bdd03128789d1fa33f1cbf7ddb3c6fc2434ea1d93649829286f5e51b9120974bd5fbe8421ce43a2bc635f06018502226ad874753c1be1c6adce85d7168c46715a4cd7d0d86371d548e5858c69e0930b42ae6c67b1102e58cc1bfad0c47746da935b5a8cdf1df308b77e180dcd841ef960b5450a36e81a95b88d6dde111b047abbcf85266d9badd8000e1a26f78ecd0eb7c1bb46d9bf27653087eeb42095af64cc5f48f0837066227691881c8d65e379decdcc4c20ecfb447930d9d28041d50dfb988689c80aa904e109aac58562d6ef0f7afed0282051d1d74207d9371ca2657bdbad1bbf07acb7a34cc92651ba4ac5d3698916de2f0f32872751a1759540f6811867d04a9e6670e8cc37e9295b9df74e7f453a4306b5450d73b6cec291403f6e445e75d3a7e72754737cfd68dd99767b259356dec58b8536298740dfd56771a1aaa89d9c002683cf358ff54eed06989501ab8b0ab67aa0a59cbfe080dd79ce26ab729d0a38aa42c23e779e780d787a8ed7cf3f6153af6a87a1aec27adb77171179a5635e4b35f0300a0eeba655e18130953eb43b32e25412f9f186db52bd213338b59ba2b8a863f2b88d1fd819820c6f1dbfc9a4f461a419570fd5d88248d07a4e8a8c3da951751ffa58c1631f5672630e82023c098a408548f1da8b8ec72ea8d2f079238d9e38797968d2ffafdefc14241322eda769e5cd916ac32138ada59cfd75bc4f850800c3a91aa9b2a3863f33030aee0a1c4b0047c0f6c58976ff0535433804ff00906143e0cb87bff6c50709d16b18c75117742405894d623eedeeec34cb7ed32568185fed41810523cddd64d1a38eedefc88a08fefa90829493622610d516864167440f1e3b73694937722b84823b90f4a885bd2fccb1c45ee4d9970f4ba0cb669ff06db62f13184b81f661a9b4fbb75bf1b78cf6e9384c7439eefe85b08621d0486502225b10443ca3016e246fadfe42d79f40399102e470226ee0a1b815401e4c98083ade2041a5703e8828d484ac85c7ff0a1786a1f5130fef8de8f29be54f608090a3f278605e82d412c4caf26211f4d49ef34654da2bccd3f9e9fa062748c9348e5af922b206f4565fed80c0c39dbe464b1a27c8146be9306d8f8f6f081f5e96e4cdcf5470730c62f31f936217f3f4f975481ed21e07f9710c3e3e9fe59e11e6662bf0c55849bb6ffe122450dbbd7b5678f29b8be329e0608834ed3c34ed485caebc55b4843ff41f2d83e39b9c30c78ae0a5dc7ba8e637d075414142ca2aaaf708bd36796471009da1aa02a9921900e6a0dd8d32f08dc057de8d01d6dcf3887a7df1eed07ed81b13de806c6f80c3d9464781cf72ee07218f61f29c4c59e09597884b52519302e5fb6b2e0f1c23a638fa1ec66640369a75f3ad128417a784a09a4bb1f2f8344cf2ac0db6077006eeadd5e37e793e158df0c2d4a20444f0bcd813c212d7106a3ceb811ac2d9b0ec56c30a968a833e856e765793a9f3addd4e9fa7c364754a5db562a0832cb3334534e8a3d3a8926cf20738b149de400127f2fa127555ed25dbd460d1d2a42dbab1f2956c220ca362c29b2877ea8f35e602b92c193e5fd814df707d9581a537ef57cf72868c99a1e0825a0311fc8222a565ac1c54a77464cdcaf3dbe85c509322fc86da58d8e0de346fb3d34ffe4d25e5d86ead4310ebaf4a06c8cfeb73cec3cb485ce814f3c5b3d0fa7bffe9bb35dc4610a35d2679ce2954746c0b56b7615783b6d637ca685a32469096cf380c3a66343fcdf49145d033b388675ea139a8d6c3b5a58f350fda0e0ec1202381fca25099cd4310c7a4e39d722cd52743bc966a6d860fc6a9f0d0e994646225fbbca336327063e063c39c1eb8984288a1d8885d9ae9df65cde35c005d09e870ef0a3f5bb133b30549d2bd99e4103768da3d188b55b47034ad8b52756332245bf66d904ce40ed402cb184e79dea59807fa0f8f2f52cfc4607fbaae306138aef3be2082cebc582d88cd863ea2a5db10a4a03c6aabfc094abfe8a29a89a413c46e3fa55692a43ba9eaa9a97d47ab554750b0cb4d1c70aaf140c6794afe63b8f9e101cece81876d6d277d70fb4046d9773d7ca1d8e735476b302c0238e68a9723c6d78ba2247e4c318c142e0ed657884b5d137991ba670fa7d223dc85ef95063b7b1d5f84a945e47ff2a1bbb190af9551af999fe45b7ae26edb1b27abc4eee83c2c5b7ac9c4c29d7a9c5ee5647c8b46059acd7c5c54bc16402700a022b667abe4272a87541bd82edd946a5ff9e3ee9da5b3c1895c8d9dd36b8d01c5f2d600be0ad423e17404c61a41b2321d135318cfe56adcba36afa681f2dab6c8116ce34e9d33d5359f8d597914575555690fb0a1ef0c0f5e8309f04a3118a665d018ab3ea26d3c2a9d07ea578023534f6ad2f7d7bc0f3e4f826dd3420379df60716fbc4afdc33d0ffebc35e501b52d79976c3fdf98c34e9ee1a49b32dde908f9182a48e05de58ce2100a80529b86dcb1b0191ec0995d5b28751dfd5c99ac04f604d3e7fd33ed834d81515e253e14129076d19ff1755e2360ff21655d883dfab51eba0d09aec348a28ea87901d6423731b60bcfe4481d187bd3b9bcc8e1840257eea205b01d3e2ca15cf3620596c2a61d688ca1247fac4166465d577d677ecc17a44021cc317bb68900bdfefe946cb663b0e36d1820e4c6ac89a8765fad28b23d67a0aa2695a5e64534479e12b3dd30bdc5d0b04cf34f50ec645b877e794dd22084815a76ace2e62558cb9d3ac42588a39979c6d086b3174c5d945e43e7ad6cea2ff15d9dee35e5d7c1600558cb9d1590590a4b85d07fb609507a87189ece9d2fffc66dcb5d922b63d6270b0eef1765a1336ff871179f12cb4fee648073b70e01114629c5094c8fc50c8a0e56d55c7db103f3273f13e81ab098a4530a3c7542b348b86343dcc7185fab86fed27420c6faf7137c99e93b54b7f8fe37d2c58bc612d8002d0626a778d1fa57461d5df46451da06d5355f894ff21dc543849cc5a7532bea53540ce0a2797a51f9e7186e8542d14bb01b354d24c8d3709ace315fc2e0c9cf71a21bc21d2e2cdb9b84dd159991415f7b1ea94ef7e3614e118eb012a04bb68244ca747bc00b6275971fbcefd827fdb14b1ed89e71b5b61b853a2eeaab3771dfbe3979333bca669056db00028f572999d9a6d23eca8416ced3d99276c0a5217d58b5ae8258dc2edac6b05508360d25fef5fd6b5a9d502b6c791ca34aaf7aa87c218e87d1279c4c50489555d59f62709ac1b7c90d028683b7898d1394ad37713c238844d5bdc141713e785826eb8c462732367a7bd4ecfa766f65ce07b2ccb38dc0d2babb0ed99c2517938ceeed7dcf4046cb9721f57e8a50b091990d3b6081e740d7d7f4fc5e512e039d2eaa17a5efe77ab3e9ebab3f4379df7fb10ea22c37a5aae150f934b355aafed012236750f0ab32535f7fc604d4251ccd811c04b04fad272ad14ebc403cdc2b45ce362b5a7e51abc326cdc1506cec08c937d0d363737e6f0316f1e59b0d0fe0ae0cfa5c23160ab98eaf2fc4a89fe6c621d5afb06b46ee8beae4faeda482c46f58bf6327f607a486595d1d7dc5b4f1b6ee56597154c870b233028654f23add8eef44fe225425db89595a4d5af494f4b7e753bb81c70621099aaf9b415ad52e0a0d0d20755fd07705d75e9615a1ff59fc6f42ec5718bb0be55754dd3c02f88c939e1d7a2254660345397f35ac4943bdd806872d3b8be6347bb4492478a9f2621746bfbc94a0c28d64b61176448bf769cfe14fcd5d2ba1e42a5c00e51c5b2c69644f7434b736504f46ccc71ce725f75e294f5b898e94f907f97f50c0894793c051857e28e0b35aa97093e84a8081b26ceac506a7c6535c7529101db0cdc9aec1a2788b1c95ab7983230bd1ad617d33c2e1f3ae64758ca47a2191dfa717a5ba7ac7001de0e8cf03be38b58efd37df5c053872f412388cb9f86110eb1fd55e8cb9e5180e91d4b0a69ea909dfe0e8dac407bde6e4a651cd06d24140cd412f420ee2befbc32568f09dc11d4cc3256cd04c69a99f0583f958526abe947a86c4e32f85aa48adfa000cc307f9cde3772f11bef10855a0eeb764263e54eb8a68805a54e5109ecc32ab270355f9bdc1915cdd2d7b3f30d468fae1167626bd54cf8ae8aa04aa002b2233a7add62be4dfa8348272a2d0e71529b3374a4beef543d925a1b2b1726a68a01ba6d06defa5237cc11dd9470dacf49d0a91a10221c360ddd271aa077522479d2129d8d4f0f0ceca26a445df7837ee38960ef70d35385e728567e452b804730587bf08cf7525d4efb0dd05002ac678037b877f63a2ab2d62184f8e1bf95c04ff55ec53183fd2098e4c989c29ea9acacf357f186842c44e6a61e6d02feb9baa1ac5b513eeb4a6011cb7ece97bdc990111373bb6161e10267e22a4b140fa83f1b7617ee8645d80a69f5b31c43d1e00a98b1825e2e9108d2f3097b8b1724abdab2c6f2d6b6389a2435078844eed214059124e130877cff0434c1e65d1a6f9c1eb3beb91ba7d21edbae8231080540106b2cb02103c92a5b465dd03030ea3bb956724b689005a2d34249dae3ad365c08f9ab1eab235b87e4eb3323d280db1fbea43558d1853ebbd3c494951a40f13752f52151383b35728b1b4a3cf378749e5e1b95ebd08af13d5b5c51bbefac182e4e58b10fdc48259e7c6ea1678282ecdad905e830a009b409203f35161380328612c184875ce47e8bd91eae489b9c1235d91864658317ab7634ed25ef666c387da1dd30f351dc98ec3206ce644ebfa0a0f49ab6e2e555456d0b7f76f068d3ac8ca5b45134d56c9875721c37bd6eb6423aba40a934c7cf5c06448647986eb60e3c1a0cca1e46933c43c447fccee5608e02eadf8d947604e5eaca84d2f61bbee4a23b814bae9bb4de3d2306f3a672e0f1b149d5a81ac066733b6e16e60be5cfdb2f11a03940f8b3ec3c8dd42b00cb329830c691d43f665fe736d98ec970ff8d2836b02fcf2f416ff068d395797367d5e5fcc5b115245b82c5bf20095985ea6430d3511153b60587e6924c1605a65f37c4c2493cecdfbb8f498580adb99140404e1d082a5569209f33f2355222016b6811a1c5405637833bd645e241ce4d7aa5f05e755a00d326fffd1b718f431a871bd313b911710fd1263d32e8d54385f7c0bcb3ede1b9d65c38880d565719e38ce7f539d91bcc4874cfc4ef785d17f0da205825a1d7fd4012c07eca393c64d3b05d0654011321fb1e370d9e20dc8c6dd276de7d3aa157d0bef80f31e8abe1259c9732f8249ce85b089c4f46024733bdaf18fec62141752172479b6edd4c9d75269c4b9735de92e3802a2bd3c12f82e7d9cec468b63ac67a842e14ea3b48e4686220093e60ff6e6871b22db12c463f2d8f989436ebf897eed23f6f9d3acef210400e6220cf1b36cc0cf5f2b80b2f371c66ef624e43d74004466861be3ad9ff1830c6242f3291b6e4b52dcc89a93c88b70db0672ccbaddcfdd2e548bc06e04d70ceb6bf2f5f819c647ff76a9456f6f4bd28d1a1ebd2a9bd1211b15a19dae63e226cc366f4d328a9bc8040f3868e5ae84712b5b0b4513912320185909d1c7bcdbc8329b64120c5e8c80739bcc063638f164c66a949993292663df1eeb020697fef5453f884d5d1ce94974848264d1b16d4b2ff36df0baa8f8a4f403322b9dbd3e2ed04aeee3f8068de2bda8049768e471b932cb56d98b0cde15cabd22c36d12e5f4ff239db4aa8807a625dade117b39ad7db536d83793bb21ccb1094477b5a8e6da9010feb15ff764969b1153306c9620d5582b725542ca8642f27119436585b45a3d6826dc115ccc5b163fe048cdecff1acf760a1f31afcf7fbb200a52fb98b45908ca0f63645ae15f969b10cc26d04a5511119067a82b7148d9145ed6fd1ad0ab55ec6a30a287152dbeeece7655849e15ee2150a851d2e9ba95efc30063064950124004ff1ef1041ff23f4978543ef085f00a7578037895335816e9a21efc4d85cdc0dc03188d05a717fec98854fed9edf58f92e9f5b3cfe8dff5baa146f29021ccb1df76d69e9e2263606668b05fb696979312632168c82ba5e85ebed96a80ca3f653b9e1c2ce3a0fee500196b703fbe941be4a406d14148f7bf155717b7555312b7edacd416c1da97b3e616f916dccc7b401f9e5285c31a0db004fa505efed6869e130630049100d21c13a432e17ab1e0c41b5ad84d5eab50c64026fe30cdcf85d66c0bdcd0a7b1ef99ff9f14733bf70f1b9461455be742ce90cafa4269c7cd93a88c4d827ecf1c5d15a2cfa4de3a475b326e1c7d95be0ad81d78694615b525e68379d012419beb65c4d468882588f9a6a3ed908814012d920a92d676efa427ce51c03902db445a4e760081689a60be74980b2c579f53ac86e077dd696340d41a1bf39d881bd35bc9c783ca3fd18fcf8611b95af89134ae3460c97862e8535b44ca18a5b60fbbc6fe2faf03e861ddc7d2bb249aa6441f7950e260ef561fe3192f497d0307be4d57faaf8718adf08179418f4e32cac7be3748744fbf8c7d2f71ef81a0695ff1ee82394ca0d3b8ac1929b1712f4f630e1905804cf0ad2d8348b660a4b9d02025e84ffb48d32da9adc6dcd0b267ef206369a708ac91814823d5b6e5a1952b48e995cf543588a686a31e144835907d8b49173b9a49292b459465c5d62b4356bd2759cbd5f3871fd0f20cf756925de667576afd9d824bb3ee4d450581e20a1a44397221179f26089e0e49ce4055cabaab525552832f42cd73de0c5d4eef70677f00c5c6f79e693b14c933162e064b9590c2e20890b3403f65fd73c840fbd0a0a7eb8d3ee5885fc677d93a2c24a8687daa674150e05f733f901a0b645b56b781ada0b9103696be33b5675db50a055b3cf0072ac555e7b008ab4c52ce6da1cfa37a20aa093eb1663735c87cfa0577a9e366e9d709f196604630dbdc53c7eef897f9f9dad4e2853ba44594f27795284ee7956eea4e2315ee7f86ca5bca7154557240b4e5e1746209feb08b0cb1c074986e9d8dc6a85b555adec576cdf72d12dce77ce4d38df1d6b062d8caf6c2490e9758f4a3d377c2eb0d9b7c881c71da0da1f91d79ca4614e0fbcd019036cde0854fb7da057dbe493cf6b1c6100320e1d745a6d7f7250100a37486f8e3ce9b496138bfca651c97b3bca83e2ef8ac5acccc74a57f4c0a49a0285179753a5b9e869eec7751f0088b128f2709f827f6c1ec6e38a3d94159286ef020d7bf91efe9c6a023809aec0c02e8018baa791bc515fc518bd0dd7b877d8fbe65b77343e0d1f0a2f6e1718ec5cf1a36a91c60a8517b3c79d04e7cb3444a5987681c390dabde9203d9429b0a3dd5332749eaf18aafb563f9b9de77c8e44ef0f4ef095bfd34c403993885bcda2c922181d88af4dd7c2030bfad8ec37f2a61462e61145497e557c3d142e770461cc8a94884cf7e268cb00ca6861f583c4dbac8ec2e4d9c5092d4e62bfacb27ae1dcb66d6cee1cfcaaca32f32c2792038ed23d1fc88ed2acdc3407e34442050ba28134f1ca90caa6519619088dcdf450e6e4dd31ad8d759f44c458b8dedd2b9d648cbe5608502effb784ac1f16063798a1329d6aa26bf38c851740dd9a734c34512836168c6d780640f3b5d6a407bd2971a49f0097f753e3b0cd0f8167178fe8860308c9a8ed69bcb4658eea8c7596bcf04de9194cd625357e0cf82c8cc04124d9e455c44639c87082f1c16223cfc125c9ac2db83b978d574138cb73e08a4ceb3c445ec61a4375c3ec67fa2373ed0a88f016b79b2529826c6c8710b38666fb821630a4c4559776e431f282b8a99e71e6e7b77538c4da605ea02da5b52c8efa8b64a9de5660b03f89a7cc5ec7e6eb06ec6b302552dfb394c2213830cf81501fdea0145d52b8a96e0e738725b967d7dc4552a92672a639ba1398de813328fb71bae3204a467eed8a73b0427d7c8ceea9f644cd98c761d902e4a3be503e335e4960e86bc03912d4ff91550b0106f49814d2646087d8f386d24bc8559b65fa2237968d9294e8b2c15685bf35a248ad1106d200f44fad57180281b5dc71775ab48d5abe4bf88f8e9c9f369b9c0f10e5debbffab7692e3a3c9648090231c191a7ff15c9c6dcf5a57e7410e23663a8b62b30ef766778430ff418d5f1d8e7488ba9c01c614c49040957739bae11b4111f565fc52a6a7f9fda3c1e933f66ca01dc24547e9971ad4f46c4f0f4c1e4e8fa0839679e94f8faac974e3f3a245640839a1d09ce8aa7cb745bf064b972994c18e685dbe4a04855e4de64ef9d704b763415451356f3e87d9c91c2f816a026b0adb66438b982f50db81d979aae2ebcf4b9dd793a3d8bdd408fe7d814fbae1444208ac8222c34a4bc6ee24de3f13b8a1fb498c6a996fc40d3f91d6af994530b7f27bb80ee590758515d2bd764da158362251f69f04fa163fac4ac7f6487865dab3aad4016e8e93fd24fc3d021c6c2b31e497c6bbfd613a951e2d147702c1082b3d63c3b809024ebd72f6c33fbf13afb7e206278a8c9f13f4010da0e48531141bd45f6f2c7c94b6465e653a8e8c6ff81cc20baf93da6dfd031f2d8fe0b36a56beb53bcefaf23e066077ed121165f78e3540901b8f41cced70b5b986c80ebd36c80b28766e475001d1be0781eca448b9d20e9fd61fc8db1ce58a4f98c95bdc7a1abe3bb26122d661da107c097cb25221a03f52a99108ee9a4a21d6d85103cebb01d0bd8e132e67142ac4071da9a63fedd7c0f7f8cb1132b842e01e2d64cb7cb9da870132c863d59b93a47f95500b4d2c58122976c8d700e230d1dbb5f1a587bd3c8a6f5967aa2912df033767401a13b3014b5c470e446ce737eb602e4cccfda66420de6acff7bb16c9cbb6a43fba88d2b8141ebe5f069ef88449a026959995f5783af0058d2daa7f7c03a2f5760d4915ef2cae339c1b4bfa0d818a189b59944bd909d182a452d8246e8fb55ad3bc5e8cb5dd2c467368127c46a109d95ec9ebd9663aa115b8dbc97e045d06cdd01b19fffc6d1dd54af143613c4b268ba508528c17c63028626b32d54aacce770b7f6747b70b2e77ce499acd2b2e8d69dfadc31e5a03b7aa934dbed15ed0c309d93bb00c4c4b936dbd1071d4160c6ec3d6b10bfef3a32ddb027446524dd881e127f08cc9b9023e138014b6a17b1184f80a6d818796637b4608ebda4fabd407abbccae626ecc79e057e60fd172b8b7b6a88b860126ce561a35b2cabac699843dcb2423f6279fb3ae5c8f3b95c6cb1b57703c46b82bf65992ada33022552ff6550ba82da6cb8f4b0b2930ed948cbec54f297d0590b51876952f9b3fb339e0f7ac5f2fc88a1d51853c8d30e11a591136b53923a14a700115cf467f3567d363c0983d3428dd16e377bded1cfeba5dc5022220dd3c32385b0d8f39d8a33715e8ea8b0ee4127851a73c55a18814d9318695ae6522528815a27b763cae652b13d182540baf4bfbca65b55a1fae5037b5e03b922c0f8592a1ed53eed198245ab3c22db4ee1dfdb00c4c450346d811b6d7fc33048a8a071277df780813d4303c19d3b0c56038a5522755b40581da703edb689f74991d56ab53a6737cd8a28cddd25abf3d062a2b5bb3923aa7d810d52cb4399405c643a04c5f1278f13d4c35fc0a5f7362e1d6cc00428fd7822d29c845dae8c4f5e3ce8567c2a7d9264efdd6dcbbda54c29c9ff0612075b075dcec57ee36d7b0ccb30ecb7adb338b014f69a07b2920bded8384f7b91d769da771df79ae6dd440e866641eebae73e7223ae135dedc32f683622ed699cf37a09bfa0bda65d5a8ee3c0ee353d7a39a9eb132e256b08f3a726399ba281e5ebd760f96a7524e15e477d169b5323b9de50b05250311996ef5fc5161ce9bb1b3de857137db416e64acdbe3ee9c148c5098e0e3a6a68ba8de48fb81f753f8a77341a8d464fd3305cf7fd2b185aeb3c1d2a7074e8af552c25b89107f3ac1f75ebafbf39cf08cb771f390e47879661612179d40367606c0688411bf8e0e615f36131c162826218765dd79c534ae9eedd4cbafb091a8b481569b135b79406ea5128ca3bbc03c43b74e7faebe03234405568aa7fa81e40346d050fb32d0b0555fe7c904805672e0ad50630525da6460c8ae13233adf29f99e9cf6d9cefbf7219f9d3abdc9e025610a90522bafa5d05f8b27cc70a52bb52d7755dfdffbed5aafb6ac11b33d94d675941aa0563dcfab1543db0eb4a5d57bbae1261c30a32c30ac20a3202020f27b70037863c8eb8477f7ae05fa49b7d1665e8d3d882fb2c82362e0ba575c3999752c6b0be2e9f534a39ddafee5b5fc3b692c7faa9a5e75b37ed4d324c367e73304e6f8a714b6fe2401bb7f49807d2dc92055958bcf9248f6ff5407a45600eeaaf0ee5c5a8c22c97450cc3326bfb23e872fd694a7dfdd0fab5a618765d734ae9cefaa9cc39ce9d8226ac217e42209e9cb8d4a35064af7de6917ef346fc1910486ef62878422078ac905c7f1862f88311d71fa68433b5cfb66deb28650cebebf239a594d3fdeace7e948d688cc9be5a1a6346d9973cb0fbf80a487d7d9ace524fd35ab6915efbcc036ddcec2f6e01db8fb2ee41d4cd3a4dfb910d4a19c3faba7c4e29e574bfba476fc3d5ea772c5ffb337db51a6f1dcb571693ad250bdab8da95db65a9d73c507b5296faccdea4beda1b149f8d529b0571e64591a1e0388ee3388ee3b813674f9977620d11f21012022125fcc1cadbb82353896544034001e06d2cf55df0b61438f39fe5818a33af66698d6fc34642b938f2a54b45b42b5552cf1180dba3140dd7cfaf71d9e8aa1aa89e17075fc1aece6dd5da83e13228d51ac330bfae4bce09634e2961c8cbddb1be20edebcf62226994f6ca16445334270ebe9251ca18d6d7e5734a29a7fbd57de5a6655d96592557fb2db33f57bb1ea3d9d378bc37b64b66ec49d82eeecbeb3e72d6bd7ef6da92c288f176dc772c3fbab81f7d0d92e5bebe46e9d55dcf37c65caf51ca18d6d7e5734a29a7fbd5dd79ac9fca7262dd1f07437bca97b3e067af6922efc6cccdb0ea8d48d7ff023247eb39044a6b45a1fe3f9f714123879a8ab68ea5db44ab2b67e4941a6cdc40aab7a25eb35f66c1ef7e140a424e09829e408b2ac018a57cc61aa83f4cb207b2f62e9212e31f191aaef2d8aa9616bcb15d5efff4ee929f1eff259f3d4b13a33fff172b57b98a86cbbc3f8b03b57b09afe0f737b1f752faf4c00b70a06ef58af432c265a4318ba248535de5dcf2a4af95239148b5d6ca3d89447aae9eec0df62da507499673f91613cbc885af24128944e3150775ebe84f274bb2385c789a4691de858fdc02f85d00c0e9ab3d8d4c5f7a4ec7559e2285e205e5f21c0048ef82ad29522f280b7e270bae5a9e7bad7a2d1e687acc4503f5c61465a7de987e5e3006b9706ffa1adde2483f1a91586c78a777f14c5f2ab558f0f4262ba9f4371ab1b4e2c5a15ba5f7c7e9968eca564ae1174a4fd3389c4b76f498c7c2d2f16864a550947f6920de89c92992ca8876deb6810ab20e25ed54e6e77ef45edf9f7b70906e09e95647aa763402f9e7faebf08e9c32b2520ad749a1ce4e90b372ca4c5d651644f99d71064ac124265ade5d1aeb48bf6d16e3df30cae469ac22d1b66d4fabbde1273d4da3e81edc6e589ef4d8883bbdc803ebf5d6b16d5b69db44a2ec6bddb03f3d4d97b63f9d4a2f2a599bbd3ccbd3fae2a1b0edb35187d97095bfa82462798c8a4c6fc354b2a4a7af893c92078e9ee5b56b63f5a0611b2b03f566f4f332cbe861e856b6714f539fc51b7dd765ef1947a35bddfbd788c00d376cd8d02d1661b67d3cee384ec3b24c48b8811d74bb26e61bab8789d96632bdcada51c13a03fb8b9581ca2f62c840a346b7b4f91ad64b421ea25c50062b34421e9e5cff18bda47d34b0bab46cf32b9073af071908e5988da51e5189cccc3ce7a665dc6c9b39dd399bc9cc9ecb6c5a767117c8737ab396f0672d51c1efba8c97391999a704e8c29e2be22aa799bf11edb9c765348b837bcff5cbb2aa54b7b4454d30330c1fccab40a5a826dee1dbc5cc3ee79c73ce39417a274db37c2a18a3dcf92c9fba59da7436653da9600bdd16ea6f760f885acddf2c57e99eec275096b9059f2d88ba2c581fb33d94d68a42fd7f1fb87a9615ea04d9ca9d2d7427ef70118f8ef00e333333cb293cc31a0226ad8b7677974297a4b45614eafffbb019322c067863865b6d9ff6222fc8261f5f96129559402a7f8401865330365dd6c477cc085663802b1544dd993be77f2eb3f5fc194f71e704f9e73e2b990d84fdfcf9d45bb56a7e3fe6c17830f43727f8a9ba5d0a1a8ff8c1ac60987141f322860c346ad410011b36dc70a39750418b2a628c6e4dfe6961c408a4f8ffc6bc7c476a4a213985258d6d458b2a845cefc690072a43d0b0d2f055d8d3345c66455fa0d469455d9610157ce185d8225e7f152847f54b9d8b250968b7eab37ca8a04974fb676870e6ad4b3a5041143fcac31afea04597c944dac675ddb7799a28737777bf644f39bbe774972f657bcb29e4dedddd17b872b0bea6682e8a9705e9c59148421f867a49fb708f93300824611044c22078602de785d14c24dabac62e6e61ae5863968371d9ce6472ce5b3cb0fa5418f176c6d974d694719675d8e5d118532a311251e9a588eb2ffd34f911a2498fa0ab994e17ada8af2ebdbda452b880719cbd4e3766b41367238798594aa15288e51033f3e46cba377136a5ba9db4c8c9a00fbee8cf5928a82f8ffaaba7f41aea747a399d509c4ea9d329c5e9e4c2e90480d32900a7d345bb3fcbb8066aaeb393c8bb1eeb3f7920df13f7749fbc78afebbb4fd66ba0eb24c2b23f79fd9827faee99b32989bcce2b79a9d3c6f2e97ed158636d695c5c974f50b7306f86915c3f4cba755918e29156b158506b7f6c62ada0ca183466488eb2bb7ee6747ad409f5355e1e65752439bd0ed4bf9c6c0d14fff22f56c7cba3b039357dfa7ec947ae4f6cd12f1f597cc4f2958fb40e14d3fbf74eef8002e57432fde9743a9d4eef9ccd894dcd2ebc9b6cebf48e2371619e5a47c7dbd6f0e2a158c995ba390fb9e6dfcf4a4e1d9b95740b5c1de916975a436263f4e73278dcd32a7fed8a41483c5672a43f0ffafcbbe4d1e86ff5e2a5fabd54db140da87ff91aa947f1a87ff918dde296f752974a6f7a14547371d95c5c381797cec565e4e2525d5c482e2ed8c6e2e2d2051d91476274abf4a7f7a7f102d29487c27b41799a89b7536f2dbeb9c80d35b7976b43c1c990327d3c959a5bbc18634e9ec9bfe4b1128e8fb0e5be7bcea6cbae8dc50349d503bfce8b202b01eb15ad5ae514fb7e192f9b9261410bdc6b5bcd748f024c418b2ae46b74ab919b6e9545a4822896920aa2501e694599e4338d9d1eaecfbe07ece90e49e6ef707df68d3d97a2e1faec6b5c9f59eca98dae6a151cea47bdbce8aa2d685105d850b4efeec79efb314c6b39b5a0f8d3e9e54f28fee53b0e757014fe9ce2e5470ee2261ca6680ee2a0166a14fff21a4b05156c21ff1a5a1ef535b8fc698724355efef43ba0b0a9d1a3bee551bfc38b4d8d6cca2d0da86ff91aa896aff12e7fdab1f2a3ca9692f23f7d4e4dcb9fbe46cb9f4edf62ddd670f916179b5333fda76fbe23b670efe1322d5f1ff46be23e92de54c577aed4d2b750eceacb6f21169607a90da7f767253feeeebed32dd9bdfcf97524937ad9d9f6e92f42f9e94f7ef51a6894f25ca755b27dda8ae73bfd36d8498c914fd30c85a5a4d21e5705356999d3cb67e9f27206f1935f2de897f431b61848f43c83eee5738f7c06ea568c5f273fba8d270fa655fd9dbdc8039fc441260f245db0ab943c7063a9d2383d7bb6bdcc9399ad0d36fa6311e97155521671992226a836a297446afbd00da32dd2cb779dd88263e6d15716e217a40efdc9277df75837e639c96b2b425c2dd82d5927c6c8efae92b15765a3b6abb44ffbfc74ab99745037e9b09d6827980e26d376e520b9189a5e565a06c5cb7f14aad639c3cbcb0769457d505b69d50be6e3d33eddbe739b745741927dcbd7a15bbea35bce3cb8874cf56f5d0515592848c9103d78034e7f52b6cf95dfe2b11357c93f79d15550aecc8292a85ca55b7387159d1d1ede6362f1445bbcad557c9a217ab02de54aa726da449c8d36270b07590ac50bcaa52565bb8aabe4a3a0f4a556140ae5f2dff27da72e42820acaae72e56bdc7671b3ecfccedfaed691bb65e7167b793170bb366e68995823bde746015c80e690fabba2c58f45a4bacb5c1766155b48dfb28deb18e3886db88ce9dd475e5a5d4a4db5b2a050a4fffa7d236b190a67e3a3fa672f8af21d445d09d64baf94286dc452329d38195a368c5300a76554b3bd71291aea8f1e02150238d29f7958487f8e3df516dd98f1240db716e968511bf9d36b43e38339b690ff33b45dce0ba32b18084080ba8a3fba2a9afafb118fd0a28acd6709dd74abd4243f8292b5447d5692eac2646156dd4af9c77b791f81dc07cbc75d33b9db2aeacb5aa2be88f6a76956f6a722c6cbeaa99c659d80e4817c493fe808c173b5a8cd2d725926595ecbbc9bece968f42c2cf626fb78399bec3b0ce3cfbcd18f3cfa346e53ddc74b7a116753314c24a29c48f4ee9c73228d7becddd31ef3c9d968967b3c5e77f71a48f358f4dc257fe36c66ce6585a06ed89b3ea78662364543e94d5fa3f4268a5993d551b2d155dce7d47045eab77dec4fdb9ec618ad7a60ce96612f3b8f62d8538a7937d86734de2c5eda615e47eabadf02d1f24fb731f05f22998a76c67731be993d837e2f22829d2cb6c0c143ccdc8cb69fa3c7892bdf7f7ee4971c8ed1056790cfe4ca77ffc8cd90dd5e0ece91cc4768aee4facb2246dc1138ff067b19f556a05f7bad39c6c40b5c4cda940c7fedddded81bedbd8ff63bc8f59745766ebf76852070e2ce674f4e0ec7e85620c618304ae76670cec67fca1c9c83e96b1af6d9a770f08d9f435e7e1ca3cb2f7ae766b81eb339f86a16ccc15e4a06f6fe98bd918fc3f7b2f2a663c0c1578a5826998f51996108a25cfa17a5b5a2505fec566ac677612ebdfe348d6285072a8e7f29e5f52b8bd8c5cd30655c0e23e9ca65685bcf44dac6716c95ff46a956ebaae583f3dbce9f3254774a0fbc5e52facee1e01c378cc3f16afa03e6620faa482193c9885e5eff68459466b552d45f2b8c00e5c31086c0893b1730adccc1b78da42e3b6d7595ab56ecd4153b55c8d0d050eb308f50b7b89f7bf4d0ed06c49a1dba23fa034657ae5cb952e36fc46d3f0c8c00feaf89685afc146bdb8fb6e7b61dfe01a2afa2dfb48f35b126c5cf7d4e8de6753ffa1add8f9e7fb43d677570df594d13fd6675742f7a1ddb6bdc29c650d277564712d048f70fe0292a6842a7a6eb68b6af4fb2232fc59f53c37929b639d4e89e44510d8835a327591d3aa2e7d47c37b2d5d66641c1d5139da5e12a045021725e4ecde6e5d4c8197e59677bceead081830eaef2cfa101b1e60657f9e36840ace9be01b186db7e1be2be2f7311ee514448117e6ef49a263db63918473390e7a0a37b679fd1773fe2af89359b35dd406129f95c239a3625adb581353d421bc518fe516c119f4f1460c98035838f1d3bfe57a182ff4934f9efffff2f9004d2e2cceafbfe51a8cbac27aabfc63376738df472902c9b45850aceccf417a35c8dd25a5128e9f5cf505a2b0ae546b0c7bae66aa25f6bef2b9539d7cf979cc5feb2a86951edefd5b2aa50b97b68b1799af030b931e451c29304cf08583fe881132c1fb88089a114aa7ed6d7d02d9e54480563146e6f9595830afeffff7716b478594f2aeb49ed8f2d43788604613df109892009890421c2094fc8c323e4d9a122e54948e40721119e90c80e4222413a21111ec2215290726338e489937048180e011ae2130e39413804899170c84e3844e7c690882122a070e78d211142156026bc656c1968ac21d41862fcfc49f1eba12b0d31aafc4951d5af5dcd51fa757535565b634cf34b2965adb5d6ca2eba559fbf62599635f6d5bb1e07176d1d0e2ed3f2cdf2dda6b578b255d79fbceb4ddec5e25d4ff2ac8b6e553bffc29ea657178c4343433948ccc58bfee405664e6d3a1456ca92861e10127640045b0fe10060040d98d88112434a8c408713422bf8fcc08314a11dd708c97e7fcc6a02e51e12b18325cbac6c59160aa1425936a0a1078e08f9112274c155783561ce146c0d70a5f6f3836f72ea6e95b4ccfcf97ce794437c1ac911214142213ba1109d21294f9c043151d2130e51241c82271c4288ceca149b54beac4325e522ab226c196848e5012ad25f3fb8baddba6cf70ac32676611886e96cd72ac51236faebefd5900a642389ca570be2aa8e9ebff370c8c0d4e9cf0193c11a972de829fe9ccb2919fc588cbed8dfe8af5f86fe846873f3a919f31012633280838ee8873219fa6bedfa3ebe5b3b11b7dfbd18e5661e189b3016634b00f1eb0fa665468f3d2ab6be7b2c35435ef9d2a664c8173937fea5627ad79d91df521563fa3b01b83840fc1af55d15ac252a7f4954fe0ba47516c450a20a2da8e31133f3c6ba41e5bbe9e0dc6716a4d482d582a8cb5619c52a9d85c1536945bd053fb6b14728c8822a2e18835a342fd3156d50aecbb01466a12a544116b23e95593c15e41e295df65816ea4f876e812a5474c72225b4153c04dd98c1012ba808a18fd0870d421f31f0b182243e8c087df0b012f6a032d4e349d8c349484450d8034a1864070895a11b4320502e586ff44108a4490824e8c610884f08040521902321102121101e3fac48e1eb893bd99a603f7305200d7f1c097f04b931fcb113fac042e8230aa18f20a18f25841df01176400361902c843f7eee13f7094a304218c4090fc2204d8441806e0c83f484418a0883f0843f84844180700f0741d3b4c8bdd72d9b594a54f0c6ccbd2eecc2e66c96cc1fdb3d468e1d23bf0fb66a31ef4b37bb44dd88050b162c58b048d2d4bc1b2e6b43c9bb9139a5946e5c37aa2496120b4956fe1126a90cd9c829fc0227142fe751c982ba593047ca29e0ea55280f7cf12ccac8a8f2d7344dd350f4eb77fb023d025cd7aecb295b12b4a88d7c30f01337ec7ad3530fac7234a72d6d2f7a1a5b645a673279293e9a4edad6cd7577dda3eeda4dea66e92e7132e4dc7eec374f07c9fb19698f755abcad69fd9ad6ada072b681fa13f512cdced822fb6db3d7d46c2fe944f3a767b4992c2d0a82e614f30df3b866887a3874ab65502ce794734a546d0f87fe7078ecc4a1a883eb0fceccb03556444241884c45b1112bfe894f69ad28d4cba158eb3758251063fa85f4d73cadeaef26b7997c8de43614cbea51c168842b81d82286cbc8be901831e380810ac6211e97d25a51a8ffefeb679d8e54b6996f660abfcb5c3251e67b2951f8aa786256a0f2c414a4e051a8fdee8e0123d4a0824032200a8b20b480680151852a0c0d29819b2d8b2935c61a60345809ab8e35883462cc123eb476c8ec7022b30120ece841083f547efe5849948fd15f04b8d213dc9f05c4980ff84004190c44b9b2849f1600e925ddddd56b0359626592f1a9dd5dbd767737bf89e2e0bef08f0262ccca77bc12fa85e0ee2ed9ebeeae479a052e6505ceccac0297a2e40829f023a0c0ddfd0452baa7a598e008ad44ff119230124e829160131cc147d80823257077278111ddddce2388ccccd50445b808bc8887c041e01f701e2f4204eeee5ec4dddd43e0eeee207077f70fb8bb3b8fbbbb0701c23f84601f42700f21580821380821880c2142c8101ef8ee4077779be8f6525803cc3d30ef3067809907660c30ebf015de026b81ad7016180b7c05aec2418098e00733b309a83c3105290c45610a14a43cc1094d1062c21284a8d1470f1921aa8cd7457f334620e108508c500422f893210821084e563458016145831fb00fd809ee01f38077c021eb8073c038601f64824841ddb94113360862a206346032031fb86d50a30c6a5a41d4787d90e1000a76a0ecc0084cd8692e428d97073b6478f83b71870195223420c6c800c1ad2280ddddf6850c5b98010fa985dacfa4b67be561250b5878c115aab8c00a3f556801155ef0479e8a0bea1f79620a52188ac292294ba020e5094b38618926f808ad80094b96b0841264d0ccdda10a98dcfe2dca8b179a7b2d12547fd0c575d15f7c771b81ae9284182001e808306816d200114e10637cc2e248958fddfe19b0c84d695f74eb47057312b89dd8210c42ed71f933eeeefe29a6bbd48274d2c3c2488b23aaff4c378250063ebdc48f888618137faba62bc83984ea2c6850b72ba794d247e74af933624cbcb2c9afd2ae802004233de8d9e11533b77ea0a48254c52733ff42c518fe56b18a5fbaede61df84089ea4e44616183ee1ddc3c607103dec9010e5834a92d1e3f392bf77772f95528115e6e85158c5158205141d47653740252b48a61f0551163061063f8591c51c1adb6b5a28326729044330e2a6591a4fa777c72e3f38f8a49308ad126567e133fe51fafd5a4bee8968cb62f381c2e0883bc3df3a28f2efa458c96d95efbd14799eea3b31021de8b56f9771e0d1b373c1d5ae52eae8b1c35739d0747f0b89a6f4278e8e8c0c1e1061b663250c1f8e4323f8d0b18569f0ad9aa416d0bc628f71e11f420f7c72d8e883c3072e47a0d0f8ef0b8fe343633fdf117a18dc500a65bf42fe97413c9b9e21a64a82efd55b7faf2837dafc791973e6b8f23af3fc8cfbff1e6514fcde78f220fa4a909e3848a26292213938bdb30ac30a28229ece7cbc7ec8ccfbf08d3f30621121e21929d30092b611252fa092931727fecfe1c13c8b9cc73695f98c4e7c61049d005698884e7d24d099e2456aee632e45cfa5fb7e4bbd8a9f2b3e7f70b039cd1efa79193945340cea51f3b064e866afe40bf9fad8679d9cf2b35e7cb39316e2e867e4e5d1828bd944f9f1f9fdef0a7ec7f773a13daf5ed792b4a50e7a7beb6a9a68d5d37fddee4c61b937872636c9143a724f83994db07483c6972a316430c5a5c01821ac3237e6ed49e9f0a5d1e52c3e19126975f0649b34a40a209124c6e0c9150828412f7ba3144e288375fd7e8fa35658c12686e44cacf8d8fe4c607732ecfede7233c6e3f8ebcdf9543a66c526ebd18df9bc19771ae8b5b007fb4a9cbce986e2f7819b17263fc86c191ee7fbdec07737ac248297f3efb5f52c4cd3083bf7f16e13a59963d33e9160dca5e93dc0cbe9e65d95319fc1963d833f64ce967a1132db37d94ccdc0c191ce5f2cf30ec2fec2f264c94b8007aa85cfa5914ffab044edceb311217030b89f42a52305013275186d8ca8e204590f830099f083515187d812eb5e07629dd49025edf37959bc11836e2645ca2c750f712d9cb82f4fbd2f88652b17211a3868d1b3aecf4e039c24a509ba644a3d8cb66eabfc99e7ec4fea2dc0c2e4194eb0b9091d56d86cbc03414de1c51cc6e5ad7e1926824088a5fcc349b62fb81da33af2841f5c734ceba71e435839c5e6a06dff91783dfca8730e287e996638f61ef18d68d617d51ec06fb153d2a28297df95bf6f2676c713d8e11cdb0bfb048b16bf24b6fa2c7bd7e1aa173e39dff8127170037863c4f923c491216d1e4b6b8312ca2c795893ec3fec2a6c6db63d963d78b3ebb26b5986b3687e48b9be18af302fdaf4fcdd4b4333eecb5cbcbb69f9ccdb58204f5fa785d9293e1fc29fa1fdbeb2ffb651e4cb7628b1cae07bfd9ce797d4c5dcfd7bc284c8cc131ba1c6318a6bf488dd034986e81fd300fe5c61befd0bdfea20ffad4b2f7cce2c86b23e272c01e475ee9eefe9abb07da7039e0e0a19b43de14983dd829f985577e469fda2f03a9379f5794a0c614fff529feefd2cf2cdb19dfa5d667ca9f3fa6dcceb09f5b1898fe369e3dd0a27c6941ff547fd46052f241999276c677bf2b6ffc11f4b851caefca770cbbc19e69df8015b0a919df8783efb437fced6d61283b07b4147d18d8e59e36e238035fd1b56873f0bd38da14b532b09737de56b21436ec8281c3619463a0316a9fe2b6f8dc267fc6f531a62885016337ee1f14a173451e030e5ffe153b2a28af4df9fbb649e662486dd9a772c81b1fc7e8461b9fe278cde6e01ba04ba804ce76b4390ad58c0400000083150000281408864422b150404fd4340f3f14800c88984a624e1988e35990c420061964100100000200010400308488a06e002aff9fdf87efe73f9f614069c85bd39c7cff9e6c8bc963f792a172725636d2b75e7d604a7bda29f51d6d3dd189cddb6990c416f3ef075b570f894466d0db0dddead71d3dcd97a1a4a18a04b7591b1561c36766b3813a57cf42c9a02785c5e90e82cce980ca62a1149cced2af8dec14e848747b9cd0f22d9a1c742110e56dabf18081280fdeb7fc51d278909cde7170d0acdfdda39a3384b8162e276a3eb054eab0a0a665c70d81f262322a133ae0c03313bb0879a0ae301b5b497338a862559c6d0c1bf021d06d539d839cdb221b8d2765ed2521415efc32d06c1aefd0686c0acad1060fee42c444555c0a3c383beb28a8a0da03ca77970a1c2098a11befd291e3c62102068bf08ef2b167cd33fc1e7c6cc543b10ab18c73dcd28884e61b6e13f97768869591b2a7c11c4355dc2832cf7800c5cff75f22610e43257b642a659f0a776602939a39a0fa33e51b37866690f0d75fc6e11fc14a7e32dd35cf2a5017fb2a5410408117c3ecb330290279b43665db8c0d1c8ac38b4a6bca680a10a88a80b9c611e601555ddcfed454a649ffcbdd7cf988c59e335b35f6aaa0f13b7803273c7d89b71702f2e9fc492397c323d88114326d77b38511baacf91bd605d58cf528408f8ea4e49569b345e970af850934b079ba33ca824bf4f3f39ec09d21075a501bbb065634acecc2941468fe9ed30ddd1194c6eac15bc3130fb3ef06e88c4c0fe885adf8013766a264bd82cdee38fb4d13176de0d1879aa61ce6ee0aee32ab07df1a987898b919307dc697f0c2d008fa3ead62c67de196d173b5eaae157ab54bc55eec5ab157dd114ccc8a6bad98187405f51cc8dbc28bbdadeac42de94dea6f64da5da41b5af64ad71fd0f4dc4d1a56e4f719563be6ad40e58db2438404b77a5c8cf3c519b1b4d0a1a2bdb748e35886d6b12cad6b595a479741bb17d38c95904bd4cb6606346e9433c204ce37edc24a12357bcff9865d59696213ef9c6fb49b954a68eebdf3cd76b39289cdbc73bed16e562ab1a9be2b20f84d3879186f4a079b1d775c6d9ac2d674825d13bd1635d7a396e1a998b615b5bdaad55b4d6f6af75663bd42e2f48704a53b911a1e0645687cbfbac26ad1f86984207300a7002e08e1f921d327f4f2086e7e204f30dbf8df65397ffffceee672bdf7e7b76f6ed771ff7ec739aec13fbfe11cd7e39f5f708e6bf0df6f38c7b5f8a7bf70770f94135ba29e86e6cd6b62b5ba2e1a254b071499a13acca2e2f1314e73ac049307ef0fe987d11eb80fae3abc1da43d443fe876b87af0f69076d0d11c69e13f5d046fe4c08b5511dca74da158a18f66ad7993f148aa8968d741683ca69512e2c3cd505c0d1ec0fbea17ba87a61925690a76b3ebb7632b3edeac2ae179c3b8051987ddc3570ddd87d10fa14649731f46370c7dd87d78af2665fe6f422072a7c5fea7dbff88f7aa8d082eddaf493170f480ee1e86d62d78d25064e58a17938d2b8d03fffc8571ba8e7ffdc2395cc7bf7ee1dcaee11ffdb5fbc0a2afa8183971b11207990e5d87561edc0ed31ca01d723bb4720877071595c8b649559280f259a4cfc8b410876ae5c598d0b5639b39dd3f18a9b9bd234e390ad3b4e5a7aa7652a24f4ae1acbacbbc335c8839bedffe53a6a6270d6658ba8c42632a1567310ccd8ec1305e5a584d689f4ed4e543aa356b8bbf6c3aef0532658635223e230ef748fd47f0f03657943aebfbfc6011454bf4ad26794633504ddd26d78a2fc636752c7be95aeed2b5fca5ab97bb15f7e77f1aa1c1b0b5917f91521a12500b61a1e8e913505d601d97528133fe7a93a11843ae86ab866f16aea259af65c358069de5afe2d9afe51cafff6f57ce59eb0b440602f595dbd73b0222db53ed7d06dd3a0701afbb8973372de1d1d7100b3af04c302e6c25eda674495f8c93a0f55e5b5c9a5177be16859d76a4d4a69c41bfb8cbab64d990124100d6e44081f4c0c160370619f5c5b9d6ba2191416194a6c1833071c10b6ba847dd6f36c623947ce302ef83e87335692f39448b7d0416f57a28f54557ee0e4185e847a84c147af124c47056a1d2737c2084d0089b0a413b1ece7b6a654884b6e2d9a24a6b810cf093f376db456cef7bc774f0e2dc23888681aa554622b432757a7a08eccdf155f9f06f7f7ff2fb5981a09ebc5f7c8ebb5fa180c2511fe0cfa3a781bc17fcc68266a7160ca379cae985f9b375a42fa7687294401a6281dfebfad7afe7d39db2295d0d89e2f54949ca6ee4fa829dee07204ad6fc6179eb3fd8ce8ae3930d61f055271cffbf344a4bd8286ce64b58a251fbd57135cbf0b5c092ce2c6a6ecd45777d5d9e8197e735a98427d0bfe4198ba5ddf25df68ac0cc3d02a460e160b967e6f697657848a8772e331b1cd85845bc320d7fd35f789f4c60a4bec54812e8f2f9b1cb46455c1d390c4ed58b2a6ae9cc1d6c33b7dba334eaf67147e78d6c24aa1dfbd6920807dd51b8c1e190e7f02b17055879c2d1d4af08722146d771e221268c81c70b26f8c10e9740b70d0e132816a8094c7a55f4079c00a6b28b4e70b8b7634907061a34f0ec1df9746fc4f3e8e586d81e3f3fffab2f76449b75c5998947da835bab46156f2c0523b4a8b0dee77a30f95dc0ea61b7bed8b3842d63cc2fea64d364f686d026b7acfeccd2592f6f0251a250e2091e10abe9b278555e6a78ef5ac941c8a652afee1a98ae78fb7155adae852a95c164caaddc1080ab45b70d711c34a8e9e842273a41c110e7d4af0420ca12f5b6f4ee83b6cea0ac274fd4ad5beb815a3eabc6366ea14db77e377f7dfde1e5fea9b65239db5055b3745ac5d2494c538959c5554433cf5767f792132e67ab3c09ca1c8fd609ac08765999a5ce854096b15a0af9e3601f3ddd940d682c0fc413e418a087953f620e7b76ec5564addf7dbd0ab3a9d9156681f85898f27fb58e5cb00add17eb86baeba3b7c4fbe50a497e6da92f38d6c8f94548c46c5ee49b543c4ae3724243a11fcd5db9b9dce080d949f3b95a48830972b332512117250e6a593d91f10394df8d07bbe81d9ebd660f873a37d3b424701ed7487c77c5dcef549313ef4d10f3e5524f5cf2a382643f076c854b1d115ae4fe06a113049f6e43e60187f7ab34a2ee923c39fb335daaf6ba8b9465a4fcef2dadaaf7b82a5225c1d1485d28deb8a4fa5aebf66827dac63067e2a727db4fce48a16552016b5ad4a32125bd91d0d8b9a8d20997f7e0cb6729430e416d389e08ae38762050ead0a41c5e723c82c5b4b083667fa20e68c9cdb0b1a61cac12b669b293953c82a6eaec2e4ecdd4e748840b8798b8b9f081dbeda5d057d5a4cbeae8527aba03294f4e5f76a8678b0d37407b1f1980b17ee7ac9fc993025f520ded9c4b861caaa828a48c3e7c8b2819d5d315cb6a9a24ecb2387fc886f8aa5e20a906e5fe167d66d78bea726d4ffdc00b9876509c8c53a444aee2416b22bb12ac7da34c388b5712169f85c7f7c484ce661a337ed178e1c5b6d8922d0c5c20cc9c4de5ad322bc6001e5280d2ea6a5f1a94fe7267fbe86049254fb0b2f51840ea8d10ca1b12c999e2c545194f2263de9d6e14ca3489c03a6626848c0a4f3990918d263a4ac1b485dad5f7506a1c1e852149874c44818d1ce508c413e533b38796d5d241b9b8301ae959a4ff372ec6d7c5a0ead66270ad8f39296c330c219eab2cba0c0310b60e267e43a15769939dc2307e9323936e225b227468646136e391c28ab5d60b7643022c2587593451bc0cae00bc5e954eed2821cab258543ff8c650044d2a47f3793a213ec044f3b58b9be9620e2a81cdd796fb52415559dbf96966621e1a53c35e3bfbb4f3e66785315a3c92996fd3105314e38428cb4d49ddbcbdace2f32db4bdecacd57d59d2f624b8948a59c8f838ef1322519e96862a7e6f5756c3a3f75f068b69897ea7ab73af8957f09b4c5ef75fa8cd99da57941c749a367c912091ddc31059890ca106208d127d8003510e8995b01de0ac76f69f2dc88a01fea1756aa39403dcc2e9dc9cb36bbb4ef1233f8034d2e478b4f720ef026eb1c212943d8ac5045f892723f6b6d4f6561d591a0aa9f76ce1f925f61ad2bbe480228ee866912ed538ae147270c7fedb165ad754d6220227f5b8368cf53bc63180473e053e0ec237211ef9f15ef49ef2e4de58b3b0298a9373150523067be1506de0be7270290b15b1e2962436cd9a0d301aa32cfe6d8a2859bd87fab1750863620416105a10e002657cc83b183f860482a163c63791310125258ae42a5c7cdf0570f1dd96b503c262c7a657a616026047d61896cb31706a4f55604865d58eb9c081366b43dd128e4e1a38367345f6e77e0deaf3c561edd440fec6c93a7de2ed773588cd2131cfd17c92e172b7395c2ee9a453b5d55b104c90bc4f65956d50b4aa146a7a195944a814ce8530ccec4b3d779f807b44f969724e0c377b086e61e0accb2d51dfd2f604a171ef530e95ea2b3654ec5900de60fac8520c578c3411a52c7110cfa000e464cd54f3713e410f6cedb7c1a0703929ffe45d238a501c7e2e3ac2818f3d6f3322eaec1f948662eb786b76bc43c780f56ca3eb798f9a59f1421a255687e39c01b91d22a3c1bccef9aa1095e9515b79b65ea55160ef53b0b41f8b9198e8420f503f01d5dc6ce23f746c30d457ae311b2fd9a4a443e61ce313c424798859966640fe4e5068b65691e2955860707db20e790c0b49a6c6eed136b9a2614c163d3589ef629a1fd2e62f4c576220f7919cb0c3ea829d93928616ec1a6c03b65bb12ad59eda4a2f6b3413545b12537e9e07260cb9949f920e298b647728d90d3b934dd0591840371e3d9106f1634da792b9c5352e694480173326c5b31240ee1b8c02c770dc48f2aa99f8cd7242e774f9e40b0b71c7a2fb4f4b5b291f17c16d0f19748768dec05cad58508e8f016baad11da6c42621fcd5f05ce0f1d193de8dba28ecf7c365862f4ec3080b0603295cbd33eb6b2b3dd066f473d708babe4f296a5088478d77c3629de6fa01a8dece45ef349f431bb5a70f97175cba97aad8b3b509639d5425704573c0bcf9d07b7d16cea8149ac511ab41f63d839190add6ec970981e697ce30f7229c178c98aaacd02e9432153a4f5920801279033db6efb004124ee0209d3f620ebc52096b634973c074ff94c8b03571a07750a7440813cccc0f8f8154b21f0c647cb2eb038616aa84e831951cbf6ccc2945bb4c39f7d56c5ca8d23e90cd01d26a0dbcc5e58217b6c908c2e995afeeef083ecf1cdfa23b28a7820b03be088e4dc65ac460fc7ccc977609d7900b41794eece206b2890966b9cd1e56dcb1184728e4b8725a416b0add5fe2c5f141a41e8cd4b19ee41c91c8e2e6a4929a7a851e910b8ba8b3055cd255b8cd6b2d734792ba4f2a91dd1eb131ed10f6ab98a5efba5ec85ab258012231c909ecee5db10892871ed93a9e535eb53261c2f95ae614b1f5351aa606c50b94889eb7570bdcd6464ad9204ad15d79c6ae540ce95897a87614824c6511e614235af71f6b32150aa9ab5bda8129054b7f58a4b228717265e52210725259ceed0b596f322e67c867c645d7c66244d1af583a2bac2f513842d52848b82c7f5fa84bd939b61472ed96d7923c8c53229a0a3e076ce29b3fb06c7ae09c8559a1f1817d29219c335f68566011a03bd030115781b32ba090e10e80a04e4cb296154c8e37352bca06d7e12fba9e84fc0f4602873401ff13aceadbf6e13b6e856eca43a37762bab7ccf6c4152576164bed69623607460d10acf2e2bca5482aeb6dadfd3c0c98001895ffe070c0cee7d64a37e47bfc9066755b6a114b13481e0fbf3fd5b997f4b65cb28dce34f751cd7c69ccd854bab14678fd4b491a25b83fe317f461708fba3ffe697610c893a42b48ec7b621bd2b3c97cb503bc4a03837978481881b8798df1201abd90d46315d8b31ccd7dcdc7f6604c72e9c33a22058e3412238c590802003fa4499d3f42b112e274702b2e6c3f7d7edc3ef70c619ecda4310e05979b82878c184f7fb6d77c7f12c54ca39b09d7bf7c195016ef507915013e4aac3d8460ce02942cfa8cea87b726715a14972e1849fce364d4eea787263cd528fbad2771d73a20a5069da90bd36a382680fc3572a08cab2b4974afe9da69282a17938d4679ca4b8d9faa5089b9d3f9c8dfe9fed1aba257194d129ea4a7679f6d62c2057825670979c780373db1a608517f85e08c2516a674117b2ebc461c26568b7da7bd859bbb408df2e7945401b2dc7fccb719e6dfc6c6263200174c1764156181aa0e5221588ca9ff0db57e12801ea722ad7a9797807a3043bc0e010459e253f2dfd1b78fc4e279a33dad2cb79195b91b03260163ec399f7aa855607466f99adf211b9ddab5e7313195820a1cb79106988946f7da2c30a46990d8fbd4f4d5c9bcc4d1bb1c6e766912036a9b59dda9e1e12f810046537b706e63a72b1d66805a4e54d45158cb6379a9a81b9cd473f56d67b0f5c088c5b254c0d195dbf8fb80e98e35b4e144977838a8d8388340bd13029fecffe4052b507f281604c169653fb4559a2fb5c5d7d61e4d9ea61821f9cfb9154d6d7dec6827c2ed880d81490c4cb1b1e48e5604e61816d3aec6ec7681413e53686245b6d100fc9c5b0d541672503e57ad4627afd1409a8fe3bf93c0bb69020a53d4af650389912c1da04a69ff56755b7d63d37150379ced0e491093287966dae9342a165a8e6413b71b770e36b8d0a4147f0d277262380cb2962327475b12c540b356b8f61c4aea2fd67548484fb8b60f7d6631eba0d8faecb179fc1d3a1f06d2bd665951c92f69a49346ec8fad2f780cec4480ff447fd4f2f1a73b9ba4f199c80c802d2c5afba490a242383ae2d102dc0779121621cc1491e1df6ae14f025316e80f3def4e0043664d5f7e2fec4be166fee8d22b6031c096cced43e63e234b9796c86527bce287254d3ab36ac1983de06ce47889f4b0177103ae775d02b6dfcbc63caedd8fe258db72054b3c981773d086e756bb6432ecad6a9b0480cea44c1738398cc08c3c5fb26d4de9b4a84152411ec4b366fa41307bf24e70470e815dd667ce8cad9971f923ced71a9a817ad4069e5b70a063fe10805a241864d7f4275fe36f4e938a4783b2c28e4600601465754022ac5c03954e5e866be03db5862af411d490c437285fa8779db42d494e246691d4ee1fbc283f7214242b70eb618da8d961963829906c650cd2f7e56a15b9ea311729b214ed07623680f9dd67c0075616d0e03314472579b016579ee73234c7a0ecb1273612d88a08814731aab26173e02cf99796c977464136ebefb77bfa7dac3ea382ea15b815fd1afbed59b8ce45d5bd1cab079d230f874173d5e91eb8341ee8410a99d6b94129ea83123db41ad2a9262bf509945855a743eabed7d76ec80192e1cc434751125737e46c2730018a5559db4b3c3910e4c45bb3a0d0b31cd4f9f173feb7081ef42786be361f5e938359a36f3481ad03bd17e1f3424e49d9a59b80dee1c0354f69058632347115964c0c241e26469338d0ecb50d854191bc1209701a419bb3e50a2aeced22cece8aab281f8f1aca626e8895fd9043c403fa694f8b40c4e49a07c3a458c3fa9cf3a16ab6915fd8656ee8c48374ab96826c213e2fd8b0566d981b6a0d0c3f019233ed72d84a5022d1f92cd11b5b7b2f137f3868391c932c22309eb70d849661cbe26a487eef950ffd8d129b8f60b83096309b12fc43a7d0e5c18300678b2a46615095eac33733aca31de0a1524135f4941ab7d5c89ca583856e8921587205a840ced94a5baca4e6bdcf8211b722a2f608d41cc62a5a72c3185abdc8b3a16565c87257053034935a262b6edb2e02371bd5d09ed86933e0773d68134a19fa4aaa62a3bbc03c98d4bb3b1c9c214749053770a1173348b5aa6395c88228df99341f70fd45e4df05d7bd690925ea8991e80d3e2d4098fc680f067e76b677ccca1d2599ed77ed33b62180a407104530f2a08e0fd57bf1f500af1745a9d95e182701c047206c8190f658ea4c0274802dc15b8564a933122c92f841585f08b2e33f27faecd6904c070cd11cbf6bd448b144ef8fef7af46b7adde3874f5cb1785d88d5137738f6b5dbe1646e49a6a2cf95598da53412d5ee3739cad78d8f3f71ba700274cadf8fff6dc1366c48e88e0b00085e9b6bb7891b9c1ab6ab739008553f0c8ae05e137df5dd77441f4d45b9f1f51f9dac52e8bb079ef0dd7b9a50f9709bb33067056fd605f772d11c5ff7a4deeea0949f7d46f21eb13217f9b7f925510572e12239fc563394a2d61b4b3338ed46262bf20af86ac949ecae4076cc867e7103c25e13638a9d1136f47a1ed7e259548974207cde0f293fc06ff190f98932c50fd72034e026795dc781eae2c8f8db85b0152417cee3027d752552576f385175647e524e88716bb80d88092a30f681b51c7cd37f07195f2e7230431a51274514b4d6c097da7d62bf4c1a9d844feea37fb8b8bb919e9a7568e08c154722bda4c9024d1539fd2600e548bd34a2680d242ddf018b3e2901666ccd41012e84dfb7baaed7011366d4e2b68714dc0bced5aef8d7418cc246afd4e342518fe5fea2b403c4bade00c2b57c6a1df1da8131f5260c3ada503eb08cb68a0a73e361d1ccfaf1fb141aa9badf34e53e6830a9f2487210bd09c87bcbea55bc5afba0c9a4ae068e7a856f03697fda3e0cc0b0c0da0b8b457e2ff220cde49d126e28c0ae572ec50d5254cd1f0ae99bbd3b3ee63aaa3977b3a3ae4396a828cd7610a4be72c66857bdef0284220cd02584969d80ffc1f4ccd69727925be6e4f8dd2dc7d87f7ce450b1f1efb40fddfa861ec75358a430ce8b20338baf9bb5f5c8ee498d5e6d5965555bb703d3bf99da2a14131868669c9aa10ceded138ed60c767fa431b916a9df4735eabf7e8a23aac432b93450b95d055a1dc86fea3c7a840b2e71f9265c017b3192411a85cd42b422a2b4406227650f6158eefa138bc01a5eda60cb987f7177d86359394e6ca8583e9a0e24e17e5cf42d4e3e32a31d0ebc803dfc14795271cdc383cea8bc1e6d2b1e95e49714a3ad8110b926b715410f66a09dec9ced1da5f44f9ac42d10eebec7a23e5db1dd55ef049f36a08489598b7c41eb4b65a63ccdec7d88678e9732ad8dd67a7d5bcf120389327c06cf6a1f87e2efe087d328ad240eefaf6fcef67c6047ca312bb3787cfe2d3b4046a956d9aa621beda075c0defc3825a429c1201539f3c900bf1bee701c420d508d30806bac27ebdabdd539ef000a48bfc2a25ab69a5538c3289cc202a6b0a53f783a206a9fde276b890a6777a50e85069091f519ce58f1835d195580b5ac0cd876bed9c38552c04bff48c4a321021d9855436b959d19d9a78a045410ff1477b58e9dbec2469bf03d767c674de6f9dc2dc90cf73d03e05df618bcd9f96db012a9925332bda7a03b945bb8713e5b1da760d8e81744376da6b18e8636b057846e40115498345b8e811fd28b98dc13d1b6cf232d95af039edc4b81e9c5e9800016b239f98f921a52eaad89c75ae99f0e3bb51730995d29d69f612278076acea71e40861b0df1919bd07fe21ed3f0a737a9a3451dd358af98ec2a06338613e2420643c406def1a0c0579805db368921443324e0b86759b82eb6de8a5b3c3fd731ace9f42766a35f534e6a7ae524c0941e5100af60e5166b6c0a6e8e5e809a1e9ba9f3c11aef0193d1e548c80035d4d3d4e158c79b339f8463e5f0744ae08edaba270e676bad1e8f6bb8293da13c6963b3fbc6cff295eb57a014a00c1bb6b83f1ea7f2884d57abaafb38cf73f44288823de60ae8e04453d8d06e30215a31447fba9d567e6ba8825e27602f1aeda2fe3cce966fcd05781dc2782ae9e8dfbe111eb6bf4fac132959c8bfc634db5a55e58bc96904e16211792a941d0f623a1b6c14ba9e3e4a90188a40b1d8a726afe78130121409dbeb2b706fa870747b3fb01831995ef0be56ffdee89bccf63d6380f316d2719d4785000db2933d5263a50800fbdabef05c53a17f54f9d411bf3b1e49b0cf244b937c8a06f05f63d73071adac904f8c29d4bdde8e39ed162d482316b1902004bc37c12de7d2e1292bb965d8fcc8a44d430340b494116a9268180888aca89a47cf29a240d21f3bc50f48aae7c690991ad596b042729d310a1701e88aa5db04d504667ba26d590ae13c90953f2ed0c3952b968708e35356c3ee649cf2d4558c817cbccdf84c63c03de3206e5a04086c903c338de889eadca77591b9426e7bc9c30a1156f14c16e2b8815f2c93b8375d753a7b582c3a6720fb9be9c3948baf4f37109546147adda3d8016ec6c06df1a094e39ddead029be1f545203c43e1e53ba574ede3db198ebaa774a0884b48f9cf72a99aee558d5bea318a7c3a02792085e9738ff7d51eb21f71b9e3cdfdbba6237ba9863c19b116599be5be63eb5ce4ed4d1983fb9b02b930244f1e2005eda66be0a8cea68a8e41b90f7ebfff8449cc39587eb3711bf109e8c08a818686a12e0b9425f680311a0f80710ebd81edadf1056f10460eb043e4425401e33d947631caea0f5aff94b07232abf226bedcf7d0faa7842ba7199537f1cabe07d63e4a5c3bc9aa7c175ff63d68ed53c2da4996cabbb892af43eb1f12d79d6655dec53d24f025f04ba027655cb5e90c45dbf0e55f42eb3f25ae9d66aab88b2bfb1ab2fe2961e56456e54d7cb9efa1f5e30912081412924919af32354bd916aef4b7d0daa7c46ba75995b7e2cabe86d63e495c3b39185051a0988084ffd6b297d32fbcee19b1eac92c857b9c2e03f4fd2326615e61ca22258fd25812918fba8b8004e5091d32c476a2e57cec01646895fe51a155f04743a8e38b08234d1c36d264aac97e2ba06ff3f0b0436313a4007b01a65e48d018727915a7ae0bbc2227107829f6452d1cf5cc9925073185d84e5d6398e7ded6a5e8fcd6b8b4404d1128de29e50c462d111b91e777cd37c4eb2b6b02112eed5453c7eb80e92430861447a0b36486f7c7eaf55aa3b0598b33de29a9e6468c80a196a7e81d3c0374c2c2e5a140f174810471b8602f88178cd121df9200cdf9eb038530d7bf41b565e8d4907cf3584e05d2bae023e1bde599b610cc91611687bbf59228a09b6e619d9efc5484eeeda02fe0dc397042f984f9b4f62ae419fea9cb0b741e0208df1f60d684c132c02d527cfc1b7980920317435aa622b43f6cd44d843256407a924d4c8687ba254a4c7f5e48218c91b656f2bacdb1ee4c4815f0de9542e03583016e6cb63b3f2d79e9510018d8a5d1de732fc0f05b1b3cc3a1e3b8911c1a787cd893fa46e0094be0daad17422bc5a093515d5d1fe5a394ef58409123aed8e0758bf7e16ce96c5ddc8c35525f9f19798fcc8632e96464f090a8c364fb20b041cea159cc7a38eea380e7bd4765ed4a6133b1ba40407d96f09fefb6584839a092c729829a61687c174445dfcef86fb3c90601ea7b1014c7c93e8e520adfad6513316369840478465e180cb3a7f38f7651648708c1c0103082c34b3d68df68bcae5489a8845c54077f5bf6d2bc0fe3892ab1fb7a4baddb258dd63869df6a04f8cf6c9acea920c5e4a03288162e334703014b46825457afa2aa6132d47c86c609c07610e8b1dd0afc2082ddd0333dbdf4eede1691694567ee4e4957130229cb126e6039a93769cde6e3cc8c49ffd1a616f63c3e249bacd60144a79040479f7668ca47e32890d9a7226847228d1522428b8005ecf353ae09730d95daf3e4db9c94b65f966751c191f4104dff3daa5cb4763944323d7506a729f2811edbb70712857492ddb621e1edf3d41c1f36606d13f9b5cdd6c9c4e8b88d5fd6c39c705921896789debdcbaee96d219dad3234394e25495e534092b1f7d2a76334f1bf8202b961e9cf40b97964739bca8488212d7d96589a238f0e563f4de9abb91cc763451f574e81c03dde92a82a1854b6ce9ddc35f31bef8b830925b484b3f115610100068649ea98c59e55e5920523ab397644b1e12ee63b0862704dabf95e690958e4f75d2bebb5ef958da51489767c5cfd4f1019a6ef390f6006827132eec0d38d31bd2f26a8ffcaec39f406dfcedd629c41a362a0d4142f027d335cbf5c7f66747da6447dcd8a2b9b1f2b9aa894508345343d8c16de59ae701d11726e75b47afc00fac94a873af30284e57d2b9c7b9089393a91b27c34d1e153bee7ac46562ad62a456f1bdda17c3c358d96f6cc012b3cf861c34c41cf85ebc631350e3b0cfe64875ad669cfe493742278c9417c8e76787f1654e0a9a6f289a426029363261b256c57d77e2adea83b9580979660e316b04692b6f96b1925d74c4ca7336a7ee83bbc82f659449b89ab0694d0134c853ca4dbbe12987b7f6ef5b8fdc3ad7ee816e2b95b9695efa3ab6b2bf0e70490326bf6723a0993ff1c64f67e686ed13371872a2bc672aee71159375f5ab5c7039abb035dd6e8666a1e0cc83e560a31d37a23f34d2cdf2162d372765c62b74d2ba1a02b433da9319c5d876189d880fadc1dc6f550fda009208e1c82988042010e0608f90f6d32e789c1b1a73c9a2c586f0272de4e5a2d9adcc9833593394f00c716aa0247c3fdd383ae33e4586a7d2efe8583b2ee83a9a2c18388f0b9653e13348b38629c472264679f8b7a55479c3ba067378fd5f3625f3ba6b381c1f6eeae0ae5cd786027a2e73f7e260e875a65a5f4b9a8fe3e3543fe8adc4b3a55212cb3a47ce8b8d5ff3500dab69ea4e48ff89ea4cf858908cba69211f299d082376123643d5627e5407de13d987627ede941b068e335d56b4e8bb2d5a7c7a2ae23fb460137bff75f6d79a5443f001711bdc3291ce2e79ecc7d4fe9b646bed10f01fa239ecc42948c5db671d454af9cb1ee5aae7f4f81301707223f7a8ee411666817b1c7f52f5137ed5010cf22ae040326a36e3980a48d1ea2c9df8d617bbd720c095d8241675a8d2ba581fc06a7869260e0629f90b097e9a650929c8148828174081559a4d9f9226a5cf2ecbbabf933ac53031a892675fad0c5659862cff306d08eae6a17dfa381cc98e0332cf7faf9353468d37611ebe14cb75b065168345b43097f50b475561605d8f173d6aa7593c933bda8ef99815078353a53a8587e8f2425c26b710fa752b81b5cc9acf21972ca8bdca38f98af6fd81672bd541b66410c1422956f9d1eaaa333816dee0e714189acc07c34e42c42d4767fe8f755450d98470e4b703b113e93c64ebb49e3a6714c957bdc82f5c67d2ee368e9040a8c49eee2683e4813ed7069cc0d74c47235a71e1d0c0471aaf3207c0006cd10144d2e0d615165e755898afb6d529757f09fad2860a62d2fa6bd051b2165dc9d0b486ee292c9e6ff31e03535941cfda617a1bd17d614b6356e4343a9a3446bcb49a85d11dee98303ab045ce301dc3528493212676dc2e1683a44b72af975bdbcbc5a022d9cb13164fa39387b3a354095ddcd5f8216aec65fd3645d3de12744d6c0abd8e45f32a5e5455a58ebcd9a29b796466ad29184b88f497da9ac6b295c1bc50b245e687a775d4ec3c4b2643aeef831d3ce8285f0a36b4a0835d651cf65966e67f6dcffff031a16f6c0a6c4da8ab570eaeb37465c6c1de8c9b5683016760af82207ecc062618ba8e2ee758f882e2c58baba614800b5d2affb1f974f9923f7a45b72289df20d7593bc898684c9d7789cb389aa1da926a13a76560a2c8e17fafbfc738a17e974e303a9035d29466d99e4ba7bc33505f2fa6f7b8638781d03d0d2a82c21a665624a6a931d03263e99dbad41726112133021198a45c292372fa22ff8d12fd9adaf07dfaff45cbc7384eb4ec32a8ae8eaf9d0c0c191cc40fd4347e280aed93fe19a7e1ae41c2836dbf4e7e6e0d39448e5ad4cef6f848d57eef479a6526f48487558f28644fa07765cf678d0f5b27136d30ccb2714214e6c5d48f54da4a099068020cb7723d441851ffe4e9c223b781531ee65938142ce4cb2db4b450987ad58597cabb206d00ffd79d8dbf58e3446bb3f3620488a88207924de10140b4a86e3172ce436b296d68e36f69c2ce00ae5099e7de1154edde073ae869f4fb44cfa5e0f8405ca53709655e72f227036a40666eb9b14f7f6bea09ba70f19b497558c1fc6db988443590ac777c119d9f8124d2dc00bb62b28605c338cc4b8b3c544dc75a66cee00cdead31ba5243013d0b5fa44ce945f76972ba177cbddeec453de29a0553b1a44accc69308d7901d698947fef65519ea979fe39743deaf278ea7ef05ebab2cca1e3d13469a869254103904b1435ede638977e61fa04c4fdd1f1c93a2a0f01d220e7fbf97a0f590c4019962b131229e86596987ab45eddb9a1a8a37b29d0f79b015b3ab02be1139c977576cd6a906036a448cdc3ac7271f77507e03198c622962a1dea4e0a8e248fc71b106307daa87b2ca3bb99811a57e0c5d49780ea402d9c5fc4d3c80b1f32426556c732e10d071b9110f0501c9cb508f93aea74512c07abf4a6a32e3422467491b8e1f6b5c3af0085626d4c4fe2c58d618db06d06700158bfacbd60aa866fe9f49961d770eeb16a9f57cc14ecf8a528301abe094fa97c801f4104313dfd38e5a96bfb5ecc23099ae036df063629c18e9531ae330ce6c3a5a2915cfcde1f9cc5b309cf20a9d5d52b40470a22ddb8f89d0b0fc49676b4686d341366c91d570aa540b54252e5934c6c81e3a6b2a5a4ea0d1b0049b8373d43b23cc494210b841a532c12878f54465be7962f4ea1d06779929676e49c0e45dd77d1302e50851c8ac57e21bc511eb4bf95e21e1fe4ef1c0d8dafc2bd115ec487713b7c86d627424e3a8c77831dad4f41475776dd688fec450e86eadfcd01e2a2e174f14fe4249a5b4e3a0e04e16020717d456020520ad41fd0fd91f8f901b0352a1095965fc774099fd8171da800a06f8d161f7b33f0942ed96083d6ace1430cb06d3dc66b1df91c736d00d524d0834dd448d9dc3801ccddd7a15f03a616a5d34bb63d01cb36dc740248a631269f9e471ff217173afb5ecca98da10794d9b61cc13818a9544c40a706454b530de25d4b853d0f14fb4757ea3f946ef0d1d206a506480f538affc5c408a959ed213c393c2558bfc01c1e7e1e84a799dbaa63e42e6c4e0c562e0461b0f68d1492daccb9dae07bb2ce060cad96501e01402656e739262558bd410f26acde571c56650fdfc750efc34e77401576762289c16e4eac9aaec8dc15639979edb8f4263b2249bfcf615499cd1f8e43f769008e5c20d8f841f37cf616c05aff4e62b191211099f2da9b6211bf5262d571ee21d830a07a148ab0810adffa4967c81c59a03bc220f77849d3aa63f721f80134ffbbc69ac3ab9006c222844a49085e7c6f916d4700b7a68ec167c96c6661b5865770e9a03266471660968d058ac8cb9dbbf3e428718f07d59ae49a8886a085b681d07c5165f80b09bedf2502f6be62a3040e3d0c524fc067f11da5d49f5ecb820041887cae5dec3682c6591cab978c146687bcce392c0a8c5f4354c7a33c4d39641ac036cb87ed944f0bf9bc7e1823ee7397d8f40c6f909960db02ba3f97f9009312cf83d7e1af5a3cb8b64964e47976da30a2df52cf543cee3aba5f84e2f18eef1cde43b50cb8d6aef62a2f8b62a61d0566efa8c30ea44047f7c457050627865d89eeab3810c8c28e0b381efb07df92e399f9583dbf021845f23477964c442a3f074e44aaad4cf5d01938f79b496cab6c941cfdbad6c16cc385f8ea08819e9ad623ef5384a168bc0026a3a94af9e05e355cbb6c558142703de14e12ee489799117e0cd4f9e6253887db890ee9b264bf4a3c8a080db6431b09f1089b9d88323642f76a503e5909be286b0dba2ca7028519ada9b750d93dedc78d5234c17c831d72ab5ab02ea0387a3bd183ddb66b3fbd374b9f7b665d3af550e567c7855c1b25fa5026903ebb66130a70fb0add637d439c2fa787150affdd9e45bd8eb7ffc4103613a6eea9584f0ee5dcd4ab927c8f7d5a2c58dad0136d6b13dd5d6850c63bc5f37bd4daa1f70461733cf94e853c73f7d747235e7ec26c8ff9d6fd27b6ea512945b1e4e8c9a0d313746ec150d18d77f511aba04f1062449fb0f5eec0e1b78dda5e2c7d4a225586215f734509cc06ac5a950c43fd51adf07e3358c450a044ec344f9545ec8400616d7b093d5459079232aead8406d892bdedff3201f90c290ee2d2c116fe7b25ae8c9212c0e22ee0e504a69589d3318771917fefc938f6ec433bc73231d73d92f97bb97db34e8e479a03cbdcbc48e301b9668bdf4735ebd2a62ad05222ec6b92876e743f2c5b47c299d14d183f4d268c9f1633a112366b0625556ef157aedd2bdca81cfefa89bfb564c01f4868cd14d34f84b502c5c85ba06354e9a55e6898ea51e28ed08c304670b82f553a36d529e9421b1343e70e286100597b6c9fd012d11a267f58fc071a9f586f85315687efdb171908a43dea407c5f865c9bf87a9b0de8df1edd9a398ece1265aefefff6e28d04ebaa1e3bb30ab70310f537433a7e968a6234f95c0c6b4ca1761981b1493dbc0e0a2c67022556402fa91fd34ebaf2992b53471231507b31483c54c23dcafdc410f3ebf1ac3a3de4af4ffad351099023c9d4de557745a9a7505ad355d9718c205254020b17bf315bc87f06c499c4f589928205e5b836209d147b1ca4d36e2a436037f5255bd990470b290b61092d135af26ae30010cd3fab253beab3b4050fc6a56216516ca32d5b9345094b0164883c0b3588c458c1db74b568f90994518bf26dbd108dd124751088e7054bd1db012e60d96525a57bc6ae1dce5c2a549ee6569b88b2c84471219d41fe3e6440cb14abeb896de04f08fabdbbf713cc1a10d5ff7f188ab03d6921f6d87aa44ff7f5d96c9c6aab0fd909f0d59807c8df815b4e3e1eff0df4bae2a92e20e2bd63e0a79b07252199d1e1aeb9fdb07ec62fa8754a1f41173e1da81f5bd06e5b72f0a2d5aa93ed94998f85d4f6e936a94728a699a958d5d060b95429e5c51b0ad5e958385784ca8a15a7d313ccd809c8dae410a08316eac948651cf14b294e2bf47a3aacec0c91624b390a115b165860f36291a141826efd6bd04aa29d40a12c458bc21cd89108409a4857ae896177888c0b2430fde7bde0ea79818749405fe5266afe0bd6b03b693cd2b3804738034f378d6bc44f79e2e1056be1e541bbbe552a995e264e8325e942d45136f648fed782ef85fc247f352ecdbdc2a454d4fd514e0277b45265f8b9dfe55359847686f61fe4bd984055700945d40cb9cb73c2003aa8d1d100491eda1e9a8643a1d3f43a1d63001847d5f7bbc111be7d149a10bdde8a8d340a424ea054191a0eba72661acfbc1458977d8ecfc0f5bac1810817d457be9babb34f4b5edce61d79962426e08c56d53c2c6447ad59fe8b7769c4afdec9e823f1c38cbfb6b0cc39173a2de5c686bf4ae548d6b9e28da576d9a26d697638933d618bb25a334defa47eebc436aabd2c4dee8088bcab47e5a10b3f0981b5d75337c2076fe269bf15f8d05ed01000e86149af1f273b7dde525a022ab32a71c02c8c67ec946c0dbc98f212bc6dc433224b024cbdb8564580a737a5509a3e305cf21c07bbbe498104547e883a514ada9501f3b4bb10f46fac8ed621b7295bc6ca7752dabfc220ae3b7c168d111b69e18983aa116fb03ebc1a0f462aa663c5153b546a17c2b98e8f0c3c551001e8e1e7ded98bf268ff7b796e6e74fb377c59e19ab46cc5b20acbaa77a2b5293e2c34829a8ec836e4a77aa364495588093efc10081c8fbc988c71d052f507257641a084f28d060302e7de943ac0f5aa91a5091bb726228e60b2c8930f7d1c29876b4e91ae519422b8ce98f9f011acafc2bc671ffdf5e1e5cd565fb0bd94f4ad28207d38b856f8a87680d0805510ec0bbb0d1b8ba603b184edaa90f33d86510eeb2de86d1df32796f15e93e1c9fcd79a0e7ca3bf51e4cc7ef23f0defd347468f70eca92222678637bf47012d64e9e1d87df28f271bb46e32570446bcdf8c7b546c5af6ef46d316724864badce4bd94ae6901c2076cbb3a0d9fea5ae71d6ab658a16fe62de253d113e2a1d3330121c5aa352d33cc26cc2c2fb84d891d02fceb34e97c9b1838a0b56827b25ba76a9611027b98739b925d4581a98812db1bd141cd215beb3ca9d4f11453549155ea5226245c344f60affa1625b8f7fde45d4af32a5dca5baf496b640ac2e35d520fe76e66b830099f142536f0e56e8aff5fbd6a7d5117e747d36e8f5a681c29c4302541499a67eaa72767de746467ced66d739b60e745fbb9794dc8ea365967f77c258a5baa50a22383cc1187c00864106c594d116d2ea9ffd3a6303e164860c19910b821abd3e3d2434bac4cdbe181c036ae2d92e74c620b5fa3a0a49589e8627b8354c6e092e601e24de0b1a52f48ba66960cf7af31d1c2342542dd95524b2a32aab9507a1862424de5f5fdea54898bb8067668cf2b13579ecd00c0c178410df6fd7c232aad02b6a972328c92d8c64172dd38a7d7f0a7ea0749725b58e7ff7c31a34cca91057244cd681ace8456dee959e9512abb8bdd34b3b01359cf96818de39bcaea26d2aae098f60a68a297dbdf8fc6b55c16103a1fabd27c6b41c3e70746254db2a7ef5075692cf8cb2859a1591f7aa35046ab7838159d69821a188bc9e22e64419633bc5079d56c64104b9082e23bc9c630a9830558b991b8f079176c75e09e0683857d69d8865e1b09be4a88c572b3c3d31b2c4a6856aaa00b16bfce06ea754219c3a3a9c7ccd372c4efd42469fb22b5203184c3f9e62b422bb26fdb89d76315be0d814b1378ac1052ce018d920f356919ac40f2cc3f00d550ad31d2b26aeed000c7a9639535eb3aabde8b11f0b7b5f97271ed71321e8280216e8e803d010800eba73111a182296ad69fb738abe5378f16321623903471a4c0d899b103a355935b0ceddfdadedf22fa88bf0a614609d4ba4a5ac43ddbf0eb822c229f7efa124f9efdfdcc523e8cf8c19d67cd749ccdc2610cf7b7f759560ec9a0893c360005cca89ea772699e1eaead7430a31d0ecc33b733ec16b0b16eb111fa8655a17bb54b86a85096a0bfcbfb9b45ede56c3905bb9c2e38797d86e9471c836a439a683fd33e830447658f1d4c82c273a4eb47e02631e6c0618c6e714ea94510471cee145c4ad6631c1da323863d2805d6920b628962eb2ab5d17441657d6898527234f86f20bbc4c83cd6c040a2708027a83f4b7908a9aa035ee31f85a0a8bd60a869b094e989e31fb8d3389430e9125b078f5f984bac22f3044322ccf310c08320c561e9fd70535756450e253e6921b0197ca3c506d902fd45fcc5fa13227e4f9b572b24f5f95c79f38420866b980e5a4aac8a1fe1b55a2832f091ecceb3f1861f9d7d0b58ebc8486bd17c52edab3eab08c1800fcd35f841113bcc9acac7e8e14656116507ae642dccc52e798582d1724a61ada1d5d4c494340d57b33539660c96aabab42284592a4c91df987cd35e12753cf3e5f6959177e448db3165272c8cb158505735a1b0b53c759132ffc60b816866d8118a71d29b13e1c3c15ddd2086c45a227a081da54ca7360088e29ec358a7f5b62cda808509b74d55a9e4987aeee3e5ea5fd348061b992d757a6c7eebfeba08adfd5bbfa718270d00fd280ce78001ad00074ba5213d2d98663d5556d94b18f895cce67a95d45c43c532eb15b5b111919e65f67b64cac3f020ca57d1823cac254c9d1fc577cf4d4a5f4bd885a9dcab818b165d6472be83882c4ee710ed00284feac3e26ce82d2bc533e4610c1c4c5633f0b6601b42a5de682f673982fce41bdbb574979bb13dddb15f4be0fb3353c205d7ab1ff203e9fd4ab945833dbba9f7d5a4a5a6319bb3b0b7b718dc5fc5e4a13285d59f5f17a977449c3abe03c72623ee5d416238ba505b7122b10e221c8975db5dc610ead3688b153abe296179b31209a57af5e95a77e9804d47f63616fd4b8510ec9109f279c25f8dcdb2b918d34f41f426bb6c092921a7d6e39a8f8913d851f4c80cf9a403813ae467a5f36c92141692ba0b2d7e2c283f514baf5eb8735c236cbcf9eb509a69e1ab2b6b8c04e7e013afa96ad20aaaadbb1fddb8ef1692d4b40f266eb921473d8f9da9b6ff5519b067208cc8866614996c71a035ce629f6080952446556cefc663d5d7a3aa173e7abb18821c340a8a9a9480e1dc4e6c14879a79f6da39ca12fe94dd7c3c8dd31e0de3fecb8c2e4bce8604c16299bea524cfa51952aff12d1f80c92ad8ed253430749032e3f2e8a0422a2af9c3bfafc2f093b7e8cddd897182df9c77afac8595b5a24aaa1891844e39956aa2a4c44de388a15556c5324d28416fc80fc15226455f3f281b818d902afe10a76b3e8a12aff0ee3cbbed187a23e864fe6cd67fe702fd6f8b7e30fdc16985a62fd8424e9b720bea7eacf266b3b797311ff8d3971036d3a78436bbf451700ba7d1e26a2ca22ca39406840ecffa2994da001c826281ef18ea4d0119eaad441635a44a328abab14394cd351d6ac68894f503e8837d0b8e55ab4277fadc9b97b28168c3bf80c27326e22f065f78b0a9bfcfa874e6c2206d3b70294e7d0b071c77784606d934181471500631a327c45bdf827d4725697d5c3f34e5017f74a828198011676cafad0bd641be7f72f2df7eab5bf129a51b514ff1c2926d3dcfba1cc29b5d5df17a8740c7e785f4d55b414e0589b5a1ef25cd9fbf9669c7c8785797a916b92c8d4b60935cc41a94ee6ac8651495a9edc64f5a1b4df1cc7dd30e515c56ee5580394333fee579a73863d12a09ea549c3a7db0797aa387705290c46e3093f51aad3326423fa8d39d82d4168be15744975abab22eaf686ae4ccdd9e5451808d8a32c1d3e17b0447acc631ebdc9766df64c2787fa3daffe0ef332f18345bfcc1640739df1b8263d541df489f1c23f7018f11791ab349dd1c19665e2c9c33e52c89b565e0718659238abeb943e5672fc00d305105bc46c97f12a1dc344bdabf9050c4e3424bc72dbb1bfa0316216a11b5317293ac60aca85ee51cbea13d476b8505624a6f35046c15527aaf221c69e02c9f43650c19e8e9e0ea1d446de9ef12e0af421c602619c21bd46c40d6a6f4c1b479e05969683bd9cf0aacb644fcb94419917d5d29ce1aaa8a92860e5b69b15b94611a7677ae1b7b8dc0ef33e1c6769a7bdba446d2738bc77bb294ac7e7a27912d1ebfc50e068756c92b829a678ac0e61516235d851f7ba01f619848f816fce6c54cea8a30c88482978dece8432478b4d3be047a68dd57513b1b56adb0864e2a5e65af623893e2310035d1f7c788583936aaefcea2b97b4a1fd117c89a1cbec84981a3a9fc1a51469b66c1242849174ac462f8d03431b5857a971bb2d534a1811cae5674b090834cedcf23861c510500b3cd6fc40314e01c7ca3f4e4da312f9edb7b9c110a8bea1b33788af6d2067ad430a60b2baf599952469de9a443c791653eaff2f28b16d2ec53f9084ec57857dd549de149195cc4428131504c805e2fab1b9a14f54fd02de163d2cb35b0f8dada90d13c45540fdbeb19f26ae9e5221a1267784423aa87159d88dcdd858742d4d78057f8ea199dafccf5007abeb7093a2555b524422460b25ba2a4205090ff78c64559f691e66978f603dda278b50dec1d513147f40ef7249f0a14aa9b2e52bd926db0273196ab6a2c42ea29438c7caa81bf03fe7bf3b5f89dc384329b3a47407e1b81080a245d3110af40b32913c9f8e1af9a96b397aa52b4cc1815f3358780e255d9948391e881788b82c4deed93f8cce8e180f211af9cc40e20bcf91488c6967e8d89ec6cb9a301d605011ed949ed980612bc37087b78001678e051c21d7cd1dd923e7f275a3fd51cfce378648e744b29d9d1a2dc47763cbcbd20a476ac08492bf34d41ff8300421acb1e205cb0144ff15162284ec596701c185d6108333f1f608a27f76baec2f95cbc7e2ba7ce77845ba3f333a7ff4e400a2f913ffd7419caca7d455797076218e36755ba690a30ab190b47a969c7552eefe8f6d222f92402cff5505806c646a7fc7e38f87e12e1c7f9dce5c05544d61e786592c852be0b7bee194f794bbf7ce5aace78504eaa044c1fbdca3ccf39277cdaea9933ae3b8a50a4731089dfeb000a05557f50addbfb89a59e4474e2087001fd7348d0beb17843891307074526adddcd2d3fc03781bc5ae4f732cb67a58d3e24402112f154662b36129259c3b987135a8d7bdef60fd6ccc5bfdc3033beef6c32005b981cc09b44aa11b95c57a04e1acfc5e60e08bbaa29ca0318ad4bdc452aa43fd02339db8198bf27aca5e321287ee0e29059b4220187d5f46eb9d582c861be05bd7843f04963659828139e4450437919f115eaea53e15749fda5df4b2d613a6677fa1253387a5f865fd54fca43fd40d774b131bdb4e7ab34b80d48ac80c300750af429e0c93cba03cf03990e8376f8c07a0eded5fe003f230dbf20b0f3080fb1106475c83a41047b290c40218f251a649e20fc4089c2e0be350b1b20df3dc296c54451a20d45c138a878e8adcdedb1f0ad232e3f3d7cb51564d5a2270ce93ecddfcdc2cb396e5962d0c2dff51c2b8dd5e2f37c6c9f38011d0748add8e7757a83bd4b3f4682b0e161a85330adf0a899cc287f85252fbd96273425a196223056d93721b4bf099a7b078c0f0c8077a0e92d09af6cee2e034100e19bff3502639e8fc429be17e762a7897e6b735eed04f3f8c098f2eb33c048bdfcf4523c59f05ee8498573064194600a578fa71fef5897287efe47a05033dad6666a62d1ce8315cbb7db7e6efb77dbcfed5ee056f4835b56917d675ca6354dc836e775b36bd1be220f0fca87b1c94fdb1481920cba8c9d69b8f3e783c9a09c6da0067c1c3b2995bf2c3f585e08c2358fcb4dab5731d7e9fc0f055b58ae7c0904f1f37367a430448a4deec3cf406059aaa0a1a3c1c1923035237f004d557fc1fbe8949ad4030ca46dd29b764d4827d2ed5bebcbc2fcc298e68a8917a359e45bad849786e46c22546ac486b12579c4231733470280b0e1b958fa1ecf2f6d5decf7e3251779e69cc82075208d51c2ac459a179e3c46ca97c46c338ef99e7c4ff4bc5fc27747ad8b937a5404185e173780335a51d6728d73b9486f1459175e0c38fc6a1622662e983709fd642c8f77523f00b94f45487d3b046b99c52f1b3e54b6bacaee720f971e7448eb5e9cfc5ba3dd1e18f617431d9a02e336bb12b662fc449962a1578c2d1ebff27b6e449aaa90186cc7080114ce9f10830781771af1aa00191852e2f3c698f1a3a1613749d4c30a78386ca91d42d11cb495c9c7195297f7312566fb82915ada39c99db170fac88f9dab9945949de7acb9e8adcdea8868331a50de65fb6542a780da98847cb1768c7cf8f76521fa8fb5712d2fdaac0b9fc210c2ee20fbf0c10011ad8b177e11caa0da55be22f8dc1a74f0e8c3c657a3a41785054fe13ada57f70b00d51a1192790d1487d48c4cc7a328d6e7838343c28da2673030456980532568ad28ba6e2bd58ecb6f5dd2e51a497f9650b8a58858dadb3728469f059f5953db0805324b86de3102a417b888fe21e3d2a73360441ab27198da101ad8aea140996817e20343ecb4eca83c2fb712b4b9457727bc7e4305fa4fda90e797521e263928ca6b340a55c827d4266f87f15db8a8395ee119b4b935d1d2413d9f60ef749c3cd79cb35baee72e25f5ecbc50bb83f88558240e09a1fb9a1ce351bb1011aea72d41211f59f342a3d15e22eddda66ca5bbe4413052dc572c9f6d7036191a14cdcd0ca5190a402e3837d1ba51e3d690dac437eeec8151211ac9389053894ef904ab15be5342a0ce227550cb2994eb20b0b60e3967f675186291e97e55a0e89d325fe4b43182b861b30cc4920992c59114d4c7627652f8d7588e224beb76d1ca5ba0a84ce84e20b4579133e11ee6b78be1f836a999aefed626bfd4583727fe1f88c78bc31bbc680db756993f21457c95ed3c55ebf6a618a374e61222df83e008f756fe75888f34707b472de4efb8ccdd3a6e447c6e195ad44c64fb8a8b14bb41c4037728c1f6818d7dfdbc671c3659de896aa19c8c3ccf99c68a7859a6b3066e72f851d827f68342f57e82538de62a402371024692250a65f0180b7e28ee8024202acc295f96945620be4811105902f2841f2fdc45c0180d1b501557484950c2149ce2e4aca5376ef61b8e01b0e1d61a4e35e4f2b3c5ac9dac3e88c07932ced3d7b3bb4cd101d2007300a02fa022d18385046180af9ba7daab3f609bcad031d1227d461cbebf245638486c80a981b7706d806b13c5b1684f325e7561d6a603090d41534b7a7dbef66e3f2a718f037e985b68351c0cbe9b405b31d0d0dadc9cea40dc8f4e54c50a78d0bb47fbc823fda6c03aa4a714b757a09c626513c91f98489669440af2f1abc13718ec47f3c5d84d47494b357f32d683c2256ae30de16e68b54a590974803520e183c2ffca3725f1fbcbae342b153e1a1d5288316c0937a3bfe69dcd21e35aa1f5607d1fcf908fb2250be84a5776310940e6d17594dcc57c14efe2293dbccae3f7fccb0f32cf64d51f507bf90462ac3ce8baffba68542e7d9bb222b17eacf923c38ad975c1347bbf4de7211826d7fe2d388716f88b351e15536e31c9a59b9ddc190bef58256d79099d8c7dd550b6154f5554e85a6133c4f72b51a3b7311396cb6f95307a6a8f8765bf2bc022c233865377f7ce04f5bcd23d64299302bac02c3acf7649a0728250c4243b8832949f4f3dcaecd5e8f81c21c03a922982f4ee8567506e793b6d2e9f66e64baaca5f2e69b6d6f304459ed6ae5d2a4288c984b7c9693018fdfdebbf192a06fbd0c3e24659be7b023fad37851376735ae408098f2bc2d1ef1c929d6322fe6515ed5d00b93ad698153f06f76e7b27c389c9a3b9cf117d034b5424cd284493b18f670e3d3aa0c4e80d4fa36802ca0dc76771eb1cc90dab3f80cdb491a2f29ea67fa121748f653ad08e6c90860ae1a41d75f7ed5c77e9ce85686233f707129dab77dd32bd52f5facfff07ebc292651f7a00c31dd31c868f29dc9194e9fbfbdf9660a17d091cca40e55998ad46ee2b8ce6d9b1a090915aab75687dc283d78d24526d1be499c37bbb148b1dee7dd27911cc825e93279206e69936467164b762b6f39dc876ab2d0d572d5d568b5e8b41f94d08277f573848498915702e23bfcc60154575171a8e6732aad9ef57a50904e0e1a094008a617eaeb68cd4be57722c5ee4c72e3d9b20a3acc3adc85af551767991b21815c1bd44ea67ba44edb2901aa803ed9149d3784cc88e110cdfe35f8a2365d9b385156c96de3e2c24859059582460d829973d6b9cbae79f85b57ff42c91fdd27b367da6d9e1b52873a22f0fb2328cd0a3e2642cc6543bfe124840681b6f1f2e33295fcb50b8c9d69be186242f5b269543bc72b8c634da192dc93ee3101c5d010f76f13f4594b9001d30954dac125a8d5d4ec8b59f885aa3298b89bf5b6cc0df7b1f57b31393f47f73949e8e9afe2e5ec3314990704f486ced241719e4af020f2780b3845af84f00a88d1302ef0f0e898486585df4a2e96db5033b9a40ad961375cf5c66e8bacf0040edcffb7f404e30f7f3dd3960d645f49c1b3a5a44717029492e7413cf1eae282dcacca5f6bcd121457788a4e614de37d9bf5fe6184f738c915a0edf79cbac7973759405d9e299805650fb0ce12bef4cc33e0c4c5ae32c59edffb49dcc9295e2d316ed116ca1a7e59e764b4bf6fb19a6d26b38a09d4699e93129b80e220e882f0e0ca5ce952798522780e782bcf166ddb88b9219c9f2ca9b92b1e6754ee65d38841128985092d04875024fdb71e05585211bb609f0953e091231a651dcce2ca4619fb3a9069a1298457507286164ec2acaace31a2fb62903c9151295902abcc502b04a78279a28a8b21fe71096403442f7b13e00a576cc02e2af0bf39e142d4f27c20f5e6306c1311cf421710ac48fd497b0c4153af168abf9338ce9ba92866d0c80089129a44bbf831854ff3c0aa4fd62a94994cf7cdd5b8ad63af2f239d690fa19215b90eb9772ec1fd576f5e41815b1c042bdd2f3739d88f386c429b7d2edc95debd72e5ca47449423e04b480702fca1db18465d54f74d0499408bc3f4a96db63b731d53bcda3408eaae6ef66664f646c59045e34fc2973c37dbcb9791a0d9b0b5ec153e96264595e566959c07de0d2469be8ae5616f4602f5e6efca8dd7c7fee8385c0d4f60b8a6231e2adf4891cea3a3037443374741e82ce2816d645cdf1743a493b744da7729bac39f7070246c98a1e68441abf3b5e862725fe68556e90282ebb6392b6450ff23e58ba05c7b22b7a20cabf9057e290e800c68f3eaa65e87a6f2c8b2859e2e7c822c6f41f34d2d288314d8c22e8e418f13738ba3d156d2645d88b2a322ae080fa637b9e82e294ec7e9089d7a8d850dda18a9ee4fdf503b0c698589662f3932544f4ce23ad8a442c52e95a5439f6d6d78349a59bbbfc078eda84df189812b948d0c6a13ca644a0c19e2b8e3b3ee5a0153811cd2acc66088740e3a7473456c29c91d0c89deeb4683856f84e4c0c223cfed3ac6dfba1509998da6129799abfed04395e75b2ba9b648267e3a8a6d7681d1e92ca605138638be08c03f0a09983fbca0af5893a7142ce5da803ffadf6950d2bed8757e412a9af2c545ef00211bea13687938b41d1fdd4ca27ee14f1c0aae6cb92b40a890419a37c4c6c31bf011d47104079db7e227be64cba53728910a96f349c1b470e985914fb002de4bd016fdb9df9b1c21c675f1d8a48f9ca9673d9634de8873e84bc237cf777a89d5595125f5973a2848fc6db68eff3c7438865b8c357962645bb067f26e97ce910894d62585cf0a0078160691f2308f0166cc75716f6a4668212fa9f33c8cc52f7e9f72d7be5d689504b5908f6e2681435286dbd8b4f14fa3589c2165b3ec60e89d5e5a66d71eaf08fee8376f6179d1213f9136c72c38d7a32a8c5c17ff673763b60a8cde0d0f5daeac25add0be151cd56f2f5d3c28f2cd966b4164df4e641c7fcb503f4b14751c655e6bdece9b92723c01ae4c016afa5e71aff04b28a149734d5a0dda50c12a2283d5f8bf84fd1c44e8e117bba5782233d41a54f43fd596c05ec9d4b0b396d7d330a134a1804bfd880c24826d81c48802c6c7f476797e495084c0057413007ccd495c59ec182f7d8d4eb1a7afe8b081047dfa5bd313ecd9dc36f9a812d3cbd025be36d959b058b87d4e5b43ecaa115b36547cb3a9c25d0a08c589ddfcadc731c8217de7319933273fc87bf3ed6ce7937e40a21e5e2b1a533f97bf9b1f6664ceb0948a0afa1e76009f4b3a0706ab1ad83fe2dd2b7ab1d3b33c24a8d052fb8f470f3262c137b6fcadee263f602e59a9ba8fefccbdeb6671c9552a587dad79ba043e4f61f625b3122b5ff45f0bc450af5208540ecc951468410fe5ad6b9e22d0dfab41b05185563556cb67bff4dd638c47e03dbdf5a64041dff12f8a4caaef74c4d00d08d98485d761ff92822384ed3c58a816386174765537082622a41e3420bba2725c97c64803619e31e6bf7afa2f3a5035b0507f5613a9b9e23e03e0ad7c281bdb4ff01db005fb75299afa6bfa2ab6bf41e8449817899b6903ec99647001b0ad0eccec84bce2a136c1939562e4a5a0193dca1bdb2a0cba90444155b8112e6fbc260b1132bd6888373e9fb2911b3a8d4c1e600b7dc8263f6229430089b371916154e4a854bf6a847fbc895782518fc4151263688ae8e88fd29e58b425c1609f9703af7e3213dbcdfc53e05cbfbcc58393bbafdd5aa7ec847f55f1fd2256f1f8ea3b25c08dbb2511d0e9dacd9e974515c7ec71a01836f832dcc508fb2a915a4cf05fcb4035ad25a90531058e92a1df041e7ccd60c63fe2fa42b6f787fef69c1a5b342679b08bdbb616a3f610ed153183790ea4967ed418f2deaa76b9c3d19da0fb390fa4d991ec841431a041c7e1c2aaddd6defbdc9965b4a29534a0145086608b2095af830e9e0dbbb31807dd85d7225b8d172113446ce050dcb1bc51315cf8a569e3fa47ffed295f58b4a2ea77ee9a62c015a07a52dc55bdc51e435996d11344631099067e5cd0cc330ec92dd1fb1a7f4aa14a3375c00578107e05fc33cfc3b57395052bf6489e940b529bfa5a5cc2da13ccfe1720b225963d72037271468cc6f9b71da9c3cece3efbf9ad7178f10ba4308238410c2ce0859ffc4672baec168dbca6e15cfca8b91a5f8893c2b0f3a3f21848d9ae5f7a571f5bce5d78a7dbc9d4a29535863dd2da76c7a314fe64ec5b3f2b4649262c10536893903d2d994b29076f1134c506e6f418248323228883ed5fa87bcd47e3b680d924147fffbb9f187da202228243d85ebb10f8b7dfca58450ae1bf99137c820078de9386a064d97a3b238dd8fd218e7c641de8a4550a9bf9c7ee8fa19a7b44a7ae84a8a3f8be2a42f2dd4659bd0211a5f4a2975882edd425d1eb9acddf258a243c0f5fd2af6e91c37ecd3ff4e32f5579c7df9aa4634f5a97a61a98a615a4a4ba55232b51dc10d426ceb4b93b26a9a9452a6e663db51ca28754d8c4aa36bce791d5d9c840ee59c124e092fa74cb2fd7030d3936e41e89cdda954779c1b4da55218f6b52775515f58cf49358cebb76474cdacf6ac94a6666ace29b178fdfc8c6eddb5533595c2787e4b72339a36d20d896a7f5928ed333abbe7d4b44ab9e79c747677523f4cf926c5892c427777186f437955940b940b5f2ba2f7fa1251f61563aa63bb534eea67c87f498a5db53b4ba5ae2bb65b0d62f492466c29e4a86d61ea2d087b1fcd86724517bf5f8c57191977fb14ddb25b42861042088bbc5bb6d7fe954785aa01ecf33346c69eb94308259410c2282c4dcc3e6dcfc8547c5d5727e4adabb6d377ca0da3642ad8754d2f1a69b40de117314e40b9f31f6a5838f5277463e69b9049ffaa496c77f8bfde31eaebb21fbf0e7daf97747aabce4ccbd971ec6eeeee8e9d8b012184cfbcd1a6b26557291b7ef43b39065977778c31c6eeeed8ad7537117333478e2cb90a642d66b4be02ca95ec432ab1f23a2d37beea48df8d7de06bec03df3ef5966b91c5089f48688b42de9a3d7b4e962c31f6f1e78df2a0a26b681d0dc601367492515a85bce5b44a5a6b7f86f5f4c856cf109e1e6f19807dfc351b3552caef9eb72152b6bc157b1c887bbc8583f38c233559997d243f0e7f6f4748ec5b90fee4e3703714cec3ec358d429185fbee21d7dd31e2979c41e158cf5af5dfcf006cdebf003636fc90dfa6d65835f69136fae53708a08dd7d0ca638a0e7eac465b3f775db9bbbb5962db91d4bafaedb8414b8eb62da8e7357932f376d449cc7643d27e0b12c43ebe7d90f3b66ddcb2a5944d398db7204195fbba6e6e1ededcd4a69b6d3b7a6e336acb966e4812ea86ce8b2fe7bea5cbec638b6f8710cf0e7d065c37bf63a4bd7c6993360b75f39a85e27b4dd5bca9403c877f2ac85b5fcbe6b87ce8b06af5a4a88494284828284845463365313213ac54f1a827d2d889d7cde4b38d71c628658c11837fc118e157a266182364ef2932f6d6c63e70801b4b985d1a6f525623daf2e17b677f5589fd55312cf3cc279545f2d26aaad66f09b6c996999435cb523225a58cdb91d52812b63dddbabf994727c9e7ef20d4992fbf7c3abfb41a8d50b2dc9ebdc5ec39d85bce180f5947cca594921d68c6eb9b07003fa6b6a2b61ac52837a143524a19218447105e43bc21f965f68950c86426f9bfebba2e292b675d6dba86982c611aeaa03a9edb91dc8cda46ba21b185ea32dfa8b479cc42d57cd7bd8db7e9ae1853f12fb651ad921eeadeb723ec93b8882fa42ce302c6fc8b8b942bffdae44fdeaea278d54973d579551a1a2e7291dede2e4b743d5f3fa98d8fc94f5529bb3169a1bae74d66341a6f41e0c7e7c9d33e101a66b64420b89a724fb31df1779bd16523dd90b8cf7e8bdda7ea270402244b982e66a13adb790ebfd4f278a2d3d8e7a33f74a0977de8b0bacd6d42b85f4277df3a5e3202f156941f89bc152d73be4561f8700da875dc82b8b43212611f66d291b95d59b8be19b516b7ebce855b0cec133faa0a236e577be3c600f6899f49f76696f2e21efbf9f3a5262fad1fde6974a59422562756275629d5300dc3b0671ff8f3e956bf1d4b8ee04c29c559a196fa59a1f6b36a5aea678ac85b298618c52cd59028f7173737a369a9d5e2e422acc24169ba0de1abe06bfd5c04953d5b28ec696d628203fdd4679588881f083bff65893a8559253d44ffda8e36a3d842d7ffda90a09c5643d8b385a2b6091dc220fc661e6c3529e951a4b208939ec2107d201e14249ff64b29fd8164d049771b9561349892c6cda2c6f50fae75c09f358872b188ba996fd9f55daf6a94fafe2cb5617fb552bcd96f8fd50cab1756b36cc3360cc3aea65cfd76047d4b6ef6713bdaaede5efb6bbbaeba6ddaa55dd715b723cc265d459885725a0dd17cca4235a14334b6a9a9c90fc98b07e0dfcc83bbb4dc82d049675f178609b9a09ce810cdd3da7f59cd5bf1233dba2c94d30fd1bcf7e49e108ac62ac50d426879f31473f1417f646b698ab2c2e966ad39bcbacefb6870dbc63e318b1fed7af890fc56962bbf47be269f3fd5c5ee5ff71fdeef9f5819575e63aefc08060c13bd905c5cf9f05ae1e5ca4bc8b4440e848352ec1ff93be4b7e4f7349103cd07e22d20263afa43e8bde2274d4bc44507d9f4a14447bdc55a145ea0dc4b8c12ccc427220202b32f7e3ce24fda8a38e97a2121d71bc5abcb15a3043257ca1c71b34c9b9b90a5cbf65b82b15ef57abee44b0bc45b440e94454b14e687329bd16569ef78a3a8f910427783b61d357c28a300260d0d89096968485fa4a1210139f9420c211801cc173d5ea7f2f6f203a683cfff3c2bafeb543cab2162681e7c40e60c339a089d09a4b04614784081871d8098cef098c20d8098402f1ddc62083feeee77881843139ea0461102495c5d58b9914322c618638c1f638cf17ba2f7d8f80e9fbabb55795f4534229e1ce1e35119e1fa7bef39be1bbc0b3f22f5c3e77120d81361ac9f7719488aae5753447d89d2b823a2be782182a90be2f61435ee1066544f97c30c41e6faf7f867349f77575e6cab1a029f88d6dd1b42745a2e8b81c665ab84e38656ce17205cb9a1d5857cd9058451dea0ea82cbf497d263642e314628bd800d572d84b184182b18218c57c06682514e950795da065fd80b27258b126e602f577ef9c2e3f1e04005487813e805d21d46ed4b3f5d5463df1cb343f86236c6c71ed22fc99da92ae15f75e9ceaa04af844bb3db075dd2c822cbcdb2d668686868683e7efc788c8db7f9c6d259da4a169ac6d259d81b0b0dcd37df68a3ce7ad9e08b0d8eb86a44d9800cf9257a815d9c4b6bb1c2f175849aba6e7e9d8d2f37217df35ff738f371aa76a3d2bee6e97ffe35f6e331b7859abace2a412b3f65bfa6ff754f2dbc9dbdae285fde2869b00d49773bc6287fc6e72479c9d76a2c9d0fd981baff11856e3e948a014e3fa4b23798a51a763d94ea6785bab14e3fa48a57d64b5599a66adaacf4d268d8d3542a44d6a626b2d46fb5b33416ee6abcabe25a26fbe94993328569b93ecad04f1c28b3d9b88c461ba727364f31c6cd26c6089dd8d4ad3e0f8dd126c6189d9ed86cdc932750c85c4e805a10e305fd3f9bc7b6c7dc2af9666395dc66739b443f4248db868dce068d0d274e1c721a97a64a333d2d274e588d4b93c68e1f274ed80c17e1e3f9de8913245219f7958ed8c3544a62c1e84c61c1c25862108dc6d657b4f993af30962c100daf44608030738758fa07cd77cd431b0fa10dabe45f0d84b0a30f3b0869288cf787c7fd9fa7558954a21d3f1fbdd7156967b920cc7ef2152f4b5d96f015985daec581aeff5acbb45a3b3950f64ddbc20024c4f3b45aadecca157fbec257ba50da572e2dee5967d1525d962c95eabcfde1d74e54fad7292cada3fb4aaa3627399a6fce266129db587acb72e3cdaed98da59da8dbaf9dee4ca27f7df65fea33bac9295fa400f142024cca3be58b14205e48308f18338508833182872fe5ce6ffeccd76c63c1d23a669669f6eb88e5bab26089cad1a25bcdef234e4f9e3871422d266d4c615c7a0973e84473b9b44bddd49c2fc390d9930bb57c44b5824aae691a841042489fc2aedd37827bd57e5a55dec31cf2b5ce5b32957a3253730e813fa7dccb694ab997d38c722f2728f7822928eda43b0a9361e3025a41f7759aa6697f5ded34af769a573b4d4abffe54eaa2d7eccffea3f99aa7967256c96bac927f34965e0fafebbb26ec6fa7d631e9f391aeeb9adbfcbbfb6efbf9dc4f9acf3adaffe4d29b5d5a57e7b713acab29ac32a661338dbb5569a645029a7a5daeb21a774b6304994653e5e52a9bb9db2595e01624d54fdac98faa065fae76a51655b468badecf23dda92e0553f6826d469b71c48180388c4294b9f16aa1a54b992e525c283766b1657dfd755d1776a4cde8325020acfd6e555ca5a9aabafa86aee432d38d468cda755df4bae85f9f7655d706502e8fcb515a9071bdcb91c626d365342d761a4b6696c43fa26968dc683f4a394a230dde43f50d63776b7f45db4a41373f521aa9065dc9d7b1cd1c71201a1b8d18b5a6feb4c36299aba91e7bcc46cad1743629fef531192a8c03a28931c636a3755032d1e688b651bad5d0b71ba535f43f4a3bdb66fc56f3978db5f9ebfb692aa7d52cd559e59e47dc9a2aa544e9b9da8c36e3b29255a672c48e1f6c0430abd8db44b93535deae7efd84a67235a3746b2ea361f66332eef5da95c123fddc16a4cb4cce71ac745aa7cd39abd02514658c1c99b3ee1939721634cc0383b7e69c339b534a1ce62bcdb761fe0d5123e37e5a369ffab8606b8ad1f57bcb5b3d9eb726fd15ad3ec474f4554804b8d47ade9a4da26eff7c68bfc99bd1f71f65288f1a1245aaf50fbe2d226fcd079241c7da8fcf4fa364c0d923f5f36d803d5296a7ebae92f7f8f9180d3a1f06efb112f21e1ad0a535d35504e9c9b85ac518698c2b4dd3fe8af1baa2bc6e54a8e95472ca2addb7ba3f4c905795575f32c269441a1a52ec9ef16766c9babb5bb6e7afeaee8e71ce186337b979e5eecedcdcdee3752a1b5c45d827429f4d40082173bbbb338410c6e8ee1eab60ba51d475373b4729ddddddb21d061c9b5390b5d70d0329a594ddab55377477f7a637060121840e3d4a6eff896278ddedab96dd0ddddd1dbabb3b430fc3a7d0cece1c59c5b3f28688314c61f27476668650e86bc835af0899bcd55c35b7b333770ca7e0b17bce39e76c9e956783acbbbb65cbabaf9edd595f43fc4a26a394fcb10aad9a650efbf0ac3c8e43c418d8474618b7c8bafbbb65cbe62d5d5a7ef7e496ad31404ac93efd1a843af0ce41b77abc4e0504ee481451c608218cb0c7eb54eccdec8ef434dca665298c5e5346e8ec93c518e32ade55bc2a9e95172374394616a3bb94d265c751c6c8cc91638c32ba7623123ee346abd4e3752ae8328b2c469e15155e6ebf078d72aeeb8a45d0182191c9d8eeee2da5777366ae41182184eedee3752a24b2e8eeaf8a9d6c29bb6537a5eceeee8e9991f4edf13a1514d991a4426976d5ab2f972e257c09a5cf59dd3b28bd36edafd77524979db6fdafb9621f96d372edf13ad5a442d57517658fd7a9541d773d5ea78210c2b8629e95d7ec0d83ee9ab9c7eb5443c418b81d09ef7677ef7677ef7677f6f12e5a1b459e1596a80bdf73f718238d7046c9ba6fab78565e113446314a468e50c82284108b940b3dafb02594ee524a8d7df891f499e781ef652010e2b30ab9a69d0c553c2b6f3e3c621f2ac5643146086127bb6bba1eaf530d1163802858f58abb997b5bc995ec2865f4d8f4e371f3d755cf39c593ebef39377784ce05c2e8ed40c8b8a918f115a71eaf531db1cf10194b51e6fbc7bc103e900c2084f23c474b71a55fc98d96877dfab9db553c2b2ff66bb11af10142778f3146968269e7725415014b9773585b68deb33ef33c24399fc30a57be07c4774ab08657f97a472dc4f5584968b222c901c90a97f54a989898ee277f0706e6db496c4190c8cfb13ab0ecd737e7e19933676ed6505abf40a7c7780b412a280113f30b37780a97f540fc46bd427e27b119b5109765ad0e2adc2f1a751e5d6857122f9c80f921ca298c0f629a7cd103184d61301183871c7cdde13feb23ed1c54fdaf3c54ad921e7a8bc318a67f86391eb015791d685c954bfff59986eaf3c680a5a17f20ce811963c90ec85082030f4ad0031294a18d80618e246492f8400466e870460eecad56198dab9c127babf5831e80a071956b62e7e13c3a08ec3ce4b3f3400307217c6de203accf7803eddcd797f59587bc3a048dabd203de7319204207e473cf5aba92bdc5f241f4ba084b8c60823e82121c90c0013336b0b76492246c80bd9544094bd0000b8f23032c581c96a10b69608009353074a19b7001862eb8d04eb00043175c90af862bf57d82b6e47e26b83b34f0fc8ddf91efb7ef8eb433f0d81b160a14e8285480bd05f9ec2dac21831426c0de82b73005094480e9c80e10e0e1014c1cd064a487063461800f0b609803e670d28a30cc91e4072427310071f4442408a313280005454f6048c11015685ce55e087b8bb32bd09a0892040af7ed032b8401ac88de020ba2ef487d0b7844d176e4f3505313f2391b6ef05c10c4c30dda0f6ca8a1cccf193bccf0c10bd4d842450d286ca1f2842c57ac5469a2f204038dabb28b4247a14b9796c215d8f71a598ed032c58b948e02a5a97d409ba4709c0f582c160d357064382e061a6bf5cd82ed88d56436249d32b62139393a3847649063246b886ec13624bbaccf3266661f902962248a0563c664ac671d168bf53a1d250aabc9940103112fac1668cd3e3009d4b70fc4990bed56dffaf982e456745d1c8ee374ded351794be7712a923e73e68cc7aad96dee7be52d1dcbaa7ebb071b12eb89c503d6f7138b058488f5fd2c96ec331a57bb07df41fbda443b79ab897d7630469050100f4c380eeb31b67e621fec9f74d0654c979f1d3f4cea67813938eeb3d68282d0d17fee7590e473520ca9c3d59e9f16577b5a9c57a1aa9de23cbed5d579ee1b8c0d29e7e577537fb10d616909dac1c5f3eaf3bc2442cb7a9ce9e4b39e653d2bfb8b0dc993e188b75ae7bdef27cffb1e6fc98eda90584f60b6213a5a723c5b84c655f929a7cca9a909ba13201a74fd8ebdffe0bd7dcee39ac98b122d49c628f51847801747404580b5b532ccf1d15b292334aee66461a2c000010410403801e3451740c8d7f9cf7b9def2fdcb3beb9d88c588ff3bdc556241fc77edc4b8f63bd3fb170742cd4db9a633f1b8ef0139cc083f8af99f7407c33f25f751e88d7af4cf53f6bedabce8f339df739ffc967cffb24f93aef28d88ae4ebd8d837d301bac2506f65b5e1729f53997dbc8a84a7c0b34d03f6c13e6be6620bfbfd9e8230662e47852173bf1e73b117c0e5a830566e8f611fd8c53e83462a10df0207ae82cd487d9bf340dc56ae95c9fe8e9133315def99d09c59838969a8493754bf5a568fc13eaccf5cfbda84f7cda5b5b00ff6416774f4bdff6ef02eeb75bebd6c4839cfb2d15b3dad1bb03e87f5d8e764acec594c4cd7b35015887fcd3c8995f3c879eebbcb86c47a99c53684bb1c9614abec33878a410c62202595218618420919c880e39638c094adc8a74c6142a8fe27dffb2682088eabd2a388ad88165144130830622b8a4618e1448f23b6227ac4114f685c653d23a0fec7bdf78d04f7f21b89ad887b8904e779b57ec5c10a8f249248028a1d505b5184828aa20054a850f13c2908a084124a78de95012cb184945330c18494580a50652bf22a553c8f0a0234b11579134d641980134e48390326fcf3794f6c48d15bfe849455e4b0b215512b56ace001c55614a180424b8e28b6221a451434d098c7279ff539df5278f23ddb526c45de4bfb41fd7b9fb12a7b0be84ad7ac9c2b34f93595c90a5405e5a271d52b82c3e55edacf062c92607182d5032a78d0850c329a38c9f23ccffbba2c5a7bab87d15bde536fe9bc3bb10d616f79ec2defa3b774741ee75995dedec17694f3d15b5e8fb121792fa5557deb601bb261cff26a91313af65bba39d88678ee0497ebfd636fa15e095eef55de92f066fe84c632f27ee501f1166343d279f9dda5c3d886b09efb6e7a62d56e47d013267b7eb8ba92d59ba2932d9e1cbb6a30b6213dc24ce929b6a31bc47d674572606c479c55792bf536beb16c7cc3eaa6defb6243fa209c6d2d62b621dea7be9fb0e6c2f224cb9350b416efb1cfbc2a84bd5755dec21e284be77dbf7bbfc35bee65de45fb94608bd98cba4f598e621b92d9a032ba9a87df61b623f9363e87f5a94fc1a0e33eb2bcfa512934ae5e39c09b14a7e0388eb359c1afdc7872679594b29c8dcd77189b5fad603f9b07c0e3bc5fd982d84cb10501008e0a95bda513b50de9713bf6497d83c94205989d9d1d2ab6203b596ebcb0c2a60a2f706c74aab062a70b2c34de58ac542a259ffb540e2b95fad5e7e478d2935eea755eda2ff5380f04e6545eede454beac8a04de9def2e7054f6dbf99be75e67e7b9772e5b901d1b5b47ea1d8b2dc88df5d691facc71a099a0fe7f7fcf6033526d741ea97fcb708bd6ec83b9d094e2dd29f25ebe67bfa5cbd92f090eb82fc97bf91c00a47bb9e9e8ce8dfc9d9a24ad12bcaae754aaef281500eca77a9bc779f7b205516dc19b8d0a60bad0b88a93e472fe45e32dc77e4b37e7bdead52fc97bee65fddeb34af0eae47c96edbc4efde2d5595dd67fabebb1feebaec7fa8f5e4f3ece7bf693bf7a205067a72259e10c99ab04efcdcd037124f0de7c83d984f4bdf9950af6bbc1a9494af0de3cf7cec516e4c672ebf02f5b1095e5d6f1a56eea6daa17db90ec52f6f1c2c168a99d220c73749496aa5f9824578c6633ff42e3ea472fbd494af072cf7dc69d45d7a0b1682ebda5af681ab496b6a2abe8197496a6a2b1f4147da5a5e8281a8ab6d24fb413dd445769267a8956a2a9345427d148f4116d4417d144f49496410fd13168290d837e41bba0a3740b9a052d4443e915b40a3a05fda451d027e820faa9816827fd433bb50fdda47be8a666d23cf40ecdb4b4c4044a4a4082112411810e39288500044870f880073a7043d2c7011b36a0810cd480810b588086192a400119262081081c81c0031c60a4010c584011a4188e881829a0088621428210bd3074812400010710fae1c300413d8078ec28000106f0a343003e3d2eb490a315001670f0dcb0f5570000cbdbd1c9692db214d65a70cc3ea9b7516b6aac2a6f798bdbbc9bc294b8097c095c5221f611a088e1f404081e2751609e224765aec103218490aae07b104246eac79ea72b118f037d9a651b95600bdb8efc796e602ffd3c0e845995b7f8a96d224578a012c220c38b29505e3cd91124d4a9c22813461a625411a388a82eb804fd1fbd5f4b6ab1c7e73185c108fb880ff4c5cbdbab9bc5da2da17bcdbfe25f519bf3e1bcde5babdb7444144d52a2ee1783b4296e7f278689971bd4cef0bd9bcdea1d5dd6fb8b67f365411955ca9852c693329e7c8da806ec011a3d2013a6ca95ebc2e5304c3cc9da08955ff9076d1d2d5fbefc1ac9f5e87e7b298380e82affd0beb5d7fec8f77ba9c803953b056ef36ba4e438aea666e540f2bba6ce97a997f6a5981dbe5c035c16b3c31333aadc035c8e2293c695577ec73efcaa1cc86ba494dc0487ae8db34ddaa0265d8dc4a4c4dc7e4baeb44b59ee176b6a1298c3cc3dd2576e3f11203c40e3f61319807f74ade3674710fbc0be3f07ff50b58e1edd37fdefc6fd563677fb8c6a5e553456d2fec1ac83e6a5fd6aeea7ddde298a34967a0ef95bedd847be565575e53dfbc8effa476555ffa8611df26f5cf9d47e2eff53ddbed3464a46839271500e3a16b303d30d73660d2ea2704f5b3d4441427eff3287cd546314c3b0a4d4632daef6ed54d97359f63434414194c6268139e80371be34b33494d2e768531ce2eaa75d0ee241a7ca366a839a743454fbed397ae9c6bd5f8e6ef1d2509ad1ea659c4addb00f89cdee6ea22021a12d2d90b2fae1a4b8ee625810e5ba2fc105a6b07e9a049fa6b4540ab32aad75bdc57f6d4158b349600eec31abfa68bdc7fe1d08b3d87b58f7db2f824f29a4ddb4bb534e51e0b4f276b4c83073fd7b9aee7c7939bbd80634334aa9652f89feafa0fd22fafdaa1fba3ec25bd03dc36a2a45b3140d426d94ec435e96e1b311f661ad9337f3305bc8dcafc561ac18c35798f1b6cd654289df9911f6c1b7bbbb6537bd0d1bf65f49b3021e4419c3cc185d6eeca4f81edfff03bab2832e37075076a0054208bbac7ff4e5f75a07ec1ffd63fad1a7d33ae017899fc90ba4d32df8ad033e9097cebf63bdae18264df75b5d55142d8687353e1aee7cf851863badb777e726c41f0bf9cecebc634404066ff1e636a84937bf3b721963bcb326712246ef1ffefcb17fc4f86e93e28f71650c296e816e10f4c347c39530c84947af763f1bae8c376e42fa862b3d72d12ef964b8d2faf3fd6ee001e291add041174d0757bcccd3fdf954ef1d75461a194d123f7cee3164c67cb9592fb9fc6c778ae2e5f7cbf65b723f1992faf9cababa30fc19fed5004ae888f8cc7a9c69b7414e5d1fe1ad22de8aec56a8bf688196eb1fcf8072598ccb516668b9194d5093aed9e7fb9df65bf2459eeb91a9bf88f3e0b64d05e6904bda3b8c20a494c1c181e4540af3f4e4ca7ebafdf1e1f70fa0c88fc75c19a32d92f156610d0e04bb16a947bc2565a0c1a93b6a0bc40a794bbec63efc463a44175fc62e5655cbb7aada941a6af243d8182d97a37270453eeb72540ea05c1b86e243239d4d0273c48f9685fe3daf2fa5e36889780bbeaa47c2008b38100b19611f0f613fc922ebc84532f69acb5162a4208c35561e7ca11ddf431424f4b57a7e88828476445d343aa12dddd7bab0d53b78e6e54d29a98c90898c6d9922f08dc0009fc8fc18264b991bbfe11b8181c80ef84246602002994bc69f1254155d9fc43f6711bfcf8f6c84d43f7f0791034d7e95126c5d9f042d7b2ba983b4745fcf8533fbf15607344527847ee469c99e9f59bd217c79a6e884c4275385f6f1ac3cf80379b2cbbf239fa36ea0c6fd28fffccb5b9ce42fff7215ec1b5483cebbeddfaded284a09af092d971944510123e5a6ea97722de32a76f14ea6699077bee677de46aae9294bd9e05229ce6adee2bef356e72dee395503b7a394b5f1cc71df4dde13978a3737a9a8355397261b8fe358390cc431e951c679f834e7a9b7524f7362ceaf5e567ae776a4f3d15b3bac972c562452a47a9e372415c44b792a6fa5e0cd304daa52a967799f922c2f95a2a9aaa94055d079ec339c8af3d9e42e8e629e97b1581b0e0e4d0d0034aee6b03ef3bf51416bf6c155ec663c3b1e0b002b7cd59a7d78cf9ff9685cd51180263d1d9b108f5b5cd5d1345977d6606262ba613885c1147f884e5c9069828ba8274f4c4d4f7c786ac282c6d50e827dba3c797a6a7a7ac25579e29888da628d2e514bdca82d9ab823b4b09815acc162a040613d4e18512ececb274f4f7d042d46e8d21425260b9be194b82dc64a10f1a94bf4618a1a4db149837131ae082a4d4cb85dc414cccb1707ea342ea639a661617000e5da78f9d905707e05861430a06c2009041ace67222881b6fa82ca6d3265bc070f0171d417532ef64d8603f5c53e53ca4107112c1941244109b4661f4ab4661face7cf58d56fd64d5af70044fba04507e29ef9352d082de36c861b9b0aecac707656352965298063a3f3158834682a204ec35684610e9da6ac9fbce04302867a58b2400a582fa86086a5a12a39ac308115683b2c6f863298f9851b3d54811282250b0871a17c48c00596cc5817e06001520e2bdc102c4da0053b2c8fe7690013822b8715645862627e81c70271e399758527a3b8a009205ff60b60d00290c2dc13032bd85b18a20a19cc80618e2959d85b4988a082bd550416862e1831c5115718e640428a24b428d85b5035bc80042848b069e00533242801951a5e28e30c110e2b2f64a18117c828d9329005993681125a056618fa5fe2276658b2d13003d392a5252ab0c43ce4c40c65d03003d33643193b30c1a38ab6437e13355c249c3973860c33110e2670688019034d9b06ae99a62d035bccf46001276ab8659c3973860b33118e25703c6f4130e0021c1ac04203974c37d932800519667e66221c3e5c00c71315405af29ee555e286676960a60092d346031293d336c31626ef07cdabf3f236012bda8ef73b1588e1cc99332fdcf81dd6e77c4e4ea572e3790b4201206e3c0d606840e276b2cd0086b95fb8f1ac2a6fd64068ac3aaf0c37fe86656f010a4d268962e91db0248519330e58baa2713563e171d0e08712ba067056bf370be0781ccfdb05587816ec160e47dd52a730028b5604154464993203169ee818ba50050ada8aaf4c7a581a1a030d3065080e5bfeb1ff6a778c5c6786ec3b29d986ea2f0dd96a9d760c6961fd1633cc356c39733d5614d7b34868ce5c281a683a3d06ba803d8ebae33d53d61a8eba8301161ec74f49809929389e85e7cdc87566a83e10ef31d0002c582270fc8e671db034f43fe5852ca664f133e5859f07d02886aa65427366c869c7d03f6f1620c261b75cc13047922d49b8d0343d938b09a53d548b451214b054038dab927bef339ebfa1e50712ba1bcf9365dedb046efc8de74d069ee7b1577038b0b210a20b142d56600315b0b7d0c20db4b0e044c7de82171f27e864c5817cef33f92158baacbf423ef6ccb23b457ce6e6bc0e5feab23ea41fa8c4acd9e87ad4a11111000000900023160000180c0a87c482d16896a581646a0714800d84a642604e97ca835110c430082183103184100300218680ccd0945800604eda0f5bfcc54aec216df80b7f87e481962468721cfc2d9f79e88d715b883d95320f7440f14f2f04c0a7a615c9da56d6ca100e9a79dea29b0c6bf02055c4b84cb35fbbd0ffc452b08a7abce67a98d641ed3b7811d9e0334f053a286fcb8d7e84e70cb2f8cd28373e229712a1d470a0b954c4b430c911f0701ed4f938da4d0dd8ee94fb2b09af0f5d99d8d8b273a304e1aa01f6641d5348c9d7bf786a66cda5112d341eacb1310579535bba63834aba96f4b52b9832b8a9e0dd715d6eef2dcd652a7c53fa8d815a028be3d6b6585fd78fc4cae3c9f5562af73ba07ae77f0a1dcf1eafd7f0b869d4f026cb3c41e11358625d9d131ba0f3a44678c3a65f6bd4d7f69051ed7b56e67d0d4e6c86506926660ad5b851737b06024c32981d36187c2e63812a4686c020d9afb80cabcd53408bf944711389af769ed16c116afd0842e26b8e975d37482dfa14c40405f2931593b134a0220bfa2b34c25ef2aeab7dd8b3d4d6a7ea1f7a02b2a215b26291761eaf64bec920485eb85143fd21f51e14f0b903dce658f7306bf4034eda8b805bc48c97e2828f5da3069721971b73e0755000be67c95ef4df14f036a05cec4374b9d20a6945e5bd94c80adde089861f09ab964de13a3df29f5640a4422a97f899f1594450d498416af718dbce36e84997f9a49acdeb774f254653af1726528eeec58b45b70b0e8c0c9ada6e88dd3353692c87ef367743585cd11890858322c3e945a2c45ccb581857c061a9c794515ed017a7491c5a70456d23c6ca02392d22d0c40a1ab06a6ab8e3f4b761e543941cf41e5923066d58556cb9b525b718224ba6617ccda959f05b38141016e1e4e96031eef5dcb50725eb0bee63328e6250d01cadbd9e822ec1a78d08a6364c3b409f3dc9c14b7afdce0edda787bea11bdc02c547f6a08dade89c45bb98bdfbbe773d60d36c7e2359f7d7841c7ae3e13a274a87c6f4465008592c8e4acb051741acaf938ef03cdadea5f2ba7452bb5c1b9c90d391c6eeb033a1fabc3bd9793fcb1380b881e9803b7d4226562ab14a3ab9098fa14e832d4b7bb052050f11a618e891dac78f52f932c6988107df2b8ab9e66d3b0229766b0d7d4d230f27830108f013fc64a0b308db63d445f8704233669efbdf0153bb5d624256a52bbf67227a230a31a184cd27246b282f31b82fb89d5c4f8fd3cb6e30ad27351598b0e4915cd3876fc71da76cc33f1c123b8adf44cda0e859e6b1f7b27091cc79e760ff15b697ad02a457bc93c41a41e0107420d6e691d9255c01ce3e221eaf2c12bfc50b3dc6a35a78e9482f5b8cc0401993e553abb88d7221b1d2b8c93d814be657f8adfaaacc01f9ad009eccc2cd1cbe15612dcba047fd42d8e5b24356eb5ace781008c9d0ad9697a454797dd7448fbb469903f287f410b3162aa85069c18e779abdaad93fa7d4e7cd8a6fb035a3cb174b2b76375b88021da35b890a7f130b6cdab3bdb7c53accf209f098d157ea9ace5e7f6cdb09d4169ca908349c443780f7e73dbc147336efad53268e765fc33b3cdc7e79522e45274c71c557ed21265c4c0133d5c98f53fc05d524f5bacc49c259b06ca06fd8d6f86ad8a6b18457fb4d77d132de2851618e0c61462be35b543b9ec70a2353631315da34cceaa36b6d6d04a95fdc603660e23513f2f98efa158c47b85b70d5a65c165ea7fbeb348ac5ef592f30c1681b66cc9349a725b94a5076ec061d21476b55371330780da879cc7e993a52cf5e60dde10cd4e9d8b37121800d6af720e50b75546d426226d5ee494aacd1b8ba7d941b9a844870dcfd86060d379dee533ad9bf5c86e5ad7daccbc040db0e0d5adf7f41b4ff1b8d7b201424bfdd4b2424d4e38ecd2e13038764788b632a749372361fc5a78bc97a336325272f319fedd96a6d62836ff4b8aa466d83ad3c0ba58d5ff614a1b1b26b2038306479f1c0bdc0202b8806d232b25b804dcd33f7f4de463104ad687fe5dfc6f0697b4d15ddb0f8d9abd666a4659c8213c1381a4a364a21a9a4ba090d07515af80a6353c4bc798f2b396d3fc95b26e373dd0d47edb9df66b66c25c855ce297556a1aeb1ecf17698d1980561b2c3cabe9ca792ae5134f8d61046963ea2f7f4bd4563d8b76b74c0ae7056b436a91b911b7811ffd12df74fb6d7529845ab87325eba6ba423bba718dc07bb27626e772141c384e7ee182b8642276d0d68d158d0b90b70ecaa9dd379c47ebdb54950731366b306519db32cc43383f338f15d28df355405c3d7e8ddf434d9619226f43b44b0a40809783bc68901b5ccbd07c24900a14bc19575ad102598ea63d106479209b7a059ecc111861d766c3fce7f684005ce835a5a38abb1730c40197182b2e040926515753b093873c2ad59865cb6c88053cd875986549f724175324756ae9a64a9ba2615025866e5fe1157e9a1acf10b27033b25b08363c9fd4781287db4c26b8917c3a4e8ce6cd69d157767c488e656f8cb710ac90f700bbd36390f4aa0d85520f9486955abf83457e1542ec81cb82f747a7fe8da260885d604e9b7b82f06b9a6a8f871bbc690ae7d7fff4242e88e5c27672d4b26064c065e9d29d6add537b6fce656874c9ed958a7ccb2b42a12b6b078872fecbcfe8da632a11b5a38e209801c710898fac9ad7180648670a5eb0ed30196ed9b835266cc234a38afa9b15527c8229306fc0e82e83c9ac8e02309ca17f6798936d45bafeebefe8c37c54d0af813e0fb111ab7fad913c8a86c1d67b5615d7868397a085a36419c5d500d9055d74994cec36720e36cd50eb93ad4779fcd0ce015c543c330665d045ee6dc5fc504280db295b5e1098685b44e5ed7c3d4c6415d23dcdb96812cc6e7c53ccab446448bcf6fd5452958dea165a757b38c3ba4d109792180b982a309ecbbd2eed1f95f974a53908a3e864aa70c17ad6c3d54eadaf0c9e24309db7ffd71cf55c2d2c153387c7bb780f596f0d4f245750eb04a5b42c3caaa508b789de296c4fbcc13df50bef662323652533153142976570ee5134304fa4e81756ee70839fd5c6948d4710e724f2310049c78d15daa058a433a94e45894f17e001632765b763cf2c332834cd7ad8f42527260f6235c745335178d7dce0a157387784692035ba6aa3b1d0eb69045b343a0462294a5e157b93b2e5c35dd8c3927bee842c22b81c0b92538f522df2114bd57d3e5a845ac15711ac7035a355b407b0716f813273d716029da5738f09d36f312d39da643db6d1a2a564097ae8d3d73ce67caa9131f93b0b74e12278dac4b169a002391955ee4c9a21df2866170a550512bab367d11c12a22062243c5342c1932b1780b4f8303107547c6475118aed4c745e52bd669cf1630f84c562d96384b1b5c06ccc05e5dd52b8a915c7422d146df06de544f25df85ada2d9e197b2e221a9894c2e2de17d18d4eb417ddf94c3fd470eb403f3f01ea5590a0b1086673332142ee6333d01c3e89cb3bdf2dc5461a400efd81e2c9772671688de259f548f319c4df852ab298bfd20f490d17e5aecf636d8825812e514f545580b4db457ed810d7b9e46e935544eecfa5cb75b2cebe3c43461e5653b48d598e67984133b656b022bc2f76a43ced7a41950445ddfe2e237421435d1471a968e9439ba47235f89e068199aa9b186b9a3abbdad3832e97d586a33dc5b652480881921c84dac78143bdd1c37d29d636445d1a08d2d4c6a34b07453c1c279c716930af5f5a38f0cff820a8b4e4c4160a9d0427ace69828dca339890a28cf28156ab811abe7c4b4db2dbf9b7c590c0d16dd95adea2edab071c8bb6f3d25c8b4293a0c7b0765d7bb0e60f38512c4e80a8b2b92b02462d69395425c2054b494c82e0b90ce82ab6667ec3ea4e334b81e305206bf60ef5690218d639e9aed46893e41044f69a0b66f5f9689d06de5d7ef3767752a6f51744417fb17832ea42afa80ae3ab2733e8572cd9ab7f90e74aba23c0fbf75888ca7f896985969da55956b61bda0d6a7910219c568a6bde0bf0f82529cc2520b496f2f33d7b2228cfd2e4e31337cd9ca2ac29a5b7116c6e7bb71bda5b048cc64a71e3e049520dd008cc420a735d67c07ef1431a6a5344829b2436b6de10ba008bb5a8a0af2f5fddc2563baf57b5feed8490f65eec2872060b54855cde0a1275baf8cb9ab843809b1cbcc5f3bd73d0058cdf12d9f92e7dc66f179df6081f036485ea61ac12c37b49da2e7572691dc8d2d2971ae23f1405b77eb3c547d6123fea4ec719ef27f7a27a14280226e7a098065c9d19eb9e9757a6e24266bec7e7ec22cf3faa5232267c262353f30ee8c7b0e34f62351744af8f74bfcdbc70bd7215dd5092cef9d38edf3c5c75e805f9c1a80fd4a217fd8addd7143a901e393380f83de14b014a9d62bfd64ff846d6a524b80755a4bce43421c38df773e30255602b427dbf1639f2932b614d8964e2de9792f2edbcdbb457995c88e9c2f08da1b99bfe6c86f48e043ee1866745d3b6cf945665d5eef619b58882b4b9de1e96eefc56818076cdbc9502123c0b45e305337aa8661ecbecd49189b55349bd972f1995e93bcc465a661c76c57e8ed206ad1d5a6523e4b46f2ba7fbe1cf9d9cb9f2108a5e6fd0de11160fe06496f17447a34505a55153293e5de82a682966c2b54e1bb58cb8145a450c0ab4dfcef33c54e9304668c2d0819166968f30ea66584e07a27b55bf4849173c2c1bf89c1fa9aa8485a381f3320ecbc28646fae696fb7d335fd0b81b4dcf558688b34711614196b372309bea7931024df4b0db0c03b335227f134f308bc0868744464caf44da9c6ed04b11d0090c3757f97fab193a3157afc2431cb310b792ad7192e8027ce3826418405fc8c39ae92e2725afc523df92d72493f7f50b33e5227c3ce2840f7c2b7c2d8ae8f76e6c52bd9c28fc368e927971739c184fd0f6bf1abe99e62a4da0c8c6d75205f1d070f8d4b3a4c5eaf25027273e7c561d08818e5a55bfca88bc11e27bed241a8d253be2e3da85c76f721033ce5dcb8bc3da9315ef180a7740ab5f61e194f313291888802f0fad37f97cc61cdf76b49f2bf4d696604bdd946126365341b7a8851384e507292b4be6dde9f10de24a5d73eb4eb6f5ac482c1338eb773451324252155e6bbcf9dd61f3c6a93814b962452dad9b725879405eec1778ef65141aea159f13d22979834cdb1467085f15bb60af06d998a3440ead9430cc0e224c2f68ae37b666d01b3f115838db00d7ac4bce47f6e6b0bd844605fee09cc5c6319e62bd38dec49de89f1eb15497c0287d39c4f9d5e08ad6c43932413fab2b78afc6007fd0daac5a16aeb8c70dc7b2714abc0a88db2f5212aa6ecda39e7bc4f6a420d801ee1d035e78cf7879e59fd595af1da0516b84e0c3a56e999940c8ac14fd91a1d9d168d60bbce711a0cff681e76ce316a7ca56bc990cf102c3f540c5725fbe8974274fd11f954619c07c43fa39a0c97f74cfea64577e8fe4b3576275f9726118ed798791d9bed23c2ec41e86006bf1c1e5483f9befc1817e7ad2b206516326fb2227c3cc731b22623259086e9f845b3c1ef45afb49699687a679b884a029cf81f3d2795c479a09f0372560f41d173a256b4a8b964b892c5953cf81797f820b47aa6756061607aa3fe8752c798e9dfd5da49288e7a81bef431538daa1627c38b1f669297a1cec503506b5346c8d5ef46913306ae4451956bc9de28d979b81b39397a624a1acce97c607a4b28e961ca62e9109a7d2438a2beb04f04496bce391604ec556b04269698e79daadf308b84f67b2f7128e0a01b665ceb1778b1860f0459029fa7c467b4c9e51a4aa22e82240aaa965b2740e82907403aa4f1efbb34387dbe7539d97cff1014a8ff39d22b106997e39bed9294b4ab2f7a777ce2e24a0301f2966678ffc79b9b64f2f9521728029d3fa5676d4748f2afd3153319e0be02fcc11634981a929fab7d0f88b7d9251091c0df3ea009ee426603f3e19da08298cc1f969b539df2a1933600fba155fa869ceb9e92bfd1cbcf90eae217593e59a10a8f044a64fd70229a40d78c5fb4fc04e2d1c25f14dff5aa915ce251bcf4a26635a710f627d8f55193bb1e25da01d19a9d4009be86914d1d3251171a2127402a5c04a74b61efa8e744c2e29091382a31e183815c12cb0986da208ed6d1861c8bfc79f64a40b8d68325f4ebd4ada95a385ca299e5da47e47b43f8185d45524009fa4365fad26c960527cda39cba8ee114d4bc65fbf3868e166ab9c227b10c2049f787bedf172d5305ba86e577ab2b714cdb170a3a29a9912f36f83d93113c9f39436ab243e699b02757b4ba08b25998788b411e364ac427dd415d057c807b80b7cb9b0e503255a1c2ada4010f31fd9e7f305e604d3e4b520ce62269bf22c411c3e7c8d71b8cde5dfcaf373ffb656b8360eac7072d8fe0a7dc1f17d0a3ec1f8f617117b1d009591a02f49a4904f3592fc267aa19ef508c7464956ae64cfadceebc886bae66b150ab88ebb0301868f6ebdcda784d129c64fb65f8cafd3196dc9d38870a0d615c9906c79cc58c932b77e4d1811e51ed0735e885825c694e3fd827858a55450a0e83edf5a5f719364f13620e2ffccea140094ce7ecd618f5f1bc7f0954e9f265264ad3638a21bed60c62ab4174ab0eee89fc2cf8245d98c829010ba8fbf1bc19044650e1139d6105647ef90e8466f6cee08df0f20d418f4bb5e5dc934becf5f11ee65fd5ff025bafafe28a80756cde532f71f8c910946ff8e82e334671f8f72e53971c926303eb7621c33fc5dc7d960f2885e6fea5a76e0ba7f31f40b84b15beda71a1a5834a71e7a65664490afb8240ba351a5ddcd06bc201458aad4a202f60c38139f9307c4ca70dd9380b7cb9c6b1261dc68829541a21db2ee4b2ed11e307477e521faed812724dc1253318f7a4412e99d95e6a3531006b625c5828287d68631374868d900bd1369bec3d224a043f2d2d9a8ad50ed645c956a42cb2126229d1a7ba56491db1086c1317224a91642d3cbdaf132eb860d34a3f7e5504329754151a518056a412bfffb209239462c1705a39cc46e59d10583a5f37b0c199c27c6e5fc8b0f86ce5f3b24e2edf7a16d267295cea18bdf3e0712c567b22b5d9de110e42f00cbbd4d6224f1680892e05f3b45182b93e9b028e182412a7d7f6fec59a074232776fe09dd31041817e8be2aad68e353146f84ccec1febe4a332ee5dbab2d0381144c91688539967ad134928860efa1c39be2fa47c6c57b3291a946f45ece235b6562f8e4e99a66b1e4d1dbb29eba504850b4f8d8bfaa1ad4c556e2d40d9a5f74276cdddfbd5af01123a451d89e55bacd880f8a1b2f596edd5e2a2dc04e6654f83fe81c7304607b4d674eef07b4588622ff59e89006912a6435cedef684e11f92bafef7b99e9bf33a64086f03dcbf64e861712fc38b759dcb58a2a13a902269b75e9031f6cf18de034cd55f2acb1f3be6ce49a4b6aeb78aa10ebe8e67f025a23ca248ff401f7690f15a854f15e4f2b2a6329e374857614c6531db1c6983173e8d04c0e54278addd08ecc38eaf85ca5358af194e2b84a4b54e3520571534bdc2fb513bd39fb6374c908175fa36f467c0ab5ab837d8a27a366067a5e3d4ff0397ff211b5502a582ca9b1b15bf8bd4ad359f4a81abfb8c0518c9f8744cf12409ef436f498cb698dafae8acf2d1e8d5a4901ed99dad4c52a05d2b5e9d11e60b02e62844de094fccbf05789aaf67ce7a2926b3ea72f935c72a840e6b727665815558b76dcccfdff5359746a5de5975067e08d50f7127d60bc25869cd26c086e9765b0516c3cb0c163d57ba9260115fb6bf4888a0aa183d1c78ac7aa73ba7945431a5d8799884927c3e3ecfea975f37f38d8b96165e64928fbaf90e38a6b5b244ff8f8ff3e4f37321574e3e7e0b6dd25be631ed5694868acaf3c4fc3683e6da46f8b4d80f360056429341d3822d7500cc9ac50390c1972ca3be064d0842357db349a5683d9df96bc6d0862249c8b5f58bef03ae4797f98d1eea647749d2d83f5cb6756f358e0db741122d14f25e0d8f65b81d641fda502e7b40bd372d038b5ca654f296117a98e94e399460a4fe3af39dbfeb5442cfd2065838288acf1e083ecdbc242772a093b1f16b202895b18dd7ce8a4ade55fb0a5987f3dd348da288a0c70f63d8410f22ddfdbfde91ef58b528ac33cc55b1b78f411657bf24609d18b2b84b0d819ae3720135e6f667576459672388f3bdb64afa71663dadeb24e2bfcb9c4c14726403cf13d0cb4665c0f3fc29933656ab64dcb00244beb0003574c3ded45f08013a9e56a4dcebb85bb89aa99aee749d5759daead9fb1af6b39f2c3ece8c2a96b1b8be8e2501166814f384d1cf870e5e70b254da5912489ed4defc40e853fa40392e041e2dc4e137ae502cd1f789f6090452ef77f74b0c694a2692af670e2ad1874fa9335390890669a184d645287c3bd4b746c52822f2f7e6dd8a7703956e916c96aee363d069e55aa5416ce4b67fa3cf531ae0c6e38664429498695f0b563ed0b5c221a379f44f39ec65c046189285029e81cab6eb0dff892119ef3543d34347abbe57d53226d78c9cf879007c53109ff8cc4b2522f6ffe11b0d1422fc62ddf8665fecff2eaa7b1c08a583e8b97aab6bd5d7c8b7cc6007fa84d49103da1403335e0c7107d0c1aa224cec2cd529a80cfcd433892470c15065a9284af130b4f8008ad43eb7b3cb0844d509f0544bd2b053eeb99d12755a891bd879b15ceb27f2f3756bf55c8fb4a8da712cb073226dc42cdadda2403b0b41bf429e29a09d3b2753cfc171add4d6bace9252e96fafd10ee02e605777438ec3131a9ee84397ac582c3d24d8a48b01f5fd90878abb5a116d4e506f6d034eea6dc306fd79a2e04a19b3f58522e25962cfef642592f498ee0c6d2ed715584270aef3cfbeeaa535762f0394bb1fb47b138b040d3d3a6a8a16073660253315e35c4858051567a72b3d0cad784252da217821c0b904009b1264c0e88c231cbbead24f185308dbec3b5b109c5ea857baf576be0dbed6ca30828e546e3bf39d83f8cd914d0e0fd7b78e3c8b0dc9c2c442744f5267e4c2347b86badcc79af9d4beb1eaed66eb0ca7ba145417e4726c75ecaf2dadcc468157c216b3392780c5917f01a9e62e8626a12a6086b34cda3987ea2e935ac290ebd79b3e70a95d6e08ca7a408d75a6a4e0dd79967431691171ced7e4d94a159768986320f7d8d0f264ed16968e2c8a5c134a348d10bddca325200924385cd6ca542335b274a8737a425d3dc03e67b0cf9a30f98f80861ae41357252b2d9067d10df4b9e7d793e96939d795a1f6c5641a5de283605321bd8c53527914af39a96f06927bfe5b0532bedf9ba0b382620b12855e150a7828d316434586f010a340bfe0d39784e4ba390d9d8bd49986c589e3f99186fe80172571cff874068d7b6b8ac408591cff401b9bda8f19396bb661be7b69ed5dbb9fc773f547a6b425e31714272002ac7a845b68f08de8e77496ebc3158fa41c5315ef9ff9c65c603254625512eec9c4fd3c882ab8203328172ebdf5020953ec7ac7af0034913746814e769196c697e5611b98914da56641c102e1b2787ebc7c6ddf0b06a6e79ca8a28933b6ce732b951db5fc50d6bcfa2486cc4cab0d5cf60452c5c0c6b7f2233834a94cce33495617a9cef8335ae6de844ecbfa63804f6ad9086b8abf01e1f1f7eb0eed34116ee74642a9ad646906a2c110e4b3e61a0467a035bfc37574610fe9fb5dc99485697e7cb2cfff6985d84da6149e9541c2706697ee7588b39948fa51da5a66e3e8e94696d2da0d1741639b34a24a65e6e96da105a52208793b93150920d23c03dd7540c049ee52709eb2d2ed5053c29d46b1c1e79837d9e38d8de050022a631dc2d4f8fccf0e881db1107e1f326c19f2a7f1027ccd4c2063bd2ce36b768f0059872f22aa297b6bec6f4e761dfd5b13edb7c9701d4c1f987e1ddd9539c841586d86f4236fa49e07b4b1577485cb24857d4083d81db38faada34f3d03fb7951468766b938946c895ecfa7c5362e2fdbdd83b1a1559ae459e7756dcef647fb83969b5d93fd40e5a788a371b18f98f57af6d7aceec7b366192fd2a54dee039c0670985f3296204db14b36f886bd27fb5676c00b8d9d955a24072cd09cb29ff213e0a5c0e58b53825405ae09f669a480b05a25ead88f822907896be991e417d3a2aee5b50d83fa9044c94af766625b1b8ce4c81d44e0f50384de10b96262286ad5e253d6756cac9482b996fff800e84d1100c55ac65e8ff0b460e6a5e376414e65ff3900a5ab328cc994e38d8bbd585d6a6aebd02f464ff9fdc42c83241259c83733533682784f28579156fd11fd599124108546fa5560957cb65ad772518efbd0c5ae2052fb3ffe7ad939164eba4e9d90062aa467bf65a2a4f891e2419dfa5b360291c0cd71e06b927248bbed0dcd71b2e73b3e1449266099dc1689d077c2015866c4114dff6a0898e50faad21175b5456a3b111d24737b5a882f694340b2d3cf6a074e1de1c4aecd3ad4e3ad70ecf060730370bc2d06f2b9cafb6e59da329e442bf0d5dd69411e4c9bf49cbf78acaebd2be6eddc07a00fb6505c38ecf285ce85e048b619d837204a3c8c623b25ea812c1788bccb5a1ce2c4288d96dae7b401471e40106ece93cad7f1e016a9538da129855fca827b53e2e8131a85207d60fa1a7420a191805bd351828fb167c62c86c1f42b9022b89ed6d920c24483f4debb3b813b06eb843065c5cba0ee449c1077be9a9b13a531332f1f0bd817a919496ee676c1f5369ab0aade228aade4e22146d7005945794dd567587263e3f7df386ee3209db85b5dad6062a69acfdbac3f33d7dcddbcfb85857ac06e97fe9ed58df298969ebb35e78923ffb890b719deb59e7145387d73819aa769c813b68bdab5c4bf5e905e2e057ec985a8923daa28913d2b277c7774ad78f5a8a8f9c084c08ae17b4cf96783659f545481dc2718d2271a60ee7bb6e16ed8c94bad602e02dda35a09b18e36b00a5f2766cd4bfe9d5b65fc07cd70f1dc67b9b95ed019818ed24ecb04c5d724231a7efb4dfc5d0e6afc7a1eaa3cad84e9997d8cdb28ecb4331eab343bbb5d85717511a570054a778bcb18b0a7e172bf47fe5535e4da78e3c39ef30248f75960a535430c630445bffd8a325c820c36e123602509563cdcb457aa614e2c2fb3a73b6da1b06a7da61285b37d162151c802c8e72ad2a182c902b88e42ac9046229c9927e7668095e1430099ff38456935e282b8d84477b520321443e456ca7c365171f7035620e826c710e24605a9c4095d8af9549806c423121ee306f77acdf9d5cd972818376ec397cc11e54c7540b19a4641705c6a0f4ca1e833796bb2be9ef6389bb04f59f8a01f2e36efc0cc0a6e4f973559f6d910032b6cd557ebab2ae0540bf2a5fe8111d681f3d7d5511dc73fc9a56b3c3ece8951507f182b8722757b57362ff82fc92050d075c526a639ea31ded5f8687530ebd8073f1046069157f421c976433bc6cd257394064f09a07090c31ae0c3809b65278dc53a2f09d42214a468e7200db4602510fc5b058e23ea87ddf12ff4819dc2f10d3200430a96ad95c013a2258ea089fe64023c51e312f0ce9f603eb41bf21953d694098b9e8470ccd16554260e82e958c6bed4c0e6d945cdbf5d9ed697bd8535de3cf314fe30b8cc9c3a2a3a57113019b0a69bcf12f43c521371f4d08062e16a12bdbb20ca6e077582f6ec1fafd097f2e8ac6000b467fce78b200aa12f1dd937cb7d9d99baf3361579f57606147a06e6657a699ee78355cf17f02b97054b9236652a30a28350577fc7079f784c172ad074a6ea7a8d07f4d6464e2c476381e01d34e432907c101b667ab874c4dee4864ab521c50bcd4d148edd12e111b2a39a4ba37750abb5b3383d86ece4d0b50511192f3419270d9b8713326790137f977d766bb2a41313d8d801736cd23e862e84a0ae8acf4c84de4f0760e9c725bd45dd8c49171646a6309d4c73a40badffd623207eebb679685b625569812d6d176cf9d928c3a5a93345ee9c9240e77da88a6a2dc6a00069f5e4a7a8fba4a9eee5007fb8d6a40d0a390fe2314ab98ca8280dd705c3bcbe49bb4366285ee80c27ca023b39834e6237f5882c9c380d034bac15ff9d1874f2de4b1cc1944a79e947670b58eb4421a7e2408b7a06390fdf3861d4dbe8f5c410d74085f4b135ec3ab7bc770c3a40e865dbed1653e570644450900ddaebeac7e10bcac25db522303d73dc50d0b0dce7fd9f0cb8c619310c5e8997b61cc0fdc094741f278108c71158ee7c631d4493a78607615e79d6e5d15369adb69c071907f2191d39d507052098c435a8e0e421dff060d23f88ed49c5018aec10e604b918d2c246e524b452790b44456bcd0d1a5170eb1375c4c2d54dd60f83f6399ab0a852cff024789c7860b8f252d41a426fe27fef3c589c4cb5a63772401e38e9dbb4ecd47390350a6805590d4581b34a018ec3d4a9a5c3ae2f94f696333c18401098130e66b471ddd10c3085ceff00b385dc5523e369305b35187eb557ddfa6ef961d71d612b5218ce66dcedc57cb633cad4d1059c1c8196572877d8c451716ef63d26383729428f832eb4c5b9b42f0a7a1c1c51db81c44a1b2543425e618797efc12fa049640a1ef43814c0e11cdd01e4d1d0e7e77040a7229cce1f4c27bebbf1a8cc002ec4ec909b1d38a8996f94ade715d6c60c6845008f0d80b5327eb218ff51f4d116dbd0f238d0931a3d652b45ed3a561f3af5fc110a5d1e07a432c8bb29bec2727504866bf83013098a6ff533ca579810caa73e5bc741919157a05997baf1734115507d06c5d21e075627c6a297bc8ff037f4858f83968f8dce347734d52074a440435ef6a22f1a2d1b185991d914d7e34003a3df23127f85957fc41e070b5af37fda9ee98a8ac9de270a0863d270989bdfa9b7ac38451a4f8099d3a67f85759b5f75eba01567e0ffc12a7f450f4b8f83c4cff240b09aff0ac36af65c866cc001d8c4963a8a0a6ecae37012efb9b56d6a61c83b9d1a58580fd8edbe2e20ca213789da8285cd94fa18b1ba815ed17f440ce492838589041ca8b66c248f83bd48dbfaf2afd8acf310c239521ad7f463ac6646948a19a756bd4c0e0140958a2d9ec00c55a8a7b3da8766d1bdf892ef95a6803c12a84bfe5debe8a217660678dc3636835e4b25642e2f7517364eef03a84927c406d4ba4dffbe404d06f18e01395956eb8db5bb941386cc62bb27769fe8d617040602cfad8eec2e39a3ae0c1c4a0fb9137792f9364618bd377ef266b2f7c174f5813ebee22e9ecccdced1adfeff3274a3b75eb5d0e994092c3a190111e67d39236f79d2193afd7d5f2a2cdad2f18cbaa83b1d428df3a98533a994c19a692d34d5488aa178d13f7865f8ae05c0e11838e64d58edd6d8109a9e2e973111153a6c9e5b10531f0c7b59eaf1bc6a159450b76ba601f6916cae30d4504c540d4866cacd6138acd493fa3d5a5cd9b7f3414a9e4eb480971c615ec825c66b9c5cde6138b2fe862e2d280a5dfcbd7f2102e976ff35d42a7c9a9ffbfb78e84ac06a6c1a960436022e8c3bd3e4eaec7b70f6b0376735c27df39e50fc34671ec1119ef6910daa5b60041c047a79a39c4d8a018b621e147705dde1b56893015024315101b7ad2b7afd89f6ec163dbb997581958f933f023c2596c756a39003c1f5f4c0c8ec96317b285b90c510b617c3d424e4e7754bab9c48876fa7c50d85a54ac4d402f32e96b2abcaf5a3df832e742d5a83fd57ace667b20c1a86cbbbe22fdb4449d98396e4938dccad95314df50a8383e08f03cca5afb7c624f28607b5de7c521206a913752f70f223370cab354f2f37354b7e37cc29e4047a860678a9bf47ea55a66c732ab8d36bc9164d37be3d30155221061ac4a4109076074c21b299755d8b1739519fb58d3f9f29292fd750e0f651b5ea96e102eaff5fe14a9f75184cefb089358b5bade974f4a9a1f00a4bc8ce42889e489796a48ff373a6c36f9cb68688b07e6530007c6f474e57343a7a5ee2a9c0e728ec79e444759a308ef82981d7410c30e8e5d1e66a1a118551fc42de42c428bdefdde316dc69f66dabd647fc4391586eb15c15aee3485a3401212de606e933151bf4338ea3eb7d957ce26260ec1a632482875afb8506d78187c76d0825d18195f3fe2099c1f2e9feb208cf85946862cbc93df5b554f87bf6b397b28f2710c8a27f83e2dd4f99faae43007b2c239c8a1a0aa5d477ed8d9f2ba477e1ce00fbaea15d3c1aa9b7b84bcf3ec24451b1ef9a7cecd9ef5b9abda8a483c810a74bc3cbb603fd2e7cd8955a8a0c5af3498dd6f997fbc9a1f87f51c2094191e08d2932417fb8c6b72d489f510a14e75f93ec9eecb11d119d36aa188b517621480cc68498757d499c6ea110889a9256f2a966ade2a14f64e640e3c3c435bc5d49ee416b1a1207c06dc0c616247bbd01cbba595af0c89a8caf601cff6eff38ff43ba674adf26e80ad8891290ddccf7c92f8268aa61cefdae2adee544c92c05d426ebec8ca1bdf0b6d6ff538c702db0b737079bc05a77003f4f703b1b4979bb4bfa65649b893e8149b6444b04d5c605e48f35d9eb54fd91a7f4698f1d86260a2fb2f72b49e0d2498d5e105c0b562ae806102e61318f8eae1c44f6f483b3ff57de1a25d0027aee646670b5a0c2018328a821b2587db28b950b1dd1d10c9c09f16d2e60086830e68dc2d01e732a63aadb7dcbb9baa02db8f3ef2941d622cbca2661891eaa42be78f8a69456786a22cadf0278d0f4d7b950ed172a70e4af1297e58fc6b748398c9cdfb28946af62c8abf5aa3d1a2ec09639ca4818fe898e8cd9bc63b30a1ade717d10b03cb8e6e12f70b57ed894a17f18ee176283d4543038e10f5b5d5d40991b85f3db6ab06032aa6c87788de4bc855ea054ed22c84d4d865d41d455b297a791412ecc9525d982997809f93ac1e965b5e0424cf02bed1b00242ee644ee17ca03b13d4b35f47304bc717657a4594180f626d49f3547e1e70b773132b48c6e00aa423a3a0e7fccd5cfae9502c21c0ea3fad5c14c7b1394540a06458e700ebef66c86b09bc39512227c0ace80ad31eae8490d84307bd652f4ff6a3dce13e9a7102a4799e73a9f7a29686cc1581e2fd15700b1a4547dc1a35746e86648508083aaeab0c0ce1eda12703ab20519d94706a73bc3af029a020a08e585fe909230e323051452803241cf940e2d40c1cdeb58a388cf693cca04a23ff7acd31ac3a94307d288acc443512e0bf8c8ff41812ea0f49e214ba78217661f1bf739c965608689dae1fed2151ee286c1a4002411f499306f65b4a2caa480c89158a4f9472a5a0f5d42bcb89dc3eb5425474ba70109de8480b87211703b887bb9a3a900e129a9c5d1f15e38d2f9de0863b170458157a00dd21953ccff29204abb7f3e603c3b3a807cea8ac166af6f701abf24281d0f71e579a2e2ff4f17cb56aa4fb72201b39a773aadb434c8b8f4c1070703d187eff2b93052447e4d802bbbc2c66180a8e85b306b50499829b0e4405fee9ec8dc3c9ab751ac845d68b8d02652c0006eb4d17e369aed0f4adacd88b4351177ae1dc5d7c6d8b68eb85110089f6a4e07fec68d4a49b164a994d8e6cbe12a0c88b5004875c88dfe1f6184029fc98cce863a7f8013df2c01f62d8f7bf837443ff8e11154a6566f0b90f2ee8b3207b095cce97b595419a620f833ec6be910a206442cbd7d1b451ac88eda8df6dee0122c9b6f2d43a4c7e82e056232cedde8b4795b6939c848b2d817a10f115fc9fa4d79c637b8e93d2c0ed509a29c71315fcdc18d9b19b54222d4cfb8d06140807290a636941fd3075e8158e35eaf328439b4ffe885ec035854471e5ce84f437633a5cd56e0d014f2460dbc864a1563d7b459c731f67b04984a7965a8487ba3f43f9d7c689147ba3f9c845e26ee8d8a10344aaddd21d02441556d4e7a0106b43a992a0039ead253f22625e48aea44731bbd103e8181f89e5a92c0dc2e86d1b7c41d0c4837dab327cbf5f20b533adf46d19b86ffbbd1b1e67a0f69f46ef4a582db9ecd8186a475f3df1bbd1fed56fe249680314d400047a178392440e2663110dfe3fa81a896f09d971482fbbcc051e2861417285cf5e4383a3a4b78aef836844360e64ee1e86da43bec15c169b88b85c0260b6286f158ad4baaa35fdc150d2b63da27125438dacde828ceb34cfe60fe469907c408c384e7a8af0ab28e90c0a54685180b47abd5eadcbf851f4ac670eccdc68d2b6382d2610fd78dcbd122f7b88b99c7dee75b60e00191a6ab2ef43299972638327b447668f6c6d290ed7068e4680c83f149e6fe60dd4dc50034e8e5e82aeee2daf47214d76a8ee246c64d42be8bab1d9ba32b92364ef4511a111ae6183bcd1c0da2f211395fce4c040287409453b91d6ef6c133cd0e66452d9d18c70aec654b5bcedcc247bd9984a2d981662fc11616850fd4a51dd95e6f5a8b0335967d2653e8b728079016430ec7818c41ca03c01fc0e15022544560a342ffb7a228de2a83cfa90b35249c6910ad126ff56a3f383b5b57e936677955c575fc271776815d56becb2ef72d8b9e972be645f68d5783a78d908cb4aaca2831050978d7c28985aeec686c1302603c6aaf408e689293159d1bdea43698182c2ec73df674e5624894e745c900492bb8378cd472cb4b8e4cc4d8d47ab7d578c4df855713f24e1da0e1c18e30b1708e288218b7aa1e3217d1997dfc088dc0ab747a98e4ddf836a68f58d3b99d757ce0dd7ba113bc3274440f5d98a2a91f6fe7f02fc6a9b209466013da26dae1cd6a8b3a9a64acea2f8953203769f1810445df37f8df8ae140c0854695097a77d058f404b9a94d4ff57f269379948ae194ee59ae0f765b79bc45810c0ad3ebf221adbcee523acee67422a4f9f631f8ab931e8cf4b7ae98a875851c4de9c310fc384e7de0b63cadfbc40161d2a75b0db45fcf04eb734e4c057b3c6a42f95eaee4ec32573cf0924ee9dba4ef1e1a42951a17a6efec16a3d6eeabc9760b90b29806107ad2014d092281698ac3c4cacca1b128fda22d9060810ce6db927bf53f46ab26ec2916142e7ce5b84a093a13b634a8522aa5d3d3de3a4a4568056da1d99ea29a82fba548485526b3d6b8db66f6459a6db5b4bcbc86be74c2b218a0cc3f0454231a97a80553e11ef9a17843b4dfd1daaa1d5cc9799df541234ee8cc6f1150d62ad051bc0c8083a82b52c6a61e85bfdf88d664a0fff92f59dde889730f15c15a2910f1ba831415a732015f5a11034fd021b15dd98c51700b185c01258e3a5949e9f0b17dd36e0b7026f8d26d0165ac2c15c4d53581ef54846d0372259f3197da10c9298cf724d1cbeb08430d15437c88d951a2e16d4062e93ebd6c34f4840bf0fda888497c553736872b4d680c52abb329099826d3c3e9d3b333bbeb25675b95e1062664ff61a1e113ca741b1acf105aaeaa04c99be9c94c80e421b99ae0fb26133e1cb265e63aabac07533713417b4056274e543a48a50656247a7e83e8deb067afef38450abd3885b8192f0ce13714daa8f23ee58681189b9a18492931f7ed3e0ed54b05948589716ed8dc8f0f53e06ab5804719d01134ebf2f8690e4c237d5fdc833612dbd7639b8cf78841c141329908aa7f3100084e444e0ef6a75149e978579ae5eab5e708b18df18a4e162b70ecc21bf8cb472e429f83ec63e8d8f47ee3bf6914dbec365d7af564a0b71f386d592b037230ce7e37ae85073aa01e419b596dc5f71d79295959efc93716789ba6e2776e1fc725684fde9702b17f7c1183df17b2da671583e6ef8f28700b06345fe24a0f5237ced9205400edd1e011cc9544a40ec60f23c7749d477e176c19ca74978bf25319e0c0a1d5060c91a24bd5b2d768a3cfb35006e2019076d0c6501ecd57ed52db6d86ffec2baf64cd26d6f9f73b766d7e30f44359c845206d73ee08bd8b6a999946941b50f4c56b40351d884898f3f95633f0601612de614572b770d3b1d7d77ed3bf220b118f143709cdda42bbdcc312ebdae3b43ff65d4ed63b066ff8dc5d4e831cd5a69373fd47eb0087bc6fce4988c734646ce12c7bb7d1f982a2076ae1df79e206d4f9e9bcb17735eb4d028128a725d65a93857cc64c9ef97aefbffbd918279011de5f04eb969249a4c0b02315cd3508e3bf946d5248bd1c57d678e24ffce4ae66c74f06416f39d63b6f3738784c51638b8fc70f2228eb76124cd64470da845c3149fc655429ff07120647924fb92105a757787842d3a065f4033ba19a0ca34ea2f65c0809b5137550ef9f00393357272ce065f15418277630126d7a758192bb6b4cfdb31ff2b5d472d75c0779c18e19c0c96239c2e8c6d87a65628d37f3b057af010c2e96c6488023a1d7accbe8c782de72528d6477591e063e71e4b2f7b3807d30896d5d252e7f2c57effdb166496b9ccc9326980b04306b43ab75e209fca0124098d7388bcf032a2ca2346976b68d20b6849b8367e33cd210c0531fdee3edc556cfae6ab3a301f08c6509d854f0871754b05f254023778fc1419091556f2bb10c54467f7859c9e08482f22f057ab4420ab4b9bb59595c8a8fb40083a17875613c31b75be7feacc1a7800b22ec21995e7b2698aca5df50b744baa7d57359fd532b05bc2761261c7dcba5416de1d24746a62a1f254e573ac5690b75ca39d91b80fc6650997492f34d64c5b752225ad50e5b0fcfe11b8a3d32bdf208722607b6424a97f11bf1038206006a6277d93429b03ec49e1f7db77db5f1bef376f365f395da181970405e5ab3fed4e7c2c50226298df19e77773e8f7051a840ffe4c01930e7d9b6aef9a487f2ac9114ceb422b601234ca26aa8262ad6a37fbcb7f59da14b5eb6a024053bf808f10d1b83626e93a56ee20e9c76c446eadab96eed3ccaef7cf80fbf081f4e548d667f9e22540c66427ce33abe73039d38ba5eb0ef67c8a5f8e4ccf44f18f9d54753a78532d9bd419a89d188f7c9ea8fa619189e3fa1a183df24dc7366499c1786288f82a66df7638c7b5f5b3a2c4663ca8656a8d45a497925a191bb32299744e03f673175020a5d113216132f7cd342fb3460a2a800256d51ff91d60c05e68de8adc6c3f256c9758929c4839c543498eec677d11d570ff6d83ac11c62b4c780c96ed04d47ea6b621a9a0faed7ad243214021d6958417d0b9c6ea1b55679ac1e1deb3a3d07cdb3fe78620841ef886c7be46514dd7ae6aa150b370c9812e218ad8ee7b8db2fa1ec47c2025ef0dec343ad737cfa59fece1b292f45d91df3143ba47855e344477efcee52279c1660cd5aa27b66806970201558cb5d9b4d84df90155837fe66f3f238a39fce2d31c5cf02605e8bbfd214ecbcc1ae2140e440d45710d1c70f5f47f9f4a369e7f8f0de60fb84799c5d7da8097aefd60864f128fc0e53f2b260b51cb8e0eed343e90ad882b1c8a7057201b871f101b48f0029c224d2e0787fd5b4110c8b9460ed0001289978bd2a989c62c0567dcb722dd5c5313dfeb44de74b68f932cbe3c55253e33b6d61847364651b3ed96e9a6816643e06f9becff8a2500e8f25060010a540ce39c58b75d6da00570e4ae736b39d13025d5aa2a9bc628b2f7c2d11feb2a600e12d2d3b3e202d5348b31bcfd7a7f8f8d0782010046e75a979d1fe54e1223414f41e36ce9046a7911e03de0a61069da7c95170953f4db7ee804aefb03912e040d669a891c484f07945adda39afcdd8eb932e74b1ebeb4b8d1e6d6fac78e1ab68300f6074e6fa5792381980283344d0712814e943ce61204074133c44f0e34836e7f1a5b08f8fbc0e3958a68e16977560c6495412b49095d8e9b545dd5e069449f47795930dca68a4a5f9270043445ee80a0006635ab4834a94edc895023df8c22257cb2b02d756cce93a4e1d2128aeb49536e38de3bf813c33629cff15c291518c5ddf0076a020c0b5455f577e96ed3cc41e47a396ae87929b080746e711d1da13f4b3c3bb30b30c6f928dff78535af3d37c00504b8019066a5efab6e2e62cc7a8d9442f2e0e444360e4553288482f0c24e5992a1afed1ebf30054472f115d972a84f0fc9c428336706a8a27578fa34c659adfbb643aee15137f3caca76974e026f3cd937bf9176a21443af02fa6d6d42b31dbe44e9bcbf631e10c576b9f0ac851641b837bbcda3a126c813a63bb41bbbc51cca216b92d4a3c85670cca522252479f700284cc672e9feb28f36495e0e5fe2872382ff04acb7f563010d563d68fb53c598155f073ee89da22c53c8da9b017abcd2dc899a0c2c5cfbe05dbe5c21241e54dd71e3a1f516e5a28ce80972ba13ea2a48b46dfc155f0fc347f726dde570305c346e2d119cc1e07535755654cf538a3a0d124614a402bdb5d834abdea74a460d1ed606cd46abc427da6f69217955e2101b6b49088f26a8614eb955a6662092ac0d17cf850fa52b607f2f01137bc6da5f62c835289cf537b7b303a49ac665145a1680fa0743ac147942c4c11cecea5755bed0bc899f2a8d61a3b869215269a6375b783fd20c9f381314ed0220a32e68b92e7fe472a0850fdc48e2256dd64718ea103400d434829417a47923991920d84ac12d01e4f2acf714d6ad034141ec6fbcc5dae4b870b516396035a0ec4c7a9d998ae4a7c064c2547126d8751ecf268ac9a9f5caf89e2a562e04f20c66279d6cef08c8a4de8ad870d2e918e3c20c012eacc102d2f7a83a12e1bb80301336e9f5ebc82e7fddf8a3106a10bd7d0cbd9417b796b70e31f48118c41664d8338319381cd4541800ba6014470b54bdfa6b0f2ff5626c7eda490ea61b36c3fa9adf7361773a74f3844c7788527e438bbb79203e88f93e86008f549e0f834f4d002a1a08bb073a8cb5f9bbd9e191efbf4ae2475332b4f861b62ec5a2a0e8fb53baff9090327eba9d307359d0728f90442202c11db51bf9f66047e964b7b2d3f572b0bc487399a39ecc57fbe50af88527bb3ba71a6185425939726339ae108440713d01d873d7e03aed3741f25b30d64c3705805d2a26fbc8e6ab56ac080492ca97b27219f455ba562218a89c4511865a4bcd1e2515e2567a44cfe7c4d6af3816d132f6764d14a7f435357c0da30f8f529d6f623037a8cb2e9cb3f2f77e2c5a1321cef1155c3a7e2b9418c5a3a9f3e4b88b6414dcbec1b68eb6145edc6e873da7012352144cf6c39856e291355714deb802d3235a0c596a0e2630013b8ad132c3fe326047ae967917c0a4af1ca89a48502f965309138ca304273448445eef40bb100d2b36b81ca5e4b33bc354fd908bbb889585169a92469035a3858c9260d7b664cda090dd61b61420a602f0da04c5cea33e72ab26505cb962d3fa47336254ce609d775a913f2ca577467670495ae2adce89a1937dc15fa7131e3451347381feb63c966c85356a8213d8081790d26e1eb24c8a6c1797f5d79298584024633abe10dc401f1dbbfabf4fa8b38173a23786d1328924223ff55c2130aeb4d7bc86fdc39f783993b2263bf81ff34793108db3f167e39e2ee62373fccd6d77d22a241cd118828151c466774d66d771b703307e31c8a351fc49d6a439253bebe5810a811da708f64ee9d080b67d5c5b895ce06efe79300732af1e1158f7e32cbb044296425167ad333f5e0b235a85ded2db92b03aac3c32ad7de689934c9fbf41d637e6a92af8af991d636e7cb63c0de068ebc43101e629c9a1bc91e72e029be184948862661cda413eccf96b9b32ea0067c9671b01a9301cfda38c8ddb7487bac30dcd6e4d27b411100b981dba035296d2ca51a63e9773ba391ccec0e730f2d61bf4dcb08114a44b7f049da934a085ced565f7f178521417dc3b49e20c33cae40d113561c33eb46ec60cc29519e91556ae8f7bd16de2f1c2735a6a5561b0cb601068e309f93bd773d41802e2438214fd8c7f2d48f267b6c698c6a8125ba59711f3ef39cf2572d6458485d1c6238acac368578fe10850eb8ad28bed0ba6f12380a5bb20f885c1d631098618fe39f0362407ac48b056ff45417c458ae17271c0a80fdc6df036e9967647ad1427b6e8c51bea45d6fc5b7997ebc1279178b79a01a00699b2eb67ebe95db99d5f7988aba935512f6994e63cfeb1519088272e187109e776c38121ed3f1e7d0ddd344024880b6382ab28bd902175b03757a521bbe9330314b49fc4e6a807e1bc5dbed34ccfc3f41880bb43f02b057013e82b8ec266e75b77be22743ca44700c9e776fe63a37228df7033afcbe8ec0708be926892f2cf09001083115b2803d61f1b31735994651b7f59733090f07ce228f3fea7c0d56dfa9af8031e6c161113e1853116f6c6ba04c91e169ba0c753819f128d9943481196fd0f33831233e4f9caccf72ddb43bb90fa34953bdf953c87f974692f18736a061906025a7c925b6aad1040aa702c18a4b207d802804a7a317e890b911c0178d18dd014876b3471928d4303f61c5a640a15e22896a264be6c1cca2c52c1942d693b903c7aeff1d0ea26b3694dfb68275d556a90c15a748a891af14dcf73573d52a093eeecba65afbb6678669a1b48f9a7c7afcc9d7222ad8b0e257294ec82672977542e0efb31f6217817b9baa625e938c9dd99690451bcfaf102176610b8036fc49256b7c7e2d646a4fe817da08e5f02501ad01f2121bae8d1379a689cfbcc73ae62d84801c1fc6896c6a3860a27160cd58f1c0f70d5a44949f0f310425ccf23c235704231e4c68907c0ff1cb7860b61ff91d17f736a17336ef5be742c6804d3801d0b5b38ee216ec935a45e434b5f2f72cb4a269a4d8ddded68b12acc02fce687ffb179cc82e659c7b4e445787b80f9852928486948b9b6ea1c850d407d7004538b9eccf229bb9e5816613f03e66f60e27ca42fb1d60c88b080c2cbf867e48172ac89efd5ee359cc310551f50fe3cdd9187696251a1a31705546e6e4de143601de31fd418267753ec53b4a90ff572a92d11f098cef4b1d979729db3d686c51e5600517e9249f49ade0618868c47f09d6cd13018e78ec4cd96934979caad82a55ceded59b72cf345f3f3da77098c22d98065681799f66a16f90dc1d3074c4335dac424bf866e7e853e7f83632cec8d57ea1b44c535d9977fa5aff2938b89141e0110b78b17597fd5e1c55e718359d65a2763ef8249620966a054f44313d52f37942ebe724c39a1a2f5a162b9d830538be538838e00f57277c08685220ee8cf43626c19192c004ba09f0079f50808aed33edddf3a597258dc603005900150bd6f55124c69e9dfbf8018cf1d77eae0454f898aba3b4c3573a0937139067c43c54010257c39a5ce2c2a1a4446db47ca41df08d466eaf3ba9283b045284b69642749e154f0a5f1baa5bcc9362c277fdfeb996d9e8521ba93b6e81605ba59f75b79c8ac9f3b026ab3c3ee3d6fbb30cc24c5b3f292d1131302bad04a5c76d0d5078d396a1fe77145bd335508c049ddb39d54260b4aaf9538812a3c5c43935ac38f3c02f7003023a03518d6188e1c654241fe6c54ccf16e300f01847c1945316600729a685b8267bf3a7f9929a67f162bf9e15ccf11f759863bbfbbd15b21573b1a42b74f8f8202fb410e0f8d0ea3e7e7bfa587a0a8ebca330095fa6227381a9773a81e9abf8b32177f996d95ee7214184088576ee7d36f58ba148100ad2790431ade9ee3abe00633430258a76edfe5cdfa1029e48db1495b92d12871e26508c66ce4e05148d240bfce71fc58c04db3887b7d81e8e4dbc0f67a2ec8268d93dc4f5f1f608c4bb7bb744f60b1750699828e4bb2baeec9c0e7e9112411eb78b580ff149a5a7e08286839768528ad106177e79cff73cc8e1da7d7f67d9c757bdc8fa18c9a3dd835d2c1d6e6a2db103c680c9f0802f92e0019efc9232b7f73a8624ca370049a4cc8d627f95d790798224713d27fc7a4cb81e234c59e45d6de5f861e927734ba11e38531ee68f01ade5fa890ad70b5055c6fe17fb3954f1ae1bf92c4195949a838d4d19b0121b39ac6b34372c16f5925740136a93a54afe6bd7481a6f8886ec503c4da60c1cfe871010b01ab2698ebad2bc068628b1385609edf185272a25c6c67ebc5b3199ac080845b91f35a654f775366a7a7d1538c0e713bdbb821f0813b7ca55ed090931180ba8ac962da216af25c211e110c07e37e15af645f027a493d683985582f7e2e8bb5461024da73cb2d08a26a752c4f2cb9519a0724d8a43b9492209fbd10aa0202486c7bdc68b7500e0de5cb3bdf5f8b169849c951fd7e929c3cb34423387288219ef9bc974dcde2bcf8c0383fcd6dc0d3a6e64f439b105a6cf31ee1fbfaf15b98a8986c2ac3eece7b52ec3e9c651171d7e3f73a9cc30fac04115633bec5dd2140ac65cf141a411506167c684cbf2c76af6c673beb5c1244a1bb10dad10298da0142e8b98d8ddac8e64324d6b5c36dfe35b6e93d88a5d4e4f4069c535f74dac021acf6c4b09cc7f9f3e73977de007e9999e96325ecfbbae8bc29a2c3449d5a315217326ab7857bb15833b40357022f6c06ae8a3c570b364cdf44d1e34cb089a8654a299abc674458f97f233778f395051f06dd7fbe9ae7884630300b502e926e8328b99c7b3175777e0b607d351e05ad7b1cb72a200a0d403ef430bb1599ea0656dd08a7d383c42265b058cc81039e2a016490e9f55ab67068c79dcfb6ff218496499a5780cce8a228fe083b4d74739b3e95c7e2216a2ead928d5e8c212a509fca8bcf479fc0892f5cd26a656c119cdc14393b0dad0c0f8b80949e7e5321e133518c4e2a1b68584d183ec2f4f3d7e9c5ad0d2d6f6be4aa0123219610aa76dac975da0cf64e3bbb0237407527c3f690f6b071656bfed7dcce8f0db3cf67b8b0c05e0ac9c1581c102ac1f1026d22e78cf70021b75c4a74a14641a70447c5f6c9eaab62e8d8fe53435dc5085f0a807f67cb46ca4091c7ce80670521016289e64bbd12ff6bf5885aab8bf506c2d540c55f8f69f374db7d54ef46820073f3e993c6081ea5f23c976a044837ec3a68199c1d092c8080ce3bda275cab1cbccde0861b2938870ff6de8ede731dcf0182095b3aad6cc22e54f2f6892e3af15721a530cb958aea4779291244495451c71fb36ae2e4b0966b40c05896ebc000067365ef73a843b6c8a129a3cb74b862a33b84a68a6e6bb5b87dcd762ff87979ec766505d1068e6e5e3f0947d23d47b555d3b4efc1e2828fe00a5cde4eb7e35a304195300e7af961959b858fb97402ba42d44e4d90eaa7814d0caed4babcc6697660f0b03dcf25f4879d8cfed5b6889db44d181cea52b44d47edfae1a69b5be2df7159f8bfbd49d54ae18fdb010060116c736180dc594a16d8568990ee8ce79d20e92e2caa6ee7eee7d2ea53d9cb2bb63acd3a9b59dac1e1512e297b9d61f665ab5e824015d6a3a5f38ec93b430744991759172401097777c74dfc11de8358a2ca690ec29096f96815a8ee3262d79bd6f788b24c8f2bcf2a4f98c0032a1df2498e35b88e7088c3cf11dda22333e2e0fcbea7564ed34e3f4006ed68a58d95d8ff89ba897a587108d8a0d74f71322ca83695df9408875370a4fe4ac918ba99fbbe79c4d0f175d030a7f0ed8af435e480ec407e6da5e4255aed5163286d7ecfdf7dceaba1554046221fd237613a7f6d2c0dc1c4f678a2571694385c297c0860a583fcb41d0c0da5c1bd289d03c2be14f6411b0783c437dfa1cc5d826a06e68bae52f0cab4d682fe22d0e7ed2f69a0340ca50ae656b03f7d6e6c7b65bc4327136b5f495c94322caa183657495b334f23bd6806fd02bfd5d62f77a2fd183b49330a29c0d2a0840fcc17ebe509230901fe002a846bd521a18ba24e8b5d715b6ecddb43a648be7f3b59afa9800405c4be2117b4d57db1f94928048e20e68ba7ea0c297f1e524e4c9402126eb87790ca02be0489865aa0c2094ec128da6a232e895db2aa35b64e50bd6c6cdd776dd310c8dc7d231309d52adae745d61d2e8181f46b113e3b1ddbf838a25b2b33f7c0b3341ac2b215a85164ec172ee210582ed66b040db2d8b90f83381aa2619f11a3e02477639e3ce2cde061ca6c22b42fc1e2e611253c7f0e1d0b71883047401020fcbac4466caff74ce28db0cab40cf3d39ee4fdf870b48acccf244005eb6ac7c1efc3501af619137db86bac45d310ed971681f87f130a41f238224d3ac94d41908c10d350081c17ed175747e6141cec09000d6ec081c450e2fbd7567aa5d6f4d3fb60bd381ee01b2d60e3fe0722936583be034311dd78be0655c7ebbe0c0a85b407b1857be16d66cded6b8cf03c305447ba4876fd229b9f4ffec21d2593a913dc4fdd224c5244b6d168685584c51ecdcf03364e40ea8f8e0594cc2c3f1681c288a3d0147e9671a23711a93a5b012f27672aa89706eddffe3ed66d1739f17f58b184d89ea29bbe020103c4f689f49bb026282389cc89f3f107984ef9e7a36971eef4b1052f003adeca8890d040563ec863ba8d26d8c2c5e64931e193ee4c2117939ac6df84200dcfe337f5a2234e4cdd13170e190c8e9ecc6f41b646118e3cbb4337dc07d7e7f3920da245e3b9b0b1c2a3b80c6778d41073b24b6e16a53d700b8860ac888638335f87aec17561237345c007c20b3247c64d0d804666ca92da4ac38ad67d51523e87571a3451a978f8cce48f7f70b8bbf1cfdbd47eb395228549e92a2d3848d7315e593ab53759e02df38e48b02e981a9922d25110093895180793e7c4bf0071f345cea38266f033ea4fbde00a45fbd6fddf09183eac74d48c2510cd0a0f43368b3b4d3259dd5e16228a68d8a7fc0b98cf8b1920a820f1b377c4faca979b003b5db0626e8659e97ab15b2b0ba2209968ebbbc0780cd6b89712b40ffa5a2692cdf6783e13c5aea79fff9e1c69666962dd3f47b2984702da620ad7cb6b5ec6b2ca0d248bb7140083890c1e9a472c50c9a3261a231b5c0c2bd96fb907757bd4a5267f6c245ddf02fe34954478208ac91379f80f7d7d8058db188298185cac632dcddcf78efd9afd9f5826bc780ae0a1fa6804ac0d40b41d69ce625bb5e732b44d2d65546987f0787966339c4ad36f1a5591541938750b886423e915415150640acdb6cc74a48444c36474e641ebc4048c6b4b711db1466016f9f36a3ff5f82c981fb2bd09ea326bf0d0aad43ca87a6876edadd14f8291cb972fce74e19bbffcf4da4cff3eadc7f9fcac2849685306b9c8b58c192b223fab6262e6d08afd89d25916aab01fb157e112adc652a3d04a4477f62c3ef48d54d0f0b68ca432db768fe5ea7e8ae53e9a570c6d4ebd134133cd72eb00e6e3b3ee0fa0cbfda591b560c47461cd3970662aacf7ac0bd985fdd134e40b736216d71e79504a2a2e606ceed4cbf4f7da9ece4b4dd98aab4eb00930c457f5bd2eea83b7fc5e728ca28d76b74383ceeb312fd22b2d391bdf18f26ec6faed0c7029d9016e8185c09126b8751c38f15ea71124dd4183d2b6e4b3602d2efab2ddb1cae8bdf2e8cec683dae718c473f1cef53850998be8540180efb37a58f9c69e416a107d4810b0f649dddf4aa466facf93c9d3c056368bc3aaf76d30f634ca1c6609d463b8a2a074d996e2d711a733883de776666a9cd4a61c5b2ebc3521395c0b47c11956d63833282c00b0b594718985cf476bb16619f454b9d1a14ae96412c4f936f9e273eaf77d6c82903c6c38f22420444e46da833a56479681c71ccc9922bcf07ca0ccc02e328e70726429bc612d11f8f8154d78527dd522ba93db17230aa0733e20a1185d8a36124906055a0dc5b1b93eb231338aad6ccecac9ecdfdf3b7113015b03dce02e14b641025c927d0c4c4cd8cec2a2970794270f44370a2cfeb061852d411d111523353f58b6dd85e355a01aad39772d9956b2bd6563c6cc4fb018592f12954a7cd82567acef25d2608b07c945d95010b60d43366eda7e3d4c09b3f16f8e3270da4a9f34890fb8a719d4a81a8652f52b1ba4c6bab1f042cc2d019420a2a33e96d390b7c0af418cc739031c6285cd7845fb47eb44f9f98f3f8c43bd48f86a0001d90a5f7d8504fcfbaf3622012c09f26ee4c2e950de2aa3120f4a162326f68c30ce27d3e699606aa4ff94b80be28309b2b83739a03b26dc9aa17dbc04581d06169c5f26daa43279ef24f2882d79567f50e51815c9f821e7e1edd95063410b9a6a33492910e4633f25b070d7c5dfa88591ac603884c0d3bf5cf689f58d42e1d714e48d2c41717b26b236d7ad16864a3a1dd169187dafadadb4b6775d3643375105125e5f3ae18656038a4703db85607524b9ae13af6ec36a18d58d55a13416c0361666df8eee53ad2078da0d629a81588ed4bb7137ee206e5601ae6bc8052bd1dd6b5934bceb4eeaffe62ee5a1ea9078dc180acb2157f58069478a7db641696f6c9af3fd2f0592c997f14f3bb03c88d7c8ef8c351824cb0dd1c9c00d5443f2d1214db6eebe161b124060463d4fd6bfdec14e9799306da26cc9f75dc9c88e34bc2b323b6c8cd817c79c146c8a547042585aa14ab119f7314bc27d3c5442ae9472e07a253f4fd2e808fb869dbda15a87af2ee17d2dd156876cd6c303d4ca3556a282eee1277e74f99c36f5151afe4d2fd9adf047d9c45905eac6ea322a90014e3d57bdfdba2f1b866722570e7abb0676c6d0762492ebc7e8da9433ff1463932105af15274c348dd3ec1b39834facc017e8af79f4a72602bff34887f4a2ea555a87b0b5912ba941cfbae30c9ffcac14e7be070a62b4573cc50b74e1971482f889a3f57585255fdc711ce3f9f16d849e5712bc1858e203a5c7f644fa19e7336df3fce16708d298d359dcc3ac523f643d668a0483f04dcc1e5c6c8e834e788963d857a93237e9690fdb9931779656ef35dd8a9eb043c7c6dda5827520b4d9e4ad0cb4442d5f5a1601617801941816aeedb73e31fdcb9461d2c736e74d0dcd7bba69424d278dfa6f79b0228a181b0cb428d7afba1bbc632cf126683e6ae38101194173ef159b64ea3a7fb96cd3efad3b215e6e8f1f236c73365ed478f2a49609d0433ae909316c7163283d4cd296138e4d903f568702593fec551e0527faccda483904303123efee7248c8ecb829563a60919ac6c729aaeb322d25c075ef82fbb5d7c667541b19475750d239e85e25635e68675be0c092e70629931ab487083ed2600815b6654ef1b692290fb11e40c76b0a5a447d12365253db0a41be818e09b22df6ac64cc131f01fa6935a679cbeb8ff2ae9b44e0186e7b365cb8cf72eff3cb51463d37041b649a02954c73063a07c92c210b49b7b00c6f08284dba0e963bc08891110b337c1d870ae5ca9e6be6a0db0109ac62f98dbcd3bd32ac46dd1e9648de88ae1c9fdbcf8f4c92a06c1f1260447c140e7473b7cd6c7c65cc1587e3d158e9bf3a12fde216076188501d268225f9ac40bbde1e224a6c1160b8afe3b5efcb4414bb9bb8bdf7665c7bef4cb252b96516b941fb956e8a1258c4cefafd09dfcd31e6b828a359edbd4b2687a27520b93aa7d00b2bd1db1133f67e2fec5b477f01611664a5ce35e337279728aba91e58936bb0b2889a8e8cc501059fc06b608c69007877c68e8eab1d92dfe0b60fd8f9609d52abc14e302d4382536efced17d1f8b73cfa3778f583a6845f5b31b4d66109373fff1f4d453e59c5ae6f5a855865d5772322f1505c4c6ded6649fcdd78971550da313031f3c7568871bc006a4859a3302f73fa3d904fb73e248ab4244c47cdd1cbd1bf8015cab039ae05e9d5310386799e6960c2e9652e58148610c7d556d3da728e50b730ff7123bd531289a3de6b558c681ba92e44e340561e8586eb45c161b21fbfe0f378d164d6a77260df011ba6954af315620486c22d44444884c49ca3109d209670902a877c90bd7af60cd2636e081abce8e54d6d971caa90dd28ae27b5ecdb46362f6c63c30fcf03d53cca6f06ef9c2f3beffc20c7e9fbd15bce1e316c60dc084e15a73f63594ab6ecf0d3b1e51aea0a2ae1dad9c863b281ed97eefa09cb285da1384494ce2846d5d5d7578b2f060e5f4b64d516d0a2578ae728e126ce7c36ce7836c8f953333a6a2aae3f394ab8ecf916cbf1a9181cefa9c89ed7961cfd91e20369082c5b220c6a69c38996aef5e8f0f1599a97c841a7d2f49356aa318801b75ffb171a3de55e89eb9f34521f7e3f2add190014c673835327aa6241489d65710501783e93a68b99fb4dd90d313d5481dadace2441dacec9f1454b1db29bd04be7d7bb58406a7764a76247fcfbf04a5299c9ee86f868c12eaaf70badf354ef6f7233c383d1176ca64af3cd078c654cbb2ff0d49a31c391ab5e3df906ca571fc141acd4185c70f73dcb8317e59966fe346a3b67cf086d7b63447266da78b1553708adeece20326dbe2d9414541dade5f456531bea7b545ed2f927f375a5990e70715856d513b6b4de1bd9f2d74c0dfa74c7df372041297b93c2333627271636c4f88b11e9139c969d50a51176448b2ff07304238e104117c511445f38446adf8df7982df46e19a36c6705ab5c6c8f707451810e81c79faa3e2d9a207ecbd97c3bc50057a8299abb1e12b1be5bae3f295e970e534d4d1d1ca2f66cc08bb1f9431a38c11be6855fbd1babbdfa446f2b2d1158e2a8b3ed1163ce0ef59ecc0a9ddfda8ca5d8e604f5ca3476118a2e88c46ed9a714e5936cafef9c7b2ff117a222ddff75c5bd4661282d3cf69136aa162382d940a15612b91a88adba78a466f082178174608df07219cf8be0b6fa76cffc342f0ff1b353ac749c63f4442c83404fba749433f0e996516faa1b7958515891f1a7a1b4a50f0d0db50b8e1c285072e82985c346a87ccda0f7dd84a443f4443a9091efad1841354a8181a4a5231f4e40915f86f2f8d788cf197a00403c61fcac0e70cf408157fc8bc3ff43086ccea040fbdf7c1d01982d063f3363a34f4e408f87c23a3f0851e27641ac18085febb099d4643660970e4d011280b7d5398ad48fc1892d55e5b91cdb73355210f3d09132acc8d7822d38668db96ae200f9d341af51f613e5d113a4f681485eec0ff57a4e13429fbd293cdf5f81c5377e00fe6921cc93fc8b4d92fed93667a622c7fb6752bdb2e0884b924a62135fc32272ac739cbfeb770ce53f627bdc6029fe46dd15c2107a7686e6a146cfbe8895eaabd7f00a391fc998e60ef3ff7ae9986d9a57018964e45850a1507483a800a1539d45abd5aaf49a3d1ea5dcfab55ec66c0a6a87fdf840c5c8f060dafb9b0b0b0b86ca95cb0668c8d8df920e6c3d8d891a828effbbc6aa38e645d5c6775566335546775966725090a2f9de16a2bcedadea00a27d9163c2c85d3d023df04929c61dd3ace28fca4f0bd6fec73fff2f4b77d93e9cddf8fe60a5e75d7abd61f89ccda5056246c382438c5b9f025b26db6333522fa7afd8988fede272222c2b27d4b24fe7a6fbf9625cc0f1ae97e706d5f6d2eaef735136332b579c4370013993733b5f9f6367304361b20f4e1df72e86b69bb99e0139969986d66d1d00982d0872f74de4647f15d341e5f247fb4bd0b4f2d9733bdd90bf3f791a83acf4f10493e792ac18e23ffdef2cb37a195fccb9f5196515fc3278f48f2ac605996df809acbb3c8f635ca167f701108a58d34d330a7906b1f9aa92dcddb28e9fd68ae906b66935730ef2869ca5e5d8bd5e8fdc0efebf774399071f1becfb9781fd6fdcfac35c9581b44ebb26595919585317d898d35b9dd6253f40bcf72b129fafd2d96c5ba4296e0aa8bf315a72be35c7571b2b27d726b0c0e62b4c280b921eb8b972e583670a9618b161ab25ccd80e58a1519aa50996225254a1594262d30995aa2248990a820407e40591f7df8ec0162ec872e6ba3c4e4acb5f6fb46f7cffc5cf8e722088a9e550053f87ede727dfbd9db24d8bfe14b78720963dfb6c0aef0b91707c4a375b709c8f5f89c0dafe7ddaffda96af9dff25e33242d584b7fd4820fa6f0c2cf1226408214f097164b58b8db6152a1ca2e51eaae023f5fe16ea7832a15dd5e3c0e9618c0dddddd4beaeeee66e2ee7e801654a570f702e4dcddfd3f777777779f01c509020c0009154000a4aa0040852c55e56883d37c0d32c0c0a8c8c40538eb3d95c8f5f89cf7d65a28afb97cdddd2472dededddddd7e769719df5a6b7b7cee4a517d0a734555692b83ef55d9df7a682220870bbf47e4c6af644057ad9c898aa21f6753f4175525b7d5cdeb0687f7db9a09c815d5048425dcc891c2686fbd6e03bf579cc1d58b48547634afa2009b6cd908e079df45b01fb6139dce25f99e6cce85b0a84c863d7defeeee0e7e20f8c3f8c0ef7a1e588307b52b67adb5515f77df9e1090eb11e6aed8b77dbfee2eb79cb5d6de7f182a584b94b376ca7beb799e57fbbca1ef7e306a9860857c3f128657f33ccff3bcdae77937cd0ec8d36e085952582d567282c9f3f6241442a315460d7ff06bf8c368b482e0e7edc48d86ee7d76eaf424213cf1efbdeeee4bb95aadf63d706efcdb8df482c83b82e2877f4533cc5ee885e2683a915f23bd3bde1bbe18e69bc57bf358f3fffc3a8c564a491170f6ae6f09df83aa51a34b81da4592ec81733b3c50a0dc15ef6fad54e67a7cae76074ff95a6b9f6cb92dd9fd84cafed6a8d1fbe058339dc617bf9632c6d352d54a0fddc1f03b870efa67a71c49348d2c07fd9e69c2a6c029a1c14d8a606b7f78c6da4a1dd6ee81736d3b781a73e175f2f47507f6dbec817361776053d86f2736b769989d2c6f4d4c4c3b60d296e65398da4c1ed916f7fb0360c78bc3479b57d65b02320036c5914dd15ffbfae9517d7f6bcf5069079c562d17b6857f7fceb620bf73e0204f126c8a09d8be7c1bbea536a74d367bef14f457508065049d966ac628c3a63883c7af7fe49d473a3869edb271d1c1e10aa1e64273c4e53e93c5190c9e292a3ef89585f74cad74cb1e9f7c1fcd305bd292e6cd652dbcf9e8c6717734b1028f8b635843ffdc4914456bbd5b2b89eeeea2f944e69e7ae01c09cb4183d6dab074d1dddd5db40ea3953ca9d136a9c40657eb91d634b1c2acb4e70a3db8168ae2cdd7a9f657bcbf2b86c06065e11e2850066bd67e36b46fcf9b4d813b83edd7acb1c1b71d3e8db9a72b4d38fb7bdfcda3683ad564d44e4b951b3f518406ef07be0ab9db3b3d202d07f6c7af45f09a4d615f46a335b429ec99ae60c1be6e9a290ab5671a672c3775fef4e6df2753a3f75e26289c86df7dbbc65b2ba1c0e61afdfd67da643f401295fdfb8411a42bfbee48560ec231356a83cc2ebe3e7aad78aa383df8a0d11b8c46ad9f49468dda371a64f061d15fa10f6dd0786b2f8e414b76ca55b6b5d62fa1954c7cfd1926b412065f9f46065ffd7adfd057fc9508bc8523487c7d1821c830d2a02c5f64a0c1d9e4e5a20c8a32308dbe96318a4e4bd5a8b54e8a3278a3cfe08d4e1b6836faa2c7e0c9f20506199c36d02c8481d0177d2d63089d16c969a38a4c2b2554f4426fe2c7f28589a2b3a97390892013a6d0d732469053a3b6dea720a10ffa125f2b5f94103a9b6e2e4b9425cca0af658cf26c4aa10cfaf249bc58be2061f34862246196e37903051b63d0971ff4e56983cce58f3fe2c3f2c58811e208733c4f30a1511aa309f16f0f962f6e67d3cd6178ce68b404f1c327faaf7c41744318a3090f9ec0171f3c6ddc32f8366ef9336fb7469b490f4e8d4e80a5521806c928a195c4173a5d78f0422613365524d94cf4e88d70b79b3f30fcaff6a207383c9b3c0def9f19d812ca588f52d129fb8fb5dac7a18253064be4fbd5b670fbb9d791b25cbd8c90e5f4d37919c9ca9fae956e96942e8fe177e776db142d9ee1d45251d929f6cacb3e591071fb6451044eab960b2ecfbc59d5b6e81db9fe98b5c3e977e5646aaaea7bfa9ccc70fa3965ff253638fda2b23fda59199958d8978e6b2b0bebca8a57e55179531e122fca83f29c6eda3dbb669764da81d34b96fded1dbb5f5c5b8dfacdd26a14ab95ae4b7d3ab264c0a7fbbe00e1db2868275baf1d96b54a5629f522585a60ad64b36fe5b05eea5cdd159992fd6ee5b188f44caba21f8b7cab3bf01f31183320876a44e32d1c219228f12efa8277d117eb8f1a9b7f64263179f0410913868c124ca081826983c84cc13ad9a746a3ccb29c7a17966fb56b715005637dba11031234c122f3a9e8c3c07a7ccee8755d8dfa156f4b0b6b4ba30e5a69d45f2a0a7c029dd0cec8c61af5b0461dacd122d3e6c622b37318942f3cb4564ac3bf5aad74d64a5b17cbff66b5528769b70c84d34f9786a9f7df08bee55cbaca62575b5c33358513a527b27de76a5186c34f2f96772a91c1e317999d1bc327103cc3a746c3b2562ac193850bb8f6df79b32a0aff167670ea5aa0e9ba463d0d9fbe2a8bad5eba59ed5adea6b6b8696a0a7fb2444e2fd6edaa285a0881c3330da542297faa3c75b1c2a856b2025e75028ade5f690b832f3e033a5f2c21386d3333adec5fe462ea524f3992bb99ecef5aa1d95bb2fc6a0bcae1af425f879e060a7e2305b74eee56ca976ece9ad048f6c7c2327c864b7b3409499b65ffbe723026a133adba247ca6950bad5a6f3b53265c12befabea67ce97b5391d2afcc2afb0744f6ff4effc22a0aff58fcc1b5f4d3395d32b1564aadcd23ca11bef3969d2ed6a889f2459f2cfc5c322803b17e6aa7766a271269386da7766a27ac419c323232b2126838b5646466a3066ff0872bbd93451ffc7d3af30e99615f3a9dee023e38b53a1d988ee8749385858565620f4e2d169696c5ba6dd0838db25016ca421595dec9420f4e2d9485b252238e7868ba6166669407a7d5ec069a190900809930a382351806a577b2c083d30a36a396204113870a4ef93b2f56a3758713288a66608653141d034096c0aa287c49079c7ebab16cbf32b05ebaf5a76ba5af56fa4efc9165f7d7a0f44e164360ec4b6409120130418e35b128043fcfe87adb9a0106fd22ae976cf09a0a03e3b584ac561f686652504cb632e9c524cbab052b6ed6bc620f0826a9e823f273f3623f719ebf5204076b0dc1afa57b1f08fe57dfed55757f7777d0f36e9c4d36403d3b2260390d7744744df7bb6da6556b4caa7d3dd3fbe1ab603a426fb94513478e9cbb0884b346ea7df53fefbf799c902efb35ecef8464e514ef846cc9671afa6fa044889529bb205849f8e3008b3fee8244e5ba03729553dc0ec8ce0857beffd9dc60877fc5f16b298e3593ec5aad56ab9d15cb80c5b34678a6b792639b5e68de239c51189ee057cb18f7bfd3bbda2931db2d8142b5eabdff2204836fae5e7ab672c8a20ab639f530346af10657b1ecfea192ade35e5aa4464ba6de7b1f366acfd195643f5968c1f7fbf6ad58460880b9f0ad9f580a433077cda3f6a530577ff4132504c05c78be2335da020cfc587cc1f74c435f02735edffd69ac47de806a5bc0c1edddbf356a6d3902d9a835aa2c6cb64fbe910c4510146befc2bfefc11452f1bf0fc3dad7af9da91545efc1f36ba5a218a7ddf2dcddddbd7adfe93792a52d48e8ed5914c39e69bbed4cbd6cbf3cc93305b3fdf14cbf0fbf56cda2fae199dad004bdb6f65ab7d75e6bd11c35d60dae749da13d1daabeef9a20c1f5ae052a8f71d268f4043f9bd056b2698e8cbec0e1d9df85bff3d9ddf0b5cbe2f26c75dbd54afedea7152da79fbd233489c9835c38c369f8d2cd798fc28d26efbdca42cc77c693f007ad9548f883e647b64e9e339c4dcbe6f1db09b01308f2b7678e0eea27f519822b85b0c94d16e4784f46ae21e4fa3854c8fed54ceb170eeb649fd860231c0a361ad5e1a53638b553d9be09336484f0810b261527d037d2816bf5a2d45abd5626dd4b5f1877bb4eb849cc34045efac2a951ae1af82658dcf9a0cab65c773db4d2da15c2d50d77424555d2ca29d6e5142796d3e7619653d429a749523965a2ca75d7e32aa775ab2619ad12cbc347a3799ddb8387e6cb0283ae844fc4a724b527202309881cf594e51c1b58d0199c258465888c8108c96d478f1168246c41948083f3baa08c09d24bd115a3920a032419b000a541da9366666dce39bad9a0cdd11a009809c01801dc807e3620815703a84921c00b27422528402205f89142c78ea411cd00790e50c6c11c15621df4a0f47d2da561aa8d59f18545a8a50568c5032908a04a00130518711124ef9c9e72801680f681a7e7c5678701731a1007061808e0ce0168629009218c082297075c8df055910105024e48481201704809501208c4c204bc2228f0f5996156813a16f0e102a01b13da60604d063e331a10b56878d9c0b785033374a0ca09513c40f5812620508242911044a53e6a0062c1461122f0d0469087046537e6e0102b410f26f86a5273828f0b056352e08149014b0534acc00a0ba4e4a06a410b2a20c9f6c71586387d503a8ad8c1820768471ada1399180fd2a6e97a90366dcb47da16192c1458f5237402242d2a6d4710d14f541e21611043e4100193e212b38a845b8cfca9fac3e40811247f7824f9a304cf123a53b5374cc4af166a679a88629c747121cb0b5460089f502d792224063f3ba0d488a8328b22d291f2c6aac666ca192aa2982a5e64d062c5ca15229c8049b0101135439a98e7ea2bcb8246464398960bb685ecaa012d0b6d0a17d2a24da145d9903644e7628d615dbabeadf642da3e5bfa587d216d1f27597da2faecb8a1e40326bc13868e16282646d75d386c8dc9da222d1f2b3a3e3154bb85d4644cc7dce4208ce3521aae014f46a836d012630687311b9cd1fabca4cab22d572fa9ac6c3da87fc319e16e463925ad64a63553a8d0e8d0644951e15cbda4a458f4c8ba21874069766bac043213686b03292d9ce5baeb1acbf5bf3765ae5d5fb9eebab66a1798bc4373a44baa0b2a8671031cc6a06991a59a2dcabc8aa0b580ab97d459ae5e44c6728af3220296eb4ecd554e6f5e44bad25028572f22544d5e45b0bc8a68c9d58b4856ae5fcbd58b48965c2257af224e6a7f4f334fd80b52922dd71917564e715c57399ce514970394cd3938bdf747dfefb8b8f27dfbf70c6b8f5ba9f6de686df9623c6fa3a219fef7e4dfeef7bd2d2160c994676da4fb99d7bc59e1ef6b237c270a3cd7b8678dda93b5f31692394cf2aa24edc844e5badb72b21b6356b5929aaed98e8c4eeb863b32573b324ecea69b73bd7e26b5bd2266e70e952e85d0cc37b0da8d111b03b61ba3db8dd10a6fda0e87aeefdbfcdecd142f910fde00ef87f7c3bf222abef7a0ff28de4b239fa9bd9fd2c86915bbd998add0b11323b6c3c1e936e289708f2bbfc493b8e04990f6857459e82fd0723157390db5743b2d2e1c38a3a0887c21a1a1a2a0f2874892bc118669d31d1a1aba7123934f96e4d974cb173a6b943f74d6b8e0859a2e295e70016e4409122488463cd108a21144444424113982888824ba119db7db0a1d4378688743d60e07a99d18aa2193e86f647ca661c61ff426cc300b6121a177e14266f9d84c9b2e4944f4434444b6271a1a22221a1a227a6c9298241a1abadda31b66b9c9958cb56fb5c296c4aecc56192eb75ccb5ce5ba2b4395d330d7324a32895c77659c3eb01b73b51b3325d7dd98a9dd1823f9cb7537268a04a25c77689c7667ca6a895c7767da540c72dd9dc13a33e50c9577462aed2bcbb75c7766c032489ae132a3558beae96753b923956367e66a67a6ca49eb9bfa383829cc9448e2665c99e160e499e2b2fd14dc2b9a5734473b9afaa6acca4f6d98a4a4a4a4a410aba85bb8cb4ee5f633294e9824ad8f4d0a6128a0e5b041e32ba768c675c97022c9a66c73647b312a86d93b6934da25d6a70cb384465fa4685718628cc3fdd7dffb5540a08bf325152ba6607f1b8df60928101173faaca8be15703053a34db6fd1c4a58b0cd1e8d330db1f8a57df2bc6fa1bc269e2edc3b91fd5ad93eb571ae6c2713538a31085e100441aafeac93db2d8dd49fb585bb705fb9c3eca7bd8263e3e433370babc15c655d5e2186d3fa953faf6e855630f8f5c4b9972fae57c6e08049d79cecd78416025b17e219f51f297d7d2a1835bab7ec9924fafdbdd915102850201e5b3945735ac96c5c9ebe72dfb00d62ac1ce0aad5154223f57bb80ab6d996905e3287d04ae2a581c2f7df7902da68876ee21ca2288aa2a0d6379a7a9fe24c32e38c5e45a31dde3369c51b5c87c8fde9cd7d466bbbef09c037aa96e98dae8f15ac9f6ddb6df4de1328a8e29ec0f7c50dd978b77c11861e181ea1f932dd48ba211882240e93b5467ae60b9224c511cdb58627099664adac46df1b790fe25021e3186ddef5b6d90adad215f2ad28ee67ab4445c6da553b2d245a4f61ccd02426179ff6a3e0e61ab8107f2d6f68d2110a6eaec1646b3555b8bd60d54b5546e2252ad75d97b45d173f5dcadacd19a15c775dba782372dd75a9cab608842ffb5fd2a6d9617de5a25c7758585ddff7d9ad2941e1d7a3ef85557d177e4110fc9aad79c5afb7a98c7e7f024b2a7f7fd416fc22f1ebee8bf83d66ff3e8bc4ee1a27ae7345d19fc1f3bb58aa6d414247ae3fd616c2355afe0df1ad8d697f786b5a21c63dcae4b51a0e30d7a6e0f0c54fb1f8b5af213e6e54fcda9720c63dc1bff7d68ac2c38d7a5fcbe579ff3357c85ebef8ca116a5f1b4f10c4174fdc6d3286e4ad2cbcef6b2e0a7f852c7ec5f5d2d25245ba4bf7bc75922fd98a74ffde9b8621c63d9a546b1c29e4ef55701307983ff0bdf205d8def5c2308f4556b5afb9da79db43af83feb1dabe7fd180307b27168570a3f7bc8dd6b39ea456d8885b2908976211ba514b768dcf75836a9fc65bb790adc875b7c549ae01ad06b31d97ad1d972d51b9eeb4206991eb8e06309bdb3bad3e2bf01d3c4347b23558c975b7052ca71ae4fe03e4badb82664b3f49a8b9fa9517e02a0afb43b8a095d15cbd9c5ce5d19263febecfcf347c7fb0e62ff407bd863f2982ffd984ef8e06ad1cbe356d1ebb04a19d749420c6f7fdde986f2d57d1bfefc56fc2593c8bc0ef157291f74d38fcb39620c605c1fb3ed3a3ebba11e779ed7dcd306af6cace1eb9242a09a0a2eed5a5f72b9a02105be8d66898ddc9e9168a4264a3e1d98433f820b4938e0c9e45d5c929dff6beaf4d38ec0acaddeff7633632c2356ad404d79cde6e5ec6f048cf133d10c0af217ef879df27d6aff1899f079e24986b2982e726c4a2c3c275c56c77850cb4b7e614fc16813078567b7a66c86506a93c0354ee27c74c82f682e3179253f0f7fef5fd2ffeced43b4312cc543238e5d7b2ab82a63bedfdf456c20defc39c7daf7c61bf33470a670baef8dfeea0de3354a157b06dff8cf5edd60d77fba01f4d052af71b0541e51467a9fa69938755b8f6363c6f46707ac379585bc26f422b855fabfd8c56f204407dae13d0eff76b8f67d104fac927a19ffc1572cd4cc3146efe48f3866693dfff4c17ee25f5c8da5959c9b6830ec2c27652ba721ae65ed1e5c98905a4943159d97da96202419a94b02f515f9eb0ce98be3861f272e6652cd79d172f65722dd79d972c12a49c79d162156505b5b37ab2c0ae0b925d172131a07580fffefb604362efd8acd864b0764ea0334c106380d2c5f3f103caf3bca8ebbde7795e6ae3c3f7ca11ec33a908fffd84f0fb8a660832dcc1af1e79de0c3b295aa47c3c71ba7f84bb4fe27b43f20bbf995484e60928e8207653fc44777d2425a9b8cf748433ba1ed47bbf3e6ed4de7c8894ad1d942b294f51d2a4c810654bd51794adaf9ce2b19ce2a09ce5f49f728a22c96952554e99b6e4b46a556de5b46ee5f4e61e42b545daf864d51d0c59be67cb8eeae9663bcbf7c290964d78f084512fdcdd8d2ea5e1ae1f5414ad14c2dff7cc0f2a0a7f12dfb13b42d868fdca43bd4bbeb648408245c2162cb25d0c604f2012a61d14aa1d94264c534f6724c4c095d35c773160314d7da577aa6ab7646cb7842bd7dd12ac5c975cc965aebb2554245c266119efa6ccc0b366a627b8bfa83fb561943db3a84f06f87ffdb9cb11fcbbf64b41e5fe235bae8f3febd6f4b29bd814aa287ac822b5092628ec38892e0997772b0aefbfcf2279b6ecbd879b92cafdbd5ba4ef3fa3ef958865a3219480e5fe23ef8f01e8f56adb6f783db1d1921e347a6d93cdd649eef72e0b23cb9158c9fd1e3ff007de43727dcac33592401670fa791e793109bc8a8489b97a15d179e055842b5c0104f7358bbabdae37c41887332e8743a69465216142a8f238f443cafbba7623fa61e67db66f4ede677b04149af7e1486895809ac241895de003cbc48f291e2ef241451afd00b3240640a06aa2970159ae3724314e03ae87bac226f999d5cb872ed79a50f9c24f5c26836c252992634dfcc410fcaeedfee89f77fddaae7f6d862679c3b3288667ef4c8bfa8ce139a9d15a9fd44afa3c47ba35528fd7fb8e1ae9fe08be7db7d7e692ba872af6a87afbfd471ef492ede124f7abe822067c19870de4e54a0681d3a43a384dcafdf7d6c4ca02fc9a6b62085eec4b47d78a4cf225f2f49349c764ac81ac0215010408501015909b0aa8ab02baa102c232058885b24a22d75d113a94b1a108ab22a6fcd40c72dda585e1504de4ba4b9b9296244dc71f3b607fc658f993e4cf8e3a94ebce0f1e387ed0e0d0250b95274c8af8f9e1c709cd8c88b11e88d0e50086881aae44712189102278a49da195a189e980d68536060b5a0b683cf0d491c383ae4f0e7dc254e9a3a48f0e3b72f8b449c387cc151f277c7cecd1b30788303667c474c942856acf923d44fccc39db9ddd90e52c8a0b6749d2f4fca0c68b9e287a8ae8f101688ff8839b3563becc90074a1323797ee4d1510686670c9e195e701212a2038f0e16c83d3b30104f6f78846d7a64f9b8000a548dc90f2920663e82008a12f708a933e40d913652668a903718a9e18815242294246113254300592244c41469870929a7051d9a846a9c84655c18bfbc506281c1ca52dd79f2e4ce9218ee4841b9f3a3ea0e0b51fe4839b3b233650e953855c064d8593973051c8305cc9aa1862b3b57b2d88942831d17b424d932a4063b3eb804b2a10fd6105de87889f36587ac3537843980d10a0376d1ca22860a0e4fc630d92a42e64799321d39844470e531030a71e607346ebad8a441a366cc9a2f3a2dbb5006af2a36a00b5f47da08f14387403bec0113c2f210841cdb4310d60d99b01ade448193244e103cc4f6c801c287363f6032635b80108232071fa15387054b46864747564626d63608329d4846082e65567682a6ee90011922cdec0e1eb1b679a6e884e5baa3d35582693d620d67567b6c4cf8d001d2e70f5a50191136387e767fb6d26c28a2ac02e8051b688e91769a0344c7190b24e0ec1861e68984161e235ee80144101f685040fc20f20232a41584e84ad4501321634186e03f44ea48ed5044a88c91a12d4784a0204192e4071e4ace96fc30c58689100e2d601a9a5439b12971c187a717f2c020876a68cd13213031cc002588aa4ace9028695284b01ae2618a1017952e5582aac8306545acc7953d58867e9841c8eb2a684c96a02d34e02a2d71906c89c3a306bc874bd01c1b6c6058b6335db0172f55bec069928573ddc1097243501a98728830a50f5a6f76104306072d3de6cd93ad1209992065deb090839fcbe589c96346ac73461413775083262cd325a6664316b1a4a95213e6c22e4c495854d86bc29e5a37e5c68f1bb3dec9f1f26233e66b4b9b283a28d9c18d0fb020341eca7a1073d3268c34f3660403e74a1c27623d049123e4c787d2ce0f71c676408c9953031d920a59933a3c0809229010363c6540d8e1e14e9a214831665bf09456799ae8217206b6630fd9874fcd4e9fd107b4302274f0a3fb73266dab880f0c20d0860e54bbe2144547e8020ba0921d524f3b00e13106ea41840f3d50767ed0012227c8e7260afc12523b33040722a117292d45ae18b13a4285844912234a822cd181c7d4178889e7a785b326769ccc7121ce0b20180c5e545d4fbe3231883740b1a12a4b942a52a0583999d22609953644aab4f921439b272b1fa02b7db098cd50e70af4214b180d3a68f9745bc41c6a10c3e5fb620317ac2c5dac78b1fa1243960b374c8139126688d60f315f4f387881c610b1a5878c9d32747290c3e5c64c9b33df1a3467ba3c3269c2a8e9b2468beecacecaeb099b265f49da7c447400b2031b1e605f201ed07ad8790de10624eb30305df8460bebc299421587f492f282f272ba623b3eed72a67677763b21e4b40f3bfc504b33266e0151f33247cc42870ad9933a4c82088b08b1f35156841d3d776a758610331377c093264f6d8c1e2f6762963d55f840e9a37312a2e9a2744f192c2224e2cc0f4996c5387f76485be345acd9ca598096ecd650c963aebb352f78a06fcae922d141d635512cac79da313594277caa91f120d580e51a1a355a6aaa3299eb4ecd54f75003444d0f1f6455e304655627833efcb0a18103a4c382380f51363419dc12126688c8257b59883816a95ba5484f3172ab8e906990a41192bd5c7769a090ecd2f0484256b3cb4fb63fd69be422b947ae915be44a5d2277c81572a36e900be4feb850d7c7ed7179dca7bbe3b270755c270fe480bc084ff33feec7897034efe37c7c8f9fb91ecfe378dccc87f03b6ec7cb5c080fc2eb3899d3f1390e848ff90fee83cb71318fe370fc8d87b91befc1797030dfc175f036fee56cdccb77aef335aec6d37897a3f1336ec6b93c072fe3647ccbc7380e2ec6b53c8c83f11b3ccbbfb817efe2586e8373f11a7c8b6b711a3c8b5ff90c8ec5afb81597c1ab38159fe2562ec5a3789543f118fc8953390cfe82bbe04ebc89b7e04c7cca97b8124fe248fc881bf1222ee5447c880bf1280fe240fc8743b90fefe13cfcc977380baec39d3a5003ea223aadffb49f26a2d1ba4ff3e93d7dd67a3a4fe369b31ea2efb49d2e6b213a88aed3644da7e734103dd63fb40f2da7c53a4ec3e9371dd66eba87e6a1c17a87d6a1dbf457b369afdeb5aed7b49a4ed35d8da6cfb499e6ea1cba4c93e9ad1ed338b498d6ea300da66fe8acfed25eba4b63b50dcda56be82dada569e82c7dd5333496bed2565a86aed2547a4a5bb5948ed2550da563e8274dd530f40bed423be926dd4233e9a95ed24a3a4923e9236da48bb45413e9212da4a33a4803e91f0dd53eba47f3e8a7ded12cb48e76b2812c205b844db37fac1f4b8445b37d2c1fbbc79e593d368fc563cdec10f68eb563cbac1036085bc792593a768e05c28ed91fac0f568e15b3712c1cfbc6865937b607cb8305b33b581d6c1bfb65d9582fbbb33abbc6aab1696c974563cf583396cbe660cb58325789adda14f5d14880060d0d1e3462544ed04c7593dd6d2df0a20add33455851b4f77d1e2ee2812008fa576ffd204920f8200882a0631227f596f7425c87d5b3defb486ff7c624ce3110def7d5f05edb241c431c8661183689ebd3cf3ef8aed08257e0b03f5c82f7be2ffc3e13e996374f0877181c36d2bd234802bff0ffe88ffe7de96684e22b2058adc2afb9f0bc8d64da5cf58430f835077ade6d1d63f5259bb39fe781effd5764f57dcd7d2008829f8fbdf77d1d8572639195f735e79dd891ee8fed177707d7ffd69c878dbed8588f3eefab8f4218e97e75a47b6b14b5d826199266e332e4cc46456de5a02ab96daebda2b2727b0591ca2c72f502c226ca2957af20661ce4ea05842aa3d04a2cac706a1f97ab179db09a1b814a10b17ca395fa9bbc8280e57e1b18ac42e079df5acb955d34da495508f517d67e2d8ae1f9eba2182ee3c8cfb408043c7e5340ab508a1865051a1c5495d36f902c6d1f29821ff87d57bed0cd5f01a4c833e8a78c7cbd8448e5d44ae57e3b25b54150966c2b552f2150331cc9b6a861e3862f896f9d6ad4b1268660f9554b8ac096a220e3f0b4a2306f3852ff0c5fea34a9a2c0420b9611366a5459d42b213d424602a2eaa864ab9b2a63ea10cd000080a007a316000028140a06442281244bc34010d407148015818640584a1ace8220d051180621c38c314801100118101818116c0e6b868b232aaad5b5c3285fc9ebc4cac05f381b341bd2d25e31027d5467865590999a5e22b3a81b03b86b669d18a860127db85e1780df2cc7fa1a6bff0a6e1641f11a7fb5624e361067d024f15a3f0de2b1aa69e109402769e7cee8cd773c82991b1c97fd9a7ad5aa5810ba1accf5b6e1f2bd7b5256e438b9400948881b18a55f75f002e23e3828d64f1fa5c643ab6de2f1e13f495b54ab7e515a1c8fe6737cc02b386025ea7993aac6a32cace7580bd7096341a01544aa348f0207d43c4c52d4c1dfb698e2f707b006a64f1e6c30fb2757e039f540d9b65cbae48542378e23df897ba9ba27ed89e2bf05ffd86f7ee7a6de4e05d4e630fdfbb9e30e0ffdf2a91cd75bfeff82076a4e02080c2a51d045f2114148edb975b2f103259cd89a5bf7780c78ab7e5080cc863e9ca4ff7eec73166d4e853762eaabdbae93341283dd2244e87bd53f2ef4305762ccb5a00ea436d31ff8deed6d5e9d82897f4026e806d19bebf549fe92e6b4802693ed6eef2be2965a15d693d8a5d0dd18e0eb84f8851684c87dc645a796e762094d517ea4f4dccae1b45db0330b07e61b13a1f69c528bfc8a21bdccc3fd0845a60c1eab04a2c64379f4a9299927ff877c518810b2f9f93dc4fda2710011a37c70698bc3f6f142ddc0e8af28c5d552c23712815e2889f9f7aa1e4e1d7a5b390ac8884c45abd67b630901e5124ac17374c8463dd3ac2ec34e033f9be4885212274a8d912f98830876c7d50a16486abe32529e74768d39ea52adc594cdc646eda365acf6116cb5e2430fca3595b041fad2498f30958e16bdb450538eb6e54fce5b05b8e1727ebf053ace183e7f5be2826a04dc59b5953a4c83d3c43bf952909a9953ede34339f297aabeb342892f4aec1766fb4cfb4efb2fd155c5c41a55ac8a087acb3a2338fe115f3ea68d053b22bb1818a8c64fd21abc298a927da911bd11e21245c942a4a6ab0238c5e3a250ecc0bc0673ad614345dcaa2733081282c08c5b075751f6b7abe4b408440e4dd8b8849266a30b760369ef78cc225f029db8be4bb2d2d5cf8bd17b376969d0b02d2acf1096780a40eeb7581c50f65e9db254019a0762c94a40e50089c4e9dd07e0974e5a364ee94dc452a47123a97a2c4ba59462cea3f0a8c5135b18c904d0dcb4888261cd191c2a8869b62232688d041760a588442685b75b922cc1884331482e0bf96041d2fb027daa8bc263baf046263d5174b92293be042cff1496b84aa96c01066508e054d500850a74b646df7b494ae7f8af40ed790212656b6150f81df863752c745d4baaae3435d9225f9a56e2968eff183df6a76d33d1ba940923971984318a48a474956784610a2398acd1258708259aae3bb1942fe0cadb523902c82c1c0f16701295c7272d3c5b823b8a9ebe23b246995a61492a5556cd6e208863b0cf3c7508bec2cae824ddbc3368f368c619d45766b5fdb3fdbfaf7ec75792d1a74978edb77ee406757c6ceecb4fda075fe9a420ffed22072c7105474e20c71c7d1bcdf498c88a879e64beabe3857d8fc486097cc1a7d1043fe6fc2b246662844b9b75e7b83d823d48004f80d5db27a5f3282c366bcc1195a746cf353ce266b33d9d5f563ed3b799f72fe952926668e279d642242b368f2ace94f670cf6a9eb2adabae633cac7c24120c62982085b903c768dc42146c1a531ebe9cd615da85186e0e5fb60aa4780b3117ca1937539161af1958653c12005e2dfccec6511fb12f44ebc37bd123e1e0342acbd21c906a582f044f41e119ca0334219e59143247a1e94669601d3644b5a126e8440ebe03a200dbe9f0561f6570532a50315f71f69dbcb521b3e138fba7f49aee9fbe6a3f0828a008e073f90f634766a7d515ed40c2c3b846cc226c1794249c0348bf8536812da782516cfa28d0219c017351bc73109ab628b48300cc1997ed41494273890d5b14da63083159adc8266f16bb1c98330edf419909e5e03fe56c6d88862a0ab6200c38e3617ba899d01cbc53cea60d31a84ac116c410771cb60f2511cec97fcaddda90504873d453b883cc84e50a0d445a5d547808ce8859545e3986f41b0dc33d308ae2765033e19c4203d11b085ba14874d047c0d42dda76a1a473e8cd5cdd87a614623b21e00029822c6c9fdd3cc078baec3e438542dc1c8a2a4451a8093dae95a8496125366db29c89ff154568c706232fe10b7d4c9f7917a83457b916606493a023baae069a759d2010c982d385c0866a7a1aec90d28b22b08fa52c10f26565248b7a4d9a7d2befa222a333f5cfdd9b7eb6f8fd271eb9e8d14aa2aef8ba77871edea3caca0bef7bf636cd79e295f17ea2dc665e4e657223ef4dd46dcc237bf96312f3579d2dcb660f23a253595bf7d39cade8ff5d71ddc82980d01fc4640bd01c1e3c0609ce90e53d7bc4037416892b6cd0036778717194c13d1619ff00f18a027f3206c618453e47781bae3002099ad0653a7e1bc55dd34b227bdfa5d258b7475cdf693ab63578179ecc22049af0900c30a30f1c32201f4d9af32ef791850bd461a6a5b0896f705b7ec0a16934e9124ab14727d9946b1711d60c9e7c8449cec1930720c919b5dc8df294e5e611aa09f3040e28eb0384b98ad17db9cae9a311be0a93886066868e7f0efe14aab48d507997cd93549381088df214844b3088ae23653e4a027e14c37f120aec1afc7678331a5811b3839a09e7121b88dc401cd01c57a602ac38af1c78a7784fb85b100634d7c08ad843a02138f64c5f1a21849bc18ff2802a896bc96be2bce44d5a0c784f003c0873f0ee29c877b9cdbbe9943d0ce63f82f71e6277f0d74a955ddf200607467a8415a991566a61fa85953e55917134788af5188ec13ddbe1fdc913a031dbc4ea923649e811e0735584f4df8783bba24020dc568103f6be53314e259a817d23f9f064f70b36895d65020a48bf7449b06b1bc9fa0b0872ec673529029f472c2ac0c29d73c2520729b0b41b6c08bcb06f2766fe7c5598a5d8ec99c0f6703da554d235ddb63fa8fdbad13342ff01e692cd9c162f3117c343afd5deb2bdd05ea551c43b795aa42b1d6c0d8b963893c237afc049a7d43c98777ef5fa39e6a40b6f4e0268b4311f2fce1320db867546907196ed6993ddf062b776824eebf3635689ba59abfc81fed1a9f0f38cb4ef436e1089ccb8edb00c3db689f5597835a435a1dccd2598dafc4d795116aa1700ea9146014cc64db439a78fe9528e98c699ce7d8711810b075dc4cf13e5c4876dff258f130fda0b0a1477d0fa6a2f231cd33c33529119f105f532156533f2e8bf2f42e465bfa4517732ba0de82c0a82a0ea7fe6ae64e1236bad8d06d58a007e1dc1c9ceb82e380d9b8d381b9d1d682d918219d570a80814ea044ca15306c17423b8b58715d4aa6859e07d372aa8cc49ab1956615c1b91033e2c21ac17cea36f82c18edea277dbf41011108b1c14105737389704df546188556a51f04955ab27647b57817c0e4555fc9e00fd45feb7b3f03579840191ce86c46b6c735631b2549df22a09459155a5a98048052e2c3d54025c62b93ea6a41500695068d47df6f7203773ac964dba49032d9907db8d40477f0077b3e613fe3d5a303a830a7ad0868359da05c1e3a14b07473684616abf29a4f780e8c71e4e420cc8935144c2297e0c304814ef6c422534f8b771d962c07c9816392dfa8919f1b063ab4553e1b8012c54abd9e6cc2d8f306fb29c30f673644711f8236895a82fdda7fab5db967639a0a64389d764418e51cbdeab6c2ce0236c6c2f7613adbbd05a5968b5868a17740e9c01eba07ab6b60f7b6bf6151d69803cd687451c06d3c89f499875fa3db3cf90eb688afebc1b224a72fb05278f3ca1479ee0fbaa93b1797b81494dd299e62bb339781febf1264622de8e5f5ab427c45ea146b7dc4584e260a088e1b82180142b97d6b8314bc46891e7b0141f700a94a434c2002ee82b55eef6e5ed0341b5c851d7f101b4689cc5e98684cf5642a99b03525ac769592ba416aa947a9cc6ae4672adf29435ce7dbd120f7b01d27aa13bac52a77f5dfdd59561ca411f5d443f9a7cac1184c0a4f253a204de675a78f96ec8f4623dc11d6622d8e38880aec8a2bdde0b3b00212b39a279d29ef80366f435254ec81bdd8b087b427ae206cbed771e9cf14a90837fa04c419b971fd0c21ee9efa8b23f70a3e9af28ba655c68c1446113d7bdd808c43494fe2730d151abd5c90b0514c9dd8f95ae96fd1559c4dc3fc3a1100a016343c6e9a575f04a081e60a26f55bf5dc7dc01afb6e64ac4f107b9b2e57f15a72d2d5fcd97d2eb593a7863a0b2866eda5c9ce48e88673dfe770739f20a31a8b6c7871f195544f0c7c0aa7111a63947815c71a0e8568804e40a53d0b8f12a61623d4aa550c0d641b4b1717c001f3fa14558c7022cd3e69f5bbdd28f748f2fb36c15be2e454173d361b0d9e358907019d1838786fa2f8e91b9e547609c3c78656e02863806286c66d36c2c45283de078244fe1edcd2c8e4d8d8677a814be289149f0a9b4289f520457ec1c4089569c63f48d645967d74ddb41935e5d2c4f2bd442ae977b6a196ed4c5e454fb2b5dc8baffe4bc435467a65efabbfe90bfcecb7c8fc703fddb5b9f2c1019f3675a9583fdc14cf9a080a0592a19136fdced97272e2be4fbe44306b34dec4714957c46335e8c74bf41ab94270b74514080ed39cda52f63a0d8592aa60a0cc303ea35ca859dfc7eb189faac3e9ab1b55e5714a8819015c18791fb10a3df2d57d25837715c05893ae11451dffca621141e5df051b3de42b84e4868e5648ab3fdfd7188616300e7d528b6216e44edd721149eec710312632e05aba6209f5f4f94acfa80226c7a0decd1b8146c49a91149b6487f0820d75660bb111ce60ee87fea613b80f01235415c8ac8b66a4ce6e183b9661169d6d620b6f634eb4216372020c5d1d27d480b8085ac2c8888add9d3cd844aa9df9eb2202c3904741b05308a1248cac10e2dd093a174d68828300b8424043cfc2aed108afb2294b1b71224b080d1231239a3eca1de28bd834122a404ed50b23949d636f90101673774b5b3286eb87cf65f355ef2b5b823a6c9acc3cdc3407d27b77009a9597ec64a74b77207ba6c4b2162c2864af745b2e505ebb9e73b76d6f2460c4eeecf3f27880474028d8f2ce714ac822c7fd3102c23122e7e1afbcea2bc6006702c4f7b4f42e73cb4c558262b2426ece6bb0a5fc4cd3f214be6e9d1c22f546a7ad2e183635c1b65680a2306c544f7f9d88b9d7c959e86688e27c18cb0e18658259341431af9ff585c0173c64dfb4582217bcae994dc913e7f95e50f0facfe3e3fb835cbf87e321a88e9e6f40835f4278ea27d728ff2503c3bf763ea6c46be8f3be2c6064a99459011e199f5e631865e0d633cdcb813e803ab9c03159dce35df1f3adb973a1e20d1828789fc418068a7752441b05974fcf4585363fe5162947f16221ea048f8bbacd4fa5719b2963515ff62199035c1d7cc870e8af155d817b5db323fa75fd1fde8927bd694117800503b694dadfa412cbfee58c2ba4b3e1f42612bf0d2c7a546bb14c28b51c20f596cac94b2aa6ad4bc111086133473a872afd0de802a819a39b07e8d3fa2fd03aede6334b4f40398f8ff29d03411a5489d31239350cd4caf38136d493b7f4328cbfcaef3f1bdf9a03f7672ec4fdf33c8e2226bacf3add74ff604720acdda880df8546b1e9b56a9cbb18cc56a902aa3b2b8ad1d9248ef786b7e584909b130e266a93be8d09e982f91890199f74b683bb2f18e7cd2dab042e87aa18853a2b2f08a47848347d0c02b504cd6483b9a2e1440ae5a81f488ca227a734bfd8e5a3327a22b9aee03222154ef0a34e9b73e83d12251075f001155598895fa202b8bdee94fb18badccf5ee87b89aa1d7b8e55def4a64651141d6501f42561667bca6409b99f03a3420b973102c7b1c9cb52ff1705cc4490b5a7fe0dfee1e626e55558b31c12ad0dd57ac5b2e95003b6c139809354862909545f03227c294b0bf31e4fd622cba3d75051edc6c4fed3d85bac9585c2b5a594c04e91c10ea6833385985477a4a669d2a8bf6136458161e78501fe5835e7abf54f09e212e2a5a73bb0d4a3c7d1d7f7eb4c416e2fd883950cba2371003dfffd10f96f22c35f26b48cb82fe6357d362654d831b12657955650ca8cb319851df627b16bf6a6f81966bfe58fb09b27c3bd7db9721d26ea7369cdb9b3f6ae48182fc3d6be6a7ad9feddfdb5398cc1bff9e9e596604b424e4c5aaa299916e060583cb4bf7805802837208101da4c59030166a04fe04dd1e21bac3c393f9f4a861dfaff3eb9a0185d99ac00e81b4e621a21575b39f99bcb83b3cd290a34b8859830dd82b5eca8fc0406c2150a05791d27579f7f987a38b62915c089ffac92c8baa40360ea185a6cfe116941f390f77fad8850b4e7dfb1492880c35877a10e1e2533facfae44a3a5025465730a44d998c1788b91e89dc489a6cabd6cc7a8e230ab9d7aaf886d74ae424e77d4aa6aaab6fc93e4b52f0d7e45c7c34928e880acc7f14990a26653ad91a2ef60649693066291a0a12295ec440b810f9bd3070f9e44f3860e62cfbe29b65223e89430c75338d6c38539e1f422889d0bff9c994053325541fa84c22a95a089cd36673118dc65fa0261e0514cf26d38a947ad250e123ad444e82a4b2daff13178c0906d56d23420bf1e62146f634f5b8e2bb1d3886204fc65557676e507bab4bd327418aa9259401ac506bbf5c71217ba10269598d8609eb22f005b629d959f60f1d407d03212b7244a4f9558432d344d3d0a91524ab88ece7775628b2f7adcf6967702df0e5eefd72de13364a1c2d8239f58f19be2a70df8ccab6a5828a1d9c5135a3ef281f2494262a87f783fe4549d75cda2b429acf27c7233485b20b02a0850e68be9b72226d58d7d14c9f56dd39d217051cd9af0b120b81722bbd4bc76dc7b040b2f2db54c60a6ccc896e2975180de8fa3b7693b1800911cff689c5e10988a916f1fcbde69a0558bc40159009c554191c8de9048db46657a56e5f75329495088b0100557a071ecc7b0f8eaf12a18b4fdd6bc3b93cc71073296f5422e222e3905fe541073b57a76c38a692a08be98236d8c50a2f657ce4cb4586fd071c76c857caa4fa5fa20c89c317228ab999d9111b5a201d3d032b241613e77afc8b50e85681b8badcb27611606c9d4c33a90001b98908bc08d215c375c10342bac418f8d2a2f0e3369d745ed0073014e838d0a0b8189d4ab85298131182d4fa3931f4e691c982971c774512021a13c08f76528344062641e3bf04319480609af0bd875595c6440d4142079133fe8030e131ac7d24386b2027be133208999515b3f835f3d7b0a46993fc5a579312fb49cad1112e33a8608286be1f615a21ad05d903e35c493ca4a540708c3a7aa56332e9c38e584473b108413b2a77a16b07dbb20155056d546163cc2ea2e5e66932b2399de655ee36b7ac71199ec8c89bcce7fb20150a0f8e355a58eadc19fd18d0254ee0236c74577f9e80330f0560223cb332c87b7b3105b208d435c3990527627c261661e0f5a9565cda2119714c4c8e28c4db7a3013f0ab4b6bd562d868aa4f192932b50dca52649d27f9cc32264b07e7f790aee71fe68774731b44fdc07db6cc3f76341f5f65786c347e680af6f8307cd6bbd0b14c0466d0ee9521a0efcc43099856d0b08c6842a35884e6f1a3010dff29205f0300667a2a3485c246134927b5326aee6f2528dcbe428ef83bf54df16d698f1440fd88334d5aabf8747eb44658b931dce3aa6ed2f1e799cc421d303b798c0406a9bb68514a285a024cebada86aefb37f8617a73cbf82fc140522c3541d01280ce86089ad75d2eb9b172f32cb5e1bf7589bf912dc749bb1fedd1180f4da9bc11af965844494b297ff3ccdfdef08acb70c7d5fb065ee3d11638add6420c7cc0d4865b0513c15dcd679753b7016ee6c627ddbf4431a182dc97ad857712fe54e67219c9dd6c547786e08ab91cc0ed550141bb32b124fc9567dfb50e6d99e04665ba2a1ad961bce38e4f56c81aff3e47e4313f2be2b1d8013b49408ac8ba1acda8e30bfe5c73460440b89d180fb220aa75eef70d2409e0c9e37cc881f02cffc8f977ae9d75e12951ea802b644cf8199b996a0a01827c9f5b893d40348e4f09efd1c1a4893a92597867d696b259ec97a102916432000f223216139ea91146a21521cbcfbf1280b3b4e656b12ee1691bae619a69315361d23e4638eb0a45a8ae8df728de0859d0abce3e8fa874ead6e33117ceec414e73a32e30f4f2e50ce21826c3dccd17774bf020f67742053dc97e730933746ee73b67e46f946d81f2d094b219a37dd17a6e6ebce1e4dade882db713d62371d92691fae175729f1ed8d90da828303eda84f0c68f3aa64de8ec713bf9e1448e4d2fcb26f854f0addb0c0126b891f09a1d49dab55771ee126e6aa5f55ddfde4066cf5889a26385cd0ad8ce76141f691243b1ee924f36fd094af04ff289ceb9e2cea56e0ccea1d22e864d99b132eaeb26df2d0a7b26699a468c39484ae17eb794d088e2890581c782164d44fb8e01b70c0e978383b78e83751817a7dab51f9785338cfebb251afaad38721403954b582e7ee564884d0925263c9b16b3951000efd26408d011b7ad4e70ab2ea0a30441e04a8cc066495af96734b0572a3afde3ca701dc8147406815888868050c5aaaaf93ebc8e3f2c42cb1e6d33fa57804c82947bca1603435991da16dac2372f8b056ddaa3884e5b9686c9bc295e192bb1499a0a147ae34bb48428521b2d12f877d082033b536c698a752321cbf80493d5c28e1d4e299d0e6cea59d94d2a736a6352300fde4e305ac572808c8658e608a2926e32c9a002100f20a41ac4681009476e60e2bf621deddcf3a8525b732f9ce2515b3c66d8cee8a13f1a1726a68434b58597c43265ff8cdad64503f478df6c318bd72f0f361903b9ba4cc4956335de62e7f072e855bccb840a6158b54d2f84d1e832a42549da4330d6aa131a98e9b248da3eb1fbc58fc3b2345ace87e41ca33870ae9d488f31bc18b91b982b7caa6ee96757d06a4ec485d126af7727ab66eb7187123dc740d4d31df479f7d335cb30b37e561106bb7561e189367a45e1815798a1392464bbd6778742b2817d526867db307af6d1f79ebff8edae24c9244abee63bcf6bfaf1256c99a57985c64c3d5aa3c66dc451d9fae39a5768862a954ddc73e895aa2a3035560cf7e54d049f74ccffb1da5fdd3337914f07d9f40c4ec2a936f07f167970883e932e1a10ff312912b7ecc15e7992ea15855f1fc7f64df999eb4b3d71363d21222b7d35af32d8c07ec8669d486b33cb0893854ea9d454b62e20876d6326a564cc1a3f4c7ce080653c06f32043510a947155991e74a45884d1fae36697e287de62429ba43fd0aec4d8dfbea4ecf02e50d447b2e96a879c0c64b6394d23e879043f6f0caefaa4b3fea84314fcf012cd9ec5b996278d16e36579fbd075108e6da5e770a9e0662958d83a34ef4ff62852095294d0fdda8c329569d08da8cd052ac30880c09ac14c55619e78fe503b3bec5b00eb6bc08613c7385fa3daa48a0db3c7c4437ef6f8cf540f967225f8d91d804f0e9344c76b83c54ba7ab30309e9716c2d2bb937724702603cd0c259df2901e4f13080eaeed088db7e8629b8c30b87a5e08181aa50b4eaf02d681ff82cbaa6494346b6825ba1cff7ddcae665a280f5451bd499053b858dc4a95a155a20f0ac87ed814fb53bcce04c716237d3428ea1d22e0045b0bf18d228640f74f6e80fc6e32eb75c84e9f50e26ad44a4fee7df32541fcc548509f51465713dc5bb0ea5166adc7bb155916958a284fc0907cf4aadc537627750ccdb1f203e41c34a1da89bd1540c4d3d15ebe56fc2a0f72fe0b4c75ca09f778e47f181e06885cedf013cc68a4bae771da68a4b7f3edd243c1b00bae6bd6cfbdb953cd9de4d6d817d5368b12f1f1fcc0f23f38c212cb1ecc66ba0bd184bc394f0e78c26a31cf163b677fefd1f25675d10a4585ecf2790da2deeb121f018da13c56124265de22b0adc3c03cc4360b52c950762bfc8311cf6aa7b6b8fb7a69d1f62c79a76f8eb228a16960a27c6ec6572d54dcc2ac1cf6feaf996e2f073d4e1ddd5b5d2f46fbb193e0331e84a5da856cc0cd1f71c74745683a1e58feba32bc5ec22d673a765ba69794091250b4d7eea039932f0757f31ebbe14ac9804a934ba2c4004938476601753c85937c1220f8141945f76a4c945ece2a25b431f720a457225bc59984a4b75da02d215ab5d1adebd48aa1223c1fcfecb944b02345311704ade913f810baf0a1d80c49bc417b9df2e75b03558c9dea2c2890a2544a2fb86789e25fd1f83673bc3c7fe983abdc92a9677f6afe86bc136499c176e00814e093ba9aaefe9091fc3fe36bdf8f78633b2b3503bf96ae428430b46a26811b081977d8e875d36f88ed8f3376c68bdc0d84db0d3d04f66e6ca3ea93b9b38cf36c2095185a4ed3a267dd8218ca8445c81ff602b5a0b459cbcea160424ef283cabfe989d12df0624d0e90393208be4edfd52436af31be18f5537807e4b99e0985773223237549ef3a75bb001eb70025ea717393b3ecde934c0cc600ef54408da38bc63b4abc7fa03da2552958b892840280a9b62fa727ab46922c29d44cd9c9a77f0e0598b9528449099a0435bdc38d8f1416e907a24278918106493c9a8866d0dd491c33ec0f71218bd22287c56558fb3391a1b22267ea083a15e18ff99e190c06cb2f523858db0b22e488d34f9be408bd24b874b4886f527077103fda53b860198bbd967ac2d10651cbdcc253d56a41004bca6ffda130410dd99bee03025ad4842d79ca02e8341039a912a7210a7beb27251aab6450cc89971dee5e2d0764bfc0fa3e865051003ec320881399c1f859b025e32de3dc6079039a8fba0dd5d085faf943887a78ded06ed88a5392c321090655520dce7ac10600ae4156ec696ec033f0a1a56c1eea26bc6a2296c37e623233f755afe08730babadb006999c2d5ef7a72a1d8ada8155e9e5ef0af33a7d99fb0006d4b73c91cf86bc87d27ef7e92a9e48f11e21dfe92ec1af501de248a2fb46c88c2d7f592a9014c211e163c0f6d98e498acedde40dbcde90a65b7eab77257d09b71222277623bee42457c80de6f804cd30b9cf8ff4ce1db17966d270f27c9a3bbe492a44c5a47b6142d452b1fdc7827833a743c7031baad709e5b1de3f68e15fbc5ca9260fd41d884d512a4f75fed84c8cd009e9cbb1f6c5e681baf78fddb77bc573b2e8c26c3c0172aaff70ee2af5e207302025278cb24bfc080e0f71207db36d9bbbf323471c877915160742ba163d69a14d7d51b469b2bc224cf85ca9094ac2dbb1a10c8e69ee7f96093f50c6208d5f3dfc7c047a605d88139e5f2f5dc5a1cdb304f484c687a903e5ff9e681570543e1c25c61babed0f0173c10950d00cae417165d1913bf42eae1aa48883718363eb9a0aa8307d89e3bef73e6480ea4ef81656f7e6dbf68b2758e33eb95979d8775391f4d0454738a295cc3f1801ff041a936f8f831158c16b030f59e89fe911c593a8252d2b1a208d41f7691b1e9013c224831981a3658bfdc195e07cd15bdf19c38f371041d7201e80d62bc2f61d383ca51f6c3f84ff3080dfb012b35ab881ae56ba73c9077678414e517ae864bed7a64ea6962c569786fe3f689a2aa3c114cd0633a230f9b5559045437f989d04082888559eb23f71aa62a19aef4c0278e076e6e7ff0800bbfd331b26115924e92446051738fcc36b10f4884d5302ab6431cfb3bd3480f43f225e432fa4d7a30d57e7b21d0cdf05345fa1424e6e66a6e598dfac461ff32abaa3cb46b2f0e2630596a4813b0db484c33bda54cf546c43d72bae3039ab816c1cc3968bc9a61086011f8e2940633e27e878e652f973e1d221148c011c7423e7be90de4fb760417fba0f127333be2144651f8755a0bcfa67f2637bc67a233ac1b2ec9068adf855c6d706eb8ca4892e531ea73be160d8d40b65af859c14f592347a013421504ece27c13a99362bd4e34ce20d3e0488bf7498e19bc3582532a9c2efbf531bf01c46c28a46b3611abf34488729bd3c258f89c881809adf920981f2c81690fbcf04603bd44db2cd538a4ed0476c97e5ce4e7b5efd8bfaf6a1cccd0a4bd0edfc0bbc228367a28fa3a06857da8557764e42f3cb55ac740477f8c23b7745d487ab95f59a068f2acec4d113b3ea880f3b2c233032adcaf2db0a418fb920e431c275ea22725f8e74b41c2439d0d11fdc013fcb5afa1e882249a4baba6b1235189c206f5ef8ee1163e814f1742611594e5c60ce9ba811e694b3d338a012feedd9d2cd906a3b841254b13c8e779ea5cddc479bd58cb2b836c7f3678997121f647ff43eda66b6fee32c01d31c93490ed99d5bfc7f9b1f4cf1277868877212c8b76c12cd606c9376cd489e071d80910befd8a8ed98cf196df396d7738f0a4e3196d842f4ed2a074ee5a0b48fbe6fcb4707f61778b5fab12274ae17aef04098168165bf073985f5b405e32ded829229ef8ca19fba89c0048b68f468e3f6b890e60362b24e9811f900a55a73da903f8803e22aad3357b7b92197032b7cd2e3d6a6c7416a630880d6a8e769f62ef36c8d8289a8646611309942bd4cab4429a7ae827e2dfe3e1b3dcf04dbead38b4d38d2fb439e656299a7c906a4b6fe7b57f956a1b8768d144f34215fceeda6204c3c1e3ba84fda77ec3aa5ff006f02d7a66d24b1ee712bfaece55e5df570b8d2d9ea770cf71c7fc234534db716048a8a380bcdb1bdc3eda7f3317924bc19a5341a8eb195c3ad017e78fbfe2860fa7ccf96fe426a4396b309a215a5917f6b998003881503aeab4709bb94b5aab004fb0a41c18989c21b0c73588c7b586d5ca8120dcc482abd6c4b3599cde3fca5889b9b504d2ee25cb07d218696161c4725dacd44e6acbec03d32e8124d7c9f6e71286dfa9f39325a08a748f7d33aef734a7b1e5d4a6d8e2611a8013461c6726148a4b488b9ab4de3361f111828f08ba36c5a1973dc8870ebbf406c8ef20245f1c1ac1679817490850bd6a7679626fcb5f72616508e15ae125fafb500c93ccf123a15824ea3fd8f9f82dd765fc6984053626585fd766e90fd0599cd83b16a4f05f3749698c96a6f4abc48310d76b7da5566ceb5bda5e44e2180396357270802a057c7b6963f07e94c75d954360e7b06f25d728212e548f04390ec345b0d989c5b797dd05126c4c25a5745815084d616e2aedc7b05213a07eb2657d2b510220a9507e29e3d9e0c5dfcb4b84130b00aa1793cd06618efc0297891a7ad08c6c98544e0032551cc37e569976b774f23104bb23171ba05d282c465cb23b9199cd16608bef80fe2c71fc5bffaf230310a3dbfe37e15867a2fe00153b14580116c1c8ff89bbebc8714ca65d4a8e96938009ddc56c2ff8440c167ac9290e28fc13d1a277a1e29e66b52bad20063ab923806a5a70eecd49d4d339fb6e9e2d40289e3a7e6e3bfa50cea520d7b425ace2359ca38976542860cbcf0fb6e96e909336e0f7863b3cb4bf31d0dd7f9e0a5e7e77ca2074f325af137114e29ac7523733d3330453f307a9c87662ebbef4e392c7aec49f059d0553138d6c053ddd2aba692100a48f792e126dd7079e61a8a0007f55955d17d52e9ebd310ad7bc54958f6c26e38a6f07603258acc8ae27461f635763bf9656554ad7b1b5ea25e28dd5f5e1637696be770b7277c7adfc60cfea05c27eca8a13983f40f8910c81ed208d70175cd03f2d4c3c3f34888ed2674ca0329a40decc41d215737fd348718e64b3717df049b787816fa567c6c4cb9c3c031f5d577b1726efe604b2c2411d53df136913eae6ead31519cdb0bb6b441743b195578589a4c1e6ca84a9e285ed63e160c3c02c1f4213b0da98b5ad89b68eaa7fd18aae5ffb6bbc4a2d000311c4360294615bc839a64abf5f56ce6c05615acd85c15e0916e593b418e50c999038992c72b7e3ef183562cfa2822c7a2c963623af63d755b406345f038fb95047258665417d2091e2a1c0f1f342ae46c559d84509f53d829951b67e230fcc91a59d0cb1b324a6abcd867593f978cfd8a065d6e967ac5e9281f8a15db66e50d551fc4b2a3239c41a69e662b2c5d102e9541a9415fbf9475c458ce96efec62a1159396c4d75f49c85d189c2169720c7fc0c70fa6958f458c4c12f183245291ebeaa439991d923c8f73497a07ca44faf96703a58bbd860e886db8f2093d3eda4366855dac9abfda7b6eb1942e2197995da51b21e2a7db5b497ec95aa8adbcf2dfc808842acc107f4beb687068cdfe2e4e03940ead833f7c717de6327c09122f40da3248b166a9d4dcd3a9f019419a3cf76ec1828c3a182659b4d7f9bb38471f10fdb6446da393f5adb970920681fcaaf2dcc460ac20cd1ec3eaf3bcc534ed818a1fae1d68f2d5abc575718e1f486096ccc927ea15db0c2acda50bc7b05da5e14a684950755cfa519b92cb0e2a9643e9c68c4e69cb29e2c20e2333f4b8038a15544d114a02464cdcdefdc648233080829bef08ed479fc3867656310dd07728848a6714f66ffca1ea0c9db531742deccc06b0493172251ffab0944077f8699feb5c27177a829c167d58c75cf122b9ef1985181fcc8775ea40d7a3957b20a1e0363e49c2fc8a4e895bde50ebd51985076ec010b3d4a316f4e1d07fd148e7aba3521297074e98b4893342a0c0f41af19e6bbde3920ebf8b72750efa88d7c4a1be57b3435890cbd7339ba288ed52898e5a6222cdbeea7fdcc10f54014c6320396adcbe8c90c9ea494bc430bf85886e2c47bfa7312ef94979b94aa52205cdf91a240cd721614024e4007bb7a25f8a0b6ab49329cee17c79eaf1b6b268ae7234d3a687f6c1f3e18fcb0f9d81faa88637a4c4332bad6390ab1b8722c4ffbdcb8c231138e6b24045676bccb648d0dd68776c05eec6655853785d61adcaee480ba9206c8d3886b4e8109e8876c538064074a7d62443c7c467e08030c8434a62cd787123e200b8375d023404f0e0e49fa384618380038e850e2b09390ee788648399d04d98f3bd47ae24550391e480383493b69ba8d96a602617827e310090b76b72ca9f859c5043251d8aa41b940d7b756548b02d35678b6f80d2f804b4d972aaa58c1b1b64725eeb75b3ffa22f2c578fc61d5e196a49146e9a0096ecb5b3583c1011ace5b7db0e6cb82419af424046dd68ca1928f3af54e24b52f8bc0638941b5a1ea1c107ba04c4dfc3862f45303d6b182934564fcddcdd24fac5236c0e01737c9431aa4368667413c6a9d904bd6d72207a5c003f5be2e0dae739f3145f77745dc2d78c1896becedba5f61105a8461890d437914da80665eb5323ade1ecd8e22eb230fa420631d6459d53ec2dad0d6737a4c03f682b1901b6aee20b21ed525f060bb9499379f4a5b4587adfb707b6160ff5010edd16902b4eecb446c501b22da9220158339f0dbd6fa7936357a0df7321aebdc59382666399f27ec1de3fdce97e3b2528af46d416e1436d3fbaa506022edcaa270a3ee6e49b1f16d6470966cb06b66f5d6b15fccb95eb1e0c090d6578e7ec1bfff1383ea5f4b22d22b2313321df2d31f9264c2ad4b2a910c460e89ec86c5dda546e0f22e739e7deec36f8f3717e2a75b223a28549383b8dfe789c87eeddcade8658e1f902c15ad1ea84322506c51ba0b479c1b5af7baa49c5973a071a889070968ddb7914974c5a47967686ce009bce6703b367e515ca2ee38e1623219e8cb2f62ada3edf998aeca2d2dde86351e17a6bc04677637b75b795f13d17e0ce6920e28718cce6a4c984867fc6d579661891aa273ba4511759fc0d3c378960495e93b2b540e9e04cf1e4183b52320724e17622834477dd2a733277bd9f60ad900e18d2710c177810a87a9c4d22a1105427552b98d55f7da15a002d8024e365c01f9ee8a754b28536510765030c97862f0d78d0132ba81abe116b0bdc4cb360a49be0a603ab171b434e5da0fe3dd092d684ee97384fbaa98a94fb9b5504ce321a6d72f06af98ffb8f1aee70d8960bc034ca48e781c7f9d92b4c778474884455fcc89137747c6c16d817e5bba4ae3804018aa16d78fd9655a71b0a7c0114eb3263b25f7534e97d4fb7f6ad8f4511b2069001c40a77a467d4286acbc9f09c7f13a9c7baa820ae80f24fbd9ec8e79c9f255b54f6bad3db163a9c159154f12ccc9dca71471d5b4312b66bb2ed39d295574958ec4cba5ef9ba873f5efed30c0a54f02e6545da7d3627a0e294763eadd27dee8097c2894881c6eece6908d9fd82a75615430f68a576446a17942f71d689f7c1472e04fdd4bc555c65d0bf859c10067747f28c4d9c20039dfe533e417a89437ee5ee2eaddb50105c5d250849ae72a34e1ed7ca844c0bc798940b5a16004071122fb66a188f74e6013c89650c5b3291a9ca36930bafebff9605e44bd21cdb424f26878cb161f685984854fd16107633ae88c8288a2ecbbbd426e8db155d5e7b3009a206a4d151ab2803a30628308c1dfe42976331403a4f011f496dab84317dc2d3bef62928f9d4012e4eefba57456d2e4dff566b5e8494c3af0dca0338b6e5aaa42eb4d9210220fac94088926c239a80c52198d5824f0846546df9adc316b2ae0fd05f5ef6d505a9fbc8675642e3402328c2017059a574418e2769a67ab735de26d04a4762a182e72d6dce237cb7dc89460382e6f1ea9cfdb473b46c5286b827f69ecb43091ed0389748603f6e0fa5a9b036f3c7a1f824776973890174833218747c36ae4fc3097d124cd6f05a8be0ad8870c5f93b7b913a831c13c0b00e1c3fa49bec269556a65c3ca89cf835840933de9be1460c63d15e09799d249e20e74813a8ff90c576e437ec794d5032ec3862a25d4f0dc8cd62b118e1193e3dfe391252ad9d71903be4fb5f449498b2e474c0865e8c739224fdabe164cf31fcea6b8919c8f0f89df0d796d6f143d6e4a4dee53273ca64f1091e631a2f48de167d239ff6ad7b18eeb0d8f195c0ba59dec35424a6a8ff8e9e6e0409da4eba3a24bed8968869b11c3a0b24e3ba0a22129149de4b1464278cb1520dfbd8565c912d84b227d85cd4e3845ffa8de257001ec045856262b453fa8142b46e766e3645e308d7e7aa469098b0d68c9cabd0b1ca6b8a4678c146f62dfca58d197fdcd90b79738adf48a23ac8ba86c4901d7cc5d3119ac43a260b31cad69a880fed9e4405b541138388f31f6d4afd8ba45d99594b70069a70f06172799d425a04d54641ebac1cecea57df48c89e45760f5948484aa8eb38bd760d5537a937db0382cefdc9f44a1e2f179078d07229d2213b4a8eeda0af467d14f4af5098e96fd993fa086a5c249570dea9ccac3ff25248848f01fc0ad1eb477022caa8bdf1fd80566e72888e389afecdf687eeca62d3d423e3709fc9d0f47bb8d4f205cdb416a0ff5e52b52601df21038c39285d756c696e4b88819f0e7c5ce1953459eac44ea79d1934388165e201ef80f00ba7956f705de0873a56a73e79b900d4649f4c3f22093efb3b1dca2f79e5f9dae3b7f4fa8d09482e58b140f0cf8e5446489b7670ab26540bf6480a7d03858135c448f406aea2b812beb9baf4d7a9481838786573865de6a70d3edb89c2baae604aaac7fa0c8de1bfcb22047048ee4d9fcfffd7700faa71f68c7525e5083586e0052a327a6418b69a8b6fe3d3c857334c986799a3faf907fc1d0618c8d8ad5366219587a64ed24ffbd429a22e0ea2b0076c3fa3f249b070d40b5cb051a5722f5cf70018a90de5a61b540bcaef794ee67896257827f12d97517436740131df2e10089514d0466241f289faa328e56f597483fe00111a6947a46551ce45f19f7a6d0ca354413556ad0d670753a8c2501dbe238b20252678af2f5532bb68a6ca20794d190d0c62c0debb36731877138cdd477a98f666427952fa3e20c0863aa1998b59e3d17912d47044f96a73427abd44e258ba914cfd0ee773f119b4245e93ecaa5ef41995fa94f9e132c5aea8ac068935c10a3aa60a9a72745049d001b65e0f85c132f646af84979decc04b3606b96af9a1eea92435e664ec00e73525485f6f7f0b13d3de99b369e51f8f766af6415ddc408305a9383eb8be46ba6ac7a214f888050f0581546f9543ba0a222ed90970024cc4e8455c6e82fc7bedc6e1901bb25c2e6d212d595f61acc5724d389018b0afd9308475cc3b082e3862a0185fa25c8a05a25cdfbb3514729a5b74d3af3c46c99ffafcf052225b9c0f1ad2363c5551120f9ec45ea983c3763eb9187b7459ad9012180c0c4f7c0c41163faa8114b8510f0b127c1dbc85e81c2321ae12622f312d72ca34041611ac2f32ff1dcb06717b46aff9d0304df7485a3a80105506ad18484e929ea5fb61a62516300d305ec50db4aa24f56bd1700b501c2e98b33e119eaa7f7053dc47afd7d73f1a17b6e859283315eb8a268d66017ffd78aa74af1aec012c6095de8d7cc5142f6e2194bb0c211e58fb53c9f21487cc8697f5f2ec2522d61618434166869a1d7565efbadb1946deee3e4ff228f8a30635fe8428915a2259935a225d932e53ea0d7a5a4aaeee8ba94908ccb385662ab006ce6733d3e27913f5dc63c34b4aefc1562b4c1878f0320ae65fbe082a82565b4f2c808621168d390931f523ed9848fc9f81ee8c3b02bc075e725586f878cbc96933bb5f068e882c3355d65d60da92c4037a3562273405fba12fc0165874f938d90db4a17b27fe94c192ae2683066ecf25dc4e3f2c5b3847bf59812e648b381ccefa075bf39cb56b3cada2bae7e4eac4d4d26a48152248312e21367bc1adaa8d05dc967b08c09f223d0ac11d69beea777b95fa77f012ae85cecd2a1e908b914d5ba9bcd058d70f2084ca11bbe0c3531a9db1009e43ce274f52c0c386025b8138433825ce7402dbbe01fdfc42dc43a14082eaa7bc010716c705e008ce2185d8b89171eb2ea90b1b59abd2e045ce4467de4b2af8cf1dc684846a35e4827df2cefee0571449a749815f7f319b28702338113a38e90744af072e2ca1ae912e188e522cea04c15973fd5bf68190e7ba3ef6dcf10cb26d02674ea6595489824c2cbe7be705e33dceb6df865cb26bfb8f51e3ff6b8cf3782db4dd685e6b581cf7bdf6b67f793f967c09a3548060e3c1be525b3fca1934e37d85402eb948eec1179cb8181f0206702acfd0045b281b3fe618624244b55ba2289d4c0a9a5357ec077ac402ff1d03cdfd17314806d382e6148b6d17fdc0c3ffde74eebde5574daa9c13ac25289a4f80d8d1eda9e7f29d43d1b09743315f3453df13ac2f27b10ff54ec0276e9836ebb95e8cda9cc8510cc5e21d82e4df274da6d882509c430120f8b6d7f5ca9514acb17caa4557c0bfd2974ff4e02d72fa88fc2abf60ad18ea219993384acaeb96fd6626712e807225e5408c6a27c251807a48cc498882f275427c28606e574e38ca8b9ee1d754dcca5596e311d6bac858aeef3b193135ee68a65271cf1c3488b1221ea02729a3b2a45f8bb1c85c6da4098ae5f81b9759a40571faf3f570a1c357f392611842da133916a13293f044b6c8fadbe592169360bd0d493fb36bef9067984b97c35c08d2dbe909ecf76c199ebd2c75b7818dd86bd88658f361e40be3f937e75a0b6da32608704b95f6e85aa3574ccea80412d399b1f62ff522170a5a68915ee1e0c51f1894a8ede012bb242fda95bbe7455bf85daa4cceb0071d33b990bb3dbba34965df23c7ac6403543d238adba072bbf108517a3e3dd67299f8a8f86a351d86dcb7d516f8020b2f108c987ec9b09eacd8277d7c632c1a58dc14ac145806626d98045dfc92db35f5e6d6661b068e74ee7cb9d1085afba18c34a2db83727ae4c865bef2b39e9609cdcf52c18e561423071a8eb667923b353a6ba81cb3270f54edaf4c3b9cfecde0327369711011a5cdab71f9d5279443aa997611f454311a940502b0a29faf7420bed45115bf4b1a4959e29b47cd983371e25e4a0223a4b380d4cce339b7694aaaeca08492b376a1ff9c5a39f556391b857b92954ea73054a164fc888f44ae284d07bee7a974c6a4c5b9f4479d15eebabea3ef4abe951cd5d746edf887cea033e2bfcdb9f097875ca780e5a60762460ba5379d23acea06ab700f7e1ae4e36632be858fe63b2f944370d834fff3675d54c4dc286567f8cb8f770df0adb0009f6c9dc233141a378451487ee13c0347d2dc0411229fbd0f3d4227ab348bfeac00747e0cab90a53b953388436333861b8588178687ec18fecc3f89130c4a54496cd46f9116d5406d411becb21c6464eabcca4fd0388112b04e956f382ebfae0d5bda4d5e37c11a56a6143bb5a3806de5cd099ec4d687e16b77b5b6674e9384861ba6d05834535b49ab49966c232cba99b8c58e14638c98b23afa4cf127a5ef49189d05a16bd7405ad7063d0a9dc92c443ee30908c348fc737a4ac577e28d23ef3b75c85f0baab5230276cf2e2843556c02da9cbb9b40835d11905b66046ff7217d461be4139256069d71447a60ae44f4e4d86a457907de9216f6f932251cf57123153e1be77403b65ffbddbb14b47fd0ee5d65286a8ef569252fae336219b563a1a661029de9a9bb6877c291a6d1818247fa57657caeb3c281e401d675ecb2ab6c54bb709ef885b3592e6295bc1838c6c3d73416d775348c031ba0f861cb1d50b696882101eb8e54b25ce99b435a93305ec3e4478fe420cdc4164b8bc89880ffa9b45b066d970ed2849b9f39cbf44867050f189d220c247e83c4ba576a8e80cef33b6b064c6db811beb11151601e220f88fea082724805d9c921175224c792452f0a9240aeafa1ce2d74a056779018f1929415bd1524c632391e666d7a7a5cda71057bee8d6a3e019885a94e8225306c3934e6d248af56592146428ce61cbe2baf065d16dbaa1385ae0c7275a9a7c5e9d8faac55f0f54bf64c4d6f1d3cf17d3a7472aa7692b7af313d6da33ac0f85faeffc02879b994d48d5c9bddff6a8406955b48c0150e7b428fb2459a3dbe7221363e4c86ee46684feca421228e871e850c5436f4f9a6bcc30482310ab59cb7b80dc9cf9497e2844c8b447bbb10cbffcac2531b98024cfe47d5e8698b7ce320fbfcbf6f38d0034682cbbd41664aeaf2d14736a5ba2f0e5b4cddf224ec811ace2f02f0dbf94ae7b3e8f152f493b615988befd4a46ed6c42d07311c524f466c3a987538769a7eefe8a66abf24d1c9f96a62eb2732d90772222fccb8e5c1fc18871bcc96f210b5bbd7a9dee4dfe6516b70aab390cab8e991461fc8cd6e8f0646e969b0a45226e18b76d874b3d0574b03369321543218b6fafa18eac7e4363556c7e3e19b7f52269da5433fcae6c9d8654a11fe6b81c176668223bf0ead8f2e32233a051fb9c60f96d8405aa88e386cfaf1ae405a0bf1e3e4ab08f04ecb84dcf7f7ecee688843b111adc0567014224990826ee70311137d2a74b14f1e4f039a4405962fa2d8901fa2819943bbc276b5369182cd213605f7d7374b963634000b74743664bb6f4263c1f7505441c25e18f548347b77a5f2022362d3f53288e93ec1643217450823098f26cf0408baec18eeb377d19075cbbfb7a72259325fd711b104e00a14d09e82a6969c62febd23156b2781588c51b6182f25ec3cb0dd8d286264b2c81c2b711df2ba51f16c5118944affa3f9a026c966da05aa26296004cd1a87b5f1129732a94025f818c1f66fd4d14e69df3644825c6386796ccc16144f55a580bcfe8f742f3c9a4680066aa87303c2b3f0934777aba003865064c473bcca634736d89cfcb7df8d20b4b2e632f00f0b044b4a43b5c37a3c735a5b78b4a22f6b0b5f4001ff895381af7e3e02f34cdb96d0de098d7692a44974d09463df70c9d4aeb741940f79f230f3f800d29f554a9387af509e9245d49aa48a76b694249f8313383c89d45ec77106406d1082ae5e6bb2e4c6e0d3f1a27ec00e6fbf6a6b91732df9fbf31dcff7827379070e08dd1d381645d27ae73ff66da45776e430ddd758181b661c918ae37453d3b5092eb704acdf162e412dd0b530093b50bd81b7709079e3d6bf9db828d59b52f373090429fd75d6a5eb2dcd589d29b10b2eb404f8f4981b14521eed4bd10373e958f0ffe6a61d270728c889ca71ad53b501c7b51088367b50448e0a5bec07e34ce3b0b2c28f87a6376f698e92783bc54b108d742b0330f0393a7d5f16e5e92291e474fc4fdabba80ebcb922c29693d5b44b1d4de292ff6476adbdedbb3237632a38c7cbde526bbc8b6c23b8e865747f1b5145312a08cc1215667d5d15b0a83af20ac86563fa44545530b5588926e45e8d9bd0dd8783c67a283060ede12b809c80e8fce4707377e08543c68d4ad2bc5cdf216da47e36d2131059b538ce7a431d942d97f4ed2109b5fd2be418b0a9fd3502e591d98df5afeffc5dc4dfa602d55b836cd0b41e871ca4b1316665988c702ae97a7524eb30919b709bf87ee07dff25d3404d06baee2dda4ac3d8cc63596cb110d018e2637a475e999c0ca2a65365b3ffbaa7edb0a583dae5cd19d1f44b3c293eb589666f53e90e2386b20f685aeef97dcce2e81e422e490d09fc45f8b718ab5c1bcaf59df490b30df617f4c5a579bc482ee56fb1cccbc1ec5a4b99a7a5d121751a12f55e66b61fbc0953fbefaf0544e75dc224d187dfa49ab16375c93ce2b7688af2de6ea52490465de166ea034cef629b8b3eb764f2e1ffcbba36fedc34b93b01ec42bb81f5e6a52ccbdfeb666653432bd20e0750f81a2ef02932c15744e2c5ac512c4b85fa213d41d63d2c10a3cabe535522a542029518a2e763dd425f8982b44db394191e352f11cb1126f2b428edf7fb265961504dc07e2f04c2ba5aa3026cc988d0bebb972ec2ed14b703bae2c3acd297c90f511f7368e1915a41b7814f8b40091c2f6d64342bd6384a44304dc6f56c08d014221aaafd8916d77d77de5f6a6b4c3e6d189b0240291dcf0a1496da654f846f06f915437806ffbcc7036fdb067a81afdec2e88591d35da99fbc89b22ec5114223c57dd6b0e30e233ec0449976df782b2554d20faa130341707a911ecde06e3b203f1af88866c2b1020c2b84adc4693c1507e36f4d8c15b23ba897ff400ab217527b0561bba5adb8d90dab9f4ac1f913fe3110855cbaf3ee2bd56996b4e1b940ec2d7a1529f7529965a92013879ea50036152b4220d9fa80393134a142250bd4c43f5a5bcae839e110cf6c55a1b80aa473bd85450d7b59fd17421a219e2a29398dc33b6400043dceb6dd4975f97fcf87f44e4890a0d8fb194269b1f8f561ee2a4aadbbabe605bc5d9b1754f2a8f354d2224895a246878ed4c09d46c424095cc258f0a850e0470d1b245778b2ab363bc3f5be2a2bf9a59c74c9cb1d7c5c494bff46b99b77b96a1f44685dbb09210619b319eeaa3aaea8a663adec75fd81447aa85d80f5fb15005ac8f17d8f0db93146614dc8d5b4a5a22f710216613eb3d3770d01ec5fc1e0eda05aa15814779e5f61996cd31b24fbb7ce44e0d75ab8135b9d96b0c2ec68af8bf86f46b00e9077c1c59c1a921008d508b374dd118af80e21c1f4687887754e4ff2eb7334169547d60e656aa780d69c3d8147c58f1940e693219b8282c6d8065f3b50224d261adae545c559e9fd7a0c952475c1d788bb7152a7fe67dd8e6b528333d7e0dcc6938468ddc2039d899d3a56849e4713c1322fd65bcd7e8e3cb9c03a3f4f0e8f3cb834382bd277714ce95bda0f43d0ffcf43705f26e68f3335f129712d014605f644531971d76cf832116d62f8f24239646b78e93d57437ce2d0d74cbb117afa588e88c74123e8c4ec616d9c08ab016a30c5fa52a284605f99fd551bb7ab94104057dbd175df88edba958742e0a5d941175998f0895f054b1e6281a60f4721a1a28fad314b0fde046825ae5bf98276cd333afdd27ade88e585e5612f6277f1d344d915f1f436172d0e31445dba6d2440a742db76e1668d19d39d5e1c32a6e43e9ac2f732c1cadd37381e99cc8794aba79f471707ac3681f7363df49332d4d2e4acea674a62f259bf88d4109dd3375256c83b070a6ff4be7609c0a06486ec0b8370d75673ee4b9c03b44563fc0f19bd31909c61b7ff83d280a23843ce1af75b8c91e2efbbb02a8d7ffa67294917910213f978d98df3962805083146baa44d3bf3412f237a7ba8701d0daa68f03315a2577857a84f61afc277057a0a7a14de2aa0a7b047c15da19e023d15de15e829ec51e05ea1be821e857705f415f6567057a8af40afc2bb027d0a7b15b82bd457d043e14d017d85bd0aee0af529d0abf0a6404f618f02b70af514f42abc2ba047614f096e0af529d0a3f0ae405f61af02770a476f27e2aad99a17fc2d7aca58a1084f4298a31661e0a754669389d3c82705b1c9f18ec4b5b8d98cc367cd8a4e2e520b6ae95beca832db918c5b8bd995ed6a94c7dd47e019457ad58d9f25b80672c0a89832df4e74033fa9423e46a4cacd4700d51117b702bb21914a399e8ae23d8d4f7ec25fccff5b2649133c5fedae5df5dd7dc189434615ace1e2e72b8ba3ab1f0ac755b209a8c3f1e4bba439738b510ed0deaa564886a93a54625dba7f31eec98c3b7d38fd5580b158120b7d9882e4852458dff3591565910cd0fe33fc6b4ddbfb8cac0ff7180bd64e50206d9036f2cadad116a5f3af3829f817a8c9ecb718501fa0fa74ef21dcf25a88f67d17b8ce85e0c49283d8111759b9322b26aeb1123e0965965240bd4cd53ba61b226ae5e1d058c77533bd019930bdb224d885967a25d8c7d44957b19dd4d97e8c408cceb8361c696b905b0441b6bd09955e221c5841f8521356f505bf3359ca5e964f4c654c69985c98c24dd2d54f44b653ed136343ba95aa74f600bfd5e58be33f502ea6614291a2b0f21cf7f732d81ec7bcb483448f5fcb3c8afcb105f4de4590d6414458a7441bf6742dd95e9e4ff486fbcc701b2c6555e24718b2c242e644e87c230db41f257f83125b5b344f03337b8868e707cfde98db8c7c0ceb0544b612e891aafc5b0d8ef32fa4c51a1c054bd150d0a1b8a3a087b2378a3b4a3d14a0ffc5c2bb14e39e4e1c848b4ea2d3bb14734b95d2bcd3d44fa397a63b4d7d9abd34ef68d2a7d94bf34e530f4dda0bb9c32d79301149aaa4a784cb3de853133254ff70362e11da468adfab0898ec5acea09469dcc56f619b165810d9ef5c2b5303d032d86f4084d0235f97af8ba186eb1ab5aeabe5bf99d0e99bde36cd8c41bfd7f4c0c183d454730e92c8cc51ec54e8fd4fa99246fc91947fa85c71e6abd0fbd6729bd21d04410a523b00380d23ec86f39b16b5f6fde6ba16a060dfde64c4694ce3f772e3c5129efe143a7b874ed90f18802d7c61c213ac57c2e73fc0e32c662f93ac9fc415795a701b309cdbd1213415c419ecab92e0d7996aaa4675adc609adc0d1797f59529b64e1f4e645d23e6496f569b07e385fcdbc551fcd0a3ea2f0ef826a2d518275369f9388ec070850786751c0177e1f407cb15b9905cf0df1bcef3c737536ed768e82049569d29591b57c2db89245fd0990e656f6c38bc187853b4ed6c211209307795bbadd0506d14ffc71e419220cd5c2419696dc4f2882b8dcdcf8e8d411261c35b3071f6f146ea20f3849bc706d882f8b23817d9906f51e78b75b018826c66d5a1e7989a91051fcaa796f43e0f851e42d24eb8d6a5471411d30a96ad629755b5fc82fe12f9cc029a4c01ab75f049289b1ca08c31807b21402e40321c66e423c0551b5e556d7cdc734aba9dfb48cadcd567b6245f27064f933328e4cc02cdb0473e6fe68b02102764dba52dc0067732729c46b276a3b946c0979d21d015a8cd5e9e6a4bbb163208af901e09e900d416646611c88c338ecd4e22ff6ad1345434bf9eac8ebbee505721c81ec652017ec5d81c99a9e7a110097a0a721244eb6123c030d40274cf0d54fba9e4d125a142f05c0acda8490b6453572b794c81957eaf07cda117f8c1682e6462ff31685e207b804e1b00518551903e4d9d54c6500ff574f3ea82a0d6d40f8c679f90997f5aa2cfbf6224ff9a2ecaecde18c6e1cba05edc1b047c992c568e410ff59e34de8e79c1a6ee407f7fcda515b2caf546d6b1c363e99e92716d2baf50c998ec1adefa9e4898b2a0e51830f15c2c0b86f73c4ac4bed860fd094241f44baffe5d8e3733717c64c357a403ab4fb967e417a1e7af4b0482250b226c37da2205291baf64d0534603407dbd10fbb5bbf50282c6a178bcd990c9e8d6cbd4d333dd44fcf253e670d48be9382560d24160311235c3700462a9f6e4e792cbc777f00c5dd5a55f3cfc48335749d847513e62c31a2f0b4b2272851c8e47ccf46343253f1fba179f98bc774bc96e12270d2e6cfd4b6ada62bccff9a7e41b04d307e0b581fc73fcccdabe92fd5d1cd67184cb0a6077e46d508677992d990df0061a83b725ec32d1ca921437b3c5806b54f5004a93bbb4cc708447f9a1fbf241ae659278df414cfd88a4dc93a895afd283103b0901d80a159b7d394142f9c664d7cb6c3c09bf1421c2f05c07e29e572b6cb67205d3a7596e596802f400cd5fda069e533141fe4c8a92f82458289de3284ad62d518b49f9d2259b246756913103fb38045f851bcca0e0a4b160da5398e4abdec37691ed506a8171d1e07df6705628ee43de40c48f9af36ed7a042f61532204385983af1e7ae166fc23c049333432e812a35d7083e92a735af14cbeb4c2cd46193553a119c4a23f46a42e7b4f419cf7131577f587bb508ec705bb429d489f0c8d454c3d2efd76a1d693fa0d847bd94361ff7a821ef4bfaa3d1f7ec4540b310cd8fc38df536cea1b58890058c8818e22202c5a709b80cbd6a29970026dc82b5f2986bf3d1847e549680f0ecf0b26bae2b3d969ce9d6df7dd0d24e19e4654e07619ec9471aa892c5257628aae0feabdfc618b2d4ce3cb8b9e225d35a8cb6ca5cb06a81ec181b0c681eb71d4eb0561c3758595d8445dd7b9b99327f6832c1ed0a39a5bb681545b7bf2807d3432183415049e14e9f1ad1f7dcb0e03680a7eafd993f53f23e7ef088ba86468faa6848ec6da52f2ceeed8d340b2476e75178a1056ae8354e46343b0869dcddf7ce83fabd16e16efe0e5c31fb65d586ec3713e9deab22dc0cb0171a110f850eab22b158dc64023e86d30e1a6da7f8efd89ec0a0164c5feeb76bda4bb5d55eea2a7e8d70819527040fa8b487b7dfdf7b9e64c8da6cc2e2a04529a512da522c96c6460ccd527a7fec92a05a709ef3610e693fa577ee654a0846699ab10e96ae91d9a41d2ec095bcdc11e088bb2d504156099ad3d9649dd9cdfe4d9ec54a362d52db061dca6c4c3fac6c80a01b475cda7914b745f90af8a948508d4e516a73f00266d6499ed5e2dfb686aee6a902d932a1e87a47e557843a95c31011df334316700c52f11e1464a838b29884cfd8360f5d0b556f1568ecbdd015c0b822d0c960f8e11c3788bbf34264c61fa266994662702d598a822055fd3b58fc4f23966086c969283919d94756c65ee3459b236309089c1659a045aaf5958e4454cd90fbc99125c8b46b342a1b88dde96d160ecdfc854b6982eb22d6c76bb5464a1be60463a3df8975f93adb0c47071379d807c7ebf38b56ee2f8a007421c3f6a03049c5d44692e6575be92a49a0aca182e1d09fa51dc351859a2db8eb18a004340a820fce90d3db8772bba90bfdf03a83b5d9b3b9bad84b4c47b40c534640c8a40a9bdf07262f95d1341dfff46ee1fcdb80dda3ba050cdda0daa64ff8af5b8537bfde8552ea5e10114157144aa0623736f4600dbfe2a3c51aeee29080ab71403cf99086cd2bfc52a18be987b5430d776007122a2f8ad89ae8f7d5981ddef16ef5cfdb812248ba26239b490b6c1c5e597e9c4ca5240c6456ebf506330f43ab1bc8c53efda567e34dcd44d1226e25baff7603ac420cd4323e4ba8d049e253c5fc14a150e2cb2e43322bd73e0e20b6ca5b1de73ecd30c58337cdff5c635b7c1358db52e1cc3835e7120ace8d3fea1129704d1490290776350e5235ed4652414b1fe5570a11e2feacfc7393611e4cf03faa19fbf4e10280e2b1d209597d9f564201369d23726bc81631407d60625a1d896fc18b209b50c7def075d94f4a830a336023bf98fc91e4dee586941f6e019ea2bdb5bf5cda16b9b24444ab9f7de5b4a29a50cac0bf80b390c75e0b1c01a3bd4dca185471e7aecc1471f17d8f203036932f087063610f338c110839831329099e189861a6c2873030e3940e9b0030f66cef4e0039a353f0401041041fc90068d1a1fd6f42084933379d28e56d32a9a31d34c28364f7b9ad92084104635104218cd441e20841046321042e8021808e51957d757ebcd6dd5343b3def82978c426569d5b8ce5efcc25dd67a369f1f20204184040d212254c44bb2d58a2d04b6af846db587942c8980c88b8c4850240196e1ae0e1fbb133c5b38b06242660d0e5bc9526524a6b6d1612953b609c6d43a1e5682a2d4a40e23099618c58c8e2a902f8611c1627430295282712369274e5c1c2e1c542408e94ed112d80b67a0a41872ed0ee3cfc919b976c6dcdd7a538acd91bdaed8efa682d75f36aeed92adeb9cb35fec214c05b7b6bdb7b5865b6bec590c01d6d283979cc8b823feead75c0b612d4f96e62c316d310313142da0509005190a2aa0aa200a16324491728514dcb585b0ac7ef5242b26d2983c835933cab15f5ba86382440223915e7b3c6d14ae86707ada25fcb8bae62291bade7c53a1eb2fb5bd400db300b30461bf5c6cbb7d8745dbba7edc07b568edf4ad99911e799167d28d1ba9589567726a8a4a4a20cf645595d5fc22cf241656160523cfe49d3b52abd2c933b925b79cb430f26c3e3d416d62e4d94483268a1b23cfa61b37529d559ecda9292a8f8c3c9b555556f62acf261656d62d23cfe69d3b538bfa91197936b77e3ab9cec833faf404f54223cf281a3451398d3ca36edc48f560e5199d9aa2f25123cf685595d5cf04f28c62616501ad9167f4ce1d2075f28c6ed1ad206ce4597daa4f33694a27216d045160881b44e0c8716b0e09d971404ce61e5e4541f1d688a5b38ed738df3675a44362dfe4245842f08a11f440d84f1c02029508994b864822a159e480040f30716974648224b14904474330b6c449514462923401543a9a4f9cc8a5a4c9f404cbe064f950b2c8110f58346111531d230e600fb840b9d48fe4e4d815541027c73d60d1ecb815b524ec8d51ac824bfd688a3c93659e0d5c320232491a2013289914f79043b385846e999fdd5a4b447142caa57ed4446e6a92cab378e70e1e3aeab0c08225f22c6665d971038e2953e0e459c4c2aaa3c61ad48fdee459b48a56710f09230332453c209332e052d40316cd9ef18b5a4b58642dd98d0047aa39315051b9301ca7e4c050e50ee128058553965d3b5ab9d48fe45082a39b37f6caa57e1447966d2fb8d4637264d916cba51e8b23cbb6592ef5989d2cdb6270a9c7e0c8b26d06977aec8d2cdb6ab9d4636e64d976cba51ecbcab2ad06977a8c0259b6dde0528fb591655b005cea3136b26ccbc1a51eab9365db005ceab135b26cdbc1a51e9b40966d0570a9c7d4c8b2ad07977a0c2bcbb603b8d4636964d99600977a0c8d2cdb7e70a9c7cec8b22d974b3d6646966d0b70a9c7cac8b26d974b3d7695655b102ef5181959b60de1528f5965d956844b3d3646966d47b8d4636264d996844b3d1646966d4bb8d46374b26c6b804b3d0646966d0f70a9c7bec8b22d022ef59804b26c6bc2a51eabcab26d022ef5981759b69d5deab12eb26c7bc2a51ee322cbb6285ceab13959b655c0a51edb22cbb60bb8d4635a64d99601977a2c8b2cdba670a9c7bc5cea312cb26cabc2a51ebb22cbb60db8d4635664d9f6cba51e939365db152ef5581559b665e1528fc5c9b2ad032ef5181559b66de1528f4d65d9f601977a6c8a2cdb42e0528f499165db085ceab128b26c0be6528fb970a9c79ec8b2ed0b977acc892cdb8669c2490a062662b8d4634b64493d06274beab13759528f299125f5581259528f219125f5989b2ca9c7da64493d7644a61e33224bea313659528f159125f51811997a6c884c3d169525f59810997a6c4d96d4636ab2a41e4b9325f5581059528f019125f5d80f59528fa1c9927acc872ca9c77ac8927aec4c96d46366b2a41ee3214beab11db2a41ed3214bea31a82ca9c772c8927a0c872ca9c76ec8927aac4c96d4633664493d564396d4633464493df694a9c766c8d46364b2a41e9321538f8dc9927a4c4c96d4633164493d064396d4634e59523fca9325f5a30d64ea471ac892fad11f59523fca4096d48f309025f5233fb2a47eb49525f5a30b6449fda88f2ca91ff19125f5a33db2a47ea44796d48ff2c892fa111e59523fd2ca92fad11d59523fb2234bea4716c892fa119e2ca91fd59125f5a30a6449fd888e2ca91fddc992fad11c59523f7a23d38e516ca8c893fa5156a61dd36820c7493d66812570843203f5937a0c0f13383e957912a30ba931d1698c4bfd888b4cbb05305b3fa91fcdc9b453f842fd688b4cdb0414ae2ef5232d32c521949055069519589c71051a564ce12d1c586101816552248c0a6c250bacc2aa220e5682a2a40615556018d104a6d690c20adc48a81f4591afc04145a81f4191a91f3d9129ce59dc7523761402cb20dd408e3da91f3191a91f2991eb18154d4d239184fcecf8874c8a4d135e45d5f9d9718fb826aa8969828840c439718b21518b2028240810a01f9f1e086174935f2e6ce3115e178de0360d563a2311d24e8c795c54c6804bf3d21a6594c72eb5c933dab28dfe7b21f95d70e5040e0faf9ac0f371d3dececb6509d3d2679b0a5a7f91ed0556cc82972d4bd0cbae7eb39eafb91798e7e56cdaf382302f3f3a3f2a99b010098df72e49e12b0cf92f437e7e54c2d4a8a082066df46a532cf36ab536c686110951e6efab8e78b526cdd5eadbcd3da7e79c5e737aeaf4d2e9b7af8345b3881c925f909d1cc7c0a97ddb0b1827278c8576ed68af432b4805afd0ba6ed4f55ecf40b028366c12e2a036dd96dfe67e605e68d2d64808a74cd3221216a689fa7e781544d4db1767ed67adb54492e8646e7a9ef5da7ad676656adb9632d2cf3558685ff4462bb96e769c47697c8376f83a8d4c645bf8d82fa4f45dced1dbf1affcce696412eb67b99d8c70463ae33447caf4cb1236af28c5f4ed2b2bc90339146da6ddd06b24b9372ccb34679962c5d51a96b9a84b8a1214dcb62ffebecc7b634614cbbcf99bb779db076b24db26e37cfb8ac082646fb47e790b077e73d49ee2c82431f20cd6303a5d66e307014561af0a3c9d4d1488adf934e6dae27a5df3fc2784fb844f36b6def9ac05cfb15f9fd1b75d6dcfc37ce75f26170983ed0137e7509262c503ba1119c5b67000aba6759cdb369d4299c50aa55b244ccaba2f8b1524207a06ab2c7d6bafd695f69cb361d7755f96efe20bdf7d6d5efdfa627248ce58a6da2b45e519f71205a0f7da761090abf19728bf988445fc41b9df14090b2292a255fa19492cb91b5e4a64f2fcb809de3c874794d61f5a781ef6d0ea8e32f698f3b0da45f4a0fada40f6d53544f2c4863ccbaf755dc7ef32d7b57623ddd6382a61f76b839b622dd5858f6e580b37f115ae6b0b95dac8b3fccf75f873018ef651e9e436c41a06da67813a8dc6d9c6d8a6313346da318d8fd1e211b63fcec3c417a2dce283d6193ace6041b93a33f5f0ea8c9bab3345fcf6f0ea4c9a8e87ab334f7c1c65aeb736b3f5f0ca4c1afb8a1db1ac37edfb94f2009270aece54a5518a621395e6e1555499875164de7b7825c41f1c9e2b21ee6059515d09317525849b2b218680f6757b7a7a82c83d3dd9e74b0a23df9ee520a02c6162529e1cbfa79f266e7bbf737d42575cfdd3555cfdd361dec767f17d7e1cc2229f763984453d5ee5951be2db5bf7f88cfbeb42f9bbf26adaaf8f6af7e324acbbd8bd5994223299dd3917eb07e91c6be1cbeb366fc20863d79cf749894d2a8d60124634698d1d5444f666e5d692bb48963e07f4dc97b5e948240c36ece658da30a8ebcfb66d3f5bdba9bddcda7a7b7cebec5c03f19f7eb99d984afdae7f7ccc4f93e9269fdedabb63eaa1951d75ec90c2187f50f2d6f169479dd0f671989b5c7bd69dd38753248c1ac5b8ee6a6fdc4c02fabccfe8a77e4c7664ad6746bfc9cda89261a9c5aedea2d34c727d52e65074da2c57c4afdbe9412a4a69dd60dc6c8cb443981ead1ced275e64da632295f91b15f9d149c9c80806eb0e0aa24c67648d6a549bd4ae98cdbe33c68aabccb790c248a90bc2a2e96362d38c5adbeaf1adf0bcb1aa434e95114e5a5db5676b73c61bb7d6b68f4afd1a9be9aa563a46e6d019a87530ea09574d14f19c93533dc35aea6a2a91b63971c0a3d98673dbb21e5e3971c5dbd74c7a01996e5f3ee6d564e07889f25b8b81799a72db8937804d4f70c4c43c4db921cea2f40e07cfe66c87a9cc763de05f2e06e6697ab5ab5f2e26e66982b37d1012cde9d5fe7978d5041495484273e297c3c15605ac799ecb6a589b78a3386389e2250c16dff575152eb5d8755d3e974aa4a524729cb74e2cf302a97ece99e774cd39675319e6ca6e072bb99654caf9da3aafedf43aca715b982eca27ace7cdd65a88e338ead17a5b53ba8444de9a7bf571d584d357afa548aea7dfa694e2b6957214779352ae67733de9d43e6eaa09f2f1ed6bc6202f83fcecd9510a3804af8043306903a9397008feccf5b2659021e0921b3b29a553ce86574ca479e8f0e99c6c580983e49618811e5e4032f1e665df1991510bf60812574b9429a36d9be7799ed7715dcd4818ec08059fc9861c1b7eb4083876da5c2dd1459bab25d8f4f1c6ce1513338001078a977da75c6508a3516c4e3a98a2c8f0eacdd6d59b3dea9533c618fb5eddd943abb6b3764c67bdce7a9d6731944949e557dafdc436d7ebae6bdbb7a357b952312fef03139bbad61a632cdcc741cfc3a27df5bb10cb64eddbaeae338571ba84ae84f9fa9fd752e4748e932fa55c22234b597d8af531de074736b7248497c5d59b39577498b95282cd551275e0b0038719b4abdbc41878ddb5e530d5265d5a5329063453262ab29530cae98a5b85b10a41c74acae9d5c7ab8f3651697ee88187ab24a096b296da50fa0515412353d8b45f4b6d726c08fe83b3a5ab4c693779da5226f54cc6ea69b7ec2a934ddd78ea103cc45864174f5da808c2ab25d83cf5ef256c3be7dc261b72e24c7195ab757698fff25ba785f9cd51b8afd9a95c6758a4e5548d33af67d70579ddc7f56c2f483e4d2a47e2a99d954f9ad6b28ca49a734a3912cf079f627796de8284c9aa29a7e6e45aebd9b4ada7a7b76fe6b369dbb6f57c2768dbb6cd228fe4a5dc5270b9095bae9c927234f9a4b5a413a6ea85392f5b3e71926adbe6e66d924a22bd3ab68c3327768eb24cfc0244aeb966ae0529ab7eb671d3f3a4a4da3c0e6be1be59cfa49cd91bd79e9cdf3c6fc67df73b41b6d65cec4d9631e260cf5199d473a8466d93532f8f9276b54a32cecd3fe37096df4c96799c5108c241df356e8bb96ddb36394f6f07818d0d54540bf08f3263649ca849376c244c8b6cd2c8384a3369cb1caa5d95e8cba8add7641a0f61cb26e3c83852e33a19274629074627234d5c9881ee5cab695a47398de5b6c90d4b29bf0c24876a775ea4893a6fce39e79c73ceb9cd0f7a4d939148c2e6dcb6e9795d6bbd6d9ee7799eb76ddd3637ac6ddd963d9f8e1d9fb40fb68486bbf74e0926c6393f93dd9c518eeca637e394d7dbd4cbdebe99f76daf9984fd9271d37aeb39a577ef2b5f8c5faec6f97b61dc1063e1da75efabb5dc5acf7a5aeb19f571cfeddd30c6b1c7219dcf1ea3fee5750e551adce310ebb34736ff726974a2708f43aacf1ed3fc4b43a3e53ec6d7b52e7a5ee775878117a598e2362982c4c0415d8f4b6d8ea3dda5fbaabd9f51972e5ddc40c5f7ba8ba675095cba843023176907e1b9dd2e7372b35fdc0cca41370315d91c098c28086671d10a83077281764a90485ec7ee02ed3487bfa51e6e060202aa9a362518aeb9403c900bb403b3ba44a6d7ed19f7cd60d6fbe4f6f9663d1d65eeb86979dbba4426b1b96c9be67ab5eb157b7af66a9f9ee5f671f5c49ee56f46ff155daeeef26a2dcbb5c1aa2253ba7481743e5ab95dbabc1cce792250c66c33fa1e90d3af5dba44269acbb5eed2da2cda9e798d7b161bdfae370e63f1ba4b64927930ab4b64a2d51f0d2c99c9fafbd50823d03c95b18d629d3516ab52b5d06e42699326b00917e51f576caed854bd9d22debc7d59cfc6efba49645232d29ac42452ed6847fb668db1c61a5d31d688bb6ef29bc96f12996e952f5c5fdb8781d64df0f7fa66f40837efe4e195115a6f6711da755b1b6db2a3cb6f46dfd571338a4cb1eb17c62832cd5cf8d8f28b9129b6b6f50cca6bdbf745bed62432d1be5825d00e99b6a6c5cad19a7f4a30759bc5dab55164aadd2945e9faea2cf6b32f71c33d3d1ffebec83fa136d6365ce5d72432894691496d1bafb4f18bdad72432b12d45c62691e976c55ddbb51961f5f6a3663d879c43af8fbdc85faf4110e8bfaebd372bf2b51fd05dec417f9b34894c6e93133849abac8b71cebdf635c97c40f0f08a08360f34c45a516524218a8c1e704e34712d34e5ad947e51b4ab7c52bf21680b4d489d78b9413c0284128f8045432c4214ed63da40960247883284a6391662604761775c3f81c14d5b87698279f2386d6efb9e624d90b625c2cd25b1ab6321666b19c23471cdcd2751555280536ac7adb98eeb3e31af3c4ddcf7146bda3e2bea1785c59828778809f36101668699b32261e1c8d9a68c4e10420be294ed85f60a0fbc944d3f162695f88230104268019422b5335cb068883f88e204a105dc07454c960221b4804b141e38ceaff022abd651769d9473ada76c4be44a25b137bfc2cbec068479da77eb389b565ae9c782909f9f9ceddbe10a15e605f2e4c9f35eae905f1bd82ecc1760c78e2ec4862ec406b3d98eb1e38d57126186881b86f8238a854739e8e9c738e39c31c68e6838ab98161e328f3c8b5050686656cc8a77a893d353b5b2c2d2d2dadae8ace2b2b2ee745252539e951596adf552515561282834525253afcdc9e9294745b9e9d1dab4b62d1f2828343f5151401707b14334229773e29c684ba1aec8cdca72602bcf362bab3a8d5c20cf362aaa0736a9a7dbd4d3defae51bd406b5a179dadde77344d3d2b4b4ada76d9168595a9676e769df2454c37ada18028d4aa3d2aa9eb62b8220d8d5a2a2dc3ced3c24a4e46a4e9a93f6f4b47d96686911d5ac9a55ef3c6da0a26a55ad2ad6d306228133a952558ab61023241354a80a55d13ced214daa5375aa4f4f9bc811d5a25a74eb690bc56816cda2779e7611274a902ed5535af5b48d241529d1281a45dd3ced7e42a128146d5fa24ed4893e3ded8f494b6beb691f817244c1b49a5613eb6927a90029ca949a5273ea6947206546cda8e9e669c37ea279da434d7d28b100ca949b25b3886451a85c2a4925ab9eb60455fac8332925a59858915132cae88a847a3ac105322c7be459d4d23aca6205033df22c5a5939c9600fa4a9458f242cb7286990c106792c01e056e7a0d000cb38290e6ef5181e9c5400f2e8000f014cd981561d6099e7c1bda27970072735003b9e00970f6e8aa36ac29c948451ee034eea697355dc94449a71551c1d4e0e27b5c7d3e6a0a053462daeae29c69eb4d60ea932e22c9c55d10d53ca8f3ccbd94ead14b6648dfd9167110a0a4d0d1b674357c6bbc1e27073c0502e1d5e3b641e7a9c98f189e5f971720282010a480c5141c448091943152483d5103279ea20b32c11ad2da1e9e4349f9eb6257237cd01cfc8754066e4812deb4e776785e56ea9a8be0f4ba9a923f0c84b46b9413291f450a82432c90f96714e4e10440880609916d416d4129c0c2310021b228784943840973c40e4b2e88804492893088c86265882655c93222c73628444439e3d41fe24274f7936a126145cd2012e6d4d7bee30799866e0926ddaf30c5cba4d7bf60097b8a63d7d804bdefc012e6120e0922b08b894062ee5a63dd5c0a59ea63dd7c0259fa63d85804b3e3df9e5c2d2e3aeedb46dea008b6837f122b7929319f22c66cd01937e9a768403224d333fdf443375804ce21d940758447b16df78da477842c122da4b5de4271bc8b3484515c374294a493961d2409ec5a828da4858569f662205b77a2c0379169d9c94307c7297b02c4a5608b4a148b1da42c1432a2915341919293ded28166020cffae94433a3a4e06901964d2838997eb4322a4654b172e5022c598ec020032d5b34d800001c1811800e04e0019b011441800fb814a00b08218840c408249460800320c08404a4999d8002110a58000352f0a24203bea45981050710d1c203201001302ebc10c6098618c48c59230399198678a2a1061bd494b9210a871cd440e9b0030f66cef4e0039a1f8008624d1a356b8610226a0822d414c126ca8823d4b4718344124abc81b30413526b9a20c28927a088428a29d64c511167882ae45871851a2ca8d664a145d4166be670d18517551250f3c51a3088a013861863acb1228388ab32cc38038d34d660a9318121d6a8c3461b4450206b8d1b6f44c161270e3572cc41c49d283a84a840bd75564b6dcb695a535781f6174de33e4ce5b6b73dd5dabb5dfb5eadebb4d4eeda46b9d7e39cb752eef5b8c5dbbfd7a3166f9beef598c55b0beef548f576cabd1eb1782bbbd7e3156fad503ae7a4567e5c5c5f8f56fc92a124676cb56ab4026ddad6719ebd2eeccaafdce3f3030408889020427e6ed01020974811a122461c30f280d0ed22d78f7c47922049022198116498543294e42a81444b22b844455382cc444e6044742780474d24b84730369d6424a994747495e0d213277709225da609255320a354b074a340202958963394fb5896616ec2b23cb30558260b4a33c598a70d3405cb7a6011ed28384bc9b02c672a5896656ec2f9ca146e9e3650fd79f279783585d4db48d479f662d72bf7f8fc0001092224680811a1220e182982db1211c95a933e9da39ffc3cee483c72331288c42593cc2499422021f0e122880008166428482a21b2a408253252d452828f09126a04c104b0264ab823222c8b4980654a4d30ec497ebd5c2e8cefb5d6f3ba8ee3b64dd36aede8bdf4ceaeb9d93d6e2952096379e039dbe47a5ef187bf13bcd6981e8049aea62d0491888ce450641a8a60092ca23d2302637242a12051902489b00c068b301894a7a0a9020ba24c9182a7ec314cc2286c0a96c16c152b572ec09205830cb46cd16003007010800e04e0c10008f001970274012104114620a104031c000126246076020a0a58000352f0a24203beacc082035a7800042200c685399d608841cc1819c8ccf044430d3694b901871ca074d8810733677af001cd0f40049146cd1a21a28620a20836461cd1c60d124928f106ce124c4835e1c413504421c5145354c4a9428e155760419585165bcce1a20b2faa24f0051874c210630c2b32aeca30e30c34d2c05263026bd461a30d0a64b9f1061c76e290638e3b7454a00e3c16b0e30e2d3cf2d0630f3efab8c0961f18c8c01f1ad840cce304430c62c6c8406686271a6ab0a1cc0d38e400a5c30e3c9839d3830f687e002288346ad608113587b8d5bd8e77f0957e088b24101803af08d8733706c37ada44b10e8c52c0a8445c03615403613c13cdc0c8038c374008e30c10463210bee0020403650c5bf448963b5176937655eb36aee33c7bb1eb957b7c7e80800411123484882784ad9107fa9b50680814726406c52048a8100924490d328120d06c15a224820d48fd8171770b4234d4016d3e4a3cdc019160c9addb86adbd31e29f0e5f10e66b0fd642746bb5f7ba22c0177449b016adbbeaddaccd01612ab53d212c5ead708f2805144f1be8feb8ba6e0fc2b7514e5ab58deb3c7bb1eb957b7c7e8080041112340487e84c503966cda1d94b45e4d8510d5834db3a40231616161613140a2ab8d199ca4491f216589004578953a86491302bb22a75aa442c097b53e50ad615ad25ae5c80250b065ab46cd9a281067536c08ae15845678b5c828455bd93a805128e5372b2c8254858007448c2510a8a0e04e0c10008f001970274012104114620a104031c000126246076020a0a58000352f0a24203beacc082035a7800042200c68517c238c110839831329099e189861a6c2873030e3940e9b0030f66cef4e0039a1f8008228d9a353c08c143d4104414c1c68823dab841220925dec0598209a9e84c3b64d9363af10414514831c5141571aa9063c515585065a1c51673b8e8c28b2a097c01069d30c418c38a8cab32cc38038d3472a00247376fdc4467ba21c71825616ca2889a401a3468d630030555a74c4735b30d302d6c51e04b0a5926b8413baac13237de80230e2e1e60c9c1c116099b734c9172078a9252cc888e3a8860303c48a2b0ac256c465f1a224fd97614090aba03286bc521b08c6b22e391c72d41c2d2d8e36ddce3528f1f631a3f8b5bf10f3b5875cc80b18c22f14a0842082184d085aff5a2121db741add268c42442c698c7451b622a69c0252a9d92e00079781585196fe3ada0366c583f6e0ec5a52972844b3f5f72dda51229c6c9c9496ba76d5d94e29a497988b5600046ad63ad5d6bed5a6bad75f62cccbf845c453107092e4558e3993aeb9cb60bf2f02a8a1bbed227b2d633cac989bddd3967981ff2f0ea89a88f1803ed86a8dfb8adbf4c6d5aafb6566b775b57eba65579a6cecf96100eb5f0dca740e767ad1036935ac07c12f904dab32b0634b2c0cda4315c9389d204476a2dbb8a08f3bc1798a76b325d7350b021a352c74dc0bd946c418e680e14a91b12201ad596b89ae636ebd6a489f331dcd466d3274d9cc3a95a9553562d2c8563ba2653a4090ef49a8cd79dd1c32b286c78d8760507fecb909794e390006982a32d69ea7c4cd7645c4d70b4daf3e56cdaa4a9f33162609e26385a93d99ae070b4aba4336986274d649e34c1d11a12c9309b9c5f58aea9784925e659a1c87f19f25a17f997be82ec2fb2b9ab27d678e9461f6774a340ba59a5db7751b9357dce55f8b2bd1798e7abb66957e653864bf221b59b94785e2ab46db8b6e735a5ed45af729bf7b2a3fc6064327be9891ca54c0badecdada6ddbe42684a54a4f7a2debda4689655d4329e594724aafb2e3a8d46a983d607b0c9cad6fc376003255cdc559bb7d67ef2b6f3d3f42828610112af2b6278cb73e623860e481f6ef0892241044001b52b284a848022646b05b7d8226473127ef7994038ba8244c365292d23ff9cddbb85c4bef79a40216c986f2d689932a24242e32eda9a4a4ab554d2b339c05eebd2fc6894ca8e6196948f13d442673326d25376fa29b27756a698bc314c5868a28285816a7a6a62890453469a2c815bca2f448f9910f24360981160c895384a0cc8149e50159c5a7952357925c1081c432946549c4a028032650cb045b8ea2064e36488200783239609201a060761005cba604f05816a1cc4079600196c5a7324f03908d2140152c6b01ccd60757b02c852f5c342c58668284dd29000658164209595db46019531d10da4441c75b1026171034c0b22d1c54f7792b020758a60465840eb0ec4dcc88040fb00c46042b01ffe66d70bb3cce9143b23b8f74c4a410e5c821490664225bc6325e4628b82f5ac1a238b54436c00758d648fa0005c0b2a02241080001cb32503641042ce36e0248c032a8399d6927240085f90a9073c2e6518e84c556e10bf7910ac844f697a08f55c02239058ba465fa28e7edbcd563151fe37ca4e2e3d4dbed568f53bce56ef528458ce223146fedad1e9f787b6ff5e8c4c726deba6ef528f5f675ab4726dee65b3d2ef1b6e7568f70defadceaf1cddb9f5b3d2af116e8568f49bc0572ab4724de06b9d5a39bb7426ef5d8e66dd0ad1e8f783be4568f4644361f8b8844c42162d4db076ef528c4dbbed5e39ab77eab47356fbf5b3da6797be4568f41bc4572ab4720de26b9d5e30f6f21b8d5239ab711dcead187d8c3dba15b3d9e8966de2eb9d5230f6f896ef5b8c3dba25b3deaf056825b3d42bd6572abc71cde1addea1187b713dceaf186b74d6ef558e6edd1ad1e6d781bbbd5630d6f9ddcea9186f8f436e9568f33bc55bad52399b74f6ef528c3dba55b3d8e79cb74ab47311f638830bcade0568f4e6fa3dcea30cf5b29b73adcc0dbbfd5a106de36ddeaf08fb716dcea300310036f65b73af4036ebdad72abc30bbcb572abc33ede5eb9d5211f6f2fb8d5e11e508fb7596e759807c4e36d06b73ad47aabe5568777bcdd72ab433bde6a70ab430b403cb00e5881b701b8d5211d6f3bb8d5e19db702b8d5e11c508eb703b8d5611c6f0970ab433b6f3fb8d5211c6fb9dceaf08db705b8d5a11b6fbbdcea30eb2d08b73aa4c0db106e75d8c65b116e75c8c6db116e7558e72d09b73a5ce36d09b73a9cc05b03dcea508db707b8d521d65b04dcea308db726dcea108db709b8d5e1196f67b73a34e3ed09b73a2ce32d0ab73abc7aab805b1d92f17601b73ab47acb805b1d8ef136855b1d8af1d6cbad0ec378abc2ad0ee9bc6dc0ad0ec178fbe556875fbc5de156871278cbc2ad0eabde3ae056875ebc6de156875dbc7dc0ad0eb9780b815b1dce791b815b1d6ef116ccad0eb578ebc2ad0eb378fb820d73ab47791b9d6ef50ade46186e750adec6186ef5206fa3985b1d4875a0b7710f6deb6806cba44cc9d2448e5ddd55dd7b1b9f6edd9ac5275eca9642e0951472fc884cb487871dfd8873e216518b2c220d912ac61804b76911881863ac74465943f423e671cdbe0e9b309598e7979a4ee9c9581d72524a25ed39e9c6d5de7e731a668b118f8452034b354a6ff4e0c3aee35eb9f6c5189cd075bdad79d79452ed5eab751a15c2529b526d425988042ec9b74dbc79adab47bdeb7978bbb5350aa4d9f67cb6bdd79c373d6fb3db734e6fd3be1ea7f5a609ddfb697d7db669f73624f2da6e6fddd39ad3ba73f8dccfa944e61e06126946fb0aa8a78d6416cb68cd117510f9a7339859918ff4e32eddb2a2ce151f6f9ebbc27d59c2280602a45fafd7b66d5d05fef609699bd63646dcd7adc3d803a46f0f10ac07d252e6cb835cadb9abb3cf94ded5406088de4551f8380903026aa038663cc440df121db96b8eca898e9c3a6fbb1ba3d6b721966119638c593eb69717a0197f7ff3126f66622277dd5dce7ba98edc5342b02293b8d90d72513c9b28c77db96dd39939ae7dda720d549bb0d6b434479e3da33089449b88fb80d8ae7a5476aefcd83a577a6e1651575eb8cc1516739e3ed760b4e6a8d4d7be0b8b5c0dc461409e45c260ffb88fc794240c7676292f9fd2ae865896149d28475f7d589166bb1157b14c72e48dc63412495ba22343098b4e126916d1388d216a2a374f1b89b639f7c1c65ea465f7b95ca48b1f0754a38ce4c0c97127463d6d5b6912077288f6921a4b75646a86d2d494a04824ae2992a7444fa3cf8c8cfe4ed7ec19779be3b839340bfa2779d6df75739eb780adc0f73e148c8024714612df7d60de322591e318a72912093e8d4f314d520bd1e9a9f6a5c0a486360a592820f91024d28c519eac64740de38bdcea97f89b56a52469955474526a1446a5afd50f524ae9f7454e31aea89843e76a4aeb67df8e1ad728dcff36d911c63550b86018cd39e74441098c2e9428a4a2110f55a2093d229e306492ce5218158c30cfc59752fe2c8c0e5f7f164686af5f8c79ac90a655078f2c6deae9bfc87f16bcc43c3abcd65b96988f380bb4e3b50f4a18ad70494e2946524a6596596a3e85059e527ae714aada3725ac115fe1a006e2145a7c05237b366515ad8e30b470fa0ae665ac83cb0a7ae8f3b3675e921735da939b4665bc9152a432e3a554492b347e0bd6cc4ae343807728d4c2fa14e0567552e3a3d3930635818f5068b6a8353e46b9e1a4ea7c949aeaa8d8f84855e559b5f1d10acb6651e063d69d1bb5b23e6ac52dece4c64ba72717d41b2fa1d0bca2e07819e5264bd9792935d54315c74baa2a1f2b395e5a61fd64cdf132eb0e90d4baf3524b6e0171a2e3a7d35310a80afc84422324aa8e9f516e82a4f0fc949a1a4265819f545544acecf86985259475c7cfac3b45a696d64fadb9e580131e4f9d9e8c40e5f1140acd03517a3c8d72d3527b3c959a722a3e9e52557d567d3cb5c23a927581a759779050adada75a742b89931f5f9d9e2080c2c0572834114465e06b941b98d41f5fa5a686a834f095aa4a89d506be5a612dc98a79be66dd21aa5a4e5fb5ea5691130caf393d490015c36b5068984489792dca8d91d498d7a4a626a092e135aaaa2656645eb3c23aca9ae1b5ac3b314debe9352d6dcb89130dbf393d2141d5f01b149aa4281b7e8b72a32455e637a9a9275437fc4655b56485c36f56584c5939fc967507caa605f59bd6b64581930ecf393d5500b5c3735068a244f1f05c949b9f334eeacd3c27c54d5950a75091b20a8d563478858b177810cb9d595c186499814fd40204b704891a04c10d884c0014e1c0880c40c70e3e280024d10308e0006093004a3e20925c24880530825d9a4410623004a42982d2084b920428b1840aa001a4c4033441044c99265049801539bb209e9005a2904154c016b8800d26033848a103e9c583a802016003b8c42f5de00a214c1646704009b28503c407980021308b1140018259c074218517549061be442716200c2dc4182000c58019f3820c55704c16b0e88cb7910c2c92ca64609833889975bcfa9e495c95d5cf9ec1382a2aaa9fcd6149a419e5aab0ea707438aad9dc1c1aa6543aa51617d7b4b6e6de955abd2a5d770197a554c6c209218d4e327e3187b11049e45c3deb7998837af67a387309e91906ead905d233fbd333eff6ac7bcea767dbc39e69b96715c6a199461ffac4a42c87266ed8122ed9866db1cb33b287e90345537fd080d882e0d2746abc3556884b8412ff721220d1ecec25c0a2d93d71fc6c1f397e36f5397e06694184fcdc06721be8caa1d99eb3c0bdfd44804c6607c7b5c48b892cd5d3848f133f4f004101248a2052089922686a081532ce5b17a18836c206f68011467d8492b791f2b9b17204892d482e7699c45b1701167920b99ed16f9b240abb1ce283789b27a3a6211de46d9e949a86b410a021edd2be4bfb0788b310f4f46b33e4cb4b8aa4049489263dc0329a461cdd6235819cc0e3ac54356972a540aa2378e4924a4ab119cbd4c8c88974e2c3c16048110968889b3087a60a11367b36ece367730d93822805c92744968a502623505a52f05580844681400aec95704d44164830c548be7957adf5a561fcc2ae20fccd5c3848902038c81512e49b5d0b040464813c205ef7f3f3d3fd70f7e79b711bdd341fadf6509a35ad39aacd9753da84b13cf0de46bba3db39e7fa4ee8ba5289615908b068f65217b90a12b5a234af2cc90ba0442c15c02c523068ca608a162a5bac687001968560b14b396f39d032e999b7f362a7669ef2f07407aac3dbed62a7506fb98b9de6f0b6bbd8290e6fbd8b9ddef0d65eecb4cc531bdee28b9dd6f0d675b1531adebe2e76faf4365fec7486b73d173b25f3d6e762a732bcfdb9d8e998b740173b15f316c8c54e63781be462a730bc1572b1cf0dbc0dbad8a706de0eb9d8e71f6f895cec33036f852ef68981b7452ef6e9c75b072ef6b9f5d6c8c53e2ff0f6818b7df6f1b62ff6c9c75bbfd8e71e6fbf8b7deaf1f6c8c53ef3788be4629f78bc4d72b14fadb7105cecf38eb7115cecd38eb7b08b7d5ae0edd0c53ef1bc5572b1cf39de2eb9d8a71c6f892ef619c7dba28b7dda792bc1c53ee178cbe4629f6fbc35bad8a71b6f27b8d867d6db2617fba4c0dba38b7db6f13676b14f36de3ab9d827d65ba48b7da6f136e9629f68bc55bad8e7196f9f5cec328eb74b17bbb4f396e9629770bc8572b1cb37de5270b14b37de5670b1cbacb7512ef669c65b2917fb2ce3ed5fecf3ea6dd3c53ec9786bc1c53eadde4eb9d8e7186f6517fb14e32d958b7d86f1b6cac53ee9bcb572b14f30de5eb9d8e7176f2fb8d8a704de62b9d867d5db2c17fbf4e22d0617fbece26d0617fbe4e2ad968b7dce79bbe5629f5bbcd5e0629f5abcdde0629f59bc05c0c53ea9de7270b14f2cde06e0629f57bcede0629f56bc15c0c53ee5bcf5e0629f55bc1dc0c53ee3bc25c0c53ea978fbc1c53ea7de72b9d8e7146f0b70b14f29de76b9d867146f41b8d827146f43b8d8e7136f45b8d8a7136f47b8d867136f49b8d8a7d4db122ef609e7ad012ef6f9e6ed012ef6a9c45b045cec3389b7265cec1389b709b8d8a79bb7b38b7db6797bc2c53e8f788bc2c53e8d78ab808b7db279bb808b7dd6f1960117fb2ce26d0a17fb24e2ad978b7d0ef156858b7d46bd6dc0c53e8578fbe5629f6bdeae70b14f356f59b8d8679ab70eb8d867106f5bb8d827106f1f70b1cf1fde42e0629f68de46e0629f3ebc0573b1cf1edeba70b1cf336f5fb8d8a799b7612ef6c903f6b903f6a903f609857d32817d2e817de6807de2807dde807d5600fb2c837ddaf036da70b1cf1ab04f1ab04f3ab0cf3bd8e713f63903f64906fb9401fb1c837d8ac13e63c03e61c03e9db0cf3ad8e71ad8e704b04f35b0cb3cd8e506b04b0d60977f609719c02e31805dfa819d3a619f79b0cb2decf202d8651fd8251f6f231217bbc42ef5c02ef3c02ef1c02eb5b0cb3bb04b3bb04b0b609778b0cb3ab0cb0a609774609777b0cb39b04b39b04b0a60976d60976c609775b0cb35b0cb0960976a609758d8651ad8251ad8e5196fe31617bb3403bb2c03bbbcc22ec9c02eadb0cb31b04b31b0cb30b04b3ad82518d8e517d8a504b0cb2aecd20becb20bec920bec720e76b90576a9057699057649855d62815d5e815d5af1562a7139ef2c2783c018744ccc6e610b4cb4928918638c514d8c31c618638c64628cd10530314a31d18fc8868423b9c62eab904f920c063cc4dbdaa455dbb8ceb317bb5e99d2cad55b2bb5946e9d75e51f2041441c68edfaa51eed68473b224586c0087ac08f1449400802989209bc3052d431b11374365e27f882301e17d6faf51c53e9b8da756d271792f139212382243a48748694ac92ac963c1943690c1f099e80f13d3f3d464c5f2c7d918f9824f0af9e97130aaaa054b99428f0e2f1ebe2a54b2da55d94db711c1739aeafd6988ae56cd7b66d2bb8d763176f2f05975e4a392ede7e9a0da37ba8b469dea7a2142b332300000000000400c317000020140a06c3308e43412428b63d14801079863a5442389445a3711c06912447b158648801300000303322336c005d9745fdd93250c8929bb689fda76378bd354b19e9d74b5350e4339e5cb97a5b87b0f6fdb60ea2d88f8c63ed3f5441ce6dab9b11ea48204827141b34dcfe498aca87ca8c815dd72cbd493fa2aa9833f0edd3dc023a5ad0ea810113651b076c8f1ffe2e8b5bbe436a17d6bc1636375b71df30ca242f602594bec43e7980d722710f6f1b7ad67067f099aec069786d852d5c57049dba0713a0514e97b263157643e1b5b6c425a4a4e3d880e38af1554df973290176eedaf344b55456e3cb0ea6773be5866f71638ef4a641392c3ffc3d298645dd05c051ec1e3226512edce716604060a93173953f73dc8fdadcf7d7ff357234b1b4c5056474fed00bc0fd52dc28705b04474e58be18d0b4c4a78e8fdf388c7c13c0f517cc30509f0c13facfde537d0fd3eaf60d2d2c3fe081be0b0223fd5c3030b52974e1eb3293c152981fd3454f1ff345711573402d74dc914cdd28fefc7cd7f44eefbc2437cc9a048ab19ff4ce3bf3366d6bfe07250ce7970f14912ebc67b1bec57033f79b382be7091dd6b6b75b1eab83c991aca8aae276d46a0ecfffa39f51978267765e8d3c36985b5e3da79b62c9706546f6a46b495629f2d09ec7a35f3e347f36af45f51c7e1402f3cea2fb11c81fc728d1ea939e11f8d66d85a1b8049c8d759a787113c131001e3c564b1231e1afa5a39f38a6b6e9208c24189c4d723e60327ee17019e88ea882fa43fc760e4c582ad7eb3f957d9ee0020ac950bcd0c9d195edfea21a870bb412917ad830bebd7f766511db2ff1aac69ea14dba5b51f00173d5e8b43c95e1b95e406bc98054153aa9a950093d356c7ced513ca0f6459d5d0f61cbc2848b514566522585a1666ae40e6c9404eb008963cb6fda210c76cd93ec9e982fc76ce2265d241c7fa5613be1099b7b6b6a2f6c4293f3fd34c801f9452e67231d65d8083a2d5323cf755ef8e0d04e071c688b1819d589ad43a587d483039a3ec88abdf5f0f10fa4ec8aaad223b96aa05ef00926bbcf186d200ba42efa5d211edf1f153a6c253c07f890971f807507e1a0806fcd2ea20a88db43c3f40810e10ae19b337536f589d7c3f4398081a80df0c2676eaa7b692d129738c12ab0fc0ba7ed2f8a7bb7aa819438ddcb7325759b8c0c8193273f6cd5ee88642bccf19403a84370955321748f502b1d4029169e02ff6f7311ffe1c6c54437381779f86f8ee3a0050dc6eae50ca5731cf3453f4ea872203c49062a9a2f3252790cfe4f8bba50cba998c22aca95c7d4a91bd9e22368ab53fd993a01dd3d698470c56adc546262141b742e9a439a14de23b5d2ee90796bb26b086b24d3707af70e21277843d237f1c7a0a078034e9d89e927f402b41a042e06e2ea3f6073571d08aff623e47ad3b7ba8ddb6f6777eab71a22e71c7682e4e6f750acd56610ffc46ad84cfe0706b26b4a6d9498bc5530bbbc4a8209275851a08139b5fafe62da7a4285869b9bde5bd7ecf2515a9f77b4ec2cb081ad148a589a02b2691528f0afe310e547a5fc1ad4c234e2c35b9452e69172182cc3e9143a6761ba3f260259cb6d178b72c5f7184e53a4ef24562d52091b38ffba95b766ac8528ced8559ecf80e3755b040520f07504156ed4d613437f2b6a00835e2d50e05d5c5fa28b85a90a3de895807a715abf32021b78197fb5443dda74efc2dc26a94a0ca90e81a28de0954042e24563b3e9b0ad6524c3899584a99f1c0962f20901d345642c64c7d9d9e850a34c602f744dc236feac809dca1be6357df79e549b594c9ac5105d37a5ed14e64969c48735c30dde90c2edac44d2cb955a63c4cac12f785a59d275305eced2e9387f5a11a03bf6a6cf0facdb20a1ec9de70aca4196fec30be8a4b989ccc76fff3acc03404d6c9786a2d239bf938d237e86029df6ce04a70fa2dc303f2febd25e01d2b193fcca53ba4d7a93fcebe13751cc7d5e67526e986a227b7dbc71e024af4e4540f5fb53362b01677e26a1a227b2baf8fb03e86a6ac993182e22218aa4ac7a12cf4f688bf1be955beae597cef63789c3eb5afb449623dcbadd2f4dcd03efc72059faf7b0a1c44efef0e1a38a81859237eb40489b015be94242522dfc4f98bfcaa0cb0111e98d8eb69ddc634436f568131dccbd7b27d88325878a378fa0cb718dc3880890ce8b5f3cccd01a7a8516a851d914fccd696c99c6f4479b138d135f994f1843fb1e3b0d6095cf8ad16a5007b3627568b0c72b69e73843abb61f1367acafb7cc4e93be6aa761a595a48e9d8b1bfc34b3eabc3e80ed290966801442060dc73948fe3bcfdd24b5c0dd6d87bf5700b13a79e6da5f9bae65100c86507b2bcfa72bbb27b827177d0dfd0226be79b2085c66df6f605621dd5ac18b0ed9a19f98b8e84ad19322cee86288f472f9fbb04649be252e6311acea172a97aedd4407895c6ff197ee42a7f0a2b0be7352e1c507c4220bba79a50b0557b45b01257b5be56ed646df07d6925d35d8b5baa578af7349759b93e74e34f8e1c4950269c64f57f740c4877b4446c9f5506c76011be85bd858a5934cf97abde00410a256adb9480f7f7688880582afdca28fad57f6c7e52c59ef97e48fafc9f1ac27dd3e968473b28dfbde635f3c5e93735a4fdabf8c8ccb59b2de2fc91f5f93e3d9ad63d8fde80b96b364bd5f923fbe26c7b39e74fb5812cef1249d3f8b38f65bf18a7715d9b6b1241eafc939ad27ed5f46c6e52c59efdf22ce1d5fbf735a4fdabf8c8ccb59b2de2fc91f5f93e35927ce6ba4003347d7e494f4ebf6abbbe362f6aff74bf2c7d7e478d6936e1f2c71d6f5cc5bae31e48fafc9f1ac27dd3e9684733c49e797e4fdab552cf75dffdabf8c8ccb5992d48e530c36892f0957bab54a3bc915410e376e22baf46d7553b4f826b1e3bf6f4ee1b83be7cbc3da727a6a7f7bed142ddf247ef4ef9b66e1a69c9a9adf5e3bc7d66f1a3b7efb2659a829a7e6d67faf9fe2e59bc40edfbe491ed696d353fbdb6ba768f926f1a37fdf340b37e5d4d4fcf6da39b67ed3d8f1db37c9424d3935b7fe7bfd142fdf2476f8f64df2b0b69c9edadf5e3b45cb37891ffdfba6593837b38c926c1898640549894e31d191c74e0aa3f35e5bc8a41e1331a5827c9b5e58eb02f15851fc99f921121de268a9686484c90ac3e5c07444cc386145efc579592f0258a899d91db3a0eeb50995cc546d26ac160d07520c9182e5a55f7a0db46787b44739355aad8c26fb2c4af639ec4898e04e402f79e23bcf0c29d720fa1e384106c650db97ca3f5dac482442b90524d1d56532b51169601effb63f582ba7cfb8221ae4441537e8f905afc0a94041664cf8b99907b4241c081557875cb9e7bd0cac2326692841096498b8333b31295f71858ab27126b856cd03f38af33e7a696aca59bd90308ea96ae64ca2680d263a2ad880a12a175e8fd1401112d51495f5393f69c178503df460ad3e7ec292883c1a07043a2a06bdff206a6249ef88a8837be9a889fb7272982d1e458f6ab4407cfd12b7f174fec4ba60b24f98f60dd33e61da370cfb84619f00d30a3a02a6e5d405a67d6598af43e145b31ec2aadc8d96da6705c010443c850566e193b8d5ab98a3c81503d985060f58efe381d9fc2c58c12558866bb8866bb0846bb0066b684d50ae7a2b799522df8959fe5880e88f8488fa4880a88705887e9810d10f161444fbfc4d7c9aa02e3c4919da1509f256256e25fc1be1a5605919425c7614917c52b1c246ab910a12343554e379590f9da7e005f41973d6261caff5fa7e1368d5f5461abbcdaaccc108fcfc236c8de67e7a22ff695bd65fcf27247f17245b20bec9b1b25044e65e773b3991ffc3b9d2df8f27f66f3cb7f5f7f309fd1fd2dc2db42e70f40537445f394fb97f704a8fc3bab2fbe07d6cc3fecc9a51ecc05de0750a51db0cb050215237363254e27627c3a5deef74a8f4ed36e04a864adf927d1c799f76eb06e67924891070caa8fc4f1f8ed7511370503808ec67f1b8d55530815277a6a84ec3436d1fe61cb2ad5a68e43dade6831c63b6559fe3e8e2d1b5e7a40f31212b81823a552901c8395e93ec7a60cb192c9c30ee5090961b39506f42909fc19141336d0e2601f51cc35ae7270115370af7f9c09a0211654e18d8cde9742e6cd256dd4afd4afdaafaa41a47fdf5d4936498a55eedb1ef608a8117fa401b6a5ee848347d93fb87909f81d39b0987a0af4f685a66567e88be6629f38df0ca62e29955ae3b2be943bbbb97969c4f2d79de5a421d5bc2bfb6047d6ec994ee2db1bfb8c4787209ebe612fbe812eed525e4b34b9a7797588797f82f2f499f5e02bdbde47d7c89e0fa92f4f925d2fb4be8034c021798a84f3099de60721f6132b8c2647d86c9f40e13f52126824b4cd2a798486f31a18f3101f43526f9f798100f32695d64529f64d2bdc9847c94c9e65526d65926fcbb4cd48799402f33a14f3309dc66a23ece447a9d497d9e09e03e93eb034da4179ad4279a086e34411f6912bdd2c43ed364d0779aec2f35399e6af2bad5e43ed644f75a13f3b926cd7b4dac834df8179ba04f3689de6c621f6d22b8da247db609f46e93f5e12683cb4dd2a79b4c6f37a98f37115c6fb23edf644af79be0f6c2d2ef5875fe8c216c958d252bf454fbc6fd448e2f7990c612bfe4782e80c036c4a5d78cc13f75c3e4ea7fa812dd8b3f93219042ffc462acd01d20974810f35a68cfda022bf0cf0d5b0844e2ad640ccc9247f4879227643a4251555825b61b76e95b7dee25a41d146709bc8846b868b6d477d87408e86264d9bf4825cfe6454a39362f52597295b91648a254fd84786fcc6b5256be1868ea0a3ffda49067fb724a59f62f484a5db21e435691e7253f0af5f34955eda74549f84325ecf9a35be5799a9adf67decd7cfff9f072f97deeddc8ff9d0f2b87ffe79edd38c77d16e2d67564ad8bd382b8fde80fce55dac91a9943e9defd80184f0a057e19b88e2c055448f91477e8ccc0db0fd72dacb917f34adf418b5f3b8c1b164e2142bb7da8a513886ee7b48e1923c3378ce7653c3e43f7bfeae3cc18193e61382bf38119baef551d67e648f009e3b9329ecf50da2734df6015bfcc8f4b587040bf7e1c683e06f0457cdf4f08626041544c95f1786a6fe6f2e23e4bcc809603616ba8969b1601ddb22812d9c903bd0b5ac89fb147bb3d42feca10c4a7299e3af40d4719f209a18b6e7af83160576b0bb4108f46732c20b6373e1934d3770595519d418703f64702aeeb808fc468110432a642e34312ad0ead0d9ea21326e89c630da51f532a8626c6c18f30382c2b845f8d7e9d5385c83d58e4fdc34d39a6ef46f314cbd17adda027f0af5f78a757d2b5dd87f8d5515fc0501886a73a9c160e93110e300cdc37654d831658ce7df133567581279f65c60b37bdd4f7aa77f651c5f77c30e0f7501492b23defff3b927b983786c5dbd8f08af8f58f600ee48d9719703cf152dfa535b4b1ac644e79153c0f54633af9c635ab755dcc6d2f643f34354a92fb4273df4bd989888a86f778556e0a187ba01c867061ec43f7548317139dc04f01c3778a5dda04a412d08ca86e564777b38e1e419a7b8b3a8ee76cb3ac0b4002cdb58b0308f5d4a8440109dcfd99e585a8a8ace2f7fb5a0ddcb25dbb8090e95c3168a3c669452a512a526cfddf01da2e99be5530117e6c05a3bbb3f9c16e13b9c551a623c8542798bef181836ad515edb07459ab54cc3e70f887e81d7907f08510286631f8df194a470527444231015c3683f1056354865ffa2633d06e4ed8f8220a5e2026436c17d4212e7248412c508346d55b65137bb3124af6566d636ead8793bd55dbd89b54195a48027c4da2089ece0367af41bdf00fe42ebe1475d769ba33d8826568b800da965fbbc378144dd623faacd25d9b3d5ee79670071ce30a14c4b68b07f1d1d1d9a8200582424c42e4fd7eedaa722c29b37e7bedeb622c293352148530c29832f69a2f008f85afaeb3d1011669520ac2e8903d4a1b59e0313287c81f237f88ec31f287c81f227f14f963e40f21f2cee93dcae070c1932634b1811a0dd139c5db324c7f6433a1d662ac5a9bda4f2f2a11c2222d2e5d7295909587cfa416af463467c20b1aa135653fae1d3b532b40b85670b86c76212754736e622958b4059b852b189c182f6430b46d6a707f3574a3027f22c1e25ee9a6e7c1204c46f57c83e008254178b668d8dc1036cd352471fd0aced52f449bdf7c830fec5420f1f1bb5d0d27f6546d626d5643133dd59bd89bf550a2a76a1b73bb369cecaddac6dcae86123dd59bd85bebe1644ff526f6663594e84de426c5458b5b6ebf141559c4fcadd951f22dee91535fdfa2a7be6e8f9ebbfa163d75b52d7aeaebf6e8b9ab6fd15357dba2a7be6e8f9ebbfa163d75b52d7aeaebf6e8b9ab6fd15357dba2a7be6e8f9ebbfa163d75b52d7aeaebf6e8b9ab6fd15357dba2a7be6e8f9ebbfa163d75b52d7aeaebf6e8b9ab7512b834e3f453dca2ce7d7d8f9cfbda1639f5b53deadcd7b7e8a9af255df812cc507155c1460c39087023f7cb59adb4cba97d51e21f5bbc88d85dc7e9e1fb89ca49a089e392f50db1b4651d98d4912d34ef6bdf6c52b4abe8ff0e36ae528c6b5fdcb8c1a8322945c7f68d21fcfdf7019edea3dcb1f8b58fcef43f0f1b2c4170c326a173ecb4c65e8042c35128f01447e1aa382731994e17089d3e103a5d6074f480d1e900536964ee66584bf90c72f106d11379891fda1a9a6c40fbab706415eda1732d7274fad5bfbf450da858190e402c1793649a919530964aa395e9011613ca72556205e8e18eb1cd34a26b3bcdd66baadbf0569931b69967746da6dd724d7513de2499b11fa8807b1f20bcbf3917b26c2177b47d81b8d3d745fb57c69573b107daa1cda49a56c3e06f1e234601dd7e1ecc3ac81c272ddece6344b55e46f9eeeaac65d044f025bbceffde8a58bef4000076756ca456f60559d0b27543869dc60fa1b2c6cf2516a62f0a55b09c5c52fed31ac20747d43bf99d536ae03ff3ffef978759b59ac074c359740083ace39072bfa052a416bb840404c40444448988880888088808081010121310e24a2488ada46d38d1d689cb470f4e90022d6f4a2a6c9a78ca8dcaa30baa9d3bc3334c1b1c8b10c5100c1cad3667fb13da3486e15241780a60bc438395e8c5084131017308846634e4a9443309411186a3378eac485f078c75cee0043a4467308a628c86921008a1009a706276ac463b0562c6790653684f239c3bc76305e12980f10e0d56a217230415195a98518c4a77750402bced62bd094713e4e8ecaa32d0450d7553633e66be80fa564832eb07f835ad86bd5a77d3d445bad33f3ef0bc969eb2b5942e450fe1f9e6a3b35688a9ff0484888a680b122cfec2e25fc09a1fdf394d4640f42994591038d420500b9bdd1aa26a066985b92a23162aa0f9003d20f818d42c66c55197071842afa57b6ca92b62d30c1e8050495151714545650565456545454545654565a5cacaca8aca8aca8a8a8a8aca8aca4a959595159589e22a8b888888888910132b2e262e2a4e229f62a22222226222626288898b8b8893e82b20f3820f05d5eb8faf2f5f5f5f1f5f1f5f1f1f1ff5c1e8fb42ed9ae347555f595f5d5b5f5d5d5d5f5f5d5dbdbebebebebebebababebebabebabe767d7d7d757d95acf15a495ae1e9c00660e9c34973f5fec02ba27421a0b0aa7d1ab11175dc82a7eefaa21207de2d546c938cc3910f9b6fe9389e46dee2e8a430e05cf45fc458348c2378e8a4e66df465ea8550fec3a5dce8f32722a4458b84734b9bd237bd770f4c140231ee8452f5ee1e62cbbf021849ebeeacc9ed404257702fa8ec248891975a0a1295a2f9a4812bc3b49c9785b32f77e7819bad8e25fbd3424a8c8e4533325601c87ccf997fafdca1333b7c107afa26ae21959d077d486fc8f55fbe489318bb5ce6d322441ad1a959fee5bfdc5221fc5ffef5242910e5fd5b891f241f7a675a7a1d1aede6dc9b202a07cdcc97b18054d255b0c43a7f8f3a84d44e40eafe1791f75a47f9239da2fde46a333b460354a85b865c9f2840b404ac8f8085197120c7816862ba8b8218c3e08d611cc0206aed8d56755d16c0045cf04d6b4692720969a6217a090468c9b8482ac1d6e5110738408b5c6af6bb1159fef7384ad9f854512fc57adc7bcfcd968e3d27ec2113cc30e12e73a1e25a82cd5b4cc5f24eeab4f9b30bdb13e8ed9a9d6e2492f8f7a2ff6ba851bdf03ff562b885d710b8b076730482b52e2e6315d58b32b9286acfd38dda8f7808353a66dc39a904343ac7380b636546b2ff05b8b4b40fd546539e989ba5aa839323337626791676e7a58c7d93520734fcd9a72ecae0d077f96389a463c9e424199949bc034d93c7ebf7e8276c7caf5a68324df51a0a1842059a347ac56515ffa1c259da098edc3154c43c8dd69ba7c417bdfc54f060170d4e512e9f37776a91213a916a47b17eaa9f5253acea87474f5c55db30778a0d1629c245098ce097afbfa71bf4508caf5bd0f63307b4e14d800074243ebbe920b2b33f9c13e2c74215fecf7056052109ee9af8508d805b0527b23770d8c5d4d93f2333356b22ec498e99053fc735b6c9b9501c7ed5c7b2419c41eb602a4e1ddfec86f3c9c7fcf1e91e7aaaddd1e1f915b1caf0802235f56c3c73ce87c2c8ca7f1ac32934a0b8dbc3196d626ae0c474c0c4240f6ca51a204565a11864010d3705560f0f25ce70efb3d0155e6b1e4c4860910633dd7d5c53282866d017e3c4ddb6e3f29aeb9fe2b604fa6c5678f5b16ec4bd3362e99baf07a2e1e3505480c852499e0f35c4a472b8d220baa883710b2bb1727039d5c35cc9e6eddcb3aa16acdafeaa7b1f154205943707b164803a38b949d6d1501be99eb774fa0acf961dec14f3fd75efd2a0f1347e29b2703b334f06d0ce8c9c608b9167ebe9f01161def01377538f3982673bbbfcfd3a443d291a4a78ff107f85c3c6a042e9bb196ac47eaeb74e5c20c62f621d13f67b31fe19ce8e521b7869e96a267223b5cebf37001a758355bfd86ee52e593a1a63cb491590eaea24066420dcd3e407f969f332b7d690f55e228e224698ad7f70b24954eaef52aaecee8243553c2963e68061efe37c09411f07ad888707d1269283c772c4e2af3fdb7356b33a22e66c336f6412aed859ef3f90be5184b73b3d0654f456aa0e4b1c4216b62126c720513cfc7e045ad1846152a5aac2e72e0f148364c155bbe08a9ef4564afac470fc380cce22cc8afd1567e32175011425996a888b09f51529f29bfccb2d4f2905113ef892d9dc3e08c293da5d342faf04d562b52e9b9a93138d24f04a5defffc6ca025fdaabe1ae43b44cfdaee61c704953c6708833c8446aeb8a704b4f542ce43c2878aafb852ef5f1fba1054f61852c9741bfa377aae7f11ce9379e3f4f15056ba1338dbd055ad0a370d674169e9ebf69d53996e65ef804bf22ecc983dc9e204784c28014f697313b3d97b9036b85a238d98b3439fd6dd11703fac5bbbf60020c3003c38088de7647acb948902ccce9c0a7b630e21603bcc57bb860fab89065065a2f6cc2ee0a7dbb060a7d438dc43e1e1bc43e58e9a06f2c66d087eb57d037b424ecfb511dec838505fac2de017db9f6007d4107c0be8f925f5fece3eb1b58f5f721d4787d00c3fd3e4253d777d39f71c6efbea34ef6ab4b08ec74896cd77670f4223cb2dd6e15d8c85f59f75171c6239885f77a2011e8ae563423ebc017ba449d841e0768616c450c10adf3947cc647ccc1178fcacaeadbea74fbc7e1a5459f662b2a0e10abe3c93b51f69d25e3604fd7ccb80ff8ec5fe1501c9153b0543e5c3ecd9570108b2ad5c23901582d454eebf4a58def4f9c1fd4b3f54f21a1b631ec2910f5e7dcd845adc573bc7cd3d8e1dbb5a770b4efd9e9367d22360edfae69166e95534eb7e913b171f876ed291cebcff924732612b71dd3326f1b255738e1ceb46d7d834be3c8021218aa555baa267a229e30dbb2215ff03c47d8661463d4f2fe5455e69a14bbdda3758dd26f52b1e80d77e9fd5d6a87a8b31f244c0f58a99d0b7e378d5684a2c659df761ff70df9bd46832f607513ff67d996d563e9b8a12f4e5a8f07cb5ad1f1dd56a98b6143b0e3052a1c5be57dc06b8a673e26186ae9961aef5f3c2f9abbe01f08a36d39cbf650927cca7758a3b8223a0c8f0ffa18361bb04ee71892b93441ebd43f31dd740c096c54df1a6829e204872733244a26cd8ddecbc6f518878a566cdff2b2d6a017cec4c4cb1ad5c24b7fa3aafbbd303880e3c02fc08939db9a9c20fc661abdc554fc0412fa598248666b73af6f076a1625dd25423ad6723dd7905d4b71fde2def9b9b4f287e07927f1b23ed04a2751eacae1242c0f1408ead5380341f95321c4347413e120be9be03cc521ae577087787d2222ae57e58878f54fc4b94711dfa196227ebf656b118fef8bf7c47a0f548584886258d10a02c206a34ed33a8be90a3af2b368cfae90b6745b313d259300d7145c81a495f71ea21656f6c6ff7a1495778ee6e87d302fcc53f67edcabbb6609fe776c393e31d5b545a52388a93c58dabf95d89ff388fec21ed52c6ce3688d8413d0d0d84f29362c45331a49a5684eca26b12e8a5e4f14cd1d0ba268f6bfb8656ea0e71da811a02f825e059a426cdf3bf4ba211dcf439e3f28705de761c60ce9704217cc47227f180add2541352c8c542ba72e76d7341d0feed295dab954ecf96c6e16f247a448b50f376ff6c64b5903e537bcac44f59d4395d1ff363df9d7580364b94f2d93a311d085cda64c1e18b96c207fb8b564712a0705133983e059155c638e07d9137729ad6bf15d3a792baa26e8b13de80d77e43ae98ac9b545b42cd4af527b4dd4ccb1b7025d140c3acbd7adbed4dc4953379101cef3e87e152d3a1383ac8001aa22a31df0783d1617463c02a410be372afe6a0c5187406bc6b4db3169e4ee5168e45cd15ea30a470d5e56020ec256f1120d008a852a6b44df4423e695cfe783231c9db799544a001a5cb7924fe9d885a2cb9652ee72b0fdc0d9f3820fe9c504e0294834bb94b8f96a56b1ceef178be4d36a277315ad1bf013423f9076750ddc0f5f3d4046f0090d14315115dbf5ef1fb28bbdd1014003945cd5d371aa015e02f81f0a3d10c96fffd69b22f800537e431cc39832fbe03ea773f8cc4841323ca7d201edf4b8ea71ab7f568ec895c220c21cfca49cd1b851430c2d85e18173997fc7d44dd67fca8814d95c459bc63a3d850b0eb26346e56584c5599668e826aea4ee83af77c52bb466e638337f4ecaf7359ed5a2fd5ec732191353774fa1f4f3942077b321210201c90ce8536d543db0fa25577e5706ed9461b642801f418c94c8b1c673468185bde99c7a882682f200e8f3c6e1a61d9bca900bcbf55d490922b1fcc57d792e173ab542388989ed6f9b5537ba5d09cdae82680303babd4191fb470f45e562722c11b47bba0a84e8f248804e900a71561b2ad03d500a7d7971563c206a1afe6375ec8b5ffa17b87a47999ec554f18c7cb37a958f86ea6c21942aaddf3c07cd557039d9ba43dc2414bff934a92c5eabb7fa09fee33b00d3f317ea7b18417f3cf2f731b481b1340fd6a224bc565562ac0a551838d84035f50ab8363145d22db19ccda1d418ff3753b82dca3e7a8e69c042fcb8699e08746ee312ed94bf824eba94a91f6be9b39a553c520e4814fc95f6a8db3cd106f8d4583afe46c92a35bec0b65b4539d0b3e8c447c3bd1597d86040a53c80f406353a1df9b14488e4a4e97b4511d93dda98a57e009965a48f842a296623e3454307c9678fac4f2bfd30ddee8209ef07a3eb87e9b689d050c206a8b11a749ad158519e927d97c6eec3c41e38910609d88075587992b72a231f36bd10801e248dbb98d532202dc8d2c8a7fb3972e8f2a6fb44fc5d588831408604505de1ffb6de6f472289274f3c5d25f68a0755b749d6159fbacb37342b7ab6d661a7d10ba42c895995a950e330f8f0e439edcf0dd5ad39e306a52a00e98087a10b9a9176884e38a11f30d3d2944bc13cbb961099fc4fbe265235ce13d38ad35160e80eb09e4a328dc011a443bb96a80b0f83c10b37dcb9b4b9e500ff6fd541fe2c965a9033a9b83fd3f4b7c3721dd02148090d708480103225cec04ffdb29e5be351acc8e6b6e27c8ea352aa0dfa4cf6b38f1257168ef5721f49871c92718d16554bf68e80bf76e0519979e2f723e31eda3ebe6b224bdfc1ad5307393bf4bc6283781db6e3e5c80045ee9fb0980d2dab35f642b4f86ea81f1ef11379c9464e4c664434000eb433ad026164a08b364cfb672cbb1932700da430768d9580be21ef65c0b85e885baa0c1e8f29a233224d72caa9dd65d0784ad3ef4b1f65f3bcc2ce5a39344279fdd2d67ea3d33ea18aca4770626fde33aaebc9a68ed367ebb5113e3b36e273277525d439641735e394a7cec31c9678f3217bc8fd61646131f3f26f3779579ef5b8c2c1f7701e4922a5a36c74986ec636ec181cf3772d7d28b361e072389ddb1d7e4d27bc2092ab44b437202f6b87d7d630104adeee2c4908940946e3ea6862d8513713209c457282a311cf7505e07ba103c44ad33f8193b2da61e08df2b2acf9c487446f99cf6d667a68822a313ccbcdd1a8ad8282026790f5fc9510aadbaef765d6b98e620f9c69ec8aa538d19394762f46f55b690f98d24143924cadf113a740b65c802da0020f6c5350bcf919221d873018d9f3d71e8eb103275033dea2267afffd54f6c341f078df4574edb42bc6b48b28d8ea33bc88337d63ea1935cbd686e80836cfbf5b84bcbecca3e0b1f5f9c76850708732b3f07aaf7c58bf57f97871580ce61e41dc661fb90c8311c7374ca72dc2a24206b33dd4a3173ad3de820c269c07ea46ea09bd5044bea25bc43a79450f2083394b3410a70985deba525e66caac9c679407db3218a37a44d45768dc7e2d3ef10cbffd2bf998250ce148a01d33d53b60f1c9168cff9cbdcc6f873ad7e6e872355eb1c11a82552969b5cdfa0739408e0c9578ebc08a4c67c375f4219294a9ec9f60f4284fcef10bed4f05af109840e84a6d2a2f254e9869ae61e9ce7a65b7602cffb88db676108a49d86e908abb3ab299d7ab98cd8ae74880befe85d206a647ac8867935c54ff8270b72a3d624adeb8e29ae3497718273b4baca32746010239da3008785f00e16bf8c0257df332cf51dcf07f82f214678d976826ef9737d07b86dab26bafb0367ce70dba15de66521be28bf9ada3714a34964e2017908cdecb6de273fcfb842a2f645f5f6663046a9ae5f29661f34f615c08d2c1d8773f2eebc5bcfd912279d7dd664a437c2f3273c9b860bf6bf56696ab9aff8151f29e613a9a02843cd124028fa5ea8b720742165971d37df005431cd9aeb5c2467a4699abdede78692ed05583b6e9430349f3164f1735c4c5be5cf3723aa8bb2ad95a9616b70c978ea95a755f9da42367acce80b56092adfab40b13441314aebc231c362cc3ed5156cd2e1fc7af9196e57d898f5f71a2f65f85d297980fc0ea5a2944ddf311c395b7607519aeb5137c71740970eb1d59614e18c697cdb9105d97d4f65849c160a8bd8a71b00d93df0e4e3cf26dee558138bb206aaad50e4c7e2d52e9e28b0583363e0817208016ab10916ce5e524a1f9e1c4007af05bf05c3836e71d7b757f8b455c990f69f1494acc49fbc97f624de8dd7063283437da736544b26ba8ceb6a11ccd2af5f58326254850aa4dd42b24d4a464f166132bdeba6d961da559f11c7401807023ccd1e3a01a4d2196e7a65a98b1c39e208e34c03ab938ec8c70322b7abe2f678ccc59710f7738821196b497074113bd4b070b988f1e17092b938c7c6b672fac0fecc58af751df16f2c80c69b1a04c9f028cce914bb4f782cebab7a6250fede534ce28a6539ce5e06f82edc22134acc68ff1d42b164615558f46df6cf29b508dcaf4883c4009d2ab8c380cb2b8800446e462d19e70e7b25c2887e1f731ef13edc5a067f11161d1267ce8a124d9ab53244e670197bb6d6ee12a16a8df85aa2d516954b6ec4d4707b97c21b7b04c440c7c7c0cb268a017e83c1f3bbf28fa85c82d5c05266f45d66e06227d8805f809afa0a7489e4f45e9ff7c27072a8139bf4457c49dfa190843c3f99bd182c1faafe6f5bb82f7bfb14fa2f3fa250eca9b87c2fae19dd54938dfc5d692c51980f68af06f584766da64db0c4cc533fd3dda7ba409a7a762d83033b4191cecf03dc7abcff32c10b9921031b816f022ed25034526b3341af1f6b4a945963d6a9b3a4186cb68f402eca52ad12083a4dadbed539426edd9043cc7f512f0b7ddf11985a2536f4e48f0892f28bb914e4556b28acda2e0cf691817e565505f910d3ff5bc24c5ca4954c364b916676f02c207c96f7bf0117bd01e672aa9f52839d01e374085f1e786db2b900c60a8605cdac9ab15b62a4dfddcd8227c054654f7405d68ebaaf1348ff65e48a68d162a8f96bac4b73455944ab706e8a3b1b5c5d3a5d4adef6301239e698f43fe6dc8d3deed12ee92276a3f16d82a2fc8e7e2f3516ba3b426add509b5761317d4990d574900369b20d5c7b1a8bd04e2c176f650e823f2aee8e074493b3db5bbd41e47a16a8f234a83d2b57329c4a3c3341819930b36cf62aa1160e45330f3a6f4efd2a2cdc43eb5c75bacc7719a7f1915637a65723b6dc6483d008c6c4852dacf35305af4c045db5091120811558898d99d3216cbd317e32491a34fcf6e83e906898e570e7f6eacd93a287f4a4e017e34b98f696307f4cf32b3238db28fe3070b855e0030a7410dfd89f6ed975a2c0b73c9eea33a107e1cf2e4dacb65382d2f5ef22579ff960b108ea02d73d825e8055cff68d2458e49c107b93f15fa86928e178e2e821e6b7177002180c313e300abc9503c87a44df4cf83c77deb2f3fbe7b3a912070e86284a8f2e2f6e90d34ae581419de7849fdfc4ad67bed630fe9fbbea54e2de7855568fecfcc62ce6c04cdc0b903a926c17b81f300f5153a682e1aaa76e95712c46a4a3c256444b5530e740f96744da4681e616ab76dee2f1009db034654979e96355fecbebaf4f2d0b99f679507840fa5e806f614d79a9960801820eeed7ca7a844d885986cbe7479e5e1268ccdfcf0c5417e8390a9ebb5728c529bc8b115de0dc97581160e954d3d35d21a0b536dcd2b9b16d877602707c6a124d16f2fc1cd3be40671402852aa92d0d51383388d4bee95c681104a97fc974abc8540eaabe6102471761a8e2c038ee0cde439811e821624cc048405312693fe8cfdea6e5fb5bfacde45a91f22fa01ca483f9f2f4595478ec715347d5a95d4006a37cd68f51c9818ecb1f2f1fccdafd73fd164aa47d131c93d8bd40888075e51418474767564435536cf50419969624f794d000c4ce016c92b2b239dc7c26d32b7d93139c7086bd399ae1d9c5d14328d55e1976c09934df0e67ffe322d411e665937fa7eccdda50ac72cfce545aa2d30b5aa24e88e3ea6e2504aa4cd2fc41e1a3baf54093102a691bb966e9a6ee774dfbaaeb3f8735a60fc3c01fabf0a97360b104660aae3d7d28ffd28201b92c754054a22320282117909e1b439c1575b32faea3202da76b23f6e05c8692c0615b93ff0015dfc80003e1ac7eb390dc618cbefa8aa3f018f5cd4669d8005a6b538018395235c3c5625fe8cf92454e0e5549b0b31cfd8787ac6c6cb6dd938deb5e76ab3e179b4dd20419641f4bec92f6e2727894a003346bf579b5157c759b8aa6be8ceafcc4b8246146794c6f894c6493ffc047bca42c07e72fdd06772e659e53643737209fe8db755aeb156e318ba02d0d8c2fb4ddfa0463292509b6db3850af3dce151ce1d835065db1c6fc4bfb017b66da6d4adf126cac72c958fe11b871f7d03dc66307b242681ce66da4912c5c46d86e2739b8fe242ed4072d74fa4bdedcc230b39148002e1d23212ded05cde58b7f9217f9d73aac58c17edee7fd209be75a08dfb88d92884fa0daef29d2c0da6ddbccdbd206160cb38f536e7238c746f734f8598a4ccc0658b15516213ef99613448067df76a5a26b27f6e378a3370d3243197790c6d4b62054f25e837bd2cbeb5064e1555fb58274e3ae344a553b222a8b0d92114b886c51b4f113803fcc4cd543efe927bfb6e2a1deb361428f29783897859cffa1279d5fe3bd91e7d7bc1436cfc5c5ba48db7a780fc0e4d0434768ebbb51cb87740385327c44ec299624a1875af25389332ad8eba4e27be6bbce606c9c60e0838878dc019fda1c76b118e908d88bad7112f9f45563303cbdbccd261c6987f7d95328cdf5d65aed8bd5a0b6e153ca136cc9c4c3f6a76e719535b0db65a8f808231e6b2a899c07b080c2536a47330414413d9e0e7c6cd60a6d6ad0c3703f0cdc7b75bbaddd08f1438236bccf9589808973ebde27b34f68a3e162a498c53eae094a0fbf50747a1180b032d5b9ab1a62bfdaf0d144bbf1f4adabe632845a271a19233ba9a7da11fc101390f1553a367201d94aa51cd4b74636718e8b730fc8baedc4434186a13458d19fa1147a0a55b02ed62376db0a2e5d03ee8fe3d254fbcc06e829306eb31528b2f25370b1cd27a1b326717d3c0445708859cead2594fb00d1e0679c03c30d18129262631bc547c508d0ac7de17a4ac342b24b0c1a5982a989e308c7d7fea555f3dbc59fcd1bcbf5d4c7b4e64c80d66b495fa997765ae28b1c91cab3da2a485b7398d06d87b35aafd53a827a1d020bcc4655f10de66afb4d6cc68706db669c85d967cc9a0bd3c77f1049be8db0ce6299d788a44271ac5f4ee83bceb76d2da902f4c268dbae0a6fd58a58d3f9fd5269f37bc00b30377aeda14ed4e9565f0b0ab9884cee7f90638a4ddc7a833c9feeb2ad8b8deecfe5cd29301fe0e86de3d64c85c7e54a37fa4712cae7066ff30c70a4c84986484ab019904501409c630482aeab5c7be9a631c0069b7d54ac740058ea914a745a5c934b8a4fbb0da8c00cae872b4e4c3e20d1bba99219ba9130e353b3c49373bcdc40ab77482682ee59b0dec09c3894f1d65775d3e263ee4a0ac9a527c36760524f36df0b07e2824c1d57ae87a79de729cfeee23868aa4071e2748d939293799b3340897a8de9f7c0e767bca45be0c583dafefc8a1f3494bf28d02fb73276298d04910dd10664c7d36f8e53fa4a5c98a4ed31984ab98d0eb0d7e6dd507d9fc1bc742383c29b926ba2047f1dc970213da1d821776b465f4d0f2b8025e48cb96484560a51b16a6b6be9cad53eb42bbf4cfc5ceb2e47682a8a3c1167e54cf0c32d90cc6a807d8ece7a4bbe57844b61ebad0b88ebd3a0a1bb741ef9f087a63a8111f1100cff5cff3174758932c03f7c0739b525e90bc104fc0880fdc859f8522d6033c3a0382d088277f832d93c5d8a5b2d4808e4821660112a8c5d38c6a53db42acff762a30f6b2471a0ae66058c09fd5d3f74b4fc6efba4e71247a983dc69c2a5a865b853e36cc1a730b5176f1fbc8c3d4d0ec05752d08d7c23488598b7e3d13298aa091f21a0fb76e488faf9bb9bb41ff78658310263fcbe3cce83f9366d28c417dddd03e5176899de5f65e9ddd7dd1583caadf2afb7a694019798360ed7aafbaaf84b2ae7853f9ac97674c2b1f4e1c85f94a2a22ea9ae234e9d995734cab845d972584cdc37c3d420e2ad9f8010443da2064ad08bcf7d624ee247ef3ded13283b815e3db8ed323b22bdc0caf2a287159312f4a12d8a7f4c615792f47362f38ce92f68f1d6b9414225f208027568a42e5f03aad607c581fc474f4cd5cd63c56733128d4a6f11453716acd23dfbb8a8d7075c32eae6c31a7723fadd6bc7d1d8188956791cd1f239a884c7871dd74b8e28eafd5f597175d93f3a872b0bb2a77833cbeddc09839fc24ab5fc3cc63e80287b4f1046f6edee0304dfee1b15e8b3aa8cf8149274dbdb158ae637c05ca9dea7d9478e5c0e2db6a3ebe0415098984633d5fcae4fac400abb201a7ee56c144f23509e05b743c1b193466d8c0004306070d1934386af8a8e15143c9081a088ce69750b967860b25034deee363e7cefe07d43ac6345aa103e9b6d14eebf4e14019d73726aa23c06b3e8199f5fe43d5fd3d12db837092cd7eac881693494a9a318ca0d75c80540e1b5045a028d715441c80fce39773ebf17e636cab9938094d4fad028363efbe60081070c7629c8cbee495b9e5e9121d2285c00a6668e931d462fab10ace40190eb741f8a026a92b4133b930b9b0a2f00c4cf2ef56f5d653b25d83e46dcf65e2dc0b6265f564ab9782892ae4cc3dbc8ab581e17eab98f907e6a0a07898c99f8ee91dc631de6625564c7c98671975e15981aef651166f6ad52539b1923f4a1c887765b3613c7e30b0b227eea0523fde4e7b0a6a6ec86902b28bfa85920746f420a5b87565bbce5a553be3d850a802a4a1a86e285641e998367f959ca25b714f725ba0fd1ac406509ce90cad5bab96765ec35414f04295f3bbf46c1f6ff2241ded123d05ffaf8e505357de453de8e6665f60258ffd3c412b55da9d175742c8f70bdaa966c36d72152b94d519cdaddad339f5e4a8ddeec44a428d75b53de830de6dd6620559c4adfb95553a6ee51f09c6950466c5b89ad46afd38d8a8f49a1d3757b5b22ce2e5cd6a968a7dfda79246615d8aefece5d7cc050912b4fe80ad2a5afe1a4ea7b06e95d7e923bac877855745b912a5c022fcc000121a389def253e93a9fee1fe91b00de2ca3015ac45508bf1202cb20647a2904c78a93dbc6511d6d1a8d928116697281ef466e78dd054dbb47322851d6f044d20434562cdd6576fc4eb7311fd356f3ff065736423cc07e7122b5174c26cbe821e3f6912c144185cd11806169454e727ec0b6cafa6a82265f3ae878005073d47c7125bd5452a4800f30fdf6a62d3770a77ad8cba4a0833fb9ef007a11083fd8396590e3e048e503a1684c2338f43d853794505acc87a7649bfc9c1f86be55342d15cb81358113ddc33fce1a0c559bf5f7e5729527c2c11f1f566c37b6ca145c0005874d40fc0d6da2a0e43c5e0f68d4c72ffbfe2e1cba178482cfecf314754d17cb6d3c0cedc92b4ccd3d5bce37e49aeb231eaf8fdd6a27f4a72653ba53d4f11b51e0e74714c59eaf7c21707d5e42e92333db72773131de5f3c88f5678286660c80214791ffcc658b27d55a4b70665dc1606059016c75d3135f07bf67d5a810b0f6a8c2b9a62b68530ca1a17f0d2a4658adf0447b420000ce3d9ae958e053bc06a0de4508b6eb53bd13d71f9663a546bf962bc602edbd7d8c1911225231a165430b022195af49269a9883439f85343e19a5179c5f2307660db740a94b416aa55ae65d57e092e0069888aef706c6e68c5080703568a9ccfd3bbfc5783b5957f4db6a9fc6bf3b6f2adcd9beab736d738e120a3b199d5c2055ca2fd6516eb6e6158c9982898cbdd1c7beae0968c799af0d9474e93dd0a612b50e865dc9e11efa7d907655cdfd38939e820071c74d041071ce4a0030f1c876040e6c17316b0f3118e48b6b34241cbe4849a4bbfc323e7e4d95ddd7f1709edb81b8080f0b274f5eb80a248f2c7e7b21a4724dcff3f1b9d265a70f7a36c43dc25b6726879132beb727a404764ff9080f53620005acc5a9ba8059994880376ccc425e4352cc9dbcd828d1368fa8cab9f49108c6a63b28be824fb960e3120919bd1c8867e3d8c2547f579d423aff7d3e35d25cb6f6262a8e031daddc9f1f9203915324c913082e258c646d895eaf3b504aa48f0244f32e97b105f9974c773affc4b639c57fe1cc65626ddf9d82ffb1ec657e67319588ed7eaa4b7ec7b182fc1cf396d6e62ab93de4416df7c211bd57114b612b083f62a63e7ac8f9e0a250dda2bcf73f3f6eaf395f6123183f692b1e6ae8f9e0a270dda2acfb379ebcb1dfccfe66d256286cd97250fdb2b271d5122dad7f95c7bf5bddafaf4147e674c567d3f6cab3ece98287c796baf7abfda7c29ad88caf395f6953beb7ed05e229af7d9bc5df5793e6baf3c8f9828fccf16b755f89fcddbaa8fb3595bf5713ed75e7d9ecddbaa8fb3d1f2c52dce3b6bcc89e4626e1d0f9f426f343285b79b707a5283ae36998b5e793362b33202a7c8c8c8180d6585959345a45a6ce67d40bcbcef1256cafb7cff14effbaef0be7779c1fb1e7dde7d6f72f77de9c1ddf7a8b2272a2fe93e673ff94d34f2c05377ddcb954ebd93fe01cf7dffc475e23cecccb9b08410c2c25e0f01fc7629ca458426344b08300465f78a15a5c3857fc57e2f1585d60370e3ec35ed17e93d828fbf79d172dced7f39e10de90df995c271c476936401a1d10382461f280dd1e5053448e14acb41e715684ccf6120fd7ecda14df8329aa9748fa530d50c705ecfe664a38a581ffa1b59ff79a4f1bf883461fecef0b62df7d288f91a27541092e44603da43222499f6d93e41b901cb1d1f4c992444a10efef3684abc40a9c38853ddff223d332e755d32cd9277dc38ee2888ef8856cce58b3bc28deb181e5b49a58e6ba60b3423689ca167d940bb8bf4cca9d475c748276740a87dfacc0cfa1152a05d4acbb97ce016417734d1de722bdadf95c3b3249a037ac514ea66a1b646271537d504d0a0c4b592feda9fefdd2fa0f1f8c48585761645961213bf1dae5e4634f1a7fc191e4e0bd2a5a40f3f64cfb261a1e22598d3eb344a5d5e3b27e5715c7fd7313005a1b4e75a2494ed3025907237b13c64297fc4db4e643e8f59da17e99613cdf290a57c916f39d15cc2635eee51a0a6ef4701fff7a06715c2593c06917e9d431c738a51f823a869ee5bf739b134355d6698ae6331973cd9b18e0293e1d97f2ce93245e3459292ea1b419ecaae3096bb2154e2dec3b1df86e9f02d1981e37dadbdb6c13e5451980dbc009c277add3a1f880e5f7658e7c0bf44849ea1a727c620859a60a2881d576c2959124b254c66d293d39070a873c510c1415f81886357f3e276ea30e6ea779713004fb7907463c5eed208b4f99511d395b60a7f3ccd4939c7fcf9618c8f7fee930429353d932cb7a3373dfc2b514bf9037bf057b096f207f6e0af600d658e3327a1118c535a2173c0c3b9a908aee2018832a602fb8a0f60cece05f6551fc09c91e565cc64f0bdda444df2c7dfc4658da5874c9047a56173fdac70b527de91a78796f321f56938672bd1c466a578b76f2039411fc9acf99d7f1073930a4ac51a8f4b1bea5b6765db0a3ba6c58b32aa067ad21ef90417877c2e38b577cd4d718f7c43cb633e1770a264a6f7e46e37c467edbd9f81b9b5f72330b5f67e0467ed7d7b53dea29f20291e8db1b6aeca83cac6814cd498e8ad0dc7bdacac336d4fb068f693b669f0a12408ea83beb904c1fb4c9aabc6de35d35645ec49bfbabb98d78e42eca3fe905e5ae89f33ddad9d9270b1555330c2f69ceb169b30b8766ea961046501bc22f008a80b5c7befd00ea0a9248421c957f253f60210223b79e978022076c81e65f92d94c8d3b84ea42c71ecde99216e18578e582e88fba143a55bc3fbb658415d8685fea5862d6c8f4581d52351f1de6a657423039b445758c0bef9b24003c6718c9af1e79dd6e47fef94eaa3393bdac7a54bb0005efab67bc99af94bcd563071338669d626a6fc99c604943fb8821e656a4d2f13dfdb4c9377918b3c35e59a5b4bd3d7707365a6aca9e9c126fe74364dbcdb9433d54d10cf377da6c1c9ee15a7e62972e27acc69327d4eb9de74824cadd3c7d34eb669776a7ae1893b254f330f3de54cd713bcf79ebe53f964f3ec53fbcdf7f2a4145f162b80ca364a5fb3e981fa780bca3675506d4f42f1a7156ae265a88cf7fb6b420051bf7344593827aa7daa286e8e8b9a9f312a8f53a3e0278efa717894f5fc516dce90e29f466ac251523967938273a2d4f749a5ac1c2cd538b71497f3a526a798cae19829d899a6be5c6dca2c56615a64cadcb7c8f652d4910e53adf3c2226aa9ed2986d7b1e4ae022bd52df94aaaa454499102c9b22865ddae989c8e809235d848d5011f56e16a55c7408a028a10db32a486b073f8730fd540466ce8444e2c69eb8d65eb1b5e7914c35a3634da4228d45a6cb43021f13d743e74e7d8d8ded40b04e38a722d641ca0e02795b032ac6ac63886ef786c008b54e5ff405152f8bb6550e5a9bf5b89a788b903d23eae2a8d68f404bdcf4fffc6a8951870297cefd82301f4466786477fde31891d7131d4c1c72e50d0750bf58d8fb29e8e633a6315c05152358b9426baa79693e2144e8e4c7ec33130e371b85ab7fa053b5723812e0dd73f179268dfcbc769a0bdfb4b6708ef1bd0dcea11d503dd8085b6befe558ca528def265a981da90393e6e010c79aa132a917e1bd4a9b7daa8e1eaa5ccf01703e812a2e836e4885512e24d7ecadc8d99348ed52686f7545dae1548bdd092eab66607880daeccd377d73376d27195cc82f7f823ad90c8197d2b4b20a645691737e2a5a59976b51bb03ead61a6ddc79d505dd204883ed9cb174232d826488066dbe0d2c668b54f618bd7aa005d097b9a84f14e5eff25b55091b08e07df0051354851a1c292f44b20536d3594bdc2cc0db99797e62fd4626139d8515e50e2b5bd492d92eacf09fab2e6362f1207ff918545a2fbf26c9d22c8cc77ed24716b7c33970cd4a4f22558a1a0616e15df2af1e252c249e850651848084b6806768bee2f70f572e8aaf74daf90c8be0dd817f8bfe8047d696aca18d1d00c5e2ee6b511fa9414ba4b3911de18811a2e81645ed76522eaa1c7a485bfa07f1b90fedbb7fd1bf3c5fdc8479395865c410823ab4937346257e9a4012478440942ce16f49f977bfe0c7d418629cd544e14d422b8cefd2c7b611f4aee95aaf0a8dd5ee2388b9835df25eb6a39944d4971fb1618e6d5381b56d3ef556b743bcad10724dd0233b9fd19143337f40db5ca1dc764bbe92da7a8e86042644c1d9da59c2343dc0b45a62e14974ee9ba1b509c4e869894f5ad5f7ae2f127294b0812cc94d925e3c5b8a842ceffd53a2e4790a702e0a92eb2ab65cb27def5fe60612884a127f255f358718d2d8cebaf6b02d4efe6bdb23e142b78702c5fd959dd190beb3c9ef5beef041e9cf3db1da6264a8950e696c3d37abb313808274dbbc58e079bc616d4f55fb48fb8c1b11e69457ad36ebe4347fc13c200ac43d10becc9e84d0ac20ea8ee3e437a75733785abbb90bd20229805388ba013da43c28c6b261a2f5158592712ea6e6826c5533160fd785b582d7050293f8847ed78054ccb6aa42988d892f67c42775ab750b4e8e4142b72440e0cc9ce72c62ceff1c4c112f8db96193c6f3a31a025af893886ece0975bf6b57348797ebfd6911807c3f7e2eb424675c63a54e70e544bc2111aca2263602dfb6d4f8e76231060cba5857837ee73f0feb3a5d640e94fc20d6e57494a16b691ce4e58e5177c31b81a80c515e2890d47d0c9f6559078c6d23e4f66ca58efa1150af45882b0a435d32d580a3f2c995a7af924f0dfd2f2a0c629dcdc04e1c19a7a6edafd7698fe2dfa81e8a6adea955ead9c71fae1fad72f7727754b10cf40cfa081ef1ced92742edad2bc0dc81da9899eae10428f7a23b6b17eb131c20fc5af2797807634b15d886f84af4e611157a29d5d307b33c2778c98291059240c5fbbde69d05ae1d0b5dba6827ed103223b3b19bed1e1f6299e0c3fd8788cfa34127f2f4c7fdd77ad62540b8a11ae679097f8a84a8048d8ecfc1f483a56ed0994064ae87d4fc0317c9fc398e3fdb420cafe2646df3308525fd1cec19c50c481a0ead63bbb91b71244c960ed08af56f0ecc73cb076faae830ab83aa070ee8b839201bfedcbe44fc32b36f30c13809b149d02d74f2c4f90cd2cf827144440967c7ea06c207761669dfe1dd391dbe93ab453880f35e408030289033f9e0ed0b8ac508ee16a82c0ead37afa1c71af7468c1fa7040730cfd8fe4fc2234e51d3a7df0414c04d32d53fc994c6849faed2a37ea783ca5f787f0b44419950783e9d8004ca61e0e350e522d4d9b7f68d23dcd6fd57262f0a234b642f321156906e7205940e06aff8283e435a56e5137835aac91e68615bd4104c1fe5c923da7c9ae9009230f71be0b73585c16430d149dce7cc9a5c2f4d78ac11bb21613f9a925ee9b32ab3953464c309bfcb5044c98f028db61f74d7d00281830cfd6268a294f2594ced3077d89f047addd1d8e3a6b00de931fd979d4e0faac6b607302ee883221083673c4188edce35386ac356c3d1b79895af8d4ba7ac9f7311e9791796155ebf06da9501f9351ffaf9928548ac036d1a2a77c49acd4f6fc450d3b1ad874715ede0b83291e9c857bf1be34c4d3e27fcf059dc009096f09d5e92d6286a08c7e3db304cd74e6a6f0e111f2f4c6f34441c0d7b2087b1a18345c22c46ec2bab4be56ce20bb3c51235f01f72cc52a0dbcb63b1449afc6b33a3b3184ac58e7c69f9767b817ca909c6d33ed641c7a5da5e15cceed0b99f0e42ab289975d1575c06e2bb05dc8018a0cf4812adf3870b60f365107b831130e7f9a33f236c2084e33fa64434ee352d642e9d845811605c356ba60312e8a8bab924d40c8b90329b8fbebe383f5f2edb7ce33be1c616ccb7a05595c90e61b9b3600ba92a4ef0a7c861cc22b79bd998da82ba694a66ed07cd5fa7f5248a8a977358d7338724c553d9a21f06dbbc1b18802ce96e0cec71e080b3611c19445489a1441b58e4ea4d357670206d08a1081fc4d100616896b28e30e3241938b8aaced9f20055e47df969b3b50f222010cc8e40a5367394930d4dedc6721e8c0fb6308779fe8055896d8bfaa18bd8afb5606fc127875444d6385000aad89932ab9073abb09e004c32e8bdaca44c32aac51348115c13233b65cbd532675acdec03b29262949ed80c358b76cc89b367f002a86257aeb2cb9066051157dcdc823bbd658146d25f522c6b9db5b7453ee20852416110272e67a199669b841647f2bb7ad301e074732625207992a3692da2b8aa049f5c5a2ed8163ae9940b8f14414f6b66c8f5a22a971034fa915eebd84d27a7fe9aeb6171beb8e2dff10d996e013628d824f411aeca28fe9952b82487793c5022664fbe5e1cf75cf016427e2dfd46a039d1d6db0635ff643a80db4c93826b61b987a94ed7d3116b34791bb206ee04abb0fd1158c2ec450613d9b8294471b28aaadf03bb77a29a0d77ebdfd7db1e99c6274cf14cf5c3031ae5be804e6c9064c4afda01ec6160d902582abe124b2aedb7e0cc0f073055fd5f1ce02da71abd660b8a688190e95895b73c233483923377d552f8dc8562da981b90ac28b1ede23b62262eab5497ea9aa63485231f661ccda3f342484d23a5b1c0c04ac91e509065073c44503db97d4be815947b58577880ccea991c0b72b87a18c89e0001c86f3c8102ab81a3f89c381a9d2452a4e354fb480ea00632127b41d1631c033cc19ed4fb6eb61766b2774435118ea161059f6981e8ac301b9706915b25e25620b65cdf3e30d2146000b2a1c185005257a14e71c0c595fe05443a5bd42af9ff020815c922f90cbc9b342afcf2208c99606f89dc0e41fb2f7f8c6f91ccb369ef267e93640c352694d4b001ead46cb8de83f8b4a0abb0db713acdf0c710c1ed45511e1fc8584ed6b8cb80a0122fd473fafcdd65cd810c88551f8a7641b593c144aff75aecd079111e92235b998d537fd635f0e30c678a239db2f092fe039607ae39cab0224f5e95b6bef81458f364eec7c3494df351d7b75e918aaf4d661b2f6cc3dba3fea0b1db95d50943a66a84792aaf05b347cc3a1176f723b48ea02c2cfa1f226193d50c86f9eea2850bd03357bb745df25a4e60ef13d05b3af1ed166f73e2127fc4d6857c0c9c38c70c14b9d9230f21a71d0594c136cff4f236d6a8a9833dbc9d639a133da635ca29a3c59e44e27e01b5b2acfb3efedea809ff2220f3867d0d14ac068940f94998cc30405f0d8c7a272d946859b30b51696b94543d6dcb8d3254910f6f8601b987d6dfb08921db950716c2be23f570b6624db09f3860e150b8eeaa0e3a292764460db134117df4701f4b4a4c3b1f4faef7030ac4148c2bc4261220e38679bc2ee96093af06b2780b66a2111a0557f74a95f074aba3c189c052d4f8dabf425a966116b8ae76ce0c4144bd5bbc424652e2db98fe712f652b86ce2e8566264b914f5f0d6adede5c6f17ae85eb59d2b3e0dfce3cd1c43821ab4d8a9d3d52590c6954042540c37078659b5ab1b91d72a122b224a5792757b8b59cd274c118735300760198b40344ea06ed1cabfbe62721018c7840e8a9d214c556adfa6282484115d1cf7911ceb7ec1d458c4010136d1d3918581021d7305d888495b8b5f0060a36b46b06f18999476d842a2a45a68a780b9f5e7a81be28613adc01edc030083377e6d006fc9bae82d203783809df41a30e0be95890f2e0459e607ae19b29e73117b2826e7475da6232c57924e1dcaaa491bf29bcfa37b9bc7585a2d1f6a7ff38d9852053c1085b5d918c07362ea08c42979b18924c3758973b3588c78e93e715b261a766fab2045d6c594dc3397489b6be70f6a430bbd3c08665e02d3f08dc2f1e05f2f2d7e47612b10bfa207dd6042fc9f0772821f8f4f91ba9e27ed8d58cd508b1ca91a6b95d63930c4ab2458960666610ee58823d8448d05feac44690f53107057dc1c7019cc55708fc7d179690c27e374b28757b4611c992373e4161cfdd3ec110989aa978cb0d9b1856c4b9ee2bdbf8a47fa332dabd1d631d507322792ae1ec150b3b1a326ceace2f6b6d192955bca14890f5f0faf0e1908e46a2524b7d61d783705dfad8e81ed6b9b4e1433f0d56c08f0fdaf5aa903393652d5fca6e05bb2e16553c0c08649d9764d770a4b34968d646b2ac9eb7bfd5b4b1aa8fd8f0fc796b4971c2e87e24153e002df3fd1e41049b5489885b16e861435ae9a64c913aeda047f8dab5a812f8b8d1ed68685d13c280a1470876f75426304614c81b9af442ccc05c18dbbfef9c86af775a326c0cbb9bd5693c206b047837b1bd883a4b005ae9f8d9fb007454107d8bba3ec1380bb78fd8cd8b8af9f111b490bd89274c0f5b3b94992d474240f8a02136c4921f66fc55dfc33225c29c7b316cf5afc2fc93291d94a06cfdf730b052854b822021ec509f62f0801b00741210cb87e59fd3677a9d67e2277f1ac3472177f1f78f6dd863d750144e614061498fb179bbdeb84b97b6d1427ee5f54b8efb81f71b71b5953b69dbac86161b8d30bf72a1df7234e0673183001bedf83fb1f6260ee88563fff846435ef9f11b7a6cbdebf0a63832bf538943b04cfb5e2ba01fb8baa3bca3ac1d93b010a9be609c0db7b7643569a59026adf91b21a4bea0a00ae6431a2da62b3d20c0540ed335b63495eed6fb6e42247aee74699268533f0fd7c802a550a51b07f2377e9ee97856a60eddbdc252be12d7b8fe3382ea5964699fd6c669a004b9d76436f3115a1eee50a55aba3aebed719d3e9c5c2885e7bed656cccf7daefb0a4b72dda3b09284992244944a131b0a6d528403295795cf4d0ec6bf73525e08748dcc9d4fdbdd68635913e8a1e9af62c9ab5df573ac244cde8b71a059030bed07a3c173f2a0e5724656142df918050f2047b517047ba980811ceea106902941cade44f8082b9cf9e3005f6ac107047e27095428a1c39aaa3bab725175a4d39ecbb4ea71c2177a9ee2eb673971a856732d58ed4e1ca558e7b1b26ee5dffa60fe08eb4614baa91b9189885a55bb126ef5458acc9472192073d0103b82385b003f12370d1e37b8ba9f8b497516987fd09805e46ca11bcd16fef81e03602734c2c0073ac697bd416c06cdb5456ac7b813dc8095b7cdc8f6ecac26c5f7814717b96edc1ed5536328200a1640738e8094bf0f6452c8c86b7afee627bb81f9150548cde1b8d3cf76cad6e6dcadf581a254dfb489554037b99b59e655a8a8b09cb7135cb6a96e23a82bff7beae4b19d9181961f4fb8c781530fa7dc523128dafa494ff48ee9846d7d1208d3ec5095160ee3b6e13893ed1e743f4df7bf51b7d1d9182f8fcb309e2da1df646fb3e85e4a3d17f3e443f7aefb3f9fe47244fdb44ee623ff4a1ae0c9111bcedb330c8c05e1d85118669ab5090c2957d56d7e071dadb9c1c20d69413d4c58f520ec7711cc72d0108d87a7709f6b411b743abc212acbd8aa6712f2fb5d4e3ce480174814fec3784c78d3822164673308a00d9a17d0faf1bd501cc5401da0fbd5745d5a6b89060c79ac67df6a60ac49aead358182bf29aa574325f7d8e942344d22ab8624fa08ab6823d880922c05ee800d8839650065cbf20970a5724e9441f57df5f73a117732bd6d4795eb394ef96e0025c3fcd5decb3881280bfcc1b7162906134e2ae185f6829db7b14284c1003dfc01ec4041968616300f0840b1ba3e2050e608461637278ff2a8685711c80f7af65fc0e9b0309b42dda0780c4625bb407800a49c6b6688f03a9c70773971fd6d4c39ab4a79179393d8bca6703b2a00b57cd320fa2a28a2758689afdfc3e01b527356bd2be6ada0359adb3a6244b1ce5dab78c386a7bed4998a33c0c32c8b0264739aa8ee1645893f6282488e13806c875aa69d0ac12acd52fb6b03138bc06562c544a350adba2bd56cb48d1aa12dba2a900653138bcf6558b167fb76e6d0c48a3d678efa2bfa16443c9d5b9c05a72d52658ab51b0d731b097dc0ccb24c58ac0e0d9578219d8a3e128ed2bea8b91ad36c55a5b9a490266ef5fdfb3c206b0931280eb9755326027d5c0f6dbdcc583c4f8023ba984b34f74efe552b4d2e72e181403be4fb800b2c00c5715036612536b3c28480c6c2f0eec414878823d6d34001a25a06d52c9a866d426dd65625bb21136d5264d00434c6a932355601797e1ecad1516c6fbcbc43e01858dc242b1305bb847aa64687199d429a6b02d59a605ce2a17d709ceb6b02d591538bb52dc92ab5a81331287ee553206765d1fb00725a10bd8eb46283240577da101dad16592c580a5ceb6644fa3eb5240f05b59f92f6d5db7e45efb843565f6078ebab884b20268ebd7d0ea7debe4da2f5290868c0c6b0a75f6094db34bb692cb2ec19919d88ccf87b5ef823d28480c414ab09775d60a2716662b55b7f7a6fcc0511aaef749c88e7ce0552430c162c057006fd5b617dbc27d259db8922909e0cd3e1c95cf469623e33a92c6fd0eebdd97934a37cac18d81fd1b821b036fdc18d8fe0f2428c1f68130010576592b2a1958b3d5643aa9745d44c1f647b57a66a158e14b0216d83feb03285430d1b44d73a980d6a469a5992420f7ddafb88b0bd5ea3b19b5d654810b6c314932d9c8bc7721c15e46b239df6d5f414ca3044bf1469a4d56a281815e195d0045efa2115d9a50c7dd4dbb1ff3691f4d193d7ed0ecc0c0091e8ccfc27c5ff532ee0f9a1d9a06e5761a80c205f6dc09bed8a351952004ecd51117be05ae160bdb72b729f056728db0135cf1c671a41f3840ac892bd5e05e2ba974255b39ed8e1c65b36a3deb464b3c0f63260bb05e2fd528a06ca0d65a336b339416c0ecaf353902b0071d810c5c7d34ca5e6468467e8fc0049c3de10850608f867d7bb31168612abe4798027b36b3f75a92d737c3511ebef656ebf7a6d8b7d61ec102a23178f7ede866f5c351e95c2c2b36dcc5fefd6e69260260f6da6f2a6fbf4e21450a008fc3bb8d09c0e7f02b028819c087de4d594c8d52adc2d50940f42e70a5b49243c9b39614f05d26ec32615b726bbac10480bf240b80920f8b554a456a1538945c2f2f26535df14a2e70460920f73b32aedbb48ca51bd95f791b37005140ed7f64aeae552455b1d8ba3360bb63db36d1cd44370cb1552465843060ab62431f7809324217b87e119ee06b0430b0fd6cceeaa0979d58a8c00467af02c49aec7b56d3ec0df9edb257c9fcfab5d6da2f828dec5a80c9cae8593e93bbd8cfbe1927429fe36119900bf45e44c402607dd70b77efbd3440ba181aeff299efb33fd599af94536fd8b7257797ef5d16bb4e28f7970433a594ece7583c13048edee565642f231cea3e86c6db67b161a21185aaa43ea164040445e7080c0de31b62c38014f83e06a4c0f66380ed91db7535c7c2b85e80a0e81c81a1f7beb800dbcae40a51aa0dd4192f137afb3d1c75abcb74cfbd0d1ffc07d87e764b39a600baeebd2cbf89a800dedfde454313c68e1e3234db56640a2ec7a6c2719c7398c32e1bb7eb2143a3694528c1c685adf6c379156b32d9787117fbdae7a5990a80d57fd3b0933e1f8e0ac2b1ca13aea6756fdfc6cbedb4bfde734b2d6bf24f39776f114480edd310c9aeb6e10d7b8f575971a7b130591140001a007b90176660ffec1377f187b245e1febd1dc8e22ef665645ca866923102783ff422734b334bc0ee2d0fb670177f97ccbdf712b1302e16495918d1fd5e7bb7590c586a6da51dd6b49518606b524a32598cfd4a2eb09b710238eab0e5c262e1aa69c86c4cca0acb4d1103dcfede92cccb8be7fadb43866674fff690a1b96574da8bccbd7607eee2dad5b0cd6e0f199a7b5b5ac0f6c90cc9c886bee04fb00785010bd83f1cd09a3cabf2ee62ff74b261c3b65893353912404d2bcd5000acbf75fe9aa6e5b0c19dbeee3592c99aba920f8b33fb334d006f87b92dcbb618d1b3bc268202b8bd56b2c1795d8cb8b05f58b0ba182e06eedec5c0f6b1c01fcef63ddd57ac55dcbd181bb6ae79be55cf52b812b8dd6b6d60eb5ddceec58649d3344d0a35e89450a40891224700eb773a334d80f7877ff52fa9c70efb2a31a1d30b87aa0258c49afc556472b0bcca4afd6cbacfb1046c8164195691c1f6fd498f5759913102b650c6c884946694809947a96e5376d850285499a4b218d15b286a93aebb1903b81ad16724d32545d95c547ac95aeccf44015ddddbd844d6a3984e644af4a20b6ca588c2f3191b24618a5a9a9100e8b866bf6d6e53b8528d1b249883f10e488e8d0991646c4b25bd64160bec7f7da60a276bc3512aee127a0f2505f07ef7ae95aef41e86fdc1175e68813dd7dca6b8903c6a0ae07dce7bb89265b2a4877b20943cc1fe0d01849227987b20943cc1f69f60fb2fdc7b1cc9d575df55331c5593e00433dcc57d58ec3aa9d020434cad090a8215d83ee8d9107b10108280bd6c048428b0e75eb599d79b9239763181ef690b6cff25f3285b1a3c7fc7f6078e1a821542195807ec4142e8027b99630f224214d8bb4480e262ebc44907be4966470e91946dc180eaadf1274da4a8e2d6d4af4fbab05fd8188f62c77094e35a7291950c5cad132860f52aac936d0864dc8c46b896ac0fdcc5335ccbb0315ee38ec1276f7ab1313589cc0e1b536bc01c22a9160c28c9125b995898265258184fe2c4c6b8164f6c8cdb986b6340306a141b536bfceb1816fbf602ca80414268823d480825a8a1fd8643f8fee93ecd0b135cdd9a3297c95afc35f77f0071548653f0fd2b8427f8be8a0d33e08b8d64679c61dfabdfd634fb0377f13a531d8aa80c6fc67fe60ad055bdc0620b2da2c8b2ecde2c7b9fc27f0606a0ab5681fda160b244c911a091168547c61851c2f8024a175c68a105e852c1ae32aa4b9458937fadb5d65a6b5df2843539c902b32647679c80332e1053447480fc70779fc90274d528b0bfd7941a3748702d81d6e49b0fc0c09babebb6dfb60d95841a462ab62bf8c12cabf7d6ccfd8a52aebb58951c2cd6c4a99056b49ad5c0f3ecafc99aeaca4885c5bb0d081218d7d0126af125391691ea19679c71c635fdc59e1dad581857f62ba823b86c84b66ddb4c18b4db08579696ca6525522664ea96e0fb372ad6844b3df6eb0f9a60172983e325b7a6528f8a35d9216c8f2dd518e2b7928a3579c965dfa7e28c74b3d24a2583177a2dc0e0a28a2566e0263e180377e13beca65d22dd97c3bd472388fd18706bb6176d9bae0b2214f23e2159cdf69e4dcefdd1a703662d766565f4f9b0118000dcc5bf4f88add93e64c4ada15171f67d37e017848abbf87f9f905ab3fd47c3888f91357d56435f4923928dfd1d5988e495445fe8b3f13eb726d1739f8da884ca824dcef6299f11b7a67b8ba9e84a4798a8e14a9eb5f84be0081335b784e432a159cd0ab5d2204314bcbd0a98b56c335600ed67392c4cbdf7d60ae22d478e26787b990d084cf076b361400adc7d28543ac204e7bff913306cb105f66874ffdde7c0f21ed344cd7d2039362600ff0250c404de5cdd8f6a18716b72f81a37197621a97847d6912ac679295f705772e5e04a7a6b52f98afdeb4a36ac49057c2fbb5b646690810b33b818037bdb7f868329f0c54f830c27266c48c0f7b71b14015792e605be1dae4d2c8c07e1800b7c516380b6deac7e0cc8ee27c4da6cb47d426acd7647dc679323811c9efb8cb83529ef790e39741f5505ee3e00071de6ee9f836e02770780836e0151936366fdd6684cf5cf32bf3447347fec345ffab5cf5000eecee2a0f7d867b8d23e3b3ff9bcb13af78d954992f946eccca76a24dddd0607dde4ee3f26c93ab58ff931745c65585eb9bb96b9fb75f791bb5b34356319c8699ea7cd0d6570e2f9932449b06737a4210acf9b29034d133a384f34079cbdeb4892244930e7c37125b46a5ba94788ed338f867f3d40b6cfd09eed2bbe5c09e54a6808dff3264992041bf101050fb427fbaafd0805412bf640fd5a82a2fe16f5fd2b52bf9e817d72c0b6b485ff0e9b51c12e59a26489132be08c19d400d6df8112ed953891a326fb2340db92edfd2bc26b24b0953a92ce25a26ddb7bfe15b17d563a82c4a3e1df11486ab8d212f7b523b6cf9efb7b9d5862fb5a73b9d2c6959c18d5dcdf61b9df616b3c8da4a4e3ec7b346a30404381bb134b645f6b6c1148b4cf484790d4645fe3df90514d4dfd6c72b2e748da6f25276a8dfd14d4af25146825276acd2de5a0be7faaca001a67d464b69403dfec4d813763c6cc193c2f7b2f23f5687f6d2cc915845672c748b23a84e7d792c84e491311b06fefbd59566beda99c910c87eebdf7b9df4277e36ef65df777fb7e642e2efbfa7fb3ec7af688abfe768ff85834fbeebbac3bc2752534fb51b93f72bbef6acf117cedfb6738f67beabbe6c4f35a6b9661ee3def47c55da99ee8f5b1bfbd4632b2827bb6775c4b468e1859c15b09cd7ed4fbb52b193982b952cfbdd1367f776cbf079e134edcaf6f494a965c616401b8be13b7748591056023fe0467b51ee1fd8c189ea6e33c92f53ceb59f7b61e2a44a5987d2a42a558f6f743d6befd72babf24257709d1d7ee8a484e2ca026fb1049c9925a93bd130ba8b95f6b8db51ae791bc66445232fa255f137a8ea444f44e7c4de8aba894a4947da89424fbd0874a4a967c8df7f67300e891966022fb512949f6f6339d2fc7fe0e1b222da935a1ef484b6a4df722921227165013fa25b546f49e25797fbf1a0cb8effd122225dc775e69892b74445f7f89508d28d4919cb8c2c802f0f6b566860ca0113f036fa51e2a62f6a988ddbf39f6eb578301d9d7ff72b2b7766be27559cc91234cd8cf9e89faf78f5ca1c3bde88f2859f2359ace262a1d71e243a5255f5399d8be2b2df99aecb912135b7dad24017f26b65a7a3554ab2249a8fcfd6bacea7b7d57f16a14a95fbf46125525ab1cf7691e977d9d68341289bebe9294a7f1fe2c5fe8238d6e44a5ee82ee6261007a12b00791a105b8fe153da2e79e06c989afb94274237aaed485b2eefb46a2cd0b79a2500a19d480bd9451b537cb526a5244ddc87228a8da83157454194c70399c2e0a2005b62cb359b66d77b489ea4603bc56d47d3eb61789ba0fe77ef65cb76d3eb22dab9f65b5da2c23c271a6c9c053a9516ba6c2dd6caba25a4559addbdfea2ea16a7770bbcf2600d883c80045e7d7b5ab71f509606647b0823d680c690885eedd425cc77599d684e796054a7def926a4af7d9a76435256bc93aa091259daca9964a1d5093ce0cce0c33cc10ddd748da8b3cbb59cefa13912d592580d6ee48652058ea4cf805975e42008aee8eebf2274f34ade4caf16445bb9a7dc2c2886e10a36d9ee8bb98d15fef3dfbd900e9712b1617dcd1e307901c9ded8955c3f53c5407425ec935c2f7be67e33d11f290e755ef43a5276c6e070616431438e543f70bc9dc670218fa1a9221222323e3994000be4be6be4c16c372ef874aae5393d092fba19ac5fd6c429e0dd31d6560fdedbe477a1c7a1b566cf0de06926721cf5abc92abcbbc2ca695b5dc0f3d0d92672da192eba694ba6f6559c9ab4b42af918290b1a65bef6b5a745db76ddb738f047b24178abd948fe4ea70c843823d5208a4d9614df707d08ec10bec9fd170ad6017690367efd684e32515fbc44a35756080feee95502100ef6744b21d39341074fbc47dbb4423e558e93a17e82bb8fe00fad7cf4aa6322850f1c8c628b962cbbce66eaf915c23b140017475b866594601afabb13d0d96ad86b55bb6655de78946a41a43742ffa8ec551a1d7aef54a1d4e57e24a282ac03bb259c97a35eb4106daf02ad6d465382b8dbadf4a60f635dbde6adc5672759946b2d8da30780e95d0fb835d88c4d5d80895b28ecb36cfb25288c4d5d4aac2848a2c0c58e01cd883c290a46aef65f53ffb5ab2c18d3aafde4386e6de120ef7fe95c6860d6bb235082cd9f8c15d6c577bc8d0580e67fbda954e57e684edc9c2d4ecad8d6e04620f0a0313b4520e6b7a3989003c9964685468600f0a4317981b0384d259e1b766f77aad4bf06c10ae6ddb968532adfb02179ab66ddced6e96f1c013804fc5211f8b43ef6e837def8eb4efbd501966886c8d7fe785344e88d1e83d9157eb683402494ac01bded36eb8817485371a8160ca6703a9d680de7799e8c3d9defbefb3118d384ee3b41197c2655fb592fb29e3461af7899e06e90a4fcbb2946ea469ff799ff69e86436fe4c3e9ec674526a851b22aaa5b16da4695ab238f747a3714d246de1502090e953c8ddb3e9cacc465dc7b36aa598823799f653614d23651e823c27128f4daa892be30859732aadd969262bb2d9ce77db4fbb49aad23dde02e76cb3c6dd45918fb848e53f96c669860593e6bb19f421a959c5047a4ace623add816fb9b4a1344a31ab56a2392ade94877eb3251d77d680b75af7d67f1ddeacdfe765acab6850c54e9468eba1c0bbc8c2ff0cd6a965d9be2eed27dfd70eea671da07c4bbd005dfb27794e5826c9f6d25ff669800d64783c702e6b030ae510ab6efaa81fd0369bc0d328ebae1fd05e033a37ac386bc95519dd9e14f2e0e5b681b653765945d2ecb3e0f1c8554445f4608b077c3288483c886918854b3910d9f0feebb8a4324237e860d0e24d777038e3c1c482c758684c31722dd2ccbbcdf6157469f4df7a085f14a387c37d9df1b4224100bd0e50589818a2ccb3c95518884a202a4c11ee40528604f65543f21bc0b382b8dbc1c465988248a59e9c102aac4382a7bfb32341609ceb6fbd918c970e86f4071251f8bb392111b48aed1dfef4ade337ad17fdf105be98a7ef4dd8c5e54ea6880a31491c81b8db66f1b7ddb2825b3d5c887d3e1d0a78c687ce086382fdb4224eddefb24d416601070e86fb8a3cc065cc7719d4ae6a830c0ee5da6205d0832968dabf7b3d14a364ea4176bb21a9769d79a3e9becb3923b01ccde0402d09583c63a0bf6202f94007363588e74bb473351966ddde783ebb8cfec6b8fca01f8610ff2c20d3ccb326b53b633461af6be7bbf86a6751e69cbba6ef3bcff6a0cb1bdf79b10d6c2b05893e6f6adb5341c25721206feb00d69281c5c15549b695c271a6d02e0382eeb29f5641ffaabddaef37c68a2ec765a58f11b53edf6d774fa0c54791b5a005d235085e56eda1d03ce30145ead234d4546335993a6695d30036b386f4d5a8d02e862c1dabf8d8ccb7e04a50b0100800a0ed706ee7a34ae85a975bbdcd7a8550371d6adb8385ccfecd15ab5bafdf6f9b8cfe16bc4cfa85dc9261b42fbab6ddaad25166bca0680dd72ef0f56d75602ade939165b7bb8df9c78813f9c2c5bc101e8bab75a479186d8ea2d75efb942efd510bd3f381afd0eabfd0c1266a064a39923cc18411bcd1461c60b2e344384d008b430aed1873e5c4b3ad67445a399217821f0bd94d18c1068805ecb7dff7270018ab007754109ce31d305f8bd0ddc67130470060837382a87181b68ac0da41eb6e5e690f90118c2210717a0863d880b65e0cf072aa3991e7c0018cdf080c6cc131b7218ddc0fe9d7685f67e472e3ec3e237ee0d7fcae137eefb0d34b06731476e98d9418dd18c0e726019cde400fc044000f05d39300bce01a508cb7b57c01a4984b5efe67e9f7d36415c888235d286b52fc8fd9e009f8d917ac6cc16e0f7d686008cb4b7017b50173280bd1c46a10300c06a1d77b39494ee35128bbbd4ef97b8e16df8fae9dc50ba62f436bc8e0da42e6ba9a36c24002dfb2cf755d3ba60025c3d6df4d9bb58f07d1bae1c407248d123c751d9c55c7082efff4b110b43430cd5da141f50871b691a57537e74bdf74f65ebd15e948239ad0b33c09e36d2bcb004d7eeb51785bed7fefbef3bade41afdf71f8df7388ea3e17d67c4cfa83144e8b30f7d96bd6befad5853a874bb5217da58b07ff705a15d020801b4cf75d97be07d2fdb6c96a568374bd94aa04711011796d8b0918daef561647a792d5b62fb6e2b5d91bd672dfed9e7a3e23b44f6b744c5160401f0bb8bf6333800351d9eb5d42bb2df4a1918643cb10531b0df50aa4a6a121880334e665c00059eb1c20a70e603a04b65d4793335007d04fa20480b496eb6fdf71ae9fb192c80ae179743013febbeeb3a215c0d58721a3f8034defb1f40ed35222f3245b6e005ce5e2747b6626168945c23ac7df62a6e036b2311a92371a5eb8e6f93a02c9411940529600fc282179806f6a02c40c11e94852eb00765418b2c38c123ec41599802dc02bb3a2c60815d236caa5360970d6c47805d239c7d556902ba6cb854fe5536920a091cb96e1016a0c0aed119a007614149d015cec0ae11e6b0075dc10c5c3f9b620b5fd9364ddbb4d0428b2cb0c8420b2adc7bb57baf76ef038a3c20c5c5bd57bbf76af75e1b444513fbf785076b735c5275b7d7079edb00037b7534d242054b8252c0b96cf84b728df0750b037e4a7643165a377aaf23996a169d0d1b48a70fbdcbc60fe07d57a612a291f291b8ec4716c6fe88048e665a007a558b51cd22f45b56b3b0f60730c4d52558cbc2354d8bfba2842bfa10e9845da1d7de03a0eb8e5e54ad177ab130d987429e47b9de0781048742dc77a8d57e476682ae2bdd0d80ae8bed4ae67a9cd951c7438e2c0ba27e0809e648dc86daccbf709d05a00d07584118a52ad49a8d9c54eb5f7ddb62f1cc0c40d705f239bce4eab08c674e649af59aa5dc5bdab21157faae25418e1c3dacc9f6b03d7a581810dce1add0b8b49771e5b81757973fd9f18474b2a67b3b1980dadffad96433518055d3c2bd5dbd36cbeefd1d59771fe505584dd6f3b292e3ec0b22cabd9e15b4c0a8b5f7da0f8877019f6a56f2e9461ca8624dd605825987b7cd07876fc9a7c3f7b57befb57747862242d7b1c0cbc0d1bbeccc4abd615dfb07bb904001acb85b29ad886aadd52b9ddc857bfb04c01cc9e5826d0887fef319957ac37e28f42347751f0ad519967ac36e2a366cd775dd0d4273d170573ab98b7dae7403dbdf58fe85079edbb82496952aa8a8642a2a9674f1f617bb87c17b1979c975046f232980f50b8274c5f6b5d61ab2ef52c196238118bca2be135f237a119158ac0f967baea482b7992f40ad74ef04666070e4068d810c7bbb977bea60f0016c7f24d61e54500ab05637a23ec09b02acef1af90066aab859a948cb5115fb6882ec71a9877f215a93bb8ca03ae6e155ef01f62030a680bd3a02a9e005b6af820210853d080c2ab06b558aed35d24b8ecb6ddb2d225a93ff4b0c3c6b035f6a1fad7b46f257236a02699e726ca1fa65eed5a3a9eaff946a496289534b8b49d468999a3c48129b44723ce2511b023d9020adb48fe9b52292fa47edfcfb774e77fa214ca3fb3fffcea5f9da1c4f8dea573e336ca73453af4b53fc3d9ea586c172ebd4baa513a676525a2596599f5fc262e8b358a3f87aa71fcbaf9065a27b2483842971dcd95ab376447d9ab154154b6b527fda30b3f5b1338fa27eedfc24a97f1ee76f7ca84a7f3caaf7c6bfc7d7f954aac524c4443f2584cc2b13080aa561319dd4bbc062e8cece696ead352c86a2e36a2461407a0707816001100e0042081a333cd4e7b8b5b855e97e9e32b756417810f95899cfcca3cfdfe9c74e6d9642686666aa1084833351e42f754f467f6b7d2ad3b4b5c7df5ab376d82114b3467739eeec883a85d2274c8bbfc71d7600514aa080b0c20f18707792833f903f04408607a0cc0a86c8b8bbe338181383023818d381189a70b7c44c6f9678081eb2ffb58ff93abd740bfd17cbbc75d8a389febf899667aa7ab41c5f6fa23f7e7ef1cc3fa7f92cb3e419f5a97dccfd26ca429928fa5a15cbaf57dea1f639f5d6e79fe6893c47dd424fcd7277221c84f1818b83301f80d9e1eea12655798fe29b284f398ae6aa4cbd4bd852fe98654f99c2f46a95339a5b26cdca7a880f39f00104ee7e84833eecf00100399eb887a26ea137744be727b77e3e66a2a286c14efdb3ca405a9766acc4a539a6e2a97d4c94a5c934afb4ea7f8fa286c1f289eed798491e600f52e8010c771fe2600f13e8a1a70700b87b021ce4c10bee5e84833c88808709f0e002e210c2411c22c0c1017737c2411c34ee4ec4c11731dc5dc7c117262f4042bd736b75a6b0203c889c62657ed6f8a777d1a8f9d2a74bb8b566fd4ba3a38996a34b8695da25e4a1877cb2cc7ffca854eccce36a64e952ab52ef122221967a27d11286a6ff530e12a9d7aad5088ba14f92e3111f6e1448a3a5b9eaf1a814bab5c8538e62997ff229b24c585e853d7b3c1fcd1b2df526c7cc3a95798f2cf353a90c7b137dfd26fab0f44fa99746c79d1dad59a967997f9ae84afb7c6aa7b498b538eed2fcd7da4748e695b933a975c01b4c006f9ce006076eecf07007e14104dd1acde46b05947a9750d4aaf15c6d2d3e4f396a152a957a9730080f222d9ed43c576399be5ee6aa1cd1adc5cf2469a24036ee9ec3c1700bee1ee36088458845887aa85fe94ee94d6656ea4fa289a252a21653ef1296e34bc45fe69d0679542af52eee1e9e66101e444a0ddbe97e32ab4c9247ef32d543746ca01ce44f2d323ce048ffc4c344b3d246885a2c53b3669ffa95eed25cc9f080233d75f9639eba676592a71675b4c8a47f92494d31d6889a25699a2aed33a2abbcb3473435f56b4475d0e09c3b3b5a15cbaf53ab5e29116816a23710511b6171b8bfb8db06b8389a79469f5c75fed1a5f6822544a713103a80f816207134a12c0d0485425b3ca3901307656920ffff22083c9038ee681e51eff4acf2897e6b85e6171096adc6368202103a589ad4c20082e65f015f6a72674724cdac0c1beed70b0770bf30e06ea05b7c2080f81653a9c970756ed5cbeb3080bba600201c6c79c2ddb568968fd2a2b96aadb23ecbf4457d6ab4d48f2a6700031ceff24000f1ad50f388da82c004a56c80ce0d0f9c83793ccd0389e3a376767718f76ac4b4639f61ec444b7d03965f37b43e51d58d5d9a37604418b107fdc30f3ec0e0f8e105078ba58a117dc091330faaacfae1e505c6070de3c30f2f2faa1f6eacd09d9e37dcb3ce45c27adc9d848324840138b4eb8e96da471c4d234e4d9299070e49661e08380098002615003f0a60029a48809104ec8009382201428009980113e083bf56447269eeac8588a4f9c3dd15e02002ca700d333fb583a6b05411ee2ec4410478c07569ee11157599fec9070a05224088bbb73888801677519f66c933fe1ec98c66d69766797a7d7e4cccfa24f3eb9739648532c574eb573e591b3692ac1dedb373eee8335de95d8e30156c67efe433cd2890dec9679a5f2ba09d9d9467dca698ee1dd84ba33b360436923eb4cfb8b72e5fa6586621b05746b77e8d3a26abbcc9d97a556632d7e0d2d4434e339f2946816cf29962d86b45e4b52292f35a11e1a179f2de3a480c1dc9112d8267dc234aa6414c311dd2c48d7de3c64ec9f495ae6ef488db0535c5dc439ab01bdb84e9f346cf69fe34e1ee1170f724489870f7258eb83b0494e068187977af20e904926a2471af4bf042104cb0c1cf0fd0e0ee968a0508a174829e2c5aee6e552310e617aad0012db87bd6009810172841e58c30b8fbad02052cc8c101075dc4b87b5d000790c0615201126ce1eef5025b3040cba9d1b8c0dd2d109b0558e1023a5ca00cee9e01400350ba0082265b04b9fb26020f9851bf40ad6187bb5b31c6b081236900411562dc5d1b418a0b418b082e29b87bd5df104e1480910326b87bfd42c5c30f8a60c00814dc4587a861b0f14437eab5f30fcd8eb93257e6b9b3f399e63048984a99289a775e2c47d69be82791da3b28148bd4435248bcde457c789a3058ba1fd5a1dce3a75219d52f7d9a3c4274abd2211f3bb58f7e34b752fa34798ca116cdd76b9ff1cc8f8ee5cdeb305d69209b70b7d011864932f3085fbfcc94d63e4c9d2352290c4db56691645e852992cc3c529af5a7bd33b9daa318cb39a4d6ac1d13dd415b3ca3fed9d19a556a12054a4718d6abd2242234d19d3025dee05569963a089355def0307776c2d364fdead4a94c92e6ea33bad22469f2f81186871421b2cc5716359acf14cd7be431c99e55567d7e911cd372fc53c37eff9824994fe869b6b616f3eb4bad558fea586e8959aff43e954a7f8e64caa3cf7c66d8feb9c9c16726d3d5889e1926ead798c9552c3f9adf4463ba85fefc4d0e2e4d58ba53e655c822f546c7dc425f9fe6ebf7989fa734c9df279afa58fe2173ecd4a911fdf37a9bad9f3f75ebe74f29343f10407cea431d8e7f2af58b47ef2f53dd3ae2c3add3bdc71747d32797baf5f35bef7435f298245a6a748fbb3457a849ee53867d2c93da65e7d7a51923d152aff4f9e8365fe32bdd3bff492c350aa4338f267f9fba85ead611a14e756a84a71c4fcd3a35cad2a94e19a0236a1e9eac93dad1680e4f2d9ee66b5235ee6dc23e56e651ab1e6df18cafdffa35a2af49d88892e90bf65af5b1fc2262e7df6369c2762a85ee72cc3cf9f7d6256b3cb5cf9be8eb33ddaf7bf20b4d4d55fe4d8e19d5e29767d6e49be893a609fb1ed3678f2d9d0f77994ff4b511dfdab9b50384ead5999adb445fb9dc096328eca57f8f6736cb67dd7c122914ead429247e3c756a44b7505295c931fbe47d9a2d54bf3e95fa72fc32af7cc65dea96d6e7ea4d54b7d01618991e6256acd3f4a2e639f52bb7f6af94185f26bad395a8c5529f799f637689e99e6f1135ba7539a2a5464d9829ffd67b3c612f73d5d25aa1196662993b957a516f6d8aad55ba9f35a2af5cfe698f3fa76ea1381fde7cb84a4f74ef942e4d2252bfc74f89632a258ea9b11c5d50724c55e6d6274c9fe2a8d18cee1db3fcd316493de62fc78ceef4a551b37cbdb32673feb4c9319baf514dc25ea7f9e84a9fa7c932d18da6b017cb4c92296b3cf5d6e2efb185fe49d43bab5c6c8260213e3e3fcb7cbdf3eae6c38d92696669f1636546cdf25526a97a2270860891e21959a5c9230821a9ffd2dcae1186f399e2309f697ed8d8daa7b9b75ee9f2345b689a775093dca156ed71eb52f33c9a7f8fa5f9a718c9e3c37ca6f84f9375a6e2a326b943911c53550c1dc95ca6ac17f539a646f4a9c5d1c73c61232c7fead42239a6353d2b93ac49bd6ee9ecf4ac746ba5cffc1bcd2df47b56bac5e37768a21f3bb3cf93e4f8b375ab1c77b4122399cb9115a2a53ecf74d5da6339fad8899130580e51b3fcd3dca3a8c53dfe1e776b35b67e5ebfcc159a9a29b92ac72f738c84c1f0afc65d8e270aa44718de3cc25d9a23bacaa746cbf1d3d325768a6fa22fea9dfe4d0e7eddd2d941354fb847dd42b54f6e9de69f62aa9b0f511dcaad4df1d1519726116299750b3db558a6bfd13d02e9678d9f6a69d12193d2acb41126fd3287987a7052e5183b75ca808fe99ebdf5298a394c22a54573b5938ef979caf1d1d4d4a2984d1256c4bff6588eaf53a35a0c53498c48a47e7439a265467779f3289977463349e65598448a24f36a479f598542a19a24730e0a9542e2b51ef221baca275a9aabfc26fa68999aab557e518fac71a561fbf3bfcc93f52499579fff759aac53e77c46b3b883a6b07244c76dc2b4b8a379f269a21b1d5f23b9b3330fbab5588e3ce3698e307c044e38c2f29fbae7347f76582c33fc9e9549aa4e93f53d3ba35f8eb9b57261b14cf4cce8903fb598756bc7f410e108cb433ed4b018fa31ddf30af89f7cee91ecb1b3c313ae465295c25ed4a2b92af5db00c13c86bca8d15c6a34af4a73b5857cc8538e27ba3f25c342d3d47f7ead7a13fd2d6a5dba875b8fe848e6f2d428907efd1ad1323d3f8f3e2fea6dc280f4ebd344d12f47519f26ba754be74351ebfda5f619795eb776fa3192cca539a230f35be8f8f33ba67bbe34c7bdf57e96f9a8de9f5fa3f9d4a50ee245adf712a8d983a71cc9319f3a7b75e2164f6a9636a849440be5293590180a7bd9b83b0b99537495458dae340cc8061d79c61e323ce0d03bd7f08c35a6a9b33ab1bbd7b8ab338b23997dca9bd589c328b422685bb8b7984e3db246b4d4e20dbad22e154e15eebee3a006c45f03e844fd3a4d16995fdfe30687c6530ede28f619eed5997d087f085f5cc4d174417769ae42eebedd1d09072f8e7d86aa91444f5395c17bdddd3a78070054e4a5c8fddc8ba045ce2265915249e50e00f71bf76bc3cdb21aee8ec30deea0bbd370f7141fb9c8dd43fb0c7384385cb6466315e6b95725ee9e8483968916cd95165f421fc21717191fb6ea060bc7cb8b0f38b24ac5030f620c0e168c8b39865ba3f95c85b113dd238f3e6f983c675e8537ca3ca23babf4bea15f66eb864d393a92b0fd2934a702e06005c3dd6f70d0e67027b38ff9d22758bb6033775771b07ac11d08202d96e3a97739b6fc1e4d5f6af2695eab5e2453b3b5bfc5dd7970af2958ad702f63fb867b7571f71c1cac4a7c9fe1eaec744a669f4f9da74deacbfca5f9a916132c9f3f658a42a164bab590d48b9a24dfddc6dc7dc5c1fafb0cd1178b73f77a9ae7a9bfcc2feaf24c517da2a57e6912f61a1f1df3893e4f39a2687e9d26eb730a3c5f8e1f3349d80ea17843d43c676ea57e8750ffce3ca9dfe14797a9df611f2034d39529befed84af388655af3611229057c12a9fcca2d9e723c4fcdca812a07e0163ed842898737ab3dbe76fe7951c74c12a6c5df5bdcc0411470e0040e5edc345b9fd2a438ee94668a279fda4793e626b31e5b3f64ca8291bab5f39fc4735c95d947cc6faa461ee1866974a7e7defae4314fd89763be01941b7ce006363630c3c3986a34fd49e6986a85c39db26c2085bbbb4b397e99779a448a35f6d0820b2d4e2d0a500332d4a08a1a10a981954113b248421647b2d0810661a0811168d0040d8ea0c186850eb09080873bf3fca94b718f224f399eb4486a9f710365520be129479d9ee82b8b7a7c9d1a66eedf5b9b24eca553542724f346c71055a5a6f8e5f8acd1fc0fd111cd3c9adc63fe492225963628540a09531228d43e228544288a651e75a949963e5f3d5e7bdcd1a183a71c759c5a877e9941342ca663d3daf9870e1de269ae34cd6aefeccca38346dcd99947c801785295165b3bffd0a2c963a5816cc491a71c4992cc3c78ca5106ba34f5cbdc325889c1185e6a1c032ddc539e1f5dc6a0e5ae7a548772fc199d18bc3829c343275598257692c4c3d37c1e749ce48419cd4e4e261130780203261eee167d9a2fd3c7ca0c0399fc83c1178c3133be80c96a8f382f20429299c70b0ce04efe68d69b26aa43870e1d9ad3f46145142b7660c509ac10c20a01b8808b50c4ef529a7fe229471e2e20400bbcd00218b420d58291873c5e2cb3034c38e1de7a659eb0d768868dab53933ce5b83fe77fddb000acc207553069a182c60ab658c109c01578600547aca0a48230a8c0052a70800abc29c098828b293030854c0aa89082285250440a7a40c11a50d00214e8a0e0871364e104509c8002279091820b52f0400a094811bafbeff0af80d73bd7b04ccd1ac9dfe8f859f55a8971bf4e5f1adda821ef12ba8468a97dc2f4f538703c0ae7c64dcb9057c00fe13149134ecaf4e8a95bab33ebfd4334e902e400079870521f43472096998027b30933cf214039c82afc21a9d7a76ea1a6ea4fa7bd33cc257429cd22de254cb528e01df00af821a9d3789ae33e95268ed4c7c8f1454d669f3135924f3b3a85c648921ccb22c4329bfe94d22f73486a64dd68550a0df2a1365b3fdf62fabd595a5592a45e95a7b947f4e6c3d469a2abec63a7764ac2fea477ae493d2a3c535b8fa7b993c2f12e9f7a96995923bac7fc3a30997dcc1306cb3a68d0723461fa35ea94baf5739a263a64a73b5a9fac9779b24c90e3aed2a2164db092ba29c19351d4e7ea4fa9d4c754ffa35302a0b0e534479fdcd2aa3dbe4a905302135a822e24c118a1a87f720b258113122021c1de26f9685a9e6cd054f5236a12805178e16214128822e539f393b91c7d94e64aef738c021cc1137d8ea61fc112f7108f80c8084077d727cbf4622a82324251f7ac7e8688c0898b2089a3e5f812c18b872d3bff88e0e74608c0304fad4446490d86a00a177dc26adc7d8783214869718fa2f90ac13b99d1b14919ee61ca87125a9fac264f5a3c63eb4d1335a249121e9f2644dcc326a07b98d2a143c3c241cb3c9ed90891345b20e802041bf030b581729014115a9fac9d1f5deaa0596923324a6ab1075aea57698e2894ce07b2f880ea03ef012678a0c92a15f5599ea92a75d2a46acce5f85b2c7bf24bbf76ca3355ed7c7ef3f7f8b0f44c6b3c50030518a020011431288a40b1236c29cfb4b57a96f9a85992af8f30bdf982e3d19435fa8cf9c76c1501c5a803513cd4c1c111a257aa5c04d8812b3a50766087bbcd1f204c6594f4193fc754b19c9fcca889be6e8998035f7040041c688203a703902fb41586a8d48c21e0871fc69e5312480ce140b70127ee1ea2a7dfd9c6c10df0b0818d490f98a44c7678789aa71f93d4aadfe3eb70a67ca45a68d6e2ce8fa9532323a9811268e04706c6900113b8bbc9c10cfc6420880cc460e00a18d00006629e980276f00929747aa2a68769ddf31a2df399539e9d35f9686e31e5d59f766ea5ac27c94c9279279535699aaac78f7209c37085ea3fedd33e75accc31154c9fb0d48c9dc69ecfa7569d5ab4cf48e61d98d63d29d36f51f7a0b985ee6852953fafd0523f51e4091c610a35cd33f57bfc53bce9599940c4f1144bad8479b2364f267de41305b2d93c9964697db22e6003181ca98ead430364d6ecbcd246801640820598b0404b05a0508125291ecfba792de6d72925ea9bd60acd3529dd42cbfc279d0fd1fd4a57e7b87a92cc3d381520a2022c38f292d412052c19390a4b4f5487d2fcd9a9b288d0051458820240c21dd43485844e38712275e227103401084c0067029c122f421e2d3c4c38ef12b6a476ae41a150a85486c554bff7d8d2317dc8538e686aa2a679fe1e5937618b698b3af528b4cca87ed42c53ef02a483a848d23c49b3f5f3d22df465a29965aa94e8a0a493001612282201af89309aa0401339614a95ee1d51a778c0b1434e0ac78e489aadadcf16bab3d396ed528e27baf58996f9273563ab3cc680cc1396fad48cf194634ecdd8b36e3e24c9bcd2a549e61cbe62a529a67ac35ed462d984494804cc1089884015ee5b07747c73ff49fb8ca4de1fd343b8fb8a831158124620678fe3cadc9b0896699eb024604812459256121292313cdce64aabd08cc3d48ee99e214832921b90684c4461e209267c5822ca124e9660c24351038dac548b698be34e4cf7a0503ba68740a1745222fe70b3ccf1532d384c38a97789a123108f3fc001c296d6cee836b59865d62fd3f7b8f9d3cca3b9d22a8d02e9921cd1327d74a5592cbd4d42c8ac133b4d348b657e99acf266890e96f53986fb9127254e939d7ff01198bbe32339eea814780443800b9e338599a756c2a534cbcf3a1080bd320472dc43d1240202efeea246d1f1a54a9588a222b31250b87e992b97528be36a4c87280153e2f50faa55af13db42d4a7b9da6769fe1e5db0bbd738184bc510e01e1aa1f569f220c9bc1a6d421f3a62ba47874ec96c444c0f41b3d246c4f4104023cb5c01bd00088a30a6e21102b98002e0c3c11f28ee249e727429d3f351b30c53a6f8c3001f34f84cb193d23b7d32bf4eb37cbdcc953e5193880fb77ee57f65201d43352bef8f95799549d8460541c40d1142f0113e3ca462a452b87bb822359acf74b5ca6fa2a716cb5495eef44df4cfd747fc0e3ba06c747088d86187106864e913b63349e6f4012991d4dd1d354d21bf4f8d6652d423994a6925c6d3d4e120aa857b08cbbaf55b07b4d4afd23c479f527f8c54bdf4de58a58fd03c19a67aa528931f5d0e415b2c93000ea22f8d8e24390e818ec697ee39f34b9fef526e2b766bdf7082713a71e208454d9238245351b756fb4df4345ff9477f8c4457fa1cc58fe517cfc8d2a2c903d5434a9cd46f1d60ba4728ea9df5995b655aea53cf4a87a2560215f3c9034bbfcca96f899db91c55a6d73cf935ea1396d3daf9070aa5d3dab9658396da47eb9d5b397ae7164c870ecc44339a7b64348bfbdc68a9c7d5c862a59ba585e4d30685d2d1d1f2271e7a484d6639ee94e30bd53c674677d032ff9ca62bbf767498acf2c66495a3164d1eaa580ea25fb9144293a968be76d0d1756af186889ed3fc4175299663cfce6b4584ccaf51fb8c3ca7399e1a2d6f36aa7b5623aac4b881f20b28bf6c34a94acd1e62390e51ea1136aef4f95a01a1db7ceda07967fbc80193ded0acb4113cf4e0a383e6b5228242e5f0117549860e15a8deacd124923a50281d9134cb06b8875b24d3dda35cc16584224cf7bc7a4c137d74a7ae6f3125b1f38e29a61b89c7af259e4558fadaf1d72d540ff9d1a50e1d1a160e2ced314d2066eb07c8ac21c9bc7a71a4130f63bae747972da91f5da64c2fbabb9339a4d6a345a877faa6980ed12d9424f32a444d53480f0ef6ac7a86f4b87bb8b3931a92424bdd4253ec2a82cb8a1d760875698a2e651ac674cf9b62bacbfc3a754e0f746b9e514453586be71fa8699e3ba50e1b9a9536e2d462d63f80b45826f1c243123cf4f033322912ee3270f79583e309f619f610e2c011f2e062b2cad1459379b5776ea139670728bf5a3bff78ad8888e3ce6b4504488b3ce518cb301c140a857aad80d06dae74ecdc88e3ce2993026911c6071e7eb4766ee96831d1bc5644b6d6acd68f16cad3059e26ee1e6e747c8d3844c7375b3fe9ce2d9e1d1e6eb1d43c2ceea5665181f5441823c994b5f7cead977190f5832ec3ddc3165d9ea6caf4e868a2a5de25d65ae825cefad2c45a08510c5278986af993787332a5ce14cd3eb9958a3359ab4495d52a8987676a9e3ce3cb347fe79f17730baf7ab88b59886a09aa248e6615ce5bc84df28fd418a408452d6ad3e4f918a9ca2af384fd1e3f97a7f631798298a76ea13b354fcd5366b1054d4d733c6162d6e79bc218b95373f4d127ace460ea955ac93b66d871e2e1dee98699e8fed4883ef5113b40eef96707e60163b897dae7d4685ae6d7e73fcdd588e69789a6b9cca2ce0366f080073ca0f3104d4d143dcd3f91b054fc3ca2e39f4eeda34b9e72cc39892424812409937b589ab0f4458daeb2ca444fe7ab859aa5aa089496d46b45442cf590944659a6a9cc5b6b1fee1e3a58040a5f651236a4c8aac8c843b3dcd13d194df56454cc3f3888841648a89000c9d408aa79c45475f2fc1e7dcc97e833ea953e1d2086bbaf38e8802d1c40862d41781011f5defa8401e931e409b5c901431a90067767991fcb3f6f969f4f3bff34408b06b4dc43162b55ad326cf7ac322cb74e9d1396e3b7f094239a9ae78b6669fa9d7f741af0e2eee1d60124624688fece2d90c813bd22d23a33b9d2e29b686b5566177d12e9dc7b5626f92439a2fbf59945ad57ab7497e9eb9613d7fa759a681ed1511c334c073c02e647acb8bba3a9e9c2c38832427d1af1c4c353a3e4c8d23102168a1ad5278c54a5748cf8b4858eaf57e5b88be8222c4df1cd9f8fb59064367df963be6ee914b1e4d43ee558e6552a55c44bac2c73119d7b789a2c9d2a5cd4f9e13b56e6d79ba60ea8838ea721598462999aac8c66ace3b522a243478b49072c86d2009935e8f81a81f0d0438a6e2dead08142e9f89d5f8786e6b522a243bcd1b181cc1a06a8e4ec2007cdf981230677f7c1419c1db4706c20420d445041040e113ab610a489bb9f1c0c420651010205201870f7200e02d90164e42d261c445a4c3c10f967fd9f26ebdfe5c3d27c8dbfcd3fcd96945c0169d37f4b6ae737517dbe5e95ba65fa700be1850b410ac172f303f0060737ad9b1c1e6a31bfccb227a3aff43502e5bd35396a14f6d2289a7fa3e397e3a780f22b651211c648329fe6c7c814cf7ea5784ab11cbfc4e149d425cfb8ff4496f9870e7ec0c28d8a6536d1fc3d1b37f151635386bb0fe1a08d0a6c8cb011408f210071b007133d76007b78eebe00077978e1ee390ef238c2c3860e0ed6a8a1c68a1a1dbc0677ffe120ce0267948358871d4b70770438b823063b8aecb82f580091055c779f71508710746c1d0dd071dd4334bfb9c98cee4c8a5b6b962e711ee512a65241781031579a471c4fd5e7dfdb3c57f95b5ac2f04f2d6168dae92ef52e4d1e4198fec4c3a336cc149eba859e292bad0ca8944ed095a99c854ca9990104000000931200202818120b874342a1582ae699ed0e14000886c65c805219885192630a19430c11100000000000000000046dd98093690ee8f7e8a1a0193ddf8f0b63c3b1033f59f310141c80b3b92a89bd3d4568359af85453f692cdbe05c8f4fab07e193b70d713fb29a9a133385e5efba59a36e07504b11854f69ed53e955b7f06298f7393c1a9c70abb7faf85dd0426435b12f1c9a72b73ed096558b0fcbe0aefd27388e9572873652c56fff004229d306ed4700bd9abe97a4fb40e124465cae9b0e12ae0d15e891d4f3d6a4a0b010ae3136f5fba01e9522068bd6b03217b34686f083bb7dafacfdd35f1e2ceeceeff64539bfc284b216001eea21ed2c9c5650c79d491df2281336a1fca1279e9d8aa7eeecfcb5cce732f05b67886733044ed04a738fe12e8ea5ed2169bfdfbbaceb73f534ae33f502e38228b8e94dcf028f1ddaf806983a63157818021bcca30258c3dcfd41a9d4cd0e723670155e8a214315703008fac615087a55bd741915544283b5e91d3854d5aea32460d3e8eb87e840b56f440082f2b08eb39fbba93c6cc0e83b8a6652af221363a5bd80c0c90717d7bbf4a72562f262408f64a70787632585ad3dbd090d926c548593c4b9c5863ebb6bec25b02233e41b709a866060625f6f1bd694c07cb61bc40f02dc02d91aa457617451783be6f7424c6fc16199db8e1c228ee7cee4ba2371b8fb622455f1e0eea9822fc7fb01e08871f604b5b79f3df56507b0cf059c869146675b7d122b8d05cff6b1fa49d48260aee43aca736ea5ae88481dcbb93a34e03a4a6ea18e0f86b0ec551af2410912dc8fa11c61b3fc623c360feb8743b47f1b33c7112422e2186848ac6e1cb41aec9f50d1b7a64c917f1dad4502353c41cd21a7469e18226dcc794986cb4597ef5b167cd30e99b011e790bf8e1159a00115c3c630f2df0984e2d5ce578b92bac17e62cd2491e004c08583c552ae92dbc9a4bc3707daa63deb8b63cfd40ccb6a5bc38cfbb12402c5919b2cf0f21a133022b5cfbe8b36b1c2202efa4a92d4b929eb956579efd96886158052ddc9a7f73338dc796641b524eae9b02ea71e9bba9d05e2c17c40b96a2baee34dc5b61a1466357c6478ffc68986c09279700e259e07cc336d85056a18a15cd00ea1897e70858ad303f981f56a941507f15e3d60278558dc7841751600ede4ddd21260de5959ab983bf1d1361655881d904394a0d569891c4964b00a2a141a651821fa262d923a67d422ca2dc49e87a09f1c400ef88bc0276c59a3f033cfa68d17bf0225f99d12bd2486dd694b4f8c738bfc247c1384988c3332fd3fcf2cfd62f645e153a868c5f3f206dad1eff0e348787244b250461095d0f3a2942aa10d7d76c9836c9dc324bfd74840081993795c1ce4a76d77837fa00aa16a62e96c5bec264f69cd52d6c4c016ed6d74a1398b36b973f448656fbe80c0add7afa36976b4f6795028377b6485cdb8b4b33c138ecdc16fb2bda540b573d873bc5e2ad6dc752aa06c4c906d9ab8eae1d871f65eeaffb8828b8618f2d63995793e85751f55b7e28a07247942f4a2fd11858579b690fd628072ecabd67755b68d971f4d92112956a8679c2827f2e34fa166930298fc751e9337fb40ba552b4a083aabed398033f2d1436208fc7f54ec02be51940a1328bed7f78d2224bddeee263ba8c12d870da053c1621eb57ad85519953aaac72e9da688c11538b340897d6265206dbb8a66fbd6da32012ba82fdca8d5526d56de31f2fcd426fed88a74d842a19fad722d606c9407d5da017c3774d4bff1c0904d293b43027360a7b1556c07dfbc482e7c12dfcf4892df65923c295c4e5a81a4e1e2de82b1736b1001c21cfafc2fe47ccc2ab91ac7260f7fc9f8fe1aae9cebbf476943b3e07eeef8819da08884e94d54999754d4da1be5e20601a78cc2f8010e5c4474af505cdd95ccee73d573299011e5d52037d24363c8bb0744b5570ea6b809b0f79ecd43f197f5210628b20833e885e52bc7b54849b5f039cdffbf5d8ed9bafb9e1e869bfce3e8cb7cb5fe73249a4c66b4385e36909beb0eee448bdab540f6e8845a8a48301e94e849810568c0d339f0719fffc045463ac8779c57e244be802d62249962e44ce78a27868d0527c11782e2e88beeddf1e7088fc6d9c17ffc79d57bc1f889bdf43d0fab6da7bbcfc094b5c3d381404c75294b6357463f284b83ca61aa3b21e418b0c2c3d4dd4389eca3b17cc93fe5f08cc42e1efd1321245dec2577623de54595e22b3ae3ddf8e17c6f20e052d810b46dd5e230fbb5e3ab0c6ecb255086597845e1c9219a9eacd59f72dcacdbe363caff544378781599aa225f870e238b41dbbaa7fc065d31493279602e97b42b15d25cfd734d1e1b9efe246de4826a95ee7c99448ec0ebe019a07b1aaa2970ea562de56d8ea9b2f0e70fd0cd84b43e412685cd53ff6057a253e7fa889edc35815d6d648be688c47d333258df857a8d547dddc8cec95e7d92e53d3c3b96addc84aaf538a05b84d66ecab003f5d30774f28cb25f26d3440238065252f4bc92b50bcfa7a1d901381f9b3f920422f581e88e1f39e5a98cd2be4bf502d3f453f50f0459eaae6b7765dee214aa553b6f0d8dce0f9d08cb474f9861651269900c35555fad50fd017e3c10453ede6e5e5a6f85ec3309e34ba15e65b72f7014bd643a37c022e0e70983b4bc11b7784d2c23ed7be8119c8d16dd41c78781966d7a031e36e7af9d43665c6ef8c617a6c31dd8eb2db22e073e8d928d85ee9471162d8ca88537aab25899fa0c21e22a754b241d4752409e40982bed005a04e14a3b565bbda2c4f006458d8d6e7d4139d722de87084339a1a48b604f12bafdbc7c555e0932d91746986c01e7c1008b29db9248a604d74c9435c2441830a3e8424ad44922efc671738369028b982b5d9df64e500de218fea48552f4c51a3b9a1061e9a9089185ca8d45681972136a15c8b34f8b9a1ae5dd5e1dc67afa4a6555e5da332f1760df1ed39afc95f0640dda26c29a980f422e3b3302e762da5594480d6663486be6ea41b89067ff11ee787129c1cb29e5751b98db176314a1b727ccd4a901cb127de2b3263066bf7215d1651a864c39c44ce6ec4b19fe59b903c2cccfb6c0a6096c16ecbca81afa8f70d8afe006438b9832485b858244e06a11e3f246cf58aa43aafd9c01b5060239c6ae7f91993227399d9b01b6a583647b2364c065db24979a52f5c00020bbcf7579194d1da17e9776b3bc62ceb0f92b0193c7fe7ed994737d3e47287e399dd462c22ac29229d14e41a51b6f30784a7dc371ac313d6c00c9143342888fe26ee1f0a468c6b41c01635e5d0520b689d6dac4ccaea3d87caffe85be892c1af21fbce8822ffb2dbac03a07631cd9d1b0900480592508d5a4b08002decd5748c73bb389d119eff422be0f0ce6f70813a21e0317586884835efeba9985b7a407277797e882a59bfc07e94af56019555ec10bcc3fb3d113a961e7256561d8f6065db0abc8f38dc096e0db381280003df3444b31443e5cc1f9c27287ac265bfaa5f7732b9a748519c300e4387405bf3ac1476daf15db6bd8339dd02d0eb026dfe9145b308843fc64f578adea3cbbbf4ac33cb413117cfe12d78e9ff707e6860f6525733fe5251babdb79597584b5c7b86d757059f8af5d3e398ae11390d84968673240dd473ba7116def5dc7a9714670808faf527f02afc4ccf0b602e9bd3983b5997f99f6e1d1da77d164868c1f1f9b8c08daa41bffb8141cf692a00a7d7d57ad997f6e4ffa24cd9b4aa76b48141e34aef461dd91a8832e4021c2c9c97cd00f6dcc20205bf81d368d40a8892d272b9eb3eb0de662f5eec81b89e70166834e65466078b5698893180e879e1dcff445300d0872d42c43c3b415926ceebd9262bb0e22308f52842abba3aeb3c9ff0e3de79aead3ffe2199393c61680b03d9d2822349df5e76b2c301dc7bc90743a6c006c22a2403aded66247134753c6ccc2464c122945c7374812631a281db51026b7661c45646528d37007a958f6d0f964497cae2c939dcee60e99da8b8f5b192aa5e089f93bce01ef661f24c56bb9000863eeb00a9f7aace5b2a329b19b9c0133c17d9d03a3216c49cf341cb11a415b124226d56a701002278026b3622417eb7656e5fe8df8d4ed0f3e2fa6a69aed217a9b885bd120f1e2f1d4afbf6262d070d0d3ddf1beb59c6dc19b318d2afdb0f366ece9acd3f8f6be4f1f6e3960da240ad98f57248233a76aa48f3f4c45e403d1f5616e582e089d3014533b8ce18ce954d0677413c3df9a412f7e2edc6a1ade774fc5b861a458680d136818375c4c15f29e032595753fd62149cc05ab33ae5f9b0c53b448b649299b23c3c4275887f1e059c66da362cbf4b6026fd003055addeb9cb6df5d6dbde8d1ede162557fd9613cf3ac9a41b96c377e6d5bc53f1f92ef27365e2fc0b282f82cd0b3f2066616686936cf05e1023ce85c9c2cff478e69c0e34ef2d8bb78fec7a3be38fc3d7828a53734660372ba6623a2f44d40a6b84ca6a0107886096e5e67c5bde9480afd2e8a56f183db3f0cd69e1a5d8ffeddd6f112a67dbff8d619ed6fea94173cee74c5772810b67fcc6a5a06a0e88324716aa122f99a70b7d84caca46a505c894ed313867c0fb6224a349a3e88494c5044304de0f94a0e556771d150ff61d532b35a31eece6451831848eeb2c2edf9c250a58064ce77af4280534f01666602914106c235e6049df418a68cc3d92b8773e8929ae1e57b16e0b1addc84c239d08912e480ef18d03abc9acbcefcae67f6d00dc4bc78d3188ac55f1fdf4accf219f6e2c5cf8694bb33763dcfff761e737790b2fdf03c955d56ca3009708d092afc9318cd06c03c1fbc9570e3c7b316c6fdc2a70520e8aea236a822b72fb84d61900338ea7954f8bf8350bc5448b2eb85b78f2b6bebd3c2ae57d6414180b5f17f3e987bb7ddb6553d4e56bc1d02d723fb48a4d62ec1da5a8c299a8caf34eddaa40b91a7df394cb333cbdfa7918af39f61fb2374e2ba6cadbbe79ffd07745247f15333802f79e4e77dce8a7e9b6d1eb53ac29805cae73a345d8fcb49bfc4f3c9451e3509ce9542bffba8edfa006d653dcc6df2f4bf0bfdcb60ca0f2d16ca0ca0914d87fb54f1d10d9e75549466427d35bce85411e292869321420cfd3747b0c160ef38f2d9c33993c9d184225862ad9276735639c00f0dc18c4dbfd8f9e767a09e1df6e36c15b6d90a98f0f0901006946364bf9e10238d94d4099d86d1c041843edbe9a98be2cf3dad69dc7ec37b0a3648929bfcc9afec188e8a89846fdb470e1f30082bbe2dd84bff562459a55490df89bafe5e4397dbc04f506eed650e3d49d0d4f290e20c6d65ad635e41d016f90dfeaf4b9f275e1d12630d5d102d596f922f807ccbfd9b13d485a35e3a5685301050c92abfc19bba77da5f24d59c1a2995ea3e2d95e9894535441ea4f8c8381b331820a19f245f7e658b687544e8ff9f20beeb7112e8902763c855a7187b06034c46336ab56c808b216734289e0df8906379ed75c736faeb0a210a408bab444fc2eba4ebc1822184e4db93f452bb89f579398ef6fc2740e12179f7bfd0cfd52e3e3eaed1960e783892d796fcf26573abefb4355411b328fffe0efa4ace75993099b6978b91df02e48b1c0615e41ace0646857c66983247dfe1fa91715ad778bf93d5ddf257d7a9c1d6aba4f9a6e137fda7cd54b9ec14a10d769e16d576273e460d63415278ef04a84fb02317dc699fda31ea5a00d9d3b256c35e7004c94f6d6fe8746a046fdfc24ea747d01b676be49021bcb1f27d21d92bd2469677961e60887f964a69a9d8633e3a9663eadcdfe854f4efd9539e8a21dbe76d6ee142b46fecff04ff7c4fcc5b352b76f30c7f305e5443f303a8ad151ec0ce82a65fa66ec78258eb32d979ab4160c786aeef1d1fb6827d8252f8f9f9f859fc320f98a519376a3ee423ec628f6893365abf3fdb4eba05195e25ec4b294083ba52e347de720b6035d52363323d7a7f76405e3eb40cd9514c3703699f493b79f6468568b3d88be999705203dd9c3b3359b1ee70dc0a3119ed96be931f6339062914de98bc183617fc62523227ff6756f312e9ff17b03b4b031db3f24674d999984539c4d165744b4b4d63ed31886d6f86fa8a7b7c2d9699cd30f7756f4ca5a15fe98cee828860e8ab8bd09df718026e155a9c2203a3c231e0c4f282e7f320c419933281479b80e00141b21bb9b416c1b773d5dcc982a908da5550ff1717b1af3d7f9037c3024ecd65081ec2adb5349f2746da284e0471cdfee040977455cb2bb7d85e0c1a26dd3b9ab135a3aafda31e74031ff54b02886052115a7a96111157909261c2ea8489e3a3b64db707da9065b7b7764c951f278d48c973fef94d5a1dc8d59f8c4b2c2d3358b5a20ebd68f538305f6e573129001dfc530edaf26cc7c99699f72e4e0b44bbd9b5b0c1ffe22d56f1d1e12da6ee401ec9d2b1e7a2d5769c268cb9ffb39c10346e3495283f3a5f76182b4015949303910fc0f261e6eb42f57494311ddc2af9763e1c3fa166cae2bdfa5644e6705fc395ae104077ca2d02f5a62422bda98584b848f0e16874d443b4647bdfc0a1f6c6d7dbf5e09752d2d36cf7d14098912fa77b0beb901531f31985eac1b922012fdf97cf9de2bbc943f72c86560206b0aae29d0405d5fd24c520ae37fdb3fdb5f5eeb395a56f1e8863ef2169754f30be22dc5a33530392847a2529f41e1c8d8ded341d46fc79bcb310f73765138a8475bef2cf2e70d01f9836e7ea6dbde9cb07679d9289f138636528b99d096259be6dc517acd71f7438544b83cef2d6566c5ad76ecbdd5045c6e540f75db383d23d2fabd61e378d59f4aca26b0f7ba4b6e2fe0b0330104a5a509658f0f7f24023bf4d281b058f13088104008f6d499d58367e0636eaf5559a0da4e217b8efbe6c2f64887c52b79983f3cb297a37e4daa115b9f0f28dbadc1c4e5bc0ba302ad3f0e177c77c0d16545deb2be9ebca2f511e8b101833dee248fe7b2881d81d0356adb9eb11223db05948ada3e64f08d395869ffa8cc3ad949af0f6bc1601ba1c5f7d5ae5c315482be4a0243059edb238a84c608420fd1418715665c65a2ce4b19b180300d5dd9356bd4ba2c37f0d3bdf245472aa1855176521830aa2483310a05c9577cf9d421c7262589e98eac95d8b13354d07f742a846db5b66f4b518d8f903e56b24c1cff111d0e92bf314be367e7bded4baaece838b7ed1080853ed088cd49466a81b4a5ca9325e7786fecfe463c2fde48e6e1bb2c8fb442b7afdf049abaecccf8518ecef8aedb3f2740b6bfe62cd1a968b6678885266ed9d5904116eb19810c1f83abb1c8d899708efc7dae68249baca92d9f7c2075a91120da9fc8c28a6b1312a42fa244ba12902aecaf4ede4fbdd234a67c8c7a55afa06b980eaafad8432b79dfc0338271204350df0ed104a17c2e37a57c941d10eb86bf6789d0d535ea6825f1dbf9bd051c760c1fd0490bc4bdfb2a079ad51e6631aa194d485c4c71e4c193f962394372b95fe180898d8054b96d9b8e5a4bbbf3be8061e16c3a44cc5072943aa775d0be234e064457f4e4adf563feb54728f5dc279d33e3b5ef7e999ad05ddc2c8c6a2cb3c0416e16226d783707114c5c9a9270efdbdf6d20ca18bc76cff9f45620d6107c40df92c9ead38676a342b7254b4d9d23d832a1d1b7ed83b559dd2ce04f195ef00f810a11cbddc45085b3a40dda9cb9f06936f03fb5f51f6b25aa114c274a75aae48e87c2fdc8ac17d700661a67cdc463ff920c1ac491a91f61dfca8bc9a3c6f53dac7e6058092e7207856054dde51fc7a5abf914ea15e32c3f3ec6bc21d73322b552e8894e7edeef2e2690b2f1b406fb6e7de7df73e1af6ef8544e8fc770333e5052e940aaa5b0b41b26ec25447e8b5d720761f5c47ec206dfb05483becd25722eecc6ed71fbaf95a544d69139b3ceea00fa302a1f7649b5644262b3f5256bb08542ea41a41a2206eb62e3662fa772078c40fe8c44771a13ff0e7987f0b6934035f09f200084f3a134ad4585d35851baff1687afe0cf21efb74c7177d4b9b7e58461b981d0bb51ea877776e912cd3181f2f0e0b80d1f6c89b2f5b6af9e2723d1b1df0a16d98e22707409b91cbc708406bfc5f69080060ea855a59df6e5fdc720ccdb1710dc8f8cc8e05e9214d815bb6d3ab7753b231ff6cea2ffa6a1c195e1b97911f1e566d7ff81dec0c9c34e09abea81981212204ba531666b2d3a837784b1de288b0d202daf35f302f91b571ff5072d359c81939ca03cfec172ff2f9d734f28cc05d0c247e1a73f7f232ff899ca27ab1ef0e644d8ef2b2eb19b5c4977495f8a96fded96041ff0f6cef6d2e2ed264fc661916865c50b0f75f06f29df1cd4c80952f2a6666208bfe079d90b4a010da3bd86a31803fde2a11fbd7adfc334f7c898645dec7f96f53d935149491f30e4cf9a4e3229bf6a4cc1236bb3a3c34460da6323defc1d7f5d10f5ef6d301e997b5030eba16dcde6e5ab2d37f34a4c483d907e977563dd4977409df3e1c615df59fdc0cf7ed3b2082bf1d51741f81bc1e139edd55b0bd0dbf72e8c2f37bd4a6fb7ce9091ccfd2c18f518a784512e9e6969654e54fd04693a5f4ae08a821890daa6d77310d24550aa6e27543dcccc193423fa264070afcdff07f47f82f554e17e9ddd68abb85f2bd97ef5d1b79af4e7de337a2d6f94c7ff06a1f23498c1768dd5ed0561ecce63be2c3e395e253dd967005b93858636c537752078d2ddbc122600bdb9386441ec349bd56271c7fbc4464fc25da80bf7095a91917f320040b7776fd7432f5ba132b1cc3c49d0c48636998557e18b4815c24748b9dbabbd02def57f20a1871ce64da2ceadd310ade92139deabfb672f149f43798f909f70cd8797d1e6aac814b461f7f399a4ee8ed777c8eb755c2c761ed9fcb3c86aafa194a8a6a3d6ae998c7b48d2eeec97fcc59595904aed1490ee49eea520058cb53fd21ab645333fe0ff832420fe7bafa1dfb61eb0418fb06d02c935f2b4e2e1938d1e0a266e86cc132d0f55813d373630b848123a452aa61095fd82c8a4888a08d41b5fbd2b34fd1d3e22b9ff513e19ac6698adfab63296506a8a264ac79b5ef60baf07fa98500e232f02a1bcfd3c05d9be3bb8d63b7c11c83ad9120f9012e5974bf9e66af15491d8493ed2509a0e97c5a363631d5969dd8aa4b8ae723d3e7c26b81cd54237d4eee017eee4cf1fe607ea19ca4662835421f72f94ac6067259b438f3da5adc6003ad0636fd6428596b59aef55e91fa85f827539e7fadf5e01113d9d2f28f674d19c7aeb5a423ba3b23182cf17ec3e457251b1a75224eaa9cdff0b88839cd95b1b79a7d81ba0d4e206ead0da9fa5459b502d6a88166c0325deca1154b3f22874119a791191e89525d6f64db16f9e5123bcf3381f10ea4749dc3c61c977975e0c8afd49dccb73beaf007a0689f076198ef29bcae76ecee6f20e7683b65567f0dca1f07b49ba6e1c92d75dd0beddd06a5aa5f5f059dcc7be44a4dac0e4b2904b5d90c319549d103474e2844e745ae6c02b1d2b2bb987a73e8787e155ce59516b394cfc3a1fd39d539405ffbe4f8affe15218c74122323f30c0e4a489dfdab259abce1642501a45894a332bb7807baa14c3f91d4e3c9bd7124249db6479a5341ce9dcb1808fa430eda67f83bb221c082e504586e86b94900d972c55598b29b3850bf80b5178742b197131eb3bd8e4d1b6f963380efc43df43bdc7cfa4ccb113629771e355eb1316b8941e9264e5100740751ddbc6084d85042433df4aaa34546cb475e40294c1510b16793b20bce28e6874db48ca8c888e662d9092881644b438844e55e0d361c48a491fcf0d9b1f9428ef38452ca6d53bbf20fc7d7adec69057da7f6de69b14130e4db87097cd2d36ce600ca09e874b1e0a7865d6ace0c6284cc68abd58e7d98f776ae33c086e33db427d6280dae4c562f264b62a6e97838363a4186244e595bcedd096adc83dc5a5b09a202393e849cdebf4341c4bf56b82e4f9cd608320c3718c09334fe38c80a7adf4ebb202b5e8efc306f882e0c219d4f47e3d1b4b0eb80232d38d20247abc333875c7283dcdd37a1955a35a994716fca5c528ad20d526475323663e02d5a5fbc9a8b2b54a47f8aec08595ae6ca786aaf403e17513f54b2523d0c07561f234a20d828154d8b6926d031472a35a9c72565a898d70e8b91140f846953b916ed8ebd80706674e538f667e3bcd662436b47830c60caf4b8d7f7c3edd61e60b44cfaa270faf3ad7ec68925c87f18399fb53c5d7c6b357b95ee855afae9401fea57bd698fcaf748ecd93cef716af38f2c52a3d91507c66f16913619a9e7b79b81fb9fb9741b1afe68f73bc36f4a0e3ba7d25cee933b8af2a46ea0d3a70c4015ca51d56ae0b6b975d87c57e98e4cb632406ecbd3e5f95d64b1e827d4885504c6165a905f93d77e1f25ca2e7a5c7ca9721b2d6400510b23c630dcd88879442aab17be595097b0d3257b823955785f7aa640f06946ee95bbe37cb4fdf267d7c3bbaa265d4f76d9d0c4bbb4510bc3c186c2a6caa9292d39c878f52d9339356fe36c1ebe25beb947a0a44b43930b6733035013c1a1e73ad46665e64bf7d3fe7d905686239be1c5cff8db557ccaf96a7289d6110658986dc90cfa79188b429b54c41e9d9da188e44f44c62b5d54eaebc528f0a5e2515cc3019de46940698976a696232415a381f2628bd6a67c0b7484df1202f15b16b6e989e4588455f94a9d85f9a7a2eb7cace4cf470f5f155c57e707ee0c478b0f613f8f0b502608337da75f0d982e4073b6cb74bb98580e94904bfd06ab53a54089e1d2938dcad41f54f2b1977bfc4d99c9d7d74eb4515cbd8c0ad0bfab7cea70f9edd5bc10bc0d46b991ab8c2888a4b27da970e9f898aac06ae68699b113caceb7c22fe9d54d60f4e7ca4822d89dd0321e07dc9633dd63e57e297dbbdf39d24f6e9e5dbccad030bac1114bde9dbafd0e81af42cc8e1c3345205855655d7c00e978dc6674e04850493cd8777d6ecf79bdb8c7454f84148dc490baaeccba0436d2fc32af7158c1e1a2a36033e53502c47fcc6c4460e00b8a3a38c59c668a17d38ab1496a7e7c5401124d95277e1706962b9d326649561c869381858b49aa23eea426c740d149535fa42d9a92466800217f05fedbe1330a56491c252e718ca326c8fa8b27f5a31f1cc9c3b507173f9c1380e986535955de1536742b9a1c701fa201791647fdb8aa9a81eb7854a84ece9bfe9d725163cac8bebff6a25a5ab4c5df3ebec6d80d78b802dd15ae6f6a8d25cb80f7d81cf52598b04372b24005016cbd1673ff929c66a78345d04b128218679d3cc3987df2888a3783340c5b4b0d0cf0fb4684d39041a05a7b19565bb6c04c04e2123c81056af3fd75a944bd5a22f058c7f395e53f70e23ee307e824ff759717304b863d6e6d7947655c07732461d05a35c464969d7ec08a42ef6c63a6901be47ad8440d033638efb9ee31514d4a9b92bf157c77461a387b0034c107b7cfeddf9b47ac726fd83b58f1ad8ef1e2a4d6e688739a1973b03fb36b121fc16ab195d4255af0643345e63ef5b1a2bd109fd0787541a1ec5b21e672af6b70166b7dd4e1d1447223344d964f53b52661b377402baf0c3c637815220b773e8a966c92f7de1561737a58dc83c8012dcb4ea5fbc3539fedad21ec25cffa553cbdbebf8b84476b03be0b9157d8e2c66109cfdbf81a3cdb1cc4418a507d47539c0e02f7300aa826663f7024bbf82bd89ff998397004655448c8e534e176427fbf79a4fc4fe565bbecff2187e3ed428db775ce3b46f5ab287ad9d68fa6f5ef9105f317d6fa055641170fdb5c4fab0ffc7f7d9793b2ec227c35608b41fa2ba72c4fa4b234eb4566aebb568765c571544b6612bfbfbdf1c3efd5bbb89896e19066d70e20a1fe4e7000bf766ae0efde087a4e9aca0e40162923719e51884420b51b9f7c474a031e2b94f1d42b2f6b40922c087c0b86155358d426b70b0b2b58abdc55e2ccc8cf10ba34759d50d20e1bef3434681212515746144cc74c14b0256b6a1e7f4eee98db44ed80c6cb4602cf1bea51360f84846cd6a6030ef74849fd8ff2fb78750b8fe3cd42af260e00a716007326aeb3df79891d0fce516a5e52a46377b8444ac91304a29eb87fbcb0a8ae76c06763747060adaa341df3ddaed0174d8e5a145f969ad0bd41944997c9293b8bd1037d98de3a99ae44d245f92f7e54db24de085fe2ed09c855623886e3fb6c50d2f5884d650d4459b8b2b0c9324e995c5b8bfc9ef0c33db73739e4fed1d2623c609104634a55a14dda31615e7857a3e8dbc2d4c2f48d94f398310e639b454c23dadc0075498f797e71cbcb0b2fa024aa0c6dfac23cdf44dba21382a6c09eabb080e50ee787deed505d4297c1c9806d89c1bd622c5cd70d0da734cbf7d3279ce76b9f3f12a62b340e479f8a80d91c6061d5be5dd481ee8e1ba7880e2b0bb04761d3a81d19ead0cf9d047639882b58f84c167e01fea5140c7e578eb96c7bce9c5add588baff80c7dff22732f84e50ca887962f2afaf7b8bf937e4b70474c63ddd2be9faeba16a1428337230ab565f9e7031637aea06f24b26235393612512b561231414ce43ee035467086366b5abccfd671a334ebb0830122fdd02ecf5bc81b0353da613145fff023f9a8cf3ea81e516a403d63241522c54317007a90997abd801dfc168e646f3f9e09913dd0c9ce06fa4e6a397947d5f410da9fbb2f15f4bf18a9efccca40edd0e835d07b91b5eeb1d14bbef92d8d0f4b0070b7b5ec53fd055fa77d1e7b31d2a99b2f9c0ceadd28c95713bd0444f57c76cef6f9a19ac2427d52de074e8d49ae45fd204994a84234fd1d39f348a7fa173c6cfe30e6850a8b8c5940e3e823e15786fc4010d5358e20d01bac83fe3236ba8a0c07e86045c26eaedf9f40d728ccca0be21d609487b30fef34eceabcdf6ce8dc1e3f27044d0cd4d5c285d69da8eefecffe13811e02fe703f8c74f5be9bf0a676d9f6a1fc823fb176f9b416fae7eeda83fc04a56cb3581d923c26e9ff7404c0351e0cf1dfc0f1bf170bf32b74f34f036cc35b2c5c3ab93f637b094f1c872f20d25e7ee7f393d0082d637fde32a8a6321d51bb68ab6e599332a2c8a388e19d5ff7c72c736cd976b0f6893203761dfa35b728ff840a304d3203376851313f6057a04880d2b96cbf195f38960c0007aed07616bed27d0df8960ff66e6be7e6ae7f6e8ffd71f2762d757ef2e888613f118f30a3bf8b882254d65367fe3924019383ee5948672523e1dee8b14a2b26885a05bfaef432326c6c77cba4cf87b80e48eec7c31bcdb2fabd918957829a0209055fbf7c23fd031083115d34ad4c7b20c919b0915ef4dbd385988bda49f54c8780ef9d3709c412140d435e86e856e9fb51ff3008a67bff9d506b6481c468fecf404417fc89afd1d137aa96d681484af28cdb73a2125118f49879df6a9fd791a57d26cb17dcfae54e37a3437527225cf3767ddd767aff5286627f00a631a0833250c6738cee126faf5e067c15f7124a2f8f8cd7b4d4595d8af86c009c1111ea1c7b42c3ee9e637faabf2140d9e310e05ee38b49fce5406a5b9660a17aef764b66d3bb2e206a5ed317048b64322f72dbdbbd5ec102ca3a7e426ee48a68a4e84f846faf0803c5a0effdbf87b063d4cfe83eb4bf303cff7f526142a43787386ec31e6c95913a6058371e3bb1af6df7d812bfdea38c30620a6b720162fdada4fa079498813b59ec67c03fdf44ddc572b4b95fb5048fb341f4f932d4b89cdd7211c9d5503d2f4c7c0bb0db7a353268e57b2d00a580bc7b30078e700375fa8f93c854d682b7149574d3050eeb119167d71731d2c1db0f0f4fc9f7e875f5ec2a7003f0974d28093ae6d7127266b92c068fbd83372f54945517176bb850356e66ea5423334773b205190650f4a1389ec8aa14ef9db1442bdd7aaea309a2540c5d3f056e1a11559edc16b0ef81aa91c199eed20161f51f4310d8035c15896db94ff9f7392067148a678404cff2e5c5a4ab405dda91a31327f814fdf2feba0bc9f2facc7bcd09a5e0c3f3e1ef040f3fef16a5da5d713a238d05ef486a4ef73059eca49e1c0db4e14a56ba3b836fdd5199a2caab7775a134e16a61d75e3760136e0382cb623c3cdae95fb0945ed5f315c6c24b0cb95a7fbc371cf4e5c0b81151e3e070aa12ba66968ab973e4a5f834c80373d72877547ee3d8aca09270108c04725906c268461e83d49469d0e4e8595d76f130430e78482c501acc2a2bcea4722c565f58bfdb944af8ed7d379b0c49237ef66b1353cd2a88a9508ad46056dd14c11db444a9c9ec04e5e2b44b1fb4e28c1ccd1a781e78a428483f958561b568fb6d0a1d56ef5b88a2008964893e1156e72f1f45829c51bc3216a7d01e9ed11047b55a0036679307f0b21161f9a8220fd67ac091ba45e175812ca415b024375c734b7ec226bbb3f9cec7025da149b48fb7dc6d79494abd3214c8e43b563dcc2959c15551aea4bd8c578525456ea4cf3736ba1df6f6896b44bff303c43e1056f965369cb9756e9cfd6809a327cf2d6ec04eccc9d3f5b414f3511a40a96016f3e6f064ca20707c4b4a90f71e7a957857f9333344ccc0cf0e26231ae5a2030f9f3343aede97c1214a7289f7f4364b4c05d3f6d538a30f91d1d03923dfe05f46a6131bde32e7b43a21fb5f45888213a74b981d62c5bd692bbe4a4e2213bf2fa894fe14ebf3b230c0bad18f1669c4c47bb16c99d05de1c604fe6d45271f120e4f7b656de5bc3037635cb8f8396b87442072123b2dd26e5d619b23b0d166756ac14379d4141a2b470b6b1aea8775ada9249bc85360e1a8128fcd5a3b040edc4aa3efaf33405ca6b06ae6927446da90f09269434c8fbb664965c06d9eeff1490babe3947ef5cdbbc4a3d39171545126607859b2496e7d8c1c89a3f4009d412ded04bda3b7045ac08a32e4cb3203ae7c60fe0d471dd74b05ee83905ea1151265d8fca59b959442c5202cf71798fddfed9f8f9a3a04e5c4fc0f88be2aba5255b61e60355910797672911283e00cf68e0a25f0f2057b39753b230ee2352cc53ade03c99ff97cb52bbfea9f526cbd729f0113c17e198f033b6c61afe985c4503373efb6e97344960976428ea668880fccf53a66062e43d0c2280822f6484efd35697717c33e0cc748e811bf3137829c0c8eeb9cc21978a28a5be3f9ff590c84158073bbb4e3e187bbd488f4cf74789b93614318afa246c4f95a55a64cbdf6db23d36ea6b21ee37804b428952a3f5287d6fcbbaa78b89adcc439b4efff93000fd8357706cf48a7e9609097b27b37f1214b48413343f8ffe4a3a0d8ab33b5c8ee1868c6cbb0525f2d094b95000f82029443030dc54ad6f46327354b6e5f959c5e5ede98299b99df79b4395d9ef9a8e296726b3b01f0d7343e61ade7c15e72eed404b321d70fd8310fd51bdfdeb68d9a1ae3ec8633983989d8200e559189fce00bb76b206dec1bb61aeaeddb6bce42e6dac3c32b3093a8166ef8fe282648717f196ee2a4a2f72706e0b0210ecf7c2f385fc550ef6ee96e822539ef80cc5a3ab783d48315fb1a724d1460e63532f5121fd84d4e975345dfbe0a6df71b206a89bc7ddde6f35159a78b4854697657f6d773b7baab8d73af6d437bef4041d63aed8f13f4793d7750723fa9469074c0867c0c98bbb983ec23b0b1a2967be8b49af1476924146ace2971cc2011537feab91a3bf471b40eaff36e0199b9face75f4c2e7bc85c96b31fe611915dd98c6e9e88e76517398d8eb18ed1d0c7dea1c58910dc40bcd6fed78373df4bc6ae0828f47f1efcafbeb8ddcc2c3dc199d7a64779ba82466cbd7b16b77de83ad4db4762701ce376b8f8e5e3aa0c755718d27a8ef8dc300e63797d2c3c372558ce59eab5e8372cbee1822f00e1413fa7e470fb4db0063f93a8a6b2e0fb7065634d9f137dffc8a1ea67b945a2ac46f4a2ccf536e66388ec42209f1e4f319862596afdf0d49b61b95f675ed2af25d71be9bf3644a7fb0423db307e2121103e1eb0a1eb4d972c5efd50590cfe0719e81381ca39d7357c281f8e40bd0ec12aa9cae4c303a93f436b5278d04b63722ce3138a45ad6f018caa25ba9a09f540d1ebbb412b63c1e15871e140726e6185f4868c17c1c58c2b4d637916759920510350999969dab90892c3782391dde39cd17c269e2b9c8de951974eeabec8c5415be75fea2db6ec4119e453ad020f01e00c4b1d11d381df23dd57ccde9e48f99291fcd08f8f823c9c8e461e5359fa10e7b60dd67f15f6a8c768a4523b9805e7cf9611fc39d4ec5987cc5ae6710ef83a2c8f93c1a1cd554a790c6b3875098f2dae57afed8c77e4b2dc22a0fd426e40b4867fe568b4bd0b73dcb9c7c5e39b64c19db8a3663e0be8e4209ab0a08760a34adc153b9697290d9b8642b4e1f8f11639ec2a742cd6f7904693ba7534f53a8927710662ab61da40f883c6d64766dc1e1f19d0b53ede923fa26bad0645ab30f3eed74b596a6cdf163aa7b27d1dc3a19815cdb7668199570a8ba22f5a62b4dcc339326fb76fbedf60eb990c5058e946da4d13128f35de657c5dcb6e9473ddecee61288e6383c611bc6ea2fffec1eca4930bf06375b5d6ac1ac70d1b3c664a84a65627b1b5447c054e32ecd753e8dd9ac47c0a11e0043f17224c2a54831502ff28e2f095b8f08d67f8804bae1a2deef9e170f8e7c501e8610485a4db7c10033001791f6891e87991f1bb1147b3e26dc9b1e8fbdba6b83feda1e3e3f340e7c18369f665b0655875f65cf4da39aca16408b84852c93529df9d7f53aa50a3b58e2b123de8def5d1f4b80c8cc363800a7e72b4869454e558ad7537c09707a1fba889911e37591069520f5019b61c8eab6b65bf757000f482d72d70e823aeddfa0a1c011aedfa03e612a055889b98bf9d4bfa8c36650291c336e97c9bdaf329c7ed9bdf643e4713ad3fd34b38cbe35a8fdc7a1101f58ccdc58b3833134f654cd06b485af0c987833eeb4d82939d1148f38d21fa4220a227045bec71b93b051299b0f731099e97e7df8679fd5f552783322e5a3e423c49be2af4daee0c6bfcd5cbd04978272edf1cefd496e19867d4bce1d20ea00398ace6c3bc5a8e12751178c87f5c3b01af70ef1c43bb04fd16ee5aa161c0c244e91c746af233e8d3124f063da5a16d8ce924bd6c2c65c73a729c432be613c0432d2a549544ee99133e4df36d5162b4602aa298f3e63d5ded66efb4beea094a435e3ccb20441abdd32c285b4250fd8e19a7270c24e68ff02298071efd19b3cb007bb5cc8db5e31b4bd9e335bdb10eaf878f333029f897f904d9e8ac282d371260983411c4e3d8b724fa8bd19113763aa157e6b8d488e6f81bbfc8f80020fb42f6ad9237fa7cb0c0e45ec1a165338fea8b44690cc6aa22c090d6f6261c05879ce7a7b8874806b1412f0d05b0275c97a5fc16585b0877a76a0a0af51b602c261049a9e858aef7afc6c4b073b261d026a90a6cf26d817b4a55421924994e241c088f0da6424288f53249d9a53326f302f178d00f17272a17cbfda5637f9ae05df68a813390db86d77470c92bc5d28e2094f880c3eeffba11d3492c63b50cb5e614c5893bdac870999d5b25b11c9896ebd29afa8d59a74288cf70cc4c11e8b0dc34e575bcacbfcb34c36bf0f6e0c85d432d6c1637e4276b5f73ca7973ee2faeb99c557518aace7bb648397bfd706be6f5d0dda0204ecb44544c9a09de49bce782fae6357c9a53d8c702dc250f293fd03bbfac107bcc220c5cd9c2e8136c1255d9c909302648dfa54e624f1d32504276c3e4b7627a3f0c1da0f8ad2ace17ed1702cb2ff571e3a2626ca0430a66d11324d583369c846ffa31d6220abf0bd8858dc6435bda64ca3d22465ce0d06de164ec43f7ef16b83653280889697a4dab2c4cad816a9d7127b2af0bb899f593bf7e37e3533de81ff3de50f955a6af0994d4305d9e373132e0df1d17936aacbf012acab3f99b4468558bebbb4652ba55eb4fe4f2c051eafc66a97825297d46ff6c711701a8329aa9a1fcfc60c4df74bd4751c39f8132659cb2ae6e4d57c5393f4d698306ae06f634aeabe01160ea919637174c2b1956e37764fcde0de4b363b2beaf5a2461b94a0b347102e220fe2bccf0091289615285a1a974fc6e02d486358ebed1ec0fb36883482405948cc77ea5df9ea7974ae89467f4b1b0d359bfc5f171391c4bb9b9242bdf6237a331bdde3ae9cd27657807be0ecffe42cf900c0868e89fc6396af6edd3f810d67b976e148c8a74266242053d3a5be6dd616504a9dd689c6007b701927480f59b6325febac89517e803b01614a8f8cb0ab71af2ab386830171cfa80c38020d0c1602ca6a05a03c966d7b00bc17c1d5c6c3fa9b64172fdaba62cbf98443edd984e092138b89d35194675c180e114d107697be04ec5714920dc1906cdecc2201863a32a227452014d04413ba6d9df83da2a0a9e1959325771f2720aa2ceca270f0662649f381426fe9ae4d116aa2186cce77f583e24f9f1ca227c45bdb504b9d3bdbd00b89d7bcd59eccd71e7f50c5970bfdecaeb21ad27c0f031da7dcf3bfdd2625030ba9e92b13e6ebce38c0aa98e1de0263e4a1ac199d26a504613cbdb6873b60c6c9e7eb8799d9f9d7ec5ad40a5fbc3b4523febd8bd2170bda6721ecff530b8203861caca80b731b18e707ecaead8fb1f3fc311497fff64c6f4a3315bcd8f3a55b6f3d9c7f111093e74e0026dcaa59bdc326178a850a4e0dcdaf862d08b77513920c565e7dfb92aec5253b257922df1f662e3ad1a3c2be19aeb1415a3b09801c9a5bc26035f28a4bda53699bc4669e1915b9079ccc18ef11129591a699d9b11a363bb17def7a802e70d688d30250ed02c1493b89b0e940a8f1541a36d90a9fb949e3baf958b0834b1141241a1e488628ea1d7c9079f95bb970ffe63903c8c36ac581d857aaf6b7c38215df6014dc789a8c826d1d4938f536fdad80f394e45b0b7943d568b148ab62d1a8d8b41962dffe1b9e93962f519a513d6250fca00df6bc17c4b1c169f55aeec0d9146e93a9480df20c9fd5909789824bf2039eaaf61bb3ff07ed7c90383d806587ddffeffe35352ebfae40c91a9d425188b2054b29f73ca2691ca69697603c303c6a067b3f1240a62e808113f32ea729cd92cfd5e149ab957c6994ec8c923580521ef069dde8418ad90687d01660c51a9792916c4e9a37800694c666d888304be0dfeeb67fac003068f93ec008bbabe622e62dfdf21d42c21151e4bfa50ad7bb4d3868d8d0cf12eeaa640122890e286a0f25b63286928f699fd68c2450f632717719d97f275704f6d8571503b40b064d57831a1d584677071835bf5853bccda735a42a5ea7b9e2da1afd5b44f4e260c168e80b3662712e92f9040542871a430b01bc031308189690d9444dffb64c54468fc88438f7274ef80e9d4f8916c111d955147cc640c207a3bd106af77ca625edb15e54bf6e94a3ca32e8fd96c99b76606b7b80088af547067881f499a92c7f60a35767ae34c8ce9f1e95122f92815937e5d49f875209ee0a01af8b7ea75f8833e45caeb924cc4bc684971e191866eebe82a79b0ceb824c8b68e3bb4def88183fb27d3e085b34b1e838b168a3f1cbc325c70890d1d3f114a14554fef1c5ce8d1445a42f664536f32c2429b5f4ab5f60b84ce8856e0060a32ace8576928702951cbe13896ac731f2631143adb517d697e12a60cae691496093841d843ebe56d024a5af76106c0558329928837bb885bfdf08d314ebfa76e1ea945a21219a21117e50047a01e7899d9d44c522dd6bed55a398c35e9bc57ec770b0f8659f167a4147efe0cb6bb090108315dd8fdbaceb6c2a45c3960c24a510df88ebb70e8f6ece86c5e1a908fb41aad95f84162bd0b7dd9b181b81c24137b8286dda21455cea3dda2baf4feb3d3d6395de9760b68477241b61554de07f27543fa29a13e83c20ced23a48e506314e5186411b31a4e2b2768f7a939d945b601d0b59c413a0493fac79cf93db5a030af7de6b0945e8f112d47e8b164bb1dde1a176984ed92246579df6a077af5841eef419e4fdb6f0d7255e76bf9840ef4415e7c813890c2554602f84dbd6c88c7182c5d56c4ae419bd27c02079dbd35e08f8dddcba1e5037628ab96c6b0b6e6b1ff81e7ebd3144d12049e39da95f70007ff7de5a7ab6d5e9a0f9a476cb97ab5a3132391eb1f9e1317f96e2903f1f93fb831506d714e42bf250f70d15f0a9cee9a9a60e525410d4b5c93bd31bac2c04a8a3f67ff1b22010cd8d19764cb7cf28a0577039a5c5bef6d0ed19054608965b5f1d3a0ad0056e58ba4c84f7f2a241dab0bdda9f61e0a9815e1e1ed001a2a592b250cf0a02fc9eea572338bb6d71bafe4bdfc699318fc867fc5e498c64d8d03761de1aad737e1a156b1ad6370112d65ba9b8ab87cf5500dcce445b163e01f06b30002f3b663be6863a7d01382794412b2d304fbe910659256eedc60f9c56b79131824be6bc447b96ff43967b7657894ec9a5d97e0d71d997a04441cfc368ab7dc31edbe29b040042d98edc7603d2fc0ffa2cd5c44e92a77de43c30a4f2073ea690c56d7c38717b99519c905cff55018b55f3506b0fb0896456370a26a72b9c822e23d21532f28d4ab7ad2c1342faeea27c9d9347ec27cad156b375ea870d9268555f4d3870f0bce7d2e1ce2b0b5401a057ca502b374301f40ebd93701a6b7dc04493f8ed3d9a711c78f1babf082fa071bdee39d37dda502f7512b343cb00e632af54cc880cc9de4ed8621c2db9a32d3bd56775f044a092d42acca2e6e217a88206ff38d0c3b43576207052d01f21cd0d785bab6b0ea43579b1fa72015cb38ee5db23b40f6b338ddee3de446bc88c6939d4c177d5d8eae2c7e4c097762a6366fbdcc11a4a72852b33d709224ddf4e6e35ff6f222db59fde5e1cc458e1517b031f3f9638f25aad2821f628d6de2be05bdee6fb4594eedead62a8a6e187e013d9710fae5ee9936042472512dd9ab6b4d24fa633bfcc80b5cd32a181827638c0dc8131b0b4e225d704aaa39fde0095cb27394aa9aa39ff786d1ce3bc643bab3a9768526dff838d7c1fa023ed30aeb2561a65c67d024236be25e9e82df8ada7de802a3567a4f3c7cee08ed713f83eae7b525977eaaf2f2bb75adcca4c25d3d167b16217e1fabf4d9caffe3b5f0ab3207c8285e27f0a0e782d7a01caeb6776304d6c7987d80449cce03feaa01e1ff92befc26c9e7596e96d46d026ff66dd1bcb485acf348f8784a7e51cf70d68a93785bbde645754cd2c1aa3300c701d6b17f66d54afb302e06f025566690c46b6a4dc7cc88308eea51013044517d8a2574de28e4801b1677dcebcc25e823339965af1df51910cb9ef049121c641614057f39a1419a9142c71020bba769ab2b5a7570cd07a1d2e0cc26f92225d9be39705f9ffb6542a1c862520e7df003bd484cadd7a48be68da271bcbfc77a10c78779dda266ed402ad4e5c9d8555b0a271d8412e9ab667d48b0700daa7fee665c6aa50245c95a3d484dbe57e3c28de83edf81c3850ee5a4e1ec80f798c11f8348e3617aee32b1d98163f87bcda0939502f5cffb37061abee4154f30836b27bdd2306dba40db1f2d55f3d10c1578ce217f38a58771982587730404ad0eb2903327f6be451a4509931d8e5808ce150f2a07708adaa7b71939387f22d593c1c43d96b1341fe05e7f70f437e4063107bca1d047238b3b201e7fa48f4b1012fed5b1ecf24bda98506247569894b3c2b99d8ba13c875a9e7f9ff7ec1cb1d4d31e0809cb89225dbb13a1331f52f41a924060f87165b54527ef236c6b1c5851917d9c7498afd21f42a67c4a2911baae605b646dcbf58554b304737650c238ad181e25934293f72deba9437fa855adc55bcb27f21c1a923c52763f0c000fc0feac1af949aee4c3082ca5dcf53db14e68cb87b99c15663f2d76ae5ea71e21cb586b3ca58490ab7fd6c8044029be984bd272d9f72b0fd905cfbc054db74da419d9e2192f8bb6d4019d9d3093b183abf99229dc3adcbebb3cc7adafec7cd03b4f23c8bbec8e712ea79a1fb692f7d1ba32518647b2179368782e7d0e591548aa3e6d5a3faf348e57a0e406db9f88a0542324348830e7c9330be4b88f6a92eefdd783061173d729f5284d36016446ed139ef8d86e6afbc167b40b7bd0922a161f8e89713264526ef0ac035a516b3e3584a5b0fba6a1dbb31796f8bbfb417ffaf19ebe82d6b31d543fd676a9d1717c50b3a83e822a35709666f051b35a4d3e60026d277436b26d55d9acfa4c1f81444d02baf4707726ae5da69aadf104cfed3b94e06dd0b1e3c4ed01cdbb42bac81ef44ae076cf57b28c04fa98aa4e1a9b75fe89c169242d82f1f4961dc0070a022e62bf29d7b6ca99cf4570f1159c257375b8b77b2177d2fb2a341f16ea399e6fb4f9743c33116bbd332c801b8f8ddd7a810b90af4e9f31c9098007ef0ab5a5d673b2c4884aad93a88a01d65873796f000f5984a652a78fd0dd4e0fcf28dd880f957d2bd3fca742005f3e946d5b0b2d12b90757ccafa798e2a7eb7dccc5b66547cd01898363b4c4714e753632448b5cb7d0ffb096298849455a19de5d82c13f0f56168a31d3852acf13f707a5693fd51da023359096deea7ac22486a2c80148342dda32b3fb7eff5646dfc033fceabbefffcbdf6e60ff3228163baf855d7b8725fe65fc77d18432911c559c3aed4401119f56d646514136d7ff30acbb55863794da90073f0bdb29abb8066a5a3eae15beb19d2be92f317a400dbfcca81d90906136372da14234564d92d37daef2746a27ae1b504288d9152e5531b39cc89fb461677191370c2434ee3b7724592eedd5e0c70214daf2205b06f81f08667f970860b8db6749c5cfd2e74b9b4a8b1fca456fb1aeeb05dfc9bf3724684a6c0d58d7edda2ea4ccd8b62d819aa826e86c32f33832e9ce4e235ef1429a5b143ade9280021d11b88aedc756d8606c675c84e41cf182489b957ea9f8136a525fca306dd1dd0431dee173456d3fd05b84c1edc7ca9399bab0fd0d4e2d912966c17b4347854ac9b5959f1eb629eb19a1c9ba83ecc917d018dce278fe299c61fdab2814ca2d75a8e761e78151ea513a0bf280448da08501a9297d7b720da4f77af62c8e8431a7f401a26d3f9a1203c4da280558fab0e91ef4bdc64095662cc88431285adf467db976a0f294b96d7631ba69c8eb6405fe74fccd117a9362e534d7de09aedbb5a587b95af2334c167fc1a94ee2648365abfafd2decaf9ca1b65c0d16db86cfeb48ded7af494d449bbae3a155f14cfc807f1b8b1669484ac2324c09791dd032be6a228b18edc3823f5bf2dbb6eba357417e813f2b528e3864fc6c273bb235f0a99b0f03b9b9522793be662a667517dd2a99043b885725a43165b7fb87e451793f2b924661dc2ad7ca539236ab2b92edfe0385177390db953fe1fda83728eeeb7d3b04ab00c0b0560263a5d0805782b0c7dd765000f9b99817a83ef16d83dfcd67cb86bdc2f77d53358d583e2049f7391ee4f0810c3fbef3e14b5c306acdb5d0a328c2a8ee4cc9ddf2b5700f2129cddf077018cc20838f5f7f41cf806322610e863ed1c2e529e5b4444a74eaa4c77015de989cb413c58414535a6fad169248d58d2ffd716e777a6fc19d0474771da229e1a87489e922edfc4e19abe1f491bdb2b51736fe06951f5b09664138935b5495f78590455398d888bd3e9ea2561b35d47e0a2d33b310163f6c3d484f239459847a8dc19b58bc7abeb1c32e6b85f192380efdea79843b1ac3348cea2c06c563cd152933a828f158e2180ec02bdcbc578b50ca09b20665651660584c4dae017670504cbc072dade292c461e14ee57dcd672697a46dfec372b12c3855342efdce46c8cf99e267d59703f0e5462f241aa86af2e12a4355f7cbcb91c5cb95f75ab974dcbb1c11bd67e4f7314e22fadf3bbddb58c59161c53eee6335db42f2ebcbb08c84cc2fc104073b315fd7a3a426325c2c8bd508c69326cb32c623550344ce658790c28b84a14bcae953717e6165913a4f56ad8f699187bef37b234e204de1aa110bd24797ffdb9d0f637029b113e00442cc606eff9151c4b5fe8aa08824177469ebb6315c7e49e8fa16edf5227bb5e85e2cdeabc5f762b15e2da6d78bdc2b81e47b4de0f509fc65f6176b76963ebdb87175cd15132a48688a22f0d6fc5190426594350fe4f927a2b67054e9339ed622d62809dfb93a4cfa72d376969c6d6f1d727b9ea0f4e5669c61208a23396b797f454c7f3f0e593d54f3cdfec0c534c0594d6a89209e4e5ca99ca926dc7a0463d4267c20bef332a52aea93bad9a6ec8ee3ad278a32c4ca90b3bbd99ec1ffb53d3a2f9fb0ece4369e3ad0f07b04ee747a580db46db4f881d3930d0717892547252748072115955e719c2cf6889cbcb2b53f4e1138849025895c26cfebe720bb21809c69c63c053621b9d3fc3d12dadd6f37498c6b2709bda9d7c2231b231b828b6b766830963db3b870e15b6c70ee82a019a413a704b2c9e4e2dd905198577173b5822acc60ae67ba948af8e8cbddb1accbfd7d24a80ec8160861c6b28f68e3674d563e764c85530ebd43d2832d654823e0bea03ee02c4c8f48da166c3a8e18a5a25a194739c0911e9ebc08addfec708252b8ce037394f3327aca890ecacb801b3168682f5894901d2064bd8bf562f1bd5cac178be9e522f74220f97a6ac942c668941b23854e1c1d598bd31cd5de758a6471c49bb62e475ae67e752d6e30bdd42d7e85d7f086fde536bef1260a8aa59827b3a51f1bf8c024021cd98060b380a37d7c84e27417e121ebbfeb2d39747ba5b5d28c0d7b6d6527443ed53499e7a0bbab7b75c402d1b905d37b83f8e1e9f131928a6ed2adac6c0dd1219e7b45ca3bb53c2eaa13273e9014cc365687f3a3417ac8a776e772158532121d36cd60cc22add87eb8ff5ce6611cd875621a4796f880e6735167216294d8eb7713e0a96ae8fc055442f17bf61c1ee7df17bbd5393a39d0b75b23c474b5b1859e3485b0c5927dc12e1cf921105d79526746de7d1fd649e776b0ae688cf08abedd95c15b1a839427daa0f933adafccd3c40c1750974f930cccd1066e6bc561628b749089b346d2885a725d1ecb4510ae302cc4adc950717c969749d963e85cfcaf702e1d24bb9837dd03462fe61201b339a81f860947d496a1e9fe8c6a4e5bc1419ef8f0dab31ea730928bf647c100604ddca84a5273520aeb8013f2b6fe29d1ac059845e40a4fb97c1bc027ce2205a79b1dc4870d88d9ef61644b54f1fe2270e875c0b5ce7bcc40f2cec503e3f7a4f87c5f09e21aba082b25a5ae73626d140517535722080dca3a92ca3d7a2df61efdf18eb9b9611f5775124f9507b651f2191bb354df4dcda68f9049b5c1a8bf86e8211a3d9b5c396b83baa10bb040dabb18621408d5aa4161ba2b04a02ba9d864b99cda2d5f0d8bded8c67c94a2ed6d1739de7cf0721423d2a32d811c6a2d889193e0d9caa2760222702ae12cc39619fdb63b9a9f9bff7a91a52fbc3c6381409de7d3947cc8563c8255813b6efa88b9f0974fbb9df807de7da263057b2be914c51627455f99b60cc045ca8603df81e1f5709b965c71f5fa92bda6cfb81ffa2815916ee9614b71d038a027a152b5aca4e1276e4b75c133e6b4f2425b9229cb9ecb524c4db758fe113cc51cc0bed94574e9f306c4284daf7c22c7934ded9bb206158842fdf4d754a9dd0f098ee169e210cfd57f8dd79885795a0eab251f1d9a231c93b88a5a029e85d21c25e82705b2f25846c252579558acf0182b16979adf644a5cf0e0d25672afb7cd27d6bde7aaa4a0621fe1927251308c19122d37a28c2951578496660684f1fd9615d97778235b7f6c76a5e952cd677fb422509094539f19f80e223781d9af5dfb719534ff23bf5cc4fc4c25c24bd92826cad5940105f16c0f02c0a90fd4ac4b18e3ccf4a95816fbedec776fd489c8b77ae7a25177de54012f8cd4c73e5f974db940b1bba9555bd12495bd9ce7bcd1800ac95b378ab5dff64c4f558b273305283f3e3441acf99d5f8a71b25b8b0ba7e7143828d7a46d2090ab95c6553814e31f0e368d70283bccc161837f94fc5a78a2ccfeff8e109a7f6c409f5a2f00c904248685efaa5cd8d15c7e676d2cd438a1cb0f1d985171a30f4cb9390633d1b806230dcd64cf730c918706f8554440e22c0aa3368fa52338b4ab35395c4fc560a2273967cface03d11d46e440fc82904ee25a4dd8b65c416097d7e9f4b09816fd2cc731fd3ac2fa726b85c650c565b490d342ed7924f8710228a234da51fa099cdf0a74408a4f789ae935f5ff27f4767e5b5841f1056eaad3ba4c4f6313a78666803bed441cc69a388455d4187c93bf0a692a11256c4a8c75c8e9b40d2820ebeff9190f9eb824ed50bef9b8c4e0ee3eb37be76940283ada0af5068d887bae7e4d05a63c61c1b1d65eea9793ccae6d689bedcc6ece91fff1601e7f189462f1567b3b6ed4e39e48363b0789cf72e3a5b2b2374b45a45f43f151d5c52610bb5a552aaf06784e5bca64fdddfea6751b9903433c95ec45e135940044a08029a53cc393ba1826a82f6925e619a46038376c98827513666259e24618a5a3bf3cf61b5194ea4e3d1a607636f9ddac48ae0955837022d7667d6fa5c40da0656be9fc518c4f7ef1992e4cb10ece97c9cb18ce65f913e3c7cd099548d3f79a5ddd927060d1134d43219a8610307175d11321ed05e63681e8c3f59c3f8dcffe91833b4c0e22cff220562a5fae49be03ca4879579719b2c3a61155bdd7dd2d7ada5bea947ee153afd1817a691294e6dd8c8d52b0947277ac6bd83a4c931150ced5422d379d74daec50e2a39beb526eab179b3c75bb5df3b8040745348b15866370d282cee4fc765aad8c7003883d9865a008bfa9138450506d8d36148902a965e221b6797c6cc4d262aef3989a1a9c954d492a053416cba8b0e5c8419e8985199db0ae56fa0a3c252f413b01479d538237209189fe7f358cab2bad351864c4c8a1f52c9eff937f6282bac68944ba24c2bf82990ff2173019d65e32b369f0cee5fc9f919103b9a51307042a0313050fb8068f1c81808f78fdce33334060cbfcb9f1df2977f9ad98bb87ee83f05ffe57dcc7ff8a7ff74aaa13ff7bff003fb43aba1645b968aacab5b3ff126f6e1a879e25bf64dc1ab5e7f02fd816fb4bd006afd8965cae11d9416c0e511fc5986840ff5ebfee65fcbfdd30bf44e908cbd819600f8f5a13a34861f4a0a5125c92336521ae5fcb20ca69784483eeadc3e99594fbb423ef42abd0deffa8f0986c6ae00abd56deb520adebfdb7f0a3097decafe3d55c3b6c54a6a09a2ac6b18c07be47d0aa08918c0e85270a18d023b35f19c2b2d677ff5688a4ff17fea77b28fbda55621b412add1a3f81f67e6f5a4dba76551e97afc9ffa65ba0e5442934422e8e777f11b0a48c0ca62ed3ac9abd9edbd2f9197def903f79d788e2a7d48151480852210901ecdec9fcff993de62ad0d35abd0d3aa7957ee9aafdcf41336024d4abce3048bc8fa9de1179a7ac5e648fa30fdd9ef297bbe6ff41b5ce405ef07b52aa0c8b28bd8d8d0c4170e68aa7f2c0f7d612195f2aad352a219b867e91fc95abb165aa3f9db0fd0e9be5c56231399f3f3adfd2fc42d502c3ea7ac3bca2a1aaa482179c7d85c758290f778b9ac5099a82c0c2c08816872509dd9443050ca1e1fd95a3b28a11074132cc0f41c4b90aa79592980b337b00ce01b5af1fa3b22b74f70a982379bc05be5eff40cf9412cea984f9f7247560cdb09f4b18e574126e782248f6717ef0055471ae0230b64d190077fe8263299cfa0dde236147d06a6062741e7e8dca89f6a8ffc650c49b7378e1ec72ae839ef91523af4a82b0ce28121b65dfaff6b403ba6a9b0eebf17cfcc73f156ceb106955300a01065c91dce6ad643f5a028e7c95c35e8a0e8d1d8b4bb3625502c8cb010081a6afe1e44b3ec451f715df98d77da9a892fa24730261e9b94512292882e5e7ed5248e851a6f8e83b31a58b71a404d1a2a00fb0f3fabdfe4d9624872bef77bd7a2381e3c2b1b21acfc7a7a654520dc05c77498879c066156e2a0351b962269e17d6fe95552b4d29f79ff156becc124648f077a8eaacc70a6728aa1d3e7e6fb4ddaa08b8908da7095c1b3b81c77b606c289a777807249ffcd730e5de03f22b5de4eaf7913458a3a9539210e9b906bd9e516740c043e8e3c95396f9ca0e2340ec742ee82af3768d224065c83e80d9a43772aa03f390091600037d2d6e8d54d5e7a335dd05e80958b93d607cb7024f81e39bb19de4c4bb5a14b0b042e1a48a601676e3fcb4acf24d37e8aed768b1abb0ca4f7550a7b5ec767f2541694e90af22928af25e4cf3dc5835f79b4f2c07e9d6186dc3d103616846d07f300327ecbdf399ded86248ff726da418b00b06dfda3679efd01d9967d0342f7c2e3d6e5985c1cc8a7741448d729357ae45db02d4d6b26d98aa176adb2e59ea59ef69e547fc0a4346665a454254649abd779e460b321533682f387e0090cb6ced93439344bceb103d6d484329c70e14db9af1fd4b50496a51a05a64e3de54c01e646494c2a192d518cfb3db687da811a9ffe4d42030166117c248564e17ae3f93ea64f04755356c46c440de306e135bf455cfe6b71152fc1496fd73fb7e31e6aaf093f639c00492a29f64cc18ea4d4c6ebc8dcc58910e7e24a8feebe410efe4f2c68b709c61f72a5baae7c6c1d1eb487271db4d92043adec45fe1313a2796418b1bcc4bf98dab0d5de5eb7b94d1b2150fc025de8283debdbb4e64bdfc307009977f7ff590a8e0252f8a20f4cdfcfc0654359ab215d541e55fc73acfdeadd5a2734f5c2416312a5879bbb14fe75c867112f4e8d0aa6b0a43205b88da408d90ad86ead51f1609c86beb1af8a5e63f6e20ee8f5a68a047ba1e8b57274045491d43ec3e1505bc159057a0be12c43e0f18b7b5dd00f00b6fd82f477894c388f64cc939f18f030dd24d8e7d31be99413f233ad40ce600bee0819da0f13842f685290aaefd3acb3e8ce3949a4550b8690c8013aa683c9c11ef5bb8ffc8c4d82cdc29480d16a750663ea816772f4dc656961ca7500970e8f808ff81863dc3077b1114bdbf024eb9aea9200314d6cf09f6ea04e8ff5e344f582a24bc3d7e69a38c2fabc57ea6832a72f764472323efe72881add238b5ed3c5705648448c7a873e98571e3c84f59b50752a93fb810ebd4dfd1cd01e0f000d764a0006c305e08c732b6ffe2969d3c27d43229e36a338b9937c7a642ca476d40cee9551abe77863794ea273c31b41e422af68d36a3e7ae10031c613a806857442be1036cbd2b310032ca8614c380f59a259f81f5e459c0991cfd3abab1729a646592e60ec5713835aba15a0ee1486c6116f08b7a7d55df63b72ec328c617bb98a851c593be146caf91679baf8c801b770345a1f91b4a0ef232978dc51742e5e98863010dd035fdbe91daa3886c5238915098286a668c45c5b78d10ce8bf08a3b0e073bb57fe447d82b50240c4130472a2158e06dc69ae1a8b260ab947a9ed9687777e71c4bae6db32671a5650b8cdb588cc0885d625e4bb41e64904c8850c3978bb473b89413a47fff391706c62067a5a724fe6bb9197e182f0a6bf9f10cefe184fcdf8fb3a4a7ad62de69e28b3addb973bfe4af87ec83de0bd499802e912ff27044fa0cb5978d0a2c635cd28d42960ae42af9fc07175ef54f495b5ac269a820ebdf42083be7a927b627d5af131d2b9103390bb9e5a13f9f01a5e0d1450a0a217b63f87aa93cab062ce00bdf0614e353f01d4fa68b08e7dca198be9338ce53a45923865a477fdb9537a01bc470dec62e0a711b71e0dd70d1459fc95a8a2b4b1582d80a20b25e4eca3a9cb4a907edb3e0bf35d02857883611e55b357ff1d2d9673f7e6d4f8f85328fddd88a259a84803e13e8784506f3fb55685b88a11bba27de14cf939d2fcb50f6c28ce83ede48d26428aa5d35b1c24e69101aee2239781c7e3257ee1176135dd50df5075b130a093410a4349d0bec87c1e46b20805f1058755d9b6a138abce87691ebb0ca05f0e6af6fef4f40783e8b2093b804bc6d75bf31eb0569a45e2f526e71d15e3f59b91f36bb135eae3f8a11ec4dfad2b9207b486f03e26c8b06f88cce8fcf318d0513c469c801e0c324da7cbe52ebacce48d3dbe82de84b9cb9d142533204c920aaef94b4d1378be3d5660f0174f2c764ebc5591925f978948d47661b209a521cb6b0e56a869d80f097317ed49e6c2bd95826ea73cdbcc683ee7659eb6cb01150067b1bcd2552d57c1b370fa07d9ae32710166e7764f91abdf9350cb46c7ae1e6e0db6b3d51d325f4e25df24a4f1506e37b1b9b328dc7bc242261712e82ff812c1ba06ec67b3c9e96504ba94c7f0820413e6b9952542641d830114ad4d70d366600a90f5bc4164a571cd29d06e9c7bd201fafe98777d167d2e2a75fdf41a6a8b0625e103baf2a9e5ab97500c88cbb7ac2874451e41a993948f8626ea3d038309cd5d02f10bf93acbfa3e94ddbdf73d033108b01e13be983e380841f58c31abe69b3524f312cbe4cc112943241c3d570df385f4274292173f34652d9326fceec374e4721df68126f3940ffb2e681f20329b9011c714b3dd07cb52a75709cf68bdd5f3970026e02582a53c9321dc2605d3b7bc2bcf5bb181f5dff1c29c082cd95b16d1eba271eab0b099b2f42a5ffc53bc39217f08e88e6990febabbb2323352199879d6b3f023447b286f2d26baeae14910448c8f8c57049c3d343185698c262ae67192425964155fa82208f4efb9c5b179c98c6ee9ad2e2cc68f2b5daaff226b719c56ecabaf064b02fb0a196730b267db478243534438ca1f0fc8f459381a0f080dcc9e5b975372a059f4001c9d9941eb39ca5db98607ee6f49ceaa0c12846b03f1e9aeb6e1d070661e2a4e939462d1110fd6bf0af2351f02f0bc30ccfe5c06b74877ceec3177395bd1a42eccc154f7888cf8c5a78488296cbf4953bf039b5e9545c1403501891343d0a07e91da0149b1274ae018528feedde7b748288921154e406ac877d4084bce9aedb647f8d4f87f944489165d46f763c12127b00ee1f235fa706493f7ad5cf466a3a3f23275df673d4edbc889819bd5b16338106950513d40ea731a3369cca8e018f85e95419aabe04b8f952f577ea3277322f3ec58fbd269acd1552ed82b0f1617df17dfebc1862870064bffa5d22208a975fcd5813fa4627fc5b4461be1e9c15f5fd5590f65748ce7326b6bddf6887511d1a8c719aaa8448c405f416b6f53746c4dbac4a394e8ba6cfcd37c1a20aba9f9352ce396f5ae615d5dd7c170fbc39043b973c7d0b8023afa1268528858a2a1937e4ced3083efc5003e97fc228e1c4f2b91f22fc23f41738d2431c5fe6aec632cd10a77ea92d9e7cf8d048cc059b83c03aa779d0999ce8ac325e57948d97de52f3c809cfb91c97224b8bc6297102d68761636f146be9a2caebe1ac711ed30bdc2b188f5b01bbd2aea8cf3d4714da611e15b59b6f845e47e7c8422f5d82b724efb4b92516d5263b08aa04cfd86c0a21a62e10631abff9832c25e5fce89e80488e6a6a01b058630eae825fa1921246ee5d821cee3c78cd27b89c2c78bcf3a4f73ac4489969e0f586775844e6fe6b3f6acfa6a74056bb5b74f78986aee8d2e63342632f89e1efc7089587b0df8b6759e68905d82b81d63aba8c6289af77a7f072b328a6e430acbc76b75f7b723a6291b51e230701e4a2994f9609a400f17d4af1b59c61e954b4fd630aafaa32d3068abc1a06e642058e4eb70bafa33249a4899a57d9ca1056588bb253b50894696a4a86e5ad185d7b553bf23185e907a6bec864a9d97bb98b7fe8572755b926afad9d51c98940b92d7344400d71df509ade6cd45815d76757b0725cacfdddde333ddd0822a927854ee9702c7b421b4f3ea4ed65ed4b22e8d119dc8846ab9944a4c3e0ae7d43546db41c66c676de0c3cbeda775fd26c9b9ab5c95c64b76bd6f8fdcb765e0b9865ab57d5a4c77c2619f366ea07fd97b99057a518fc5f898207d6865dd148ee1a2685e194e7e001ec28a66c33c3310e30952e1b44ca28de406a2414f74c6cd3f897f837a501ac9618ebcc295f85c665cc11e8d84259d6ba84102078b931d05bb31567178ea6601723087c8618c5d37e41f5b081ad46b251ac950bebf07b912b80f99013445a3a23232f7fd96b5b01b734627cb97e24fe7ea982b7760ff1d3318d003195ce7076f95dbcb11be34e6fdcd9de059b6b30fb6bd4ec31b6055a7f744cec5a386598ba3ad7b18f143cc523a35d834d9088038ac873ab429a70683840ab36b5b15ae4e2afa041252a2e85061edf70d618d853467ec68fabd4ba583b4657f3de6bdb9d9ccb8cac8718082cae2ac3ecf4991b401e3c0886d155b2c5f6fbaf153b8543f59164a9a1dfc51d2a88492705fd4cff6161d835daecc2a257ab9ab372d43ba4e4b7a3c3885016a426eefaf9c0146945f518cc0673c236b766ec941427d1bbcc46f835abc23a0c37c6ace0f6d484d08d3aa2694d049ea5e8d09908ccc1771dd3f4c724c0a0eaf30eddcb95e558977c469118fd6d44233592b0fbdfd08ac57731e9eb8355905cdb431479fbed93053cdbce8d7d951e93fb3c2b2640e3ff14510bc821b98f40695ad3e91ced789206909256aa1b182cb115a9d795ee626d51b0cc515acce1588eea29ac7ba69402c6af0200ceb72498071c3ee14bb97d26a2a081b969d14707b0f5d670905c1e2b8197aa87d43c13a78d309762e137d07f3930b406e366dbb56082195d2766b2a3d91c3bd995a47760df67b9a09de3e7cd18cc4c298850fe648a2016e09ab1f4ac57866105de2bb242a4ac61cb475ac60c8d415938fe224d88d8ccd015ce730cb9010d8a20ff4b44aabfa35192cdd5f7c5783cab51cbf56a3c29f15ffc230fa3769acc6c29122fc2cdd23a01090960781a203533a2e1bd4a56881cc05e146fa99847d7bb391e1c8b90be1e1e7cc7833f8a7e60780b23756b3846fcda5523b70dc10007ef162dfd04728b4f283fa8378f19444b53891edf9411f5be7b75828b56bce5985d28bed0dec826fb74b022ef92782832766968ddef543c33e2135aa1a33a4adc81f0e49119509118c285f92a337a5358ca78f49b0e0a43ad3313ca6768f2f9b260046530ec0dbd4938a268dc307018d686eed54b984549c19436ba6a916084d3a208ddffddcba14d831629321d5d52864ea4e481261e06947154abd4d6c8ed73c0f15a96cc3866f16f1ec3885eb6f51b845dcb8348dc1ffca921a80c28d71fee573e8007ad61a210038850b06a6614c2247924ed8482c480c8ea7bda1dc205cd11705c7c99da6860fb969bf4828e1d334fb19b28afb42dfc30686e3a545da620ae4066d266793e10e695a791c58ac998fa69575763ce5121a7adcdb3abab764829c8b81648e52325c2566873a06441ba7d4630cc0434f8f07e59bafe0824df81cae55105986843e4cb85aaad8f03698ac6a4bab5f6c57977f536a6ef03c7e0dc5b55f49d9aa1264624af1df2fc3d26038e0b371adf05315c9743cf0b227325f053dee1fcfa2af0a9ad5a0cf9e3ada3b4103324a2980925c0de8b480f7ab64a7918aec796e19ae2bb5764e8ca3e326e96335d2da8eb3fc78dc80f34f644e2609f6dada117f0aebde8c40e51ab511d03e10d47ec838c37a6694b7e50c9e614ed9e85bdd0f45825487e4c1a8bbec322af9810e00c2313730256795d1862ce65a456106c6999f84514c79c8d2da7c937a8e495b7c330075ea5fafc94113841f210f3ecc210787a2bc3d1ab12dd2bd57d0d8446778a8a1aaec2b96d8e80b3ee5a20a9d30a9b29e25dc969d0d0f017cf44505f190106213a4d1436ca2a565936fca34ab836d8a783b272fafb182800e451417a1b8aba395e0546a427f81cdc67c26b22ea64ca921129925365f456f532f1b9c3ecfd0e84031e18077bb5b129997b18b3b1f593b1294085114eee1ad1083bc440a8f9eda243b89f50e63e9420ed5addd50a642f77383e669c3ef40e39d0e91a85d23e04a9d6211ed9972442cc2632be785ca7d056dd089349e51392d9098fa2a63b96c61f14577bf084e53a14ed7ab59e1490457b2a8e8e9ab32cb2548567caf1099e7ff9a45d013f9e4afefa2c7e5b0ca389c96523c4d1a2dd058b7e6798bd2bfb35cd2a973b539e10365e86d34190ceaef26d56106b440d60d222e87391b74819e4002093594dd2899cc3b19b78d714a6be98af333820ab609355cff7684ce6502f5c057303f4ce4d03dc3c5ec2de9ba7c931288c0483e2f2184eec891864223dbf639aff238ee28a1f1815a3e956d33b8b52599052635652f591c41af20baa505f8e012a3641c22d83e1a85eaf7541a17ffa82da3cf78c2f376cc03bc59e68353fe22f4d1251f00970c10258c47f700f66c0a266eef7abb1321428c05f9183ddc4ff1e447f51286e0b314f4226ac5843749365a55798efe1b1acb471f59190376e1e11076cef12dfea12ef9bec2ff178520e83e229790757d29b79eed7999d971b1567c1b2e3a3ea574224f9461e938976c36dac66ce37dc902d58a6d75fe49f9819d8b9c734e4ce6d34890b11c02983a7110871b006e5ccb6ac8b79208d5ef95bf59863d1f3aecc1221aa295a8ed18d422a6f2ace9bb34b9014348501e2ad53d762d09162fda81cd5f6faa04be9224328a8028073cc043e244cfafd720461ef15a708b4c917f947bd9d6963f023281808b799e995b20b110975433e88252208deb20c34a664967e450d639cc3a1edbff64db60fe589931652fcb50e8a9356ce2a0518a86a49afda096e13c48bad2478942d6c334b0251c2f06d4e6f15e6af7cc544f434a85247f09241537a8aff211a4931babb98e07c57eaf11b476a22f4f84a3a60f210c86cfb505e7df1034b9b1aac5aa1b01bb4625e378cc8f3a9112a2d7ba59368bd318b6696499a9710a0b504bc61e057285de73c2dd0f5749a0be85cc0e278b4e3eec9012074824dc8d872be43162529b8f32946d38d80817f8e210a257e54cb446debd1ed36011c0317632506528ae8c2503ef45679a8086caaded409e79adadeb2da059cb8311896d7888666281f5c4948827e6abc00bf292b89fa5262ae2b399dd1a24b9b9d63db769187995f27a555b0923cabcc6a79f3fe3c57d517032f9cba288f51f6d4e332d46b99e638b7e30dc20c3f39c941d14f665b861d2dd55e40566e728e40d7a8d972c400a735fe08d75de9d8697dff71942ecc2bbc8c613e9443c0490b4d182256d0467f334a9d2513331a232575a1299bba6e119ce8359a069191bb54cc26d8f44580ecd37804213e5e50a84979dfacc6cf4d5283a8dcc9651beb4f3a9ac4a6ecbf058250cae5b5595984e0f28e4d8a87615f32296ad17f29245f0191609ca139cbb2dbd10b3c47a71abd342a0fc31fa44ada569ee6263aeb01d224ca8daa27007edb0bc0c5fb37513411e3c388ccc13fea00e3e51dd5b95d5536d8468e6628728e91d56892eca5a4152c2be77326ff05ce9efe3bb5a539e269ba460d129210aab36a8883ecf3bc558867f520e1103955489e4c61bffc5ea0f3397e9ab50df25ae2242edb476392662faa9f29b722a619dc26f5db32b13fc2f60ff13e1551ff2c0ae45de80c27f3fab2df2e5a38713fcca24104c003d0e37ac3af114eab60ecd367e2d49f5c303ab31828f85c18c94c6294fd7649ff8e6cc3accaf39ac40b3532a060cdd2cbbe190f9dfdd3d802198c09677b3cfed6a3936505a22534a45cdbad9b61c10e67387d22e21b700c1c3011387b84a9f2478b20314ddfdc8103a0bda64f42b9b1843cc7158a97904512e3b4488170a5ff3760a6c9a72aa8661d6fc091f1086090485a3b12a187eebe0ac341c5afc6e3cc4588d39e3447bd03827b79a447d798a82e72622ddf08d60556593329e590a1662a7786005384c272fca94ebfb889a5dc0c9f44b734f15dcc34c315f109083b1fdf35e35202e128e1c00fd77be7ef283d92f983db08023b62611e7ad7714b178ff8b807d00818e85a25587c5a81d67073bc908ee73b1391654fdbf5fd02ac02bd64a9c7ac00b8b345638dd28061c606b22c46ca096d47982be8af003d040c8118114fa76af17fe0bf7652aea7445d983672bdffdc38546234693025f5323d9852aaa7f45f3f31641c9f516c48aa0cae6cd0895d6537779701fa527752369363690447aba2b0dd3db03387de21b6171bbae071c8ff972f22b820339b516c97d2a9cceb42f3dfe4b46e3a3b3b43cb36032aa56531396a6cf66d5062216717a235ee4663e3774a319d96639314e866940cc061e90369748c45c70783a6ef2984ab40fd41fb81338105ffa95cfe738e0ea2af287b497a717ea0973446a917113a739dddd241fc64aa8c84bc52fc87b2c1ffa82a4deb3181eb7a1d172473629d55bf2bd585800080797b62492e3b0fc942cf6bf8b4e38e1b9d7732e6325db16db0d261717c3947da1be505cafe6965d3f41a1cb657d1ae7cc6897136a3e61aae4c057a53dffb38979402950ad81832f38bc2b1a418e6463d9d5fd00217ec2980b7997232b6c05752d30799f8703e2620460f9e1b943b171c3640ba7e098a3ec54661e274e404ab746de31e13931b10b66dcd981fadabfc292accc12edbee4658a9bef1043d30bae220e869c82a66ae56198a53e5a0edecf4a21dfd0c4ee90679a71bc7a76472476b4da276eea5720d90b636904e4e5b24c8586d4e90ea2c199a365b4e0d35b685f12a91bc2fef13724e14ecb73fb230eecd077cdd12ffc1c0c33268bca502526126ce6e7cfd9f8bcac5307a641b6c67896898a021465409322f4294d2a0cdeced58ffdc6fcc20c827d715cc0b855a2f928e142ba28a829b5482e725fcec421ddcc64ea6af50b8d6d03842d43f66b9a892b868bcf6fc29126922c2acd740fac26531ccfdee374ca7d59c140fe162745e01e75293a2219b0c18ce68a18a15e20ea1a5ea94916c3472b65d4eaa2fe8418d2a0944002bd08fc30fe8b576c4a0cdf41f0da85da29314e35262f6da54e70f9079371e375d5aa0a21ecd1d01b55f2d80dfdb59e4b380f6e46e87ce81a5d75129cd2383544edde2b843fc4afbad16c09811505df769dd90d255636d54957f9cfbea313553463f41560484798e796b3db930ce6a32aca3d206abccf1ffd452ca98704ee4a272a4b099206a80c32e1ff5a8c8c9560bf921d8ce051d3e68139785e1eaf0f4135e8782b74d9b31281bad419ff70d6514ad85b3d3aed1515721cdea18eddef39b04e689dc9e98c2f87ef174013ea1130bc6f601cbaf4cd04c41603ee25afe14386a2103d4a330c2e32da26a2163b615575f2c5417071b840921b0b40c9b728481ee50738719b67b277c33f896c49e73d5bb043f8a8fa551253023dcdd86301fa238cf92ec2ada8f425766a0797ff283653ed938f3dea8be43a163e167e4e40dadfce98b68c906a45f8c42b90db7f3978eff61b61555ae72bfb50947ff2d82208f0493ab982711bb0c241f19ef45eb22f492d81131d2b3cab5ba6a029bc0c508b2748b5dcc7a80cdd0e81e36cf4762a74797b1b13844d3b3e3dd5d155702a1e4dfd27bc63d29728037f4ded84c025bcd56b9ebd6f16646770e49e86020b027536b6ad17c9108d2b7051d96b5eac40822a21d1448ff852118bc208dcee101ead9b94457af2abcbe9dc626dcb4b879a7102f698ab635dc04ce67d7b6e68bf43cd02c61ad91f15267290221b624f0900f45f14ccbd2a5ea45467681f380f91e8e4cd55df080a7c9b22dc4eb7e9686e9ba0793a88a154e0024dcc14130c08e1387572c6e04c359fbe39c8d29711ae0bdedd4ed3771b7acd0283329484ae78bff856fa6da9a4d60493cacb5c91051575a41a6a69f0b4996249f0554a9ae115e0541b01ac66f487be27daafa3aa1dedbf02ee715183ec7c87684ee87c299b0800231f8a68e106291c1fe82b7bf44ce202f80d87438c2fa38ce5a5414164212462e89364ba2e81f4cdecaf87e43d75dc541c9856f8a0de6e917d752bcd4398790e3003f507e14ac68ee4e28cd82b924d0044a751827178d22fdf9d94499c0287b4c8f79194c22a83885e94c298890de3ef21709b98bef2a1d8f03f17f02540feef3a0f6815289a8043d943b937f1168b2f25af40891d08d43f6a503e4d5e5235b882ab448369225ed7861c945b659614c338c8efa4c454a49473f5ee98ef3caab1696356f983136ba7f4697aa8d9eebb74874d148241fad9b994fa3ee92ba6e0f15baf431309494b7ba20f3eba37f654eb22da0bf02b8da802010e54cf437bdaba0128f882fa771cb074e69ad9e7162667890a03c72e382fe2b85d69a0419f926e426bd3d8b6e74afc240fcd691a9fdf0e8bdd78f8aa4ed0c5da8a871c7ebf95baa8c8c53265f04cc19698822bc9899e7de05a03145fb4cb7ccd7d73a5edff372f37302ca9bd6361a00a71749e61b8e78bf1a340c13a21bff88908ab0b11641aa48c806a83f18be75633a6eb8993b9865602592932fe5ac1414a36fb6e1e87b69d2d57170432eec9d68030f99393ad02a934eed03394333efa5bb41cc7b39cf47403380321d0c94df2b13a73072ecd78618f86b4a40c76aa9a1e5650f5191b7f488f5519539140784dd382f95d406f2f64c647f09693d294b5797746d91620c8e70101f73f7ec2de95cb07b71f10969dfa79b4fa3402d297a30cfb34936ba5911de9284ec7b1aa1dc0b74d39e00f315b264cba89a73b97b7ccee8d107f8f90396a7a28db87940fd243df654e069a3a8af5d9509599b514eb7de8e6d04bc54336b5ae5c1cc50ac5b914844ae6ee749b9245a1e9ab17a10add1da9985891e9c5266e6ae69cb5c01885c02487a94e88a4246cfa8d2f83b0289b09106e9b7d4a5d23adcce91890734beae7ac43b4fff0528e19278fd09f243d3db57beca9687d7f5280a45af23d46cd9f65723123b73384c8222d3027f65721fe5bac0ab50b9ca6d0568e63a182fee5bebd1853222ffe096c738707f46094246ffbee51c05389bc35e817d7628ddcedd419b03a57c6e0af5da35f820d0873323d555338af753d9c042daf3f2596593133c4091dfb5aadd31dc8b884302c18667f453050d1a3e716befce1393765c0f70c95c02cbfa61a612d48943ba0508c4fb0df4dc562cce1f33c1468100c31ccf78a6910f26acd6c5915833d37b61a7ce74fa52f5123e8930a465e0aff0ef97d66814b187ee8c725114c8a03474c86909645c206e21e1aff1a7d19b5c290d06ec736dba69c2fcb7079ac69c634481881138f8f441836c03001d4a773e40ba27c95fc2f87b1111adec8b5a22d42edbd2bbfbf4fe197176a5af02a48cc2a95c6fb1e4308499b2e96defcd977aa1a2a036733ca1393405f2f5bd06994974a8bd8578dcad856ed1b9ed8518b14d24342609dfb95041bef91b4dd09311227b0eecb86dde23c9fcde4a9acddf616913c169d1be13ff107e052b7d9fffc45cdb7bfb04d9295b9bbc6b3bdaae0c11edd2faee8c09384f0f27b512b7f42268fdd0de00d405b85f820fcb570cd41df1e73cf38a8b912850df8b7a313636dffb746e2cb596c888fa45daaa4bd56c0f74559f18dfdbbc305efcab9d69c55162151355ba3013ea5e195a05dcd21f41ff5dd48b74d34861dff3ed2c19de9a8292df646870d35b0e3040606bbe6bd8d54749d01f14c0c8fedc3c39c3ca6bb8263dafb2018bf4d45a069ef3f7414a33a85ee09adb6dcf3871a5556d09d7b17a53d509bc97579f0dcbd9a9184f8b86bc6fb05100cb75931b12d869b4bcfc5021ddbdec281fc695b7d2fe6c2bc01e19f98ebad0850b719ebb6fd087eca84c7a6d068343726ee14b556eec0c8ca10b3c26c18059d7de828c50acbec86723628c2f65e40490f5c87d7d653324c2589615ca45945954ad4629de820689b6d8a41ee7c647bafb71c6c765d9fabb4bf7613ea358b7957bdc97c378cc9780828cdf092723b2f77ab32e2f890a6f1bc1a4ff37eaaf73c292b9e52416b28dd13cdb81f62cf2fe558bfd742a8f635056e17af84a6e60ba1a2c8079238194f1a1d99493c648cd327c5aa91b0407c7013b5d38bb0a0b63458560cb0f4ce6be8e4fc634d112a34cc223a2b6131b5c6ff2303a03bf4f048760cdeaf4108c81685ffb86e61f74aa586e01c78688be5dbe0b99caf2e41e01b6784a245898e95b416b8284fe0fd3566b67512a61a568001103da62e2c8f782870f60bc9670a961a73b2c2c72a511408e5654986ce73149a8a1dbb0852bd67295fe71b5116d4eeda8c67e2bf1099b626e1b59ba6dc225b090fadaf487936b4e83f35798728162c48dda6e759478cd19f13d73bb17333450548937a082e90fddf2e0e0011dac158c299b57f8edb51141c9e8f5cc7a7bbd897d3ffbc6f7c9cdc38a7695f9d41aee9ee0975d2b0aa777503b1ebe7a29ad05e0502fe1c9ecc1e6afc44204ac2fc20fabb240607e093ef32800aadf000be8ae33ba0cd1b7de644f3896e4b372788cde8a0edb1db100209de631d9225737f4a870652afff25b94ecc60b1d78dab11054cb60992094e16161aa1c5e7a89cc2600648da3a7b03a5103da4f4c92d6c16e27371ababebc0d2a91851a6903785ef722a42eb08e1981607c65d10ea60000a8e7f479266e5ba7233dc009ece6984197be3b9ddc8421f99f7f923123beaf6b60230024a262d5f5a6c2dc90f9478473b005b995e98aebc5159ec40ecbd9410ce129054759e016b2b4fc7ca2501f75e7ad59ab751bef2b32d15705dbcdefea8b9f2b76a8086a136db981d04d7de90308295dbdf772b8a25fa7fdf3655e7e6165c7b29c4af02e0ce32e397d65b4a40cd4ce10a6f27beabf4d61691ec73e8db99fd3986ef99d5491d011ead4a74aa7fcced5484b6ad027ed3635828ae9b1afa76a9ecebc690cef845759b2253a702e26c05501b282a3f2a453b3830efcda7fd3024b0a84443fe78d1688d37ae5bb928354be51149314feeb62c98c964252adf24e125590e957bddd1a87114e13cf5432d240880e718326ace84b0490b6a9e1812c988a7982ed6270fe1bdb2f25a1085e3f8653a4334f73f800ade90be3ad0d5c0d2f4af8bd71df38203631a1a86d38c95745c30a28a0ae3914b0ac20ef8cc8887b6ef8e18dcbb7a07938df085080b7e68862ea5ac4bf383c381b3f43fe20620209dd20c6e3faec94d5785b91544d1df31ac2b76d7a972e5e96509f2d73e905121616707fd12d94f9810a2d730967e5635e0eb912ed45bbbaea68a7321e591109e4573a139bbedb0bab331d8758a5ec72178d5f275ccc8f791946a0b000b9deffaf343b8cdb91085ef0ca90451f100b9a2637d5c847cc533832f7b8fa6076a5ab34c4234dfb85b760a726dc10772070fb172e87963f7585f98cfa5f927b590609833656404152861583ca447b889196c61178c73c2c026fc31cbabb4f02059decebe07c89b2b82ccb8e18aa0dc7fd07a1f314d69b1d08f24bca13ad518247a54705ce17ad758a5c657322664d105254d39c53dd54d3e5f46647d004c159c72cbfbd50b8570272b038656fecc40b2e334c1b9d1856bbf9b3121f80049af3be84c9aa46bbe5f13bd0c36fd48f143e37b0b17efe45f3c06b1cd2cbe6fe4bd18691eab5f634c2e2aca4df88ffe809e0791250f20f88aa44ef92353d512802a49ce4d0517bb9e9eeef7ff552230c1c54420e39a8eaf8db175056bd6b8a75bac80f9cad6d4f5d449083f1021ec5e8bd63be5447c197826a2e1c4846588ec17053ae0c3cb561048ab6ad201c07ff1fb1630ec06981867ba18bf46a171056020d8c2a2342548982681dd31da6a9fecf723bb4de79ab592486f7687991e567bae8d85ebbf585949824ca47f7390cf7478fe9b670d0b09d42bdd1a4901be0c590c8b0c55fc9b162afe4d0319d8a690628b028a7fcbf2c4bf39d1c412ffa64412ff860406feed080bfc5b0528f06f588af8b70948e0df8818e2df2220c4bf05010107fc1b103ffc5b0318f06f3e2ce0df1490807feb0101ff76a5f66f4bb47f531ab78cffedf2b089f6dfeaecdfc2a47fdb81fe9b2cf66fb0dec0efdf5ef3df5cad7fd3c1cabf55a1f26f39e0f06f53a4fc5b14a47f63adfeede8867f332afa37a2a17f1382f26f3604fd1b500dfff6e3f36f3d3cffb6a3fa371a66f8b7274efead09937ff396fc9b8e927f4b92f36f3837ff6653f36f3448fead9bd9640ef06f4762fe0dc6c8bfc910c3bfc1f0c2bfb950e4df640bff668002fc1b0b04f8b70108e0df5650e1df0200807f4b81c8bf71a97f1b82c2bf9d60c2bf0929e1df4808f26f4046f8371142f837d4e9df4cdbbffd8fff7ef4f19f8f3dfe07418f2f814140d0e3abe3cfff3cfea3fe1ff404f11ea19e213c5dcee3c37fcfa3e101e241fddfe962477c6a8785ffaa376a54595440ff6b68d8420348030c33789921ff9f41e64fe87882c51323fe96947902f444088d932c9c64273aff9bc8916a324513d69b006172061320ce0487c63bc323c2d3f9bf648f2570fc30d293654a6bcdbea5d492a52b815922009d3bfed66b1475b4e8d8d4e8883a2cd828f1a2040925614a09ce28d224d123891a3049c4ff49648e152ce480ff7360c041e238535ae1a4c191914e64cc8d183758189171833740b7c9a26b6cc2d7d80cf9533564fcaf01e29e4793aaa1a949e19e4743d3a5264b8a86f5169ea21182640c243e549bf16b66b3e7d12069f2d3747c9ca6fba2133b98991bcc8cd1923273267f06e797f972192b2e93c26f73803768b61e600a18cfab3900f81f400e79ea081b475470440447a000427a3036b73cafe648cfff238fc922260231e12f80a76268ee79343072fc344cfcc73053ee793546729032e202236218b142467ab0be3646b21199911c524670669ea00c8691c18e940c6c1c4606237e1819aafc32d0c890420ccf627806d3add9b7e47934a918e488810131800d13030b3f0c0c75a46038e337df8c615ae1a4a92105039304c000038300601821f5c21b32302f30f1df7e8593e605239b175648b9c0c77f174ee042961f6685a75c90c1781e8d0b465848b9902af2258fb6d649b54e82a919220149ffb9a78ae0902a22942ae2534449aa080cff6b8733d632d283a9915ffe4b2732062625cf48493252728bff07784a16f19f04e944c648af762865a477b3d882e9afce566eec7934e16cdcdfbc197bdecc1314c7dcb876edac874e5fb440037cbb199e3424dfc5489020c13c482658863dfed456cab595726d2590da289ed762ab45c213705ce1d937c5c26ad0139955936b7fc270f28493c7f348f0bc56ab551b04a9ac45c5d91231f63cec794f8c445165599e0783c453ce3baa9acc3b4e190f33b0f5448627500a4672a65218128a628a081bbf38a68820d1a588187513242267525c2da49628c569c1c9ba3a521aa6b13bc31437c4ca5256d0179585a9a5540a46540d61e3dd7861786ac806669e3de09d3411293584002888914221ec6aa18c0c4fd94a76d8889d216ca65018e1042b78646d867d345327d49032e10f13cc489950850938a44c58d2f54c764510ab5c41ae6c6bf724e9ced9ed3c692d7176653b6063245906290dacf3d5021b8f4f806478ca5af34ef109385ba6b235785e08ce96cd968db584844202f0aef692e986499748b34bc6d50d73c96e98aa1bd60a27c633e4e986b5ba61adf9e449ff0475c35a22cd60b5afa5394b958084843652240091224128481e41a69091b2f672b9642a4800808801c4025161043052238cffa53c3582015222909112c1889408409d4ba6d25aa6f853c9566a81e074e520d98573cce34cd239c3302b5bb9714b4e8ca76c8154898295b6a4ab52972b8bcd64a6da2ad358098716c4b865ac189810e0488580a5a6faafc2532110850024853a014a7c872f1aa3a14fa5432e1a93ad343bec499d807082227512fabb79edcc56998e812df354c9ae25a675bc0d0b9aa9b6364853263b52a62d295395df661758ed0e4fcc0ba695a62c66c27429134d6a63e3efb0ec57c6e3acc32e9784599795d15ca96d87109eda3ab571ff594fbd04a967f93b5797f4cd17be3496f4d1245ad7198634f516fe28e30f0afca1f2630e2430eae271cd8836633a3b17adab8bd615a9455b60b52f3f82f8b11f3e7d7ca9cd19ae751248413288fac8024e5ad73e7c50f53185d5c71039f8f86256bbc347967760576a77907c88340a1f3a95d25a680f39de32d61e5fec81650fd9ffef41b34710b46023b467e95d1080822081f0050301896720c8fedb351c956a90ac1308345a1391f16e8ae3f7d96a5fb2f64d90829566431e3d88f49079b4482ac54779709147127900fda2bd60d8b5d6ea94a2bde00f6cf003297e60e4a2fd8578ec008f2e7884000fd75dad6ee6d9e392335d6873bf407a69b7958af030c01d67bc73595728638457323c657704d1bd2896d368e8084856d51d3a18676a577700998db8af1d6ebcf3bcaf953c0fccb825623bb4d89134ce24cd02818dc7961d31ffef03247c00a50740e8c11a07effc6e183a520b3bb4f848b6354be98115b11e04d183a12f7b7cb1c13b3cfb85e78dcd74a530d9f5c8c314adace5dc57fcec172bfeae6353fce2c37f97eb8b511d5f60a4eb5a235783777e98825dfed7510710608bb38e1dea58e17f0786968ab3af110fbcbcc3940759f0e0c5039df7c5ad14369eb52ccb80d956d937aeeab8032f5d9d9f6a073fec00e8eff2cc08530a2dee5babb64ab04e161d7afc1d55ba8d658f95d6429a251d5f9c8e91ce589d1d9b625fa12bcf63756c8a3a58420711d001ce1c3e98438a39a2cca1ca010f72d0a58b9107903045d2937db57746979ce9629566199b626c8a2e39d3dd2967f6bae40c05abfd249e60df96c5a668af58bbf35a71d6aceeb6520ef23ff3cc4b5d95fa8a60edbe4271a5b17e3d79d284e88ef6258bd1aead1a38fb766c1ab59e3ce92b742565fa0a5d89b3819ad8dc20d95c83a48cce28ce96f515baca78864a566c2dcd1950b6f612b5669e3de06c2070f6135693dcab2751a40c14398674433c537090070ec8b8952a7288670a0e348083f156aac8805452a9d2559aedf13cd60d9eb8411137f0e2e0411c5c6a71c4e0e50e2f6d78898017242fb7810ebace951bb76e87609d32299366f63c2490f6b8240c46564b6be44c4cbf72af6a910b46cebe7d276dcade915dc764a6ada196c454b6ba5aa296151768e96da3211795daab5fe26ce63965328da74cfc689de2572dd8339a317ec26af293b10582b532b6b227ac26b8f17c817dc38973e3db4af6eb4beb4a5b6138bfd938a395ce64b95b36b72606bf176e6b494d4e8ecdc59566efecf09b329c24c7a69534bfaf936a2d9aad3a36351dbbb89561ddd5865febb6582d05438b6f8bad2f498e4dcba69366f86ac9f094e15967dad3b3348748f03c969491324dc439d47d593b2d30a8e96581b4d5f4e65cc3f375bbd5b9c30667d0e53f18b66c064dccc0a8cb948a33fb4939f3ec99817c07b60cbe5c0629f81356937b65306b4c44eb2a8315ee061d6e98c00ddabb4aaf1b348f411f9d516863802506407f07f68d0190d75e6d74692388ff5dd83209d63684da0802832d6090a5f662c1407c0703201898d8c8828d900d98bf03fbcebe63485b86e1a43359e90d4539656d0d36fe3a65f9daa1357cb84d556be8fcdd1a7f4116ff31855959161b9c2f70d540704e9e1700914bf605d68925cce6d1aa5c90c5df7d14cf979c52c605aeff78c2828c5479146b900b86e0164b8d37667388678a1a5da841d55861072cfbc62925e6c12d20a36bc192ec9b2d58e1b557a5b436d8a0e561c118141bc9dfbc5f6d1628b10068bc61e315fc60054fac606805a8775336bf1671a549453c4647725225796dbeadd4575afa35582dbdb20b972e3efc5d36528d64d725491a9d67ed158bd19b65c74a23cbf81a4a03a8752d86d9d7cc7e69a8d0c0011a48742e69331a53d058e1ef1ae432c6ff4eaab8642e2e9c61c61941bcb359ca8c2976257df345e7cdb5fbca10966495b2ea8c2967c85b2233c8e86e1036c3872e0ce70c0719a9586600fd1dce789cb2a59632560c20a0022b2a08520616652c39c1e14ced05b694302a3bb4b85a55c65dab5d96ec8a24552a6196d6150cadec2023954ca2a1913274aed0d5d21cf23c960bd6201979fcef5ce16cec92363f69b1c6f2bc27f99be2ccf27c0dda27ac26605894c389c9a021050848c11114c481822d50c0030a6840810a2708e3043f9c008713ac701957cb25c770ceda2f99235d1786aa58a53273688c2bc6e8310420060dc4988018427f976153ca407a719db2d22347b2ad478ec80ba31287e1bcf3cbb10ea912bd4661e0848102630c302e182c7c81c617557c61e50b69821d98800b13c04c50a4046894208c12105102275ee0e1851c5e3031530b69ed9a33f9ce190e279632a338bb5386c39ea1d3c3341b8616263b2bae9612bd8d91a4e7cae1c4539c79822e79a4a3cd1bb5868293c4b5033a6c6e8274f09be6d8c0ce01ac280c556128c7ed245a717083a0df1487973ac27e930d6af01fa47098f19bc278c344838c2dd06feac00ce8928fcd8d0cc479596efca618fcdfdaf841da32c1800d9ed937458bac85d562072d5a5a50d122ca1abfe9057336f108a556555c5cc0458dda1df1eccbaa96d20e27fd2838dad04a34cf10d3580b85f3a355f635ab95362f4b0db6e020ad48a69c1409ae60c10a4c5d3638d230a1f1ed0d2e17c514163efc221370ee6031021e748025bd15c6b7a938fba68c459855436304429dc74ca58c0048a5d90ae58a2e7e9f2b7a08c2aa2b708cc2566a21d1b244e0c5de1f1120f15f04527ee9fde0ae9608a4cda35408301082a4104c790854f8ef795e4db437d76edd5ca9a76a70de18cbc7c22a083c10140004436ee3dbf4def9a281152bb0020c2bb4bc69be2d564b793a69b21460c590df74c67f202633564445412c1e22241b5a535443b6ca16be1d121c259c589d7d4b5be0d8b2c69632fe22d29b7d4b38516ea2d844997d53b660600b11cf406a8bccf1edeeed99d9b794a2828ba7a8b8e2292a40f014151e788a0a0e3c4585160b8e78037ce00d9cd1c21f84ff393cb5012371ce4c576001022c4070c508ae1001084200022b3e600a0ae76ff2c090db46424080a8013b7f571a562a3bf09bb670e044bf690355fc04d032840b54082184068674f89a19304df1d5f1e7374501c5ff166b2c53965afe4d4f38f17fe83735d1230413420460f322c4123d9bf53729516b2841ff0647b6e14a082c4412618f3f3d3d14f6f87393cf1457fc97b54e8a55c9854b8a21a4b8e3f88631313079a97397975a260606a667137b9ecfa35021054884f635abad7e1306c47984e902bfc988df640153057e13058e45882284b84d43318aa31fdf80d5ee603068951bb76a9d54eba4df340121a098c0ff96350d9bf83749e0286c20b0aac0be608396c7e7dabc6ad0f2809de509ac8285bd024155cdc81219d5a0a1a0a3238ce483c13afef4f4772d4f0d027b7a88678a8f258a552b642d6bf573d42195490159b14a2dac06c5ee14b296d5a0e501eb687fb2253a9265b17bc270f22ccda1309cb395b52c3c6b88cdb0893e9ae040184e1e2aaa828c543206c625bb3b5b14f16cf695e10b7708d6f125f34e6c7cf53761480d9bb822757804ed1565b5d2f6dc2945be203bdc3049eb4a6f8b4b0dda2a956ac65d67cf1a8fb27359c175a4f2824be2896537bf5a43a975526da1063b1c039371e7562dd31beb5ca92bc95a21d9c5247d33af5aace51760ac48a511561b5bd95769aefd8963d26785ba4cb1cdd5361e5f334876f9eb6caf28adb8f2928fe7b9a858292373edeff6ac33edb2119be78fec5cdbb96dd44dca233bd9375b5e7bbbc3195b1ed9f58c552a83ef88b1bd2296757e63c64977ce249da254c9ae527ae9c45269b62cd349a34a3eb2933e3faad5cc9422292c59b3b45f3928f7c84a5b8aec94ec6b6623b44cfbd6427a6586129c2f89296dcd2b836477d3b2b3911d8fec6aa447e7ec70e4a163faabb64a19908254f6c803ada3bc7de4c847abcdb6dad9912372763656a928ce9954c922868a544bab950ad0f2bf08cf04869840886fd79e37011b7ee9810d76f89a78086c23462418361d9a8d47d9d621dca188f1b5e28c5a22227af8251142ffa547040c3403440cf11fb43dc22a8dd596e2d84a465acab739c49321646678d23c6f88102e3dd9d9489ddfaf831d9822b0c26f12e23d8880d08f3241e0c7f47652a542b265b9a528d59ea21af2bc2435a3a4d9b0617669069159c93b5a8947dc525aacb1b2b547a607e8d8d4b45a3a3635345b67b6f65e9b7036ae0967e31fe0f8e1053f60b9f45a984a995792cc2b497a9d84d195ec94acf883ac03c129c196c5a8ea071aa864fd90c2ff4ecedc6ec00c1aa0c67f2965034cd080287ef9444acf8785ef10066491628016e93180884bcfca530c00800f75f8f00612cfc39ee7c31897de3de0c3ea527e93038040614129f17f3eb5802b706a6a3a9aae66a65abc43abc1db51a0e00524e9df84010500a512c0071e5bad0d08090062a96d36ed9080220918f2223130b20795c413294e3454473d34794d5733f3b55218ce19a626d96f8afd26d86f6a13f89bbe17167fd3fc4dae4ab3b75bf537e9f09bacfca62a544c39e06e180ee1cc75d25a89c67ed31429517e135218ce8f655a65dce06f3a3acea61b6e53a37f83a3c834f49b8882f84d43262128e06fb2615cf5fca620b0c1060aeff529e21132c292899607cd0e1a0ffef76c560bab41a61a7e7e938fa9c7c463613508ff9b97dfb4532d35a950380c47a21f94f8f8b3adab211ab43c7d8d7038f3ec013be329846b0d252f3551f74fedb6120dbb07065a1e589185d5a06a69eeb07baefdb95d6945b58682ebf80376d26785304efaac1006430b24c31308df5024917ec60bfcbfabb692cfb78f07d95d4b6796a973a7962f052fd85295ca60876bdf9e9f890f68710514ff674fe1299e711012aaadb64856d54d4d64dffc52c0a50d1a9868f0363afebe604865df09b1a778586a815d9be16d255ba9ec9bb399194c4fc4ce38698a9645c40362f0942873b079081224481012402a1bc662d2bd62626734c8ba2c1f768effeba57ea2f3c3426a623b70e9c9a5368dc0b46451ffa7c9d62e4655cbf16cacd28993d958675f52738aff331ffcd23b359959f19e9e597ed1bbf31fe6a9198e5de1846ca44226fe0e0ce76cac2d5d2e59a6b4169ead566ae1998486929c3cac0e833d5f23ae892168672bd5e8791fbd5d3b2662b02b12be9d0c4f591d3d6f8966072376f0e1d273b964e6d98186d9e00eff53b4ca7f2b95341bc23e1ab342d5d23c4eb1224d1aaa3e2ada8f8a96957bd5a01dc2dd3fb9571dbe66674b1456a4a4cf0ae56bc3896f2bd18a54efb8832b529495b824aa72af807a85c750bce3ea285629185aa0259f23b0f687bbe7ce0e79421eb0b3d8dfa7126717e8a8b658c4436b22717681c03eca8db12a0c27cf8d92e7cdbe2929d8103efcb36f69f62db56295c666c6b0a41f37edc9365c75194b2b2e4b63b9a8c8c6639ee2cc7e128377d2aefd915dacd2aa446918d2994c1d6fab5a57d706e8a50878374c4e4c4dfeab1a83ae2edb1a0b9a779ce01110c82f3381af0c57b6e1ca253155a2e06d70feff36a7151dbe1492d42821c1b3ce41af1cfc1f9f7ae517f87798d6443203589ef832fb9690e0dc6138ef383d6fde99d404c02faf853980891ad4168b2c510d523d958394a772307a2a87a1a772b0e1a91c6a782a879eff414e31fc501c8a976bab31a1618b49b5d4d0a9e96866b2b5d764c424c3d683187e130c2f7c0be19b9017387104fcf732a8a2474a87199c08d319129ce944f2613af33cac0350acd29ff1b27abef5b729dfa2e82bd65ef25b14303c6525fc97d87434332f70a6e9cd43af01b4f54a558cc0b76b7a3312dc4a34d319bd62aacacdffa6377fb3d93763e9e1a62e988a0891659abd35a8f0ed309502502142e5844b0fd7ea1cb296f59be46f6a61482db758cbaf7155132d8fca07c38af25844b3b706581ff9c0fae8abe30f4e921f9b9b1f9c2441363741bfc900f6deb6b9258e2d1d582e408dd170fe2616fa0ac52602fca601fcdf4cdc3fc62aadc130cd1357a4df248019a643995e291dce827ed30a2ab4c2166bac3ba3645c2dcf6f0ac06be671966b8b3516eed8345a028396c020002ccdd96f4aa1d2d96f2262e2bac51aabc3d7b44f49d1e38a4890a4a464f15f7ab5bf05b1b9cefdf5941420365dcd4d4733436778d2a2a871585f59adc449d7d26ef417a5a2b0362f4b609029651af29b50309df0bfc3d7647d0919649034d24911991bc360f621ccc8208374f24482b58f0ae3a82b2670940d47051d05741493142b8b7c2d46d21f0df1b51f10df18f08dca11123f4be81fbda5a75667c8beceb54cef1491ccecd7bd4659a63124483c2ce62c9359944c600dcaf9ce33af92acdde92b74d5b169b4627dade47960ef1cc9713c7304fe8fa975120c2aca91fc2ff3943dd64e6ae5a5aebfe7b55237dc71831bbff4649eb54e3a8a03ff8f9eba61e9c7b703ed0c09912e2c70225df470225d802a10e1428e13e1c28b13e1020227c285eb44b8f839112e6438112e4c38912d5e70225b8ce044b6c8f2bfc89fe41fc00550e45b1dffc6837fdbc146c75346415449f5744919096d3a902365d4c31cff96837f93e3df70f03f8f1b6c7178b1c156837b7dfe0d8ea4a27f7be35f0283bad2d08ab3795934f8b719c8e0dfdc88c1bfb501837f63638d7f7b810bfe4d8d16fc1b0b56f06f5dd2f83734b8fcdb1966fc9b0acaf8373252f06f2838c1bf8d21c6bf8501c6bf7d61827f2b8117ffd60517ffb68516ff960509fe0d8b11fcdb1522f8b71080e0dfacf8c0bf79a003ffb68503ffb681d2e366a801d8476148694d3403d85524b02d511106dbdecea15a229e6a89f257832c0b83dd443d9b445f8bdc93227e239d9cd5aab3f925bb29abb9f0a39383b10bb26559276715935da535c8574f87619647862750c6978e578491d8c33248d9c944592d75610bab1246650c8c949d6bbc2cd9b3595d5dc636b455d68f8ad54593302af384d5e4da1f1857c60db398d629fb7a26cb623494f8a3a2aac98491734876ae27ac2678064e989dc9a39536b66477643753a99c51ac5108ab34488275ce3a532c3b19d901c9cee592b5571733f304b191198cc4b2c373288f620c8c0459b2eb091a418713000bff490728930c4f1911141cce100ae80187e254c141c211c251c2e1e4e0e05cb43226061824322606291383f4442b6562809132585aa172e3c78d1798d9f476a62d9b3e6ceeb06183b31923269cd95a1869427136ff4d389473035081b381e12dcfc30157e3460d1a5d6d0f5659705c81add4506a0d05a4e0b8b2e0b8e26aaed43a09cfc6b965c1115b70c4dd4c937334a074229d5822e9d1d4480fdf8e43d20487040801c8fe4b9b2592f490b83a498d92e7715d17975c27c5fff15cd76ddc8c11dc0c1041e2bc346e46c8c57969d2e696c1e3b822d55637a4f3076cdc4993d5f8a806d6c0996baf540750f207851323d5a04ccb6351d2d7321e4b3477e64e2d8bb38a0476dfb157483151d496e5165867ab35a333fc6a2db036e660726ae0eca3dbd4a8abbdba1e6f5eb9a85871cdbe29472e2ab265f9f657276e3cbf599b19cb4c95c099ab8d81b956767da7ec3a66c4657333ba6447b33589d23a9895b34b931866e51dadb4598258e2d1d23b9584fa4e3cc4334576313597ca2ec6855d5229498e8dac3514d9e1a5066b6dcc152900574405e9e1066f5071b22656690b4b9956675bb916dc90de152d08f18ad4e25ac0e15a80f9ec5b6a85322234801b8096222d0b722cb4c0b100008e05211c01fcc88323c0975f2e8174a61b266564a48cac777cb57018ce9605473c33fb96b801bcc05618d224dccaa31567cb5ab971d29db31082a4fc18e2293f1cf0941f3d3ce50716410023a071832f42c0038ed30cb742aa73dd03af9869d535b6e12797b268ad942024d0f0933f4148e8e86c66bf292b4c8693fea736a45039c18076b4c3004c2bfc3dd88ea836d41f0332f8e8e3c48609346198081568e120420d855119561162ba58b59726736dda4a76f8356211b41039b580c2a3d649ad58a5454e6bfca7170019410a68331e6df84f2ef84f6a9c5af09f583005470448bfa29880e3ace87eb6f96b20a44c423a6fb6f2351bef27a7c4e056033cbb53b6927d817d6d50839668a7a7e96575c69ef79a8d97e70c0870a9267605ffa94b0aa62e629c1b22f45a67bffaf5057128a8f117adb59c67f53cb02bada8414be49a5f4bf94f69fc273436297eb813be08e568833b81062effe90c2166fc2715fca732fe1319ff2905ff0905ffe9041c18e32b5811587d80bc80334108ecdf0404d47f4e0812499f0d6957a75211f7d7b089652e2744e73f8911c676572b3776f5652730bef81150820fef665c09e748b0c12fc35336db8a3c702458128c7ed944ca0e86038e04216f554b73ed15178482310a03e70e178484ff4b73a89379622b2eb05d5464a51206b3330d32a9cd244b43435303633f9a6dadcd19ae8578b45d670ec719c52fd90da378bef237617888674aa5f4a3b3596ba06c7b73c5994e1ab5f625bb96e9b5f48a33b332e96a659e52ca0ee7dce4e424a1d91b93783662ec5ab9eaac96966560766696e78c66dc33b7952ccdd6a4978c628d64cb4ef6ca252d386d589ba2ec5c7b4d0bcebe3497388760198fe174c9d92ac999e4f81f869209679ae27f0c1771a6a53864781499d4b2c86d7a70db1867c284db30c06d3e744cc270dc8cb86d054cc45d8e4bfb355891b86731be6cb8c37de91d934eb2f72529771afef1a71c523fb0a93fe87891196295d6a9d4611f495b65d83577ccf5c715ff67e415fa0710ff3b3645d81f3dff1f3231302d4c8bf8b1c50f2c764cf14bcf8f256050abaffd5a1768262009b6f41f87a7fa9879a93dafe9cd7c6471d9995e7b32c17f2ac1c98bffd4c57fe2e23f6df19fb4c8e23f91e03f6131e43482ff74c57fd44904dfa2d8438eaf36c6ddda7ef658aa9df4cdd71e473a5c6d87fd92a1b83696f35ada1d2d0eb2c378ccf34e519cf2c8118ac596e5066baf89c311268ef20af8027cf82190d22306f0ce78ad165151d0eac8274acba706d551116bd56a79ff2904ff0904ffc98afff481ffe481ffd481ffb4e5c481ffa83caae4a1fac1193fe8e2078fc0a6831d67dcc95378fc606f5f01678757c2a80ce7069fc223c8c7d9cb088c93d306fe6f553cb1630a986da51167c6339abbfcd5d47449ba9b9999d417a3a7be3079ea0b0c4f7d11f2541d7a00e0cbf8d497d9535fc0ff2704090106291f50f14c7f7472f0ea2404185229bf49750ae20481d303429b9b2024a901028e0380f84d69fc1036c0c400909a5ca1e948f5e587daf6760eb59d6a29a64ab407a9b6506da1ef37e23feca93a7c38be5344e280930f220c0088ab84367870c7d74a4b60501d0b385240027a40c0e98ac94aed4ba7cd94034d697ced251b37185ad7d7515cae1a1d198374dd3bf39c49b01bcbfccd1a9d5ec9223a42f0c36a50d20a3c02abdda135510fad8940b0415085694d94d201160fc24160b53b358836b3f727632a64594160674b14a4b244d912d1fac75ad61c4ebaa46fbe6a2e891bec25fa23bb572dec6a780ac90e6c99572dec970b833577b8966164aa45921d9e974ef115c51ac919cec698d2b06c5aa652f64ddc4ab757f20645c270f2c4e18338e260e37178e03f18246fe2a871f8fc0599a7a4758d553aa78d84d9393333739317207f9c32de9eb20106fa4e3d66b0c50630bc032d50033ab0961a6c51832cd2fb961ae4ff50fc450400e5a937fe78917934aa649d707c81030170243d2ff5ccbce3cc36c4ad5c5b6976d819cf1658edabd5ca8d310db220993440fdff67909c2e0fa23dd5fe4fb3f05f02690bbc738cd532cdd567ace1ff14d3698431ba78aa054b9e6a41cc532d782188082d887020b58b6f4652134fdc90301c71f70f0f52bef63fb1e86f9aa7d3ea0877c3ba9568ec0623b1964fa8d7a9e844741a7ad970e72484a19c6c3805fd077202faff530d3f95e60ec371a7afe5a9d47e99ee80b4351b7da41c81b5336e2949d7fed46a3bbfc94afe54ffc96785155ab36fc9ea71ea39f10039ed9c746a0d250d9c244b0d5690fe27d5e9c9df3faa0e5fa22adb4c2bd21a1a582308e97596911e4caf526bb87e18b03d2f56e989862d0e1c1ab443a638b029c812815d918c2cd1b5f7fa247d5628f750b644b8fb279cdd63898e967c3aac41b349d4389c3f5f8b4b3e6138fe644b04562471c9c75a16eefe89554ab4348790467b2b52be56bc42574b730883a105eaf0352d2b285ba2301c7f6eae486057a4d30ca72761d4e1e48d531353cbe43a313979a6a33796c071d239293925f94f39279c3a65acbe7608cf16caaa99ad0dfe271666b6cefb836fbf663dd41fb551c0ce96285b7b5491fed34d384f361fcd3d93657a55ffa9e6b5932ccbc8121ddd9e8d279ab9734272ea362fa7993f06c6c26a504ff70fbe1d926a6733fbb570172c5d78b0f727f7fdaae5c1ddb0255d8e7459a18b10d0ce5a984ae9c1fab6a4d70dd3e3d23b2a3a3af291458a1449e38a3444904612addb92418204ac8dd3f8d2b8218d9e5f7a30313c93ab3484fc7836e2d7885b757e2d34e440a3cbff56e3f9b532be9686c615bf2542e301688c6854f9df819526c9264703063450238c8b1a5dfee7295f522ecd212e5bfe3290caa0838bf8736185e1fc8c5a5c68a413274eb8ac70c61d07c3d14a91def802eb083b43e90cf00ca4ff605f29233ddc3a43fe7da5193900bb95b115cd98c28c24ccc86f85537a954a33689834caca0c21ff6a15058a3867e21cca729b1b50059908ab54004a4f054c5430a3021754f018e98930b2935e919d32ae28a38a32a0909e4cd722c3889c22c309192fbcd22429735b1c5758856f6be7a914c4c630410aaafc364a364a36df28a520490a726ea3e4727d2de2a53cab516ad98ca181319678be76688995f4b5ec6b7145636373439b474b414b0dd6eb9354e4d333bbea6a89582dcb6138fe8831c5f81103278c2bc240220c247ee97531fcf42930f878ecced65747181230c610c72ce91424fe1068f84f34ff75362bfe53093db03e0a7bfc29927d75de9dff4482d80d45b4b7a7c55a10b1c64afa6cb87302d2a62f8618e54a65adff34c27f12e1b76b0d6a70f6d14e8b35d62984166b2cd30a65aa723a9d4c48a78d0b172ea773e1f2871f5c26172e7d64dc201f5cf6b0b90942929adf04041d9cdabc5705eae1833cb8cc3cc1dff483df84078de98e6a89ec00432aa533add407778abfa9075fee181ad5c25a546b284b0dd6a0f037d5c1835a27d1d8043826b8721c71b6cc637125f0a3a6042f9480851ab9f2e2079c175afe7be1002f6a5edc70e9e5da22aea3941e383383a475bbc8a1a3d92a6566fa8a5c74e1e20b2e846ce1c716766ce1658b2dfe7712ec2bbbaf8feced1cb82d6868a0850ab4d0c28a192923b558d2428916335ac0a04500b440410b205c166e6491ca02045918f12cb2f8b2a0223d8f042908fbabf3ab6991a0fb3fc36da1c0b92d419cdbd2c3b92df6dc161cce6db1e1dc969c735b5e38b785c8b92da6731ca023880928a4b4ccce69719dd362744e8bcf392d339cd372734e8b91735a08704e0b0ae7a8f863880842848840648a31ce4d41c5b92924706e0a089c9b029f9bc2754e8a39ce49d1c6392950704e0a2cce49d1c43929b09c93029f9362ca392976a4b83927853c2785907352fc5c145fce450183735190316488090450218521511c9d8b62e75c1438e7a000e31c14589c83c289735010710e8a079c8342e91c14b37350c4ce4151a5046e48095c1628ce6569c0b92cb273596c389725c9b92c2f9ccb92c2b92c40ce3da1c7b927ea38f7440bce3d4182734f5071ee092ce79e58c0b927c4734fb8ce3db13af7c40ce79ea839f78400ce3d21e49c137d9c73a28e734e7839e7841ae79c20e39c135d9c7362cb39279238e7c410e79ca09d73c29e73a275ce09a3ff450690020a269c6082902129344174ae8919ce352173ae09039c6b82c8b9264a38d7c4e91c135fce311183734c94718e892cce3141c539269038c744102894c0a59880e11c13a9734c9cce2d91c712749c5bc205e79620e3dc12589c5b428a734b4ce0dc123efc0f2244851344504189109c5362cb39259e38a74410e794e8e15c1240e79250722e0916ce2531e45c12db392478700e89159c438204e790d0921242e403c00009e78ed8e3dc113238778418e78e28c1b9234270ee082de78eb8c0b923843877c402ce1d41cf1d31e5dc11369c3b62867347e49c3b02e6dc110438778409e78e0072ee025fce5d6006e72ef082731730e3dc05bef8bf8201423809420270820927ac00a484afa042000040844b218005736c39cf01872952a220b156473718fdf1c71f7ffcb1e9c05941737c3b9bc5dafdb6215bca8f3f3e400413a8244c3aa0964049400220fd514a2421870590c0c06fd7a69025fa4d2df05a1ac6d368ceaefd91e5b944613d1b31ea0870eee8e4349e3be0dcf95117f88cc503ce9ddbb1ce35280c47225b835046a02c80a2c0ff1f55010a6c42bea138200449d2373336cdc16d60cbfcea087349ef0d6e034baab8e37f156b90f157b185abe287fc1fdf2abe2a582ed71b5af41801065ab26039aa08715e16d8a12502430b54fb0acd86bd530b6bd1b5f7fea8094860c9129d254a96245992b30467c9cd129b25354b68962cd1d1d151a2934427470747e746c746a74687466789121d254a94245192a30447c98d121b25354a68942c49a29344499224497292e024b9496293a426094d9225393a394a7292e4e4e4e0e4dce4d8e4d4e4d0e42cc1d1c15182930427070707e706c706a706870667c98dce8d929b24373937383737373637353734374b6c746c94d824b1c9b1c1b1b9b1b1b1a9b1a1b15952a353a3a426494d4e0d4ecd4d8d4d4d4d0d4dcd121a1d1a25344968726870686e686c686a6868684c38d200154e9a4890ce9ca088d8b438635b41970c20f13f481032d0e4f8a28688c06b616d8622a63d72fe28217e54103f0a020f389e426a481184239d8bc235040a35fea360742e0b1f16568358a82b4ddc11fbabbcd504157cbba637c7aabd522c51b64435e836788b56b4feb196456489c0be174ccc6c579680210ccf0417ff4d2a282195405d7a2f1bbe709230420c5bd6720010ef92aec53b489b4f362051c483013a0eabf2aa52a58a0b55801401d289500287011bb61efc7085e2be7e5c00c8cf61f1e21c162bce6171e21c9621ce61593a8725760ecb94735886ce61519dc352730ecb0be7b0043957841fe78af872ae081b9c2bc28dff237044501072c24bc0b2c7392c779cc3f2e51c961d9cc332c7392c383887c50b8ad3818b733a8ce09c0e56fc1721047036d049023ee2ec02f10489b30b04ce06fa7818e261d6936db802671ffd28a5dacdd5079c7d547f7e9411d40824d31fdbf39b8ac0428129f2ff1f85519787639c9214306289ce661a36f18aa380ea384a2e1d9b9a2820d8b36f0a8cde8eb2aa1d4d0c7e3e61387962312b942d11cd0a59dbeaaf775add61f80f25ea582535c92c27c449bad981da64c005692280ec43c5503054dbd8d8d880df4b4808447400357f942b024434911eb8841be28c219c188288ffd286fd8a819135146ecf45c0067fcf8c0d27841a45e2ec9b42450c4c926d61dac560d9434c4bca6018197a80a97552abf66ab53a8c71df58a53770e244def1430de105a1c67f0aebd0d61086d09c0b82880ec11404ebcfb5573d3f60b6443c195b2055de01db088741f34e2358d8ab4e9629ad27e85a18385be672f5dcdb4ab61b6dad79ca68464348609d48b793f8def949dc193667ee2bc3e2ac784a8bc3996564971b672aab339cb7672d13bba3333979684de4a222c13a310dab6a0629b26b5aa915978b8aab5f19aca0a5e1feacf8f414f1785e2b0c9be67922a662c5e5a222c390cac8191bc3ad4463d55a2cb14a7616e74a6787c5ee242bae246b815c5430f8b25f05afa5e53ac1da3faaf5a374f851567e54951f45e547e5f0a370f851537e94941f15e54721fd28d68f5afda8a31f75c38f32fa51453f8ae8470dfd28a11f05e547d9f0a3825035fca89f1fe5f3a37a7e14cf8fdaf951aa1f45c38f9ae1473df9514e7e14132e3c217f17d4129dabb1d404c98c9224ff85542ca2a21c828e8a8072b5ae2124a2964f0daad5ca67a8d573a4926284d49aa21a727134f963287e54ce90128af44bc9f577b531259c7bb52b53482904396266df141e997bc62cbc58f5c0feb8d187187d79b94bd602f47f667c417a370c499bc1c6b7bb51f2bccc808c637826658e3a368dc0ea83f1f87f4c7bf0388dc2d744aa851434b2441d9b4696081b654be91c61ae0e416ac5b534873a0483726317f63c5c0b9bc63ac42058839133af96e65007764d269c1f9515c96e8cc19d1517aca8b6908b8aacbd682d0ce7ac61d4da9854cd68c7a6cdb41898191b332b684d3ae26640b57ac7af6353e46640fe83b3692e7036d0cac5856ad46af72b94e1be3f61143fe87161cfdf36278d9104021de4a54704a444c9f3669e3dd5d2db46f876361dcd0cae96dba1063b94a003bbaf6cd17e5856bafa5aa995349b16c2163cbf97cddfccb5865dfd55db72c1e8ccb347f5ed285a0447abe0dbe1932c8bcc09990fb22c3313f0c98c94522aa1c4135f64b1e35a2711e15a43b144b58602c6faf8631d005d6050437125d53a69e26a5d59eca4afaf0d5f33486223d776632ceb978c499a3f3ab3d57e8d1b8377fccff61679e130e0945a278d1ae0c02750812f8aff385d4d5733134ed3c7e48502d6376bb77e9a826b5551a9929b9b1a8a6bf89f0c983cfcaf75928ceb766cd639b472594b0486952e3f0a0765c3b9a6f4d1e2e3323c81643e2c7b7500e3b9367ea960d65e23d48dcdbff5a02669b6145ceba4d6392b3ebc9bd95ca7cca8d5326da61f7ed3cd6681dbf15f8aff742ae147adc0ba4908878406b3ce54f68d3613c96e36a52cd1fc26d0de1eb11bca7f32d299a2644a9229395370a6dc4cf9512aa002f0db4cf95100a899d2b7817e931ea81450448ee250a934504350289c304320463fca0470f691382feb37794109419570906e70a0484005e94316a347bf298c0c6b211490cd0b6a843f0646841f1502ea479d66585362d586925bb1c1adc6a0d3a8fba75ada619b459a25ccd2509c4d972b774cc6ae64872d0e659249cc012493a1ee1f7944c688b4612d18e9448a34b772874c62449a61be707e2d2752e60e91209132198fd7e572c9ee256562449a6124d857289ea98577867446b19cb9da0b7311b9e4c4d5529166396fe739f3cbe572616b5d106996e11cf3a54a2ec8cea3e80a6791ab69c3a44a167d2992e3bf2c7a41510f45b3a226ef5e35e975c3c69d765debc2b7eb867144487c444546ce11c15c7a3244a821200cb9e032e3cbabb14a31d2d111386dd83facda57ecfd011bec062bfd701f0581473b43e12a4f7af314c115b642198f3d60d32c587deced1c660ebba707cfee89550ad616977c8e84625182382860fcef96e650572d9523287d8a74b549d3f648af2b0de5cce66c77e4686b63ee586dce707fb56fc3ec686b2bdb23e594e2286b8bd6ab343ba5c5d282b7959a6681640776cbdebed2b296757e32f6f61579a41686b3ef912245473e39482215104b1ef9b0543e4735489f1dc95a210dc9aeb668b722b2871e24d8d2c913d9430f3206c6debed2c2b4ebbe30a09c6e36e219917421a9c959625383240c47d1355aa599f4d9a4be3099590babcdae5cbbd985b10c86c16c83f336dd919dcb25478b8374b95c3201523e7932f3ec9132a0946932a3b29538879c48291120a5b4d5e57249d9c1ac9c19e70e675ac79919c743f39f87003b468c480fa42d190ceb2b778e90f876332a2e5450fcb79132f6e5793458f1df4649da5ce715477cbbd9b744c30a0faad2a82432e8f6b1a4540a8d080000000000e31080203820188d86c311b95c4e242f001480015bb264945a3e984cd32c4829830830060008000080c0c0086108005cf675db663ff9922fafbdd439b035117445a0bf4e40c89b8c65f9ce62b476771c82a1e7727788e7ff85f40c157716943c5afe351e0ab5ad8b7a85afc90ced42f29d6ac08d4f4e69b4daef6abe47ffaec73385bb1f55400b47999ad85dae290c721a9b79afb60b212df047183f2b98f512157bebaf411cb5d8243c8891bef2c9152afd2963968050fd53964936997544b32dfd6ee86684b689bce7e45315dc2146c9bf6dcfc0281660aaf66238e628aead3a8a4a10cd773f40e6494ddaaacec2ba50b47e1c8f2ca425ae9466791e1415960108c471a49a7ef0e5b96e4d4bddbbf78931869396375f44b3a6ebeb86be09891e8d420fcd39b87a5dbecc5ac8c16c9186198ae80e45c2ea0a76877bc7fc135a94bf1d1fa93cdd8a1ea0969bc4a575d766af9fb6c87a0e7d03e154869803dbd178a4ca98588035ad3446a766b5ca3432b31a9dc74cd7d077440bb1c764d8b9f69add8af1560232393588051943fac42377a3239b65b61bb561251330a912471e8166cda74d34250e876f0d2c8693a0f308f86f38ea4e51d42c0efcc9711c5a9c0ff319621886b5977c6b26e5e291a43ac8e2262153eadf41e1f21c2874eef164fdad10e9a05ddd5c9626d806fac47ef767b8db544c9642e934c4cc41f3a77218c71d32339b5ea08e3c27d6275c6ffa7f11b7d4d77cf667f849d4af294f20f8cb2937da2a378a4e9d1aa0efc153bcb09ae7162afe44493e80e6fb5ca571ec630fb6699e4294ef7f921954ff30f38291f67bdd3e7d7ce4d6a7359f1543bf917e12dec1a711714fc5fa76593a1d1c038f7f3cdf52f7deb2f4cffa71b90d76643dd5b221708ed8733eaf7908ce46796b6386dd0104f1ef314a12b0170639f3228e1cc2ea27e67b66b50bc13a7b48356e98dc8a60dfb538d109111fe2d862adf350fea1b59e7ab1eff151d3df5faece1e69c3cf98680fdf621c69f056eaae96b3192c970cc9d9cc3fcf6dc89c34d34ff54eb876faf4456f24e12fe57024e13f3f92f0372049f81b7906d2798e24fcb17124e12b62ee0cafff2949ccbf7914dc7f18acf8cd8e41b71fffa119df4f1f04f43a641e19d18c3156273fb53f814f354658ed9f57b847df9f865c54cf5037d86710ed93417cfebc146e8a0dc6a74aa7fda92f80e70709e2930b7fff1804fcc7f15f2577e461c97ed24bf99f66c0c4c989e0c2056e4698df27afda5b98cb5242ac4f4aafbd76bdbcfe67b0ae97f538ad7fcb573df7a7aa6bb336e55879e4b7ca34d6e0354c739962b566d5da077a588baf39b3b39bfe7a8a27de547dd7c6fec560e9ee24dca58b80c5e00f064ddb98a614a5f3439f55fa1627900b55fa3b28eb2787990055724b8058121966a560c32371ca3bbdff6035e114fa375c5d403b05bd498d33e25c030b92ebc5721d80e039ace67e8e9066980ae91e84a143706ec53a1bc7c42d9e47c781df091a68ce76725b038c5aa33e3e2e6333579c5d50e94622e5cec31ba7d70c05a1670d5ebd05429f02e7034af2826e2147737260822fdd59fa8748979f800f14940be74802f079dbc5476d2dd9f48c105ca1955af7f34570c9f785331f251edc946b4897442592b1077355c29867caef72764a21c525c1cb7cc9afd01d7fa75e4fa58aab54563c9923b7b0f0e954a74e866e676d3909296204dd2601403c099cfdf4535f135f65f3ce80b4e8627b8cdddceb80a399b2bac585e09f9f09c2cb77863f7c9924973c942f07d3f8dbd9f100edf2ebd6719098b2375103e245a7b82a9fc13b22383f4f4a0ffa078a30f0d9b938365653443f604c63d47ce27840203411b3c13cc9e7b164b3c6fbd7f147e76759e955cf0de9c9e117e9cbad201552b8a934d4077178d4d0ba22a1cd25576a27ddac31e1129f19c35180b92ece6e84af5bfb723b4cfc7dd86dff182f6f05f7de1b0976d59725830fe8e0761f80cf9b4b178b3f820779255520eec2184e13170f8af33921957ed5a054b606cc0a009cae051819d0737d7648bc6e1a7224f8904049b969a90fd765c201e631af6315468e48b16ec66c76509f2eab10156c3cde6d46c2f19c11225a270da335492f28cd026a09e58b11132c4b86a9ac685da690ee25510d1e3af2f784fc0d09c983c7cdb9d015b059101b1acebead13bd02f8b967137db9ae4f0c205676f43fa19e8f926a0e49320b9b6f7c3e1724c839f5be313dbc923927cd46f698e2c6e7c626388f3cca394674ae0440466a6cfe33383516ea20b3ae01946584c2de90e9377b2402c9ea89a5662c385b6c34929e682652f3d986071a8aa6c6c9e627f12d258aa9740872a7a603e368f5a6e9d4f9fc923b91714e26d222804f7a32a853a166470099d94f3904b4249f362cf3421a15388f29120e97667d50d8fc5af01707f4b318ff82991b288099298ef2014254d40047afdcd81dafa1d4184dab313d29cabf760784e52ea6011f9be1b44777a6b8728f00be1bd3e4083a5fb65df306f3dc43ea933bfb993138431efcbf1900fd85c3f31cf28c6c42de60525433175c6ab12eb91e37d2e241df08c013e80f4394f4915077eca14588315fc341e2545d4b40e9311d1c10280c07574149d4ee78437f9a7d100c0729b5fef169586ac920132e0b1e941a147ae63badd6850340c7428caa4fb36c34bb1549c9385198d32edf85d38c2df7ba1f1722b9f949ff21f5da14d15936dc4f081a31e0f3df39b57531cff0cdca088f30eaa28ecfb7f6dff2ae7b35001f2f46ea024105ed286cbf816f3bfdd7cb8a8fccaf182c6edae24b2451dea73659306a738ac985eae9abf05246475a2a0a1696eec3c69dbc62db1c1bb215afe817fc620aaff59e6bf59c92344eafade92f1e3002769d0e2d3bbf37910565b6dcdca784b31e6085c09dd7e837e1c261f78e1324f13769fde1228ecea40106d2792097de0004693d984b730081f41e380b7635c2cf331c4bb327375f94fc3bacf33bec907183fe60cb72e6d7722ce25419834fa5467d78d9e0f331f21ff80fd7fb79217e85df7933da1cfaf7e4d1c0dda333af07b8232b77c6cb0341010de3d2401f86cc7a4a689d701ec6414dfdd81038c85d19f43934aa590bb0f920514f716419839bbfd84976653b78b2389f3802256280ee7f134d2ef27b18a4d5da4246410cc280e02ef73416392902dce73739222e9a95758abe807e44af8c84e6a110872ae503fcdee92dc7fa5e92d8522ee8a1d79f90d8246d6961576396d0eb4fc949329c539dd828d31b200781bfabc8849489b7f2db8c319cf6991283eecbd6b321d03570c4e7f06c535cced33b3f6f38cc82386d938aeb5a8d8e205e0c06e885f892c97ece9b15ee9f08c36e2193e606f985d07255f316119d7e53531924b1b421ce136ca50ddfbb40528ac6e551388957266dab9d8a2930059a2e955fcd6fd615ff0487e6b2a5fa11d652867ccfb79f035bfd0732202593663b96e04bbc113801080730d6f1ed0e3921e5d83830187a83227c3884d3609c943e5a86131da3ad510da1e27aa85bbfc801f695e29b3c88c03fe7136b0f09c3959a5812bfcfa2dd0065a6883f0e5a3bc143e212446b810a7a07281554a5c21fbacd743c878dc43416a056db3d941a4d4e10eeb4dad6e1130cb4704aac274ef9de38fc9e4148a7705ccff4c6d7820a27ebe64f43ae1d61c4bba623c929aa3b9ba6abbbdca416e950ffca0bc2b93cbd2e2542458191d682d869966577b1b8b2efb0960f4e518cb9695fa8087f1738925938be26ce4b25f7172c475b2242d060d836d01bbdc0d155a4ebc58beb5e54fbbbdcc4a540b12a2f161b921f1f3d84f2a0c1cbbefda56194f3b3595d1d717d077d964fa8458b7365318467ede5e2e20630d23594c430004a11d1204dd39bc55553dd7c15fb183872a6b5276a8123a33cdf3e6c0a60fbeca0cf43c21d5461dd08f159e7425bf629a5aeae78d203cc9a809b9463c514c5e9b913d10bc4484948b135e723931b7d07c9b492ae432530b75d8d3cc6dfdd513e45e8494ddae064330eded6d85efde10196498e65a83c6c2b687acb8297b0a31b6e8ab57b5d323c1294682ea496cb8483f603e26ac463ac36bf06350ae85c418b52cea162bfa17238715d8de2fcc2e4f4a29b7d5e39b041a5de9f445a62402b2eed8158583c08b3fa9208a1845153e07b4391f94805cc1650fcd631731ac676e67e1f4dd99819890ca721a8d8ac255b5b6e6f119b7c5ddd7f65e023ffe585fa32bd1fd2d95c2618dbc674ae02de256d1b64a6c7a9e2c11a117376dc1cd2b46fa513e5f7c801de82fcf02408cfc8946780f90136fa373728ccaf0f69fc8744ebb4d84bd3f6d040a6c0a49106cd463bda4a93e1d987cae99da14fef25cf811a79b9c4e2e54aba7bba67c7948d9d670774a12404832864c40f129193b62ca10ab4ae34961fffde47f79b6503d3ddecc46d8d46b830a5865a62385970d609b7220dbffcf16124f11d5d68542537adf99a7da1845cf46ad7b1d593f78f3addddb209222f8d556f4941ae936dd3f6a1cb723d021a2d3e4916453e7933c877830080561c9330eca128f9b6813c0c68ab58bad0d3579c67b05586bfeb846dc8a05700957846970c83db28c5da81e3191d897cd0785cf6d5d7b58a00469142198492ae6141959e9b48720ac780f76f4ad7bceec48f1b685c64d5853739bcbd2b4ed59e5a893de079821ba061b70328f8250f1b2855632a6eae341405768ea79b893de5be11c17d8e0b6c2a79e3825712b30efc76a0185d1c50e6724e67b561c0ac1efb1a2c56c5a9e6487621413726e662a6bef72960f1b22a344d668bbf81f089e2031ecb30374fce6c22e4b049dce653cde94a5edcb7e5e7f78784d0cac6c1f1a62dbf4139c60692e25a6ddab4f545b6e94192be0bc16a38a709fb525376d04f0bb774107011c4f4e8b5020067786bcaf39d57f43d8564c2cc204a2c38030a3fa3001be852d291ccc5233e18f83eb96316ee0a75b2f07399670e63f13ccca59c5b3e5f648919ffdedc8b0198e28741d9c144f42cde47e7f965370b42e922d43ee8d81c09d6590c77feb8685b665a3175e752b4062eee0861f22d1ab1f84e34e0ea73386991be9b426809a8b5ea4262f96dcd2ce89eeda6c61bc84ae022e20cd2e6b89b1fc5071214f56a8dda0e11ecef0389f75cc99e2097284ff721809a292ce2630c9ca2ea5d34455298623b10d28cd4a9490103165d71bd27f3f9a352e3803cb1247284164f8ae754f92a54ef95e360e94d5e1ea0000e9b3f54acff2a9f04eecacf42227bc35904041d6175ac384491004d0823c53e9bf6348c48f447b5db649a5fcdfafb19b49404a3260fcf8983ed4f983d0c19e8b1725c4b12042b135a8bf0ca43546b34f4206f40f807ff382b3a86cc6147f55902397390674a2de6226951a6a56b1fe056d64b53a19a4dc6626e21e576c5dda49dba2e9c9c6875a478d0645c59b4ae68565b9189d839c55f0bc6a51e75bdee0127e4e771e773ed729a5ffdcbbdd4a8dcb55e0e0bc0dd92ff846eae92704dd626cdf07cab30ffc7a62006da6f06b7c79afab95f7409cb70ff755a552408889dc2c37a32dc5c71f383ddda31f757870b78bc19e14c6f924ce65e0e914d4b84bf9a286afd982dc628c1a9cdd403b977aa35509dfb1e0548a90ac2dd5c48b2b9247d18b6b343607850ed5ccfd85dd5ec907988b44e52d7943ac838763e6547765bd4182a523eb24a8138c8dfa5116eb6872c05bcffb6f0608b54b0530d5a96b627450d8dd377c79040ccb3a2947a61793ce7e20c7420c3f2bf406a263965420c78c800016d72148e5e528a1d2fef41c96a5415ecb4c06def920b5f30bffae3334115a55a37ed0ba6749ed45f23d3c0d0ab998f27d058083856e097860bf587dd2a701180c76ed2ce417add3198c6c420b29f4507f3e323eb70924d99dc46d65d473adf90fd5ab26c772e8c880f86dd358cea72f55cfd11b54430d279bbab19856a368787cc17738c8069f8588142e0c2cf548514c767dbf57f8a3573578b162bcf2267d15f312479a672997cd505ee9c528001fdded69eb9bd84c507d3bb92063f4a82fee01fd7d03b277c6456e1983ffbeec345223bf673f77e76ee5a8663915d4a807e797dca998951e0d04264c97098205db2b5dd03467abadaf19c8b21647a44d35f05ec68d43f17840cc7a5da4de27ea26476e9fbd2783a98b650d7adeb8601516be5285069955f8b165e3beae334a68d5d2e5424578395e8c1076edef159d8dd5c72c053bb5bfec0878818ad152d02e17c2ff2b86347a21797ff09b53e3300f99d40b498ec0bb948f95a3320916ae8876aa22d1aaccd5e142a107da6fb8d8cbe50b98ff6474eebd685177fd1e6f0ceb572ce9e3b7494709530c3de79d422f9747731b412bc876c0852a8ea1f0583e380f6ceccf18976ea3e82b844c6dcf5bd6f702a507e2512ac6e4f3160e22a4fa4d98ba5b8107e8438d8cca8e888e139abbb496e7c1a5865f6d72001cc8d4fe9f9c741d72f7f1e80bac07ed4c0c77701ea055edfeae3d36ccc2ede7be6520b78290b595b2c424442eb9cfe5ec2ae3909c1667d31507539c3db2c82d80d939bf98059ddaaeaf4196e12ed60f62408b6c8d68904dc9cf396ad34c2ffb6824e13fbbaa734db2c5580d2e8f176a507c402200c8d8d772cda2b4a934be3797633fb3c58957017b5a742dac595a5624e43fd5f4c6041c5fdaff8d68c81fb30276e548e31901bd41c7e1c7e15ff934109f5385131f3c68299f72ba8c912f362b44a38167d66cefedab0ca354096bf06736c615382317c6e05d99c765e4f4ac3e9bf25053ac8f21cbc6bc1932671d2d2587ce7ecc2b78bea46a5d69979b549a1875a5aaa00a66b6335fd828f3bd8879f79f45891dee006584ac403349e0489759a2a052023e2ca9de5d1d350fb6005ea4169206b1f59c04f97f2751f9a0ae4e2ae22c5de2fd76169bcadaa6dcd39b9f0b3f2c755c38eec1e42b8993ea5fd87963771aa0a781e57e0dee9fd42fe05e17aac68c68d53178cbfe1b3a3e9df417b5f10329c6683d45be201b9c5d81bd67a6eb300a47fe61362dda039a949af7e3df698cb87f76c47b3840a348f17fb7a6bc4b0ae449f490432b98281cd152975b98ac1e42f0a7d6296457d069dd8fdcf4750362c0350f5b52068a9bfa8e730c3a957a0769d45e473a8fe419c698d11e5468811ffed4b5166b83e298c6e9f9cd8c63b3294b5e4ae2009110735984dad9daa9ec9223720ce02a6291111d803f061fc02611463c1b81489beb3bf5148f0b3cc61e4a763189d10beedc3671bcbbb5ce99961518b14189c9afab2b121ddaa4ffc8ae55136451b7fccec6909feb5d79db7e2f6b3aba6ff53e0fd7fd177913e17cfca6e60ad3bc2bf4c92e86267167024f96bc6fe6b8bfe4b441b858058156b1a12bdc58d0a534382ff624025fd2bd46ec0e2f795538297eb0096530ca5618043d2203ae8213abcff77731ee9a7860c08acfc8ab64090a65eb33134189bf38867059753f3f8c1ce77862e2a873509eebfc78523dfa7b8da59404f239435a20e3a6fa8c0e8495b15bcd7e8c100f14d07e4501fb71731e0b0cf298fb7bb6512f31062ea232780b38605e3b85d0e1d34e91331d848eda917f888e5fdbf8a38dc11d032cb708e443e3bcc1d35b5213e68f94400fcabc6ae3a7ee4fe47ed5f7d671d9b64c4fc44988c07ca0f59f8d6ba9cd3227c91d96ec872eefe21388339ee54f11ce15eb5c7c2c9d00492ba884e18f10f8ff8f3796fcc16b4fc70f47647bd32bc58807e433f845eabac39082c8f3de9bff093f2fc70f5223e7427bf5e2c8884314133528f5d4410e8c87a47ad1c14a46e8a4e25c9b6faf812cd718b398d20b3d8a263ee623c19944258f5e972b70ce041fdee211f308d9cfdba04fd4a3debaf0356d1a9e6a242adcfaa22636391420d5d32b4aca70d17f8602f16a7a2a402da928da807a4b4607a593d8aa7a6b92e5224b796d0720d236db0e947cb45e860cef2f5e24d94dc26b2030c0c62e2f55b5958f4234b52564b25f4a24e199121503e9bf62624026c495990e4ccb1906275bd0f29b72b79f207d1b9fed3bbf3fa4cfc5db0f5ba0a90b27dfa0abfc01b5e443ed666a2c0bfd3cc6ac581eea8b8531dfdacb7d8a3a3d9ef52135f6bd3a49dfbaf6c72a6d1a930a5489e8f2f5c485450167c840eb2ac6277ba54a27b7f672d6622f5f0ed7d1d3bbf50ce27a3e1f931318cbf250930662b9b609d0e032d509d610a0383653d26c37e610a3dd7b26e82e057eb205cd2f4e03b31ae7f1f412faa6d847b7f94c950deccbe0970ca434d590f71da9b163ab39beb6c10edab194ca872cfc0055919a1d429f278e6b57295651ab034486fb4fedfaa6c3b5ec1d2c7de4a1ed842c3046a54eeb186d83824668b75e4232b963e9c01de1e252efcb32c5cbe2ff18ccbd70cab5a9756f22ccb16a869cdf2901d0e5e82512634019e83fbad2a7364312131658e0d3aad2328d05e5993beb26db2af5850a28b63296a5a9660650936bc0492dbb489e337608c491444284084563a1bda0adb7de028097216945fd03c03c837f01bcd189f1289a262d4063ccc32400058179ac6d6bcecd2555720eb40c9e42275493b2d588698fe7ed29f866533fec42edc14672e119fc630e0f922fab08e2c5817f4097fe41a5cc9b0a0b72a575123a18f9a10a81ff9f0155c215342d11a19b46cfe05b89803190183f38d0648c22f6f3cbee45fea7860327729ad2d669e12f5828f243eb67a1d105beb3b4e00f3b46d1348b556acb0b314268c19fa3f4a5f9b044ef5f159bb776e1fa66a1e4c298cb1f02c1aa5ae130e373246da7b1f69e19720fba78c5baf2c7e3f07b20fe1d3194d04d0915a1bcde1b3987fc13647c75c30d9d0d7708c66dcfe75fbe26783d7fb667edda673ccb552c34815577808c306bbfd4fd78216d061a09f9070dc34866a385504104868e6b34fa3e3e5b7611fb31905c748773e9f00efa2d9bffbe4d73e16d60a05e707a5635387d8766931a8bd211fb0b999b6990f5147ce70393bdf501b28d8f8dbba5b50896d35e22cce906a6125d036b02b8b22d88b8e0cb99383da7fe184aa405584df8825ee24e887abca389e543cde6121d961907cc1f1af108f084b85a33989ce3a27ff0494d74839dbb594654f1474d37f7f2f6739e4d18151f29bca35280dc57526560f22d3180a30ed84a2628f37122f68b0d753b555b361b542a76b13f4349433c6c8a20bf6a69b292db455a1318dae4c6e38b34c4ce2906bc8859e83890dc645a8a6368bde83bfb22b61c2feb561c39f41356a6f28e428646e06157604ff1d22bb83f41fb37983a8b9334558a2b025b1c2e7b8111c10d2c113c74c8901307598b7ecc7bc286481603805fb76b3a0033cea9960c770a28de0903bb7c34b4a3c41c60e0556d8f3b1da00e79548c2160aba0a6578c604e0327504f230bd634a6e72ceaaeb32b3e2ca2a50626f55cf933e02dd6c2b71b6c2553d1575c9ad291a6d2746f6ec20d6cb2b39baaa86e064129c9fb3d6907e948dc6b473ee264eda5bfa75a89f11ee9b5290f9acf707ead0217c5465e1505369308be4db6527ffacaf28980d05ed0ea18ee237d4c88cfd3e6a392fa73ba827ac062d1e477a6362424cfac6e6b00dc76f66cd4eb14ae4d6588cfed59cad5888c1dd0fc23f384b80b82f28998f47c4fb716606402b66c44d514fba544112db31317d5c68e9cf96d05224d42833286e6394c9972ef5477318f14e92de7e6b8d60d201ab88e3a196a1918433c639dd28874cbd3824bf4fdc2c846c22e9e7c1c3c85a83b8f284e1997f28e405101a4f50941a9f5494e087c7ed6467a35deb3868c410be83e276c996e5f70f2418fbccb90498a078451ee5dc889d591c0daeb22043e40970dd13d50f8d706443f3f83d531d15b2ad14d40aaba06249f04001bf24d5f6d0933d929a9d8b87511ca80971538dd144698faf4cb90b32c599eaf0b9d22f60170d6f805c999b1ddf5f99cc7561a57f653b86633b58c6a8a1bd9476f9e42c4a19c6a5081735964a2d0d3207899acdc295a88c3e9d0cee24b94d9618e5262f252aa549cdb34069e79b6c40b96fd4b57d240329c1351b7926bbb62ae1b3e570688ac3f1af1f55bf9e06a2e876b3113a0573a069762cb5c179a386a3dca8538fd1f5b69a5da14c37c8f9652bc9e91d97d8378965e23df5772234f40c5c7249b6a313c7e0cb8a420810d3116eefa115c10393435df077aebdbcd1b4a05a002029486fab7b55067b105d9ffd4bed67122d4a48219c72f9aba39dc4e9c860cc31b4630670c81a4d23883738bef0e25cc1d57f031526de8481942050adf32b531b97506368ae3cd1e42f02cae77b1e553b4b12c8f6180633377b0e884672d9ae6cf0d546c75087051a920916a4dd17c69866509c51560e78273b76e57d8b209d18eb8c05502782f0990e8b571d93b2a713ff4d939d49f54f9bdec67ae02d6254b62b5950c18bb363484fbb7974c6c3547033456dfb377197576dd6e6a1f23a45372ca3cb21892f68c48545ce2e98ac39226f52735c68846b0913c37f0a608d6824bd2a12de3e8fa83e579cce9f8d5b227549c473833124c3801efd920cb594835d12078151e723b5a3dffd27ebccc83546400d7833f22d87df3e19720676d31178ea2cb4212b27fcfe58a807a191cc89b0911cb5efa3340ef30d363f576870ea3110fafe127d4c2a4238c680627f61af6b669670320c9ad09e01cf67c3840b65e95f6faebc87065fe9f959f02d1ce7e930eaae22801e8be046b8fbfde9fd8129e62ae800cd7874d18f163cb574ba0eac33856f212fa8b811033747971c74ab71272c8931e79397ac3fa2980bf1f07c787870b98ec98ee4ded8b19778ad04b3105cc18436f280080ee71b0e05d41cab87ef7f8264a4580097a5502844223d4faba707e7b5296573cf1f772857c5db40c655c1590a5fd5063ee823a401c77c7435fc27d713e44fa4522224943ccf0ff190f4f4122972859c8829ce2c11f18d4f6c0fb7182e7f07103fd7030f07a99d00e50a14129e0566df71c6fe6be9c98b9cb74e47f7b50e1f3963a11c765da5df730fac61511c19c442567df1e5bae61345fe66a2aff8ed115a7f3142298c304251a1743472a37f9782df5926e4a02b13e0f73c4bf0ef4dc5bfeaccdd49e9af540ffb51d8e6c60364326621cacc6182baea65493190ba4f9aa2668c0e582e7325ccba60be3ea763e1e09b62eebccebd0e5f71ba209cc19219d40e4ec6991b8bf1c23e52c9e4590ec95fda72a9f7449a4cffd49e9a0069272fa75719dacfecb7f084cafb290e6f2ba7ced8de461664ef12f2575bf7d9bdbb70605eb97caf10ae953d2b0e46562d0f15e587e79df1db91f69146dd22d37bd99feeb4d2103c09be9ce478bcc52fa7d773843c847e7345e6ab12297f181f354eef3f9f8c73d1535909a3e78a3a0bd6c6c9d62b1a7412a33c97a1867a4d3b5e8093c80ed691192bf7c5f8298d7734b76cc62380dcf355b71ff03bb38e21d5aef766fe68718e8dc71af91eac91268b01f85f6b61df89c1851bde7dd367742073069a4fcee7459a365bbf0f247f5561b790ecb91d694e2b3e96abb858c7c44031275ef89471f0bfd17ac7d0aa77e44fb74a7d19face94048207ee532583bd9da32108f7024ac0d86026f881c5294133c529f7f40c45f6b81392a334201d8551ba93ef52d4ef0580e6f80cb30902a741042385d6ed040fdb55a497e01f80371bf54f91f00a166f687a6ece46585b45061b1f315cd912121cf4e0ba417cb8c757c709f120b02c87864f509a8511332c87063a707ed77eb3506301dbd16d63b746cfac4ff22d6e41d0f231bad4cd8b1048ac40b94428c267a71e88b5e8359a04792a45efdba87b6435d64d7761e1a818250d7c5a815d7acbd4499a08d699a5d87701085315313289ee513845fa48e8aa102822722513a18a10eb5da75ee839e24338ef6157f2d22312121fd1ac79105a3512007c61146b587b1d0e20e61882f4cb6279c3c0b8043613206d505c169e9162fc77cd0833298a13921de69e822954e041ed673883953fefb02f7428262b422b10dbf7c5a51b89174930ca93c88263cff96674fd077e84e7011e2f80b7cb0642181a9b2fad378491795a6f87ff2f858af1e4144714515407aeb2160c6ce42e8146620c5f14b1d332ee98911710ce9c69e6355c57d02ebedc9db033152f400231d21c9af17046fdba06f9408eb812f8cc238ecbdfcf7d89c3792f7c6f7606c0a42fa75dccff4795031fbf1de114c8e69ef80c4bad483b3156140ce4ab6be16975d9214418b688260ad4110005c8a87a5da2b003fd0de7cdebd660fd7fab9cf344af5cd9f3b4cb7696e0cb03c3ebf292bf0b857e60a399f8eb4ead2f8a4b3491e27bac159da04b9d30bcbefe0e4ac0c9337bd920bc1ef766980460d516496ce1d6fd5dabed62d165bce69cc79491b24b681d155620d872644b9ae31547aba93c9a57c91cfcf76c31e315ee470c7490f19f1b3f435e775b3bfbe7dd65195819e629ca65a79e62ccfeed94c3e2a92b697de07f89ce7f83936f640009edc782f5df57d6d8a6df25999031f1709c9c7c890e97c9cc75aa01fc1f867dc35f8d48ff927f51038b9ae2fe024548385303fc63dd5c4b5fad2bb22e76aab4d0a6079234e9844ec1aaacfbb94ed5bcc15be5a73fc3b94d7dcdef8b5fbed787628790fd5e5e5c8a262b012b63ff37c8b71210f145a9e0b8c863121d6fe560b0cd2e832d2e9560e403917ac7ee5d40620039f331779afc7fd95f903303c86c4dcfe71092c1fe91b7be4f21d04daaa3840eb2bcb6a5cca1f80314070505253b7b0042dcdc7ee2dfeb7bb5a5db853f04a35c8bc6c30b6d1820842c3da8edc7bc22ed8a5865f249b8bcf4668ca899babdd278e822706bd2fd9422712bfdfd736bb45caa3a1ea2953e466a1f54ceff6023f4c1fb63fd28e339790222ef224a7be2822e9e263fc92fd119a9cea4f00b43d7bfa08719278dc7fcdc66788d95441d34bf597326d4b03766e1cc0708bcdba9c70f103cc030755cb85dba0e74b395992baba79f76755028401c04755fc1c2ddbfb004a178ebbb212f5a8a161a0b8b554038957c7a05c2b6eded3c4ae6239814e51dfaa6dfd08b6606b1ff6e0f24d55051e0c6e11c2ba63cca5982b4b4d51bb49a87956cb98e6be0283cf9e48efba7cb2acd753e04210a7b503091e0484d9367d9b6c6ae084c0c98a6c3933de20819320e0dc45d274b6c8024ebd7e8b4b681ecda4aedb6c47166f086c1fbaf2f4505b50c6eefca41e0d8e1a0f18bd2011c70a4480dc042f3635741e389ec35b1a2fb3687a1278b3661069c39e04b3d5ac5eccd3eac83f5a5f9fd95796757357e8c3ffcc72fb8fa2db4fa4dc11b026608f993debf9d96e87d7f296bc6eb70d3a1058c0ea7da2b0dbb3188eb25b0f7d7e481c6adf8308db1867e56d9b5c2101d4d26efbd2dac4cd681e89d89a3ae6f21bc3e893f8b897426e1e4bab7c4cda0925ea4fc77e35bead067e9e5b414000db1bef44622a81aa71a2c0caee9efc3a99438331bfe3913b0bfb6d649d5954a4bdcda47e2e8ad3478a3cb68af139be06444c6a7202c88814645c221ba9038fbd9583fcd92234de08d24dfcdb02feb69f3402dd034e79b73ac451f8d3801fd9e8755c7167ebb6bdd40b181007ae0dfb8bcd65f75327c5ad351582eb26264d4d3db0405f24ff093c4b7aecfd39c78033f4d25fbc17f27fd470ed6c8949fb72f0ae58321f48533b275a97fb0afe816013de93df002fae54d6cd4f48c352cfdb8455e49af8d41604883fbc57f44edc9137cf3cb29514027093093bd5b7b8e3125695ca452172e7d5ef98931ac1b3f44514bc56364347f71ebbf3fde10b58533f103be13b3942001d655f6843610726bc8675ed3e0043ef2b31f1ef117718675d13cf03eb2c29ef763dbff5457d6f5aefccde924ec691562d7e59379e444bb91816fd406c6ade65f99c37d5909b873af14a518c811ec5a31b1171552f6e1bfe5f9c43f94738fa0951e5cd4f3194573db5d5d859f94457f1bbf7672ec71b730cb162bbef5fa077a96e411bd742e265aef0903d463fc502cac55697ae27a59fb7134c21022eafdc040ed9d993540be3b79f777e2b9ba247749c031dfe5c8d911b62526dd8efb46f4cb5ff866032169305b7f5368a4c75ad283c4fd2d0d5fc0ef5a31c25b82fdd651526a285ac8622baddb9c17bbe6df0247b74fadd9f585594cbe2e50b73b2446a54e3af371f80db1b3ecb1f9bdb138cd950586e04eb89c37ebb5aae368f2022134f16cdc4038588891356e7809a7d0624002971503e01ae6f41a42989e71dfb9633d104de284a2efa9d26c97b9b46d1050c47223a63016a20e0b9668dcb4a3456857b222f7ece56b8a84f4cb1cbd73af8d1e40a1aa24a304736c239c85613d8c5df317d1dc4b273df24f22d4d77b4cd2d17810dc2aa516c0016acef92b5b0b83664383f93908b1e23204ce86e814d202dd8a6a45cf0ed43fec4be507460f3f77cd54e3c3be0162ef58edcd99c3139643b81424aa7d8d1821131fbbd3a37741228316e31450da5b79112b978a18eae52bff6773a4675afab37a07057bf3d1adfcd11ae9576105771f48745118a97cbdef0770ce6d5905e9a4aa3f0c44603ab2d11f052a3b3c011d1a13e14f81270224bc1f17ca02a19a6a66c120570eefd00a908e8147b0ee0316db30cd721374b8aafa7a1e74cee5792a0d027c1c459fe10a27a678ca1052ae4d3392265b1a2d52bdfed21b072c52f7f26e68d9e7c6a408783a991244c2584338e8e4a2d0b0fb76852f0b2584d7a4ee8e5efbb38d800e5eeda5697d2a8aea5ee1124bcfa99a676152c4af8c0c25a797685eb41a6360e01d902f68fc22f942f6cd8dc47df48a4273afc248a6750bc9acfec06627f845777da6e4119ecb323f16804b08f98fea7f73d8a80732b4b7ab1617f088a9e03ce66b5cdff4776d9ce7c8542004d31b7fa693761433f2076d55a1a91b53eb4da9f56f492ff98d722dd030d3831f9cf6c41f2c4d3073aa87840c925db9af5b4e6a7b6c9bc171a14feefd7023d861f8a887c6ea416eb944966c75660f9cdadbccda3d18fc73fca6ee561dd8b50809b09d5e8b7cc730e0358e9b4e30ab43d01cec547c6401799324da022598432c2bd8bdd65a76060952384c3264bcd91c5327579c9b80c25d4bdf043ef67b79c9ee1c480e14943aeadb2f013dd171a284d821fa84312bb256807277957d7e12acb8a71da1503e0d44d02677c29bb02383a7cb015472c32fd0fbbe97a550d6fff35d32e144d942493c9e7cc0335af4ef3e8b78eb46ae754216b466e5d2a95bb29cf1cd5b71e0a283203ddfe7f7499a64eab9360c9e660e6d2211397a3f696155645e1c918827b218df2191c627f3c2273de426169d39c63f76080cae2de05903fb6e0116115af777600ffa17d8955ee840f5bc0f7ffd35f52a51789fc068f7b5de5c749144d18321b4039d230a8bc79079858bffefeac7c6de3c491074be47d9bf3f8a127b3ac3b17cfff97e44e18c98731631f9403a230940bacc9c41a246f198c20d18a138cb1242771fc3dfbf2f8fde1e813e6bcf62397ab5c661e34ab462ccea862f5bc1a7bdfe69842578e2cac0f3bdf7bdee23d019ad7e5da897880cb5de6f8ac6563bc6fff4b68b3c209504fc212c4145e53c3c4a155014cfd283c596d2ec63e1af8bab163a47f48ad2aeff1967e0eedc3cce7027e0087c18a0ce224285afd5d8120bc9036baed73550629266e167648907ba590ee1d85f92a22ae0a1e5d739a0a2766cef68c3a7ecc1ddce448be2d2aff061c7e3a40ef103ab98cf1c28330ff169b09075fbce9a9d22b38426c4c8cfe61d4d32ebae273a8c8f41737f8a06fa7704a4744a33a6915a0e14374e1590d0930236b9301bae824e6246427b4e6f32a287dd79c8439ff4df88f4233dfaccb065038ddcd3ba47b778a5e3beca0ad0b91acd2da73fe970355d261459afe682b4a6ea8663d10505aa82f8c73fa4a2acbb9759d3f82c698b880f79f8e7c6681e96d9a173ff3767811a4826ad8386665380522c8275bd4a7e7fd61d3d3caa100165f4d83077d014040bc6a1430b986ceeee3fe3a9508aaa2c83af12713aed35ef279e4e9918e69131feb1fcf1506082a07dabe4e365de47b355583cda015c371a02b49d2052481522c845880469b235d63c221cf99b1265a828d52802d63f1f466dd0df7d06f766a036026df92b81151b7248b3ece796ea4e45eb38c43df74ad77f821736379852bc5e62b37c27b8d542d0ac79863438bcf438a6a9c3e8c8afc9aaed37af414afcd697b07a3d2d5bd801fcd91ede16617c6d2da16879d20adba187d0fd2587f7d79053805fcbf50d619436665f395a20face7b62e05e2d73455fba552f544d47ecd6d6f1f596cf08fb766849d12dcd5d7810eb6dfebce13b0af4c344ddf59511afcd54a4bb82aa1d14d03585ca665f361faf65f26eedf7dd6d907029747e5c6eb23a9a3f3c9921db03a9804fb7e88839cbf8cf204d9a6781661433b7dbe0bfcb11f2b60107667d9bc31c5370d293f9ffa11eca5f88b1ea9d1378c79eff661e6c40a15d990746144ca7ff19ff4c84cf74b1b72790a9dee0998faa50781306092a3b34ca17db26aeefeea5a7f841db6198b707822ecbd45be3901ef92ddb52f5c9cab9de1f1d76be07f6dbbaf21b3abb6c6daa61d03035726b2ea8ca665d7f0efd17bf658c088b75a3ea874ffdc16bcbd013066999730810dc7059539deb2ad9099199e8a0cf045cf9a37f7ecc133516a9e5ab2e82dcb41a0376291a3a62b62b6f9d790467725d19dbc2e86e5e624fe0ae4a678090287b63b74494272bfad06240a0bb518b0b4f61225242e676cf09ab49627be0791dfe0072a250d6c194d14608bfa1785b9b438cc5fe2fdcb42cf435ca4f63f6eb508fea7523138f308c102fdf76c334a3e78bb6cbaa7a0de0e9376a5a4d8b2f8fae5f68846eea95202d9b60e758d80c7345d0c672b864fac11469294d73eb0e2f4f7c536d6d5618162fbcfa8317e6da857073b495314b96a4619cdd72e3ae4858848ac55555ac9279503e9ccb0c35ee048a1011b586f4b5fbe3e8b1c9150c82151c9569f3c35ee52118d1b20bc77b4238768f7bdbe1b865a4238bea6857e2e9cb8dc081a91cfe5bedb4f5b61e98392f4c7f32c74ed31e5483c92b42227bbd9728b756bc60350c5399eb930044431bf60e70f6b79ebe4cd191c8e5e7297116663a17fc4ee59779a03974f66c033c5aa041c39fa2329830d3a774e27402e073b34deb5afb8caca802bd98044caae2c4c548f91c99e8fdd08e088009bfaac3533f6847dc1e429c59567a698fc7dac17b69e4827618fd1c88d40d1adb8f09a9d350353be3341f6b3b87d9d9bebd16ef115e91acf83302460628264cd8bbc189822a2d8e1602631a908eb7bc3dc023034c612c5dcc5c4392e35f59086d7dfd9ed984c378f4583b2552becb803b07e0cf67e474098418b5d0f07ca80e0ce85edf958463aa933470f36b1fd76a331dd9af9042187ec6289038bf9b4916ed1e2434ec01e801f2df87dc83bd139cc1f40402624d0523b4b2a3c50f3b8772e1be1832f818840290637d2f63b2f41cf1e35a789869a40a4f2f85e3a6aaf14466a3b4a87287deef965058bb9122543259717f664ea72cfc801c9e335250f84fb8c5c1c270b864d1d41acce2fb7ebb2d6f5d39b1cbd00add4e5193642e6432b82db744f3792f2bd64e4afb27287b7d044ebd140781310ffd3a5fef5766287e18a7158047a78fad329fd9a217c2cb7b57b6dbd5c8595fa11331a67b111d11639aef3f0c565a0c4e554efdbdfebf4b53d9f427378efeee838d0a11a7029e1398c9ec1e10d291b5b30c75e30f5035bfc073422fc40822620be73dc6adcd31758e6226911176186ff66c47e0875ec11883f58b007e58f4496fe16d822b794ba854e7fa6268e928d146173b161992f0395900db73b7d1e440d168ba8e090ba85f56f319c3ddce914f48fbc57c58d73d8ce70c154ab32548d2764327dcd941464e5bb2fd548e0ade103dd482e1b6d07220d26cae63fbadf7a0d836b2ba25b263d4c09de729f19501254e7d31278efc7ffb7b6bdd9e4310fdaf49af3985afea9eecf8f3267f88d5f1d7f05a70a44ed4caea8b5ec6c7c18accb60df68f60a45855fa806bd9edd8e5a0ec8d982812295cee2a2ebaa5a908c2e36f429c047fab00cbbd90039300b6b2ac632074e1e614fcfbe617d8ef4a41942b608c4fe723935cb8605a238fae2f641aec24eddba93fcec637561827688e0b3bd26fc75fca046b1be5d1839be9e33e594b01382ddeb43bdd948e80c78f6c0a8f5ff4c638e935cbfd870c2e1e9f4374344156b1885b82e81d97e3fe89ceb31ce5a86965f5123f1871acddc8f95226c95bd327bd67fcf279d0a5d4ab9c4f2987def0802a7c1929095538c7c147fe7f017722e1f08ad408934305c70f55a03f4f25a790777d0cfb3b821b07164f6d05e1189063e301bd1cd746c80aebc43fa39351142e46decccb236cca0431928ee807395e6b9fdc93ecebe57e0e3134edc780a085ec4731490245fb018ebda02b10b73c4a6737d0741d0345ac3436fbb3242b5ee2ca52dd8eb92b8cc51b75f60d2e3641a3243752f252f720cbbd5c4f02ec072896f5ff67912accfd56873bd821e457719961006c1dd8c6304f6063c4f26473870fbf4925f8b799bf30c7eacb4cd8112378443dfb80390863cea86454afdb469daa9a9f4e92760a57494acb920f4b28f51de24dcbda317ff53377673ad491c1efb252f96cfd713f931c40fd85f90385709ef6ada4de026c422734be6fbc9b7f96d8357763181bd9c73bb65e06a4e7985d02f1ea0db7690e27f93b8be8189f03a51dd4322f5d8e82c7fa7859cfda987eeff31c03e1b0cf4593f00e875e245ad515d471ec98cf81f4ee287bd200b121683f0dc16afacdeaeb522e875fc61e68cfa9da1a5a600b7579ffcba02616913c84478e4d38df963ff400e3acf7af47bb7a791cf1c00af84efec84134f09b02f54eca2b3817b93bace117cd1472de2da60d312983814090c0d309ef15e5e60abe1b5935f1e5910555f953679b80bdb13c213fca463ecad54ddfc8df0cfbb2905e9870ed8f94bc5acbb5582b6d5a2afee1d64193b0156e8386a4ee58911d73a3bcf8ca6ff930461b4419487f5875ab308f9b6e2163d9e386ccd4100c0fdd5660d130f73cbbb719314262c40e99c49e78ec1c8cd5dcba76dc86210501bbe89cbc87d1597f8d1f93c872625136ac6d5414ee9e366b201c03605f2af6e645fce46fdc65f36b4e588965b3656fa6fca977518a9f83cf67c14faa0764e328c036704699e6e62d58cb1c1945fac1451a5be4d6143977604125aaad3efe4d8bdb39a4346385a5f595d1bdf2c0cd034dfeca491d9b0d6ebaaf5ce534aabbc3c0d1df66232284edf7f8ca54e95160cc99760e3763bdb6641d67a1c9a4049e4d43af0eb4f0088b927addeacbc4815d78c892d237769af55a32e0f928f452e805d788c57273540545e320a45fa90f286421cf80cd89f992cb3ad1e7296ffe2adeff1f98441b8e7939586cc4226c012867bc0ddd1188105ed062cc53a6e213529a285edf04ca45a4ac421aa4a0fd0ab17078a7418007de59533eb31b98964da3c4dbea65a6248cd84a5c3b057fea92d759f734abcf7a167cc05b399100a8aeabd60f13e1fe5bfc9c0db3dbbce6597f3163da7bcb4bd1fe9e9ffd4afa705983272d1c3249ea1ee338641875a04873d5f655e9a4336e5987c3770199f99686deed7b04ca95b8e7f46804413631b7d9615302b754d07476375a34b80337f848f0fe7e28ba3e2496789c7b70fa0b130fc8d1d1c12d8a65a04efdf0049805d6122872468a508789081260ed16ba9f4d681ec48f43e0081a0f46788e3060400ee5c7d420a78d35abd895a24e894c1693e3725286964b342c91c41ac4cc449e8b0b5fd952d79431944da65e03ce2930337f9410b3abb704a981ac63aff4fe9370a232cf346e39f58f37e489de4967c153cf317cc68b5e2648b1cf11b6436d106c114e7448913bfcaf20217e18260e1cd6ae6fba21694209c6c16cf963e93a64579f88c7c32777602b0220c69a5ea52d61f827087a93ca3fa4747a0e4eccb5503eceb77c405d212a3374da710c191cc78e3ff29bae2064e2f5df68b98403afeb69521fc030666cc0f89b2d8a07affbcd6d622e7c5400e981862fbe705189200c7623442a072919fd1d22674145f365ccd1079788e27b57701f269d762c0c4a6e11b3955de05ae7a1d708478dea5f866dc88215223fe32d604503f31ee7f7c498272ae9d9940648c9258b20bcfebfc5a9ad90596689543649f5023309f7a4542f607d465bcee85bcc960756e909c28ff7901a6fd0ab7a0d1f1d68cab3c3d0033bea47075326a22b224bd00e9f8febeb28f07c00de90ec97eb5da03a26a8b3a9f2c45a345b042e982f05917ff78b5270a6ab4847d8a3d81d3a711d19c1f30aa20d28c70de621798184698817b11c21e8c1a35f35176c8fb281be6fa05ba03a6f1c8b733c67f23bb93809197e8e4caa414e3dd145faac4ef5063a6e80e2c9b08bc77df32889d14d5c350c96fd1a8061020f77e14366885ef83d34ddb2168ceff550473e634bff898d21ea2af07de4d22a2845d67fcf82b26f5987b4006910c3086aa2a81547dbde42403858c1769f910f854bffe03b8b8ff5ee31e3f2ce4af29210ac6a52b8400a71427a8dfb67d8389748fa40a6dae72736ed3290245324857edb95f5de875c5d526e578c50091894e9b6fe9b5a9be210e5b6360239da3ad2716db44502a82974377f16a35c5b21f7f92c1e39a74a7bedf61d3f1e2ea9de63ed7fc69fd87b96a0dccdbb8c2abc61ec8f584c760d40596be158d747eb0b708b06dedf42329f5ded22e41e462c6cac207b37ada8ab657fc5d5302e1f0e0dead14eba7ac5719aea771f020abeb5d8f2d17f6302f5320bc46acb168e6f3c5a499d79dbc366940798a9d546637368d376a59bde3030e0cb2359c4c899295840e1feec93a0f2f7c6b369c8cf5fd4b9f9206efbd3b762865b991efc08cac575128375fac12ba012e9c1c2513f12c36929a599a598be3854bd8b80e2795e4722c4676d90d95e3c6261b6f1f45021a241fee9d7b7fe510755025577e2d4f3ac0fbac6d3eed67ccc1f772924ca8898422d6e1044bc3087109488bde0c31cf01f705f76a93ee77008294a1a120d552f5fc4c7287fde6915eb2448c011965e4768cf5d45fb97d187b32c5294d1ffd3546b92d2058a93f3a10214dadfd0f329be6f8d414b45a13cf6d64512d8ac06be571a3486794cde3eb59f78584f856b350ab815396e782a814d3b300f690b515652440fc6287bd1e730a0cf71955f98688a87f5b2091105c57d5cc8c51acbacceb627d99d05f97950b5d939d4da8bf684b4986f55f427a461d3bacccb863c3f0b840b1d8ad80dae46fe04b8f644428db806732a7ebf4075274d84cffff4f25eb8f38fdf87fc2fdcf9c77f50ffe58e7ca80745cef9f9c3abf5c82a53cc1144201e5da9feadacec1c758ca29795e2400b3febf3f0443d08dcc16fa97d30586da723dfdd772ab79c4ad89ffaca015bdc3cc278e1088ad77c46a88364c3e0ac89804000cecdaee3e1ccbbde11a3b3e6f959434e9d4f379c8f82bb75a82a98cd98014351cb04c8f888996cc05dcc4b4c64ec6fad8d2b65f640c213a3280b9580877d52dfbcff0edfb069cb06dde9127dc4a9d35fcc7db49ada84fe2ee16c7019f5561f38ffc799ec1d474f997f86c8cef071fb948b7b63fc1fb7a728b87c299c6724f6c531dde31b253c3e8e32793a49b40eca60a6eceadf16f3ef72a1cb7bfc48964b29925648bdb5c1d95201dafa410bae8f51dd61bc2b192180dbaffd8c89449f6727a24f1464fe3e9ab6f65b4ca424be3363a22132ba6cd534105b01c47b9c0f9dfd05d2926632f971d377f2d88eb50d3bec6b41f44bfa1c0b41bc04a85b121eb7978af55167cb73d42c4741ccfb3398dcbc778e0e214f65bb48437d91f8f2041767fe98acfa3512b62328dc83fb71aa1b09f7b86e4863906d44442cb5b4b00b85b150315f2a595b569b4e80d8421b3acfc99ca87107482bb2dde76411f6554fbd72887267bde8b2e86e3759b61320ae170df1b141e7dab90d146862817997b53113f801dfac528c6810be7de5292c0c8af9bdd7db2cac55dfb0eafa670cda1c4261c07cef63b92d55a8485781e7bfe057ac77435049c48f089345dde49ed990a075812b4e4c750a797eab4c224cf1f203abda4b6465eebd644f3ec6a42108e881e26f84931d8b7b81e628b4fe30b3c83990297e2d89286588ef76347e732fa6675a5893a34948ca1b5a9d540045fdfc49af50023efb5197316f61f14e86f783c97beca335f8de2ba56392f39fba0af94b36cf003e0af14dc420141cddbf00d06f34a7f39f91ea767c3a15f0b83f7638d77ef14a285ac5a27c452359012a89b91d791b656a330293a05793ce3db8e9ce172e242a758cb6c73c6765a719174668376fe1ca66037b2ec5e5c9a418fb7308afd05937c46ee17e10e6a8a392a60009676406a0c2c98877bf9925dd22184f26ef09acc79521cbd2fedeac267f66f8f02326248bdf801d1ec4fcfcad2a5f0dc0b2e1ca4c1b62cd0868f5bea91eabbdd68dd3b4ac9cf0f5fc20686962050e469b32ee03becf38ced1b18faa0e86ed99a220caf39ce8685101254c60980d20d6b771f7c8103a159886a7a224b2dcc4ecb29115c9b5af2f43b1f560906c061c7649fd450f9b32be05faced55d600585d272d62182392b71038187dca4e5e3daeaa7115884ef3812c249e19fcc2c3dc6db54d741b742d77f85eb3a6b68fa30e771514d07a5fb577198022e8ce97df06c52f9004da32eb3f1a3ed3bb3bdc304d5f3440aaaf01fb29a480b0034856ac582f4e2002e6ab4b60d457665410a7fdb2fe53ad26d2559e8fec5ebb2dc0e24d459f34c76352e2d6146bf0159d510507948d8283fee22f2bd6f5845bdc524129d1eec3d3982ea73fdbff0ce26eba81ebd83f6c3779760c314ab2dc75e0223d45e23152a6d741f3333e049ec47d2353efdb2fb0ccd11a5080b682017da16d2aa290cbe3d8b8b101cd113e7411ad54365c69711d482604415a220121c60443e6a88d9ab2add8259ef0ca1ea4a11a0f9dbfa5af97618436d23807171b3773419d8fd3715e296cb2776e31e0c4e50d8c9cd2c12ffa8d3b0318812dfead817b50f52c6938ca0f7170421824004a9051e9ad8b3f8d6098b2d768e375b249ac6bdcb70422bff81f6213fcb49a6444148e35784441ad5668832907b41c38da79094b658db41310b8a256a38c79aaef45e312bd7ed89fe818db37d28a52f17d272d35b882b947c7baad0560089f0b8f8f0d0497c717b34ca9fb3918b2e4fd15bc837582466a8a4f543cfe9872a5c74c2ec217992ad29f3b68df7a2d7a305cbececb0adf1ef4cfe8fd242b88cae9e758c0d9720e16884d47d000c823dbf00f4c3f547f0b9f60923381da81dabff4bb057b9ea621cb6b084f481e0ecd0c7f59eeb20c436033dd95550d6b9cfc7a3acbe4292b031ef3afbafb45cecac7b1fb884b894f14f2fbc2200c8d01ead20e7783a0b0625290f0ef12275db771c6938b111860b03d47fd6a5654c9206dab865a334fba21409154dfc0244aa8334e64cf828031407145209541c4141585e099b53aaa9635ce1bfac6a6641c3365a38f29bb0e5486ff1834b15416f5e00fde236e685d2ac44c2142f1d031540ae590e25f9b77ae41203a8453cd8fdb8cc2564c333bfcf416382a2a1e7d2c54593898ff7aacc48d08a1b91ce7bb4f0d888d8bac28a23ab3cb99c88211d3a41a83c46ff02828dbc5090ebdce874b0aff96d761ecb28474654d95af73bccc0db336b85436181533bbc44788dca12753c9688dd40a616a77be9c63ec0f953b16abe07f3fe4cb0c1a76df506672ee298536f7decb7fa3ba31019f3871b534c5ff9c6d370bf0713b722400020e47de894d0636c9ee35cd919a6563a41b3656acd7e5f284138d9bec4bc9ea7ef143981c01b709d9a278f5ebc0539bf425055cdb5e49280d76d8e78ded0c8886528e087deafe578a00d018239b4706aecb60cd1e78de63c0031c0f2da4d6c0e285057cf333cd76abbd7841d382919abb2b5f6636a2a1b6673331c2c2c904a0e63ce3f07baaa3b07d38c94814f010dfe223fdf4ac55da1dd5b10ad5c8a22ce11e0b84f6750f6cc4928ac15857b4c97fea1f5bddeb61770dd063cdc3699c8a3e565c612118753bfec001fda1561d7ae9d4c49fb2f016b85fcd25719bc2ddf4495519d7e67f2b68fe4a9c3411d6eccadb75923deaf3dd6b8134e0db4d8c4ad4e540c4590cba6328250a6dfb828a8d31f4901ee887820f55e98be86007c536544e42c596f29e22e5e7c84c1a0333c8e0ae1886573e027a217af16a3aad1d19eee6b4685b2f11da0536884996a2ac3f56482d2abb75af03b7c11b1f1a315c9ed0fc706ea05e4d6777c2c8619706096728e67a71c4568e5d2f5bd242613212efafc2724d0b285028f3de90fe5e13f73a91a44aaf8c4468964c0a304ac5f606a1658e5878c090f378c1807d5ddcc93ae05664d4f8008f39b1bcf25fb4023be12c35aa99dd96534b7d635016f62a940142493c846c271b58d570f116b9e041dcc9b49a49c19c97958f4f71c304f2bf95406ea1905cb7c444a47e6de5c0b0bfc7d69e4e9e1d1e82f2cdeef0f8b9b3da525a98ba3eb5f2b30dc92149382c66098b0b43269c50230969745876c18a072d9026b5602a389134aa4d464b4891cd0a07e411cc4a1bd65a99079f0a7b12b398ef84c8c1a4c1bcffb9ecada023c5c49cefb6fa637026b60a2d1706714913b418e0aa48038e0a27151d09a1f37dbe3f5a1cc643205b6a4db07b93203cd6615d6772b90929c7e4b09cb25fa17ab8153decd36d5a30f8e8c5feb6a3fb9cfa501685356fc5ab3b0bca218e1cbddf36da933dc1549307d90af050982e9846782f6bea09639f942938bed885b5e127c5653e2987036917d4f827a9f27395fe798f9a8fa85e1360e7a41e31fc9ed48a6a5a3f731f9e084239335266f3cfaa55d4acaace0cff2e4d50838e827c048d6f5ecc90c3b22b40b08f46947260a936490812a24b2797491f9d0c7efb648689fbb4581017fefb48a6fd789165046e1f32be3b90dbc27f4f2458df96b40d42b7d14fc36e06ddb7bb16fe2f0939fcfc5dab356913676d58817b792381e7be71273c1765b5030f63b489ddcc6031c518ebee39d01965b662c43e0b079325b35c3c8ab3d7a12bf4ad9bc23e663867b6e4dc3f0594c3e5eceb977c823bfa4fed38ac4c51cac76015e0e24309edbff13e33a1b7aa3d0d1975f62b5226b76725f38e17c6fd459378d699c63ad15f2d9d1a97119b9ec4c93bbde50f949c5cb31dcf25130c38d50b19f8b433efc3986ea1b6cdded42ab7123904ed947ad71b9e558ead72ee025ded5dbe22317a753ce0be949eb84ea7ac393c13d3691cb9b02453fec381438b86c2c2a9c26a729b40e87da150996bb75dc60a60091196e2a13d6ac38019fc65a14b630eda302d8754bf6f638921e1dbec655f0eacbf9a87810f58c1b0ebc21fe77a093ffceb43ed6611346ccf5b0cb4e507e6c02eef4e99b282ceedb720ec011cd2440c2e00c13f6874966af0e46d6f4cb5004cea4b10f383b4d44080c9baddd64bdffc9371dc5620c02111f91001757def581a86f0e0cfea2dbf3a58922358ddedd7f822be110efedbec21a9f37297972da1977ad8d54d2c2d38ae4501e78343ef0401d001ffcd7c26b8c3da7025be7e4537d5a34e8171b6403e300fc84b1df175766b0631df873e058f56cc16d9abc2cbd9d72fbeb4dc03c02e84d930c3628f5f6275c0ef2ca2536f532c79ae7b0af28aad78fb38c58bb86f677e834963858afa2c4b6a771db70e830d6717b5955b39e5d01cc61f178de010c458bc101abfb6e81585ba4b75ea482473b0c1147159bcea3f3b510f6ddcd366c6bcf32743e4889ab4bf4cf65aba36f88394780661e5acfdbe9dee4492834b44c870d15cf7aed15dcacd3cc5daf632c9b02fdc5ff3eeb3d49df3a87a9fb4f769fb7d5ef8dcac86ff1c656518b61ad4a60f90776b56070bd03b975392ba17219741a242547040fa49cf4231f05c797544ba1a3f515fc36e9599a6a66b662ecb987ced927c61aa89d69977731a8c2f4c7dc115e708593d0be0b8343ba33bfa3f7f8081a2ab20f4832c0d3f36193a3f75b1128d8d53ef63b55a28b78ca7cce2ab9dea18fce3301bd6c4cfcb51869aacf90aaf19b615bc0304609de1b8e99ed9eb054b147641507f89e14bd41973f38267d1e2bfc97d9606e5aebc9b960e8e2714258863adc91563c8df39f786fac605a0e98e7c4e77840ec7b1ab37a285a72e5aad421110ba66697e92e97f14ce6b1a7cbefedf01463defc41a2d49b9a8d46ab795f286881a6e2c1b8985b1d2e31e45821c5b54f48c2b46910397b7824ae67924823a09281ab48846f9213d05702fbc40f3f2c267b5baa447cfab2cfb2325c4e3caf0ea671e5fe782a9a4a8a3c2ce4b99cbbffe5e721ce7c5d410210fd69288c77296399c0e69d285dba888ce3b5905167bd7f9ffd677d9063b69767be6524e67a8fcd78e553261686840fd57085f14871117b46dc53b6bed0065aafe3071d167282531107fabfbbe79f017dd53c3c2b0ac5ac293a611f900f83594fd2e963bac14df17fe493383f0fa6828c5cc7626d1555c2bd03ce91a6664b8e7c8347fe845487c7954e7eae9c66ad0196ea554cca4a96d7e5b83758e9fa964260fa750aa288452f83cc05489ec1f744db69932978e06ebb202ec8368d3bcec8a4148fea5e573b538c55f399bb3e0be21892b7cb4ee3d491cf2aeb1915458276baab0045f9982e47ae0812e078cd670651eb45eec11ed0a50f66b696df433f89d654421dde4b9a5455fe5ced1907904cf1b6f21a6f599ec8bbbfe2230d6aa20f8fa0e508e02ef0b6c74be8f2ca5cbe9f11a3b96a8d149ad30178aceec85243baac1cc63fe9a3f090f5d3413f4734d8dd2ed8fd9228f755d0f786d83bf7d22e0fd52f47b06e02dfd0d713fa47d1505b5ddcec8e7f4803d20cd7a65bb1a3374c11e0742ac9cb6bce4c3aa9d6399f12d461c565814a9a829f915f6ad52f4fe5bcdf00c65511cc4296df97f1c043f9579596930837130dc429172a5deb6e2d30e91252b45b5fa82a93f550951e40e736900128b33743596c13eb5bb4c343768d4c0ae96be32c11f0d8b145dcfcdd13601925dffafcab77a90b00a22b5045c8cf01f94a2cf4fa92cdcf2930295a742059c352ed5800cba984cc6da0c3609c37e17d8e63cd1df307c530087d42991fe223c3300845b91538d1377a38e450df8b689c731434176a61408559d89aca28848511e08eed4c58bbf0654468ec504ab2488005a7e6b38eabfa11eab382c548c248febda09406df036312cc58284ee8fe002d9324edc3716c7d243dbf028c6dcd2ba8f974df485b3446f36e94ffe10a1b2facd51fdf1e7bd7d383acd46ca3ecd451f33ab83a723d1861eb8690cc1bfc3a8af310523d27217e0250cd450ee3f4c3d330fcd149fc454c160d76c54ac43127e18f06ff780efd37e5acd23b0d3c510821b57f1a6bbd11ce7199e48119f4416f35d4f6c09a84ca478edb2f295b1b181e97f167363c56144dc41954be8d2ebe57a7ba472fae0e923022db304cf4a34d4b6feb57f29aec7c8157a85a7c2330fe66a5b891276400d5e3c129e00181ff206974ffb5fc8ca6937f4ec04f94ea0b1746078acfa1a920e6e13d617fae0b9dcfc58cff11485ff30cc40fc264beefe317109c2ab2557c7b5aa517e85f579eea9f7d2c338b5330a71f886ae437566ff9de49162c3469535f0722039fa066241f50b0b395b2eb398cb5f1965fc36e7edb7566c10238cefb4e16eda8c58c9c18bb6c002a47099ab7ad19aa6f1db5e1c8eafc8f06e7a66acc4f8a352970e8eae8a89473b8c420844df35bfa084675b8c6239f383104505d20805cf5daa70b7c12c309ef1ca5e73fd5a78f89698fb46efd742889f6052166b124196e3b3ef684d6beb8bfd23af73ad3e8b385fc083ab8d489266e058e81f2b0734a771cb3e46c32050499bdf36069ba8a5bdfc70e2688380c8950624ef37749433df8678118fbb84bf36b8c5790822b6cfada0880f78e668dea679c848d1770b6c0368496f3e645ee89c13b0280fcc6800ba59be1694b7d52c53c06b5b78cfcda3cd285c256b3399d8add51513bc49176350e3747db0c057909bfda2803c86640f59c9274157a0428661ffb3bf2a0bcc4f421e7bd709b629c79cae3a98d1f6d327143a100bb81e671f5346d75aec786ae2e843218237573ae054c8e16331cfcac1eb88fb469a8d0f423c6691a1960783bcc45e8ef73d471bc51745f0b43ed654cfa68bfcfac153b67cf47e5b15becfe8ea3d65126cfc48cdbe451741525f0ad555d584140e9fddecec7e2ccbdfe371de490e202872c1207419c1a7da9edc0498eb8dc2d067b61911a20a2114ef8d7a1c9db08cfbd8acb8fb5d99cfb68821adc933f7c527b54ea9e2389f3b44f21c598c30d8e294593c061753db657295c8635ff04a5bbbb4a095fb840c8f374c86a94f7cfef01a7058515c72b9fd6401d11d84503a17fe8f2170dfa011029bb7f9ff2f941c9a9f9cd88377fcd6639a5e0835913900dbddf7f2d174e977c084b2a2bf1fb316dc63634c75d77ecee7e6249c38375f764f8c34deb0255d0885e04e64e18ad65760274897f305bb3462d01e26ddf6e7ff3f4f8655d3c15a07d69b811935ade811376b9ee782f720eec76ff4bd865fe19a80b6ea2e6ba7b2ab91ad2d9c55e154df345662f8f0eef073cf966ea654c6054b398253e8fd982be2cd786ad807c4d24b1f2b2cc5eeb1e2c8982055e1f29b7534015981a70d5a599e92bafac3119e20b922aa4501be54aa2d2bbfb633185f8382ab47fb30ccb3ceee7b40b400a8f4521583ff2b79cc2122e8e75681652b273f11cf99a9534a41999d5e95939a31c7031f2f2a4eb261f77df0e55bf20e569f6edc209870ba6c8e9244cd1d7a11c06d3fe75ed150c7709af0cb66f62b5ef8be7dfd4df51368ec0f0b76478c8c7aa9fe2dd80e0ee4f62eb32d7571ec67123a9c10f31607fc288f82ac6dce718953fc0f8f32523e2ab18739f6354fe00e3cf978c88af62cc7d8e51f9038c3f5f3222be8a31f73946e50f30fe7cc988f82ac6dce718953fc0f8f32523e2ab18739f6354fe00e3cf978c884f8de5758aa9ba2c175698e00b52ef2915fe9c2cfcb2670c7f63e9f72cd5fa1c83f80397671f152a862f62e2db95b27f80e1f0030cec4f3224be8641f7e1da9ef231f34e4362d562bc1b4b4d7e9801e9938cd0af66ec3ecf28f941c6a74fda747a90047900f8263861fa1f328c01ff138c9caf32263ec728f701c6e72f71d7d28f8ecc0040b790e67c9531f13946b90f303e7f8991f355c6c4e718e53ec0f8fc2546ce5719139f6394fb00e3f39718395f654c7cde26acd941fb0423fbab8c89cf31ca7d80f1f94b8c9caf32263ec728f701c6e72f3172beca98f81ca3dc076af9dc2daa6ad858210cf22da4395f654c7c8e51ee038ccf5f62e47c9531f13946b90f303e7f8991f355c6c4e718e53ec0f8fc2546ce5719139f6394fb00e3f39718395f654c7c8e51ee038ccf5f62e47ceaf226be83a3a0dc262787ecfeddae45807f98d3f33c164e1061f1f7f9ff913cc25f860febae083c213b0d2993f334aa5c282ecf3991439d95ac960c3f504e46b7f4bf5149bede3d02e9ef69c64746d62735d0b8df06cd8fe277224d823e5cb9a1af4f9ac9cf22ed9a83ce2f3983be604e014284eb378b14fadfb297d18da7f5ed71b770f95fcbafff10e4cdc4f25b1d8d31609171c1d307fbcfe9d78e79c1d94faf86fad961e660129d43783b2cd73efe352cdc1f1ce58525e2dde57a64c5e43dfcef1745575b51400d7a0e05f66e803e71cd03a7490fcfcdbca5658e3a18e29701cfdf892e339d17b395631454a7dcd6e67f4d7871da487624365ac170e6a2e9ca2301e11fa3c202510d2cc0c3652bbd2d34d4a4e35688c6361ae9a16a85b20eb6a99853a71b50d86a46d23a239a43b44ec7e0dcec6232212a2bfd71c039a6a40834dfd8d3b8a0b267a89c82c43787cbd0a764d963e551ba7d9d23c97c0e537a41d6f5cb0ebc595e8f0f7d0b402fc72d30b181a47f256d8883ceebf9c639dfac12b207ea5da70e481b3d663d911dce4233f779b0dec5eabea4b062e75d31ac8cb696882974e9d5411d4c79cb2c7a189397bb14cf301e8d7b0912a99aae01d212a55863b5d9bb8f4f31652c68ff16ffb9a4f77c3ec12c064f66f6fb5f9dbd391ad48d506f43d3a0f7afe9561ebafde9d92afdf0d78238ac2e5c1743ffe7be636498d789c245846deae3531861616c5418fd2445e554b8f720e292b594f2d9d1817a38478b42d00e40599a914a803de046f503cfefe1a1931a93b43e90d613e264f48731deb8b3f0adc929e7de7b3333f01aa1bc684303a85bb883c5d275f0597d7150f81080831c6c1e358b3c80cc88e376a2328bd8fa041823e9afc505dd415b3a5ce60f524f9bfeed54bb4b757494b8bdcb0110a5aa3bf5e17ca52ee7fff2b4301e0c18e5ae47aff79ca946862d94e0adb31326bdb32107b8fe2b3f99f3921a0b571536467e9922be7edd22a6ebdcd73deed1fbba08fd0af50b14b0ea1ca8d6236acf69d10e51f22a85595d3dd19f9c17d007cc1d680995ab7b5ea4ebdfceb76b061ab60685d04e6f74abc089188763de79a6f9646ce5d32889d2087d2cb71eb06d168168ce358f97be021830e8fd52ffc4ce95e7505d0876138fc18ff6b10cc5cf7d010d531e83fb5ff8eb15a618347ec8b290ef3749b6da54585c56819c8ca1d874f730799a8bdfbd42e81359996464dcc41bab4b24f27ee092cecf37b6c3efceef9401a9b2dbfa3a09e2e7af0543f9cea26c019d93716a3b564258c5362e5ad1efb793a5dfc80cfe061a895d524adf8c6abddee2cd5f2f0b6207566d2e120c3dc47b464d8b933fb03b2dd2f899dc6c186746b73768ce35de49fe8c3399abbc3f7df138bac8233af7d8bc199e6c061d27efa0e563492d4fcf7074a0d7208f2b123fd567dd766cf243a4782e9e4fc17c52e4be4213bb9ccd3056fa725441825fedb2054bf448610858968b82527a8e71af4b4fe1e2c18d895593670fcc96bdd019d71677a27b2340263f16caf12278db8ff2f5dcd5392b86a5cdcbeff1f26ca9026ed34a45e6eae356c1ebaba89e8eb97dfaee245c612b95be88a851957b57271baac71d6d5f20950568bc88f1f7aa8736959d1250b89cbb0b08a615ab7a885c328b3e3bcf92cb036e7a02ab0d1ae849931789fae7ea0fa47f8c28197e1187fdc3a8342bb5fe89eae720f06c65110eb8449793f649a5bf2cf454797eab7d9b06006538f44fef19b01fdefbacd215de0bd391d1bfb83fef742b249fbebc4d41c20224a02836024546085e497e82f1fa0bc02711501d0f7b80c44f03dbe6a1320cd59f063902dc116a08e0e7f14d890323bda15d326b407bf83762d6014349e1af2d282a2fd417824f6e7c27035880eaa20d857c06c0a790bca2bd6c1c5a14c1cdde6d0f9e951ec85ffb0c27113984746fd3c6446d28318b0070f5df03517c44b0901a3ac8b7eb59777ea44c837763b9dbea48881d68cb7f55e739cee74b44c29ac5504944e0f889c3d586a30555b186c6f072039637a17eaf4b2319ea35ec179f37e7dc4f838f1b452a1351d58e13cc7c76a014d57c7ffd5ee6a08e49b31ef0132163207e4bc7f1c37f2573a9d98f65521038fc6108d80ac5feac1964a317a816e855af40a8092ef996efdd66038ef68d87838181d89e68d95a1d9a5a8301989e1ffe0089695a97f07086077abf5246e09def598e7161114495c972a700f4a410f820c6dbbe6200b4f2a781a03b6f031da2320185083a4c11ffa84dcd7247968e904f0026b7423510660776080f9f7a198d5704ccecf9ca1c92adc1fb396251374170a336d7ef2b1cc8e15be0b95dda699f13f0599d89f2bb9b7d6552d2602da82000c69c16707ba63a31c57b0fe0c9e08b18baeeb398824653dcd57221b365da9b3b1173d69f534c11ab4deb925ebc6f933a1c5ce4175b9c62500e58015f0f7422468a1a7a5d656b3c38e9d1cdfe28b6f44437a2af1b57c8b96cf74540b37bd1117397a4d26ac2304dea1db327eb7bb8d0efd894a11b3e0113f86d0d0bcff9ee58ec73d51cbd39188babf725409976e8be197f63111bf4730580110595381e9e54972fa8c8914dd870ebc3335e00c604db6bc8cb4c062462126e943d3075718b22375e4f22a7d6f9e9e9c66116f4ce98bd976d0d364052b239ad7287430ddbe699c5a5cbf9bc27371ffb2481257bf93596fef82a58c6aab6e56fff050b7d0e2b561dbffe1df88e16136c3cc1bd0688ebbbf29abefb35ea90b4ea17b6fb4659b2849231c0ba007811704a10c1a400cefd67ddfe2c25804c397b6bd7124e4d9ffb7f8f233b01b3b0b35dad408b5593272920bea589ed94d1c21d44bfc5c4af06200cdc5c529d8f22199c52b78e1bdac485a934bae47d068361f377ba3324e225de7bd7e66e76a443a7bcc5365484c03f3bb7392f33970ac25e4b566453cf7294ec0558f6a4d6df1b7badd22a8a67577156099e556cdff2b2cc7cb38bb1b88194e0efe637aadcc5d01816d65f1ae88505942803d05fedaa9ceb3cd298eb94dbe75c1ff690730c6c3e1ef65c2f8a7e7965715d907d16b481d2a868b70fb3377c1cd0d98a0a1c2f9d43750e57303eb6a1fa76243d9fef918e6dd45474cbffff659712f0ce36d2f981d10d80c96dda8d1bb0695a782f33200b596c921c6d1cb5e7537e62d4f4f5b4bc6f7a6a0b84d958713aa726960241815c754fc2302e8ba26c318c9621acc08581c8ac61c67f160c4b14d9d0c98936f21d2f456f7f6f03d4665709c61ef18c74dd8d3428430789ba03a2f7d3230b12b226a0ff3055d35881f6f846bc1789ef1c22e9df4cfc5f9d60028b8bc7c142714060509ee74b388dcd46da740cb1818c162a0d74c52b3a7f1fa816f92244bf3b0f857f2d617b77f7dee6cd4b32934f1345d5c4f1e8616a7700ec792f2cc84e002c3c118151d92c079accc9bce80c08ef6aa4537ec964b2c3f27a4cb6a65104549ee9822984955a161983f64108241f0583654438cb9b133ff1d4fdd589b1cdb13dea96bb4b793f733ee6bba805ce324bb4215bfe25b4e8b25b3eac47a0d494c1349a7fda6a565c09d1fb205b22d8c63dee03deb9817be73b39fbf8c5a2527228e0515cfbc0ac95ae17f94b9f0eb88cdf8250ef81b77e02e1e5012a21e83ba735632c0d3f504e1c46320fe16a0d5c155800ef33733366e12113786b832d1cca4a6e95d7ea4097483ae4b549cc640746488be6cf400027d847c86f635aa4314adb037af8d7a0e319ed9821e6e5356788e1d08e9dfc475d2a7b00eb93c846a2649d1590976396208421edf63f64e37e61a971c5d17b65ffc8d08009e896b74012942853153c96c72f9988ecfa16281e413f23caec4def3cbe47dcc85b8c074214e651cf5c400a9b76d0919b08e312a4852e057ba5f3a6de5faee813cf76145c341b306b24b24f876e288e79bea408e9763fff8fcc67001cc73c5486ee431f6b27fcf39dafd9503b4e758833727d8024f7a139af4f79a9dd49ff08ecc1ca1bbc4ed93cfb1f0a5346522936609322664350dbb64b403631417211783b6648a88530a89cd798d49f765f9dbf7c013549f090e71879e13585f4d8993a15cda642f99e709aec161eb71af82e386c8ae71aa330699df9458d0d4dca56202638360cb7b92bfe6f089ad27445cec28feab9f1c613328b4ddf57b26c561c16d2d84c08290245084ea73d93d1b0393b934b411919d890f5558c0b2aaefc35c2e156f024680c0f4912932fce492d132cc2bc5287774f4bc23be03df79860f00950510d05c084a5654c6370f97b6e4afa192cb677b006ab1c9664f426d0d722db6b8ac7533df322d82af60b30591bf9b633fcbc298dee8e52546cfdbb91ee8417a932cf648b032c52edc0b9832d2e9f0887b5ce0ef654f92d566ed21e0bf07eb9b3678a4d711fdc7f551a3c712996a4f983d20d2581cbcfd2e788ceae717019f909e2abdf50bdcf0bd0e928ce6b284a66dca81e94d19dcc1d78e8ba4beab7bf72fbef4ef3d6161a7206d4b2a0dd3ef18183a406342702f3323afbc6118e8a991bee350055b5e811b87d5a2e154fc0ed5a753c952ecbca2d688d67987bfdff973e89589c424b31ba9e6bb0dd93c538d5d3a9011e5ae0db3d879cb569eb4e0b7274bde91e8182e4262b653433065e427f3ea5a2c328d17c2ef06b5ed22ab0eef558618f114b901013d5c824364e6fdb5947082533e9c8d9045545259437b142b6bd4ff70bc576cace7f1d1f9e0fa82276d245dd7cc15aa1261d15155010716f899a22af82bae8c6206670a03f0078cadec2ea3cd916c747ff9b1acca6ef8fef2a7aab50718fa13f31e36dbae05b1d364418819c8ac31c50b355b8281b6864ea4a396e8d79d54bf820e6331dd8eba75532f97b1a95ae2bc9b1298f3d596a52738eca72aeb194e70377477f2080d5f9d651944d34712aa2a6fe367bacb537379b151ae25603d13dd936f9be6822ed67a0c8d4b29a4bc1b627c515a29548f5b0b7275c3de2f9fcabd822ac703185d1c61195b476b4e1e3a1ecd10480ef297694796ebd628441c348b5b7b5bf5a9ceeb0dc1844b41cb34b8e1cc02be6256ab10a090c62ef4ce663ed13a64aacb6045e1fb1def0cfce5b052e560c7db15220dd252b11518e95964eeeca798b8fd20ef6537349843b70460f5da1c3e9dee7da623e69a5ee7d0199253e19305aa3aa7bbaca62b78de84d8d10fa54417700e49455560598fba4aa5b0272512b33e393996589325a4b3622bcbd5d144d92b6cc96cef1bca572d62fe25c1dab16f6b23f34de794e10bda0b5633ee2cde7f2163df77cfcfd37221bb73f5f36a8b3de77036690fc230a7e610abf8de67ebe7d201c0f50f3b56bd1444352af2d6dfd9863838e62494d24bf4b23da82a964f337718138794082c9273ae7da86d8a7beb436228fb048fe57eded2002d466d116ce041f224cc9028e55077204a6d06dc070248df1244c840709a333f6542f0621640092b902822127e07e9149790631e5517d7995a98b7c46b1ff1ab05c443bad7143184b7828722f20190e81c2fa9cdb9fd6e01493c28bf26887505df7b656cd52018a00bd9b903fcac25bc4c8478e89b718ac503ebcf8a0605cea0e3d2f1176469cd8fc7d4eef0f9fe0d49e26be4c429600f8d9afd7d94ccc19e8979125adb3b57e7f7408649763df78f20798b3eeac804bba27b3fdafc0877ce8d6e19b5089f50099e3712036e4661c5dc583d41360134b11e77c20574280b2ac302e77ce29a94c3c1f3471464b140c0a260a64d1f0de62d7e49cf4d3de0a1350aa1be6f05e0e028231d6bd24811e591e5506e51b3b6e411748d53ff90c21ea9ff47c60e3a63c2ae5d31424a1406a70e053c1e1226bb193fcd81f86121cf4f7615cf4049ddd4d7808397816a2e2fc5028c8bea29d6de9b4d57af0612f011a4a75fca12154b0b66a099ed5321b978a6af9177fa306ef41449378ed9deb8d4ba818b0f4b18dde265ff930f4f760d81b746380b65eca9d6c27c16daedebe78ed3c6252d22446d5f41ddadd157c8e3315b6a57ddbff97ce75c09ae55233ba2503d7a3065d20701c1b9acc230243b29ba766f11aab51c104f574f86e497cca74e4d0849cc183cd895b54ec7370422ff3b537e657553540e59b842399c87aeff63b4c3d6143b4834775cb076dd4942ae20470f639f759c93cf760235a400b87d87e014ac9a559197df91719ab89879826dee9edb6ea43fbb9dd43c4237ec3c83515a231bb38ef541a875854f318f93d0960c4690127be95d5c3a9fc6334864e9b744d7f8c5681a04a17857192d71c0d82451114127cb321ab8f59052f32a676fd0005f13e70f4cc22bd14cb5b1c8ffb1eaadbf065006922ca603bfae743b3af37a3f1cf05e02a855f03e51f493275862f19f1aa9d4dcbc77dc4c9c67df424a6f0e6984185cec146d617b577a8a6e0cda28d20fcdda280ab6bd841e20f31076e2e029621af10dc0b12d66da0e3c41bba52548ccdb3dbb4b5ca4cecefc339590fdd48a4e86768d96c6c5cf1cf45b9eacb1266820e483fe1a29b4a2e1adf46eb6e40476ae2bff46330d29b0d3d5c98977e59782d72d1c4162283c3c2211a091c8dc89352c30fef3f3f8ab23fdea656f6a895710e8c4af62cef8852960bda47184e6db1b1f4050cb6b4d57fef7db8c43ee4623e191d0ae56a236cc6f4b1fff9b0fd360257ae70469b9692e7fe18d405cb05462a02bc5d62f170d739a49ebbcd89be7238b175d1ba70af444542376032bf9819c3b3bab9e88077917d36c1ee480f83bac47a04e9c04d52d6d4303edda95c7670ab487df20fc4eef2fe0cbc7dffea59ad6fd54f463b8cb3cbc7b997bb0daf67f13ef125af211f30697878605ca745cfd593bb0a9305a2bdee8a5732b7609e45c009ab60af875780596832528b86a55cb3f02a8a896a8db576acf365c46e9effbdcc482ec83064762b729e45cfa16f2ed8960a3124aeeb0b613722f960c4aa5276a6012f9f307c082193fb02e38639c8f7aa4a17e84c8cd1953645c9c13fe99f24051c42781707cae7bf2ce8e9b88867e93e33146481e5cc61156b5dbcb0d2a360add7417180e49dbdd371eec62116d029be670a223bd044d456004027111b0111579242646f9975e0a2e5d810b6db459322ac5782448328596ea19c1687e93859edff1a7fa74a4fe562a9fb1faa76ef35e11df2e5ae0a0cbb89e11e027ab30ddbcf8512feac5512b67f3a4eea8c0ddaeee324079c053499311bfc9bb4cb2faee62e99c3059761acd0be5b2a94f5dc0095549b5ae26f7101215d0d026be0ae699addfa8dd36e59ca2d1cd5c3345408fd815f878f2ccf25ce5f5854135a2760da661e4bf5fc896f5cdb1dbe4026383a42201ab91e961e551d1cf8830ded8aecbd73d7cdb07bbc4c5058a060c046aac0b9fb5e490a5c1cdcc8b26ccf882a400d03511641ca5083161cdc0e4814cc4eb22f14628880665d4917620ba6b51810faa841415ad85d13ad2c703dc0128ee5b18814e3ad4e6d529c6f2552ae75f2fedbc891b8e27f23dbfc640912b4b06425689b364d4a6caead039fe888fbd42ecb8e56ed66d6850ce5390c9c9f66b7bd86cc8e0fd6302e01ce7cbd4b54fcf8c48dc8d423ef921476c35071c8dd8fab28674f6cb419d77957e7a4a71e5d843ae84181892ca9fe09d3da2b583893697b9532fbd3f4c90db3a9c6b8fc902f3c33343235a536635713a823ca89ab7285e935324c9f7ea6b9802f8e8aa25e48e85acccc10fae7d8f3f31ad55c1b3bdc2cfa3489ba338bdf3aff0f7c98df66c1503b0a8db18a74c7ed0f541005b1517f9bccc643d3d80f50949738eee32e139f116011948acb04c6fe968f7317929d5c1e52a9000c6a0e485daf8437391cd267b12a593e4bbd3f91c7565081d2d0b6f1201032293e01ef8a61ae29df3621eccfb3e49d8c841e3d6f4fb56ee38eb806ddb8800bcedc765e98003b02f6bdbec6ce3248fbad4617a50329735ce907d19be078fb6bb215de3690d990208e4927e46748fedcdc88d147a3e643749e42fa3837ee4936288f875c959255834b8dc39786a0d18ec8ed85dc3f437b644717eceda50ab078541e138cc2c1363741bc2085d5f00a28fa7047825803fe453ef23e43a4f451d4c77d75ceb4a296e84c287c923d07928170469037e35c40264dc5c967080b9c17098a1d33d2ec271f3cabb74904eab0428835222132728e7ffed12c403cbba6982bb46df7c9ec249ccf19e1785b9cc0a0464038dc0eba8a033b02545868c4f293e3e274e3760e1dd1245c3a317eeba907e33a7c95014bfe73b4c8bb4d031a1b811574c303c88d38b0b1380c30c91b403041945df73ed3d2f49434501b6d635977ec7fe06f138ef7d28a06feb016096d08def295b5740c469215313328996a00cc000db72c1fa23baba21b22b6052513267323fc89e16f3a1cc443c8d6a1b95c2bf7b088e19cfe59f243f418395dd968e59d19e7b52ba29eaee68ba8365106365b68927eabc6487f09bb29a37d6174f277071efb4dd7e6551844b64ddf77dbb9d0ca0f44f0266fd7dc5ea81f48aa6aca1e023cf089225bbda02cb06e3a2242c4e05124ba021c17fca87a498b6bc6dc7f42ea65b373b0acd269eb11d8e2f4568f9a2e688b41c38d578da00ede4a8d98dfdc91000e84dacc03de1649b03cb9a7090a080b4ce7ebf177e632742dc3d7f7711ecf44263d36c0545d76b759c378eefd31b503e8a57c51624df8ba5df2818a938c30fe3a88ed4d6274eddde9c553170e93fd518eae085d83523d6f7348a58780b78f6632a1093074b5d90179e4c71f9eb2c1a681f5adae240747dbbd893c4e3cd06057697af35b01ebc0559a116638669f5838086696b130febf7acee912ca2a9a93d078e736af9a51018a8680852c79226e83b7fda43d7602df280f441557c41cead4fd12027adcf2f9e2f50b840d8083eb154eaa34f0bfffd0165acdbc80ae8184511ece5d3bea2d27c4e6e387b9c9e09608bf7567ead75cf0c6073550cf6ba0ca58e4db20e03d97822594c674f5d5618511d0d115fcc89c65aae74c8cb0d525c9223c9eccf4e30026eb7c0f1b011e9cfe9370fb97e7a83162641de4ccf7b628012b1cfdcf75b8b1fb45c3b87dc8fe7eaf4a0011301e56b7ea6cbec5c5f3a980669922b95946a242ea676b0d1272805e368803dd63abcfbaed1655471ff39dc81e8c6f248caac9b2aa07206f1c1249400bca43fb61743fb0378953d65008cb227ab20603b7511eaba20a3a54a9d5debd09b0a8d677b49afb857634fc85a3b5a298bf9203a01a4830352ee45101bd1c21c4062e6f9969661c56155b9545b27e9dcd9dce80005da79ae4bd288b6f2d44dfa13ae35ff2255a2d49a062a559e7ec7dc06443ed74142756d17486c08c830fdce71d640ca8a66ac12383b3bcfcd9520d4f8cc8498fb2b497944d1c854b43dad7788e30c2166ebf8a7abca0dd25aebbc8fe4a084a97d27bc6b949be4cc447a4cd0bb1cb72f0fae7d9514596ad1bf775bdb5eef55b7a87550035a490eed5943626992b7d43be4bbb37836c4f5095d5317b0f350250892ea356423d86520dea7b2ffb7b49b9ee09fe116d80335bf017817adefb2445e55b41c400e561b5b46230d2018085e96c9ce926776bb531a1db7de71936375ececfb8d68986267a54e71b761f7d8d23f0a9bb23305ca81b54bb678d217086284ed1ea3661329355f63296c71c4f294f238d534a7046d48e77599d1326ba437d434a5a1465ae5175c8a5e1b37c42fb036d87066406cdc6cac00119170e69a319dad0b0285405736729906199a5573aa505406029a4f292cca8f4792e8c1985859c0653fdf482b95e58b5a6df7ae446c9c85ff6d0ef38d8d4115549f847febed3d16476f78bee74ff6669bb742475ff9d470b6bf941ef99977ab5481847febadc4bb051390fce375beb222194fc2ed6f363b402463d1975deb76ae73daa86f4af78f8ec34e036a4f8d0b0940a86842db2014cbffdbc915fe3b0c28e8ed8a55839a54a684dbff48aae89b9e27a85d12dc3d4f9adf026f03c4d92b248bfe57eaebedf812262897235e2e82b0ff833ab3910fee894f26e9cef0c36c16ce347b3042b69815c76123eeeb607e6356cf866ef0da19c029021a32fb735c903a84eeeaec0de7243b4e4069be1a2912e65bbb65ad18cc54ab808b72d6c31c88c4d2796b836b8b8c2d6f68fea8cd284473a70c4bad0fa193767bc7a455c0f5247455c78b83ac7f58b658e0d8fdf21733329ac5eaba3e168d866aff98aa721e6835d630f82f373353a831eafe1f3d96c9d304726a8993adca48af5c269e47abc8609fe6ba697005dc9618da3ac186b141f5bc61cbf907ec0f33111ac3a42fe27d2508dc8f57ca84cd97b382597c355b82595e4b69ecb996c663ad4282eb5f8ab2166cc77792e73fb52f7da9e785f5b16feba5ca48a66ea65a45b743d3a81e60f0042119e26c6101f73687cb591a592be08f33d2ed4a54a1ec47637732c265a18cd83f597b502c17654401cca876246f06ac989b62986464eb5d6d25e87c5837e085497bedc7dfc5d3391fecaba25e3ea01172c1c69054e2dc6fd17381070ae0e04180ce1139c3a00c46530c3008f439b47b12bb4c8a113219ee3866c7ccadc4e4f593c3430b73df7204061477f427d6bdbd6ca1418174219f318bb7b6f9bebd6e8b9f55ebfefed69febcd6639fd36cf69c39beabcd6af8da7c66aff9b479cffd367bbf702c5ff899bce3fca57ff7b771ef7fa60ed8c659ffff5bf316b391ff75ab2a5d1fc7d5add16bf4fe7eb3d7eb7d6e6bd6af1ac419a6308411a50ec117be16ae86ff5f0b69ae15285c09af7bd70912ae11ae8310ae82d7c02be0f5effae0c7fdae7d0efe956fef5f555de357bdbc0567d4736ce7f43aab77f368fe5ddeb66ddb80fc8f66a5a166b15b36bbff9fce3cd7dfb2056dd72aff93be67ad21feff9f7ab8dc76edececfdc2d77ed4783cbdfb5d6f22eb4f7b3dafd5679d79fe4d56f36f72ff46afa921485be1555b6775d5d0cafc6f46eb8016f69fde3d5f5707effb9db77b37916dd180ca84e331babdc3cddffb85f76fb4dc9992ffd5fdaeb7553043df2aa8da2ac8eef109deeb9e6773f5bc1bfeeed7726e7681758f0e77e1e6359f367bbff0febde6f3f8fdbd9fc928ddc88ab6634fc62affff4f7570397d3f5fd7eaffff760ceb9abebba2af7662515bb1c3ba2b5d1894b006fff3e9f43eb7e52af2ff3fff7f9d93fbffbac7fd7f3533f8ff0af7f6ffd56dc1ffd736b6ffaf6b6aff5fd3d0febf96cfae0accfebf9691fd7f1d13fbff9a20ecff2b19ecffeb97d7ffd72e2eb1b70ba7e279ae7dae478ff1bc97d3566cd8bb9fd0eddddcf53e819fa29cead869b1382eef2e2ebdff7fddfaffaaf5ff350bebff9f5f1178afacbc5507c65e2aafd83be50d7baf525eb0f7ebfdbf0bd55df75952d6ffaf51505b3019ef177ed5f7fbdd1c3b5d15dfd557de2fbc2abeabbf17feff7ddfefe97e3c7ee18da30fc499dd6caddefdd4bfd1ea27369dd75ebaddcee2fbddce6cdb1d3cd0e59addfc1b6d9ee3db3dd41c9fb78d22dd46c16da3c8bdfb29bd8fa1e4fe7f7a7ae2d3693e6f9ce6f3f8b479cd46dbf5bbdd160ae7ff31dfbbf93cdeddbb9fecfaddee3ae0ff6bd21548c0ff10bc79f749ff57fa19add6c9af4e8eff5f8ffebf0a01c0d2d16dbb567e4512d3bdd3cefb7be7ba1ef1ef3d39a36bd1ff753b5add8e76668fd5ed68756bf49b2fbff9f2ff57222b9a8d2e1b3ba3cbd2fb1cfa3a54b7bfaf42e66bd09a4f9bd1f8f7cef5ff15a8ebbd46b3cdb6febffe74d77dd6ff579fabf6ff2bb7e9bc46dfb9d96e77178f2d93ceffd7edffdf7ad5feffebf677ef7e7aafd1ecf6d4539453778eef79deedb5e6efd86f36dd9adcf77b7aabdfdbcdfe6793f57c5bbfb79bf13c9db9df5342b2558a220086c0e69680dd7731206e3b40bc1d70b41d10a48fe3514a753b1a98ffbf9bde8596a5463e33db2655feefa66f91bdc85b5d66652734b62e34b2b2ad6d92e436c9f1cc6f93286c93246c93f6fe5f52d2e1dc74b232325ad61659cccc2ccb6c4c0badc68756a3d1b6d0d2a4b2c86cfe8c568bf36f3ecda399cda1ddbc1a4e86d655eeda22eb4a53d0552e8bbdd0d2b8bad0b2cebac6d2c8bac4b2bacecebac85e6434b22e2eb28eb6d515a65526269646d685b655f645463e432beb6864adb3aeaf2e343232595697585999965dbf835d5d8dc73cdafd36b77b735daf7ef7de2f1cc08bfdbd73fdaf96c0fb859bcd57fc99bd7566cfe9f1ebabaa395ecd7c45dedffb19099277f360fcdfd3e12e3ccd66cb99fbb4f77bb4f3ffd65dd9fedeb97e11e9e7728e73ef7c010f5ba225ffbfd76db5db8ea8a8d44c192b2999a1b49830fcd5529652d51caf669ec3539bf1d4ee2bbde94c7ec3d9e6b6dadc56c3fbf4fe66bfbd5f785daf7edc066d8384fcff01f4e9fd6c1b946f81d20cd4ecb936361956efded9fe10de6c7fc4ceb63f41fffff3ce7bb73e1ede7c7aff5b2e982eff5b477f9f75cbff562dd62cff5bb1fc6fbdf2bfd50a0a49c278df20861adb2d91bfdd62698ffcbfed21dcf634f8bf6cd662620b8509021256402d219b54b9f960ff6860d8f4c0b8c4a0dbe0a3aebfc4288a4065c6809d08621e0020e678378078f1c2c94b1087a0234c50703d488256c14a0a76bbd369a5f2bfd59373bb83669df2bfb59373ab63c6f4b73a45ff6f7300b738a5e82d8ee1b626684bf386b7cd16c986d866cda380713fabce7eebb75ae53fdb989faf3d79f6efe4d79f5c27a7f15aa77e35d17a94a5d2d05cadd53cff40d4a74ffdb9022b82fc670f5cff0e36ff799e5faf60ea0df5e7795ea582e57936a7e67915cb47cda97996fa7396e7d83cfba979ce53958ac52ad9e8b9954ab522e6d63ca7dae461a879cdbfe6566a95cff306d43ca7d2a45189a839156ba5e658a8798ea5e60a72a03caf52697c5cab599dfc27cf7d68aa39889c9a63a9794ead9a73aad5a6064cc5c9af68f26b52d52acf52a9d66ed5864acd9776c2b9036bf7c6ab6a46fdd64f35915bab4ad62b35affeeb86dc33ffd4cfc3c3f3f39f5b736abe25a7a132e539f54aa556f3fc9b43e534390e954aa562b7f20254aa959a47559f6e846808e439da21aa627ea50ae5d6bc9a7faa1955b7c9ad9f8ac67e3d2eb750fd007ce41f2b08b59a63736b36cfc9ab1da8549a71351757732ad5aa53716a94f26b9e67a3ac5da4a89c6a83a5a166f37c9c53a94faad8bc866aade6e501a8f03caf3ae53537d49c269b53b1a847d423aa51f5577fbe9363a9d43cc7ca53b55285a8546a8ecdad74794d527e73a5e6d75c678a884aceded45073391a9c2c355790d3e479959a5b73b0dc884a452da2de50b3d46b5ecda939f5869ab5e6d56b35cfa7f26aae94d7e438799e1fc88fa836d56c4e63cda9793ece73ec0f959b5ba9f9d59a53516ff22af528af56a9542bd59a5351a9f910d526afc969acd43ccfc7b911d5265bcdad34d63ccfa7f43c8889a6aa6ae09a57f39adc1a94d7d48c6fdc888e7201d69c4ac552b37ccee313750396e7d49c9ae7b9d3cffef65ff0978fb66df97adb0851cc36009f59d676cf1569533a3f1a0027bf3c02095fde2fffd9881b20ce00b0cb148c68306ab683b1c4461c7d01db8ba2a846044151ed3a2aa6a6e4244d01b0c9c353f233e1b8d31061ddf43fc59939728a83a436759e6037e9514c061a9bb820c5e938483a90f6376ee17edc15c3d7ad10feaf82f52abd7fa3ebd067f63a725b05fc75683928357c4db7ad9afdff1dc0df7af713dfdee77afeed7fb36d95a6773fe5ec5489aa3900ad1600ad6258263dcf8609e4390178bde264093809b48ee85a81701c55602b005ac56a7e6c8a822000d6b45917548f6ede581c1a2f1a31d6a67a20c8e64a0490660620f72db066aa0ac20b0e27e0f514f08a33940988f30e9003b02648879a3d7085ba2612fadc08290a5a0d017700ec00a83af540d104f59c0a5e0dd088b355d59d6a158d236075ac0b85b5c14602566fb043d6a69b6e35b7e2589b6cbcae06b26dd821ac0db6010e17875b1354f3936dab9e11c40e552705af9580031a58d5ba798091758cb383edb1e655a7ea96d50c07084bcdae6589b264571f9d1c7b53bd5a71aad52ab59aadd2546b6c8aacd56c5a56bb6366d393c566f36ad60ab64259731aa12a51600dd25505a04e64600fd64a44c32568e5140c60d6ffa96968934d24989695f0ba3206c42e2d045653ec35972d5005787668b26e0bcac84e8f2c49827418d54111eb03a7e6a5101d32583c423d11e0007f1ff6ee305d46a130590204c6df03066f0bd8cac8bebc908e807e6ed8f863b1e2819fd9a888bd46d2e19482a7063c351d23e6cd0de8a7475348101e3a64c4a03cbc40c1cca06dad8c8c7c792488111c1dc09e38b9140244478e138e8511207419d564a223c78d168380fc99dcd593330afac96909c4468d17283058e0cf66066f6e6be4ae03e3a59e9ccb23962016310cf267066164afae031ff4f3f2c89020366abca04491e1c2205c18d9eac0780adc5dd2f658ff29e8a79421964180d8a841892203860b16063dcd706f08a09e4acd8825d8d18952846858c8b61645c242e15e5cb2e6b46a4a3d7335432d43a3c29a828a82fa987ba9dd6a54fe74e3543550d57f90a845395176a82a94075981f29f9aad565be5b1eee0e8f0e40ce108dd14d9f4d46469b0592a167bbd56f38f1db4194004305b93adb1ead084b33555231cb440b200344a581b1ab1156727b7e260cd56bd6a4eb5c7ba09e1032056879aadb136e518895700daa8e19cad4d3a815430d135cd9a63ab7a005a8971f540a05a6dac624b6300ab08326106e6d7710f125620d53a54756ae700aeae06980062b14866833e3b5a11aa5f811300856ad670b8385c3e2f9f364d6f2306b0ea5df3159781275b53cdb9de59291806d25875b046f9ce373094440d53e6200d19451deacd15ab274b654dc0bb4d0a6eaf4a365e3604b06f56a62c95208d115f82290e7f78a20673e6c42afc00bc81d32d42c8f1eee46a45d50359a170a04d960a6b43a3539d227f558d6cbcc400da64c939651a30a22e2f9b1a309cf2b98a062090b5296c831d6f73b036375d01189c00b4a1013b922b04bc5679ae395601d6e67a00cb74a57503af29400386b5c90ae570d52459c96a80b84504867e98680c243823106843f394fde67ca7c866591c6b76e83aae866b70ac0574ac6c4dd6c60a754d601563e557a22a80eb4f540dcd5c95aaeb40108dcd4fcd54e016d90d9846c99a644dc2a60064d2b1725d0d5c8f6a92ac453bddaa9120e013545ea5ab3a59ab5707011868c8c15eb35881b96392450ac70a7f7ef1fe8e8e9f8b63f0b6804d2dad6c26160636167f95080c10a05b830039e5922514c1d580004342d94623451e4f28e8423036f2c1b9c1feb8514312f2d1b1c4884610694a05a09e163fa0954f4bc1c82de0b2458799dd93e1104d7775c0260b890171aaa6c9260ac8315518887b6343932d229211e38d3f97918591bdbac6e0ee92b64727c71ae2028509da4e291c2c56a4f85b539b0a0771ad4830bfa85d59856bb2584a09355a90e0a0a1d0818810210ecbc8ae0e14c0c9cd54cb50c95847f52d54516b2875cab5337742d5a466d630c159424542bda4dea052565950efac0df2a41c89c6e85a94234405a2fae4dc9eed554bedc979ac3ad49bab0db58686869acd5ea9d6bc9ae7d86ff387ce70fd35dadd86e2cfec39f41a9ee79c092a15fda5344a294b0b4b017f9caea4eb68fdc09e7b77979a4bcb4a13945ac5e95655ba9255950ef7f4f4e4f6eebb94ae67662a7fef7e5abbf9f77b6f43b9dffdb756a93f2f13a14cbbcc5999aaafbff732457a9c3ff35ad22ba49bba9b4d579356f3f6ffe7e1eef7ff56249a34d4ca282e9faaab5fe96e377c8e291e8526a3f47bf7931abeded2f97f7aef30a683deef6a7dd7c5c6d8f5eea7decdbfd574da3141edf60ee7c0a6c94649c94ff7b369b271a0eb4dba035dd775fd7f2b94ffad4ffeb73ad114b3441f4376f85f1f8bc913631653f6f5b18d3ed66de2782b005656ff5b9b583735c5fc309dffeb3d5ae7c7994cfeb7198789bb8dc388bde1ea30505f0e3ea6c776bbd95a514f4f60ae80a1220af897de6aba2b0a308c60d8f4f31a1e0717feea4d5eb738373a3d7eafd1e638fabcbbcdee776f56b3dd747fe9f8ae8ea25ba3c97632034e4f514f393e58b7bad2dd7b1b4781a80272fa950e17e5460797bbf1a5af08950b950a354d0d7f0f7c18f2af61a6fcdf8103e0dfd1c2fab984c6ff0bf0fc5f15fdff9f73295172287470390091925839362c96ba61bdaa4aef2ae955ba6e60858a1428be5f1730788f76d7895977b070d0b1aec1a9d784ab1a2684d0930c2fa810a1a8aa3a59f20502c16838230b5cdd71a18e118a01d7e96153d5840e009f58d5c8284e49d54240ae040cf81e2f231455db914a7a13b9036096b8d5b4509e453323187140e0540f2cf238825ac1d05dcaad551d13890bcf89b5c1a6d22ab650c5052e31b01887c050b1d8c813137b74e4e2c942c534b3d8d7c4f191abea931a03b20992f21b15171ca050173d1b614051448a1a2fa10676f859f0c501803267112a5d11fdc8a292b7b8891f5431c2d22f405e026479dea0766540d15146b392e3c80bea8f98201fdc253a88788bcc4b4d2cf6003fa1321ce0984f91e225028787463315c65cc806a6176f65141b5d24e69195526520951ce0ac0cf30c12dc2464705b04d26330d77b81f639622f4a905e5ffee6a526eee085df5d8477ae45425dc2c3072e7a61e9bc80937ccb79a86de1ca39cfc930866e3a4114caf6bf971f7046a45a78461ffedf842084e6c2900afec9ff3826a5f062c34a49c8ff49689923d15df2c34c81ff094594152000f42140d7ff6a2649c48e2aac00dafd5f3e7ce03de2e0ca5bfb7ff10ec5230e2cb33e2efe3f0a44401527935833f87f55328e0548a4dcffff54547489099ed3238c58a5a72e90c80062f314e29bc09c7a30bc51a4866d465824cbe9831ba034e70c3d43583e4fe7ce4c80e105c21fa203e5949c2229c903bacfa064c9e9d3e71bcf0f260307b0454eb91e107806c174f017f9c394d4c8e48034bedb8d71c394b302cd28191d3b3e772f4c7fd0e06a6b38845cbc8c3445410685f992f0ed97e8687a788213878819a0330e194ddf9ca47a49eda50738124d1770208b6088a106813443530496374ee3c03ca2ca83a60326c899afe9beb0c23e531b18302421539c02ce789fe1f2c5938c06293eba10489f615242051d5b8ed98998f3991a4f22d3497e722606dfce346ab81371c4c6004b0e6867220089c255604889911a6267ee062b9770260982e000d719b316e23a334c522d2e549d91e202b6e900c414090a3e43d428e1d288a20e45304d67bee63b02910182632149a55510395c618bc13a94159512e9c193181e33a336c52da514acd2eec1c538b28653ca6145113206ac78597d6a2d75708531809e802d85444a4b771078918792272c618029f552a2e04da99bf6014296d2260b984892887fa5559fa53d39d43070c9bacbc4816246cca91e65698e1b50ca969881a2a26d0a24e4439021ffff6f5ac40c8f2a439755aba12ece1c9d04390fe1e779783837b94d5ce97cdef796947835bb579283f74feff59e97e1c15746237f91b9cc5fe4b2d5950e97d34bb7f37e0f5fa3e1563ad7bbfae9dcbb9fd6ecbadd7d86daabe3a1e6f8b3f79da6bb96c798a170390266ad050a20142163d26e2879e149b9001549eb77cc9da2e95469295960e4134e920c423749a005de9ac986cd9dcbb075fb4e8a5910ad0fd484cd2622dc39944c70ebf0d49753c9ac2011a89ef8fe09dd3032e9e487150a8d92cb305904bc3fa1767cc467aa9c1e6a9e365ce54165552b0848c1387954d4b2166b39eb6880946f715267b94588e41228408217368ffff5a412ff0d961e3fef3afd7f3408f8ab3958ff93e9ff6731ffff9554b22f0a6267a7e9cc7be833941abe8ed2adaef46b28611fcaf6f571a8923ee6c9e8e34a7d5ca5833ee6d155d255a2be3e0605f3f531e80e7d4ca88f41cdf43168d0fffa58fb29faf5f1e78bb9357bfdd9a78fb59f587bfcdd278e3ea6824985511ff754cefad893ccffdff3873ed67ab279eafa78ca8d29837f8ad9fffab8338bb61387b31490b3f2eb63ceb8fff319523ea5f43dedbddbea9ebd1eebe75d4b2b25ea7fea59ad85f2f97bf7d3eee6a1e6d06ae3f1f87feb90ffad96ff7fabb5b28790209fdae3ff2ad4ff9f6cedd104cd6877efedeb52d3debbade6f5a8389b769fab89cb6e4d75afd9686a5953e9a3f5263699d8ff7a9f49d7bb9feee676371a98f96cce6a6342a3c0ffd4532640da2589fff76bb85b3fd05fe9f15d5dc55102e67f2b901f4e725a256d25e0a7bb32fdcd5e2b51faff8e9d04f2ffac2489ff7f6d122e12d23112432476ff7f245866244a48b85f1fb3edf43047f5f1bb676332c1dcf1ff6f32aff7b9377f3787a6a3dbe3789eee401c1f1787a78db104b30ae08c46763fb9f9777b3fef66baf1583d17bf1c5f7a2fb9fa58cd76d3bde33cd956bfc72728b7d5736c7d3a9dc59fd95b6fbe7c4673bd7bb4d8797fef5c6db51bcccd9b65adb5d56eb07e8cfcee77317e4db6eb7730377f76d7d565f568aeacbeefcfec2d76baacd7ef76667cba8d76a3bdfb5dccfb4d63a39dd37fcaeaa3c7d7109effff9b9deebb2c3fd57f6cd9c766db99d96cba35facd4eefbc3b5b295a5309ae04fcbf475f5555d2e83d5a7fc779327d2cc4889ea53fa5d35942ae848c852cc930fc4d3afbadf721b4361a04695cb3d1683d88ddff4f715f35f51c5b5c902af51c5b902020a3ff7f209a5a20904d6820edaffd51fa63c98f1dbf773f99d5737127ed0f0f3f0cffdfd2fe50f231e0ffdf63c9f77ecf6ebeedfdeef177714b4b4a746c033a38ae67efe75d5fef6e377be7dd737b736bbecd860aee1e057ea29642947070d9bad113e876c41559f62ae4d0d0c5884732829b68330e51f2bdf5446579612633e89381d197499f0595e4c7056a63a0a46cad7c7ef6f8c205d638ce02d695c1b0051294116beb0c75d667e0e584e60a5f0c21bfb12e20e2d6eabe0f4470956ca9ccc03d5f2df81cd3ce08630a9a626b803a8bc7aceb696605a961cce911804b0549e021212b0d844ab1b2e830e5c0f840944a0b77ca0442aea5910a5faff687481633493c2fd2e928eb2b1a25304fbad8a39557866a7c7137f845e5e8a065a07131f484c7674f9217e5cc0e1bbc28598d87602cb07a8874803c387b180186321f43a06efb440c1ed00c191fa227042eae20e2a9f47d40bb8d232add35921cf919c016d57fcf6001172f1add2a211da50cb64900fc45581359d0be41729c8c3863c338feff73276374eb2d049e831766570c66fff77009d276e997c042292296f58df57f518b4c314195712a4e2e3c34d6f8ffff8489ffe86c8c839163e9cb45255c99a921a12a6388a051bd35feff8de696baf87873d4a18246981d48700218c63023ba0066985e688f2861fa194179242847880834636b0d4d74ae623a01d4925eeee99e31d0bda7d6ee1632266860c2a1e811e6e295cdbe6a7cb30a56d0092a01bc2c19e324236c67c080715dffb8c86145b2c085906632e9ccb2f1aa8daad1d0ca932580ddce32553401f4a528100a85a40d8c22146a82f7693a9887627125c1c8f056c1340a999a94a8888943f1adbd26205ee84e542153c2c400f28c5e62c7986418faccf4e462e6c3c2280ec3108bed330e8315110f751d5925782dc266638f8fbda94ec0a2bb3004c03f377e1c21463182620d259200cb13d5369a7523233c90e6a016b3012112d617fadcffffffffffffffff5fabe2c7d0473a52470d1b6902f0608711406950a0c07c696e21c2622a446e22c7102303e5035dda8c5c79b0788d20b8f3d4a73dc0bde66dea2d0e752a3d1ed94fe7c7b20976c905254eaf9522b3b145280a8afacac02850baf8392d3177dea94af81e239416d47676b698831c1ddd18f103e927cb685445062556c6c83071e26e88540122247c3a538ff0136ee290077ba3075e8f1ce7196b03e382e584bd065629d2093e3614adb216e4bc38b0b2f623c2969e2811931f0eb96d83c5101549182712d33c79ca5c282059053ed63e228681b008c60a1faa2ea587386da3919c13c61501548486263c303a9d0144fe5a6b25ce914f3879125724d1a144c742e3525e90a32c35775c1a4e26b08524e9d27c97e89d78bc092224aa6029018d2038c2b02c37209a1d99c1d3f5d2b8442b0a93d9f99de1f3067eb9567f765b4b02b63ca920fa367500001412e3d42a7f49739d40e082a2b3c50a275223905674f46ba827e967ab4de1b8b6fda173878443533b2c86052258529c901104438b0562468621dcb97b556583d9f9c8538d508fcf04fb8dc3ea42e3d8d16f3b96e71316f9c8438af1da4b4a3a71244857f201c41a1204dbef2690da0953f0688926904b12c885cd7fc4086c8f8b84b68909b3215916f7be3e6092b10443aa0021ea389e79ecb1d661c7086c67081c228cde5a32ab9e165a1e8c5a827508a2c66aed0adb550cec2c61abf91931f7599380a82bc6906028b12c6c32c292e176752af2d1d6595702cc8696314988a0dd20f19e32414d584172e0ef1a794e0e1114ddfcc4434c998d414c82c40a17c357878a4ed10f102003a4e05909736d30fe922c22e9b97060712a0b9de4c234a8874d65c49c4f972182d71e1feace33217c8840a17083686d1540821a98dc66755dbc521269a027a98a9486309d929a41040466b9122cfaac917a90f9c2d6644c46e44ef661103864f9e8424614d4ce88018a7b8b0b6204e0c9418379f6c008fd43c683c83c889209574ba1b5cec8f187142883b59c8194b021252d40004173c26c31809185478c0d5178da1217db874a34c288ba2e48b54629b86cd21e622dbc84328e30d5c7a899f0112a24e3e5e4643102c2103f14524d640b90b68841a0a8b948e11387d156506f1fdd86690bcd518547f8498cb7a95b014438c8cbe4bea2110f420d1739645869e1828004f5c6370466e11345dc0a3ec76e83e3d6cf43113335db0a2b50d2a74a3bdc8420b88fe04cb8c2896399f0cacbde0bd1a3375699550a2718c6ec1a90b1080a10604b03d99550a1f203e6ae85e7c4f651031a92c44ad4898fc7e09e869cf810272a8c70483022276e8207aa380633f30c06352d873716dcdc8450a807653c2530e0cb04aaea317bdf40779a614063b18018a142a31b1f470c5806dbc661bbbccb17115bb404b44878f2f5caf82197e753e2ad303f9390a2184e4f79187c815911b0685e8ade940488f1778a2040130018aa7c5d79eaa9510dd362e774025cc80b335059bcc0fd280d7e39d2708a2e5391a03223fa0486a8c509a82ae2d32d481a9b4a3ecf31654fd963142e544454205fb138c48c9c59f894c0c0e40eca84f4132fb074e3c7e18408272f2c881214605a2027132abf16053ca1965b6e70918ddc90892646f989651f00371adca5bd6191052051838b45a36ea881810858261766bb8a04761ecc4279f008ba7d053899d45addec003027416cc225d1e5340b92b79f226349acc81022b5234464c59fe8d545d1dffee5388006f58c07696ca74bf5b0cb256391208a1a46bcb905f4b216ae7ecb1684533256710a4884a244ed4437205a59723e15239619d985e4170042801a6192c80f107ce9c45953dbae90c210e64593b0e4965032e96c0c0e411e7a88e903ec0cb635182166428de381a31ddf173b5734f06c20616fa52239615bb16e46c10b2312ff848cd0c31f21591056e91cc9de2a80e02c00930ece067247d9167e9a85db2e3b0452c0606b7295d1feb8bc702246963c1471264abe4a6111505ed56d767e4c2c674ac1e98873a262541e24fbf443b26747a4070c2831d59b16cd4b4976840496297f6d9456100438f9b182008e846082134d38a38c0ca964c12c2a71287513400a22a25a69d26891a8b5a70a5520813044861684e1147fb43dd51fb390296d17569da33ec0943ee1b0618b680c8d26453a73da9ac078a9d2f68d137bf89628e938346b378480f8420b8e207c9a50f02aedd8a85520c15d6dc1cbf9415486e5410bad911a9f50f08514390ac03d3d5fa0a012ec18203909d88409ec8c878f1abb8c99a34928a1a2113b6f277578439137a434aabc8d39e72ccb673df9188f8a097d5c2852472221e0966cc31a31b9996837a10364724c238421071991ad4338554ace0a627a1e14702f32485aece2f9122c3310a3c9902d9b8f238632a7e070dbe43cc538225aa5b88084c26ee8814c886d63f1c5d88b311f6f042c34b8e82081442485e0881d40dc82bf027490772c2a6c39c33038427901457c186f5cda1a8b11a46914d6d97a6ebd5ca8557e13012421e17c42c0d0c14987a0b8263eacbd25f5d64e27c9f89450c44e155111bb04343e83b4b4122c753408a2e426800e4106907047678a4a7d505df10946b0b0e5c49cbdb55f42ec8d8128bc43eb74310044932f14802625008db06ef1620ae2e472356bdf19313e82a0e0b5a4f94204d095208e8612b481a23de0449c10c0a4b2f6728380e612a000725fb6579893118ac258dc4559a82cba6286c5a6ce20941373706e5da59463ad36ca5868cdb626d474a8ed06c716203f8a8923e288ac15d9cf347221936c905764b56739c3d449079f5f8d81006c40b63d27d247db105014232f0ca81146cf41d30f4f764007091a702852b2586ac1a46d0c5122cd16534871e499104360902a4cc27baa226c302f09481f09626e6a88b182ec5378a24c8c2fe92f020222e8cc706c7b32b40591c679f28b8d4b24dd199d91f6190f93a15eca9626c50d44747c01c4a2fbfad8ec3c992864e07070c56234ceec6fc79018691a0eda8048273a6e59e26711933c6d2226055e281ad28091f644aea81ce11a061882370207dbc66d0a33870e630f211606fc746c9a8614f172fda125c396179e1c074f4a41dc4c77006d2d721d34d0e3f234216d31c68b69db881bd8e443978f900f4f1c0906971c38496d24cc7ee602a405681c0a94b8933c746adb7ce6375db61dde5136830810dbeba3c31e017cd40b7a90c1876c4c2492e2933f42411d09da5188f0071230140bf82531372081e28a621bc0533741f920bea2840312265094a80084e503e4a591941f27620b0acbb83869a32a81652a681a232227de5380263b13b4933c4aa65ca6053a293c71838910143080de7c689c6c31792a78424cdf50250630fa0e25e05112e603281f78824e9694498b60747d65700ff0321db7c4ee87991a3f97592a9818a038a5fab5572328668ca20842a824d9fa4c132ea1b504545c58967b92b48b28b832781c729879b836835bf2f38573ca7bc55080e35be44bfe8493893631115c7598abd204a803ab082ec3624f9d6081094857ec27987a843d351c8cf0e121476917aa7393e4c786063f4b431488ba36e07ce8482e0881d7f8b1e86237c073ea33e4018c2069158ac41a53cc8a6cf85c39d9b1f04ac82854426ac583a3802b43171049112fe09858579239ff9ca64f1e0f438b65d88484f2568b578034553b5c1dbb16992da453ae2c5075749b045b212e541a6430cd68bb10a5850112278a268f1484d2333e175364a42c2dd6d0d83c72b53ecdd409c55dc7f8bcc88984e5980995438cb1386764df4f0050af8a101d9120235422013a5173d66345cb48891746b6966510822b84005192a06bb94382821f64037290ca823d196046a655518fa0584757329c28ea060d181ae047a40a8914c4edd9e22392102c80a2d6d622b05503434105b43004c12e8052aa0ef3120221cc94a3ee363c35a14be20142c6cdbdf39736ad94c8dcf3859852135272d9049c4141401cd6a86e72601b47046b5038ca946264e4204b0f2f631e577a08401ba033dc6042abee4935cf34bc34d400d8d081a24c00a2c124336615fa57a722c592a8d1122b4544aee1380bbb398b43e20bb90161027a4ca96495b2bd3d21342d1ac5b146a6f6f38051eb60fdd6de59393665910480a5e8680b6828ac07089b93232eb0d980ae2783952ded75d88ab94aa5ada0502d409f318e0d702844692bade12d7302d8ea44700b83879168930e447388665a5913ed598abb9b1079b1650c4f4f810405995d7cfacc43c42b124b9d46980c08ad2226398459e4fb260b7bd19687b1774ece4d9e1e7f8d4a935b2665341e8900c2009650ee1724426f14a637500ad402d6bc2a5386a0421b20487c8339c2a2350924b1d1030fdc2889ba1b96411aca352b1cf47dc671e16922b90a330c6614283234f4661417ca20e44c8f9f3261baae0ebdf14b5226d298bd335ec6193e4e733c895a426db9d99689bc4230e20bdf5f6614057e38c00809225d1bbbacd06e432a9268228a131e29d29424802d350ebb4e078d4bb4f811bdad6011f090a402401a359700482412681334f797552ad995519363b9446aba8f1df599b50e361f24115170e01df7236ddce6d8b8b350479679aa05a24484ec8615080993579b4700c31c9a796ed30077572320ef4d9c2e77505b2ca0ede050710da25d4467697e3ccf840942a39059810a2390d616d890a2451c6e06e8483127460846da2543a5257a441e1163053253554b680dfc408c52a52d326feb7161110209af9f183060f8984781f2c9af57eb5c61b3e83c1760818c2c453d8a109826392379a127078e30f1165f30902a783cdd9262b8f7f3a47667724ee6e99de839e566422912d5a0b93454644cf439e4f0c0c98d8dbe1eb4ae4019527840b1b0976307ec2bedc907859ae7804c777972d349c3501bd31ed136f2030b311d51103ae2319d5ce0403c5912744a1e525020a744e543960d28a07c0a30d8dcfc7267a2868ba2c0471b5bbe21bcf0e14e94d7e192990a891e149b6d3c127a08a11f3409ed3dd9d295c0a680980be916e1238a0ca4cd332b99208a506285921c7ebd6092147aa4ce51ac0b41942f1e011e0c915ca778a6fc202c547c5d11e336fd8d5ebd069908619171e320f4c9293425220bb603011b3386b0db41230320a408134269aea00cc7c007778608e120b62edea33c8128338650b829b4379005831acf9a1eb437100050be3450a4c62295a34a3a1921706ab05140f610a3c38ad693ad1596b78710301186d4ec3999ea626919848388a0dfebf25855b86906644bd581a39d1765666ceb9e9b1547ce63d044c2b496989419a6b8863c8e619d0e9140d201eae38a220688cf19053a86ab2961279218b9a9f9bcf3dcfa4cd8c1b8e0018499046d9b8f113b4b52a7d01d6f4fa79ea1fd7071c3ea51aab7b75319d1b4a356b152a4c2cbf3c5c686351a8459635ad5c6123d574ec33aa459a92909a38449d6e2a2fbe175185d35308c24f4d25bdd323001243a7dfabc7085d25401b503c4ad5781b3e7cf8f6cd38755952167d04fea2ac428e2c3f946e202989c38bf1b3fceb2d4e73fa2b52f112f25cf0c1006c2d021a9c411a2e70790c1e98a14bddc81bdb82da33c083e6f7a9e8e0f693ce3216b33ca9f4b92865c2825b201afa091fbb49cb09352d3c4c382f40dc86486b7e4162e615e01c80dee93312ec614c9e86982f69022d7a26760481ba6110c95cfccb21f9f2b68b7240c4f8226831e74d8d72e4e007190044618e232b804d571662364ad40e7b94ea91227940781138a80853d32a81d37bbc04c066949526699d1284d46063d846aa2c688d97e2a62df328f24f0b041556622c7873241516e0801737342c9cd942d71f8943503c9c70069179dc316175e503074932621b0551fe80ba310baf410c5648c102802d882c02ab87195e3b6fefc6ee03494343d1d2d88f4e263274633bf919595bec65069c944028ded02c0363c4c7e216d2a33081443d348a791ceaf001a458d89530d307234fcb40b1542e5f5243f29b5afb556c2a60e0f4428fb1ff8e748565a1613404a17b47861b67b9c795120121575478abc502aeab8d9d8d478cc91f0fac9e2a1055a618aceea4d85c552baee8c5811fa01f12147959c76ad0af1c90cc263ce5cd495ab0789527871cd782216c7bb31d5a342ff746308bbbbf285c20e912f1f123f3e568c0ea540604127efca39829edc102dce9dbf54ad60228a2428498ae831d29375840434c553720e4f499334843bdd07037f228a1337b61b646097421cbb4487c2e8e0d960e6e509cbfea44ac3c29a1c4f13c50670678a70652325cf3219b5103e3b67b8c03c5a811f3ffb215131e9aea17229872e129c4024510ea7940067d578de7e5138033c2211c0b4a705fb07397031804853c3a200c85d9820bb2f40133684625853449e20100ee28581605bdc25134f4f8f2b2a42353dabd61cf4e8410974c0fdf99a509b62c40911751b13264a46341122da7121f2439682076093091280552843929b6cb1b6038989284ea030381a8aa4b205b1829db709219b02d2b24612cc489da008433768174a586e382b5d9a30a8d9737422eec2520b311b651e6d7cadd0e1646e0b94b239d96187e98364f2f1382bb1405dccb0793424f0f244890dd685b51a59a32d7c614b661c71c920a40826a516480a5a1838eb1f5fb669366e7452d9600a6a40726515f2a0360d304506556f72152a8cc654d45b1b47a4c2ac1d558df4f8d9a0e53a92d494163785869abb479c07b2a39fcc5c72aa018da102913b6e323a4698282a140c8ad0551747a9b82d8bc1a5824e8f66b7ac9c208e716d9aee49921683fc2376a684d291d847851cd91f2f2c029e10755add781910048c5a4df864d34496243d690205f4d618d97e9ce114eaea5e547d844051a639415887f1cb808547d6082b91d80c8814f1cfb01650c69ca0cc50d3d55305a155a1f0c20a1643862a9fcc7411f1e11ad4e0f4e45ee0766304dfb806d0d5d0061332c8f0e98c7a5161b9696907228707c4840c66c4c86a8a2a1814f09b22a7c4fd6145af06925ba41507294ab8b61a2d84c4086002f9e8551433e3c3e8c5e49299872a93a760f71702d1a8cd0be216a1275cb004a6587a8890004e9a644b2d359e092d60607ac2c5571d0f272885d4374d1dd2a4981c66714259947b65491f3d3680db231fc25eaa762c75b02c11f370e50462500fac1f2b886c6d9c9db034efe0cdc0475e30c338f1db4c51c0cc818cc9078e59dbb51e1e202f3c3660cb307676a48c008a20271758da160ab8b6c4e87c0cf41c2d1f51e93c400c4039309d3b2091738bb4d3527961a3b358e6e7e401a76094bd043c801847e064d01200a7e048712e513304a51104cbb2184922c126e8acaaf87224c069dd7048926ca9680c3557e92a02d69701d209e3e5b584030500539c9a08162092162569a1b849e1860174044d233b5da9296d95458850359f45005f4e742e3de0b1f533b828618481c5fc4a1bb1c3570a9e86a2013decc879813d789c1739b03273c8f4287a0874bad223f45760548c68844a1b3e67fea6ec9d3798a574d10226f138be42d4c7d94413470d19992bec028928a871ec79ba11259099d8a28a53ae00497b22ebb377c133ca908a53c48c2c13749a6584439a5e3edc6001b636e1c499ce0e0b021af00419d308438b85f00b215fc862b670002e19188454ec460777d2512209eb2d1543614f2c455b4d26f8e2e90076354b38f0c88d25e982c24c68ba706b432036490a976fcad70a1f210f1e3ee8758161292f589dd9ffdf1c8f3241f7f9bff9ccc7d1743b149d8ff1b80113eb15efe8103703e736d5cb86032f4a7cace2886446e15bb40a0d83b523310468d58548b78da80e104052d0fce0f23786e3844b8e2f57673d22142b7707c33173fa8ea6b625842ea92d51efa5fa6da00b581b571648bfe38ad74439194668cac82a3ff201c809c63504eb0a82a7627131fae4bc205ee720c537b61e4cbc35e634185f21993f400893f25882a4b97fae2129a36140934e9bcb13250114ca65f54f0fe3238f4b0aa855d9e985cd25225003aa881247f065112812e5acaae20947d40d9e91339933e159fd76b3e5cca6f2fe37d39a5beff559bd3a1d76defddfe06e3af8fa2d07a7eedc50a966f2318f4b7af7531abe7ebcf118f9ff8fdb3e1afec7f5f631eeffdfde7b3f566d1fbd4c8f49ffff257ddcd4a4b47dcc4f90f9ff7f7dad86a7d973baceafd16bf6ae56c7793b7d8d66bbdd707ecd4e2fd1add14e500674375b27dbc9f437bb4e49d77bfecd86e3e9fcdd9257372a0afee614151515057f5362c705f0836b8a1bc7cdf10de4d8fadabdb7bdcaba1605ff5f5a2b99ddbbdd9cb9473fd1a5791dec500928db128057caebe495c5ffd715ff5f25af917f538a7c8980a5b2f12fd2015255e4fbfb9757093a4400e2d29fd658c15ab0498dbf1c26a24feb21e2034d342a45986e270f48a4280bc372f37ca08e9220c5d7507d30f55945f8e18c0faa4567a83c8c99f43b9258f9b66428e6d7410f3b09c0cac66f2ec3dd8e21c5037e50669174885dc8f491e6a8cde8c108e9fb61a322880f26711f220d85bb4bb4327d6d8f5a5e4113c4f425453812820f6b76307a774369462ce6a0061727040316bc1c44a856a152b04ae2c0ec128bd458f18983a12a5d00c6b431e0038d60256afafae3a39c0af70948f37c0e0a2bc48925d97c5e3507009dd60cf97a1a4be92a44b6f7a08085d8e8f18ded9d4014712043a5d59e3b470c0ab2b1bb57e5b9fd7b7f05f7b2445a45dec4e4f1247d52ed30067571101a085da4883211af43315e42fb3223eed5520980a707a99e29190b1c1ae24daf72ecc1479607937a1ae4b88c38bc04f4cc5534273310da7a4a977985508c0bf2be343140c2d0cf274f070fce067cbb8d3c0a75a05b2ac9a0f2d0ca476c8d578679bad6034931d34cf895ea194fee902ef01797a6647a343be08027f89b0cea3a785889259c662c6ee03e6551fe7a1d55ef293894de1ea7736f155f8157907408f186273992f6e60b7a67c1f1a288a9e4be6fb81471583b21a1cf64a3a262efccda8fe88c1140c81bb34f7fc06175a305f661cf284cb73c233d95cc42df67be711b097380a54c57855b716d4921110c05b79c8eec882d314bdc4ea6ee45115dca78634c7bfc08598082e7c30b96c2a74905ef428c1a6730b4dde1b16580ea6671d5f004400ee0f1a3f4b4b9f4ec4570a295368d25023e3e52a0b507752c5c8c845b6db3b6908f1b80956f7fec4f460e46d43f45d8937e5d78495a2b369f1c0d0c2c84447617d198e98e318fcde399b8e5865fd3fa8915805f999d736d823154d14ce0df1a2fec8cb3b4cec3fa408aa3af93fb708d0540d9a3420f1c3592b69a11edc746062a55d4742854586a9561517b01a88d177b01e93354018864664ca58504496740acf1412c04491aee059c8f0b3882e9023e1e846faca4eebe508930609f99ee72dc11a6fd75bd7736eeca7a1dc028a945dd3510c5928b2358b069e0820bd869ca91a6c11fa80ed686ed1b901b70d12bb42ad570d09d6885768d5c99e8143a678e917117f43b344853536e011a6b46676424190bb40d8f3a3ec9304a3b267511cce060b2c06e04520839532e30bb3b3b292c344d431235ed7242256b347adbba223a475d1e93b0d471c06bb1208b1185ba1dcc051602c296d435d5f003bd7249a0136346f14a031062ba1e729c5b6c4c92d2596870fa690e3ca45b232c12a3c5111cba004a32c91cde58f15b90722c7810dff91942bc4f97549487f035c8034648169e6c5309195acfe58324e19b5b875b672a38c6748671c267161cdae86e74aa9df7bab867512ee267ae334f93d498253b11734d3ad5d8b4b04ce71c5dc4bd16ebbc73ed430d772c22f0981bff9d758192b89cbb7a21a7ae889a90c3945b0c70740afa97c8f12f403d0c7e1472dddd4ca592312ec0387b90f156d3e15be68ea1520a0702bff8fe066627d063c90076a98f382f5279836d8ad4381c7113c8229f2614a08c3b33a15628e20c4c9c1193b52e2232b49843a370ded598bb985d00817219bb28607e605822080e8bdb0cd616dcfbbce16666c00996f613baf6c7000536459c86b60883f735cd29ee4926032c06358d6aace7ae855b02b826863104876ba48b74825bf103ae815527d8864f351c780dee13692749d0efbd0de11cbaa23d737bdbf0076623eb49dfdbee6ddc70841cf56660cc4d4cf54d34866ee5c68331acfca38aa29ba1d3168d0336866e6a6e0168fcb6d84a05176471227775730ab140860fd1545fd2830582de05630b804864f9c16d44d0e6d9b6a22ddeb6c5a34d478a6d93ad041b9b8dea8ecdca650dd370cd43e7da19702d4aad8c1a90b0a8af2089a66a18d4dcb46a038a985a496deaa4756913391bd82248b39126e18c0b94b82012690a9e7cf971e1259a8656054ad09a14cc1b5a0bb2e480441f7e687e685f768530a8c406a0696bd4c009691f95a38881cb6dba982b3f96957b9cf2d50ac3155e76c9324dd29912a3331167e833f0d95760c9a720b152419c5a01935b1ee39ae6c02c8cd90eb30a66b33433001ecab094c5f8290b2c132b23f3248bc421d3b322d33a93e58c698e91185b8f89c38c55dde809743b06b14b23b8893623915807b13931a804a4097e6c1320a248b0202b41d291b0d1b01a6111c21410e9007970fe104606edc9946fe43eb217590c0cca1ed8891dcc1d0a6665022cfb95e42bc4971d95afaf97a957a59706202fb3d7d2952e305d3bba2850bbd0a4ba740c5c57b86070017225e0da9ab2a5622b6f2b6b0b472b538b84967a2891c414589ee8ff5f8bda68d68d18e1153507e7b498ffff9ff534088845a6c1c7f241f8b10eb1b0da3e56d247e0fdc2ebd67bd49322e2ff5f6ff210154703da41f2ff7f9ea2ea3e453d759df8b39befe16bbebdabf9b9f71cbcbdf7d6e3d770f41abeb7bbddfbb643d1d73bfc3fb7bb77bbb9ad62679cfe5ea3d93ffeff713a5a915211f2ffb8b8ffaf27febf9af8ffea58e2232a2a7110fbee051c1abfdd7b6f43edbd412cf667badd3b6b3cfeffcab8f8bf00f786191bc4d62f1900fed5c7ffbfec6f1321db12c5194a3314463d4505bdb021cbb2d577169fd25dc73942e0d9fa38e056639c833b0182611b33b37382140208041c42ae846047ca3b1cb870224628019270376d55676ff2be1c961c90e1563d32b0305aad90ae31f01607005586272a02e8551be3fac69200937143869542a15523cebc39f995d1621da3439c82c59d7186ec4cc6612ab716763ccb09fc3c1ace6c9a8d4d79a23819086fcd0f744312e4beb8c0a0486300cc8e2468864c563ee2b2a5b7775c891a5c9d4e8a1a1b671ed24d2d5410e350f47c9eb9018c908b41b4e4f6230ecd752060af98495d5ad77c6ab0e02a7356777529b6d13340108eec911b80599995c58b206e4398cf5306a34498558158e83d2ba79f0b972544880cfd6045d5d1d510b285ffd06698a28a84839e225f2260a914d1e5ca9429566867c82c8b1c205545bebf452aaab9191b4f9fef9f4ad021021095a8dca0d6956ed061c4a41d2b580b36a95166b928612ec56918a11113d1a7f510f10f928ce6550acf95038446a508d3dde4b4465ca495f20aa3a63645591896db140f7b95d12a0f42bf3da32809527c0dd4c3ea8d9008c69c0d17803eab083f7cd10423cd14b13ecd149bdba233541ec6b09031991d2aa1a8e5b23d4aac7c5b32146b13721c934ec2128414a4879d046055d339c50cc8a81161a7d036c3dd8e21c50343634ea6be8429a9c28764164987d8850cd3cfd2972329489a4c42396a337a3041087b6c28813ef8e344e3daa808e283499c7652aacbe84027b6c54343e1ee128d749445d450d31e967658e851cb2b6882983150211f7c6f2aaae0e0463812820fcbc051c6d7e5861f2e5886f0dcdd509a112788418a459022ae830b93212e4e08062c7475b9d0e6a35838ad12c0a75a854ac10ac9851b0b47619aa758c8782eb1488d159d6cd6585132d9f340e166a84a1780316d0c08c0a104b9288581d4fa44b012357d3d88c06468a7a33c860664cf54b84f409a9f4ab3d23dec90ee65a2c20a7162c9758e2d956025a1432ad24fcd0140a7b542225ea87c94bf4c2c8af53496d255886467baede89df4609f551158888d1e9f580503973a7fdcacd3d30fa28803192aad0ea821b82ac273c591439b230605d91855ca75cab771909c3b14796effdedf400d233a90109b52965d0044a455e44d4cae152a495622d49d06d3f649b5c318d4d9d1587317d150526b34d240e822459489b79b8ea2323c9c247d81508c97d0bec84024f393958b5c2b3eb45a2a01f0f420c51acbd8d1d8c763837a44c602878670f330c6b0aeae29140388a0b1071f591eb058612e11218b802cef075b392e230e2f8101426521d42008403c2355d19ccc40681f706bc161144912c01141977985508c6d963f4af11d8f4f3e0c6d9b182061e8c76d942241c8974006f341e2c1d9806faff1e18c23de87361c2b80501de8964ab227cf33840b3e047e7cc9b8e523b6c6ab425133f495de59f8108f47eb81a4986966b99fc0376501417061a87ac6933b64344204136bc9300d3fc9bd3425d3a3d9d1008982016b0cd44704784ef03719d474369c3c2ad0528e7e62192ab184d38c854d102613648365a14b227dcaa2fcf53a0e20b121c35ded91a2a8f5e0507a7b9ccee940010173792846a925fa0abc82a443083fa1aa1aa02db864107c921c497bf3059db9511b062fe49908f7c0f1a288a9dc42d85ad013de647005031197220e6b27228448b20423c9c23985e00f1b15157b67d63f9d093f8cacae04a0f674c60820e48dc99ba0424f9aa289e6451f7058dd688024468481879e413b81fef18cc274cb3342163a068384f3d60c342d9985becf6c634282f931440c460d7946610eb094e9a620d1f680d34d729a8103686d4921110c61e017c9120b20ac0531d5eac88ed812a36471690d8627355244d7c8d4bd28a2cb1986273a28a041749ac60032edf12364e1c9a3e7e90800098678065b2f580a9fa66716181ec65e54f918811ec5a8710643db1d37ad878f96a62d1c0e046580ea6671d35048014b595b1bc055ba851cc0e347e941a3f401aa8d34c2b444ead98be044d109824a688c3aa15ee4092d11f0f191a22c62110af6819817313fb83a162e4642ad2a3fe41044da3dcc559ea1344c3faacba3f818946dc14eac2ae4e30660e5db0345023f4888f9f49148b88c1c8ca87f8844225561d4a4e831fac8e3d78597a4ada2d0020d3722cd6e878421391a185808893b109e58520364816d7c88c64c778c79ee4b2a59b0287869048f67e2961b7e060e71608880938008808cc80ac0afccce99e08bd0b4d406508aecc318aa6826f08f9d5677b024f19946f4849d7196d6791830ba26b926faa68d11a538fa3ab92f94181ae0490672b485ca0f00ca1e157adcc0583108238b095a28daf3e282d48123ec1f8520e04438515055a308edc746062a55b25d951b8a200696f1f1834285a55619162a6ba35ea6937c035a0b406dbcd80748acbad0a005cbb9d08ca80210c9cc982a53212988d164b1510210d80a56105220509c5a3c02e1f3ac92448b58e383580892be2e6e341a54c28800377a01e7e3028ee02ed8e4262587cb812d403e1e846faca4868e50a0127433c0b2704b25c2807d6672b0b92ef3622b58d71c359072e60f9bc2bc63f281669020193228edafebbdb3f167a4ed54cb972f91b0d5eb0046490dca031eb7884e659e970469000f092746c5945e6cd9863559ec621684251747b0505383896d87cdede391b3e502769a72cc5602e8c4618b12f5a18d04aa83b561dd4d2e8b745e787ac144263428a484efee907bc20a102f8718c22b2e7a8556a51a0ecfa0e95f706aa0d1cb835668d7c895d983e8f0c18a04a8726148e7cc31321e9d514a80ce49e794661837344853536e81138708483e804d9107786674464692ada8200513344591510a96433ceaf824c326a574c9aab81c0ce5e9f8d445308383c982040b1ccf5437acf8b1d9831442ce940bac0a0cc219463d1dd54e227ec8d499718e139612a8381d1db05f1f2c344d431235d7ea76da86bc9d56313d844ad668f4b491676ec9158742203014e91c75794cba226926a32fecc1a19ce00f5e8b05598c082b9c208d3ad0c10d43aa07cc051602c294904072da0125a98438a6a8861fe8952b0266d7d388904fce0b1d3f6614af340031d58487a095640a3c385e2bc7b9c5c624a9831c6c9a44b880f2c8a8c1e9a739f0d08014000e8d4e985e9c01222c12a3c5119c0088a12a5c4cb1e1e38c56492699c39b2ad13e0b85b7171cc2e723a41c0b1ec4f73e8b2464229a800ae32021dea74b1a7a385a41cb569ee01233dbaf411e3042b2f4049854606470c96379b4a9840caddf62c14b4ba161c867286490247c73eb702b008f9eb42d1a194835b638c6748671a460d465f550d566b144240e6d74373ad3b8dc2c923500ebc03741a88b7b16e542cf0b9b05de96c63d3322b8535bef2f3d82b8191aba0d187b92abc2d3243566c92e048b1225fa8c34d9ca8e843ad5d8b4b0ce802611d1545ab8e38122d745dc6bb1ae3b08f9b716c536e2d5f21c6ab863118147588b3792800e4d37ada1bfb32e501247728029d8e279bd1800e1e3859cba226a82c73e6aed08738142184f98b2998b3e689604c9ee03839b113444018e4e41bf921710f83753947611cbe705a887c18f024eea8a0fb42f5a3e467ae006f930ff04bf1f362ef59672153644954ac6b800df94aa49137479222545ef67bcd574f8963957e894e9e6f38392b4a7520a0702bf781989c21e4f3dcc0b71453d85272266beb400a1a20c53c70ba0fca7c79201ecd21e61c2b8f439744b91b9562a6fb04d910ac7c4f0cd660600b53aa3006b63a52e20e4b87891a6d821b576034416f934a100259117114f01be709c555a136a8522cec0fcb8b528243b7c201665c464ad8b888c2ca319647485fd45ed850245e1bcab318fee809b1b8c386d3383b40502e5327651e0c3816e093d75002576645822080e0bde07a8cc043844c824900c6a0bee7dde583045871412ed124e356b5b0b524f661c580c9d8292ed10aca0e644024bfb095d7b80c1c3fab36e6acbf354089b224e434be451d28bd9590646181db8d734a7b827994839dc7ab8d6cf18491e2b57d2589f0ab10ee425a6c5ae0c5d841ad558cf5dcb25f004ce4386ad20900bb8268631f48682c5f3478e06c32c300f5da413dc0a1f54b888326aa2b0fa6386ac3ac1367ca64554c12ae305725f4ce29a8e61a598a955516064c3052d439e107888b49324e8e333b2f0b8dc6b6030c2439c4357b4670b76d8c1189b153e12aaf9fc81d9c87ae2c0888e68a6279145adedf1366e384286d21cc3b25c2a1350014e34080e400552ac70c5111dc80722b6b6fc54df4463e85655859b37344c412fbbf43086957f54519c2bb1ad4a248205874791d3168d03368549424470aac12985eff2a7026322d481123aa0536b952e82e4106869fcb6d84a05dd66a45b6c184922bec889dcd5cd090484173c66dc045891a10ac88768aa2fe901754c1e47235a0819a5d503238d32ea2e923152452d2153276054f81846a8b2cc0ca6af84279e9a074d2012597e701b11fc89195204a340dcc1562b8a039d42a8089d99e667cc59904a284759503b798792ed0e385d0a6538be350481079820e3ee42a0d3664166130444f8f6ed0a1627a51d58aaac59f4e008e7183832d31307cb024796f84c50b64100185750a593208d60260131ccaa10a4106c9cda2af114032ed9280382537a6a63d1851989061accd70222b676f0c493213d3215da01207ea906250a37e49051260eb40377ec45ff85db62a54a8f48903df468cb73b514a60765a1164b523692d02c413b426776b88010e5f484d2430c024ee41731ee909e0090963fd1c9c5b65de6688f123c23c2ccd826d19577f4b56989ef588c31c478a36dc6d8eacc88061f3e173ea9009fb0a8af2089679e68a2b09372f32d23d843434044121e223f5e00744a1287661689b0ac8a4020ebc161951bb16215ca90c1a788a995d4a64ed499c51b1d930bd7ea6913391bd85e595064513584c503778428548592f8d190be01a04d628a5429f5fb39e302252e68442916231c19ac227018d2f3e4cb8f0bafd033849f8a90dd29154c8a341c559881d74365a975f4815e22097fa004ad49c1bc0d30d28517935f18556bc99203127df461b92930f8e3c8cd970a465a2b484c10f1c425c5c4883115af333d20bb4218546203aaa00ac62a61207992415ba3064e48db8851c6fb6a6c4087ac6524062eb7e9422e918dc69925297e5a55203270a2926f6451b642ced8083a832fb74e405ad6fc6e3e779474e5f6acf86872b4c27085973db251488128884328e9c3a0c2123a94c804b8f87ad7003a411e756f4958e1696c161da6e1f6c808d92f1790ee766a96da8424e8dc80e6d2e0ccf8140ae056d758415503a837618baa8410232ed1851c4f5d848c8d34a5a584c4107ff2fcdc1061e39186b2a1306a006b202e86d00d4e153ca4f63ea3a000e4ca54616494ab28a406661272256ccb9fd20ab829c0139fd2e3232d6d839d5484cc93b22aa421b73cc6358d0fc883115f603204c5797d7c3e90b172c94d7508c4c265490af1e091e2a3210c82c82c09be02d5e158011e2ae5a260d40c83530712d6854da0fc741fc5014f0a40fd792dc56cec4e2f43007bba647846d0d1218c3a882481b1431a3a22123a30999cba05205b4dc9f47cd06bfe101579ecf1e003237b7ea142945fdaeb6191994587db032702828f1b34ae4c482c122bdc9269c090eb90248990c328266afc9420015f92888148120e4ff740322ab5458163a26c3d92d73030e150e20c425554066db881ea06d290486f838e37b307d0538dcc2842aa2464f69953e0f5e8b2d31656aaf8143127a2e78c505a812320b41845bebdc61d449cad248649c3f1b3740084630949259f90d1841470514a282e91d39eb1a14365e62b2cc916ca07457b79308ee47e50392413777b5ace5cb746bfe3bc6ef335a7d17751357d011aef9bcdce9e77dead846dba76cd7c5d016bb767aa7adb51d4aed9fc8ef34b79d76c8ef3df5f1541cc21347f323afabc7a5f5bc58a38b8373f89992c593f0b84bd80dd2b35538694cc183161c07cf1d26594cb162d59b05cb1221a5a05f4938ae7944e4e2951a03c71d26453f39a7965b2e46af9ff6772e36dc57a801c2fd61b373fc998c9acdf9fd73a0d96e66aad4e9d2aa1ac216eefea2bb6e7db7b6f07e6deaa4a5ff3e919a2338afc3f23122e8776bfdfbb5e370370c6db9f71f57f9d7be7e77a196a19e5ffff191d63468c19ffff1e1da303678c22eb1c0c1e1890301e6140f83d3a6e1ca7d35469f20f0e9b693ecde38beacf9e5ab3a665fe77f3e7fd4ce9ff66cab428b5d258b1a54fbf5a06f3578f503e5276a06c40f9460945a94f8699fcfc93939326261d2719f5b1fe9baa6b7addfee6f9d07b62301393f78d9673028775379b6e490bfd0556d27bbe6e6febe1af945498fae1c28a092bfafeff5b91b5024c5dafa04a62a9dbdf387dcfa37bbd30b2c4af7b1afb98d7f0270029d47e7fcd51e828b87a5313fabd5b9158799cf7b8f39a8fd3d3e91db2b1baa2af36d2f56b3e6fb7ab86ab00faf7094c2efff775fbbb6e7fef59bd4c00e1dbea7ed733f13661f64dfcf45a6f2a2d71e3892ecd3b3e7e7dcc756c3b227064fabfc48412f0ffff3997d048e2f3ffafd3bd49dc2001a9d3b1751290ffff6c962c16d24f258d2b4096dabe3fb731cb88b8461d8d9363bd51b0f1ddf8d528d62f34f2fccf154145c4923f16d11611f9bf9b3d27624c84d2ff717121b2fcff4344fe1f22fde3aa53aa9c5a21b42048b9209ce8bbfe8ed3cf6afe8d8eabdbdf20c440fc8138ffff7fdc9a8d8e8bd37551c625bf773f8532c6b98c62ba7b8d76dbf5fa1a3d7ecfa1eb7635bfded38b868b718b558b411fceecbd3fd8f850e2ff1f8f52429fc54e5e6869df6f8f468782c3fad8fb859bdd7b5ecfe75d79d2e77640a777aee20f3e8da673a2633b9dd78a2914191519ff523ceabd2be9ff738d91cb388b1cb270b8c181f07310d300f939146dd0b201ca86c80de90de14432899d898cffffdc4022b7773ff51a8e7c2eb22e7dacebbd063106281f43d8ff67bebdf766f32bc2fc8fdee411f9b9354ff7b466af09cf88673978afcfd1c5a310c1fe8f47cdb5d969f4de1beddeb35ad92f5eb25f605dc4c85d87496df505cc1fe002dbffbdfb09eaea8f5ad8f1fb1316d82c9059a8fafff3ea7d4d6881e67fafbe256dc3c67f364cc7c595158efe5f58e4eb6fbeafb2e441a15ef8ffffe82edd2e7f6eb4bd8756b7a3755568e2b28542e9ffffddf3e70314e2703a2d59b8bc90cfe5777c2e7fe373791a9fcbc7f85cdec5e7f2935c3ac8cfa573fc5c3ac26ffd592ba26008d108c3266c4e28328192efd37ce86fb3ab98ffcf829aefe63e79f5eef6daca52f93feb39e5cc04f194b414bdb773e70024a0e9e377bf66cfe55b093cfa382790ede4648ad0f8f5d86b7d0902f8ff7fe6f93978dfa3a5fc9f8d02e5ffec1327ff679b6cfe9fd5ccfc3fcb64c9ff5925d92448fecf625efe9f3d62e4ff6c111e22ff678758fe9fad14f27f36c8ffdf0ae4c7ff591f3d78fc9fdd916da1e3ff6c0e1cff676fa868c779f31b8d27f8d93b0d107cfbbdfb4910fcbf3e56f36fb4fe20b0f33b084cfce6f39abf0b14eb635ebdbbe3cc71fa9bafa301844277855fb3cd3dda4cc7369fd73c0d40ebe7d5bb9bee8fc9fffa99a7d37ab3b9cae773d61499cd9586aba5ba0ae23bbfdec576f5da6b57af77b5579a1e5b2cee554e63bbf9056971afb432d91bf7c6c1e1f3d9cb2b0e0ec7c1e1b8991938eefdc6f3d05c5e5e5e5e5ef13838eefdc6e3f1b4b8f7eb8d83c3753c592f97e58d83c36caeb434701c1c8fdbc5d3c071efb78e27ebe5b2d2d2ca69f858390d1f4b838fa5a5a5a5edca69767568b0f39ad7638ba589e3e1ae381eeebad3f031a9ae823a9eac97cb4a43ef66e773569abb2e2f2bad1cdfc7d6e8b1357a4c0e5e968397d3f6f2f99c753e67a595dd76e5b45d39adacc776bb77b2bb7e57bfd15ae9741d4fd6cb65c1dd687bebac395e8bcd26f676d5dc65626f576d9dc526fbf2c6bd716fdc1bf7c6bd71701c1c07c7c17170bcccc7c1e138381cc7eb4a4b4b4b8be37581e35f5fbc182ff6f595567e8bf164785d5f5fbc182ff6f5f5167b8bf164785d5e5ede38380c8e7bbfef3ddd4ef3f1a1f5ca5e5e5e5ede3838ec8d83c3e0b8f74b06c7bddf34713cdc25a795f9f52ed6f3eb3dcda7e9e8e076e570372eb6210687bd5fb17077bda7ffcfd6e0e1d7bb98181c66bbf905de2f38ecfd86bbef3ddd2e8bbd71efd71bf77ec1f170171c0f77d3cae2b8f8bcb3c5c4deae9af72b8eb7d55bde6fb85b6737c726aeb39b13b3d9c4deafd85d16eebacbc4ebf57abd5e6789c35d3978591ceeeaa9cfcee72cf1394b4f7d26167bbf647e6ecd7b81c36ff4be368756b3df5973eefedd9fdfe83599579be7dcbd9a579bdffd797fef67b2f7ebc59ff5643afe2c9d8693d1d1008767fc9f95a180ace6d56a5e1da3cebdab7975facd7f8dd87b9ff9f61e5a3a9d6537f70efb5918edbdf78bdead4547766bb9b5ceeb2ef3991edb6d8766aedbdf7673ef7d6bcf8dc6f7e92e3a729bddb8f76eb3c9fecfbac8b6f866cac95fe7ce62010e77bd5f9ee7c9ff67576425b3912afe925296447644635644b6cb6f017171863bb39df5b935bc06d9d9faff679a339c43cb86f859105946b9a645c50f8a590f8a1d14e3cce2c0bfa7c97637fcffe1e6b819ebac46f75c069f5c066f2edc2617ee06151b3f93b56413b31ab219b2182aecbdffa7dad0f167695e6e17b3e4ba7d6271dddaf15dad2672a301873fd2821bff1358a30d64110fffffde2f5cf77ed5fdaee7d4e67821683caec2602bc286f8ff1afd15b005ad354eaec505aefddffe5c352eb5176869367eef7e32db99f5f8f5ff45d2e2f4b19befe1fc1d17ad0817adf17f7dbc86a34d407380c6b6a4b3df4aba9ee6e5d66b741bdd7e4788e3968b585893d56cb7d71ea161b69b2dfc3f4ba182de9989b30e6718ce2a9c099ef99de99da9cfe4f4244c902041828408ff670721c4cfe40f666e0df7128cff9f0dfcf133b90d3ff35c47cc46f5b19b4dad3123c2356b1cc728c13543fb150a7cae19b7b0ac8860d97acfa9b8655adcb2a8dfc925db41e648d6f7bf6ea5efefb4d5988c863bf6f9fbc61cff6ff0b9634a5f2ccbfffa589f5bc3f7d874905cb1f8ffbfbbaf79f76e163b6701ff1ef8f539e0dbcbc67f96ac1eb78bc5e776417e6e9789cfed22f1b95d223eb78bf18d9b404977b3e9d4c23acdb8618d3939eced3f31e50472005f4c96ce249764b61f010cf3f7eea71c2e982318092e58dcff1feee9c9ad1fa7f9335bede4c9fd1215e47e01feff7b78fb8d80fbf53696f2520235b786d3657bf7ff515c2fdddc73bd7e978fff7f93fe66d7e9e32e2cbcf6235e07392e6e8f83616bd08fbb95b7b5de4273b7e6b85b6ddc2db2ffd57c9aeffb9e47cfade1743d9f96dbdfe72e7e2ebb56a7effecf3640dbd5d1fd9fe5cfff67e7e4e267725a5ada5ef67ec9deaf17ff66abd96e3370d82b2d0d1cf6e2f27ebdd2cae0705ad9fb25a795c1e134721ab90c0ea795c9e030b9bdbbd7bc5f727c1f0387bdd6e83170d8cbcbcb0b1c0687c16170181cf6aaebe5b2c061af751dbadf6bb3b7bc5faff83ee6fd7aadd163deaf97979797d7db8d57f67ebdde3defdebd5f2f379b9df6f27ebdd2687ecbfbf5aaebe5b2bc5f2ff79b9d7eb3cbeeb45d191c26bbd96ce030d95d060e93cfeb2c70989c060e93d3c06132380c0e83c364bef716384ce64b6f81c364f79b9d7eb3cbeeb45dd9fb25bbd96cde2fd95de6fd92cfeb2cef979c5656f367de2f39ad9c87e6f27ec969f898f74b968397bd5ff2f99ce5fd92dfebb936dbccfb25f3bdb7bc5f325f7acbfb25f35fe0b0172f060e7bbdbfc061afb71838ecc59381c35e785de0b017ffe5fd7af162deafd7fbcbfbf57a8b79bf5e3c99f7eb85d7e5fd7aa5f15f5fbc182ff6f5050e93d3ca6f317098cc9381c3643ebc2e70989cc67f7df162bcd8d797f74b4e2bbfc5bc5f324fe6fd92f9f0b23b1d7ff6cec699e7d6702f3afe4ccda7bbfecf3278a3d7e4367bab9c4ea3bdf4d8ee2f389e0f5d6eb3dd5c6fe83579afcdde4aa7d15e7a6cf717cf872e7bbfe270574cf6f20287c9de2f39cdfbf57ec3ddb4b2382ddc0d77d3ca62b297d779678b81c3e4ffb36ee79d2de6fd92df7c39bbe0cd7fb5d96eaeffb36d6ce9f4beb5a6f6b36968ef1edee09ce5d6e2e3c9e8c86e2d3ebc2e3ab25bebff6cd9adc5f368e9bd9cdee7cedefc5756c1ef7abfe0b0d7182e55e57ff76b34d5e0d7c7748e5c2a1aae18f3f36a78dfe6f9bbffb366d9b236db7dd60250f3d79f3b65e6ff34fa0de7df7b724a6ff41a6deed14fe60c5364636209c2c8605f5e5d5c5b3fab95953590ed22d8df3b971c57ea87545fcf6eafe9714e713a6ff70e94524a2fe082c58031f5267ddc27000f46819bfecf81b8df4dd3afe1152adc6fd3ff3d4a78977c7e0eadf7d6f51a306843e37a8b7eef7efa60ddce6e8cae63cfbbedde4e52ff8ee7a3b85194bf773f99db5c2830d9aaac377b808efc7f56aacd668bfd9f1d53fdffad12ba3e17eac7d9bdf3d0d517dc27c8fff5711cdfa7f9b8b6e9e21303ee53db53d17fef69b89a17e43a2db9e33a01b679fe2e4e8f9da653d054dae4d9b4e47f31b78904b7a99ddec7f9d413ae811fe9b9359c4e3cf5ffefdf3d7bee7393407c6e52e2e726117e6e9283cf4de23f3749ed7393b23e3709ea7393903e3749e7730590c1f9f133397e26c7cfe472b61bf5e367f2dc1aeed5c56582fc5ffff9df0ac2cac4d4a4b734e37ffe8b4fcbed68d5337709cccdd6d3ab564ba659a8a7ffd33c9c6e8792d8cc9fd997dc0238b0127c6e81a84f4400730da7cbb104467009c495e00e18fdeefd8e3bc0f02b7db601dcff3f37e90b37c9c5d7c76825ae0042009b1f001817800ec4c6d53bdfbb4eadd11db97a875f57b7bff506fadbff7fccd59bdcbb2ea78f7f904a918afcffb94884ffff9e8b24f6ffa7e3dd746c7d67d7a1918ab848d6cf3d82a46bb3d969bda93f8a738fb8feffe9f511f7ffeffd32317975abaab1d1966fb7d3f16e3ade3db786d389bddd3c7098cefba50387d1de2f9a6b34c935ead094e27fae3172d9a9d7df6b9d6b8c5cd6ddeb3a74df9f77de6df746efefbb345c4ee71a2397fb04dc229cde0d15d57d8a723abf7bf6da49ddef7a4498df894b94984ec3d7e61ead8fb9447163222f9728491f738970feffdca1223feecdf74f71badd7b0fadf7431dc6dca1f71fea8afa63359fe6b9433cff7fae50962f74832b44f8ff6ee60ab1fd9f4ec3d74f74bcdb69cd5e738596b842417f6cf4b941a3ffff359c1bb4831bf4a64bf372bbd92dc70d02c7e9fb588fedb67bf36e2e50e9eff9ddcd05dad166ebfa980b44f83f3f47d7dee302b1fdbfe77ecf71819a7e1c1d3a4e5fef7c9fe6b93f6cd900593d0b20abf3d084717deab248d9a3ac51866c11d10d0f9601b7cde5a2cdb9b3b862ff7fae3fe1ebc1ff23e46e07b7e45a9ce0c86f68959cd95c6d3a2b940d1211e27fc609603f02d8db8d1ed3fafa01af3e405ff3e928dd0a80bee6d3525c9ec43c2b316024ff6791c003e2a19a1902eece99ab9305bb4587efffec4fd627cbcd6ebff7abcdf688bd6479ca6477be6475b239599cec8d98accdff58d21abebd8796a51167a7b0e1ab94155cfd52b379f6736f94b8362d4ec1988e9e192d355366947494cce8985131a361c07c19f532da65949b85c2cd5661b96cf9ff2372b1915afeff34d82c9f7b6de25e79b856446e5ee4828522f79f62f6ee27baf1787baa9fe65ca1b1d229da195ae5b2b3b213b4f3b353b3938aa791ce259d533a39c552a6a284a1483d013bf936d9c46a7abf99e12e13f112ac126c122c12cccb23418cfcffb145ce6422418658fe33ba122b24c8ffe58f05f2e37fac8f1e1fcb63878e1c58421c7f3c06dfc0daa0fcbf06960676123b032b037be6f58a591323361903c6e4e4e4e4e4e40b175b3048fec7b6a0ecdd4fff63214cf62bbeb8f80229898d54910205e4ffd84747474747c71326f41cffffd812240cb123b01fb08d58111f422c82d092a985c84ffb58c6c5ffb1881fb07a12fec72af880a50f8bf97ff3c6632c05b014fdaf9e8b6315b118381c6e384cd470787878789801c3e121e2e1ff1f8cb5801d34c4166205b115b014146009b1132460d3b011b083ff63f5b067580882813d60dfdf837f46bff9be47ffb3df780ceeebebebebfb5f6cfcff8fd5cb7ba3d769675ebd93edadb3bc79e3f1d6f3cad693b3c1780cce1b8ffbffb170f17baa0fbba5f0c0ed2f1bbb56eff4e9bb061f8b5efbd838bbef553b7766e99cf2d57371b0da578d6770c6ce61e5fe19bdff382fa70dce49b31c3badc5800103060cce69f41ad6adc72ec0b661d9fe194d9e5bc3aa7df3b651a86ca36c62d3bc5fb470b72c3e03631560cdce7c5adfafd9e837f89b37f682bf79e3b1973c1e7ff3e0c4536129f0d77b05d7d50fb855cdb9b3aae678b52b36ddd59a17bb5af362bc7a278bef63bc7a5f5f9dc9e3b19b6fc37b357bbdd6f7e7347aedaa6a8e5783d39dc35d31f8eddecdf6ce6cadb77b6f9fc97b67b6d6d595f75be5fda6e94d627895d8db858be17051de3dfe0e1c3ea3e1574d16fcffe5b8bc796673bbdf34b3a96513ca923e56e2df68b7de79e7dde0309c8e776f92c5f0395ead47b7b37a747baf5babf7b539dd56a37b343df69666b7e7cfec7526854c21739f9f6102b865820386604987ad924ec0c0efa02f4991bfbffb202c10f6470c4f62dd2249c2fa60b7582e761be1ffdfff2d26f8f7ee27f3e58ff8f632fed997347f7ba4f2fff879376268a408e9ffacbf25b2ff2d11fd6f87707a211100fa54db21957f3b44f06f877cfded10a5bfb534fd5bcbcdbfb5a4f1b79624fed6d2c1df5a6afdad650072f98d4e6393b9cfbbd679d7ea7bbbb71bad75deb57837fc0df74aa7f72df3ba0eddafe1eb3a74ff74e6df7b7f00fdd4efbcdc9e76b3dd6ebbb71b2da7effa5a6e498f9dee799e6e4db6eb77304b9cffb1daffb13dff6379b03b61292f5b0f8dbfdbd35a589bff732dd89addcdefee2e2929292929292930180c0683c16030f8fbfd7ebfdfeff7fbf57abd5eafd7ebf57abbdd6eb7dbed76bbdd286f9437ca1be58df24679a3bc51de286f94978a8a8a8a8a8a8a8a8a4a2c168bc562b1582c9e9a9a9a9a9a9a9a9a9a0a87c3e170381c0e87a5a4a4a4a4a4a4a4a4a4c06030180c0683c1e0eff7fbfd7ebfdfefd7ebf57abd5eafd7ebed76bbdd6eb7db8d8a8a8a8a8a8a8a8a8aea5251515151515151515189c562b1582c168bc553535353535353535353e170381c0e87c3e1b094949494949494949414180c0683c1603018fcfd7ebfdfeff7fbfd7abd5eafd7ebf57abddd6eb7dbed76bbdda82e95782a2c05fe7abb636af26fdbeae8ffce97dd667be975197f668fd9bdcbbade6cf65999e7cfcefc5a6f6ff76e7e6f4febe97d9de586cfcdb1d7597d4f9656bff9be7fc3e5cefc8e3ef7f02c385cd70272d9ccd5c555b645d6653e2b3b3beb327789a571958d99d9b2c6f6fe3cc79fc5f2f8ba353b7d55b7a39989afd4fc9b5cc74e5f89e1e419503edb5f52fa57253fcdbbaf49206588ca99fb7e6f23c1dcd76835daad86aff99e0dd6f7ed7e7fef5c7d7a7fef7bfb1d5b6faa3aab258821b98dd1f46174fea7a7a7ffaf95418404f9fffac3c7b5c7958711345badec7f38f0f645938e6b0e1c37feff366ab8c0f27ecf9f5a6ec1d922caffff2f3d3d3d29e95d676662a972794b79031c86f76f76ba7fb3d3654adddc6eefe3b1b9dd4f2a107bbbf05fc662f2a3e5c4deaeb96751f5d369b49c9b37cbc6fdffdb06ac489bdd7c5beceda6d1d4f8ff2f188f75ddcda693ec93ccfce6764fb693d1add14e746bf48bffaf2eae2db4db484736faf4f4b40a894555d2fc3912233fafcc4ba0089f5da824304cf7a11854c89823000000000000056313604060301c0a8562c18044558575001480034f946ab23c994d85f134486114c518c38c41041040082160804c4d551700023a3dad7fb65ab528fedaa54174a916de89cd68da4bbb4dda46c3aae85b6d6e2ce4c887533ae019425abd9e468867da75ae9925feea00b53a5cff6c5ba965433234a8d2f04914cb1a2299eb20a07e583a799896d88ad31b9cbde228866baf6d3cbd722c16692f3512601d0c39bf1b0018aa3a1004b10f1509b8160e91a71b10045a0d18a1839204d263f0270e667900ca69468bc312c45c6c6215bb09242f34f3d33d32142f9d9da65520a7ed816b586adcea935b3bbffc09564d1efddd2907314b67fba7c1eaec0ad3ccd87e6666470e007ec72cf6bc807951b576861ad39369930c93b227bd8029b7bc5e8be7d82c20b24cf9ddd019de26c3fb5ba37abe60061b74cb250764bebd6f143f69b11c0edde2cb1466049fc52e39aca25d74e1dc00f1230a7824d699df5e6337f56a56861c043c8078cbc0a0c487ad6dadc2764a849c63c4e201d08ee61ee634f5fe0589a13dca1095bd510cb4f9a77a40c4299d44b72871fbb2647c3b90017627ba6c0f9ea7b4ee2ff42d9fe71076ca233fc5d8ddf70e4cf4e9ebdfd03c6a2681e78faafe58dcb85f5772cccb62b34c4e6cc9849af47e3057c3c6d7de0a9b490bc58922ce90eaf3a13866944692bef1825a4e96c4cb3d71f4ffe3d916f75897a1e7033ee803f136c03f860eae93ee2135563fb4401d4d06fe402759cfb00070f9c280e22a2498ed06aa980d24ac20a9d6a2380e5743840ef6567c5a65d629883b9d1a6cdef761c83b6ea4bfeda2da271790332f3ea5473cef7a41a466dcafcbfccde55fc41d3b95b3b99bf830ff5a57fe8d1110647cef054bf26ad85306fce464185e9e4ceb6ca3af2f5eb5cc51d7e8b1627a634ef08217ee4c66758e17d946567c13c7ffe2326b960bcc6cceae6ac09b7e022aea906163a7b73f08f0f466b62f436391345125f4394a741d547613b0d63df8713616f6a0a473c9bced93f78dd75e2385df0d2e0a909020c20cd694512cdf2685b594d81fc79c0dc2eac96740bb64aa8e0b4ed08e57c11314b35cf8f341408f9e6eb5ab0a7e0a6b096f79b93bb4d2bf2ca88adcb7816a9b97daebabe86048842a1676bba54e11ae833af609d7107a29773b47f6bbdef0df5acd1b953b8bad7190a745fb98563ee1db31d81c3cbe5c6960cd0c2dd44f68de0a66b9f15f81f9f266ae8b1ea12b01f8f1920fe21c15ac688e17f46e9de2cde464c5f57bfa03da534d8d32b1b3de3d5fd057dacd0c5451d5dc91a856335c854db0f9d0710decb6d708b04a154594ae5c037a1e1986bf1e337ea3a5d9870253ac9cf3e8a41b6a74ea3a17f82f705b5df0fa4ed256da8d80cb80d434bc12bb8196a87a6290806a2c831bc38417233eeffbc3670c8dff1ed3047198da1d7a15600258a6cf94cf248f2e95855e3442cbe8e761d960fd55911c5922224d455e190b6e8d5a8ffb1cb542030cd578822573cd0dfc268741eebca41ab39e0f72a855acab699480b82dc4f189c52a2a0862e2aab51315a76290f8bc49696a4064c7cb3fa1f306108f9d7b76812f52cd1b0bf347a6f320f1d42705bbdee302e439649f0acbcfd7f3bb16a421a7aa409c17dd2df2b39fa8be5d1373c20357d2f9158d35a1547227da775d5c93489ca7e2a63f0bd187fc7effad69653504b73ed0dffa0a05e646c698998de9b6a0c00403af3a71b7ab9d4488de379e53af90b3054794d286d6af4800e90307cd5d781f5d70b1967519bbf0eb7267eb69a2abf58736e2fd060656ef74d1c585b9bac5ad769d6bcfa9a155a64b8d6b7cba838d19637665a4f806d0ab61c71456be1e8f09c5e85fd66bfc17095f01a667658b7be96ed0134bc4e441070cf2eed57b1af44a456db5df244fedb859fec573af1304b52fce16895ec48e0d2f2cd5c76cc2061f6ffbc618e1cad67f5f86fcd6dbe8716078c3563331e6edb83e80f253c8cd2a86362313cb79ac5764e476fd12599621ef6f46800bf6a1703e760c9ff259b655e03fbcce9655dd198ab9e57ec6ac75f12d9e772e71afaec6c404cf7e5292d769a8f115784b0b95fe29a9d4614ed989f1ee8a1def1060bd556d3389d93cdf126dc90f93bbd9c30f9e9250a47c7ff43cf506520b57a2037de52c1f27cf08e5baa3e4e756f9958d67e720b5fd780938af02da001b823114b68343bc4efd5cfe89b489e2579efd2416f67f17464f0736e8b9bf1251c135f0dbe1a48e6b10eea3709760e15421d96fcffd59d2023e39e51beacc10a4df330fa76391759c4bac38912963a586da0d697fee42fe8bec242452f9d749489032e327600ce3663320cfb307c1032c0f6e8f4818c45577fa75f9872d39e4efe7f7031e940373c61e803beeb0ef83580fd2ba9ec3cb077c9bb254fedceed17f754abaf03b4e4ad05c71ddbd93c05a883db3329cfb2d5f8ae72dea58807b50737780049d71237a92d07658277fc08e1e950a2711f584803d11c0d3b66d1cd021fd8d271efb33c209202d22efc93a042f0fd9521681c431f5f8d74cbb13ad63fd39f0afdf78efb2e3ef334e5e58e5dcd56be8a033ff9b4c243265cf68fb62e258f73f1888420b0c4321b1fb4a31682e7a0598b9e27fea2657544b71562175fc691b2e18ae8eaf70713275b2f2a1b0e7fb96bfc2fbddcabc872bf1d2aa8fdfc70dc7c61fd70deed5b0e59a4051a051a1dbc6157db2460cc62bf1389677780b5d886bf6960e0f0cd4185f94e5c519106272bd73d8e1705c7b63c5b757d91477d6500517ff0a1fc4ef25308253a903c6d32d9e805833d864b5717fa2faa431145d3aaee6d24babf0806d9cbaf799f6daa1e3cc72a210e7c9aa0175c84621e0d1aa01f2895748fc1d94a503686c7673b4516c391914da54f9b5a563dd7350b32aba0419815e4cfad97b7196ae0d3f6d77ffbf2fbb80cefa8b51583616ceef27eff63ebf561f65c5bdd410779d5cd2ccb118cc1af2a737e490106de48ff9922ac7075d68c6e3351813d2471ae0a1df1fc99eb9ed20b872e9ce7858944de821cdb5ce23ad8b67b161b57f6a57cd4ddbf2d5ea56be7d2a65c653de9920be245e379c3349de72b330eb773d5cc142015b398b660ed840cd055b37f7c07fd0eb47a3088b78767c7157db067fcafaee341730cc1c5de937f6da507abfbf48269ee10016bd0ae032f934a9a34c2da7c82b702876be16cb030f13b4f94da5fefcdfb2c019ee34b405586d13e9fd4e4cfb042c0b706a8ec6e12e3f6e43e678cfaf7274aeb322c0ba0e01cbe34bf562f3dbe6f0b6dfebb9404e25f4680475dbee77e198baf29cdf7f929ab08fe878a49de3001d7b33b6d0260b113ff93dd4d99a5f6d989b059bd21d2a40b27f950d2b932f2bed3464afe05f517a90d209e2e122daf3daff793c35155186334bca64904ca54580ef2b75d0c34be4cf79ce29dec7ec9e7f8669c3f7bd24587390cc761509930f46c6cb77dcfada25e0eaa2279f44fdde23fe6f10add18f29d809accf6f219b5f5e58d290dbc8db42e197b0a3e3728d19cc766f8b1f59d666f2b970b2b3780c6e0a669a1583fc8eecad81b49b71ca7a4771d7a79aa43eac58dcb7a29ef0310a99633c0507ae75ab283de3c110649f3ce0d8c28d956a09ffddedd1f0c84cf32be932e169e2c93722bf13e899a4c70becdae846e3acb948d41b2dbea6ce7c6b69e659d151e66b65ec5ed81b6e1fa46cc7f4191e4fbf74be8148f8b089bbef013f869e983414d871954b31cab22a11e31fce5e4c4b36878be0f0f92cf0365728d89f10da629dc5fc643d3009ba462c011e32e615786276f474d00fa6deb5f7c9f1a02072c1e46ea9e7f230da479d04873b52b5218cfb9bb69ba9c87d3721fdad7782e26ca0f1d07707662501f7a86d32cd3ef1c4749cad19392b3c39aa3eab381d5d4b889116395533c875449f157957de8e45fb15c2ce8c061b0424011fbdbd21584c5aeacb695d31687999259f58f5148c5dab8c948378b261e185a260703b82e59da5887b17d0c10ed7638f205c1473c29e36ba2b5ea435cd61aa796e434dba61355d4dc8c5438ef9262e80e1cd6291cd83c945df85c7ff7d691716d2ea76b64cb883a62e17c7e426677117a1f077648601ae232df9b73b62b0967f0302327fe1d2a02de62155ae408bfb7e065fcb3308f8e75772a2680f10eb3c933001de7d667743358229068ac1ef8decc2f63cf0ab5f29ce10ed3d99c6e3ddf387a025f8bdc9a8f1d9d22057aa834e70ade4bdd535b33cba52fb85900b44ffd76662fb3d6378340b4ea44ec49052c34c23a7ad1c9b881e1069f49516c7e81fdb67595873751ce669d8389592d6f348f70986f203684e9bb4df6d56bd3569762fef4e0785974ce0179ec0a9f021871b2cdca7c0372b14287f5e8f0e668c2b3d0b442e59f9d6e7a0abdc3944bb81d5d3e14c6ad5e711ecdeea671a02cd2251c452675bb4e8a395d63de9603eff5a53f3eb9d719ef11c98cd2b97f2aa1ef6988d6fa2e4c0578503441c5b28403d099a53c11d2c69e9d5833887e15bd81c493baa231e5901037c9d4920d2c59711fbe48dd168b57bf8a6c139db9d7f9b06a33095111ebb526094f342cc403823767997224371ad3f5e3c5892316c86c884a392d44a93923fbdc13227bfffe8ee43354f03567a84e0570cc0fd60a596fce220e6e162e8f0002c16ee3ee848397ad76053deb7eb1ed58410e5954079e5efbbe4c845f7bef1e178d8fa8d2920fbf640c387158151cbfcbf1b39151b771e1c93bbb1b9454b5849aa35019401a10e2932f9d3ecc253bf4a6e6ba15744db873b8db7e0edec02f068a326f20cd8d1177de6cdfdf89ee7d26688f355fda30c098ea428d7016887eb80e3a9d7bf42615757507cdb594dd8deb41d77b66fd1c0ef9a7d2c781670c1d4310cfb00993c86c1483481414323b1fb493e1b82b7348291d51cab7a74d5b06f6da80403161cc0acbc13cdea66a82cd2d418478a6e95c06381d83b70b5798fc97e635583e5697b70df10b3643ee4601caa785c9bd51451bcc965fc1173b13f9ad80fb0b33570d9b5c6d75ddc266bdc179cf1e107570d052ee4bdc273fad51c78ed008dbf2c24e0df8634da5876bbf456445178a97daba5eae2ba4bef181d58c8532a3d6812b4cb4a9a5b713c0901844fc3b1c7bcadaf7fa9af2be9eb13f475dcf97a66be5e2a5f37235f4f8caf1fe2eb2d7cbdfda21fed2ae0293a601d127807fa6e6a555a583a1dfa2a72cc335fb9a801c8577cff5024bc52e19b2cab0ec87bb88aa66b7fde488015a496a30023c5deb500baed19d80a4e6994e58cf60b6d42dc3f2cdad3dad50de7bcca3ae159acc7741080d502534620de028a49e0d616652888601992c80159238711c2674d1c919fb4307a9d61c7268c38eee06c38b07f9ccc68b424149f3db85681baf301d0e83ede35f3c558129945e1e96129ba01e7d40afb855a5b99b7ba6b3bbc27a39f345d62f0634fd3b6267aa0b3725e07c96d75ac2fc7cc99ea0ee37af4bdddc9f9a84e6e2de30914ddeaac18691d894c7948e6a5746604d7860593a037ec9f44b37f5e226e36eee1912f11c69b0718005a76ef7f6b767cfd423315fea638e2c68d5324d58d8aa9493712680f37b09e71d0320a4bfadd2213b164f0c8d7a9a891f333e0240cfc1566a810378143103d170721f2e176a7cdcff31f5719195c52b048461617156d8c3d42fe21ea3b72e0ee8258ef8a91d678a4c2b763e02aba2c98543e310203a534879d23ca6985c9c922042b2c07ca7f79051f5ae0cf7c4f3055ed3f82ab206ce0180484a5295869275c5c0b3ec887d3ba9be5fd378b228a557d8c4b6c4b564ba481ce4169e1c1ad2c7817f42a2c1c8389b706560de0760187c09eccf009f4836adf0a04bbc43908c6efb783de6fe1b8a4748fe7dc02ddbef1756d494705a73c046e95d892553f807be5838c863e8cafce6a777d597ed98c19372d938eabd5d669596e07a75f6a23b48affda7647f43dd7ab52bb4ac63da1b29cdcab467d8715901acfbedeebb7e830f65932cc5a5b157d00f515cb855ab05030fba915d30dc753ccb6eccee681e5418a4ba2d1f416dc780bc771ed5e0ba88544444f947ca656820b10f4a75d085ccb0ea9c9fb50c8dd339963c13620d83cee2ba4e2d00129856ce325f0c3a396f5be0979f7d2a8303c85ab30cac43479fd78ff0c34fb1c7827bcf4d37dea7d63985657897644f26ab66fe37e2cd78fcd09141de21cf43cacf705ef795d6f346c75f068e2fe383d2cdabe11a1d95ad9b6e67828751d5b97de1999d5a2c83c2a04cf452544f3c63b0ea97b4ea6de8062c0813a3305d78bde2039623a637ecf30b442feaca92a3cd3fd0dd81e7b82b797cec946025ffe45045563b2311867e2ec726701ba38adf5fdc41adeeb966916b8f68d6da7dda0a28edbccfc9b34cc9385fce3f30e935d28e03b0a36d490ca8e10c5541e6e30118ee681ee92b4ee2169c37714cbcefc8f46c7d42d930cf5fc0dda27b9ef38ef141219a7d5d1976ea817b3b2158156ff9ee5c65c5ac7f81176f7dba8078b13d78a5e38d4ef5dc2f00d4f9fa7cee595a0fa8192f24d148c10faded299586b046387676b032a5f8c4e3892b74f227f27f486ec14100f7c2cfdcf047cf1db95e4adf09b182a23553c244a67f3ed87f0fe8b435c3a3ab4a08146838461e450bb13826bcf8da3289ee6a9d180fb09026f2301b7dbbcc781ce48249b3780e86a411771ff7c7949f7b900276e3b98c9745f5e8f1903d253f274516680e09981df9faf2567aef502a2a2fe3c3c11c5aa0e3fed28e401bd5fd5fda556adbd80a3d74afb8decb0986d2cafced82b23580d2b88a3e55b981e54a32703885e5c545789fd6ee6350f5f91dcdd6a233c116f4561af8cc29b3d5ebc9301817b70a2421f3c16db861a470dd9592dc56016f5cbbbf1ac2a1c58d3d891bfd3b17d99a65253b47895f0ab431c3cd3a0632a336755368789ff7a6136e13fc542770561fb732ba8c107dbd1e917601ed4bd2765fc92f7132e2f088e2fbed35323edf44d5f3abf1416f11c818845d8dfdb278d95e61527eb7424bd2e1690be86fb76e52d9a1f2d1d860dfaef91717b386e15351df6bf064123b32be240bf76e5d2e76e1e22f129190fe248a25e47e868cceae2107e42b5c40ca831ba17a7af69da3da9e9eddd7f720de3d52782d1d28bfa1cddffaadc9d3549943a0a59dce172636d3145f80712e74fc526ae8f94ea5b60429d486c4c9f00efba5e4f51c190eafc1358970f8c43de20de3a39f4ba2300460743c5a4bbc9f0243a8efc7d838d3567a9efdf846f81328a676560fc778dff2bc2e7c9a5d1375634ad00abaa3787558011d3a6ce1bfeb9d4753ae92a573a3a1d567361cebdb00699cd2827f6ac75368395e19c64da6809be4818565f3c6e54edcc64d257ade920cec84d4fced97c4607c7eaad019aec5706cb169d3be9791ba92c580b867bdfe96b9d5874e13b47ecf1b09bc1d41b68c0502ad3d0a27d012d9bca03e406a2eb039574e46cbf73c23689c707f71321e246ba25580b31541ed6cc815e22416879ee785a6328c773f7daa8bffb54fd995cdc68a1f9775166809b469c2c3e1b0f340c88f0168f9861ca747d256873ad481cb30e6dcc8dbe0d76f14aa7f52edb75bc38857f45d2a64c0a30532d9c319635c32c129eb1e171501476a0337cba7e8daa0ba73e4709becd953f258f17da519b78c0505b6a9d3c6876f96397870d76ccfc3fbfd02de78f2fe86276ee8cad0b15a45d3c934bafe43da27e2eb07ed30c09bf8625994e1879603e0df1bd5aef27eb406adaf307d74904efcb524b7d23120ebfac25ed4eb9ed635ee77f983ec52afc64503ccee55db2d374f4efe238636f03633317ea23dba387db7f2ed4193f8d02fff55df26ea6f5ff0e7e04c9c9c4a3b245399d03dacc5849e7605740145d2644a0cc7244ec2ffc5c2cccecebcb65ee0911d517dcf4b7d63130e6f2b514137bb5021f336b9c4ff1d6c10a1fbe2c11c2fb6ab235e09d15b913e9c1aac62fa767e08c51a0df600a2231e87ad5810b2845db9384ef0fea87e0d102a19e2fb65a0dd3d5fc8b9ebf850c87600f18db0e15a5f3ea8db738d7b5fefca500c3d33698a28bfa2a86c89ce8b7687ad260ac93ec4e07b2ec93296a0bd4a18e12ff29816c6ac4da5cf221cce29990f7185b4fa7d0860709b3b3bf41694d4165351ab593aa69cafd5045b91f4c4365c7c82bbd42f470e94d170a263f5517863f6238a2d7ca0b003535f784d52de69523567de8982abe90f5f2390fe0668016302a7c5fd3c12d78f2256d1cb8c9e9a8e84c0baab3eff794041493a6c84171f5f107e8260ed140ad7ef076df67a9227a8b5555643bd9f891c35b55cdfd43d05fe3a7930be409ee9c95082a12866c7c06adb48ac55e8071db915759fc9bdcb4d8c790c8cd6114d8b3c816a16bf4d53ac8c6937ec29b1e01791db89283ad503f304e44564bfa2040f9465e9c4b99f7acf73af8b33562b602d71f4608e45d968b7c87314ec4b97af2855bf961e4c3ebd29f2c2fe1a99ec11e40aec063c9581b2bbbf0022040e8d03b125d947bf919139cf08d246915cfc53c912966ef746b8c0a21cdecf778bbd0fbc2299a497daad5bf89e6a96bf6d5ce3bb4824b656296f17f54ff6a11bea1410ab71f7fb0d0918c428e47cab6428dc178ea9ba72e2c7ae1dafccd437c84e4cb330f4002e751099ea7504417202fdee054fd6f45bbe193b21f463734ef0ea8c33ec2d7bf4a240da64fe11772a34e9fef34c61cd097be8654f099cfa5f1b23d5a71c1b812c50e6c94d7464d19207b1c48a51a481c8454e49fcf67ad214aa55a5d49c95edf1c578b5a1cfcccf737ba7c67feccc5566a7ea088f53f1301de0abc068f8b7d1dec1455973e584981924eda8984878294a58d1bba72af3150cc5a5c847ce769c539502210acf5a708c15c8efecf61cd77c4909c51956ce63c94da63af11a231921820184fe111ab61e258b4edd48a4f67a2033e6f5705beeb20f78850f022fe6a17e389cb0dabaf1760cfb3763f4538e0df6f0c0f7ab30460fb21406d599a38ba31fcab1b653a0e39cf67f3581e89bf2ad917ff6d0be0bfd8cb56159daf81e4f4e9e3e45a387397fa73b3f47d78de8201b96314adab66e7cc1eada71999fa6811f7624d862972f276e915e1c794ff0bd896a7e2c115542b6321d80edb9641519dcc90720402647113a2b40ec23bf38cf01ae89bfece9f0253ffebf4c92dca380b5d2bfc0ab38d75ff6c9bdeb9d6ee7445b940163b6789bfb8f2bc33ea832de3b1d1b748782bc43dd7e25608a4cd038b83b06e67d53bd9bd5a8749d4c852a2b2647fa241c3634686e976a1110c9eeeac7c901a93670857ae6d0e9689816adac870dce8666ed49b6897b83320498e5733d7debacee66d70fb67d374390ad2d5f1b2d7d6c03362b71987236d471b31228eb6a4351bb3d65fe8d3ded6dba435b7f8bb802f5d3b7c9c536eb8f19650cf51d8f10ebf090e4d5cb98bafd3bc9df39ceebe71c6e7ae4921cdbfa99d3acd00f8e78bc6d7f6a9e353534ccf4e770319a0800a5774d8e0d4f6d5b9e31abfb0699aab6f4ddf6e65c831ed6cbf5e6bd8ce42ec25ef03974b52427d2622425d9caecc2389669ead1c93e2b3e1ba8358ef0ca5ff2ab91a4a3c10f6591f5bef00b479c6e17bbc8ce14e9794cac4d30581b776cfedf0c689c1c7ddf67031f5e1dc69fd5e82717d7b3aa04e741ff2e475ed51d30a2ec6a0f0c4d7a9ae2381d31c8129313c65db6a71691c27ba5785e017312eea6cfe12233c1b34c5a7860ffede326a96301ef732f556c77cd12de82cb65f03897b19915c8d7d0fd325625faa704bf970a18bc7c104f8d2967aa94dcf5d6a7dcfdb447f1d85e716c3d5c925a65fdcc8b95c3d198b8ed4f3ba753857cf3d15e69d99ea7eb6462d5952aec43dd8cf61fb757c241c6a14f6bff0dcfce8119cd6035cd6ed4a3b0556da67e462ddc17909d26d805816edc5853df95410b0c4abf5fddf08732a1fc53e99306b130a802fcdf155a51ade7f6d76cd7e0c097a33e5f678257aefe176a2b6c35b1bc03f4e56b4dcd293cb632afde2507e855a9c40cf7dd8d7c8c382cfacba73d48e276d64a9e730cee1c1fb7bdfe2f066e64c391db1a3d94160e5de6e69503b6d769ec138f7159b4648c019d9037e7ab3242b18e9cc7e76cee5c9641cad5a1ee8896b3dd0c91d07a3847b88e4add7c773acd511ecd7b8235198ff2d2878548cd4eedd0dad00e35e17507320ffd6035e682bfae4f8af64bdf91eb223ca48ffd9d96e514c1b466e4cb7dd340f57324b89fa6302d7c283a316deac3d7e04f8cb40a0356296b367c48d39e3d3bfcdfd11b5a277ca3eed047ed6989b8680f4eb085373ddb45530cf4b8bed06a07f3b6c471a9d9e568d7fd75697f20f3de59d2efa38b2d21c0ffe76380fdf3b4f61821eb60a2206db2279dd8393cf9723e9ae275cbcbd515f12c2046198a7d5c599766b4aa9b995a4877face0eabb14f04e764431f88199fed6eb382f2715c932f4378eef18468a8babb3dfc9c34c986acbc25829b48a2508cbdc36be5c01fd1cf6b75b022fba2729c41fb1c6bea0fb79e5b584cbc2ca471180155675636d8f4f613e2db769afd4562e4e3c72d0913a4b0a50e2978d3bb7ab45a8a908a6b0b8607721529f53fda1a07a89d875fdaf0eb78865e20e975c58dcec7c96677eb3158fcacdd1ee25b40aaa3bf885b0e4bd3bf9a9b2bf4fcd42fa1ca83855bbc101ea4d810bf6030fe316eacc76c83c59df56af468be929f028739d62759056ceca8bcabe23b7033e339cf13b6244b957c3a124b72a7d01d68250d5421d80c392fdf4cc70f0d7ae2da53d45ad96142a5a718fc5c2d878f973d74585cd6d0742f916fdaabfcc468a927f3981a30580ebf0464d92ab26ab0791e551f81a5c49b28bf16513518ba9603d11c7f061ce6ee4d13d5872c037e9810d02b07f1de84f6fe802cf8ec1404161b0fb23b589bb380ae7bae54a8f35f6d691ecba83f80d7fd5fd3b130fc1c70787cd198db7abc0b082129e4340c944e647e4aafa610800ff38036b9b2c38fd0fe8d788702af66af66b4656afb0506e00cd753ddfc8c69d2f50e5c4d8b4de126ab47822e97d319d655a5aaf46cc1ed70a49376ea76f7b23abb18983185bea0fe27e28a7db01b189994c77b4053c16f9c2304341f87431f5fa8b450e682fd4da837ae78cb044b0a83ef91d6b507d437f518be249aa4109f3622e00aec0d442615a14e41379babd2b61edf20dd0737a53387c134ad97c35eca6022a1aa7c920e77e14730e8060663322183d9ba82c78cd34dc4fab318c828d4b562f3821bc08aae62c25e8d517c5c5e4acdd0653730f924dac3ccb80d8bb027cdd144a1e865f067cfbe6da3e0cc48c2c6b6625d5dcda6d638f8a12be4901d4f55a221f7479ef5e6d624d541bb0c25b073e97472971677fcfce7472077c1110aac886368c122e41f76141216a5519f2ffc20e71313b204f1bcdfa7d27175cdd0a73e9a51662e3d5579c213bd8ffe216284c16829adcc46ceba5a821c4d19db396d0152d05bfae693947fd119936990e9df8203913efae71ea4434a90d2eb963351a267564ba6f86c63dabf7c5b7d02332db1eaf2e4ba8f28e1275a4481dc443a6953376dd40f4d5e45fffcb700426a6cfc8747528e2b63d37bc6eaeb6068026e5cec7f68652db447e4040c9dffe2e6a6440435a18c0847b129af1ffaa6bf5cff9dd1b402397d3046d7acfd7d22e0b8f6cfc4bdce05d1be29ecbfacc1c8d59bd3495e48ba8f0824d5ca24b148ce40fbf039d5bf50c7f9c55256e65c2a57ff5f00587d6ede77fa8f81ca02ec4a757e593643ec424fe24ed5e693e4966c7abf224656d7a3dc941bf3e6a653f893159c0c4ddc641592d0e30ee5fbb6b51c11af5d0d7726fb6218d6dbece09a649ef600e7e93b183195c4d66171a7703066eefde7753a429ff1ad02ef4b4e23647b7e2b18222c0197c98eea48b1eabba500a85b7ad709895923425034c5d500f2e332c7e3952dfe919c6864c459f741513a35607b8ed86ccd2b4d60d658d18fcdeb522c37b769c5d2ea08c258bdbf1bc7dd62d891cacec31a847ab07ebdeb1f32dc62737032aad6be68ae25ccc4c8b17cff967e9f24f83e7d0e986825ae8279046b07801da8d809583f71d59399dc30a6d1ae64340e515fe174cabfca313370a5d453aa0b93dc3ba0f7c46e877c43b1f551e419cdca59c6d9bfda9d677696bbefa54eec69a0b93d757c0516ae4728422c3448c59cb44e8f64603dba493de82fd563a49abb58a1baa8fa7ba891b77d2d2d3997595ca8fa665f5874b95af8019af0c90b2c26a932e9ad91d369874613cc7aefc8c539bf8b2e88c17c599099746a188656da0fa69103851f4900f0128f4202b4a246d1a883a015e1de631fe67e6cc66f6e7d544b61df128959152fd857486a5069f8be10700a75dd03f351bb97ea3f0fbc1982b755e5f28c8e83488f957c632c16e813e6144737fccddee938319a059b67ce42556ee9c4c5698a26a4cdd4bf3132cdb34510fe05e89090ed8badceceff86395a505ec7f2a1b2ddf7a86f893364e833b03605c8f6addb9f81a9d785ee53b26f39ce6d1888a9e54b05b1f9abde7d5886a160b1c02d8e7409a37d6e0404365dbd51b560fd3649fb99347e585e59d09f1f2cd8504e51a1cdea1be17d4a4415894abe00e4e0bde84e550a1798725bded4388099cc7667285337936ef58c659f941f810422a87c23453650c43a6ba4723f5dffe0da97139fe81a031668fb949226adb86c865c44f8ee1dd1c602ef22b6eca44c40090bb477a853827ee5023333437dbe0f7e1c63cccf50379f0853248a02905e23eaa0fcbf4cb3ff70761bfd027cca7fd006617251702d6bb20a1f89abbaebdaf1f0d146ed4b228e922fc5bff42797038b64a42847be34bdbf0bb651821029b432d5c691fa4a0c8cf4b9b57cc0ae31a90a76dbc9db683693748f715ebb9828535b20ce6aec62f59322a357e2b0872436868a55a9050feeefe3ed2870c8319b7b3d77d1eff48e003305c1740c66358b53925de4d244f1c63df07fdc2b36beb9a2af649a7e013b8cccd6a22cb8244efe6f42690f99b7f7cf7f460d6bc0367849ecdd57d9a06ef0bc1659287ada4c5b75fb02e7ada0e716238a7763fb4941267591b84688930f19a1c679108258a4455318837b31a79da2ad01f78744b61915fdd91e267f0fbbbcd194651d3032cd2c29af5972ec67ff8a72a22a0cfb8b97c7860dc0cb81226067215d34e8b1eb5bea0b418a3c2348df5462094c17fa3604352307446fa578a4ee0987c795157705fa039763073e1ff011b5130eafc252f0ae68e6eda0a4fb72f0ab93f50a31d7a45e54541dba230613dd5a71e4297185408bf911e5404ff1736a880e0e9a74317b92d035949b7e09479bfd59d6f77b3533df0bccf9e992be034cfd798045ef652749e46caa706bff085747a1ca7ae6604876ff8563e90ff35179b363da2f32b63e0d0d90e96176d74d889d596d7d8c375d3999396c94bee4284e4a9d038ca818896705921599b3e06f69d0873dda1987d76a8bc272732114cf12950807538fd076a6262cafdd1c2410ad1c2f31fa0d7110699eb9a0cf5c84397edd0cf8f2cdbf909307a583300571b0c3af3d47486a0c2b36970b8003e07817fc3c06500a278e4905c6b4c565fee79847ca35d50e87f50aee3cac1815c64248001fb795f0cc35a09299a66571bf9232dcce2dfc424b126a5a18d7f9cd12f0b9e447c79ab3fbd71fe2e508e54a01e20bdab5e015686dd857c53e5d1a53364611da256d9ae95aeca3802dfe50bb263b95f2d4490256976dc93da82979cc866dfd4d9c330eaefb1dffe8b5b6db6133ee414966bedec345dfe9510d615861234d787b8f6b7e66e81dcea3dfb022f5f6321c893ce286d60329f01471426cf8f4d66feaffe09d5bb1a6f1d1bdde81cae0f7ece48893efdd828df5000fdfa4a6a303a50788e08892e83003e249edf1e8040ba37dab6bdb7927250ac8a7e669bd4bd8ee840477540ed2b3aea3a3496ba6d45b54afef492e4ffd3cc85acbfdad61899d64399ac3eda6934a0f3f3df9b29db39e6642b9f82cc69f3e9a3c3c79288efe41179d64900044ffac2dbededd05201c07950ebfe1b637a00e3c04b5be1391f5e31ba777473aeaccdd36658cfb746b409a60136a19f7500b8158a262fd2c100c9e5e88656ce542ffb6a594b1fb41b6921b970d8706d0c2de3dd7b86dfa6f600c7528599475a9b397ae92da16b8fd7be56a4c03b28f687d9849b3189c772a6dbcede461b1763e7e74ffbd988254e55f0ae3c38458700f00dc5050ec18a1b47603cd245eea30c13df89cc08fe19e5b43a0db896eac80b174d6e17196fa5da3d7631eb4847e2aa2fe18e554b6ceb0dfb8ef4bc76d546d866cc8da3b21a48eac6ad298936b788962a964a3c70c3454d7d9ac0325e57658f5c7ef45beadc21f480cad610a932970b3cdac9ddc3a3af734372a8c8f0fc1b75b0617f39e1d367b97fb7b0ca1086efca173090c3fdff65fef2a57fc09c32a4fd197803343b6967cadc3e99de9a2f8a81c0e22a0c492bd7a8bdabb82fa42e41ece271f84fb0d0509b6d647c94311d7c659c3f454ca13903bd65f2e441e909eb3a950099f6d5723678e20adee7d60a7f8765094f02acf378c2be4cbfafa16579206d1c7eb5a916b44f623064ecc7ed9fe2d71079066a1c7009577caf5ae78985cac4d64cc7f92e1c462ee125968a8b3630a67215dd82f62d5fa54f2a54d5427ff97328219cce53b7c5c28a660ede3c68dbb46607bf4ceae885529fe9b2c0396ce1b7ce5213ce81a8373110dc2c06d3d27dd8ec0ea9ede43350b1e9ac2f0bd0094a0bde3bfd2716cbe01cda35135d276979a6feb38a38229ff95ce1c0d400484c5251c3650d1269e7f42d20f612e4da3727e6e7c7be7d12d5a2015bdba011e188b07fc9b88b33c9c20ecef2a8d369b82c74585efc22e0cd00265b5da48744e02436a2275c1be46cf1cd408dff9013b7555a77961d61af1c9f60e4bf1be311d572f9b479219b41fe841be76b5b7cc6c983dc56133d6e615732052c517f680650e23186191e1c689b56d2ef8c728680a2039ae062761137a00e13438ba613459683d5c91f717379aca949da2233b7a80842b599c14ee1cbbfef2dc2f21caa49538850a078b17479961de50826ec6cd3e7433f00cfd416c7f0138b99da87469175c9e763107f76d11eb1a37bf6cc314b1fc41cdee2a23f3663e6f9d5048e2e35f4904ac0deb37173dd191a70091d0015e3e094123484dfa09159cd0910b98e0ea06a53e0401d9946ef2091415b50c321d603023d7039c80c451788e516e388b4063b99564063d185082ca5108227db902ce4260889d30652b02d6010a74943339b9020742d0548a92741c03a3495d24942035bb01470138704296329d41636915248c19345305db15cc26b99016e02b609af4da06ca26313e89a20d60456134e6a2619911e38147029642e4a45102c9c662e0b6011382a4829123eb512200e7c230f134831140db00c3297a622081eb6099705b8100615a41c91875a09180ba791870d58048a065c8a844b53198803db04ff54531290e82154cc2374e761530c23c4e5cf50d96936c1a3fa91102114a6c9857c49ae2e15dea711272916b238ee0e52b5fd2eade960287c82b9c2748c31f683d1dd5ead9402f3fc4b97bf0158ebddc62dee049609d7ab3e21de3c5efbfc4e868ca495453ab988fc5d47c3c542090aca554315087fc5c628ba5f8784a1c26e543808ec981cc341cb02e11cc166c0db090081420b0a3c8b783de317119bff2bad04bf040ed63473a5f80f88296a1e0db2a35b14e52cae3a5490cc45f2b3ba9123b1ebaf18bf4f78ab52e72f2c4ba3dd305998f32335ed761e694104492945c005a953720e683c27e83a9efe1acaa63c627f66d0124a4db0f2485ad89899825a9fc8526f575ec02774b31d4d612a84460f2d32d8c3c760db3599d6f3bf067e4d5f3f88f4b771d87dc87e82af3506731c632262181be924ea4827b313752a750819f371b93d32c6882579c8eb8175656c10fe238f9e83b1f357d65c78c284b297ebdd8c04f392531023c574ef204650118c29a9120ecac39b54a2f1ab35d40af75ce5500dc762e9ce1472e206b47542e128fa6e40b3f0623542a0aefec625ee122309713fbccc697e2660e6af2dce10d84581c5da98f98b38c86fe2f9b7ee0d033f64a991a809d9be60afd75bc762b3680500973e1ab0197937ca1027ca4a2afff8b608ef4d8bf02bffef640bd303b542dc0ea536f77b5b0ed15ef803c669d78d4818f42f457c38b51017016e167720f7fecefb10357ac0699cf43172acc2a648c96adba1009839d339cb0b009217fd600058a4bbbe16c6e45c72dbdd856c873176bb7d4dfce3d99599acb058492739c9975b13e1728cafc53a82c5c2f26757d9d738f4d46719ce0efc2ec447d06ee8fb6d6a1c5eed2da58c085c6fe89b8717465d1de9aec40253663c250a5c314ed6fc3a1d06377789e0ab5799867983398fb874301aeab1cbdc99c25cf36e7e80cb9e30c347feaa8b411c70028cc811389d4ba5428871d6663a62a13fded29e1bdd979ee171a3e1c0b6cb4ff4f618208a91d5bd4e0518895ad20c2e4c54a6ca73f5bcdd596350df57418af9e4d93cce86d24de3b002d1dc855288a639d3ed90c673af4f432775cc5e5884b639f2d30de7c254b32348f43ddccaf1ec19324551926526988d36a88c746e2e1bc6d8094d71925c64fe505e73604b6ee949f49f2997551c243bbf6bffa56e7a2311eb795a7ff59f7439a50eae9a953b3fa05e35afc571a9db34d6fadb7e907d5ef5406384a5e828f8b1cd55fef370ab7dac1f74d69b293304436a797f37a7c18c6e9fa7d2c5ccd4189e06a96f43df7d9e423f4db4eb2df9c1641929e7e8cd3bf600fabd48a175217d255dab0c6103d277810ffe1dab0e7a3629fff62e3166139be2868031234ed5c76e74ee50667ca4bf51ba8b6d0d61219cc2598c555928ee0afe170e2df7d695e30937327165e96dec399e3b82e2305fe57918f5fbc575a65fad9e9f300e7ad7f60177f61db9f7a87c03e88b3cfeef613f6fdb33f0cd6bb506ec31b52938d7fb5d2d7ffc2e18bbc9be2d9d865cbcfe97189ab9e8b61c23039e47d99d2ecc04a0a134b2d3ef1827ca301b85bbf393d1683ad52f8cc36610ecef8b262b76a65578795ae6f362a54fe1c0a2bb59bf62c7ebc785ced98bcb30378064b16cecfe8e56b77b7f0a102f9a3369ae533446c8feaea2855a2158b8083017d14b69d465114f6132ee2ea99eb1a4a077e3dd18548776927f2731dd8abc0e4e975d30f2d51a9100d080aa8bc7d7ae8e7b7e9673cb267fb7cf2fffb44c7e8c267c4ab4a10d0e9843037301bbedf3cdfba996dbcf8ac83ff27397e2f245f9c1d79449347f2a05b13fa9c2edd7ab07fe4a961dbf205b8df91afd72c8174df3d0276dcefdaa9b87bfc2b9f6a7c839e82b760efc123c8ffda99ec3fed2e7c1affc3958029d1c1ae8a90a3a2d83eeeaa0db42e8344ae8a114faa2857ec4d00f6ae8483974510f5d2788ce53448749a2774113bdaaa2c75d59f4eeaf8c4efec4d1b75f7df4618df43891f4924cba41273d104a8f94d22da974492b7d2f965ea8a52b964b7f08a62f8ae985647aa4991e134d0754d355b2e959371d134e9795d365e9749476ba4f3c9d534f9fc9a76bfae98380baa0a0f6dc235971551425197d5d472d2fa49d2ba913a4d47f5aea9998ba4c4d5d93531f9a9efaaea8de9054b76aaa2b51f55755fd25ab4ed2557784d539caea556975445b9d8bab97eaea67f2eaa6be3a23b05e14d6fd12eb87c6fa5a649dabac9f65d6113aeb19a17547697d925a4fb5d663b1f54d6d9d955b37f4d66bc1f5a8b81e925c8734d727d1f55ed5d5bbbed12d49c7171c33444306696533daa77d7aaa8d8169289d041217d2ea49a9a34768009ce0ed47ae87f8e0fee7893a27b640e786d85cc7a1162b5602735cd82dcd6969ed6d2a004250083b9025999563b2b07c6e6013037dc287fa1d2f5591b1cfbb79a9a0c8f7ba99e2d2bf0e951ff8b29e66edd33c3efbc7f426e421be91bde5356ff830bed6313fcad8bd9852c4f411cede019c24f2676f386ee84523b886f31bf9d64b37706b63c089f771e12ec37b5e816a6abf9032c7dfb45eb3a703a8ac892041a025087fa3ea58734afcffb14f200bec5f015beb286a033d0210ed215e29b25a95a7dc35a136d9a74621f65abcd82e18b81d50316e018efdb16692821d586ebbd4760e360c771d25814c64ec1e192402991a9b9f69c36116d82e11b0b7d8c2ae3a85dcd0eafb3496835f4690ec9504617fbb5361d0f1a0a0f8ab9efebe0b07e372fc7bf0c3e8153dd5abd1074ddc7069550a4be107719b4c460cb052a39f0150068a1cfa1b06621d426b0708465c68f41ef3e2171095c76ccee4b1291144a44c34e3226aa2f42e40fbc29b94fde253b61c00bc0184809ee4f66398eee7cc77766d8d78e2f34db27fe418ed3ffd707afb8f17c235df3550440f50e9da58b8d48660efe38e5a85d6ba29eda26f64ee9dfc7faac613c1cf1af91b4ef387b556fa52e48f21f1f603c78b7506ebbafa40fabbe9198a46d391304fb1db1c166726954f0ae21a33b92cb313374c10a44af28f8a46e5c98926e47428079611f6041d95f6eb2d4f8e84e53e2f76b0790b54979b05f859cf162ee956b70257408c8140004597ba8284c41681dd14b2ff7bae432bc0ef71a80e4f279b062ea58faa6b428be5dabb75a2983c96b93db4f33439a41b458dec79109c5b91774b634dc81488724904a12c3a4911077000afbf59ca1620ec07942e1130c084f1354a38bebcc7648aba8bee26405513af79fa78e9e1f656a5fc36255976aef7abeb29c57a70e10ab2a287098bfe561841ddba1d0e29c4d2a78e7beed2e2033500872741875efb198446bfc7431be1dcbb013c247607537048d25d0ce065c9d51b7a31e2db5af4928bb11086399432e583212e3169d0f8231fd00d42fe47e8113a5851955418be316681428b847f3f580b476e1b7b02db3dc5170989f7a36ba087d1a38b6c87449680e611626ecd95f5ba6ed105eca900bb69844bf23513afb6b1f77322e0cdd8a13911c7e177b4f31b8919f700f30931fc6ddd20e46b11ed0161d9c79e7b97cf8f9b187f9c4d926228dfad613f20aa89522d70ef021aa10066ceb444e765c5bdcb66ae2e60ec35e292287c4bb9862e3597c56ddefa0d21bcde40a97e2de1ba868480b151b844c61fe502867b44a6bc2a22b3091fcb16a73e5051a932c47381b21013169763af516c0bbfc267a225d1e39e9de905eb0b9cfd74e4c91d31dc8cd49d6a57c5feedba023332d45339b60762d3ac1c37222cc2a2c19e3d38d056a49d93f662db188796058dad20e54751ee6baf3e4683d0fe026683f5bd80330f5891468e3190281d8afc6c4462a5e84a7a7920937dcc54b959114f096e3e59ab2f9bf0d1b8188bc044c7a3ca353866c04b6b2b89b0b1e2a3b5e459d71702f151ef65c34e57a13522cd5dc6278859b5dfaf9abcade4da88cc8aa643caf43696df7194cb24a4928a6dbdcd0eb49aebbbd021eb341edc57676a2ef26cc353fe515615f0adfae3db1d1779d780eb8c80cdeab1031c1823419e91192d1b86e0898b0c43fb2b456b9b0132573affb00885de52f510d10e750bf968cce4db4d95b87411c5cd0b3ff255618dcda55fc4128e9d0a491116f868b03e0951e0a6585c226fe9a1e4a3a926f4379dea5c4c44937d64d13eacd4c6f5c133a31ea85c878277b1ad3cb9a1c7bf8d1ec7dc1a82382313f770f413c5d42cba2c9eea3b4f203c9443c9e9ba4051026632047dbafbaa3a007fd26f4ebe460aa0610ce316fe9dcaa9da4acac39595f4d3cf02c749427c67041f2a1034a947819a5213c4ceb099797ac1859ea4fb3a1dd4564d144ef65c78a97dcea303311859142e3b70dbda00f11d877ac3c34835375c8a060d0531bcc61ffe2dc655aacdadcdb680199859057976df2293348b4f9594f21030a50b16acfa42a8dfb4e6dd5565fd67415606a89ca9b87560d12c23472f6c46dc10796f3b354cb9b800bbc39a60ba2970a3e0d2fc07d6502e9114df7146cc57436bff201a6fc7ecebf4dea12b5fa7dcdba7118d9021be8d3020ef53e77e50c7553f24033a9d6abc9b6c9ceca2a2eb8545cd2ed781faa1e6dbd3bc169b2198cd9c805c0c125994416ea83f513daf3b1075a0392af06a11c9f49fb7a43f1d37712649c1adbea0cb72f4edf67df2791a8b8668d58d462778ca01517f9f27e13ce14920cf46133e9bfe7d8841e3a2d57573dd1e990a2c93e5e50b5be047092c2ed5e24cf8bb93c0346062c1fd97b6ba48cbbe09c4141cd11217e6ccdf1513d89aa5b5d86f8264696b8af3fbbb5104a65a1ef1c5b5df518137b4fe7133adc0f4a5b114e6f777e31ab08b02b9348e2bda885f226e9801fb2ca641fe9cb52357adb62ee0cf3e05368b81fdef426e3e5c5a8ee23af2db3c84c5096ec9e5190acbff4c246420179cf396b59d1f90b96882a8a1014560b6acea5f8dd60f16f9452c2d54d36cfedf1343d4a26070b7c88f5a06a917def32bc28ceee383d204299dfacb2d2cb29485b726bb3af58b220833b10ebf3c09d79f5b1ad882c15f54781ddd8dda01de6a6e7aff250fc5a55dd304825aeb8f9eb0b51d01b8a77ad7e73a26159dfd224e9103548d395a3c9ba24891b1f6a0bcfb040537b153fabf8b0be5b23fa74a24a780ab36151654ae81c9c2dd7699f88128ac3e4db3334ba272ae8554fecc8210b26ac70fd9d76930635a623c38a215ab353b150a6ba08581f1c8cf273b2b247eb39d27a6f48f587b58fca393475d82ee95262b5f8cf688df34c71404316ef3955e75f56ffe54f4ab7ccd017d0d90379b8740117e9f1e8cff29bc17cbbaaccb3acc1dafe32dabb544cc7d27d9630bca902533b463bff7a150d0f3d60091f8df106a0b90fb87761d16cb8fc08a3b7ce55dcfd4754359fc9eb06a0e06dab3499ce7ab07ec5c85677dc0e61b64b6a4901bd731f49899f23bce6098c69c76fd28438c611e5d69b7b168764fb90660b4ffcba06cac88745ca35fb7ec75e19bd0532b12ebfa9625ac71bfad8fcb444f0af58252fc36b3f17f1ae54e6ff22606fdf9e86828f4a6f5731866bd0381a25d61b825f762b9b8eb9700750cb17f1c078b49414cbc5473f2887c381f89d54ea7f9797f28e6a21d12adbf195d0a57d5302f86f24a0c75593dceab1e1c960cbfb8b6d0089c517218b06b58d42b97b59b22d666ce98d197d3c1c25c964b200708f1d386a7bc5fdba396f99c116bd4d2fefa423fb91fd0c4e40d7337fbd62cb81c72dd85c595b0311df03f03c776042c57da1e495f7ae1d63fc7b3cb45f9dc3a5396a319de042876706cf429ee1769c7d81595716a4703a328879ce83dc166d72f18daadf5155a0aba7c3e151eac7ca8703e789fbbfcfdfe65f4b29302842244e6e37cdb7798cad4c0ebbf40557f9b5b7c5ef71e50d662e30eb7e2c868a15f70090f8c8dd704bb23c1ef3096d84fe17147faee6ef832c24298724d6f646792a67c0ecd878e1beb74ce8460b7ad16e9cff3c970e95e6326c52b4440accfffcf1b5235969f55899f98e9634c04f4b8be4d0f94b9609e6b3cfea46ca7107ee247d0b6ccd169c70edcb696021eb969c03c511dc5c7ce986b26175cf496130861f5d10aa7b2509dba238ad02011e31bd6c13f88b5a2574086ef44ca04c25c2747b4d4eaa03f23765a0f176325ef35821c892272c2878dc29565c50c314f83e300c6f2bee87161ce7634002b1031e78bf2cc5b55695ca1c60b85ff15b4964fd0fddfaadd2facf4e59fce77ef54b057feed3e664debc873d01893174072117a97213e71e87aee96f371755c6a3f89d57f64dcf9f4bdf043e001f4c0ccd729dd031c7f8f67478d8d6ce68e41409ba20acb61484397d2a4ede2889aa05102019b1da9b6ee47a0af747dbc621fdef0714710dd4132cd64f684829c118e96a52fe4d8965b96100d2c7c3c0a51217c7bcb2f26374450d5840fd59917f3454d6aa5346529918ddad640ebe2a3cf51dc9fcd81b7628ecd68a77cd07126c882f100c270d91d6f42880e26e0d015e8ca952910546ba5d710ed7c80b2891a0d56775e924eb668b6332c3a5d10a57b82003d4dc75fc3e8443485e08b9f00f6760a1a2b9c01a40397a5d2224a21c689068bb1fff646334a66473ab8c582866de21ac9a938e2401df5be062d2c8c6324116af3f2099c03723a125ce21c84c0b33db76ba428496b882d8ec95f4386bdd7e8b7396ce1e1682df82b5faa929ecf8dc618f8b752a07b5a0a8d7029dca32644233103e7cc84eb0e8be45325c53e95cabcc82af8040ca4870e054f43ba68204a955f2e6144fced5d002f82ddb8cf2ef007c776c5a465dc66a928ed5f5d771280199c741664871397de48dd5e985bfc1295d3f7348b52f9dc0c8b47829d892b5a0bc6427f6ba99845a12ed3b05ff88863b5dd746c28c507f20b900efd87f78627663df1dd5ef48dbe3b5eb65659c4677ba7aadf86d106c0861c064b1fec05de0ed18ea94d74d9bf0ed5388e0d674e482bdf3f44a93e130fa582317633c687120c63a5099cf1100c270db6cee942043d3bf55a64d7cf06b4676d23011ee28b0129ff35c05914e91b7f6ab9a7fce394fd3c04906b4b8e42d5a7cc5d574f27f252aca20f5ad11119eda281596600706de8a108c1fa2777152ee48e46c63157fb680ec3279681c74f12fe11aa90f7fc512034f9430b9f585870f91d57f838c8f190bcf389f63c36297ead4d8cb48460b729cadec990e1680cf2c2274bbd99aa026de966022af6efa2106170abf27baa98decb9e82dd9f1bf6584246974e59873ab26d19eb0c5827804469f18fe515f9fb36d4645c58ec43010be8d374085206a30d396113df1abce03a15b9d42e27c7cddb03f7d499d9f7a1c63d6c10c3f2ca3641d127fc0dae4d0857695b0388785a61b8ceb6593cd82312e93cda6d8c1ab0fa86b08fd4eee3c55b725b929d6a8426d12d9a3cc843849afdb2c68230d46234ec70ec393458a7793fcc73dce86fc6b3b76970a16f50800fd9401161d51eb800aa7a978b707f5dac6a0194fad4742d27cd35bafcaba4304606ccf4333a2416cabf963d395f5f837f427f5f6b5a34f9278963af54e8ea0e91415856f8fdc50b2739ae6c6b25956bf6002acc712705b263115ad789fc539445eb312b71c38db684cbee0953abbfe8b48d4657699d386f8341a9231f09faabd5d647368f1125772147b3176f1eb46d9aac6e3ed5bbe161b132e7c11a8a15d5e479fcd6f4dff492f90d28062698c1935942fd5df3293d11f9d6f5b5cc02ad8383bbef0f2bebf9b56aef139cfb6fc8ccafebd2ca8731e8be339b7fa4e2f14ba1f86b64f618d72c040a6b4b56fe561abcd62c19952a314570fd4ae117bd9614e7af8f47895403cee2c2c70333e8f40c0c8c38ce8c37e26f3ed75100f01f873cfe5d79608c3fd113e5991affbef8a3f6c3f88353c5fce987a895f943323b8599c159d56603e65f1fe100d5ead5666bc569b17d795a37a6f6257beb73cb40a1745d8f1e3a51bf84d20b6a2a740c45076b64c4c8a829fed4dd031c0161a3966c724760f27db784c7250a7d9f8086a29d4243dfe32a832c9ec68ee1f16c78f47ec968ce1b0738c1e87fc640cd1179dc88c7caf574f2d64520807d5962bbbabb7023fef9128ab0ff772ba75c1fce00454eab80758b83b70461fc603f42acd77dd2a7f4a663b1f9d6389009c26ce006a5a95d0738fde8fd178a94f895c387bb3090de1420e69167da34cfa5228a5fe8ed9a4bcbe4c33e8d06ee8126a0664ab12aa276a5a048f278ea1fb282abc539578c2db24b643b1f1d5842e20d0bc65f9cc12f064f09f0a30d935d2cdcb6c1abab89f7e69d83091b11a86741efa0f7bf0187581b2ad177a88b09c0d331705ad5f87645202a7150d410d88096d2819e64d76e077e9e21fe6dbed8b772de3df697f125e7c77cce4d90b15c8ab2ee966dcb07dc410698006c856888090b16638cc796e9746b3b567e96a032a568581cf079230fd33bd9be68ca5f09ca879ab6167ee630029aabf236aeddda7d08c4312244bcf078e80e3cb979d2a3a2a74c3207a26deb7571b38d99a9bb3f48f295c14d33d3f4880f76a63f447b9a99bb1c7d34cdbcec13e1a7ccba96628b9e9f7b94ca869f3a02d4efc305b12629f910fcac645bd5e3c1c3ae9d6e6fb7fb8dc8fb2e462e114efbf43517bbcb57d64163dd6ce0dfc5e3a59ee243fca2dff0d1cfd90622c80e83ba93dd9f9f07fe03fee4c6eefb212037cd0bc82b9ff81529fca7dbff452f8a7ac3df0da2fc57b03e19ac13a679443e730431b8c3b7e955d5b8da38e3f23eac346b9aea2d7fed3e54fce72c33ac4230bb23d6be835c419ea26f8cbb6f456f42b71873315792bed5839b69166b5d5cc19bd2458c5db6a277a5618cba60d56f466363cff94f8c886ec61b74d5e7b8355d14e562ad14eb06088eab90cfbb5a8fd2c7a783b2e7bfbf043340f302b3c277a721d6ba77c537a3db187169c5ee9a861874f1aabe91a631e0b615ba39cd63dd652b7a235dc6a80bb492f5bd1e6e4ad358ddcdc3a24107ff03b7f946cd3e91a93987d43bb53bfa13e2ad236db8893f5ab65ba0a858607d2eb9c89abb1d902fe47ee21f81ce89aaa7961d370ddcaa460f95b78163fadb9cff9e22d279d603e1579f9e6bd289166cf61fb117d890394cf88954650ab0964c2b29fddbc520c9e83cca72834ed4e0dd1d0f4bd0f0dfc0f78561fb17fbbb69f95afe676380efff8b19bd485473dc3bb8266180d52d51f0e93fa8e449b0ba983b1ecf5e1254210ae89bc090dfc91a258e44fd1584297665d5ee9ce493d34c309e285fc00433a12bd7f4fb05f6d1fcf49b7ff6d1a78b1a0b66a49d80c215ebc976ae642080e3f73b4e65d1feb8f73e96e412999e6964b361bf45fe89cc06e016dc7064dcbbb982d9ee02f3ef6236eb531d8aac0d7e12e6dfe3ee212bf07b3609097da4992a297383588ab9d1c69ca8d33bfd11674c5df5058601985f3351f936b2bc9c115bb13447413aeda5504d1bd4cd81fdd6289048c9efea47c59ce94648a0507e4dffe0f0bc03655897404832720d1d73354e708d08ded4be3a21445197f860c6fa2d8a3b19a144d8eced4c71966db4a91c5e2266b5b5717787e83e34a8a6ef8178339f4d886609588eed4264ca2fde8da4f03f398dfaf6e546beb58f7b18d4b82f5559bd0abea2f96fb52f8e63a4b5a6ca6f43785bfe4e8e9786675d9d6bf017dc671f7995f07d43d0d89b78204afd4dccdf6d255f7c4b6140b7a065cdf30aead3babaa1d551d92a474c8bde770bf3066c297d388b5b50c27f6ae74c5028f60be5a777c4c12894d976ec4fcd0b3a3e8dedbd3fb4c332130618d003fb3cf8d359bb79cb0d6d022cc284beb75fc2c0ab56fc1729e9ada1c0402e435b733100f4e53c2620e832159498e0e84600052d378b11db3d1f21b7aba0a502a1ff86dbd208dae9214c3f6745e0d5a40d03a3b35e60bad77fc19d8390c9b31e4272e247ce3280365aa3c618e53d48be2bbc8d6bb52297563a23f438fce46af499a2dd59b7d0decbc80787a7ff9834f0a2eb28f1203e69337b9c7cdc746aa4fdb6523cff99973343ac987133e3047e32d6a5ed32dc43aa107174e3c5eb1ee8a3926df294e857f55802df79c5616a85e9f11f8c4fe8dfffce203b755a6cea222aea50394ac16e6a549ac751c3389b46d21929af0f114a6659202167ff77f6339d1cfd5331e498270476fdebd7128737f0a5b219b765e11b920a2d8ab7534e86e07859aedbfc37f66de1e83bc82a6a69eaf9f3c17342ae53474bda008d4a36a5e711dbe9d14824d5e2c0387e36c56b82ba50a44d3e043213c65fe9f5fde5e858af0d8a050504938ddc43dbbfc888a3bb8feaef39d6e7c6d4de4e750c84f934670a1d16d22d2938ccc3aca4b57ab884458f47281e587f37391f6d783fb690a4660d1a1a26d249e670ac433d487b776872fdf48f4593f82321f4b58b002bfb044c45f0efaa7b8df12acef548ae7a1d5382cf7a789d663e34318c1c29c9dbea032e7db1cb7f9c4a4e6059d7a6010dd115779e0f2aafdb0fb76790d6ee40ddbb2a286f0ccfd9ee8b37f2bda7fef51dc03ee81ca3d2c00cb32ed9cf733b5fece4c0f9e3930f7ba1fdcfd65460d4fbae9073d7cdeb0a54e13eac51057fc14b5209468eab1b83defaf7407a82c01f3a73e0f342ca89e8dc648b3267e331058a220db19f6a972558de177bd96531394962de9f51e14e0265710fcce45473708954ca41cf45cd14ff9fe1c5234f25767f5de6216bf6159724cf56c667632bf6ff6737167c0a315ca3c9e5765ae1343577c0965e71fecb66cfc8ccd3b7b9304f42a0d52a5a71c3629c7b203c1801b4049ece7f739fbecba520d7e937349dd91cc075eb6cff7fe8c0c42e11a0665e3fa8852d7256217e0dbb8a4d922ca0c5acc3a2694b53f23cc83aa8b727e501e512ecafe56229bc77b75681e5f34aae116e18c86c97a5004649ef1d23bd00a48f443745a1a7096ec7b2ed8387107c08737f79a123b8459d0801299354792871da4c1da6072f5151df6cb8f30857635b083dbf8c440840fb86d9277462f8e87f8d9244400f085cdf399bc08849bb3ec3214e4785047dcb226f29e3c3cab7322facaaacb087f7af2c7076a665e532fe73f3c9fce83bc912d2babecbb6664499cab57df3c501533832d44ca5b7f1e030e108b602685aa33e9a4be35384e560d20092a28c094384ee0d2056fc2eb014f67b91b2b6c80697403cac352b2a17208f2ee896f23a55df0e5afd2b9c1748b440b6cc2da0acf88c71710c22f4b0034b4c6cc97d217d6dbc4e919cb73bfb6e31b786232efbcfaae0bcf0a29e7a04445ba2c84deb923a1b9aa95a491f5652f237aa21228b15942b935e106dd069265e2cbf803c16807797cab915b5aae1ab56e85e39be671ec779164f6111e4da7264f5c7a0229b162fd58be7c3f1e7cef76143c865624fec521eec29e899e57c9f911f7bd5ef5d84945924b524292c119ac49d11f6791944b2ef29684c16d4059f4b661756f26b979f9da6c2a3d1357a03e3be05bd199597a7ae1c81b0d382e49b0bd9870038c61b7e8058f4a4b6ca191d8bea7494904cf0003cace77986bc2a682f77a239a461b280ed01af6462f632d645d7739cce3219c9fb86e62782c27046d98263e2ef5dc53cf5292c75cbb4a6c7e387abdde6f115fdd14c8ddfb8ddb1b4bf32457c2e32db7b49a9220ad6cbb8f00d0c5ad323ad69fb4a37ae76127475e72b349d40b79e77778390043809f8a27386ccbd4fc0b3fe37add26f74d2ce91f027affbfdd4ddd299aaefd2a97662bd67532b1a3a08358795bc6c20e9075d3657f36c7221ece74956b6cd2095cd1f74e11a904ea13516e7674a69ec4484f1ed0881bf970258c63ff05a426ba505710bf07e418a40a7eb7808f9019351a367888d660dda6ffabfc9a212a70a1e5543074ac501ee2d6310f4ed4f4524b251f8196f2f799c170320be42970e8383bcacd4d11e985066311b9d9e4ef7076f4d9a9612fdc90669e245f2853eb740aa520426d4a526b45c8740c77f2b61c36f5ef499a3f708f76a9198d41f28ebf0e65331e42498c5ac03c858465f755f782f89e9d8a98cfb56f01406745a025e2c45380d2920f2a4d001003ffcf0c30f3f57bf35b77e4b69252599241d8661eece21654a29a524ab0169ae75fe41570e830cdf0c6d6c0b5a3f78b49094b5663dea9fce7316122d53acfaa570d903002c24de6bd52529ae9733d7482e1ff12b67c164dc1ac9ba29fe6925dd5b5723f9749cfb3ca763be961a095abc2e6576d692ea3492324dc6f063ba73471ac99f592bd7c58d36462329a89e340d79aa57422331753c9547d3bb43cf48acf02c635173ba8e339234fd72f2d228a36946b2a8c9dacd269684cc48fcf9b51d552aed82cb48928bd9baedb11f56468250e12c88ede89eb96424c97be6947275c9848ca40f9ffe41ed7cb8d831924de9ba9b9ae5fbc648bc8ad1d5bd6c26172349c6d6f4196a539818c916d5ece3cc65a9c34852b529a8c83fa542612475ca24d3bbe9f05a30125490e1eef45cd20323c97bc57d4608d554fd22399aeedb7c7d59ec8bc4d40f325eea22df5e2469535ea6c573d8202f923a73d2296398ec4b293db636083260631709b6add9dff387ced1f4d89a8383a06600c00a367491782f77f1825c960c4ab9487c5fb3eb9484366d1d5c2485315dfa938a669adf5b246fded2d741f44e53678bc4aace1d1a93925525ab455225ff0a95436cd0e9eab1e5fe23c84895db110538b0d868051bb448cc2cfba869544d09fd2c12f45ae73feb6d37219245f2d9979ecc9e4c8b696291d497d73a85c9fa29b1c7d68813986074166cc0224146ab96ac133e22bf2249ad6f97c88d95a734ae489cbda0df34a80aa36d45d29da8a435558b12aaf6d8720213469e7d8e114c034029d86045a27c06b5a382e5bbd02a92934e551ef7b7a3e5b82a926dc683981b253356938ae41299935d58e86d0651911c548e9e73f2d94eba9d22b9621097e161ea846c8a6451b7b01f4b5cca31a5480aad92799f629bdc8a14c997dac2ef8ac7f4b19c103868f06307c9eb78c20eb6940d67b0318aa4d1d9dedf5a4a7ae8a2480e59ff799584c630712892b3ac9a083d4d6ff381225137598c8de85c3fe2239923b0f18904dbcbf9ca7e1d334f9e483edd6d9d2ced8ec6ba1349eaf2b778ce1c3d3de244c28c50bf58391f547d363691245b539437fdb1d7654d248bd25ba244f435aa9a89c45d19939a23d2c4073191201fdcb7644ec998598fad20ef738cccc11e04c80813e6b803c1918390e36c5c2241cd63f2a0bf5e33e82d915c31c68ec8d1f9944caa4462da94a2a69c73fe1e2512b5b2adf653ccb8bb27917c712bf4a9a0344e9248d854b17dcfd3e6e7138904cfabb631c8d2e1460812c92ed283d0e327345ae61149b14a2795722afd724147247b0ea246ebfe78d2d94624e82433fd6245ec76c388e437799da62d675a7911c971d4293dddadf941a988a47a57ffef3421c7d34424889d9326c3bffd374344a278bab8f3953fbec54324c6dcdb9844f6ce88d510495dcaa47ca6d6c6512192f45df2f8a5e962ae9d10c925b45b0ca722e4843688a4de7a6b17cb79637f41247ebb970ad3fdccbb0291f0413535aebb569a181049a73afc6dced5b5f94362d079f353bcefd6733f2425599926374558e87d48fab74ab22f4278aecf87c4dabb14637552cd720f49f1cdd647ee8a0e5dea2131fb9775e58cdff390a0d4d55995d586d7a8c7561070606a60030f4942539f59be684fadf4d852421d23e54a48097b0edc080942881b213808712324c81d3a1011f9f1ee034f3ede1011f1e4a30e1111f71f4190884829f3e4a30ecc2a00d0818d3b24898abd20c75f9476da0e4997321fe474a93023af43626a8705e11fd445b1e890fcfb7a3f23a4e831e51c12849ede784a99d725d74af9810d3924e58d97744e6f189b77df886344096cc421e1ddd53775a591a6079103881c4e382170d020881c40e408429ac3e598c1c88888888b88b80c444446ce2fd88043624ae1c297bc2595ae9e3cb0f186a4fba0fb62c9f353cba9031b6e48da2a9d29e99c2919ba1e5b5e950736da90a449fccd9a3ecb5f5f8fad39e6e0ee01846b10a40e7782a6d54044c48d10637547881b160439ec80811ba7de886344017160830d89c1626f3fa5d9a7de7b6c9555108044c19920871d5c150736d690e09afb4c8e8c476bb9c75656081c340811111111110922222202c40d37a22022f272fcf020e84044040822226e84d8dd1102470e426a20222222d2726810e6684f22223f7cc40e20596fc431720033b0a186c4a4cdc4a7b7f08a9ef7d83a03a205858483b00c44440c1dd84843c2a9d2619555b2a37e7a6c65081c341011a9424352a596ae1b0df16cf6199243d7854cdaf992de990d3324bf6a99309d378ff00ecbe08ad2a5fd2e1b563946aa76840d3224586caed5c5fddfb83db646ccea00828848da031b6348d09436c888fc5adb7924882b61cbc7d76183204e0373c490547194cd7fa9e96cc92b34b011866452156d4177bcf947da2ad800437285d38ebb1a4d79ec7a6cd1e1e3c763081c34084974f8f83103119132a3061b5f48beb9ec52eaee2dc8911712e63cc45755504a3d1e851f41720d6c74813fb56b9ef3959e980b5c7a8f674f2a072f9d1e5b23c63ac1c6161273ead129bf299d1fd6428212fa73ea5995f5ad1e5ba5d00c6c6421c1d3f75c858f6f9ddd37e21891830d2c246619615d9754cafd39a5c0708584f1af1a35a7545dc695703618a1818848a937e21861430b5648127bf2b45c83c745fd0d5548f860bf16df31dce61c03072a2465deeb5c6172747fdd63cbcc81b89c37e218a1c2141276fed6632b9ec7480a496dca3ccae7114bb2148544750f5139a762cc79a190d8e96b2d62c3e6199f9098e51f7e36a7ccabd20989f6e5d9f7d3a588cadd91244ea8b019ac456a92f5d81af1fcc10f6610e246881042e0c84148aae30e11911f0e4444c4bc11c7081b5808922832a9dd4b613536b7101ef82024840739a0a387b0260a4092d6bc4e6de788b610ee1c3f924de7f4783f1bebe1363f82d8714713aaafb9d293db49ecb19577d891c96cfd994e153c111111117482e68f2076f848122247ac926cd8ab5ea4f247103b805047bd5532094f1b3bb4edb1e53fee00e2638e161141222222222170e4206424250e2207ff804344e4ea00d00c3a502254f04edbf69f22221202070d42121111203f1cd1e17488888884c0918310b3f523881d6c18630e54a50d31215faa4765421e3273924d31a9c92cc1183e378e6a4bc1bd1e5b2169ef08a1438e1e40449c1082f68e10ef3a7c14f4ae630775cc4081c871a614d5ec6c59cba269bbe7e8da9773cb94fa3db682dc41870972870eea98411a2076f8e8418fc412b952af416b9bd028213967ce7aaa2b8ba51711114f22229e7e38107c238e91197c828bce926b41c793d2c8055de71bbd4c339292a2c8bb4d3294debfb0c7964b410e20a70f9d14d4f26f560f1db7ac1e5b574e0394f441c54e2b9d2e7b86386183a9989d57b695294948121d763c448352917f2471d49377b48abab14d242465fdfdd4742a7790f11e2b22222252a5f47084448bb30c22836c929b2203cd9111536fc431921821f1bde4ed7664f6bfbbc7968faf638e395844c48e28c021223262cc48a1bd11c7081b6f2842821abff5a049c715777ff8f8f1c3454488104782db58b4a8fda9612a3db6a2f0238801d23f608040fa07e379238e112442d2587766cb98f9d36acc1d2133f041c81a0b8690241f5254101fcbf3fa2222490e1f23aa6fc4313222042de6ee941e935aa72e4fab4b39542715e465f3193b08499937427c74fc626880905c1ad3d5a6dea939251c2133f04188e11b718cd0008ec40af293f810b1da29f7d80af2c307620ffc204963f607afa4c2ee65df7d00c4834421061f52ec8e39eca0430e25dc813cd9e10347db43534e9dd4885e55831ea0fa1a4c47df0a9eeeb17575031e9c3e63eaacb2917f3a2b1bec20298e8cb8cfeabce9c429f93865de484ed9844ad963d7093f7b6c251f29d0419295a7362534e752a14fc9470e9272ecd0fb399b264be9727090a8dd9794ad29bda6c61e5b73d841871c23666f90f4aba14a5a5ccaf5693315d820d17534a9f0bd12a7c927f858ad41529df46c272fc96c42c9071d3e7ed85196021ad45a6e1d53b694346b67e6876cf3202c6d10558f2d3b7cfc4855831924cf79d6dfb63a9d62f5d86a77c2888f20674952ec70fd6e21b407e98eb41c41380810ab7c238e9192017223f12c8c90394e3686999742884182461163aa379a894ef6d8f211a40e3946aad42410846fc431526090243c86dcd1e939c750e9b165fc870f377e70109061e91b718cec0b9293d018294a543695a3ff3e4682c831871d404e0e5c90d81e3fe774a9be77372d48188be2214ba74b39dd1e5b2357aad5ee84b3010b92454d7bee7aff720ef60fb6eb3aa2000465b0024447d9b8fb978250da1e5b3fb8479782820ad4b7e0e3a284a91ab9c7d68f20408c1352906433a6ad4a5cc8565cf48d38468a701276749e4cea64a718ec1e5b2350f081fac7b1fe612e308957a62988ab57af46ac34081d7fba493a95c5f3139f74efd6632b43e0a04188d7e1630e3744448200098123072150f011031191e450f081444456df886304291d3e7c8ccc917e8c8c14201353501bfcea7e833a4f8fad1e40eeb063e4878fd7ca0126e9f01b224e26718d7f8f2d37b597eca24b6dafc8edfada63eb093e7e2861a4cc126389fe9ab72456ceecb195eae0b20d8183062130087123048e10387210d21e8427b00f0e112a61672ce5f9ec8b1a843db646b636df8863c49474aeb3db3ba543279388c8d137e21899020aca31587be96e5a66ce29e10ee43200c221c5ee18b97c238e11268818afd4e99c4797f7a93f1011111131f41320ddcccbbed34bc4de632b040e1a84fcf0f1e347222212848e1709812307212375c8b1f723881d493001ee19cb5b9375ce64c154113a9c30c71c2249aa37cb6f9f4c8f41edb115848e1f391e448e1f42c82074fcf90f1f8d6fc43162831200b9e3c7c8480548f0a30323f8207788a046bcc748903ae4f861c7480391838e0b84200420a0c0072a10e283041ea8400732c0010a6c4003353222820c74000316b8c0052c907cc4e5f811840415300f50a0463e3001732040467e141334cd8e76202b81288c8c78200250603a3400811af131c7c81c1478001d197080fff80b3460030ce8c0025031a00028f87842900c242003083880a66dc000c66ac43cc8e49674fe118941c5c5ead2e1347c4724c5cc95574c2ec5d8372261e3c4e77ccb9c93332279fe3546b32e879e1691f0512db57a321da6a488c44fdb2177323fb89d88c4d9b2f49859f95f848884bd38b245d8a56ce24324059931e5aa6cd1c3c710493aa665d5ff6ed5b7108916465ae6f0d15f2d2112c3ff9a165371742e0791b89a4c447e3ead2b591089d5f96eeaa762281d0722c9e25d94db6bd3e0312012845850b35aa1ce35fe43e268f2ae9b5331a9b11f124b652e131d3f9568dc87a4a0736ac5adb4f18cf9906831c71463a7ca53c67b48d89836d6740aeb2129bc66e6bdfc8fb5701e92f4f2c4f33ab97c85f19070da6b3f89d3bce1bf435269504a7e6c1455be1d12b56d2f85d163e2f43a24880b3bcb59fd3a273a24c7c6b14c22734298e690b8164444a5ebd378cb21b147b435658d32271487e4f3701e4d5a384f110f3824a8f8bbf12a96d071e6f186c46fb95e11ed0b0ff37043526cc975b7c70719f368438289a5e97d5a1d15e6c18624ebf0f93d5cf6850e8f3524c78a98b6bc99d93c3cd49054d9e3d94f4c94e51c1e6948dadcd7ecfbfa97720e0f342486bfa4f2dec693fe1e1e67480caf263e69cce9ee3d3ccc9094428b8aa32a67d37b78942131c8d585d29aa3c23d3cc89070f28395fcf44b6b0f8f3124d6c5070b62797fd2c3430cc9396abea45d217aa38747189284b75d52d5d962aa87071892c2f36e4e650f9df3f0f842d229d37183f6cd3193878717124b8b1e9591ef5ac9c3a30b89399edda6f49daee3e1c185043d29af176df5373c3cb690582963cecfebb9a13b3cb4901433289934a6cd33eff0c84292140f3274e784badce18185a4ff3842db05a557dbb9c6e9621c132573ec582361adfaf4ccc7e7cd4e3592739578cd6939e6bc0e359272b20fd33fdfb8a9338d44cfbb142adf8a7f75a491745ea9193c2fd1486eb70dff95b228f543234108e5b2637a4159fe19c917b34ca7dcb8a9ee8ca41e9da3a56f9f5e6a46e2c63c4be174529b929891ec71bbbb458d50512f23f92c752bfbe50f2b5246f2052ffbcf4e97d29c8ca4529fead64bc6141919499fe29df4ecbcedcd3112bdaa72d6d4f9ee648c91249e3c5db6d1264ec54852fd1f1d6bff72891889298992a561eb2c671889f5ed1dd6d5726a571849429ce8ca109742dd6024bbbcc78dedb7b95a6024674a9bf71654565d7f9164a274ce729d52c9a82f922bf8eae79846df297b9134a23aa55fbf7b50f222393caf28b34c2384b88b64bf1921f21f1b63a88bc4b81f6d1fd35ff3978ba40dff499369b8481073e9e12d74d27c995b2428596f9595a3e5bc8c2d12dd6ddfadad45b297d27e0df527d4a245b228312add7f6bd659245d2cd5cd21d35bb0185924e61db9a992f2a8598f45c2e60b17bd7dfa255824c54b327c46d3be22714ef8cd8bc91549b93e4b646753fd6e4592f820bf67c49d88d0b222b1e2689a4fb79be4bcab48aabbcba09f4e94feac2a125d93fe7f08e5393f9b8a84ed51b9ec2a9d67cfa222312dfc6a666fae3c7b8a24dd98d6d4a5ac60316b8a24f51eb6aa4ed7b7bba548f83eabf8ecf37d754991d4c1cbe2d6a8a8993b8a041df4da3d3b3b635c51248975d319533f4efd5024d6b5c5aad34b3f1f14c922f7794efb4f24ad8f8eb5b18ea3774f24cb888f93157fe4e39d48f618bb2dd5b929c63991f0d59a4ea94da284d22692f227ff51be419a9c3491247b271b5cac722c6522392ba5f3bd9882523626922a3bc4ad4f7b6cd12512d46d0e96628768de582251c4e357d6186b36ab9548ca28c2940c512229b7c7f7b67a677327911cc4948ed018e4a55512895ba1a6824a52948e4622d945c83c994f72370a8904597efad3564e63ca47246f8fe7f55dcfe5a32312375c8a99f5b64a858d488aea6f177dde63e61891983c2715f362e8f76e1189a5d3f3663e57534e11092ac23d43332d275922925c83ea50217a64658a8844d1597fa554c937951e223167b00ee53f5aa6524324ea95f8060ba254aab4100952837ce9d578b12a4a88046dd5f51f93f050fa412467f918f2ea4f41246cc752623a69ca51cf4024e5f2b477a1418fe60988c453dd95b63bb24b29ff90b46eb2ec3b0961724a3f24574a3a8f78ba0f899daf3fbce9f59cc487e40d8bef8df69a53b487241b29f39ea1f2e6b01e12b4866f9cf196d3e421e13ea3462d21b46378483add32baeb9eaf62ee90144763d2ad9f3f7b3b2466ec29799e44cc5e87c4cccaf1d3d6d7111d12d7f34caf257d9fea1c12c5ad7583ca25b34339247828ed8a75d1562d0e492ff2377b29f378c321b1afacb37386c8a7e41b12c475f6f9ff8d79dd90bc6e9e4c983815e3b72159377cd66ff9b6a4b32139b3c997552b71eb1a923a750eea3de7105d5243d2fc8e68496ded3f0d49cab35706dd52a3a321f9f563a576c5ec67480c215dc3b428791b33249589aedbeebbb67419123493342916f4e59a0cc995514328ed2c158f21496fcae8f9fcf8138921d1cacf47e83006200c8923e49ae79ef0d8180c00189247abdafcbfae990603f08524e1de62b6dab3418301f042623e9959fad2ae6f1603d08584132eefe9b74cd88a01e042e2762955a36a00b6901436e8fa58e5203e0d801612cd338b96c79ecd340059484e3bda71467f672603808504d5cab9641a8ba5cc6b2497a70ef10cf35ba53512d5bb7bb43359d2b01a497accf2c99451eb1f3592664b84ae4e8f417dd348fc92515cb3e3463e6924eaa9bbfe0b0f3e5e349253a8fc58d6ce0f1e3492648ed90e164f7bbb6724e7515b4189fbd2797346a27e07f1574acc4786cd48d4e029a5de904fcf9019c917d4676aa588aa182e23514f88d175ed9971a13212ad34095115f489b73019494954fec538ea635d1019896efa426c6e2ce529788ce494d2d5bfea5f92163446d20725fb722aafe5bf18c941a5fef49637a6f4c4482a139e4c6d29db3f0d23e93ab69f90a146db248c640b1717f6ef1bf31d8ca46095ead53d9d126a60240865292d758ed79cfe45f2855132d7f79acab42f927cfb7f63a86b8edd8ba4d8726aeb4e7a6bcd8ba4179554702f192c8b76915839af27e795730ce922b1cfaed42f696887739178739ec42e56b820e32241e4ba3de39ac5cfb9458214d9a16b6d41768e2d92d263b634270b233cb54870fd3b8db571363cb448908fee7973e9a8af9945a295b6e618c47be52b8b24d9234bc6a05c4bbbb148dcd426dbdb834562de87b79c82a5d4ebbd2241e9da292b9943a57aae48ea537e41e63c694179ad48aea0b2ce7bc6946279ac48d434725367ce571bbc5524256196bb52456d134f15c95b39c6f2e02736052f158915dc8376de0f2a927d94684ed1544674778aa45b4d52a3c7f03179678a248f9367f2e458caee4a91d895bfae437a92731d29926cfc93e7a832cba91b458252b3296398ff10d68902b1d61e4ea7cb8522494fa573cd1af752ca81223983faf8536a83cdff89e4d3d40a2a75e386dc138975a57d252d45c85327922fdee9b029887337712251cc2d7ec59261e4de44625a5cc7b4717e62a489c4edca29a3e9fd8ca24c245fabb6e7f7c6a433261294d434952f65ddcd9748780d2694ca060b42b644f2884ae69a4bab448225cb22ea21e4586c944892592a336b3471afb14924995568aebf7567c62491649f4fec930c5ed9b54824880c1e545436d4ad0689e4bb4cd12ee5ff8a6a8f48f28fe2ee2534f49a06004724c8a8baf7dcfe9d4303402392ce2c6c6fd0db173f030023922dd9cfe7984358d219001691a8b9545c680653a233002822d992dcbafc59c17b3300242229a67c5a9e0b9d1d3300202269cec5f64b5d925519000e91946f2284921135733100182229ab4ba9a074ce98c5005088e44d42e7432b4688e472bfef117f26771f44724c3accd928311d774124860f4b1dbbfaf578201235e99d4dfd1195438048ecca206efb63a8c5f587c4aedb9c4ba8c9ec9ff243d25a697c1f315adf537d48ce694384ad464bb9537c48dca8a6733c9151b7537b48d8b8769ff952b7664b0f09db619d944c9d76a39587c433cfb9ccccb462b4f0909c96c29c086949735a7748dc5dfd0d7f712ecab24352bb27cf69ce3a240559e1953f05d92ae9909447076dfbcc415e3887645f5bff18b2ba412787e4b1541b2e0969625d1c12a47cb43866a7af727048f2eb15b91ccfe4aa7a4382109ae4558cab5e55b9212997925b5359a1ef526d485216637fc4547fb8141b12f3877853f9afeb536a0d89e2793c884fdd33965243b2f556c5642a28a5522a0d496a53752cf9cbd13d1a92ed6443588afaccfd1912e6848fd4ac7f41773324c6d2a5dbf274aaed6548caff23357e2cbd8f9321b92e8a9cdab6adccc790545e326f7cd00cbfc59094d1358f860f9a3e280c8927d4c50d31a52bcd6048cad5e8196f474c86bf906041c3346eec85c46cc9422711f2b3a90bc95f16ebf4778d96b990b86ab15e417f2f670b49232e01a978da2d7eb35d5877992eeb8685f54b17293f8db9c65386c82b17764ac1e4d3a84fc245bfe12c77b0a4fad2b740470dee17367a4c225bd839a51c3f66dc749d5a9c41bcdd069bb1d4295a685fb2df427fc6776b16af29abcbfe8ab9a3258b92b4198b9558646e428b7c329b8f61e1099b0b4de2ab33fa0a2c278feddbfce977c51746a8860f1b6a456d622a293959dd5469831589e16b84c7a95a9a1e7b6c191db4b18a24956b1b35cbd9a82b7b6c290eda504582da30de9b2af7e5a33db6fac74814eae0ea411ba94810ddc9d385d9a350078f00e122031111203f468200e1aee3093ed2f1a00d54247dfecda1a7c3923eff1449ebd1e74baeed72544d919cf744a54c2f9a83aab4518a4a549ec66822ca354e0ace34eea6f694cf46338a4f99a8387f1f91151c216e9c51431ba2e0e7fee245fdf49a7a280e1fd483dfbf8fa7e0087103005e6803146fdc0cef9e2a8d6aaf141c216ea402000b6d7ca2b52042639e69c9b63d8169cd7352d353cc4f1e3842dc38d268a313c87b4febb06fba4cc309f45e75750a752a6613bc5a549339bc469352138650badff1f7f383ccc011e246c8c211e24636a38d4cb82f966d4d640a4a374c18ffad29aacb8a45e108710387d1c6255222cb340965e1a5250a69a6a5c64ae860c14a64f27774d48bb9357b0947881be78b36289134e16de282e6f827516acb594bba4cc7a44b02d98f3f16df21d41c89f2755456ba2d0d6a824452b4e8ec7ad984fd88e75453cbc3262d7244daf932590e35820fd7f7b6fecb986318e1a6dee5b7ca27de45203b2d65a6d9bc7f59455899a3cdc762da9d88ed2e79aa98d5de7644546e4283b8fdd5ef108b5895ae9877fa0cf1a69849694dd3d142d439bda2e7b6aa0891dcefde3a9b621425f43db6b0e898810791e38710daedf881888888881082dc4147ee1b718c04696310a57553d5aad73908158423c40dbc5cb421884d57c5dc0a2a73321f882be82bd35462a480d8747d18b1b331fe1fdcd0f7239fbe4e29b91fd0f07df9f6d487445aae9b14fd2cf1e16ddbdca4f2652bf51eb82044da88e6cbce417a70ddd2894e296fbd4479303bec984c8befb9190f98082d426f74a5f90e9aa5d9e5ec663976488a31c5669f8d33af1f6a1b7530f5a5b8a4eeead2c19c3f4ddc7bd3dbb87328e355b0a07ccf475639e4298eb6c953a9cf38f8ddbae649731e29423818ff536babd56f584cfc885635f59c9d1bce9969f184caa631b4366c41863371399f2e5c0747881b87166db001b5ea95de633af9b7b1062c97f2941351ea6f430d26e131f77ab2fd7abf8d34a0928e9792f77688f0db4043ba82ea576dd2c1fb36ce70c926bf0ff24f6f6fc30c0519f6aac47748bbbd8d321c3b5b7231c9c08c16f52cb53186bd2bce97ccb9672bb521863c5ffeaff8eb3b6ab71186626fc61f6d3b51b16e030c7ebbffe6ae9022f40564d4f4bc0cfda056e40537e7a015e6266feec24145970adedfa1236e830b46f96cfae35b5d88b98d2d78224bc82877f9701b5af844f37fa876b6bedc4616aeb5cb60b15d713e6d602169171b3ab7bd7f9e6bd495f2828f6c35d931d648ecc818cc7ec3f469aa815eddec41f3832ea1a18641c83bb38d7b9617338de34bc9184327ed9dab34d470e5a644da8b9e341a656bd6e974b1b0268546ed9655fe349aabcfb03454b00d3f4aff4e67949258772d9531f3c9669cf44c565039948a95ccd046fa8a072de31d15cb2a6ddc4acf29630d3ae69c39a8b62c5932921dc3f8eb8cc77c90510e1be9739d1fb3c74805995eb556a2a73106a73f6edc990e5155313842dc407b85008a71166df741cf9d6ee689618baaba64f276fafa61d8178469998c31adf5c2287cd2b118ee22da3cc130e6dc20e40621b544030c736fda5d87cf49e9fb8b62931efd79e576fef44562fd7a687d93adde4d2f4c9be4fca5a8154f297971504274a5c720ccc3bb28b98f5706ed39e91075f16c18939ff4b930e3e95319d12497e2e268a563eaf36ef1e5ba6ff74eeb31365b2479a59593f7225e9fb7bba3241d77d47141e8782308a01649f9cef329d9bf1df5d3e214936dd3c13ebe5305c75185006681d78736711aa6757359743a7f6d6d4c42673bc5e2b86642f7eaa8f28c61911447c8706d9b93678d5ef1b559d454f239327d5c91545e71f4e9cd295586133bf8071c222276f08f2023fb461c232e805624e7fa90519bafbe549988049943c47fec1b718cb40058916a50b394c552557a75b47c733e162f09f5541e1f84b82122f283073908a9e38e19f80852870d44447c04a9430e111191196ca14200ab484a55c9e2d28f9e922a92c47743a5ac7f32948aa48d19abe7d53b778f8ac42be5f6626a39eda748b6761fdd539e4d364562ae8918b94f325d8a64db8ddd153faf3b2745925f55758cf2182c6914c92762f3756ebe4d8a22d974d01f9e7b634a752892629c859d0fd91b0745c29d5fca14e34f24da9dfaec297e4f24c5df6a7c68b79ce2ef4482ca9c2dc8202d9e8a794e24bb75ec91272bc77c7f1349a37276987435919c41858f9e3963ac9b890419aa9b44865342b89848ac2b953f73bbaba39748706d91b9c3c3f4a79648ae53b18fa17ab3292b91acea39d759279e4e4a24e80c21fd345434514e2229c5e4a794e23dc8a424923f59984baa2946fb22919ce7b2990a5bf1e28344b2ea9a5c5331a964de3f22b142a9cfd6a675427b4724575ff7a6d2a2a2c5be114939e6beb6a93af2f28c484ec96b7c436ccc78f94524c88db13964c5f0a15744729bf6116aa36df52911891f33b2ad429379091189e163065d5716a7a243249eafa7cf4a9b46880d91985e2aef9772f9930b91302abb8638dd15e92144b2e9514f592a7452cf201245fe72a8e6d4321b4124c79ca45812da7b191388a45bddb9fdebb0a50144d2e9946e59640afab37f484aba56aee7c74c47fd90bcda1b4e6c56151ded43d2a8ddb8fef39852c987c4b4964646e6eb32710f49d263d6df92cc31887a480e9ee4e84ae3b13f978784f1d09eca4b5fd01a1e9253f4689762568c95dd21f92ce86c715d29a9cbed9074e7ee29e8acb371791d123e584c1936e9b16c391d123537e55dbeae9be57348eca084a5ee6d71afb81c925df4a9b49b4154ff7148b48aaf24d7429cfce1905449a98a6d3b26e6bf2149e9344fba543a757237249daa4e393ede86247bfb24d382f77fce86242117635c8ea9a44e6b48ce1c6963295f7c99d4909c46e530b5c1b3e8d350d56e86bfdf6848902643dbc5543a275b006748d2f2fc3a1ebafbb500cc90a4c35c8c29a7f4f183045086a48e6623eee93c7f5800644892b61a3755e8cb270b600c49c17c94b25c5d327404208604154657e8dab68f4f1240181274cb46bcaf4b074f12001812e39eead5ed1c2e3c49005f488e19b3bd3d56938a4902f042520edff058ab64a54d02e842d2574a6da254489f3709800bc92546ff6dbbc6d16d12c01692feb72a95d2af79d724002d245faaaaa7903bbec924802c24a9b8d19efffc13c224002c246659cace77e69d2c5d2341c6747e155a953f4bd648aa3bffaeaaa48267a91a492daed6f15ecdb395a8911c9632b7b7665069a569249ce8204dd68933ad246924892e3bd17b119df468246bf889a9e5cc9b7368245cdad3f14fd3a99f9e912057a5d932ce48b44ba2466ccaf295d48ce4700b69caf44893373392824cbfa4e6b1ba44cb4890a949c4ea9c860f2b23793fe9efc718cef564246c589ecb5c21949091acbd9664ca94b225cf3192d2ee670d7a39c81849413eaae9d5db304d1723d93f656f49cb0aa3696224651aed984a9ebf657a18497afa328c87d39cdf1646f28dbc38ee9a83f5dbc14818b9418a59d5dbaf0d8c644d5bb2b7eedefb6c1ebf4890bd9bf6a5f3accde6e18ba40d423b6c5ed05ab379f422292821c753181d33259b072f9247ce76c50ea6d684cd631749e9ca47dcc5a01583cd4317093bd2b2af625697d83c7291243a47d31c4fdcfad73c70911ca49b4cb3a2f3a8ae79dc223968b86739dfea93350f5b2406657163ee334b68cda31649573a46fd43bdc2d53c6891e027f632c84cb3b59ac72c12f63b6e922274d274691eb24852dbcf51dbd1ec29cd23168961663c695b8f612ccd031609977b1f2c4faba94af37845b22853c9ce6e3ba61ff17045a227cb14ee2d9ad61ef16845926eeb28fd321df48478b0224179cf6d86a7f7a48478ac2279532bc5982545de8478a8227153f6dc5e6f5a79231ea948525143e51c4645d2273319cfc3448ba748b0aeb49b72d9e6cf1409a7426db6a74b71e95224a97872aaf7f3ea4f8ae298d55fad08f1184579e9a929462c8aa4dcec1e54ced31ec4a148acd426643ef95fcca048f6cf759f3379e6a0f389a45426a4e8a70a233e9e484eb19450e32bbf29a71309a3f3483b71c1e2348813c915fd4de69eb3a033681349dd9f5c356b9acf59a489c4b41c1f59fa3c7f8b32915432c347ff778a591126123b6be5ab119ebb2aba44828c29da690e4dda3e648924ab50a7bec547450f55223937b52fd97c7bc8102592e564b2ec2be22135348924f93ef7bcb09049054922a9d7abcb43a8e6d24722793e674bd17358891f1209a232af1f6a48d4ec7d2a45ad6948501b3abe93fe05ab140d091b32ebe27ed2a353f40cc9c147c834a3a619122cefe9543267ac96ca90689ab3635815bd73910cc9dee59ef7435ccc6663488abb8bcf31b35ff84b0c89d1aaf37cc5fee0a7528030246b122a4cfcaa555a7dd8311284473c888f3acab8006048becb1cee63acfca3280a3f82182414e00bc91d5c44a7e419cfebd2638b0e1f3fde8650002f24c63e157e1ff5b753d60e399800a40b4931eeb9e6f0b9f306991e5b4180fc90e34798e06e47a9b52014800b49616bf3bc5358b790e0a693e7a9784b4dd92a4401b490d43d2a428b85a51133f2a10059484a214f2ba85331772e2170e420e4f650002c2448b9f86d5a7a169316e246884b418e1fb812980722222355f040806b249bbece327df26516f7d89152417ef80082de72cc01248f00d648906b96546d95fceca46a24688d8cba16f9bd3c7bec48147e042975860402502329c9cde3bf1adf4c552c130498468228b7fcfa17911645d2484cd73a4ad3ee7ca71c8d44591d95d964fc4ec7d048189719a1eb51f32fe71989aa392b69d04dd1c3ea8ca477afcbe4633927359b91f8e3b9f409d19aad3e6624bfe6d35164bb8cc4d0534abc7c3ad1d1524692321964ffb8c9481213b35ae226ea2a8e8cc4d2158f511ba674f618893945b1bad5245615364662a88de316ab772c9ec5483435edb94c8867bd0b3112a4a9243e3662d2843f8ca4f84f736dad3135842e2080306ed79482c5d41c2ba6d62c951ac2c4d6d8bfa7c7960e8100c148902f366a7756c4ed0d8c04b1d81ad3affb8be414c62c4e688fba9abe48ce26d38ad0dd1a35a8174941da68ca574294c8bc48dab899cd8d4d25a347805d2496e5a7a58513db61ec512a88eb0008d3600b082be1b4de8863240704d045925e15f11bf76238dd26162808908bc46eadb97653293552ed4ea83a8c20002e928226d3dad8f92bc6981e3710e016c922b3c9ba8bbb41f70f7123c48d100f7143097200b19b04016c91a4154f6b25139d5fa36f84c0918310119191ca3c10a0164997372d2c5d4c1f2c478be4cddc9d34d56ce6ca66911c1b7ebdddb4e62a4b16897241b4ce9ab4bab7f8a08e1d84b861da4080582466674d61f72bcb790f8bdc544a937556bf22f9df4309956a6772845c91f8153e898a3f93d145ad4810d24348fd8c1a547a5891d8f1921ab9a79f3e6d5691703bbafb534e32ea34aa485ed54d316fa9b5fd9b8ac4e4497d4b8ddb6c4a51c16fbaab68f153245c878fc93d55ee648ae4d5aaead7f8a3de2945e2c81f8f5eb1a26b2a49917cba19ebd62f7f10479114436e75c9ff78e85014491f5f34e84c4a3dc85c28922c548d5e380fab3028124d35c93e919b39589f48bea484fe959ef5bb9827923a54ca0eb2659bdb4e24c854f5b85cddd1b2389198eebf2b6bae7661f9818848bb1344448a009b48eadc49653c13ad2d4a04d04452c599e8e8e9ddea10386820f2c383c8c18328380e44440a19089089648d9195326acaab799937e218f141004c246ae5ec224625d3a9bf44a2c9acb39ffa5b22d9e367d3ab629d52ff4a24a9a65199849d75503f259284daa49bc33d89c411b231479a5ef5204924e9d13e759119374f24123d05fdf1da2d632e219154211e9bb2e49a8eff8844ddac39a59becfcde11491952537feab28da64624e66bab2a939652126244a2eb6c348ba592252d2279435aeccfde25bda38844173965b2ee1f45998864131defab31e811a1232239c6d27173a8f0dbfc2112fcbb6b74ca932192d207994aa6512a4452e87c4225ad1b4f46891049b51e3fe7122e42c7d22092aeb5ca92ac7c55bf20122d3d6651a72e7cfb81489af1a4d641846ef98048d40fca3d95e7ebefff90d43e4a84d20d562af74362866abcf7f78990e94362363fcfde98a359860f09167e5175742a136def215953a679a5142ee5b5f59028bb7695bbfde3493b0f49e2dd824ef6fb31b2c64372d018973c76a55ffd0e49272a173267b870713b2468be244ee3591699ae43d268b5b2568b6b33d321a93cda25af6cef8c4173489ab3fd14c6eb3e34480e89b92bfc69bfcaa364280e891662d3d3c7d07415824352784cca4ac5df90982f1bf49f5a17e97143c269f5ed0fe7a24edb8604b5a26193ba29e11f1b12cb2ab36764bc86e44d231fc2323524464d6174798c5542c56948bc1c34439bfc59a9301a1284cfede7daa823f23324864bd1f2cf49a8309b21499e8eafe563eb279721b12d83d23fa273060f19926fd4c3296d1f71f18c21a9d2c594898fb94de58821c12c7525d1eb3cfb8721d12b07d70a7b1f630a86641dbdd6ee9da2fa345f48de943ea74c99537869bc905467327a0aa164e7a90bc9a29d54638366e9301712ec4bc80729c2f464b69078499ace65550b8917dccc5783defa6c099085041ddb2df67da852d612000b89e182349dbfaab7f935925237469ec6f416b33512845cb37f110f2b723592c3df8fca41ba96d2502341099de7954d7a0cef341253654507f7f027a4d2482ab17332c534ff51d56824eea95ce2e48dd06d2a3492b5f39fd039f762c99f91ec71348b6b8c9e733b23295bcc5f2799298ddd8c244bb5f69fa3d3bacc485ef59251cf643a9a652429d518ab5db473d02823f13cddc4e743c9083319c9b9ae725cd56462bd4446c2e9910d9949299df4c7489cf7fc9744e62ad38d91b495f3a8caa4a163548c04f9ee69446d76292d31123553f48a4d11c2b4c348f824a6e6aa52c591a23012f38a6cbbd1ab9d1e062339faa8de3db996ee048ca44a15e5ae4a2975da5f2456ba246405dfa02eeb8bc41c34a868af99e3e8ae1709abf12b68ccde98aae345d2e97ac960bded2241289b17fddc223c6eba485851223d2fce45a2d76dd2596bf772061749bbef4999509d829db748ca6ff5dd1d63def1cc1649a35b3a5fa9ebb2548b643b1567f933fcecb448eed139ed9aeacfddb34812d3fc721acc2c471649bda355b149e75c1b8b24f91c34b66c89f861919c35f826b11f7bb3fa8a44f5e097cf53de1c5724c714ff2b05f110175b91f4377e6fa57f162ec58a248d51648ed9d966be8aa4324b95621a3dda8454917059ae1d731e7d4a9c8ae4eabc2396d51dc48a8a24b1f09f4d9c4c1fe12912936caf123abb07f74c91a497ebc6c2a67a8e1dfce309a5482e6de39e73d804032045b2b79f0ad69d74daa08f2249a65c2956a6e7d3a1f5d88a4210eb3aee9801761d773ce61b718c906000a2486c0dddaac9a3674dede01f70a0a201842249cd5957089d73a35b3db6f29201802251435f1cf15423c7cb1e5b50486e844021d9c045444444928b88ccc0076c18c027ac5c418ba88fa998ec812a22827ccc11033a80b010dc081111698782fbf8218713ea484444e800c24f28a57e04b183007e1880278cd9fa82ea2c8dff003a91eea09f64ed08fd3971bc87dcbc7449bd895b94c820fe0168e295f311f10f2013d79612428c65e660a21827e6dd5d7309ed2df77d478de90fc0129969066de3a3945f09478e999aef18fbc4a784a562972c91b64993c04ce7534966c8f84192d8e445117631c823b1674bcd39ede88c43c218b4eeb3f547a0f5fb4247bfbebb1d51cfe694abb99c428d388f6de794ab2566446761f59e455c5a5993ded2b5985544d973b4c39390d144a8291e4f6468591311968a4b7766fa317408ffc6bfd45af24a324465ea96aa634bdd856883ee894f13c2b9e4a539c3d688b60791e812952966b882a84c6b7453da3ed60ec449c65dcd95e4261b10dffca9881132bbf47f68b7466c7ae511213f9884c5ae95aeb3501ffa8edd0aa9153e0f800f5eb26cfd1b63ca66f300f6e0c616afeba8a9d6835e4a5bdfa5858f07908752839c6dd19e15c683bdb6e9a27709ff0e5c0afb5a3a4d6c87359bfc3c9e3a9862a5a94a07572ff7c67b4b3907b473cc29a345fd8e1cd2ac9c54d7864fee9d38704143ec65f6f5e1900e5326ee22636fd035ec27b1d2dcb51b4e2968a9b87f4c396df092fe4dfab13a1baefc72f3a0f2e77f0d88939ba5a39ddcb41abc94a33ca8a0dfa6010d5a33d55c12291acc1a3d7d54d19ff219b251417b4c2abb8f6786f2f2c994c5f469660065b84757b85095e37ec50c800ce91cca744a5ac71fc3f961b46bd0ea6963c4d0261d453589ccc270ccbc298caf5776070006b475370719935c11ee00bed09fd779ca7cc9b203f0829bb457ef3cacfad70174a13125ae93b65bb3900e800babe52a7d153d29dde800b690ecaf9c98111ea2d50168a1da18c24f3da7e8591d40167a93fd8fa7db3b087500586854b4883913ca6bb82aa77310a535cc31324e2f3d64b21ae68d1faeff19d4a446e1395e7af76230a7d1bdcffbe9eca7a4348cedfe29654d32df291a983265164de6112134b64a32a93c9bc2990e3ea3787a3fc68e6a4f1a74865eaba92735a79d8bcd48fc9f2ca1c2bf4566f8a74367f6c465d4e6b575f3a132dadf51e1f55dec3d4c461d5db456d6858bfb9081501ebbc62ddde6d01d0335fa5535ec67c773c66045e80bd9b9625425ffe5ad44c633470cced4a898fb14b41b464aaf5838cb7d7a616c26b6ed921ed3a40743d9df115323ad040c3f7ace9536a8aed6bf28ea79f64f0b1b325f94ac2e7e278b59b65e24f3a69baf185f8d17657953897da8f4e7c704a20101e150200c0a848303118656c7091318482038309845519644418bf2011400053330202e2218121a0c0e100e0c0c0e0606040606063c101e142003024130180c0483815ec111747b006197405c1255157b691d9f3cceaf97e64ea5fed0c64e8878ef77576332eb7b9c055b8d900de39cbec9cd5beea5fc00a4c8c43de78ed00f0c3d2233c04603a6c96b761b2020d4e44fa6f6563d2b68b4f2f9b073001096601dfc0d0952d1ccdabb42420399952c51adc054891910d02cda860b352aeb3bd10b2ea9fbd3792d47a24c06c68b854f6a139c054fe4418d1bee62715aa8a5d9e64da1cb43ce437fe14c06f7f8009344959d762258cb8e7fdcb6bfc1611af6194041b6ce80ce440ad146e3b286c8194d1a0d8cc28d428cbe8ce63d4673cce6cec32309a38c76916183358734dc40af082c628508541c11ea41a2eaebeca936aa28a7d62309c2940f8abfd215a9bd4ab2add4be46ca8dd77081da6f840403ee112d74e93475d16980504739535a1282da4b78dcdc5eb9ce3dac12446315bf50971ec24cd7ca756be12d2f320488f38b77e3ef6dab1c0eebdd25b10804247c44e70797c56a3ee86532132f61a1ffac7962ee56bf7b4dc8aaae534ebe0de5668ee2a4f9b5b6d6c36eb61fe7eaf9375139073b4425c12130a7aabb7328e3f9c4d0de362703598173376184de70b0dbde41aabf6ebc27108cebe4a99420846501c10901f81038ee60b9ed0c8da1729531e7e2877bbad5d6de1661bb424804fb8f22d2bcae33928fdfbfd897c38fa0afc0b7dc873c7f5e8186c56aeb008a037b00d4ff3200ed3ec47f55000380aedf0e0038fd8be49c71183554c579ca9756ecf8d0f50f8e5ff54f8aa3d5f7165e517cd02a050a63d54f27315adf61ce05ff0c6b1c887c082f31a00c51e6817b218cfe34c8cd516e76219d681d5bc2ef42955afbf4eb5e213273c5f7e2d3f9970150eaacc8945ff5ffa78530ad40a890dece52e029559b090c9852989f08b0bb4e3a74cb1905c7d600cd9d0948de39706365b5811c061e458ba7e46cfa58dae221f5ed16079c92935991a3b7948088a887936bf9af2e06e0f0695faf8455caccc1329293f3f0fd5d10126a906b7da17e9df4601764402e009f42ba3caac34592b75c484af2844e09d86d8e15d3c746f080bae36c6f99a0888de001bacab1523ab00d3a70f738506727d4a8f4513540e7f0da03387aaa51f13e3ab6634e4f98d333e6f41ee6a906854851b74a5c5c8322ed5588b733c84a4a72fe20b908f6616f8cd74890bdafacc1b08edf26a465f6a6413c585e70aaae44f5ed2d5c81c1a2076416c01263c76a3d1ce442b1bca72202418aedcf2c46693f86e8ed11d370b74c44e92972067d647284a14aadf5824c1bb4eb8c9438c967009dea4160b7105ea8180472224bd910ba52330fe0c7592f3be4812e00be902c85b405ae6f66144100f888545ca57e2ff97327721f9db4f34335429797b5424b1218ba992b1ea3a82c59bc910b6e687a00811005bac1e6bda0a33e4f3844a172063b5462474a55b791014628b7c6f142bf3b6b8536b4f626a04232b8f86366249e8cfcd84f25994e9ed8ae8903daa4c110cc539ebd6066ae5661953e50b825fee79a7def14a52d597fd7b31786b1acab4043e8cdcdcc6169f4ed33c7358c3960f8004de2761d868514cab7e0484c24b47dfcbbb87c6088654cafa9623e0c2310c38382a6cf5fba3ce68495364ccb89f5bda1448bb3833b9f63422f6ba24d6fd4599e270c499be8274c738ca8cee37c30ca6e727da31a33e2f5fa752b4222bc7343f8217f329b1f6fdee2db6d2f048be1638927f383297bee4af11dc3a182fa216fb48ce68df5b9ef1503870e3387ba701a418f9fefcdb190acd12733996f8e1532ae893c8f7cdbb62ec58c2b73852dbbfe1bba73ce3d73af921edd3e330a298bb86184759cd09fd014acf4766c19cc8da8095faad47cd74aa3c70d961949aba89de6789ccad7d0681e8676cf71c12c63b73027d6274644557ecf9639e909c93f70d51c4e9c8388c0cbcb0325d4118cca26adaa39de8f9b08be17bc0e30548ca227a6ce298d38423ec78db933017f1e981f1a10ab7cd90696723eac6e448dcc830297b17521d031ec7a1cc15face5bff30c2b752eb95d4fa542c0c53b3084b41e956c103fb1b2786a08ece28da07963bc559df72a8cf55cd1d1211a01471face8e8b518201535c20caa0ca148f84e81c5f7720f76e7a415189eef8cf0c0cb2f352f459913b5e9d3f8c728be04effb14e9267c981387a1c24824fa402e66888bfd91dde863f9785c89f7819448e6d4438844fcd0092702d3b612b8281bc6d9450723117de7ebf366f6633ac1043f539e2f68aeb6bac13ddfb5ea6e6c9d96d5248de4d6c245413c55332f75c19e122d1d475a4a963f172b00841b1973720acf607e20ba29cc8355e5b4398cc97459396830ac1e9dc17e8df5f276e14015fac296c9d1ea8e731bccd1ec46dce2a1e93e7f1041d82148f827ed04f44101a38d9d0e091d348085ce58b03f46e8f5e89597f53d63c442d6b28f502df90c97e962ddf46f31d3db08cacbe93c14b60a8ce56dd47a19266799f1185026afad646f08da9b62ddd0c386b29139bcb548dd14ec1b6783ce1b3a4709ecb8c64dd6be5243607a3bd621cb918803cb6f5138c98d8fe5cf06a2bb6d80dd0cd89aa31f1a0e0eaaac42592edc9a6b4f0f0fd2dbd28a1f402f15c1a107f403dddce9c3be7d25e7222ea08c783037a37bdac22201962bb773364af95ec1fe405d159ac6f53896d39e514c7243360a9ece03b09fed20a2a1edc4cac4765436fec7a6f23675d1b80c65835566911b53c6a9856468fa6554bc2d1b25294516fd9d4d136429c3d61b8a3813e86402b1db0bc8dc9aa7507821c9da10c89412291b2393f20a0819091d1950ef1a9e1630332d2132b334cac6559372a32cb044adea3d86ac0fdad6c4c8eaa2c36234c5528e9d59221d6a9613da2c6335d28865bb07b9a569d9565053bb0f6761f360d9e9c712c2cde210f888b31603cab5726b01550168ab4e174b2e150b3a3c0c42e5020bdb07cb3ee8660931da72a26d31906f29f9b56cf0b4c4f05a20d1b7bc045bd88b1205ad153fad2bee9608ac9682566f952593b3d395c1bb45b0d90282c62edf055fbac694cbbb66be0f7a6bc26217c30eea0554a062609143a9f0415d71a34460a1c0a00eea92fc59f00f040fe54588533d9228a505484c92900242394f65cb879707c5dcc1292a3b456da13ceb40a90c62f98d506c592b0939a0655ac17160986861c9125de524f2ebc93681011ad3d54fc4987a74150181c7546a2f55ba117eae00b697baf6e13d8b13d4e162fa22046d8054a0c0b5eecd52bc2f36054467d281d23be734e08e7e8af2d3b43d6d69b6bb21797e7f8c32f114a7cb2e3f398f09f1ea13589739212eec63d41a3e15abbb534e527da2a14c1114479fc3283c4abcd021b326347840258884fe307d1f7618bf4c0c15ea95e5c77b3bc3c22b8f9db8ccb9a38f1d3eee100324104584f4920e3e77feb843279d3decd4b1234f1ef6ecd1230f1f75d8605288134d42c907ce3a1ccd4cdafa96dbe1870fb33b30e23033f4c27d8491a48228d2851863f890830f39608091860c4f0a49849243b6a8c347da9b83df774929bf7cdf1923456065e7d9274e32116412209d9451831f6cec98430d36728c81460f31c4e8418e3fe49001861a30f805d7db6cc7876c520b462598035abe26fb861e996f9f7be2da7906114698707211219e1472a49253f8e471474e3ae1d079e78f3b70e2f90327194384544290498408f24805f1384e96812ad125dc79fcc841470e3e403a5144482709a172c7196ae0c8e30c1e798821470c7e9c61c30f3674c081a4a111d28927933c9ce4fdece2b7543b74e4c5434f1e3df2f4890e9b450f494227ce1d76fab823271e7e3e6dd8ab39036ac30844d5ca4a3adc3291c5226c2adbc6a8ecc243ed38120bf6027a1cdf6910692a88204d48f289244200d1020e010c22de99109fef1c3beef271070e3c7da4a13405943b994372e5a103b71c3bfad4c9879d3bcb3842a49245b05cfdccba186a7b268a20d11491e9780452b5bb164b76dc36742999450c55b2234f9a142199e98f1894d25cc445ad543253114d7f608a5529a93013461d66caa81cc76acc02e4112481ea31a74f74f8ec79470e3a610601a489249e4442c82876f4a163071e3cf5e8d1134f3ee8fcd9e30e9c74e6d069e7fc6c471321ff8a480204d0448478f22584d40f2897830ae184d0229e38f9d23be02056d8c92bcf9e3be7ecf98e1ef8df8e100c3d184a08134c013989103fcab8d1c71b38e250c38d1c714189ee8a3a70e836a388234d78b288104f083182f4452662408918171c3ff2d6d92692239c34a2449254f2e1b3ce1c7de0f499878ee61c3d933b54ac6288359121281b3386524a8799439f9c2194d02296ca589226136b16e99352881441225c611c3284d4544e34c27da218b57394bf65a6dc25220e895e0803a3f6a52b2207892e0a86a400fc009bb01f4039f1f6c18c8dbeff43ca887afac92f0362102218e227221e96446e76e71448973601778e85ea35ceb33d8b0d828b6b26cd4fb2c74fa97b4ad2a795c400b5a90fb350a1a85621905acba9e395a37da6418ffe790edd570fd5af47e8bd67f0fb3f453a8ac439dc0c1a68f957e6cef04994c3cca3cc51ee55e658e6357330a3a7dccf3eb0d9a9f86af2b2e29cf2be20886941b941e5a3f63c6bb3c4f916c326b9b045767e3b86f6677b6fc824d4a5b340ed85f66cc46e33188e7735688a8400cfcab4a769b3169c9558067fae82183c9346fe23bab90f545df08deec4468202d05eb092007d0b6336e09e05ee02f4b78096002b16e81f20560c6e04706f411f01e82c583f802e06b10b70cb027702f45a404380750df40f101b83fb03b8c0a01f03385d76c8417695c4a926c4a2de492dc7af6e13050dee881ece60c3b49fc8a5730076257baf806c348f3133309ebe228fc163902de5fd67aeac1a0487ae4ee5117d1e40dbe2f181ca0c1e2a4c46ae2c7835769d7ce10c2e218ff3e32ed12a5ff99c221f21d9f1c049cb36e283805228c12e25c0c79f84c0b55cc5f97bdcd615f9a7464580f99ae13f3ab76503bc2b3789b27de60924189850cb920e867fac4410fad355f9babca85c3373573b5fe3af0856567cd76fc0e9247c2256c0e9361d0b7a1b8485a5aff5ab436f64e6d0d571a46ea3e70f271aeab741ec37e8e583437f021b7a1f9744034f4a9044c7dc2fb70580fb60a40eb6da5172a838fc8a6835d360d62b14b357929be49956800c86e06c684c8f20106f01db26d37561ac78feeeca2e3c2e91591bda1f4d85ca31ef20c09065589b7553838b5537d2a56881a799fdb4b37a6e479586f923da72374cd30546a63c2951f8b91cceb307f98e1989a541831572a00c97203868af8abebbb3ea734769ed948382673203b552cb101b1b6723ed70722f88523ad159a4085f09b5eb263c136b6ffa3e1094f9a052189cb1bfc48e20c43cd1291b8249c766038db7f43049e851fa65ec01e5206fa68ab2f87295562276ff86cd162750d312ab772fa37df7856c65c9e347c21b845d71ac0ab933c48dfc81e8adb1a664af00f0f21847ca29e7c1f35f28d8c1ee5dcf864881a1e200d8827678f1d52a814cce8babd066604dc5441dba7a6ecab1c4ad4165cdfc42cabde58f466ef94d2dbb7698994321ce562a51cb8021ccae00a7fa6edb766a94c3abc6b5b1c0ed701ece7c892286882975aeb3b31a00cc7ca92c9e3cf5383de230981a9175f9989d2ad0b1e3a4b185e546ba21c71cfb8c2fba85e97eca68c37dd22d6c78435b2d8378ae65536b3d8a9212bf40946f62a46112878d5ddec060beb086fefd6456f4ce11e30c1a1272e49fa1a0b39e35efda11d8948974f276efa6722573e947f2226640e5ebad53becd6e09cf1aeed7025adc00ca0f07b3844b12a3e228179480f8ff628646678163ff2f6ac61d4809d7a2e4e4be90d05906b9a764287c5832aa8580697b7c3f4c913c67d6be31e46df817d303a9b4aa27adbbc1841f7099c6ad1987a90e18a83d1c33c4fc5a5b3ddc150fc5e0b03afaf9a378397147424b39ef79238b281bc0b48831689a6b767848db9b91cda6e66b4528b57d18ffb6d21494d51216e320359ac2b619d9f6370c4d3f3829f00851c5ebc6524b1468169ae61f188d4e7af6cea6a5e1f70dbd61d69642c33f5b535aec8bbcaf58e83c94d5fb291b8beecb1f31ac57ed80f5b1fed81097626554e46a4623871de5ea604ee1620df34e7a9c5f91733dc47eb0b6846ed5d410170aa3e6cda90cc33e6c699d836bb25275b88b3f118554693a092ac8d4284c471e3c63da04b29dc2378a917e821ae91fc5cc18d1f84df02dac567311ba0abbec384154dd5781a8779193bb83c05b988305ea0c2269e87181002328d52a80fb63c172d0742f34d82a2f60d06105e744a287b9230bb3182e287c9f057d1699ef4bc60c8de2407137431465f949a71cf5f6973cd1cc1ee41e22cbf5f233c86bf52231131bea7ab84454642808dec1a6c237b2470a672bf56b5f5400d7cab45d40049caea77f967d2a897b126f37502d44d504f0fdcbf1b488f08c6d08649e523c3e30c23c8bf031da84dfc9b767cabfb44d82ce1b3bcb6e13739125db7eaf1722ef21ce2a117cdf2c1984c8cce86eeed334d21de0cfbf5e28d776b7363b61ec2e4fda205739380cc0d0adc4b9a11a780a20c29e6049a7b661b911f73ddc01fa006eb7bcc770210004dc01250cc0058c382d689cf672dac0ba44fcf31a84bc391ed183fa0f5bfc9fb533aedfce7175cfcebb9b8835a476dd414ef3bc37425123a08755a13563314d43fa095176b388f5a865fed719565f35732b0daa0008251f44cbd29b6a7a889c3c9fc149754333f662ab8c089e4c6b1af9b7b03ccf1d5b7bfc05e0f309821e52033326275839c70a4d53019fb7e37a48bba33cffac4db92545af48719b21976184a61aedcf660e2e7dbfd830899dff88fda56a75be9083f1c95888a400442e737438e1d95abf9e1e0db1202d0758d8c0c426868cc2d355d2348cb2341c2783e28a861cea8e496091b138e8e22449c7084a2b02999bffeba1e1933192590b7d46e3b140d9c021579ceb9fb50409c01561c328f9cfb1d264ba45ad2644e94ac658ffc2e213c68caf3ca082b94eebb673de8490df373714bfc77abf775b832efea6f4555d40bcb53d7e18cd2a9f0309bb506345f3205e83ca434dc5ecacb721e1a198d503d8a1501ecfafaf40c42d12b145b7feed4b6b1563a02df37b06a327961baa09c86e04476ee81126f4e254e116c40dd099a1655f297943b828743c548f8f6a0263306b95043fd8654de16d0a324f8506dc99c67786498bf22f2b5d312d1cf8d31a228b96b6da06771b271bec70a399ab1f7ebc74988ee4c7634003e7368b0f4080a83f2301fc363a0da776be6cbbfe8360e8c9863e7bbbcf0351034b0a2f78948027da7bae1c1ae9997441eeb76a1651d6b0e061f6073547d6a556568bbd4e31a0cb5af91b11532808939bd24d1a0a060ab02c1bdcd93c6d4a6f48ff2df0c5b6cea1d94f9e66e2208057bd35739f8a2676407080e73a27fff5360a69b3cab63ea1f205fc11bc27ba101c320eae3f753d4ea6f4a8dd67506034b2014f8d228f1882f518c227e1b903cc0e817dc0067ff8e75767faa451a55ea4c1c4a492d3b24bbf4ad2e8534fca294796a2d7af633f87c7c903e10ce8fd09c38f6fc0fe422a6b0f0bacb563d09ac06a5afe565bd6d99192bc275c81e9adb27fc80b0867b0f4cfa5e369d43385f2602e6f0d272bd40d134f88b51a81e34fa83297b47b64ae07ea1e728a336c0dbe16db957b1015c34d142ece82e802f4a067b1e354ecc067900f69540c3f6b8548ce9dc1e7babcb431fac308207d1dd68206e0816a66d85da1dab0178746c499128186bd437c6300257c2f97ce465cc6b92662000f474c5b1cc0716ad146e0dd0d9df2c8cf379f6107b5a2b42c61e69ab7533d146002ae5b84200b3760b46439330f0f0f0f0f0f0f0f6f7023a436f20977902949c9499cbd74bed529a524934ce968f82bc4c4a733139f72d40821ad85b72e01040b4e0b4e0bc4ca1f4eac09b1910f6cf18ab2630b577c4a9f862a9da54ff7a18626d8a215a697f13cf995f1242a64850ab658853949911e5496b6f4b055614a93250891fdddce8ed7a1a37d8b54a4a7efc4cb3bcf44d2c3e332c70e3164b0052a8ca77a5a23d95f4f9cc4b638852107917457c79990e79e21600b53184ba89b9c52f2459c7565d8a214e6d2176af62d2e77ba0b29cc49e9b9fc90212986a88cc2923d7592e4e944611cb5f89ed687c21062f6a7b84b3f6f0928ee93aaa33e76eef813c6bb52225ab891bf70f28439efd68fa9e58dd99d30a64b181dd4762fab19842d3861aefd5123962ccbc54b842d3661cabf63b2836769965e1306abe42182f8e8157bc2832d3261f22ad576917816b28e0953d8d11afd9fbda16242d8e212c68bebda5da274f89a48610b4b186365fc2524951f92aa84518476b7b758ea4c4b943058e44f9f745c2b977c7fb0c524c85146c89230efaf48f949a3ea9f8b84e9462d6495ec90305c96a0ea3c9c89389647182ff7ec3f3dbee9f03bc22caa42ff484939e49c6c84396b24dd0faa524e68196178d5eafcb1c93968751126d5922edc8274393d2bc2a0aac3ba8edd9b4f48220c124b7dd5b74a7db011615c2bb979c9d443183e9d9acf3e2ab922c410867892228847c9f75d16c224d5c454b62caf5c4f08f378054ff26f9da3838330c8cb4c2ba1a39b098b204c3f424c95a72c1006f520ab527e9ef8714018d20913e62ba9ef2ffb8349adcb64efacfd60ce7d21849c646d4da4fb600e41d7a84a1e92e52d3e98936a24398dcf3aa6b30773092fab9ca45d4ebf1e4c5b76f6233b3943b63c983554f5577e95f5ddf060565df90f3223d9cb7507539c4409a621b2932d3b9825c74eafb7154688eb60c8ad3217be74c86a4607b3e9de1f89d63129967330a50fc144c4b1c827958329e4da3bbda78e395a1cccc9924aca3aa7f4415de060ca6a4f0fc1c48524ba3798fe53a59c71299738dd0de6cb6339b7941837491b8ca1a254709f0dc6b6bf1c6e96d3d724d760be94839748597b2d55d460122152a4e861628c9806733cf3f4e1459c961fd1603e97b75c4ba2eaae3c8341e444e8281919a2d26630c792103ff72795bf636530f58b1afdc81e6729840c26dbecec9f7d95da526330db6505f5fda218cca772594a124955350b83398c509fc5c662874f81c15c215b7ee3b52f184b5dec89921623b1f782c193107eaa253e978874c11c37c77b72a95eba840bc66b519ff6d5951dc32d1845d764a899fe4f7e69c1143152bedce92b2729ca82a9e4d57e99c656fc170be6a82e273e444e62235ec1a0fdb268e9e4ab23552b98b36629af95f95c79540543f4dc59823eaf9f990a86743a9c0e2eb92ae96e0a0629f37b9277234714a560d0ccaf8b7d45c1e8293d4c099bfd8a3f140ca7f37252a74757faf409a6eb11dd34fbe433a7138c1769afeb2c77cca409e60b1bf976215b49b798609e28de9ff5b944ce57842d966052c1723efc2e25fa4409a6af504ab88bb651bb25c1d8796bfa1db33dc34282c93ac752f749e1b2d6239862cd5cc2f887f3a032826927a9d018d5f07153114c2774caa5cfd25dcb8808c649b2e2a4fb17952a3204e39a65ffabfbef3d4f08c6cec962a88ff058ff05c11842d549faccca172148d802082611846da8386e4235ff81e9d2ae247b8565cfa60f4cf157674a49979064d703937f09499f4d5a6f9a3c30ffada895ddf2b598edc09cf3c452d941586411b6610b1d98ca7facae725ac8a97ac2163930c892efad175eab3c4a8899610b1c9855ec4bdba72c5975b38d2d6e60dabb703dc2a4e33ab0850d0cbaf258d2dfceffeb3fd4d28a6505b6a881399810fae1b56342bf2d6860b60a89a39264939eb20f351b7735be7040e91c63f40e2d6661bc0df1a76584c950965562b2307a321d0b499b92ff602c8c2743a20857b115a1425818bec4898cce675df65e0b727cf10adce44c72d891102e8316aeb8ab43d63ed54109150235be98400d319a021e1e62340a6c787880418b56a8ba263e4c92d1595c569864ad74d372d412a3c0860d3e057cd139c668b20a2f78522a841c247e5451bbe57a7b8ecbbf98400db6614405675ed0221526ad9cf6e32c5cc38b1a5ed4f0a28602cea0052a0adea9c3d98dbbad5552d0e214aa59100993536452ca6619923d2711917917560f0f0f0f0f2d4c618821e67a226d4c6eb79c16a530e551110bbd26ffdbfc502bdb8103470e0268410a63f9fb67b5349777e55118ae52eaaabc37727ac51768210a53a59f09babeecf58242614e9fff72b3d762d28463a00528cc41598f58973e6108e2935290e75a42e69e3088d216a1f425a1d4cd9d30f65d105a455ff0aa97130671c2d5524d3efbcd06f3408b4d984f05ade94125214cd89a307e97927732e4e79c4abc81169930a9eb91a663e460c21076bd4cb58faa31e1258c2ab29ece82f66d9b2c61ace8913bd8e5b152970f35316ce0d861e343c718626007b4a8844947190b25fb420b4a98ca6a3df553ba7e7f3ed458f07e038c47375a05deec458e1d37cc0950efd0408e10683109939776883eeae966721f6a78655a810fd8305a48c2243aaae8f965cf971b1d861835be70c0711b0f468e1dfd00c7e145d1408b48645df5a9840812c8bec5b894e2c4bd71af4c0c1d5a810fd8385a3cc26c23e2ab82c58c91bd87c78f1146abc011e6d9cb9154a5e0591ff2f068847946924acb72eb9683a705238ca35a94aa2591c3f7a343c70e306e8c9115f8808d0f68b10883c749bf8e6cb163a7b5508429469c15c99d4ca6cc5f82b2dd03689108d3c9f39c12e66fd3f2392e60f639c4200fd00211e6c931ceeed29bbc24f2a1b682bf410e610a795d4cec98f454bf210c6349e85021644777bc1006eb2ecfadf7f1d3778430e9097184b8f4557ab5542d06616978522f17794118238aeaa0d939f5c2281046d10ea6ddd7d72e5e4018efcf2b780ee7ebb12c80167f307f251ba14a9af851263f18fc3f57ee7a50134294e9a1451f0ce14ee35e74c4ceb3f960c86da2c494d05954887da8e940c1ef2843db71e351f061bceec170f22e3e69319535ba1e4c71245d568a4f6d2ae7c12052b44636f9392d153cf417442709955436caca1d0c3a4ade791eb5ddd1fb50db01c60d30d0ac142dece08ed2b61cdee2f5a8801f2305cf00f41cb0fb3152f06e03bd0ad8ea60307dde154f4ad6b69d0e264b1a172e48ef0f3fcfc114b49383b1d5c68452e2cae6e23818d7673b6cf36c2349e0604ab9ef3f41cf8588d6f8c2011e2815f8800d1b5abcc1b45e1fb74f56caa5143798dbe485515bdac45e6f83a9e42f5f8867d272686c3077fe8bbc48f8fd245a83b92af58c8e7dff217dd460dc50167252a5116cd46930ddfb558ecedaf19da3c11c5aa4a6bdeaded57c0673e9bc9c4a4d9f1cb46630c68ad987904b6530b8faddcba414f9e34a068358bd5fac9ce2a244c760382939a6d7a988c1d86d4256f2d5f80b87c194928c94e72724214e60307efed1ad8fa1247ff70593ccca6fbffbf41e255e305e9d4e881e4eab88dd0593ca85ecc83e265e352e182da625713941c374b8055377596c8911eea2ac0593d6868b794abff46b4702e343878d720bd0220bc64f9b2696bb225a60c1947ef74b26b5e4969da8c0140c2dae60aadbd190a3f5f0f0f0b08239088995731c3d49e205b4a882495bc5a9ec1cafad475182165430a8860c113e990e72941f6aac801a5f4ca08687c70d1c60ecd021068ed51186182800e3075a4cc1fc7b226e7227d57cc9bb000c1d2705f38882b13b2b25676b574e4950309ba7f09d2ecdcaabff045375e7fa2c96f355f84e3078b2d8e9e3732e25424d304df6b1751b91f4a71113cc6ea73f62b9d905792fc19046f6748e95ec94502bc1ac1f4a597ab193603c89ed23645d8e106124184ee2a5edee14548cf608c61a59e24f074bb6a7d608277d0e41c6268c97d3cc56695787a83fd45ae0784190a10953f61249bf56dd779b298d715846260c498847f8527a975e1780a1c346e64006260c41869b4eef9744e8cf250ce154688b6cc9f40d7da859c2a8275c666b6f5209d3a84b966a248dd23af950bb1ac8a084f94497be874f1323c693305b6577b811212c5c5e1286187ba37264c9bd18d34046248ca3f2e849bfb9225dc1dfb07103079a026ac78d17638c2f6a5c6002351612c69f2b61c14c765c48c6238c3b1fe6235caa5d191d61aead7dcf791c3918e0e121068e1c8e6434c2244f5acc509131c2d8de1ae92ea432a1ee000305608461e3638718efb988d47ed611f91b38582043119f68d66908d5f50de2011989784b59ca19a5c5d3a76c3773fc0e30500622cc43c621ccc310e6b12b905188df479ff49f10a9b1493be2b4a953096cdcc0710108200a4015320661526292d210a54fe4fe3fd4d000320461aca02b74b75290b3feb18c40986a94cf9548ccb3dcf8093c0aba021e1ec48b1a3b86194106204cb19582a5d8414b7245c61fcca364f8e164f4c110c25a2e37379de67496110432f860f4997fb73cadae7dda83a9f37ffe927811f2bb1e0c4a8957d7a83c0f8664a974aebed8ce258407e36cd88e5216af83be7730767eb6f591ad2541ab6a0773599e384bbaad8371459447b4d1f020523a184e8da83a8b64aa46650ea66f4f123c788eb584c89083396408391ff5a2a54ec98883f9d2849d6ca22c636239defb1ff016b80a7cc04600ea20030ec6d37b1d4e6fc5a428bdc114fb935e0e4f427948728349890ef293473c7d93b7c19c424ed1f66236987c3372ce2179be48d760c8ea9fdd93ed5774ae06a39b543fcf177d7ff33418c7f4fc3ab4a8bb7bd0603415b582fe5e35d1f5194ccae2d49b52fb11646d0653e48ba33fe97019cc9d72986b7ac8fd1693c1bc5db2a593bb6330ea897c3272f515ba184c6b2a4bce217c56916a18cc1d3f33a2856c4977309865342df8c8968d24bf6094bdacfcec586982c50b665117d4251d47287dc22e987bb3dbfde2690509e182498c0ea9427b48eb6e0b46d1de1d39cb5087df00430235bca851c38b1a2d7809d4f0a2468effd0d10fa8e1450d0f8f14850c2d18b543a2fc884b42765246160c7a296d62e65b3453b1820c2c18ad92a9533adb7e7eb553907105e3489b2054459114632751906185237bfba7380b146454c1346ae2d77756f589f50b32a860883329774aab1ff39372b920630ae60c0f7349e8e95b171120430aa6ff97fdecd97262791f6a56a260482adc5a8c907d929850e07f926a7b8fec875a197982392995250857b760e57fa8d990e104932e0b2173922f6fbb1f6a63a0c0065e0a64340175eb99ef329191fa502b4090c104439620eb26d72531217fa8d9c8e17643c612cc9d4df653559af87cbf0e251872e554e7b966e46bfd50f330c0f8f0c2c3a3c6052650e3ea4221230946d31fc4840a613d3ffca15687021948309ac69bf23de9d9e230641c81b10a3ac7d9087547b3495974a83ee9c01106522b42905104e3bb48ff2f9553f68960f8b151b122849c98e81090262b6f1154ca87ee096408c1b09e1b9f2c25f518fa2098544ef8b20b2fcfe3c9008259e4458adaff24db7f60f6728bfee5a2322dfda1f63ad404327c607cc9a24efd58d69c7a47ea0443460f4cca93e473bf4bbee7f81d379e07a65012cf2e8c10b94cfd502349c60e12134fb8b6885fce011203193a30d5e99472eca9b2f9f4cbc881a7b72bb2b7296bc7eb203c031938d8846eed4816193730a5092932c92ca549b90fb5d761564ecd65d8c09cc2fe2855ae55bffd879a378e30d00b72326a60b6dcfb9ea267edf1a00fb51b63e45809c8a081e1ccd67405dff1acee43cdc62ccce9ada79eb25a44d63fd434fdc0852c4c5e1eb33b3a9eef6d317088c15cc4c2e42ad14ecde41cbc530de00216c6f5116fd3a36a291b37c6c85134c0c52b8c3516fec72f46feb25cb8c2ac924fe27f8b1f6a655ed4f8620d3d0b1e2bc0452b8ce66a5e4a083566a9eb0217ac3028255bf42ee57891748895e0061827e0c2c52a0cd1e3b6df3b75c8de7da8a9c20a957f99f197a299e02215a6b36ecff9b9b997c40f35bc0217a8b8ade78286a552211f6a36940e5c9cc2d823a2c95cdc86878103d94060dc683156479ac25c39c4c8f4932227c43fd40a16b8288531828f7bf75c12264438c23899052e4861ceca598292639b95c20f35328a2aad87a4d9d944e943ed0438707cd8380b78f1b1038c0ee808230c05d4f0a2460d2f6a7851c38b1a1aa8f1c5046a60d9ab008cf2062e44c1e5d7bf4ab4fe2c828b5098f446e5a4e7e24de409148618a973247c59e2c0c5278c1af661664d4f9866be44fe7f7db9f2105602179d3067533d21e4fcc7d4cb49e0821346b434f2b37d6c13661d2b9f0bf2de6278346192253aa595f059818b4c18ce5274f8eb8e5d210913063d6d1752da67bddc9730569b381795cc7ae28c53e0c212e4ac923a6535255a2e2a615c111ab23d7a9428ff3ef76b9330da85ab3c394b8e3d7a49184b54a7380b45c264264fa58bde4924eb2161f65821e5c77baa36fd11c6ff4aa2727f8c64713bc2345a7244b5092959761b61c8639f446c65ac549011a691a1b6f3dc73c4f116618a7a5d9a9532efa922ccd525f73d7e8e5c154b843192ce1dc4df968c094204417fc5ea696a29658e1d62bc808b439852dad20a2a9c7710a9214c3a6c95102aba4298434e552909a5c764c83f90c005214cd27b92b67a4842087d108624b4e5f95235ab5b10c69413f2ed122dc9b9813088cb9a9aa99ed9a602c29c3e2674f6d2ec3ae50fc6b11179e95397c88f14810b3f183bc553e144e4e09fea3e18435552caaf45de55a302177c30870971dfc388db477b0f95ca927d418834518a810b3d1892a75077a52a5ee89b07c384fb346f713af4dcd13bc640810314004de0020f8e891061764eec74872b9fcc32abda33d9a10b22ec94f87cc1548723c45709a93de9e4253a2062c66789a5f6e3733899ce4bf953721c21399492ce755a71cbe4386c65a6b66c85835996f62ccf43aa6fc02a7e7b8629dd50fe4a17f36dcacb36a0ef2a5f90938212d9603e9556e67a219df2890d2ed6b029a1fb4584b4bb1a3c253a551eb1701ad879df3d61175434e839cf5beb8bce49776730e71c36527dbe34aa6406e3fc05f74dedf9f552194cb1f5dd52b448f27f32984ee545d01753c2bc1fc3799d2d522f06739053967c2d9ff6d8c3609890c5552b7b25a539180cfa92780e9746e9eca32f9cbfdac2bcb4455e30e95249f5ab6bc54c51174cead77acf5ec405833a8b2494d25dd1beb760122137fa2f98380bb5168c9fea7d215dbadc6267c138dbbe2e61467eafc68239299d5fc289b0266dbe424a873b93735f4ab682698278ce4961642f84ab6050a74dfb4a5033322f154cbace2c07f9e6d15f9d82499a698d0edaf9e4a95230e810ad72cf7bf80d350a26a123c58a96324b660a0583879ab0cb90fdfff309e6d18a14af5424d7289d601e175915b644f830ca2698454fd4bd739a583b99600edae7a693c5b73cc9259844d8ed8890da2de84509a83f6d4b962f24a1920493ef77c7d1f1b27b21124c31dbcad29ec811ccd1a3e953ba448c60ee19ad5361948e265f114c6acb3c5fd2e42cd1238249a59d6a251d257eb9219824eb6e8abc4e08a64ee12299f678f1b4413077ceb6fe51f929ae4030e4f620c2c6e75372fec054d9e2a5b3255b93f8c010b7bb5497925597b21e18ecdb3627280922cf03f37828115772b8b87e0706f59337545ca955b774d0e88ae530b93c521be0220789aa77ef146227aa0e2e7000032e6e6048da7278cdd83ed472e0b0b1e34b80e6002e6c604e3f0fda576249f2341735704466743f1f6a2df813d810a3edc4680a9489d128203970ec686e011734f04a48d1d2b3bfe3f9628b5998b49dee53d16d92ccf2a166e36fe0b08bc016b2b8d2d27d94af519ada56e0033638b0452ccc3995a9d1ace4879a270a7e07043a470e0528c0c3238c301a051af0f020b03028c5ff4f955df9a9fd8d15e0b0816347b152008d419847969afadcf8899308c27cca531cffeca2bdd44098fc34f7dfcd75fb7380d05458284b3a8afe609014e94f8c32a5dfd9ebb0e10743d0a7bb77e288a877442bf0011b89461f0ca972c551bb948450793e983ee6929e524a1a7b305d783091b25a849ca287070d3d98070968e4c13cf0601e22a07107f3303b98078d3aacbb2a7a218d92061dccaf5e2aa57c3afb169a8349a7a092c77db8129b7ea8c9c1e8faf92fe2c9e360ac92f5bc2229c4861c0ee6ea113ac7af9c4b32bdc1203fe86e5b33dd54911bcc1524a89f92973698833aa57427131b4ce6e5d16a4c3fa7d359433afb841c35984a427675bdab3c5969a4c15c41a8de36552a4c6d34186256c8b789a887cdfe359063cf60aaee7bfd3f257124f9a13676b0e06f9ca5e035c0efb734cc602a1d2fc53cfde81594ca603c954f9e5fe51be92583f1ed7646440813ede918cc572b3ac24fbaaa108ac1a0264d127337bad4c46130e5f830594ee554f7120c0695d359a5cee7bd07bf604e6a69af77feecedf382d15aaf54927afd33b12e98d49714cfa62bae78960bc6d292f1e859a42891df8229dfe4dbf7055b3d7918380e0a5aa0059399505f6db962a4db5930cbb66b6589a5cbe38685a37185a36105538fc5b934da153fdc34aa702ba041058387d2b8ab4eface3a3772e8f0f02839768841630aa63cd753cfb942faec8134a4608e64295a7ae7e88e3c4814ccc36840c16055eebdd932b2a38c1aa0f104e3a9f2524168494a75328c1fa30158011a4e308f43008d26984bf69b0edf3deae67ea8d1608221f558aa1ba12e769f926387183496c0f5c4092326dafa50d3010d2598c42eadd5cdb6e53dbd8c5123ed9031be98c02963d42096051a4940254bd239d93904ed43ed02e5cc0d3490604e3949382bad7ea5c3b1a3161940e30847c308e694dace4c2555118c12fb53ce4a4a79f12682f164a9f5f02a4188ba43307f68df135ba992098f64053e602304348460bc9e9ca24ab99ca58446100ce1654f9896fda1e67a43011e1e2db8d1a4021fb0616800c13c673946cf531a350c87c00d0bb481c60fcca6d45674b0e0aa9e9613a351400a0768f8c020b9d52adee2adc362c3d4f240a307e6aa740f95bb3e9c7768f0c02467913d24cbd2d881492d8e36bdae22ef2f347460aaa42fe407bb4bf29e0f351b37c6c861c609a09103c37d487fd3b9d439993830f575c767b9f82851d4041a373087fcaa26cfdd3c270f3381860d4ca665b2e4af703eb66e81460d8ca52b6a8aab5f6715110b346860d2ce5d37fda2f2a99a85e1ac572c7d90f4a773b430431686b49da6634deeec8b6261d2cf12fc72947f91242c4c952cfc4e27135622b1915798f10ad304db5efd0a723c855c618ed38aa5424f6d5c3aa3150675aff1db492ec962cc6085596de75344d11791f35598f2c42d5edc58c9c8f91c7d92053354719aa894e38e8aa6c238a2826b5cb75e8666a0c2a4af17cd34bf543ee543ad0539769415cc3885c92c4ba718f12a77a87ca8115398c3ba4e784e3e21ce530af396f4b4fbe4a1aaae12e898410aa37e256541e7d758b2678cc2f0264356857c56295ba2308af8a06245f4d3f1fb50381f225ea78a0a284cef6ec247fb9f30ea9e6beeffc9f9e87e878d470505333c6190fb7ca5a53996da7782b18f1c27da8d316ce8681b473861d0e229f4f442249cb9094308ba735cdbe90bd669c298692662b93fe36328478ecf84694476ed6e96ce91734c8460c6250cfa52bc08df1bbf398cd30a821996305e770897f2a3a1921f985109e3fe880b215d92746006254ce2548c49627db1bb4dc2a0d4e4ae5cc954dac93fd46ca067c1dbd9982109d38f09d1923fbc7f7e2261ca92ae840cb72061541f6b8921c4a7998c21c68e3170dc08663cc25812bc474ec9ca9af4066638c2a02d764b3cad13e1bf0f351b2c82198d306411dfe1abf26a4bec8b09a4cd6084d9a275de68af904cb2381213662cc2dc7e125ddf43b9c5d073c0c3e304a83f146148e9448a32b5f11f9efe40e980198930bf8eb4923a41846142f67c1eeea4a8c81ec2f0412bf4a38686309bffc8d33f4adf4454087348a97a3b785025f62784b1738ce868e926d6a75f8c167c8184198330c8b034f2354bbf2b880833046188bd6f41947b958ad8dab040cc008439669785b31f11456f1f6ac52c30e30f26a1d3fddcbb849dfa66f8c1a44ba8a4be2e5bd1c08c3e18465d96545f716645cc0773f8df88abb5a3b4ae3d9844ae607272082f9343f46090e226dd429c14390dd8b87bc28c3cccc083b16a278a9e8c574b9b8d61c61db0523993772174eeef7630c30ee7f8218834face0f351b7b8319759841073f88b274918787ee8c39183de52d56d3fc50231a88c20c39687a8212b61ea7ac271f6a5eac8e0633e260b03c36df1f7488d41e0ec6114912b74e7ad0f4bcc114de4674c4edec7edd604e22f4a57dbed00fdb60b8dca59e26ecc75ecd06b39e48b81d31a7755f832984fd1129828f049bd5605cd3720ffb962fe869305f9c1e7d177ab3278b06538eedb67f51ea2ba56730cdd6bca8ec1b8baf1d618619cc5192e838563b2ae9b361e34c47d9cd2883f173e80f73c2465ef81f6a29781d64304c5051c254c856a74d28b0e1375ecd8c31187dc452dc5acfdd7d1838900d3198730ea984454acaace2c58c30e8aa5ff95edff3faa176030c35c10c3098e3dc3c68536d1f4c857060c6178c552a64cc5cb5f67e4a056678c1d4e112bff2d5edf85d302811afb84e15744659821b38c2580ccce082a183ce7fae1a394933b660143db944d8c4dacdef6e0333b4604a9f94dc5ca4acaa593057bc8cf95dad87a4c5b08199900233b060fc5472d279bd08d11b0560a0f72b98d34c1039f545685fd287da496086154cc9827a13bf762227ed875ac2f13672e0a882e1b3ca98c68dbc20163c99c00c2a982ecb94675ef8436d0a668d130f5adb54726d98d9456086148a8fb332d3768b0b5796299f8287e98cdc977ca895fb6246148cad62c1aa83a7d7907da8d958abf1850332407c30030a866f0f93d693d86cbf1f6a65ef77339e60ce39522ed662de89680135bca8a1801a1798408d316638c1942d62f2a5746a82516d54fa7779b74f4a29cc6082e9b2c7924abf5041e7e868c14b60094693d34dab7cf952c54a30a945bb346eda3e47747f30230906f59013a2e41bb31621c118c2472f9a55ecfccf114c23fe7a3ad9a4ff518d60bc24296793a32654bc14c11cbb15425cddbe108e1d3678083388604e9e4aa46411de47a58660123172520b1eda442509c19455229c455005c1fcb16eb7f33b88f013108c9f948c28faf5b982fe03637a1c55bae7933fb93e30cbb79c87ef3d30de57aa9313f75bdfe481c9cff4080913ecfdf21d987fcc44dc88a6580c7560b88a9bfbb5a7ef732407e634379d21ad42fec481b1be42e4e45e71a3733730e4ee10c56d9418713f8e1d3720c0336c60c827bf743b264a125f600235081866d4c090f3db580465591eac9a410393f6987f13c4680119b3305e8df8f08ebd3c3ae7b8c0a3cf2186878787474959984685ba9c55a3722a0873ec1043462c0c1ef592fed8d14b9585a6860119b030c65887905c628cb6fc2541c62b4c6de9234bbcd5b3e5e121c3158614f1764e44a511c2fa50f3f040bc25c86885412ccb62845dbd4f5a212b4c165aaf525928f79052810fd8d8808c55184bdca679c44e70038c09144b5518a4e80f114c8fbcac0e1b371ae938cb808c54186b723c3d31ef54caa50fb52d7390810ad38d7c5569959c74674d51a0a357f00019a7308a909fc42c971f6a6a0aa378c855e1722a5ea51f6a2b480f0f1d5d021d38bc288539e4c33bcdbf5e284991c2ec2da2d6d13f08cb167d2919a33004f3f814d646a990f60fb51b63e4205fe050810c5118b47becca96f087da0d6484c220be3ee78c687e95dd879a0ea41e1e3890010a536949636dd9e464e43f618c5513d315e341e7f2a1b6836578c278c1624be7bed205323a61cc37bdf611314e1855bce393984880304a7cd9164f1f82bafe0783558e7fe3b5fac13813c5c36a59ca754a1f4cd9a3d2e9fdddead8f2c12c2ad98408e9a323c57b307f853f5d39da7eb7ad07434e6df7abf4215dd43c984cf868c83379a7a38507434e695e820a41aea27b07e309f9a142b3d2eb267630289fbfea538da8a75407d3568f3e5d29e3eb173a98b3a46c721f7298f0d51c2edb6bbb11412d07432e7521c8d7ee18498c8371e27e8afa3979347dc3c190530a5f2296161192ce1b0cd732d629dde32fa5b8c11cbc3f84ae7c52cb6983e9f7e343cc52a551271b0c426e5f59c40ab94a690d86e471dd4f5fd392e7d5600ee293388fd9a6c1fc15793da8f19392846830cbe533cbfb6e7dbb9cc114ee278b3c119f267bcc600ed3964445919aa32f8339ece93d6d79761f2f32982cdb9374c9592752760ca6fc3613cf5b19f12362307d85b2a05a37d92b1a064398dc49994aa282e418188c9f7657562e5f308b1c7d69db44d2dfec05937dbcbb7c7a7ad661170cf93cd2250b7f7aa7e48249b6878473d1af7fda2d184da87dcd97480be6cbb922e5c69605931a15dadcd6be8310164c15de662e7a5828c95fc11cc43da9384957b75bc1709654c5a9abb4c949553005652b6ef954380fa282b9b783df7c4793abd5140cb3a23d25a5fbfb2da5608a17aa53ba79cfe9c72898dc3774d5c4924bd28382210793a0ec54458d947a822155f4d17e9de4044356513de9bfc2f52b4d30b9d6e45589fb2ad964824145ce5e95a55d7aa24b30e53fabc8c94efd5682712ea8d5fe902605154c82f1cfc54e87644182214e5021e97f6a00473067519d9273ab5b4c7c00463069937d52b52fe7cb39802218c45ec894dc675b3a67004430a439b1d4b6f349c773004330fe8e7b4e6a2c9e90cb00846052fd210419d93f45df913080209846c70f2abbf985bf3c104c29db2911e11ac00fcc29d7a79270219dde3e001f984e45aaef89daafa40ea007a6943fa5144fcd9c3cd10078606ef9f528a34d4da738801d18420816ce73f8086a5406a00353cc4d7df598a5ea6e7cc2007260ca6e5a6a261ae6b5e1c0f8498da40f9d1bc00d8c9d3bd9d765e9241734001b9854fc424711413e866c003530e56cdddf2f173c447d003430bd5d6ab9ebe8e7f7cec290e4e65fbaa7d8db2b0b73d29da1334f47b1906361aa6832764eaa5ef60c0b430ee9b7364f87fd5e5e618c28572a75df7d25e80a93f7e92891a2d8d6aaad309a32f54172a8cf53332bcc2a51477edc88ba105d8539ad4ff9497b752d4d15e6daed6d8ba03f4c55526158d78a6f23fbe34b0c15e6fc965f735f82e8343a8559d2ee75ac903175275318d6fc720aea2fa530042149865c56d68819294cb2e2628430e35f621d85214cb41069d38356e845612ed976dda69e83952e14c6491bca54923fd54f82c2a83a3adfe53d274bcf270c7abd75f6d7e2271df68441a9d6be1e5ddf0a55270ca964278e97572ccd38613039f130bbd8a244ca268c2146c9d7f813c22ed684f1ed949c8e30215810c984d93a784a2159f5e3689830a41262395bd2de90f312a650b15298f496254c124778343daac2a8ac1226711ea2f8640b25cc7fba16238430fb9d4cc2a0bb912f6ae787aea0244c4976337b74041d711409c3a594a7645b0c0983f8d439827c085742f9084378f320e48c1c21bb230c32663b4be343efdf469836b47c70cb792f524618f6f2fcb6345c84292c47cb72ac7ab65784e925e4d60a93622a2a89306558327ffd9c2a9f448439778be5674b232fec87306cf78cbcd7c9cfe71ac29cb24f66c579f10b51210c498b8952c22304714a8b84302713663fa2bf41987412d92e957b45d65c10e6346d8bf4110c8449acaa7562e7939d4e4098d37c89f48a31eb8dff60520b6d16be6bb672f2833945d376a52db64810f5c1e4d73f579ed75c2ee583b15b4c963c0b3115e13d1845f2acca6837f3b1f560984b977a76aa2592300f883822db8a5c10bbc08329a8c8c5b797904f237671077367c9233f7c28172d2376610753dc521d4128156a272276510763840ba1da92b6be5dc42ee860d833dbfff8a615a7434642177330d96c5fe9642b9da0cbc1a44d649113612f7b12c7c1fc9627395f8aa0475d7030059d7747bbdd363f7c83b9f5c46f6f6aa5f7a81b4c66ef31ac74dc62a9dad0451b8c97f495db650fe6d1dad1051b4cb71744ad88c95d2a86d8c51acc56af963d9af450ef55a10b3518a4b5c748d9a1fc92290da6582985ef13a59e1f418371ef3f4c7777d588cf60149364294104d5a9e2e1e1e1716cc34cb067862eca40f0ca49f5ad399e2ec8600ea754c3dbf3aba85117633066ab9f776ba844b53ed4ec30d085188c76b97f3294b650a30e8341e58bd9dbd7ccd809180c67a217f4a894085d7c817c716ded7497aaa00a0e0b5d78c1243fc2e49e289122885d30c696780edaf2323de782f947358424f941e7116dc19c2daa9adc29f193945a3045d4b94ea35b10bac88261645db89ce6f1b3e886d00516cc61f3b7b311b2e375e8e87205b375c98ff225e2e491756105933c71a274760c7132f4832eaa602ea14fe4ee92f1498a54307f7f4ee1e9a55c439e82314f443ccb632176210593aa6c5793b33b852ea260caaf1ceed40205e396cafc1f91578230a1d0c513902932446a764a49a9a4a10b27184dc482fef5361dea35c1947492b879da5db363d805134cf9ec2d7e547b2959b1000e1c19f81c63e8b8914ee8620906ffdf7851f955d733825d28c1a493f0fa518fee11d42e9260b0f61122885012a2fe5d20c12037f3d4f78790d5464ce8e208a6ecfbbda574ae8fd51bc1a032c26f655d6499bb08e638a14cbabd28bd252582b1ccca3a4569af041d27a18b2118468a9254f5a963c22404535049e35ae1e27dfd413087e8ccfb9025b545078259245b6a09e93ba8f7fcc0bc1744c875af12fb531f184fc2f7a5d8bff33d7b605a911d92fc3c30249194e7fee27e32c90ecce93cb364ca9b50dad9a00b1d20c225cf1f7b51c38b35421739286ceffdc9c5d27a09a10b1c98f3452bf1daa144c7f2a2860142173720ba08198bf3317f1b98f386eef554414ccaa98b1a94c4870a9d745ed9d8852e68a005951cb1dbb45362ed7b84e81368ccc2b817ca4ce892b77d250d5998d453b48b756d2c0c222a8fade7126e390916c61e5371734a843ce2f40ae3e85ccee982e80a53854cdd107f7eb7a656182c3c9f6ecbc5c8ff59619a2f7f9311213ff7bf0a83f2d416e4e7a80a53ca3ba1467d52299e2715c6aa202ae76823245a0e2a0ce339e86426eb4b627f0a83c6251b57370f422d5318734c9e1e197f49f7a51426a1fdb64f796efb7022854924c7b050321c8531ff3727a5e8369d280c29e78ed7dff3146b43614ea7545a13ba0385b982a8cf31ff0adffd278c1927e552bc3d61ce892e13e2fd9c58ad1306bd5fd9c9bf72f6ce0943baf4bde0a965a2a83661906fcd9ed31a7222d784e94e973c57997ce80c6864e29c3721ad4b5b1026d06dc1c282f6126d88ca8f1e62097f3c05175f3d8da1c306492ed0a884499f8fd6053428615216e4b78b9af07de7244c9d5388b4a49f7f9f9784d1b2a4e42b42d75a7f9130279135dd438826ea4f903025d59b5109724126ff089396ede89c53655d0d8de1089378f6d696e71b61103935d53d6c57ecf887da913118618adf11c9d3e7301dd24598359452c192d07b32421461cab3fa29374274905f22cc4966724dac10e9cc2a3ba0818872efe45908b2a1a3172f03340e61decb39459b75d1f1b2214c5de93edea66347ba853069e524cfba123d9ae94389bde3a80012c268068b1ca8e4ad0683b240240e8642a1502018068f2f360333140800202c220dc642a1782e8ada0f1400035446283a3e241e221e121089c5e2d028180604028140180c0604c2804020182485a3880cec070048407dc302addd68a07650b1502ea875283ea835540d5413ca049417ead5281d213766061354146a46281c5051fc15e51b87d35843b9a052c051a8ae0e4db8053502550f757914bb94099417d4058a0928e067877a6c9e191c2714064a026a7203a769d9504080e453eb0c353aa293270c465493d40aa278a56c52885b8c4071a5e134162806a8933b541c39e08d6541094261403905a5a09a00a18037050e381ea0801ce2ce153c153ce13eb59f9a4f094f1eae19fc80dd71145029df4d9179aa3c313f9978f23c4d6998c15fb6a4e854c18ea439148c88a66494183e730597c93879ea7fb27fba43414385a13aa0ea50d6506ea8035074287b2809d460280ea82a3140275c4757ff05a58382802a40e982d240fd824027c8a6e88c6ea83a540494196a37141eaa06507dd6c276df028acc46ddcbf40faf1750762832547d1b146dc8e7190b256e519a544551758cd43d64637de840a9438143490d05ac0ef5b5090aa70930d4876ecc7669a9dd49c19c988d0a3dea2a0f011acaee43a1aaa823e121a05aa0ce50fca176a86aa838940028fb50c00d209505e5d99bf157f9a899dd5f8070c9e27a416663d84c292571091d586c6be77d15899f3682ab8c6056e3a0f450cc50355407a080e0988167589ac128d8d333e5f7117dea5d090846b7ca498bef54c225275f028a7fb75e2d0bc1b934b458a3f4ae5ea3ab0d69ed2815f707483816dca2e3cc9d63916f67ce4a0943c18dc9eae0aab59facd1492264780041b35d8e1b3dfa3002ef35a01e169fa8217fe0132b93b8020cafc50a8ae4c9f1eea252eaa50b4796a700f0f82ece6283771d15079fa70b8c35ed3d4b530b45d01dce5c7860c89d97a300003fc0943504fcc1af18c331b01ce705f8bd9590ed190514c2368ddaa45d0d00b4d813f83390b888f89094530e665329e22a96310d27c5941ed07cf236a3cbd89dfb64c4784948f1d4629afcfc8f6a59037e18ff13c00a1fa8d00307e507ef8b161f49d242cd5064e3ff4a187dc8423e9a06f628b55d4621fd36f8cca3210df9c38154fd9fb5301f0bd6e063a2a103ba9bdf17ee8ef6644b5c3947766541772ec6e80f9777b16f2bc029511fd3e0d28f3d078d813d595469882b44e971a19e42d73773ce53a1e98eb812ca49d9c9f4585921d93d74ec377a5ec9bb7797d76a149ff183387b1eaa2247f716ef2467ebdd51a672538143d491881c7fb85204b0ab426a3b8fd91f8ff481c461f81f4a7a190582f6c805a18560320267038d85af3c2e7b7f593c22815b7fb9e2d95c210582221bf1578c2d06143d23e203f062124433dfc5441b4c169e0e6065d04ac5bedfe90ec5f4b8d5c49d62e5d73297183112b707e76d15b607cbc8e4948302e39716927426902d36338e26615863b2264f0a44df8bfb288e8d381616168711476d7cdf3d7a697ceadfb67b0d0ddcb9de0bb04575cb4c52bfdc9763190682ed8f3db8b5348a519f453059dac41e3a3b20c2ce8792341d73247be32650f90a2f70a4af9ac8b44fa49142c7b946a64c43371b4dab4101fd05ee6b2e64e01de0d418672258a369009cff0925bd788c3578230968ec518528d7346c7a8b5018a599e1db0f942a23e2f49105cb084aeeb81ca220de75486211813d30684f42ad90edda51bc1549561c0a1c3a615f1853132177b342b2b4fe7aece8fb5012a66d73c181747f29b6f161e5d43fdf6b45b9182a2939d7b3366f1d7eec92314d8ffbf06b344b30a7b2841ae4a0d23775e2f961e28678d2a612e5f7f27f195b6e30e608e054998d2ccc4827b708c25743fac9cc8a9a41de5906365f58078f3021b4cc095e1e6b654959bda9c23ab835e88ca69b441376534798780052faf32d802087702e80d00b7799309a4f16e551255547d736329a46d240df52163026d34f0b4aaf908a531c5ce925c8754d41282367493319677930c156e41b218c0b6fe7a734a372cacac3cbe04bc99447e4042d086982b3dc9362b2fc302a0a2b8543e447519485328ecc9962341802ff717e237f6503c03e68b0368d16311c866882602f07c73014c63b9e33a1c2504f8130842b69ec4d124e2107d960c817a59a365fbbd1063a2a62cd88aa426e9f5b76c7a640980ceded72ed78dc8c5e01cd2ef2e5c82c6b3f53c96c942c00989983330198784128332bfe987688f096aa2cccffe30c822d111cd9b37520f92321fc9256b70113ab9241401b8fb5bc2441962f61b69a11f893fc7746a2b77b416d0e84ba50ff65ed0e6b1919285c34807b9c19f0bb1796030d2da202d543de0b71c484882a2620c23750dcdf254f86247aee9ad3aa4a29cb013480885857ec6fcd34ef34110f73118ec70d1133ca6a4223b438ff62d49c4c264342f637950304d6e1f7352ad4356620349fdf5f46bd9ae1b5928d579f7749da69318e400fbcdad7f0c483185ad0c099c329a2a1ccb01379b2f2c0ecd06e8f7900b4d5212a13ec77527d80a3dd4f22f384277bcd1ceeb28aa1fd44aa5577271005b27235fe7fac21af3b392440440f576384df92f063f442960eb4d8a5c1cf49833e598b6263d3da39bcc1cd883e7434bbe20bf6a93d11d33fa4080ab75d83239e39e0829f324570a081dbcb26835ecc155e788c39c607d0be90e642dcb134c083ee25ffb114ce9ebe5682522da33d69f77f60d2b7f6d46580f66cb55cf5e8fd0a0afbaf140fe06560b786aebad18743bbc9db0e8c051cb087e882d824ae5c40caa12aa38dfc2b8b92da6afad272113f94f39cbf1b8126563ddd42fd8602252b28354ce86c2c2c2c33601db21bb1ae77f6552af4db0c69388b0612a1cf688bcf78b45c08a121138b3e5a4efdfa1d988f8ffd988f51d3e9ace4d342ac56154f27213713aff37e3ce3c08c9682f38e8155c0fb2e14a537c34c3847eaa86feb7a1fec881320503c0d63e8d15f4581d08fb3b2ddf86434a769162895073ffbe11b23a12da20eda7b6bb723d003e08636ff019c957e2d596ae64bd7cb2557d3d106141f9c9d41143712adfae797aeb0f465963f4c202142a2c2e8a6661f5950de40284413111911af3baed00f8f90d9e0873fc0cc28f5bf3ced201101f530575920a107432142ced2c31ee1b9e795db20c7d29eb6cfedeb14de2762ed6602fd3d321501b425e430a60e0c08e2e2929305662cd011ac67047d645b5878e2145d2532ef9e74d07153d8c218b20acdadbe4f46d8f1e927250a41468af9f97564142b546755c06159fa6f979ff847a4f8a04920fe150b05caec1a106e14e35bc9a96d4d0481f52b9a203bb07361f5131248dc79cb3a6c6887e7984f22a891e7f5c6be29d3067e1ea21afa84ca1910a6c546a86988038008feafe284359dc118348d63126b5500f92ae9871cd93b0a2f3213685adfd662333c6c29b85de51d062b02ca62673087ffb079a35dc4bb8cb8518974757581221057b8faa6561ebecfd28605ffdff7ad87bd4d8ba82b990ae6a1ca4b724233efa427620b683f715e1e257dd7f3f0acf515120c948d0acc7c4dd01ac3e81a11c5f70c27b5e149bb4a6d559b091e22dd56b848a03b55fdd0a5b57f22ddbc8a8360a393749de9a896ab550825099a244a971a72a9c6acd35b08f694b5f69562bda5159e53406a3f25d651ac080e7f85e9f67a8e1724392270ac24c2b03b5806cc9aa649834a036a061b4dfb82c5ea042796c8453fcbcbc97c2901d68f429b02d16855deb95ee7e8078e9573cf0c24076440f06cea7c623c24ed12c1abe9fe0e1d7452fefa13905309f45c8a320410514f04191ddc03888bc48e852ce9331a156e70008daf81e2e8da02e6f587f07a6ac9e3c176db6ceda52a813f9b993b1bb42197fa63519b0ca675a33b2e38a84bc008404844b30d77248f97a0dd426af6eb84862c48113733068ac897d89a021bc2a4c895789e01b502473eef29fc24d46df2d468257e452a365eb026f79b210bed210c69656af71927dce222698a7f4633e4e3d75490520f4494727cf062c2b3b0426cee94e1e244e00875cd05956ee5396ba8f2f311a01e3f24c69c9b10cd0961dcb6f1b3d2e35a4420d840e723c0e7f028c5ed166f334ef21dab4defb8cd8e605f9ddb75081a0e0b82be15dc78003118b020d720ff02570305c1c70934d301daf26aaa491b94d6b1ef62c3b8bb4b7dbf52546010a16fe44a49c3d1dd85fd90c7c70cffc7bee3e64d3cf032a399b2d98f54ccdb65f25865575a68c37354dccb8dd281f72f58234b177a2920308daf7084a18ae225d7b7ebcc8ad37820557505e84be0e2cc9844dd77dc2ad9e2725d3cc6e79f5e76000c8d11ed253d0e770fabe82690c10f75cb99362623aefa5b5278d9e4a2d5c91a6144d641a7c7fafe81f665f53f5b6f123cc234b682069ac317d8765f459be4725614adbf3f8cec221cf6f7b57fbea490f64685fc9d8cc431674a3e42ce0cc54bed28ccea7cd146150c4ac584aa0901fe1726e05f89b9c25bb09e0b1bbd1118db2e3452da5fd5f578c3fd02563d0b3f5eb4b7f02f84a9dcd5a38f80350755109687a747d3166a7017ceda69cd393e1cb3885516f57538cfe111a317588f179a46e9ae9f5aacb6f608400ae9448c64014952c6c747d54176930639a40446dac669c9ea6ac8c4bb14d1101f882ba8d99ad9d5c41d783e0c3e9e7760798bc0f68c44bfc06fa00e9799332d3619e67763e9a5caee41a28d10f6db0e36a31fedee9cd908c846b862f3cc96cfc01da4c22270a0c346ceaf2475daeaf7d12acc4fbf27997d7ff5d86505bfdedc50ca88c390ec8ce8f77bac609cc0d13ecf64b0532babd800809620da379dc0132bfb59c5830ce4bc279497b3ed9d4dd34b0b60a6ac83c3dcd73bd7da12ab9275797f115bbd989b32b7983d94a1b802f9defc9d1f8507d02da58e810aab8c1e82a58b8b9a7ad37bb23da732d4e880a154cb80a7219a1edc983e0ea0dd32663dd71e5f913b07b68f5762d7837083ae7f2555988e1926aa0bd1b0e6ec4cd281ef99a44e654d838c21390fd75a0567f58c64a0f595d9a86481c7c953a275c9fb0ad85cc2c3d271e50d54695128d8a2ca189483b95aaff163f31f61c4bd1459c88b316d4f598666831fe30db9561a3e0552097f186d9764552417749c31a540352d17310b51071d9371da8abd05d2d8b1d2650ce480ad7b8061483619c5f081f432ba89c36309b929982625e5b9231495a45ccc3b2035874c5cf40a77217e9ffa70125f321a4852e5c4836734cd076f7caea9c2be4b06c38b8d5fd4f9309a93540d61e237f3a5184533f3fa85df03de99ced5726fd0a79769aef88d7ce0a06b68b8d1d960fd3ae924e0e0783a3e15f670daac769a981d893f1b981d47249334c761869f4c7b5f68a1059f2f7ab657109d638a80e4b736506481fd64428cde97a13a635baad958d3c5143cce12a22d564129b8dbe72baae1a288f7e5c37f55ae5c2fa12f1655ad427d557f5091b31fea6734ccecf722bd9ea9195fe49acdf9017ca090d17178bd546c3b80535cd35868dbbc9aafb9704885b5e7c34e5801305774e65f1de3f5c2d1e3f897971f14c2a6d89fcb12b2e91dc95578475299c20f090102a6183d86842aeb748395f5a52937e5a056c44ed7b496c5d389c895a37063853d89708856295c3e09077bbfbe42e211c320b22bc7b3a98158cea6eb16e1df0bba781e927e3070d00a6c8bb5a52326b11058200bc858836fe896b9efa1e369ef0f7633707e083960cd9ee5a3738d02bed824138ec244ba20d560201d5af59aa57c486cf22bafd2b832291728ae0e832516a6089cb4037b07e96dd60a97caf194ad47717b6853024da2a9238fef112303021416c7e01e65bdfb014def54c4d0338ee8dc6a7d599c630b38fdcce4dc99aa92ac1d0cb3eb5d6f128e074fcbbbc44eb3a8a2cb0be2193d449ae662be5b55e7059daeb047e2e67d87ceb4f0e1338f43fc569e66eaa738666a0b9968507c316063214b1d1fc3f0f111ab90d10705b53fe0b37a1f63b0fb63ec3628404655cd40f8e7dd940d4deeca4f693e1bc4bbe0f78c9024486084421e97b04a25be2839de8a516d9f9073080c7261c2ebe97802c6a64c5782ce284fedb5f27bda4ae7334c20788f7ac6be070fe224daedfc8345553ab9c8170a7eb0620c0ae1dc53f67252d45ee023c9f7c75cb00dc4b1a730645364642afe852545fe5dd356ba1e1cc00ab07f3f5162633c82ada7e2b76ee31ba045e36e0804366000fad2de8e38aa97bbf17ea6b8b4611a28e645d6a39adcde2dd7200fd7ca2a84dcdbdecdcc4a57304ae0b15b260aa808350db3842ee480d2428d529d8054c01ce66642cab1a344434ef4c7aef05725d6e6c729ad2d72dc5fb1caa5cc3aa16029682c7543b18663cf2cf1413ad774aa3647c47725e60b75575ec1626d9b441e36c794759a5596b7c7280e9b93901a1458e80412c619335121d89aae9b6e48ee86aa9783c81bf41a787be8da75ef7521ba02deeef9fe4b4a72dd73ba5b88c9b1facebaab9737935d77de852e215d8dae84bb43da5b3fd1a88087c97ff8ee99aa05ce416a84498cd674ba058bfd2f33811763570248b2357c0d091062884bfc4b954c2d36334c46626c805562aa8fe0f8d964448158e191404b68a380157ea3339a4a1195e4437cd92d6cd95208374da94554a255824f8cc6e1cf201647821afc1e48ec466717a69c1657967a6e0b21d949e430695d8e6692bf3239e744b7167bfab325bb5e5295e09cb8f5bff3fc2a897cbfcf3a6b0a5c747f89500ef670e159d9c77d5806ad7d43db04e323c2ef04cc3e5cc24adf2a0c2d99a4ee6c5efb924004e9c645e3f5b45798354fdb1ad736a916890d3cd2301d4838276f44f44eccaa67508ca8ddf853804e2d0d7af97d1db251bbbc47ba0beb5a883990a960f66c5f5de34476528e085263e5dcbf3499601bf5e97c8e5e6d36cde926ac49a460bb26fe51fee6d49b91a3bc89f43d07acfc89512b21f27ac46f4800e5d7155c652a66e5aeac8d07dce98201170c81a366a3e1e92cd608d19e49924a94a6e57517944309a196081c04a468ba1262ac3a3842aa998be22a0e380244dd1e0b14898a77d3f58839d1611873588850a89d002a8afe36f94bd4da62d7168cb576b98b890bac1fcb906631214126b8b6dab29ddea084a7c8b089133bd02a5dbb156730c360ff367a1d03065487c4dbd1e6a0eaead90a1292f27c282ef798fdae690127831c3403cb317132533ad35f1708138a3fe2a1e54a0b4e0bb807f10bb54068ae1492fd5d1d38679236f4af2cd930c8a9d1eebf938a0b1217a0048f356b11ce0302fbcb4bf55fbc4eafbe8ad1359d1117fdb52378bfcb750cd4079087cb28253b88b832d2ef46cd6c14b949f65f58651f4f0492d95724a9520e3dc799e550d5da7c5308298e906db227dfcd27cde7bad3b0dd1bc3c69fcc8200d9711cf6513bfa9688ef8a0d774f7b5977f1cd9062fe3be6e18717b79d67daae14b1e425a05dcb4903559d7edae5d11f3984f48abd641329103a3dee69e5a6a12f5d92b2204848a4a52a98cd3654100649f4aa5f468ecf6ee32450236df11d8345eadb22283c9570a42ebc3f0530ef3d904681701f3ffc1cd13efd3ea0ae56e2c0b96037e54949cb2278ec59f084edf7761844317dea474a2d72ae2cfcb516cb20e38251a873f35938cd29f33ca0a7b42bd881061c2466cb4ef17d4e108c0d4b2f3aec10e2715848637dadb90d6d2a6ed9335afd7bab37e86e5959c2686a8e0116c53d8bc8ca2078debee1d3c5ad49f711161268181318308ca88520199f850ef7d8a56d315a49f0a0a1bfff04c7455354b9bbe144b4e1f194c6cf862ec489efaecbf720f95462d060e2e44a57e10e3f90081652a6eb874d65a2e8718625c28f2d7114e3306d244dbb1bee35f2fdbe393bf66612e215e0e15c895844439e6885ab4bd02265ef526ffd0788581f4105ce739a453b7477379c3622746772850a860c86661e24d12891c1308379658e10560c020cf60d2006ae060a1fcc1b61738b3df8a2377838c83027eb5a01d27cf86f3ef5c469a4163613974a6f920ec2fa540d32efff0c36ba7109bd6a450bac3709e13e30c07d50002550009001e00e004626a4b736f700799c5a222531fc485c1ba3a35c1b22a410b986da3ded85ac38d970a158040819fe038a4d6bc4e03fc735895084e52053ebb507a22e0ed5ba86b39d4f7aa2850d347025a6abb303f630d937b2c5ed9c22dda673e44fcf486c3e9a169fe942fb1acfb71ccd79ff6177cf20d6927da0d49e87754a148e2de9c04901cc4158f72941f82e5d6a13827195a4d5d9e15ac1727bf021417b242e206b2aff8bf7ddfc8d3f08ff250455ea16ad61e4ce41600685da6a25114a8f15c84c60fa7852464849ea9ec2e6ea87e8246c4d2d6a6bb5203aa4513b8ba7bc90c0e017588c2c0d954d566491346807f1d66b055608322da3b52cf43f044efd75880a94d7bde999dcfe62fe6f615dd054d1ee691eed8aa8a43d5116494ddfba4c69d31d1c1b3370c7b0fb4b453f0078e349acab0a887ff039efc0459e2983569d3bee316f87273656ae212f869d85430974cabb7e358ac35d95fa9817d18ffc9761d135828d4935c38592cc01a76b091e6d8bea8f47bd636d3245f8b732eb5785f653448f38927e84f70face831bb278ce8b0ed6b0a743872e2ae1fb37fd2a1261fb433c4096f945cb38d77c05246580f6d786b2df27d22a94d8cb3b65721571ff42e7e499a790074938af6833a8abaec84c9a6ba9900df8804a8c211f9154295118b796631d01b833e975504c393d29a8615f1914f898526840be11c3410d528ad764c906dacced46b59193347a512b22756dbebb1610e5111ce83085650a4c46749e2590a19131139733d05085ccc388bbde651d6b23453a10e150a5710b5d0efe56f84183475aa27e444ccd48dd3454982c7aa8885187e3bc6cdd3ca4a9965496270ed4312dd4b1e298379404cef6c616ff139f9f7e1037447ec645f4c86313562f9e51006b086b9862400fa02335ca5f1919b9561fdf87aa5196e7e0189eeb7c7a6837e7ff48f2c49d9b96d3aa5df7e51a5608c6058e0e290d03e0a190dd3f2fcc90c74c32d407214a679f23e365b50f0d08ce290c3346cb71a8b58e3668d8afa0f48121b52d04b19d82909e075486889d09aa7d0836f591f4d495a82fde6c92a3c68dab201832379c17082bed7608d0156f334a120a72879e8b73f374bc141101407b5168ac341411d87720eaa2f160a98a3927045db208350ac502aa8f906389c0a549487d2f1a32edb208c8a4ab1fe288516ae37ad13ea04950b6ab7288654c1a0182a1f4ac22869a9151418a24469713837a859a82128bfa25ae354cfd795c22c4b8a0d4a4551f31500ad2ad41aea094500ca0665ada180cbcd433980ea8b87d25a51d2049b415307c55303d0f201e50daaef0aea30a8d78240f9a0a4a7e04083622d0a862c0ee702cab450b718e5a49fa35271287428614769a426a0f0587f851e25f270ec7fa3587621b8a0e05011506a284543d1a6435140cda18643e103c5843a952cd91f0cd6051f2a4a7e384eeb09151c4a0f350dc51b0a78316019ea3d11fcb6637cc5eb2c16723c56225664a79b117c8a2130b33512b751aa6a3eb8774c08a11e485907a4b65fe1ac931b7d33505836a0f808025ff0d8dc0e33650f4739fed91e334c14915401c2df85efe93d86ec7d48cc573c321eaea29310e2716831bfb452f8744fc0fa0d59a28d975abae70c12c863e0e873f6013300b820638f9bcb9c7bad456b35adcd4b1b219c2cd06df7da019bc7089da243151444c63d58571570ad5899d7b2c62138e43b3966ebbbfba15f2000635f939c6367bf0d0603f4285a9b6f823606ec61dc48135d20d038519ca8e36570104257ab196c81a7db72eb2faf51f13a745e2d09702f6d812a5667bf86140a7c01f0e40ae8e753a6a2b0e9b1d6d4004338e340294e17ad3f0b3094c996f319bed7ff3614994d2a3bca4ddb17fea8fcce3dd991d34f468a39e11c167de5bf397e0345a7c7b3a881481be0fa01bde7616519b6c66b3b57dbffc7eca980faed26b8b2bbe8143303db79e9a10bd5bc34bb2be2b93bb93e443cbc49caedceebf1e1c2d3940af1a3b4cd938396b15b82a1af094b62ee517420add866455d46e91e6280b57c2bc628f5e8c22375ebb39a91481e423f4aba91ac4eb047d251f221f40beec90ab8c05cb6aad4f85c1d9a13622dfadf9db66807411c96c005e92b4b9f185a80c67803ea9e0cfc9857d1f61d345c9482210528e7004ac2498d8e2d84a635e04f34523163ee47665f576775ae36b8ca25c2ade2ef03b9adeff82c6356368388e13a22151cd1d0e985b943753fe4fd4ab9c9de613e29d19bad144138c16f705be841f4afed1dcd1aaa2f39a0bfabffeb71fe6fa521e2cf7f0203415159adb0a24935a0e9e20593b0f027208edbe8d9c55a787542693e542d0167382a507c396bb45ebef02f56a1df418ad9c3068eb061a5547f6d2a4c2f018e6fec81a7668d767b149bd21ad6234d4f00be7034f31a8d9c6fb9e55611464ac873918407efcdf9c4d407da2ae1a6c18df82934a57a3872dbc0e01cbab212e78e8eb080adea067294f058ebf458da3012afd0469f9de2009ad1b409ff848b9f30b76c35cde200acb9aaa7d779c29e3d29352a809a436a2a9e6cc50eb4c6a7236bfc8c1f8932fa29e90a7568811f58a0da35d4ce9051ac3727c27d12862cc8705fd7159b2493b874aa6cc8afdb33685ea284b94ea85eea993085831abcd7c679e90e9748ed9b36a590f945ed507365dd79971f2b484c0df41c7acc21e5d41943b7a3d022f4d29f0c0f495ed6810fb6bdb04a2eaf1cd0188c10ac1a0c915b9c3610ac2450a00b6fa7086ee48a55d617059fa89720bb0c4220ec1107ba588abe079784ae902348e1e6e601b7ade1300c7937f8a40003492ca739cc8fbe80b66902023509beff1f469897435b740cdaa401300cd9bb102af14dff3a64812f3f9f8ac4eaa86c4c56c24d52c77929315630f62d329a3d3e3e7592d69e3f7d8aa6fa5e2c373ddb929491fed5a77834b36d144c3f0896822c730282a7ca79c80af685a14c2425b94c840e7d253876ddf42371ae38b17146cdb09b566a62e52258b7bb0eed044e524b8f641a3de985d9c1c2caf5d38c66be83d309f1cd8e6abeeb66119bd1ebfb73ff49e4e1def7964bf63f2a48fdeb0574b13ad6c83501f567d315b0f65676a80535b17afe201e9504ac6d02ce75c45f0b3960ee24850300c3300cc3300cc3300cc3301013080511110da45c92330423ab023948cab42b52bbd4c487407c3a738eacb5669b45daf0174e17410b150baa0b4e06891f3284d893651e74c58fc1b61fc46672b1d2837896f32e88bd23e732e7d49d631c88cdbaa62ef52ba4cb00b1c550b18b741f2b51f9c33e8a65f187ebf1c31aa7c73fc8f1f461f9deec81feb8ffaac387fdc375855829594d780fd6644c957aa09a1ef658e12cb63a330f5296877df0512b5f7a7858cec7871bb5fc4e2e77d826583ccb6591179b1d964cbb90620f4e73a70e8b6a4a4955854a291dd6ff1f91eedbaa0da9392cb1b9c25c4a1d5737392ca5b612aef388c31a227b941d3b70d8d4d28a56571ec5dbbc618b90162465981fe6e686654e23a977dab047cfe87b719187a740890159b0610f993a66844d13a60f638ca70564b1867dd8c126cafd95e4d2d5b08f73b427628dfe783f6958439c3cb0fbf3ce153968583ca3851e0f2ca6fdfb71862dda498456fa30c31272ed87c4a6dea43ccab0ae69daa8310fd463ea418635b246d2f4c79f56ef312c9af76f3da545d0bac5b0a5c9144b337f26863a0cfb78906319e3c74e9b180caba5fd712ceb91c5bef570bd22f3e34ad30b4b57e693eb649d073db00b9b458dd18ad918f4462ee43b397aa5e5b785754a274d56e5cc0e9d16b6083bdd95ea73fe6093853d0f47be438f27e43cd460611faf0f3b5ccc5f6195abb513bbf994c72956d82c42f4f39474bd73aab08720e617a2a59a63a3c29e4f4b62676d3b8fab292c79a079bace2f9d6f480afb40e53b7b643529a90231c4e03136904514f6a1e76da9d6050a7b2affb4fde38a693c03238b27ec9157aa52fab2d0a35c0ea41494a6200b27acc1763a450b893a3f9a208b262c972ac80fd2f99d471e593061cb21d7b7dff9c476ca8124c86209fb204288e26972c6f1a467a10472fefb893cb41ea55c38010f7411832c92b0c58cf107faa9e23e759605128ceb8af811b64b9557a5b9cec2085bd85cce243eee90629c9c4511d6b8f8b099d294d23f88b0fd78cc2f68c55036e910b6cdcf83be1c43f6e645085b5ab9cbc9ed10fe138a208b202c7ebd399e94fcc79407c2d2c3b8b01165671b3fb2f8c1a69fdd9ff22bb7822c7cb0ea9da5bc1f782e9d3b8b1eec2966d21c92ba1397cb82079b791eaad8c4cb3b49dfc1763df4154f2b3d54bd74b06ee6b40b992b42fa9032c0e0076b20bbc82207fb79e6b960194d3fde385872a9c6698e7ea9c37a837df2727aec1f6683bd4f7f90e3f3868e4685aa5830461960b8e92c6ab06548dd9987215f8f87912c68b00f2a2334f3a833833524c943ebce2339ee471632586d57234626eb539c62b1975fd8bcc9be3a770416db8504b5a813e6a3a9a460c62b6c862baca315a68219ac783097c453bf2cdae7c898b18a3587d94f2959ae487b95d1c00c55ec31a5d50d269119a9d8472aba51f43c44d4baa3a352d0d1310315d4318019a758254ec51f8cd9770c570ea4b31d1d0cb8c016444598618a358e8cae5eaaff0d5199510aeaa819a4b051588711057584604628d6a4f92befa4374d8acf00853ea830210f3287cb8c4feca1447e14b4eec244ef8955a342e6fb612c0d61efc416cb73e4c3f7ae4ae7c4969dbb2bc6f8f130fa26d61fcd57081ed6a3491f4d6c97136bcac7a3d85b796462cf3fea1829d16327af31b186e49379538ac1873d5f62f1c16469b0ca4a49b325164d1e3ea45e75280b57624b15ff1e54d809b6494aec3ff428113d965d4e72129b4a8ce8615988e8b791c45a16aae226b2b73e13897d4763e6f47ffc796220b15fccab4b151f5dcce511db9cdc4e4e5371c4f299fa879d5493856c8d58ced2c5463a0f31f628462c99223f75d9b588f57e7dd279d7e58f57c43696434eb64b42a7895842ee36e75afc339110b124fbe4e3918f4a264ee8108b45c71a4f21e571ce218658ae725f8c72f6673f4e211693b066669feb6a7e1062cbe3ee41a5eb534f311dc49e249ffc7e8f228835867dcc19d7fb3ec502b1461f841c9599ac7258452cf02c20cc00c41aa34e08dbf2a9eae80ffb5805fd81a9e7c14eee87f56fd77a602631797ef461cd9b61a6e6327c582275ffd9a474e2231f7b5863cc848f9e7222e9ad87bda36fabc7a37f5339230f8b7559524b96476f7403ccc0c3a69bff52ead1698cf1dd61f58a379f763653de7658256ef261ec90f1342c75d84e6b337adc293aecdf9df17cd85bf18239630e9bc79ad9d2943259d0e5401d3c230eab84acb0923ad7f58688998007baa0c00c38eca3e4c3ebacf5a15c30d0d145170918c3c100e3015b7011812dc8e80e3387196fd86ffe3ff9f76a0e22316398e18655ad7c687f5d25731e02c38c36ac2a17634899b5118f8961061b56d5909e1d99d247bdd01ad6d9d91ec9de848f8997156698a59f43bc4d6ba661a94fd623f32813245f851968482afd68a787bebb5d39c31a3fa7d91437cae46786f2f8766dbf33d6538635cec4a6eb8e928b69327c9b791caeb62b2d84678c61fd61e7710ffd7673c51022f7a2150d33c4b0568e212ecde56fd27c18b6dffa491732436f3c60d832fa227b107af4152b5f58269f6d688f542fac69e2574ffda87adc7761c9159fee3c52897b36179698f9d879e455914bde82b9531ec64587890c172d2cb12e4edee9544ab36a614616b6dd919c3db218e2e661022ea360618d9a71e244b00b025b28600bbac28c2b101833ac607c087edd397ffe2adc25217b3e9d4f2adce1a33ec9d543ef780aa74bfffaadeabda470547cc6d40f254251d092af696c4430030af6d8afa58b5dff13ee49279eae7e23428813520dabdef1dba9cb3a849ab046d44cba1c30dc0b315802ee45a3208c055c046630612dcdfbd7c3907221f84bd8ee7e1c2266484123e5d40c25ec33e1a672a37388abc981945f9891843dbd620a1a9123f5305b70d100167821861808380a482ecc40c2761aa7ab3d0c99b33f027580608611b65dddcc23db3c89df6c4611369df4e156661061eb303f71246d56a65070021280818213c08c212c17e269253231f7303f46185d1401660861adcb3c9e89c957e2694158cb33a66c668e5e1f14c604ac093380b08f3e5a502ddfb31426c584193fd8a3ff55caa77a8e719ae1837d503fa8ce4ea931e7270712195666f4601f89f0cd7cf360d5fefe5df5bad82930c200a30ba79ab183adeff3487ee87918798244c980193a582c8f46c627e79e656c460e68060ed670be9ea447ea113eab9d7183c5fe6365fcd07899fb1936d83cb773a89847e327b306abde4d544b9f3b681e4683cdf30f638839ad4cc33358f2b2c793dd549f473f9821833549cc313d72e7789214420062b156ce657938ea93238561b1ec850f2da2cf06df49ea2000afd83657064d3e887949752eb66883822d4e005cb1cc86fca399faa1add8924ae4aebea9e0359a1202c08a35e7244cff9e86f5a0552cb14294caa34a9f8ebcaa62390b9a34e67f3e1ffc48c55e91971166152ab68929445356fe9e8f4fb1f4286a848c922fe246a6587e935d7e8c5c23519762511f9585c828692fd8a4584397f5b063f47148e98f2200a2d832cf8f5387591a2fbf070108c53213153fa85eff083f28f6af98073e38eb7cf79d7e82c89362a59c2b862d07121901f0c4b69fd79205b1fbf1c48f10804e2c31e4072dcf301f63c789a507a3f9a3f4e3fcd1e636b14ce7e4d933d7038b696229f1f0e1c7cb2b4c9a89356caab5ce3f39488fc2c466163fce030995fbe37d89657e289532a29dcdc62cb1a9ca470d4fd1838aba129b57f2fc83f90a25b63cc889167b9beab4328935339a980f62d2fa8f49625f8f107df0a3da398cc4a6677b31dfd605ab09125b4c4962ea468fd82443981ce9b41efc8723f6918f56731e8ddddedf883d37c4e7340d97632519b1765c1fe5518edf933f7c11fbc4ce3f0a21af87317f2862bf3cecae34dafbf16212b1a97cee9087252262f941a4441ff9f043ec1b253ec6cf2eeb9c33c4ba1b44e2a5cec9ce3c85d87a27e287dae34188d5d4260f721efbff9006b14707adfd8187781f4a41ecf12a43eeb832f9d12510db8efe86fcd9a75579406c3152521e95e77fd8a4635c4b3f1e647ca73a02865837d63a47e4acd428c45621baa59dc17e3c5631c52c5183104b86d9cc31545906b1ade5ebe1a7f0984e0d4150c7d708c45e2a71c37dd97e688c2405643a85a10620d6f8f16825249d8deef187d547993bbe53fe2825ef873548ea3ca8c8608d3eec9be3cce7303efa8f9c156af06189ba3cf04b3a16a13b31f88bab1a7b58c3ac04cd3c987320610d3d2c21270f19e22aa70b6a297958d437da27fd18a5521ea5e0614d5329e73415925e4a133bea564515bb143b2c25c96347cc5fccb385f1c583038ea851874d2ac4c81ce319a3de4a5f3c3840a850a0061d960827b691726656630ec5ac5a46d67a5cdb50430edbfe305c97f5270efb389354a5183eb22286c39297d3c54c9e31f569deb0efae4a760c216ed8c2cd5848922985949c36ec439b09b1ecc186bdb462a8697ace79ab356c17da399f07bb96336456430d650869eae6eb27e5e81a6aa461ab9093e50826e223cbab50030d6b5acc9d33f37f86ad834dd0187db37962ccb05574245fcdca43ff51cab0f48f535a4872f9d14799146a90610b225b711a2b6eccce18369fabcd1f1fd29a67c4b0af965eb44f91c9ab13841a61d8d7c741b473e3a3a7190c7b44aa54aa0a9a47c32f6c61731a95142d5ed82a7b837eb4ccf729d9857df2e6bbbd347261ddbaa011530c7e15dec29a47df9f83c630c1aaa2854533afd376dfe4f5d50735b2b056ba4865673216969e3ccc271e5e61bfba5c1f8248ce9943dc410d2b2c19e3444ffe26927daab06d9c8d1b434c03a1061536390d319d874959eb0a35a6b0a5c57c84f24febdf4b610b4b0bd9954662c84d14f6acb8fa795071316da8aa0614968cb321f25ef0095bd6ec8f525a47a8c5096b8a9572ef45883f3b3561ab955c99471f9a79d061c21a21261fa75c316437b88425c608514b428fec4655c21e7de331351a26862e094b5c7a0e9d3fab4e42c23ed0891e3d938fa4e772846dd422363d2d88f86584a5acf27a5a91b85d7611d63d191faa4f18afe421c22a9df9a9a18243d82b45ab5bd593ac9408611b4d3dcb92a9b18a06614f31133b6558e6f00381b00fe7a30f7db53a7a94fac1da2b3949e459448ef86091fb8e6191525fceb0074b8e8d17e63ff152493cd833473c4eec3cf291c83bd87a7f609f37570d1dec19736a3e9eba0d31552307eb6ae7419c3ce1d256a5060ed6b4d2701e1fe2e6b46adc60cdf4c17e3091ffbbaf61833dc87f8895d3ac90b61a3558c3f56538ed3cfe94b11a34d8d2a6f2e1c67039c17ed498c192d4376df70f3b2e276bc860fd92fd9f1e6ecef34b2cf6b1930bf53dedf881c5921583c41f79fa616a5eb185650e72f1831f76aaaed834e592ea61a9653e5bb14c981e578a3c1ff33865c5e2c308bf523f1b57a6556c7a39577a5cf9f1284455acd9b9fe6f3d8f6ac452b1da7f8edb1b7b3cfef16cd01c773dd8f8f42916bbbceef015492556a6d8ced2fa70edf4526cf953728fd663f061fc90620bdd3991c7ab9ea5d151ac1de34feadc29d1434814aba4b4aa1ff24308b343b1a6cf9572eae308ff19289691a850797f9c79dee3136bc61f8ffe7c3c3b1a2f9ed87f2c8650579372deb5139b8fa62325a977ecaa38b174ee2afde1754ef9076e62e98f792a669626564f9ea19972541ee7a199d8ea7a3cee8efd438b1113db5affc0734e5e023fbb64a19a25b62f1f7a083976cae34fa9c41225ede2f99f45c71015685062dd28a1bfb2e4437f15061a93587e24a9c9468254ff2a89d534a464244e6a9d7f712fea051a9058c374d27ce73caa9a700b341eb184fcd1e310a711553d8ed8c387fac348161651728dd83ffb7adc753989f68511db06dbce9f6aff7dfb8d5186183416b124599dff719de4e14f08550a0a0b3414b18fce2a55fe1fa589b049c41ac52c8f7ea03924c66f80c9810622d6fca3d91e5a30efb5107541e610fb50bb873efea1dde6565dd0e9818621b68a1fffd487568f72ae0b4a40d028c43e1e8ad74eff20844c8c071a845865c63e5642850e2957ac0e3406b144ec91b253bfb91fee078c8e0e2e412c3f0c93b1c39ef9e5e18158ee9369678f0f40ac493b84491bcd7991fe61f1caf883a8216352abf8614d7e39b2f2a53c296c7dd8fbcc530fd447a94731f361cf41e77c9047a93d2c1a345ae771ced5294f450fdbf478a78c57717fff3c2c696545523a78d8a7344b437f143ed3e30e7b45bd58b52ecb0d3decb004b1b1ec743ec888ba0efbd0720c31fe3883e6b4d261b3d0e3f156764aba9fe222025b985a038d396cc9d262ca77ee14ab1cf6d9e9dbeccc3f96d4386c157307339d51d128c2614f233fb40c99d3fe756fd80731f3e481dc579adb0d5b4ea9baf7316564326dd8c71573d5e4f9e1fc60c31a16b6c36c28d994c71ad61ef9468a933ee6d4b06c4e41f22885bb14671ad64df3d39929d9a1191af639493b76599de1718ab58b494432c3569ef47cc7cbacc79561df1efdf06eeefa8711b9010d32ec97e30f4cafac939e670c7bca91f953a50cbdb0c5b0c4581f31f72278450ec3b0fda798740c1d524c0a185c0f1fc3a40a21c12f289fd124631e26892f0834bc90498e94d3535a6a0c34bab0d8598ffed7835cd8624c936e2e26bb92197001f3058d2dec1b54fdca36efaa242440a0a1051a59204897c5466c92894eb015e8e810e30bb4010d2c6c51d5c6b636864ccc09d842011d1d7785cd629ecaa3cffbcd5c8b86154c177e681de42e6866021ee8e2d0a802124259fc92a0800615f6984725760fc2c7b4031a5320cbab52696afeadb92a9d603174c0700c18c5808614960e5b97298fc354da1e85e562ffa8f35c8a8ffc81c27e7d39a143e6f17890c24f58443262bc2a73c2aa7df53189f838a74f4d600c1a4dd86294bc51891b26ec5911f7830a2952ea5172201991f1058fc11578808102061022630463b0de03682c61cbc9d1427bd5ff7657c2b6ea1372a75d189d1ea0918425f58f72e6f1302b7610cb21615fb3c81ca2fef092ae6528a07184fdf3b82fc51c1f76c934c2e29926d5e418f19cb622ec1fcfcc2c2496f4ef4458f77ce01b93a843d85435a37e1c53f8b4a12184e53aa58eea1573da89680461ab4db3d9d8c9ebf358d006013480b0fc28861f853ca8fccccf0fb618172c5a269fccc391860fb6554f8df59310c4c785014617fe20811764f460d1afb5aa92e851afcf83adefd3c6b7c7339afc1dac1db747ebf9a6642eaf832d3b6808562379f8c33e074b30efd2907fd0696c1cecab9f479e962951e71b2c3ff494d2e474598edd06ebc7c995f2ff78fc9f741a35583a52bc07929d61724e83065bf568b4563be6fe414e63065bef7c8a52c9e9f0e3d090c1dae39c0e1724726d7d62b164f474bb5f212b9507164bba546551baf38a2d5889e6f23cbebcbe2bf61fdcc9868c9007716fc5967c7062398f52e7d479b062cd7947f4f2a8c72a16eb615c86d38deb7fab62cfb99a11ea772a36cd69233374fe28ec46c57a9b7f29a66cf2a8f429969d4939ff3fe58faa4db1e6e8a39ed5e0c3fae1a5587624fc33e5187b3a29f6ac18f230a41f5a1ee43c8acde36918d5d1eeb159144b0f73cea34b15ef37c6a1d8c47cdc03bdaac877312896951e549098230499f8134be46145cd0b7962f11c37659cf938ffecc416a21e1b9d7e3c9a91138bea470d6b1d2f4d70136bead88f11b53c1fa39a5872c87b1f1bcdc492237d9c72f430cf674cec693cfc78a4715e62fb10347f14ea727b98b4c412bfc18733d3b531ca4aeca32affa1e63c526289975312cb7b973d1e27b1c4ed850ab96b62334a628b1deae3d93a8da9c248ac41a373a5309be24e0889257488b7b25e7d27e123b6b5d039ff4846c4f439624b399c86b9ca13acbc466c113f4c912ef2307de031628f1ea844fa308bd8c7231f84ec14247f5414b1254f1b22a9420a21bb44ec5172b210fa73f78f88bd471f6262d7e47c887d243565f731f6d919629d1ec594cb54538825128cd8f6d46273d42c62ed4cda21a99248a82cd0841b8a58b253748eb71ede4884213710b169ec1f4674fd38e5ff1c629f900791f2ec68871f6688ed22ffc876e34978450fd7404707f5e146215695a41a62bb9e6e6c92c009e20621968b9d9030bf9d92577bb83188753c7ee4e370bd20b61f86bd10343785df88811b81d8bbbbf2ee0f473a8f631e6490e08b4206186e8230cab834dc00c43ef2dc1dac774b3cf97fd8ce522d865429ecc7193fac2a7a33bb71f2851b7de024e5499691323150707c01c7c540c1f173830feb99c71c6c6c2c7aad1c48445c1c30bc8c15d81ed68e58a595ea4a83943990c008233b3a3a3af4b0f5a8330f7d981d2c35dcc8c3d6a3f8cc75d617146ee061cd196397944df94fe6b270e30e7bfd602d459f68f99b41c30d3bac9ac287e8cbb8fb0f86f16090a08b3ac38d3a6c39254b765b6a359d0cc30d3a6c5a21ceed96f830bbc71cb68c31599a9444396c59917a1492a79fff897ae1461c36b509167d6b29fe8f5bb80187c5077f397c65e548b9bf61cb93dd1fc578445ed80dfba5f9f449f47b2479d386f5d2e6914795ecf3d3d8b07548b99d336df2106237d6b086c7184b9ff3a2f8602356851b6a304292744aa6cea43143ca8d342c26a3963e53ca4d4a550c37d0b07e0c3df81abd3d2b9b046484518133ac412bc594298ac855ce031e30029fc01724e8e8e8828ceea20837ccb05f9afae8a6be0c94c15e30a0a3030c2fa30cf6e23b3ae84619960c6121794794270f090837c8b0e5419eafcedd3cf81ec7b079e6e893079f396298c4b0870cc12325fcd0762339901e7390c10e2878230c4b14898c4124fdb8c77930685d2966f530e70b7b9e8dff98239485e885c5ecf643c5d03f57f92e6cb9873ddc18ff34e6c15c586c240ff62e6ac8b46c61eb1c3797a5e55a58a35ec7903e79b270da38c126a3fac0c23e3db4fbfe9d3a4f3eaeb04e901e76f96cc9950f2bece3498d1f968e5ee71e55d8a32e540f7b60bb1b642a6c29a967ecc14666aa780adb678a8e1436cba3e981a5feb0075146618d991c5285589a230c852dd85d5eab9d64417dc23ed0ccb373fe3999844e58a32e0f3e5cb089aa69c2aa311bd73786684dc784f57632e6b92bd3b1cd12168952c1279ea44a8a12d64c796c62fcec249484d554b752de7ae70a0f3790b0e5ad90497ab4c729528eb077f26817cd6346703edf0febf25f84adbeab87311b11f65df18c79a21ac27a2165e437fcd026870861e9186ca3e6e9c70a93206cb71de3c78e47d5e600619124798357c69c1e066570e3079bce06ebc1450aa934e4860fd612cdaecf61ce3b6f4cb8d183a553d3d56c85181f43861762f0182a0003055d944223dce0c13ade11e9ba8731c2e5bce0c60ed68e95bceb326b57526cc10d1d2cf5613a43429ef91a557023079b07b39f0ed31de7f238d8e3d7ea6a74da10ffb9c19654340fe327c51012b6c15ed1828ff3782de4614adea8c1f63189048b98cb34863768b0867c44eddce4e1f7bb3183b5ac43d4bc3a9b5bdf0d19ac7a792167cc034b5b97582ca6b31e33870b2cd6ddccb99e2152b8fc2bf6e85516baa37abe985cb1c7dbcb1f27cb308d5bb195cdc51fa7f8c1e492b062f90da9ff2e7b1c2afc552c3231449d8e1f07f9e1aad834fa93c42affb4a0a7628f14a2071f764e9f0771542c21c7ecd0d1724eb1fe6705b5dfb0e9471d532ce9d51dbff207157e2ec5dae3d00a6ab107b17b25c512faf3205ac63c0879d1512cc1473eecf30d8a621f95afbedc391552178a2559c4ac8b947363c88162915031357e623eb1750f63fe61ae181e2fc5134bbcc839f6f347bfb77562dffbd3ae7871628b516e72e8d80f35bc892dd76f6cdc38010f7441860d4decd915139aee340f5326878d4c6c51ad473996c2a594c76362fdc16dd6670cb9c2f74bec1b26d25f448f97fc63893574e6f638637ffa289558fea2cc4e4d0e1fb40725966037f98719ef496c3aa19258d52d8935fe9ca845af48a5e948ece146f7fea2d483a421b17df820e741b08fe91b7ec4ea831ff7eefd8ed873be9cf8089375126dc41ed524ff782f2c44728c58d344498d2a1153e598452c16e2d25f55866ca42862c959513b39341b89d856d4c28444edf8a52162b535bd14db39d63fce2156ab78dd1bd4c32ecaa0c0165c44608b132c0bca2081178c8213784747096c18823adc462136d14cf5bf16030609bc3860b003c8f8e2b1022404750c823a8e6d0862fdd5f53dcbde8caa8d402c193aaab6477900621ff8787c2ce031c660f38775edc22c798cf258304619448936fc401d2bb0d18762830fc5c61e8a0a6ce8613d930c3af3a5a1c7311fb091872a02d8c043d9b8c3ea11e7c765533f653d722075748cd1d105032e60881d8a8d3a940d3a6c9aaf2b6647cedbdfcf61fd4bfb18773dcc9d87cb61b50ce7e3906877b1791c36b18bfe1d637b25e270d876734c775173deb0ccc7937427ea13abe38655f220a590a772a4d78f36ec23b5ec54ebfe8fd0830deb76c41fa4b8eb7b73af61bf4876694c52f9e0a386c572aad4f04fcd3c320d9bfef872dae7e8392f8c8665cf72f041078ddc159f61cb14b52a5a9b071155332c1dd15338ab682b5619963451277faeaf28a124c3da511ec77224c7b0c71fa64884b1ecef2186cd728c3e3c29310cdbfef007d2117be03f0ac1b087cba13cf3340f26795fd8c76142b4bc394266375e58c7f2403b23b3d1857d38393c56c9c50a39c3852de854768fd244f961660bfb707fc2c5944715225cb4b0c6f3f42953b46461ef61ed8fe256e5eac7c21a537cc6924b6a9bbbc21e2777294fe34365acb085189188985bf9aeaac2923b585acf4c3e8e93a2824143fe70b2fe14b6e80d77d329e4f47129ac751f36736e48254962230a9bc60e5e936216a3c7160ad0b20105820f53e7718592d260e30956cffa00c01f6c386109fa39c7308d5cb5d51824e00a904106958d26ec134385a83944f88aa11c486384f15d381824f8620c2f838b2f1e1c402a6f8309cbd7f4207c54fd1256d3fe0c29feb0a184d3bfc73ff0619294d2d1d1d1b1450522b0450522b045106c2461cb0a1fb12185a480045ef8c12db86800188e0124ecdfe3b5d891b598959303c9045c465ac0c611964f95368694be0bb833a0a3630c1f0183c15f74e1fe39010f7491021b46d8af3afcb06fd259972549106c1461c9d36493732486db2f07d201c3c92812b04184b5c43a43ab2272fcafc3c610d6489bb19c7be3c5f45c0c0c7081011b42d847315aba0d1162f8492e086b8448d7a3fdf2cbef80b0a6cce3d518ba2bc7f99103899c8d1f10e44272c9aae603eaf8c2460fd68893a1cbc7e1c19231c71f7954f44a3b7320997ad8d8412a7f192ba67a8e91063674503672b0570f2aa63c7e0cac800d1c2c51f9e1362a56d6e4021b37d832c54896878e3ed110d8b041958d1aac61eaa5e72967033668b0878f53d2dafa58757e06abccc40a551235c72e58304619a5011b325873d643ee9c53f0be640ea430ca88c5ba321763c6142e8a3e06e1a2062c56e98e1e731e8f3a926f455de01e6abc62afea618e2bf6093efc4e9a6193ffa3154b0ca61782ee0f56ac61be7bf4431fd5afe6b18ac566c432e7a4371d79a8620ba69aebc34b096ae9546c3e9ef09fe2de79d215154b2eeff1c40d2ad16e3dc572219c5e0e3692745453ec5de143267d544c9b96228f627f12f220522ce317ebd9992c76488e62b3505791820fc2b436a258d6cfaef35dae248762f5f10f66f7573ed24701c53e394d0cc95362c8ff89cdefebfba6364f2c93c13ca4b4b14e2c9a33bb87613bc6ea7062cfcde4ff15221e62b589253ff2b07e3ce30653137b7cb81022479feb6b64623feb7c213e1e49c5fbd4c0c43e3331c5e4e4a3c62596bf3cb87056a525361ff978a7a6934729845c600b056c412cb08502b62015d8a20211d822bd10e30b1274e15e88818232ba18c3c100830457894228b155444b953c9e490dff24d6ae92fe881732c5811a925852c410421edaa49819d58844d5800475940bd478c4fa13e3975dc55004351cb1cd887e929821eaf1aed188354e8c9652737c68c153811a8ca80eae61f93845cb3e66d4bf0ba249d450c4e613b262c49c8825479a60e573a5b19e1a885846c7eb07613a46cc51c0165b7011812dc84040178414350e411d23a8115b7011812dba2832042d2681fc3852a9450cc981543a3a84a08524d68ccf23128bf630ae562be978ca43620f8999df8c21d6f347ec95429e54781cb1ea84766af2badc956e449df1e13cfaa8a38f4761c4fda911d359fa61da16b125cd146717a28a585263c78cf7e873ce3111880832c6a489e35162e640a2811687d87f54397132c2c4983f43e41b3a3a623c9f18f25588366897f4c78d5f0e742f9a045e78c10fc6038a1ab420c43ee8a1858794656a51db81168320f86746f089a9530f2c82204f4ad40cd3ba1e0f53256811082ba746ca6959b1ab4b24d744be7e3c1e78595568d002107baab4de95b2b7e2fc39908e17613c03fee087a547e1c7d1531edc87258f43b0d45739c8fd483e6c3f08d7e3e8a39021d67bd863bd479639d855b2881ef641dd8fcaf8d8989e87256c9049b62be361c9d158b5c82991f2878f51b6e0a20115b8c3da9172b2cb19edb0496c1e86d468373fb93a2c1df2584ae539d54f4a4747190f16e30b1c684187edc6e6879e07b612737e0e7bfe282e63c6cdf8d8cb61dfe9a0f399437ff2e171d87c3ccaa12bf9296ed8e1b0844cd5ce3f0a123ef2bc61bdef104385c70dab7adac89143f88f793cdab08fe4877335f6830d5bf0186b223d9cf8f1e8352c572b7d2a95fb3ad66a5834074915323a04a93a0d6bbed8c9b5faf14dcf6858f2305acae3fa9867633dc366261b2bcc7de7f3716658430ac9faaa47da315f19d69416e53fac0bf1cc91614fc1bf3fc6ee8aa86e0cfb5cfe0f63d279e76cc4b044fd1e5d984a4a074d18b68dc9c7b136306cf1d162f25fdf9890f2853565fea47335fcf8332fec752729d4ec8d5ea70beb5d58ae1033a591301796899572c68e851ccedac2e6a3dcb2b0384b2b6b61abcea399f225130f921b6891857d1ce9b17296c7c292532fe709197ab4dfe30a5bb2c8c93dd8b015f634cbb93b47b5487f79400eb4a8c2da159d21e28765ff870acb8e49f00c1ad39fc1296cfe291bd3eda477484c0b29ecdbe3c95beb9512e147611f8ff4479dfe3c50d8b642ff62eef86c989fb05af271f620cde43e1fe984e57e7353c80d310fc3d8842575bea0da9f92fd1f13161f449eafc6657ef49670c51e6486aff394b0ed7f0c99c7b12eb74fc23aa1d2ccc65f4405095be61e847aae2821f4304758f3a02e0fa76cb5ea2e1d1d0f3058a08511968c1cd136e71e2cd0a2084beef14e0ee973c3c4e8694184456bbb92f4a89243d892a628f1bb7e7c18618c51810f238c31c43028682184b5c7e361bccd832853a1e520d522086b9e18b9423fe6ecf181b0e44d7e1bd4f7428eff83b547ab1772ecde074b6ea5aa4d932686ea7bb05e8ef1bdfc69737d9c074b8e65e134a5bd2041dfc13e3d79303719d7c112cab7477115923b9c8365f2f8c76bb466427770b0e49407ab9d63327decdc60effaca576193999d870d16fdd49d293edaf4e9470dd6f8f281f486c9793cd36093ccb92a79ce608bf9b2d2d4a38cfdb5163258f2751ee515eb3c0e9d582cf2c39dfcf99921afb058365ad00db63aea035fb1e5f38d8cfa9c9563ec8a2d7dda9c96abf726df8a25c647f3217de94ace8ae547bb15cefb6aa3acab5827879a54f1d1d0e391aad8e6722463e8481683988a756d222c77f850b1f5b0e4532cb12f3eecff550ef14cb1f44f4ecb681fca26578a357db01eb21e6f562aa4d86c730fc3877ddbfddb28d60c677ef619c1932f8a4dfb23e4514abb1ee751a1d83f57f0bc1e4c5772058abd62fcf6b87ea829ef9f587a1cb3913fee89b52285f571e51fe445d4894d7a9473a510776335494eac975653f8ca555289c1b1895552300fe9472796d919c118cc4547471a325a137be5f4a1f2d0746e2dcfc41656b9367e1e851c638d893d3797e825f9b8793c2eb10f2be441c89047d2c94a4bece3d2185b312cfd5a89356a42d4be8a1f876494d82ba5984232268b91ac492c9be27dec1ff7c0534824b1e5615ae641c85824f63faf1c1fc447999305896d4ed27795ffa61f448f58fd46d754ae3af9686c1c8e582ac41ce651151fdf37629d105d96c4671c8c58c7f3c8c7e187ff2296d364eae79b2ad57714b17cee51a5eeec78117c24628df157517f57258524229614529a743e0a09692f87d847f73752a7dbffb30cb1c79d6e1e6fa7108b6ac7d8f4230be703090e426cf35133bcd3aca64cd1187706c031883524fd9cfeef3c3ccb43104b5c8fa783de6adc0603b156bc8d89f5810ffb4240ec1f63e59e78fa1bf3fd61b1db118b8d9e1f561fe6a710f3903f8c9b3eac1ff27bd257188db0f06119d98c623946988e903d2c29e5942346cda83c8eeb61d190e5a3f38ae7614f29ef8494b9c3658fc6c3e223f9410c3ee51df6f403899927f257b2edb08ff8ccf73062c5c73aac9687e597aac73d94a9d06191cdc3eb81e60e313b9bc316299e274d9651eb430e5bed87fe41c821c6a455c6c301e0051c71d8873fc8f0f1b89277a8740e2464000e382c595eaad5131944524407c0f186bdd2a2d35396ca011c6ed872a8cc973ce7cbc89936acfe63bb297e783a39e5011c6c58c5ef2ce4f5ce1a960b3994d58718369a6ad83b4530cb3c8e3fb8149600471a0a071ad698b6347a94a307761d1c6780010e33acf32b1d64365d8635f2765434a6a30307199650bdf6db235d8b5c7941c61808387a80c102324a01708c611f4959a84885381f44060e31181c61d8d6634c62a15ea9b11e0e30181c5ff0c2a61e212a8718277b39c3d1051c5c30c61483a8fd70620c1711d8a2a3830117d8420d38b6b044c5947f628ab134c57220610087160a4716b61c31581effc6f079908285ca87393475f474550e1c038e2bf83d0c1eb7c723f9580e2465020e2bac2579d726a44b9f0a5661d33c4e3fc834d71b713e38a8b00f6276920b8be981c439908e9280630a2dc0218514e088c2fad559f17f395f55e9010e28ec192eaae424e93657fc02c713f6107fa6b746ba76fd1c48b705170dc841063be0021d1d6490e160a4551f70386189aac1c7f5a389103dbe09ab0ff3eae5d8b3be9d09db54de0c51979e975cc26279589507f9f3a8872a61b1edf1b8d307a21d194fc27a511191a77bf89747c29ac7934f3f64fc7aca39c25e66a7b793af7c9c7e1861eb51c92185dacc3f4e11f69afc9bfd03fb14c626c21e7a9029e6bd5ce90f61cf9b9392f4907e9e1036eb41489cfa7818b509c26229880fee3ba7c91b03614f5f77a9fc87ebb1fcc136b61375ff3c6c1e7db026ffaa0d19c17abc1e6ca1debd1553a3e23c584b538fe6f6b27e981dec434d694a23833874b0478f9beb2e2407ab788fb6ff82759c94c3c1dea3cd21f27b7e60df60ddcc3c4c8b22f5c34ab1c1da91e753cadb83dabc065bd490692c86d009411a509fc3e64e7f8663065b98f03c7970994b378643067b8ad799974ca6b8a9586cb72976d43bcd133fc1621ff5b83af470a2576c7517f2f073e55165ce156b7a845b4b21a41a70a3156bc887dbbb94eb447e562c93471f47affccca2b38abd7f20ff0391fdf93955b1eda4a798293e7a83988a2dec4e3a3e42a57831546c95fc838470535172374eb1fcf9a0f40797fcabac3fdc30c5ba2159c5c4fd504f2439908818b0871ba5d8d2a4f509412699871ba4d8347c8e9a45c9851ba35862c5934a4d04fb0ed91a6e88628f4e715ab127ce9a6ea15872458a958c525ad201c53efe982edefff86ce5ffc4aa97f634860d39ee853db14628199b0e967253853ab1585a095b21cf8f5f4639b168b859bb0a91fd9c6c82a4db830c61cca38925528553558d1b6712086e6462fbfb71d8c8ef7e4a9b79e00626d64f0d11cdfc59294ab5c28d4bec19462f63c88d394f2a079276516589f53ec262b00d1f3167ba2075a3128b6ecc9bdd153287ec39c84081185a060ac42803051448c00d4a1cc2871c627694085d076e4c62335bbf3cf44a3a926367801b9258226cc6f423c9bd9a2c50b81189ed73eabc3f5e39c7e421b165f0515478ff88c57fa4a21d3295caa61db1f6ca6647a74f58311bb186543cf9ad038b63a854ce8542a248240e08c3c150180c081a73260093140800182c200b8622c1501a4bcb7c1400044e301c3a26301c1e201e101014100b84c16028100c85c180302010068503c16058a00ae6613fb0a55b83a23595dc6206a11b6458ec7a8b54e9817ae8f95fc5bd6f9902bd2a51618c563957c02255d2c81154fac284e4fa62d124439ce7c2297f3044939800cf0a60b731f1c5765bafd750fff757b891830306a97e13179d86213fc084ad372f2003869651a6cdd0a4dbb57c59965f573ddcc1424b2a9d81d9221676cd6f316231fb48e70256f68d1e94a4ddcbcc8e804f97667230316e8866ecbc3f3dd0b36e73499420d17b3945c54f7e47caacec5ee351de6f00c55b697642ccd70f66c7127a298c3c2337da0ae7de2f429f9e7137df2fadb4a584828c82ab226eacfe2acd632819b69a029b425cc9677939e52453a2f72c5c69f860acb5c48d4e1861e3e32b9727b42f63ea01ee9fe6ca666d371f307f1d5d572ac62b292b19a28d7b1fce3f806d9021fe0e2aa8a0b55c466705e161b1a14e0093728551e35acd64bbd0bc5d58535b27f0781c0c56afab8dd0405791cb90486ed465d8309a772c21ca1d6bb0da5b1f058066687714cd442bde2ece5540541747df0c6cd40cb628053a8cb6a32014359a859aa2f5a80c6547db4f54b86cb95cea5a3586e2a4c55a61aa7ed3d3544671183dae77ed39526787594b4fc163f040d9d655bbdee57fc7276b84d651096a0e9130eb18156cb34579a6f2f56fdae86a6a988567601021735af2cf49c1c7d28011928da0a076446d215be68b4198689277128c6c91c049ab931fe4f38c52d5a5dba6076d5b5281ca986cd9dd53ecc329557c29bc502f466ffd3d3be280bd804091f396e6354e8828336469f247512047838cd3efb7343c6e3031f097059e86a5c07a22e1769f5c39bcd359da73e465994d5960dc9736b2d17719f44fbf7c23572af0e0b76363291db9ab1f4001713ed61f29fb26094ae243107cfcfde1491a380ecc04aff059a32172bc0908f2191d2ade0a23c44dcd28e85d165c58e8307db68d746ff9864c3b3927da06d37ce11ab1e769a6efc76a4e69cdfc1987b07a9a36eebef468ac151c099b3023d24161bfe668dc2e9b1ee2b25e9d4b306d4e3a3a657cdfb57f59667cf9bafb6e971525e4832c546ae48c08bc5a75ec5bbd8735d1e3e11921c91d25b5beb5ed993961b912f34305c97c162706714818ea9fa066a2363fe518fcc4dfea35403ec0660774441d3bde7500b77c939cc3f8b667b27ace519ab648a0c1c23fce3f2ec3f8c7c9b1f73f264f2ac4afa449e3295d668d6ced7562ac9232a5f30313517cf45bcd3ea0d746fb3e52546b9905a38039cca924b0112001d382511bbe3d65069e846309a2e5236c92dacd58e0f0e1c9b231e1b719417bfe222ddf0c3fc7238ec606fe372de1cc682c86e9b8b659439107eef09036724191613f28fd5c2a4bfc3c4a620add14ad08fd3876b523c5d104060e511a800d596e6390e4ba2b014ae4b8432dcd7c56dfb2919552f09b9911c6fb6a9d6824eb2e9500c190e8fdaebb348cf6e3d9ec0d5ef285c9c6712dda064f9806fe901d9180f3229c1808f173a91374a4476678ade6ec8a653c384e950f6891b8488ae0ce01d864f20dcd327a73896e21b9531081c2b713dd8257dd57c4b52686333044d4981310800acd303d9102971659895df7a12aa0a9b46e38e3a8fb1216925c15987272c89c81ed18a6af11ebc25b3afbe6ca74c2af6fc138cd9b25c4ab4e3808e7e88e10d074d442b0a9fa2c1d8a8875c8c1ada129c23858c0dba75b4b99f8b8b971a285d8743c269c7527a6fb8d46a78e37d81033a6ebc0811bdd465c1b0de56fa441c51e0dbc7670b24ba5f2cfbaa58ac9263842e9a05f8afdc8fdec4b91935e0ce21c10d603ac7d8d288f9558a24cccf7892dfcb01cea14794dc19b30d4b58774ccca048ad9acc83e684879dbdc00de21165b4412358b586c01db6934ffcf545d63a74ac3fa7183b420dc6bfd91e8f342dcdcd57af4006383c51588d8ce8b8823c1ef997291b407b35ea459d8e19e1de854a8cbb0b5b502ab416c8b57bea3da73898ed3bbb6a9d48dee333762a46829e8304d2a4eacfc5d5bd2679440f77fab570efa7de5af4120da31fb3ffc648157b3d5bdc1e294c377b57890926e6d0647cdfd439bc7855c242d437f9421bce9f3cd147cebc38fe39cdafd608cb91a1ded69165f83233704fd8ff8c8fd29a42f4b2f461b6d9bcc5787ebc62e937751058f2340e637dcb7e718b00e310011500e8fbd640e62b6ad15d3503bf714e2505ff7a2e617ddb4a25058c46de945a14ae06cc2d6aacbf8738a590443c6a83bb44efc7655f5b0e6fe2c98382032c4b5980e02bff1d2259622dbbff8da149a4322532026f20c5ec85fc36406f522d23b6579c6d5186aed3a05b74a8994f976879017e6bf5f61b079b4073841ae4691a695211c87e471241efda44b44ca9d1452143d308327126ed1e0b94cc0dc1a23a8fb6a87a28ef9781f58193d2681ecb3ee76ccb0cf9e31d10f98a789753a988f4e2268af881351e23cea2009b978e53d54c10ba0203e61e87ad995429938cda1a7b0f9df97a1a536f4ba6cfa9e4476adeb0857c6bfa28f6eaa692368dda0330c0e26cbf6f1f6eae6c59cd107e4418e691a27d4561242aae1e12d2de275c3e9fe8510cd5ec7461650e5e18f77822c600686daf51c8774655a57d8cc0f2e2d701d57047f7a04d4a20592bfcca24c10eaf2dad0d25280b3b4a8788c451bc589a5100984ed141c87850889c45bcbff0b11d5cb7bb3a47109ceb92b5d49db9dde49a025d18f44232553f5c36011f128aa52e4a8fc27ef10b225976ca46ea03e3a24e8a4bd12030e4c5f72716a3774161df03d94f29d2f499293c5722c264d75e68a62866e72204719982f111f4269da0343fc91ea48d9231716e4a3f5e08d54d54e3f11da460f48a0d244d63812b38cf11ad5bdb311ca3fba029481d17bdf0afd30bb0690b3e5e4832203b35858b4d3ac8104eba1527319a686b8fc2a3530e136f6add56f3a6dbc9a39ef244cca70e4260e2d3a63f86a87d273658e3dff7343bd67d7e83149580d007aeaf122d5726e5631cf5ebde61c6ec78ac413c35b7103bafe891a27ca6e131ae097b709d3230e42dc7e844a1a87198d93348524095ecf9f9ab252d272c081e380f2e65edd71078d95592d917467c34f4aa78af375c2dd011950d841218c2faeaa682681b46c03ee34ed2c082f5e92505962334382168cc619a7b20cafa9d7a90d6c9f613b52bfaa78b1195921038ef8808f6bef5669bf84759ad020ed1f461e4c515beaa4925e1ab020ba5b02d30449a4984ed1e91125cb3d46ecd85c5fbc3811f9a7a20c48cf0a582268a40a002cb79c25a351df1f5d32d8ec410ca0f729110fea16d1ead995486589350d8016152f664a14830a47718dd5b73bb0456a136e33abc0bded4a6233c359968e10a8b10166907d588f0757d502b32255945402e54acbfda1e314a5f55a4d69959dd6aa776d39d59a48372a2d959da832bc60a02d67ee8a3eb45dc2ad6fa3332dde98b19876eb1d532f96a0182f0589502c4d95128c6504802eed740d56abfd49e5673120262b922ddbf329e6145d4275df676db6231892d0657f207e0fbb92a64c7653cbebc14e2551bed248a24aa685645e9f401c9c11e1d3e63c4d6627baa4431a1a3b72e11df034c8c9550dd569d09cda07fd8a8d0eb605656521813a92f320df25365d5200f3f00802f3a13d344bf0d0907a1c1de11d60066a52ec7d1bc516716c83e7dcd3bcc01edbb360de2911c4d866fdd1c6d6bbf3dd15a281f27e4120cae3f4ebf1f040bb825100221020d8c381f4c6b89448546c37c22836f7561efca7642f58e68a139f0410716aabf9dd2262a92698bcc3f5ae4ae2fb0e645f3ccb0bc383bb5f54b320f00011dbe646de6121dee083c7dec71fe354216a61c623b29d99894625eb94035580e72607c230b41e1617f4a28b08bd2eb0f22c9d40e8223f537781e7d737bec59faea40a9d44e8a1568fd9b27abedf5b731cd6efa99f3a6f291c933173fcfd22d154a0f8de8e0206c6f06cc2ddb63b8da6591f3c416401a140cc8ef6c37fb03f5a6b720e1548c0ce4947a5a1e4b40a7fa0ae15da83a6209329e8175484b73f4499f9c1b0300b2dc2828021f8ac435932c345534e10098dce5056b9bee182825e603a8537b28668a3cf83521579fc4c76512d9ff48e04db16a84c7a2eb5b46ca18821f63194bbbb9eb290e4fd71e836813b40641027a09002bc31386b050cae57d71d081778079801d42f6012dc09352d411b30053400480e705a23580be69735312d28388c0d115bde03e1639146621f8770704370508e9833628eb5df5f34e22cf5fb77297bd0936ff51ae490a957a7bd4baacd829f2a684324d966334a94fc438c775957c53722d1769a1d6b5c3716faf40e8ceb326839c3fa3c0f89e2854b24fd1dab2aa9891f73c69d5dc3c66ff6561d3b8f4cdb549f413c2650aa4b994fc373298ba76d6a296c36c2dc01a49396391f69ec130a0ebf3273ec18db027f88b56becb6ce56f5f636eed6efe92ac6e96437632b32e55ee22312e065d8dca65eea15ae291a7420977f9214efca1236ab3d62ff757017d7ec9fe42bf11b11a6f7c61bd60ccb4d2eefe3e9547e6e82166b52c1d7ee452267630d4a47c7b440cd2cdebb909534469d5d20b70a7aa1fe6059ff167373138c95e539346ca6af4a2556899f07dc5bba48df5e07461d5e094c8ac03d39bdaed9b442dbdf9084eab26cc8da649b338e765c2fa48cf17091562e3703a0f0d4f5bd69913a1f3a8fc79bf87581a2f3b1e37316fa97edd81f10046580df296e81b87e76cf003be34cc01532aa68a5e6905357516fe3d0d0587228b16b6b0f3230e95d6c429bf06b86ec34b0bd6b65e963b8c58532549e1c14c9e820fc226c6f18d055e37c27e4a4b16ad371bd61995781dee04787242ad0aa109b6d682f249520a37e952d79e9041c3fcca0bc3b1ed9897a6d967b9b2b2dd65c943cf38008286b7df9625e33f037edd8f08d0ab28dcf46d980c68499801533e58735cc8bde3c02d89319456142e5a74d2ceeae1ed228f701cfb02cff12141621d2dd993219a9ecaa41483608c6648e2669bd4307dc9e88447146413b7e8fefb9c4eebd6bb7c71c84a6366be3d8adca458d5ced5b9655d86c5dbe12976bcf06dcd9f824ff6a35ab349f65eda128ea7221d3eb0d29c94d3a08b708eb404bb28497669468e48772f842d611fee666c3fd020fdd5bf203faee690f7c4900ae992d7b407aa0027558353c230017058632b138a6e55c3953aad0d4d78e550757b46af824d654b816e56db50fe4a91d104a30c5012e651b4de1d85e0577772d327dc8c5ee1cd067a681437976a8b8c1daf6cfc80e02ff36133fb1562a87be6108be7bcec6afde72213aa2e1f1fe601f7d02ad127d872d6c1c57ec979f0b1fb3933188581971071b0e77a18a53a2f28d3c9fb3f435b29ad821b0d50fe579888b011d8ea4356366691ed7e6abe9a7aadd606c635f0f05d0f7905c248cd70280c9966edeb37e1c46cde39d1dc3a427b649fa5b50a5f121ec5693bd4d380d96b43622541090c72a4c88c471b5b01ec167f4d06c7888245a0e9b306bc46d61af8800a098d242f0c592b1dd339c085e3b80c5817d1a882d005aca11224a28fec036637153f23815bd17eb2f2033b7fccb1697fb56e2c00cdcb72292086d4e2f83248f9b7e857fdb23133d3203ad1abfc0708e7607b170d7f2fbae9e01745d92065bf6e79ebe7f7a98c8861a64ca51ee052a02c132a621e6a86bda1f50371527030a226c16b642adf7efb638efc4e0c8c5c032026be205daa613f4e8dfd600da0c9f12ac90f62dc65431436a0f6db47cc6ae50ac7269135a622b5a31ee0872ebe464fac2471588911baae6db0039cfdbab9a205e8cf1ff48c13c56867be5ea81ea97cca3c32becc636df7cde12b9ab202294bb2ad0663c3edd32075c7811a8a85bbf75cac5dff7aad7b70d2b173045c3867653a6ec96e5d0ce10a622278be445463d7913ae99856b20f160feb02f6363a36d103916a3be16d0b4610f31b4917de75a5c90298d9f1c510f77cbac398b74b293a22dbb1b0072685f71d3d1f26e5ee1a707d49475bcdf67a896b71e00863b02173604a5c5378c9f62b43523b4e0f7e3b71a051b2ae2433d56a47cb383c63d98db10e3f00974ca77f4668bd281fa479eaaf7882e75944a33b274a8b3b86e5886bb7c8f5b43c057cd78f5e245c1c2f0aa8b4451f7b1c80f11128fcc661cbde1b70072c551d0d15f40fd39a40646c1016ad7199d0d0ec43832f7bcb10d91918eb1b3133f5f60fc353c204dfc6df8f0e4e179a00bb06a0dbfaf6b7957d437f32cf899e2b24da80c38f759e6790d6e6669c9aea5edc7a16345bf8daaa6c4d52e6b7c3a454dc5e5f878571e5aa25739f0b7e9d210b149fabf170ecc9f2515902fac5323a890cff270e82ea8c478edf89ea5012440b825fa42c9f47447f1512c13a41e3302424f30bbd0dc8c2743bcc118f05c322587e15068199f5bd21fd8e9be67008d21705085dcb995817b708013d4a825360b1d49d9414f03b02b898bdd6b44ab75ea35d8c31abae5e64b6722af412a1a4d1ace5a1a4cf7c8272ecab5f2768dd0b9215fe38875e4d57ba381b44689351c75778675eaa1bb64c4ecbb561da2e3c1366118f2d4afcb90f1a3f3ff482518ca2dae15bde9f0dd447645c6f428e6c17f8f13f5f8a3053acccb838ec55ca6c87cab82ff3c6915033ff0e42d8b5a070c12f366dcb196f4b60dc06e2dd8dbf25c8781c437dc477b02983aea440ad9eb11829fbd7cda0e906145b278d6e92bcb486c68bb860d183113dfdae8256948a56167e5a00ae1e9f6e34cb0b6dcf3c386f47740dc2018f24fa195e0214368737f34c14c7c1ffbb12a1299aa322ec5877d50186bf47a64067715ffb2ccf5c20e615df2cff45e951dfa356b323c58cf701c69166909a6806f55bb213f378c226bdb9707c94e2fd61069c38c57504b2ea25651befa83e978ddf76af4a270bcceed23077d2fbcc2787178d1f092fb6b194cbc570f2f74ee759456c449635deab57d081e97fdaff82ef22e625dbdbbf4fdaa6b98118c80be3ac13479c578597b217a85beacf4d9946918dc2da2565caeb20a11af37afc45e237971bdea7bc17929f73aeee5efd5bc7e3db97a0daf31af4bbf645dd871458f9638dbd711a4036a0889ed49de56d9d8a5c196d713050d3c7baf92889a85d6b2cb2ec6ae165e6a9924204d4568a17e0abe9f3a37f93166a0edc048ccb6119b1900da43f845b4f96f33c3266a0e645212211b1e30e00276c3f50fdd19b87a88c94b79346c1daa6ca9d2028a0ac45e3c3d38370406f81f34e703b94448ef154eef88e0c10fee883faee975d01d7e95e6c39759a5a5312d2314a4f26f63a909d290f651daf4ee5b8ff9550343109088b3689185f050bbee99fafa030b3a5ed3a56476beb4fab3f92447e9d1c492eb6c3448e0f3f01a6b79371bc2e70fd84182cc33e76be5c7f8703f628afa63ad99cd271ed1f9a3b4f08837fdb2d166c8b9fd483d04aaeb59de8c2e6418daa8fd680f33f40742c7f1b913865a2ae72f152465a4f383b659393b3b3142080377a977f9f45d0a27d552a9cdc21fbf368d9611f327af67e539798d0903fe4cb2b287debbb2ad8e09567121a11bf31647bf547ee6afd6e17f4b56b38f2b25964797502a8e36e7fb217a91282ff01b31b1c75f674fe001580213869d0a0cb16f82af5461082a049000c919972f4f2ae897ac3c0a4b08951d081482f2452f68f3d051dd580635280abf7265b23c1209bf5eb8206d070a46d04af32f1f40b8117aab52ff7092da46f354c0a814da796a50a941036c9d410dfea555c1326568bc3a7523432b62e5adeb86346895c1e18e815e665769702d9b66088ce2c428c20882ee05ea5525109758032bbcf32a41720e3caa3400e54b0e63c352f68a7dae665a8cc9319562c32142b0cac4ce3e0b472e3786fa17cb4303c19d6c619bc0d52c92c692f969e43bb5c7315405573c4a26a49da9e64470cd6b9388d508b2c84165ce462f5749e8ab7fec1cfe47f4cc0dfc1fd3548608fe787defc32bb41c8f2449b41708c2e30ff2e3ecb83d1b7a29baa73cefbeaf775acd76f45303fb987b10aa1f8ae2074993aa0c496ce8582d81056768503242571b1df7f99a6d494bde5c30870975c248b072aa8885be3d449d61bad196a1838b1ae2fa4893c65b8f7c70d8a41f1a6afcd4df0ebe0436682d8b51d80cd5b014be94d50b22f81b40e2ecfff5b31582bb360c95243df111fc79c32b92783728237a5aa0401cf6cdbb7f9e584b691c748f56157ba0b5e3dee30e7b0a1f947229256128ded497854d914dadb47afc5cc80cd3013c00bf3ac05fc99f7f8f00fca813441a70f6b91c44663566590a8053a260599f6df2a2beb84a90fd1336fb989c94d6168d53cc31e9683a59804834829abeedea4ee19d0f7e5104dd49c98128f894de7d0c317d1cd5fb20d30f94b8a08eea8b8a882e150dad6c19691b3b321341601fe92d5bb98124f4a15fe843d9f18ecd13311eb22a8cbb979a705c6820cd5c73803eb88eb1a4bb05d314b47b7d8e3a38d78d1e399e44ff0886fa52b8256ae3c10a9ad091a317ea663469bd7be65034e073cc350fba94c6424e14c115d406118e5c54a7f862588e2e484d65acb423c14f83d923f58ebf0e9c3bb18e9f1752cad393f97e7c40bbe883288c83de1882a45de672e1eaf86fa53a09f21e36ff63d532d0beab15b032378dadb3e24d7dad884db6f0d49e44c680873ae2807ac940c344d356f91e6b2b62a8549f7e9cb928e0db1d08c3eed07542f167839c2889ab65d4a98518577adf08e3ac8a6b62655e19e87e402b9e32f38455331cef25a05a1575796d4db6f4890cebef703f215341ceaccfca91db34e6afcb243769cdcd3887a011c420844c62536982301ba67eb3d1d413c01a2baacde4cd9f3647a4182139d94c6c66cccbf29cc920af7512e8e01316253025ccf33417d5e9a8cd5a40473765c05aba16c0646d7454c4f1557c18a076de76225701349db2298b9d0df38fe326a6f3783b4c63cc0993396f3b4811c013f0cc581d63afcb25e9e7baa6f83cfbf37e6c2136ac80bb3f9e408321460ff6422381b80e2353f6f90d19b50de2c91e81a7bc7a82bc3f04102c49e5584c18146142a17249e449fdd916134c4fb7b8603fbf61bf4e876ad8a5ee6657fb9d7f693fd6e42ece9bcf39a301454ed11c5407278819d0cb53b0bcb7d173321bd8ed74ea1a2334584500d8354c869eda32df5bc88cb7e5ff3d37bf4358013bf82d4401d114aaa605eb32301e2f0d32d9bc37da0c6664c8b0fe84a988174a2fc778df8e00ca33f1ac6e985e5d7ff78d3c09285a37f42a7f8ab9ec31ba33da8b339a0c11ae030b62e96ca64b1758eacb699dee2c69832538a071df8cb4350134b9d0e684c7f6f54bf0df941665e8f0ce85b45d2b2c7a36693ec7984628fb7db3de29621a27eebde4c52d114a9e572e7f40f77568605dc4113ee903047c638c4df7d8961e5058504728a9b78b903b619c7235ff655ce185804134873bc278968edfc74f3591d4a10683a2183aaa18ec19ac8210ee9cc21b45177e9b349abdb2b9faf0a2dcf74a994f75ebbfae4ad8317b12a79fb29868ab48f924fc64839decf80cd4ba54ca4bf55c42d802dd3756bb469a9b185b4aed6fe32eb38c60a2f190a8c2ae0efced53263bc08afb4b0bdc22e54ebc102e69ea8432a920d6661a7531b699bb622b085ae7cd25674f2062d5e253445e318dc2ed5c30b8a0ba7863bbba32d53beda9a4c2d36e2ad0f4aa55fe9a50d9daa950059d1bd6b62fcd7c745446b32bf597605bb4b5d6548c27bd88e0c337f38c9aa163fa687d2f7bff44c074508da73fe2ee57e42d210c685f30e03e0c0c28e3469e7c0504f460e4296f4e290a68cb26da0f13860042e901a3c2ac94dcec57e0fb410635c2a1266b639bc68eb01c2795b05d7c10d5e6baebed360afd06c99c00119ae64a1b765e47f422e0fd3e8d41063f38e96e65d2216c82be981db5faa38697868cf19cf843ba3d3372099035a7b35a1be706071be7811bd352589871fa625bfc28773bf24911caf2c565c8b0602c335f90ac869a35f7882fc1ddb4cab1835484b6f8fe66668c6570cbf18154aad491f685ce41d730aaa7b1af8f3913c7ef5233f984437093b2a3f161811b636f6cbbad02dfd48c9eea645b4789a7893f0028448eb64361f42d0250d5f1e27b5c664b1a9df0d47dc5e28aa62c7524d214a70965a2bca02bb130f1a629455b114e500ea5893ae10df44429f1b715b6d0efbbfcd9bf2f303155c8f37498548432067401d6e5a57b63baf5701c10b3959689dd37f9eca008f3b4cbcbec5d24ca24d0ea6afd4aea4d345875a3c28b1f7eca32a808c685a52a316c9921f5282a4e0279e75ad5868a3831df4789364959d8b4ebb57c37c740142232405fe1cce004d17258aeafbddfd2916223cc97778a429aec02ea66c61b815d43ae7e88a95bf1fbfa918134c9143843e5b1abfc339907e23a88b15c59349b31f1adc4dd2ea980d38387cc08b91a148f199c9f55d856f339643f38a1022a6ec0486f791af8d17a3c90857c532cdb2cc22caabfab2ecfef2e22ff81c133d9b4d045c99cc8d47359fd65d3f1c359ad65a500424ea80a896a74844b11e36f56de8655a77d7ffde9467e48c5b5d31b28174030e8827da37bed17fd2b4017288eda634e5b4fb6396ec15fcbd7a29fc262e17e7e052b6ca30fbd7ac45af9d6c0b496e45b1e8248bcdbaae94f0b624f65f6b5cf0674fed9ef05cda4f2c2dbd04e3573134fa013ab03e0f05f7134374796503c1eb3ea6dd9d947cf364e5f1dc0f9475cdcfe4397a6f0a0a092cf4d1051c897969b0ceddfc2be3780d845811187b87490b940d1d326c45ee91fb758aa77dac8e96254a5e23d92a0b74c21a66144325e19f3fe835fcdc0e831f2fc9f849d91245a6685141243371982b0d9d0bf918d1bb6ffa642dc131c7252440f214059f6c368cb2bcae2da8a6d8b8de21fbeca61d08dee8cb7c10371462ee1cc03f8afb92f758aa9e88ba48dd537025eaeb102a89e4548564f0e7bbfd28718eb59000c59dd071df6ff95c38a10bde328e1e640dacd942548346e94c541727ecc6888258b3bd4668bdb6a48f25289c9da3813e6e887522108c4a44a3bac08479b10eb25dea02fe8ffb79712f6fbc43e4a82c795fbc4b3b0e94d705fe58c5ed914f8c9164448a3345df56b14a2ee51d8d23e02e767049a169804aa8e0a0593fa15a3508a2c2e1c9eca51889cc531e418a417b1e54f41d8729521962600699c33ba980c091816bc2a2c841a4699e45c1afca2f955749c9c5afad24905801a9d5210540847ed49e943c5432187320675ef45d1e656d6a8098a110a862876525618caa58097b8962b55b4287ea97ea81a500c50162e0ad817b738fa06a8bec2990ee9114ae5a0a670f72a66f0a479fd1e80ca055507351b4a650da5c3022cee1b8a8e50627f1a1c08038e7644c70b3a50b46439fcfffffffffff1aa4a81fd4f48a21a219feedd649249daf3ea245268644a32a594223b1c1000100090bdc9de7b7d8d02380a00380104ea0bbe0bb40bb81e8138810720d02b5ee2b5d27cf1772959ab718191911a36fe80dc98675ae7c5769ac3c30fc8f49c626d9ed478e296acf516de8569c1a30fa898af554cafe3af4775113cf840008f3da0b5caeaf555b1f3d7eb01157d3b9ca6e032ba9e3c205f85c6d894597e53cac8081e50a3c16c8596ed46b129591778dc012df3d5e5185783be5ae06107a4ec8f17b3e039c5850b9315a4171e7540bab8b629f1e263de56f035ded0081e7440c6a8bf3a698f87e03107b45655f9961f7541f0900342542557e2ed3665c50115b3cabaaf72b7ebe0808c366629cabbf2d52a256b8fa3466ba107048f37a04f5874dbda95596577034aa717d3c255b8071e6d40daab58ebd9b39e09950d68cd5859ab6bad16fb536e071e6b40498bf9b2c92ad9ba9247071e6a408a4d5dfabb35c91e9b060d1314a401bdf9e446037a57637e56f90ca82c5fc729dd32ce818719bc0f27578b1d87c98d159401a9355b4cb93c378325ddc0830ce8131ffb347c0a97e55e320694d65ab56ce52c5e7c9335f01003f2e39c546f513537cc9330a03567dd39ca9e5fb95ac91a184a97e50a4dd589098dc76152b202121cafc517109a2cc5ff98a4818717d09a52ceb595a3e6db942ed8a94ca6f8361f179049b37e69ecec68ce9a81c716909dd1c4a793d9d1548e8716d071f1cd92cfa7e051ef910554d44acc6f3a7d8f324d19786001194ca554d27e534fbffc028f2b20356c96b8f849ca05d10a28d3dfcf9d93dcd61957e05105943ecfe2b9654d8a6f510199ffc656dd7bf3ed3a056492b933b92ccb9e749702426bf5c367f11c65e95140c9d0701abcb3e39c121450efeada552b8c8f769e804c69a35754a976ed644003d47b73b1012f7e02271e4e40db580cfbac957e52da2e3c9a80d6d2a4969df2fde7acf160023265ccd5aa1665e68b5a0252ade73a53cbf9992f906fc153d3a4f81e4a405b509dfd1f175d8398048498748b1db3be58310909e895996ff76ddcc071f26a950d0b943b0252eb58e149ee7aa9b4d55846406bd723b2f1ffeaa32a02527efc69d0cfbbf9393ac38308289955a3625abc45d343407970996b69b38a6f2e21a0cb55bd6ed45ecdbe6b18f008025af7da68ae389ae40001a1323fe567d0145dea256b376ce0f0e7e2a486c9053c7e80a660a6e7b47c902ce5f1e5bbc598f2e8016a936a7196eb3ca55a4b3c7870ace0aad9ce84efbe034f9c57fa177a5199cc3d7480b8944cdca3f47380d452bf5bc924f3ba9f161e384026d761f3748eab958749e0710374c64ed98c1a4d77373640bb969bb516ae2cff99f9008f1a205de5d7a8e329ee928e06a8b049bfaa0a9ff9b56a06a8a8dc7457d8a8b7b797f390013a06ef4b26ec546ebdb2514323e0110384457951a7b8a55cd3f70a94a98b1556ee5fcaa0f27578e1c254eadf0ab46f8c4bd939afaf59ac40ea94711ac5b2ab40eb986f395feb7f558eea50055a3e89e6c6b437adf71b3648b22315c85797750c1b430774a00299b4f6d07df358a0e31486f7f15acda9df3e0a48ba78bd2e3a4c717c0fbe154f53db820447175f038d697494021973d0e01b26bb6dec92b5191da44089b19c365d7db6241e8f023d3b9b19857950d0210ac4bd7cce318acb8402a57aa38faae42aaaeb1928909956a6685ab6b2c61c2d3a3ed1e1091be9e884f59bda4556871336d2818e4d2057c6d4f796a2ea4c2e4d203bb56b2d6e27b53c13ce0a3fadd5928b0984c6a4393fab97f35f3b2e816c3fa574acebdc95295b7458c2745442b38312a663122a0954f81c5fcb60ae932965c98e8c949c340466e800a8d011091be140072414cd9f39861d8f406529e7c4ab8f3a2c6b6444d511085539f5ccba6cef9af90c1d8d40cad666bab360315d0c2310abf9df93b7d695e42e742c0295a2cebac3be5dec25de335e11386234d09108ec4084a58e43a0c7636771797586406a99723eb9be328ec8a510280f9b5ccb9c0e4220bb2f2acfd65c5dea97ac750c02ddc9ff5414af76fc4f3968740784d0210864e9cfa49270775399f3ca86054e0942472050ebaaebf3c39814163640072050426fb5cbe4f964ceee1f10efb1af63684ef2ff44a36b7c897391830405366cd0d80cc898218302c78c0a3afc80ce9cf5a6a45dcff247fb80d8a4aefd51689792251fd0f5b61bb665aab7f81e90157f338fe64f139a0e3d5cea7163f260125e3bff3176ccc678c0f4f445cda0da32671d7748c70b7e2a4fc3765ad0610794ceb460b22e9b5d636a38e0aca30e28f516544529ff5cdf85c9162438cc4c2a80e36970d185c91624bffa240218e8a0034254aaac25754183ec734087bdac65fdf1563b2c0764f418cdb7e9a3161a8b03faf7c67b3ffeafb8a5030ec82c6765ca514d4fc3f5a4e30d489d6a9eae6e52fa7627245dbcaa6182c7c51626696986160801490a3adc804ad1345bf274623e0b8480240072e8680352d6e7c6d112b5d0c106541ccf5979c9277157d1d0b106945d4aab5e4f5596a5d3a106a4945ba637b59a96ba1d694099fab8b88dbee119c3850e34a0cf3586e967fa1d6740a8dc7c31ae0bd31cb56640aebc99dfadd8575256b2c605c989c93145471950fb72cdbfd56a66192c59abf127666cd04106a4923aa8d29ed589676ad830a63ec7e7c8408d0b6c283ac6807ecfaa5c7c5fbd4a66c95a4949448718505ae75ee6463f55ea54b2766283e451d038eefc460e1b1bf00f8c8c1c1e3ac2808e325c9869d68b9da592b50e30e4e8f802d25e2e8a2bf99b4b6a2fa0ed57b97eadf3a3d25fea75740125dce39656261c193936747001dd7ef29585d5ae922a31a0630be8d4ec5aa58be1ceb4a685747c69291d59409cef2a77931635432f593385e8c0024ad78b7ba1ddfe9fbd616391909cbcb251e3725c0002853bae8092761e2d5c2eb9f4a18d931a36dcccdcb140084824d06105947974b9a6d76ee39b4ad668d0c8b118b04b818e2aa0d5fc65b74982c3640b131a7ac67074f118820e2aa0cc73d0f7701a330584f65894cacef32bcb4a36011d5240bc92ca33475ec9ede48941471410a7e2cf69a9dd3ffe7f9211e88002ba956afdcd412bb7da9f80d22aad78caf94f5fbf390195e5dcc6c3a5587bad26a0d3bdaa33156b26a037aa46addd4f5ee5aa644b07d28cd0b104a4cb17dad1ff74c9bbbf409bfffa0a1bd3cac77f931b595020470570742801dd3a56e3e9dc5a25ef8ad09104644c397c7ef9963a98ae648d9180ca518b95dd793af6722ad07104c3b47dcce767021d4640ac6b0f1ee6b21ed0510474728b527698abe8fa3e79131c2668a883082857b231dc6cf4d7414c42c71010afc47cb09455921bed100242d5a658ef96a2677f1d41407dd672baa10308685979d346739325c486805ac70f506eb7ff2e3f6866e8f0015276bb886a255b9746a92d4c709cbc9d8c2c1ef02c30d980065860b28191913874f4001db379a8ea4ee22faa3a7880ca1a46f364df7f6571c70e5031deada9b7588ea14307c81cbb943f46bf4fb152b29614c949173b59c0173a7280cc73ff22a65dfce7ab850e1c202b4ab7943da7fc31952c74dc0025b4f54f2a3def95511ba037ebb4bcd15ba3f7de34b8d8e2d701135841470dd0fad46b97a9ae0e1aa0a33e3f6dcf18cac8e2015efc0420e0c54f403d171d33408a6dfe709d291ec585010d480a8d8c2856a14306ad6e7d49658fda2ff176bc2f3a62b0ced3186fb164dfe446167ec0e215c8f0c1a4074f4a6ab5280a98830016ae40e6188bf1616545a3ec4e0c58b402fd2ec54b8b1b5fbd5a386cd8b8615881ba28eb637857695e99ab408acd4eff59d9fad88ae1c04215e8f452eb6bfd5e9a8cbd80452ad0cae4bda3d4185daaae6457d01ae07b2c508118b5df78e75aad4b69c9da0afa06a383e55280c52910ab2e4fe696ef9fdcab61b88085299029a239abbb151bd73c83c0c8489a2183016f72238b113e2c4a81d2299bcad9eac48214485962612e8a55b2b30b68e09680c528768085281067a7d49665bf804528d01f363379aa7d78e18302fd9d568aaa182b45ed7d0229a5ce1dff2eb3539e405ab67555174fcd6966042c3a61f945a53b96b674f3b0e004c27e53d957ce6bd23ee70b2c368152a3f9f78249955294f101169a4099f9bdd64a4b4bcd5a24371ec78989167fc348b838814017680a5864029d3de6c62855566a4b61029da9638b5a4ea54b597a80c5256a80852550f92fcfeb944d99655f09e45cced75a789a1228b91f0b3e9ff3ec9493407e9b983395b48cd1c73349a065a6b82e772a6a8b06b99299733c20ebc4be03323d785756173b2bbd1d90263cc73ca2dba1e23a20ee77b5462dc8e7f1d001194db53cfd4945cb3acf01fdaeaaf4c62d1573580ea814a566157eab4b2be38056cf5c2ef37e4c790b0784677632195b6abceb0d08edced76a3c6dfcb47103b2fdd4b44cb1dd5c9b6dd0644e1f6b7e4736a0658cd569c75399f76b40e6d53978c7a4b357756a407a478faef26443f592066496bc37e91a081ad09a4aab6a949e472fb87a003903fa5b6e677e1666aa93d40e2066405994afb5b556c86d0b5206a4a9d89f7454a585aac50a01420694ef05f73893622ec9c6aa6162cc003206a49266f294f9debb97700011033aedb6df9dfa56afa892b5636666666687d768e2410b8480440061000943dadd5f568591d5f201040c28d39e15c3bbf2e84aad01e40ba8536b73962de916f24934807801651f2c27b11c2c766700e90252345f94d7fc3e5d52f302081750af64926f232ff3870b640be836d56bef326a65724502102d182e795c52f12e6e4bf2bf2e0b68972f1a9ea3cfc971d5b8010816d0659b9da6b2dc71f10a282536f4f39e4a3226cf3eca001001c40a881139cba5b594ae675fbb568054c1cee3f26492b92eb5064205a4ca789a92b87e0a68e5e2d9fdc4b3d4a5205240875969ba5bab2820c589cd2865ac94d2cf5040255ddaa307153e019def5707e204644579f173b66462f373024813505298762f4ded9a1bc304f4277d3956c5f0733a08b204649249acc7a0b5bac703f9026d37a769aae75f4c5db2860ba2040449023ab4d47db8aee839a56fb045020409682f8fbd632a1765fa6cac811c01b13aac7095efd1f509418c80eeddce2d2bec26238b07bc0364cc9071a20293dec2c60d07bc03b6f00f8c8c0802a40868b1b915aa85de7f4b8da96064c4980af0a8018408e8bc5aa694b4639549a926493ba7408680ca2d6e2987bdd729b33340848092eb675f239f0c044810d01bc4b5f65095efd58798071020e8f39f9784defa03e4e9bd751dabed494b19337c80762db1ba63ab952aca4a4e66301d407a8074539f5356327bf48c89c0b101840748d76539576bc6dbf89058312306901da0d227d796937457518f3a40251da3cebf2b1f55b22580e40025ef5598e6681ea5e8e70b101c20b5a5ef1cf5982d896db300720374bc8cd175d472aee3b95600b1013a5d7567faa8e13a9e3540464d39a98eb93a7d1f2c80d00069299cd459313c03d4f8c5fcb2979501da4be557a754059018a0e2cb5d3d7b7e17db54858f5720eb846c7228122d6a9890b02b50e2239f4b9aa7f49e27f9680532c7fd6b51a9a5ac7c5981cefaed4b45ddbef6b1b30a84e6aefdd2e72a594bc2872a5072750c3315576bde3815289537e98befe59545e22637b8e01b361cc00019334c6e6080469ba0913c7ca0029dcc4d45e5da3f54cb1a17903143868c1932948c1932d43e4e818ef65ba7a15b4a0aefc314c8fcd993dc9799b58e173e43033d32725f7c9402a1525cf83b33e5b9fb75c04616a782fc20456b39be16e338a9618297784c071fa340fca5145e5c735f4e8d68e9431468a999793b1f546cc7437127cf31cafcd68002256db43ed4f52a99d54f2043efcb53576e031f9e40d99866b94f7197e2b3073e3a81d24a9fb42c73027d327ec9bfcd0fe3321c354cb6d8043abdb79c56aac3ad5bd8b8b14e073e3481d2a62bd457e6786b057d4395e030594109c2472690a1b25147f1072650aba445bd19eea7f13736031f9740cb9eb7abdebcbb6a256b965073943aba6d78bb885df8a80452a7fca539c978edbbd6081f9440a7cd9f79fb616df5bc38828f49a44b95789d3ef7c54bd6fea48d15bbd1347268f137d6051f9240eb4fedb2dcf493a36a7000091f91400ad3a5a349bde753fa92351245c346491611181951346c949868612434b8d8c2040d081f9040768e966245bdee515f4252c386a98051346c94241b117c3c02dd2905535aafde2a2f35e1c31108db4c99764bbcc84b1b817ae13aaa75374620e52ce56051ba94bb298b40eb5f5db9351581949a83b994b6514925df44a0574ffbc7af0fb72513840f44a05735b9c71cff7fe93a044a3499d43f8db3b9f4840f43a0c3e3aed2725b1d655c0864764c1a5c6cd4957153b286821bbdc5df300df82004526b9916644b68ca41ff1804426d2cfe973c7de04310e82855ac7871ab77b517f8080442b7a354a6544a73a62959632d3e0081dcacd90da332121bcab0e0e30fc895e1af2bc3c5b89f64171f7e40e9ce7215ee948eef5d1f5e53e51dec54669d0f3ea0b733da6e4ae21aaf82df03e2364a319b33be83a84ad6486ab41f8d0f3da05eb79f9267b1137ce4e1030fe88a71e4e4c9dd79fe11d8c08d9ff134da37303202858f3ba0be946cad7de93b3fcf0ec8d252ab68e23a9c5d521d9075ae69b6d4f765cb7440868dfd3ab152ea8eb239a02bcf7d1a6da9e2e2f3850f39a06e5c7799777d67ed79e1230ee8f98da53c8f0acdb0c30195b4d254cb2fb5c6d9de807c1d546aa76ed3b439256b1f6e70e3f7a59ca09d0a6e0b1f6d408cdcaa68d2b2bb107cb00129eefb9b1e339896790da8ac65f2947ef3875c8ca9012dc36e4a97bfdb74e5d2b2f0910684edc6ba8626fdff2b34a0b3d8d33249cb9e0115e6d5b7525be59b17332067b4e4c69dcdc66d2de1a30ce8aed7aea47e8a1bcc27035a7ddc9494be1a034a3707f512d94e29972c0674b74e6a327625091f6140abd5ad68faa496317430a0442e866a4d51c98a69ec0b285d396abc2ca759cdcb86ca71623ff8f002525e52ad52679669b2c0471710a7519a89992bb9acca6143e538e1025225a5827e79eb630b29f8d002fa6dc34773571d637954f8c802e2df54545a9be887157e6001ada351e774c58b6fcfae804aa32b472fc967e6c30ac80efee1b36ed44715d0f249f68766f6adceb8e81b1ea0022aaa66b8f194f334f9140e16fc73b592091513c7f02105e4a6f7a85576a934c9848f28206b5d563c95256369fd8b0f28f0299f4e4e5e5dc444307c3c01f965e35eeee529e9eb04f4ebbbfabaff4c2dc34d40778cfbfdea6ca5e4c40494eb17636a32e596af968056a9f92f66a58af5b92f502e26ce3335e87d12958096beeab29973a6bb2601ddeba572e9ffcbc91509a8985ee6c767745c298f804a319fcffebf4640c9dc7e6af5f6e77c4e1190f75a663ecb1b22a03b9ffe2c4be6773f6908888d5dda957af70dcd84807a8fc91404b4ce5a317f657976eb327c0001a5aee6fb1aa5276dea1f207fb5ba9e390d23e1c307a774ae6f7f3aa707285b3ba9eb5f2aa97d3c40befc518fda33a5b1f40e503fa319e376d4c17ee4c04694f08103f37103a4e7a8bdc2e73c3777591ba0ceb2bae95ca79eda73848f1aa05f8cc7246cf7f2ed06840f1aa04e6eeb9cbba619a0b5bd5337a734fa2e561f7cc80079e95ea9efad7bf01103549a599db56e7f055adaabcfea2d4d01e1e10a942b591e554a2f192c09e7e0d10ac4cbb059939e4fa6529e1548f35a0fda5ab90ac4f8c5f570ed231f5658f050053a5de3a252f048053aa6ceb172527582072a907bb9b5ca8c167b4da9021ea7406a6ecc6f534b1a963b1ea640d847a94fd5632695931a262b11061ea5408593ab5394e299644e96ac19522036a9e851a795afc964391287c72850ab9396af7786f9e71a18b9f125384cde4314e8acc7c7a28c55494b9d8602a5729471d96ee305bd5826386cd420b91b1ea01081c7276cc41308bfddbcf274965287f99073ccb81b38b80840123c3a81544f8daeb73c8753dd0f3c38b17e0b1fb3c6574e296ec2858d2c3e470a4c6a70a0048789074646b4a8618223878d1be6b10994bc9bfea7cfbac29e15903143c60c0f4da0f4dbef09dfa4b35ac72313482555a67369328b8d2726509e316a95eabc554ae1c2e3124817f7ef39b66b937896b091f7a8c48d50c2463c26613c2481d4be7a5a8b8ff28804b2c28789732d5f53b886072490265fdf591617daab640307c9c9ff2251aa15051e8f40fa096d4d6aa3ea0864895d6dbfd778aad992b52dbc0b5e8f46a053577fbfa72c2f78300219edcf3db75cd8c0719237de04bbe0b10864ce155dcb6e64e4b8e0a108945c966b3268de529e6a51c384c3e0910874322defdcb35eced195031e8838c47918022d3f7f58659a34abad241e85380f42a0b54e1baad356f6502d8f41a4063c04b1696ad470315e3c5c2e2add31217e40ffa75859d56f6d2f7098e0a881d8ac903e70081fb646c81e38440f361292071b411084e041ef6023217640bdd8181e4dc928731f520784ca5caa336edc956a29590ba1039ae3fe0a8de31c541022870b89039a59f6df5d26b1952a84c0012fe40da8cda0abbf74cb0de8db2072ba64939449a90d08cf1a4766efc40684c5aca96d7fc24dda6b40b75099a4c92caf527dd4c06afda71a7b3c6940597afd59c58551f94203d2a5bee7a8a35232bae60cc8ac5a4a5d9db23c4633a02e068d6232e86dca6919d0e61b5ef566650819d04965f9f41ae765d032640c0897729f5ae7942dc6182206d4ebd8249f5932dd5a42c280ca3207574ad6ebf869af02216040e5ecb5516cb61a8d6621e40be8143dc7f811af10e205949651b3bed7d8be5ae9024265346cfab81d6fbd61e39317bdc59942081750fb4aaa32fb97af2b5cc386c93121640b487ddff067c1bee3ee764b08d1026a735f4e1d42b280d20e6363796eb3ce9c2387102c207c63456bc36bf9a7e9107205947655375dad75cb5c496ced106205b45cddf576e3570115c37e69e9297e52bf5201e99bd5a94d49d3e68dc521640aa82435abd272b763d82f05b47970ada5d5f7a7dca021240a28fddf1bc56acfa7b3cc1942a080f094738e61b5d44b67a220e409c894633e95c296528813d069e57e7a858bb172a99c26429a80184b9e5b41a5fe1485256bc76464f18055420813109eadf3648adccb4e72e0681c27dc879025a0fc524af33133256b38fe01215f20c5ca9be553135a2004240128448812906a5b5cf64e9d5c463b810849c296200409689d82ca7f9f982559a143c811105ef2dfa56fcb6d0831024a68d61583acec8ed63021792f58d034cca108428a807e319d4e9bc86ede7c16143060082102ca4dd96b4acaf64fd691912120cb7b63ed73925a532c4872e3848b1b667fc3868708012d2b538af60bd528101204dba3e6d07469fe1721404057b6d7b41c538d2af507e8f84de57eda8942880f90a5172e8d5dd28142480f509733f9c595a16b69e301324b332acd5a9dfc28972f84ec00ad93e7d439759c5472e242880e5026ebb3549e3dfc5cc50b213940cbada738b12a979071808ed22ddeaed4929d723740eaecf82ae72d37d752b6106203a4cad76917d35627b12a2608a9012a9f464db9e5e9ce557a208406c88f7a659fd65ac99a9d0d42668056f9518757cf742b890d752e089101f275d6d6a199b3d22a66112131c863546d514b5b50e52b5031938b261df324b55fb2f6ca170045c0700542546698ecb9ada8ab562035866abfad562aaecb8be6024f46160fc0010c56a04fab24e3ea5ead63ccad02a9e785094dbaec2e6975f138726c4142024315aa971f2d99dc4fc91a2160a402212e839d6db0dcb57abd35c04005cab585260fd3e5299066da3aaacb9e82986f8133056a4f49a964e7d3d82985e56d2ae44cb54881d49b6e3377eec018053a7554c275f96719d9c010054a679d4b1da752e686b5002314681d73f618454c09d53a2323ab82919155c19d1c30c0000532c78d5757b272ac97b8d807189f408afb964ac7ed780275cad56814b259c9dd4ea04e7a7dbdbcae5e5672a2943d47295a6904018c4d2053ced1df94a95dbdc0d004f254fea37a6726972b18994068361deb61e62c99d60c19e5023266c8281690314346a9808c19320a0564cc9051262063868c22011918a0800c4ca02babb72c55ac277a8974beb4bd2a36c78401862550c15ffb45d97c6f69ff028c4a2056ab2cb45e858df9954a09a4d0d58dca3eab72e924d0b1b7d4938a99be822e099438715519376561f64502bd19d7a3796f0c062410df1de7343ee7f8524b0d903143c60c193348646441011927fa0894d41876fe2e5c7ecd39021d7ed1e76e64753c258c46a0539fb4cb617518814adb59f2e14e188b406b99f7526b4e195fe5c050044ac5b78c3996c22a1d660660240269a7cb5545ad4f97c486c214c04004325edbaeccc1f39354b2a12c6dc03804525c2ccaf4a75733be0c8152ae292a15fbd27c966e0046215061d52e29fd15c3c44508d4c7b23da19941a0f3df5f7c998a98e60581fc9cb414d5bb5b624e814029a525a5d22bfff2548040df79bc3bf9d28c39fb0774eedb9d9858f901311775ee5c6e7e39ed7d402769bac2b3ce725e9ec907749b7ce930a53d203debf5f4807e71ad49ebaaaca34979408cea52edcabcb4cb78405d74dfb8327a5dfcd21dd0f73925ad2f7dec8078e13273d4cd60aee43aa084b7d6b5bf0de980d674d9144bc65dd63b07e4466949a8d8185dc7460ee88b31ba8ad1310e68e9e195853bdd78221c501a73547a575cb132f30654d6781ff54ca647dd80dc95daf295d4a72fa86d40dc8bcf9ee56bd6cd6c40ebdc9bd58ad8b906b4509555fe28a61a903db3b9c9a5561ad0a12b2e65e5dff319d180ac70f1e46a3f695abbce803a8db9e3a7fc2fd79f19509a62ea258bba3220d3aabe8eaf5365962724035a67c79c6bf231203fea1171611afd6e3120fc738ab3396716ffdaad01230ce8fef067a7ee81012dbe83cd69cb1ebbbb2fa073922ff38e65254b9a607801e5a6392b9ec7a7e4770171b2ba7567757362c6e4024af6f2571cbd4bf9645b40ac16a2e5b5a315e58a5a40256d7a3e657dada3ccb2808c95516ad2a8a47e8a05d4bccb7eef78aebc7511605c019972f2d2c263b76f4a491aed3628b0761086159031dfadab2e2d59518f5540ac90ad985330b59d4514040c2aa035bba2c538afcfccd101c61410e231dd66491fbfd1a4808cb152a79ca387d516c5071851407bcccb5193cfe624c537061850408977653fbd9a3d87ff09a8b393ebaab36aa6ef46469400c309c83dd9d1681ee3e4bd9a805419ee63fc122755de99804cffb3aa627ad8922213602c81617c81bed78f396af44dbea961e33c008612909bcc74e8e6f6cd7f92806c0b174e7f7ae59b62aa00030948193ffde92bbee1fd2320c366dd69457d51ecca086895fbe445409b45219a5456546df5e4a40a4e0a308880d8f6d2a43abdfd346677803104949a525d732ab6fee6308480ce79c9d445f770fa0c0b02ba37b736d656e63e0f03083c80f103b4b298f763a74c1760f820152b4d274b4989b7256bda03183d40c7a852af6ea99f9cfc091160f000311af3455cc55a527a9d038c1d206c5bd79b462ff18ed2c2e4c404078d1c7280a183f394ca952d1b01460e50f983c9ed8bb1b2f83abf808103540e7f9daf53d95a571c60dc009562fa943e2e884e806103e47ffa139a94da0d1f7b038c1a204c36bf471db31b60d0a058abe37c7db64b02048c19a0c43733e7f67c857161c800a9a40c2f1fa5eacf52ec2627354cd40b306280f23897ceb4967a05324f2ae5771bcbc35d405c814a724a0ad5d17daf61a386b50215c5296d8be69203082b10fbe155f3b8bef4b7b3f0028749b955a0c3eb5978b1ac2a10f7f2b62dc915dabae7004905b2eb65b43df9959a13105498dd54decbb4626c68cad94ac6f633df967914b80d0a989e02f532fb9d4caa640af3d38afc4b3f878d2d16a022500ae405cf145a639b9338edcc00420ad4dbc91493c5d8bbcd99e502c8285049aacbda5556021105da742753b9ea99394ea140c9c913aed48793dabdd3061050a04336bc32edadcd7c55863905904fa05c6c3ead54d2d96e3e5e2492cb248078029dadfd32ea5a5fa55c9d40db9caced8d4a2997174e20e387f5ed3aada4726a13680f9f53719ef2e73b9a38ab1c4736a517413281cc4a33965f09552213403081cef732cd671dd303904b20bef6539cb9a432cad2e101882590219a1a65ce729b5cae0452b3f6d2767f72cba91a39128412685933155376dd4a67b8781c272a238b07e448c16fe02bd005c8241016f5ce5d1017bfda0491848d8044c2460c246c04e411886fddb13da7aa8fcf254b72030717c5c60da3208ed8158034024118612307b2081bd90088226c04032089c0430008227004e410280feada755d6adb9789c088c9fe00c4100a52081c491042a055e6acb7346b451d37c82090add2d7d5db4b1028a5e584c7f024e7d1150884c7d5f5e2b3f557b600815679a36fe938fe63fa3f20b3667c9dfbe5d9eefb01753aede6c9b3534bab3e206de6b2b8a8e203c25c998c5dedadf37d0fc87fa5cfc59fac3cabeb017dbba7548eed32bbe87940ab9c52578503a637cf103102818e592b793b4de7d902811948c60c190d987180403c3b5b73bae51c1755b3d49e1722044ede6b2c60646464842dc61fd0ff0f1ee4b406b39510c30f779d34ade25f6136b991851062f4012197eee66d5bc98b39232331f880d6facbe2bdf333752736305082c3c40331f680f8d399fab32ed30ec90d1bafc51a09c4d0034275d6bfd42bb2ae6589e3f865a69687a4da9492ec0331f0804e4b36a75169f16c97431fc4b803522a575aaa58750dd7b1036ae394b8b34dcd49a9bcc98d2cb40ec8986b7bff34c718744068b0cba9bbff62d434c062cc013d9672a9fecc7f5d52c95acab127238b07c8b017c490c3c588030b62c0c1463ac61b90ea55b0cd31433e63e306c47d794eafd5c86ba1b601ade4d4567a295fbee94c1731d880e7aaaeeaac9c5f15c45803ba8229d7cd142d410c3564aaa1de2d33bbd2e06fd879fa2cdb8306942c591ee346cdbac43c03fabd53ee4e8f527f79d680186640beeaee58c9b453cf2d4e7a0524960f8851068489975e32c9dcabf13eb3186440e86caa9885bec680b6dc73b92b2e06e45eec689ec5ce93290c88b7952af8e9ac6ae30203fae5c6ec0abb2aa5587d019df52e4fa9c7bd80ce9faa922c3775019df94f65e1aff2c92f7101a14ab4fe6d43f4f7de025aa85852a5f4a4f84b6b012d3753ed76765727e72c202c5df22cec37f7af8c05a472b999466736bbd85c01ed2b5a316b96cf723a2b20d3c94f52a6bb0a68a1e9e4de6d1655394705c45e8e5bab6734cb6453407e9037312fc5e7c49002e2c5f6e9fe4a61aafc28a05ccad76a3c57e12b05056497b63bb5f39d6bf627a0347a10f35b6151a9931350ffcadd57b594bdb1d404b4d4ad572695f2ed75cd0494aea8c674d2c9c6b29680eed78edd5ebf40c7a4bf539e7a2f550948a964d2cecb3e9ad92601a139652fa5272420fbd723a0b3c7bd6c73f31ed1180119b5b76ca92d6df84f160125b436be8eea5acb3012a12f53c1df3e3c632f593d3921b181438ff56403c7060e2ebcb8e126c610d0977556e9712a35475108255d65b796e417043325edfc4e4a774e6ffc09c600425adfcc56a5b4294500c820c60f105e596fd43ac5689b633e40dbc7cd2ab6a607a8d8aaa3d6c99314cd8b1b386a3c891a175d8153400c1e203b77d88a69a7b2d04c37c60e9039c513369ac26962e800ad726e17975e5a6305366aa0a0468e1c9c5bbc3962e0009d4cddd33befc6a8762d6a989c9c986c81a61ae306e85ded50fffd8d9d5936406bd35af3296fe929786a8052399ed6f65c27f54c0364ce9ab36a633b03846c9a26860c10eec2d5a4f29e772d13230628b7dd56fe1a34aaacbe02b1a1b2957e9331bea2ae402adb8afa5363de5cd15658dff25765c8c90ab4a6dcfecf5a27ad53ab40c6d61d73ad6f349ca80ab496bf972f6fb2d388a940876a99aaa75be6ec39542035e9299d53f84e813661590a4fb7167d3405f23d5dd0ef4a8d0681482910dba92d657a47157f91029d9fdd33decb738bd7285029bcaa6f8e5ab75796285059534df8a77932a50f054aacfe1ce629ab96ed83022de2514ee6eb95a1f94fa0e47667c9eb3c81b8d3412f86dd54aa7d2750ae4e27ddaec5bcfb9c40be9e4ecbeae1b2ce6913088f6965fdb3c54dafa309940eba4aea71f3a44ca0662d2b59d1f2d82a1913e832d9fa3b6231bace259099eab774c6aafcf25a027141f3e7e8a556029537ebc4538a1208996f4d3aaeaad7524e02b96e29da7d124a022dd3d3b56e79450259b19318bfed2ceb759040d7d6c88ffc8feae71e81544baec275f41c8156dd734abb30a59bd408a469bca88589eb33b53102a9f9ebf5dddd562e2d027d36f7317fd89551aa08a48c3a5796c2625ca54c0452eca5de2b992a5dac2022dd0e8de32a697a0fc139440c6172c3031b58814821d059b92af5ba2511429c406410e84c3a95f2e02d3e6c380b0c50404410284fd1a578fa12450281f2add95f1d2e4f3c22802811f903c22fec27619f97e4aae80544fcb0cc3e99b3cad34989f4c1b8b49a399ab3a34844f8808e72a3f9fc73b6b5d42640640f7900113d18d4bc5e26fd499d269207945dd6ccd93c6b9c9e78489cf2ec0f1ff5f8310888dc01b1fa928f6bbe67bfd389d82145ea80aed07459aad89f595000dd89d0013d5e52cfeb7c5aabdc29227340bcc9b69f7612a754941c504a6c741debe37140bfe92c3dcdebc7fc4a704077565149f78eb159eb0d68713269b97cda1efc7603c266cc54147bbf18dc36a095962a6b7dd9b001295c3fb806a4f038f79adf685944352093dda76ff9985256ba34a0e49ee73ca159c7f01a1a502ae7dc5dcbe41eae227206d4974aca35e3a6cbe4e240889801e929473f5e73226540d6c6649ff7a4c8808c99633a7b8e399bfad441640c0859e159f55b2a06b4fbe6e9ac4a9e93aa6a98dce002870d1b0e3041888401addf64ce17a60506e4e7be97e3da9e613d5f40463175e7a5f172cfed0584ad147797d45392ade9025a5652cb4a93c420c20574d8cde62a9d06edd36d01955d76cafed7396d442d9c936ab8d54b324bd7032259402b9ddef4c4596c254b112c204555f86698c7f83a45e40a28ad656b518d29adfa6e0564ab1cb3af32bd99a5b60ac80c7b3165654c840aa875d97c7f4f6d2aff9235b580c814903a66a56350292305c47c7fa93067128902b26b73077131bead37112820c5834953e22daa4f89e3e844c24be409a8958d1da75e5b50f1f15ac4092811d59aed342efd933e6627d204d4df7e322975f858527ca420c20464ecdaff3f95749820b20464ccf50de6da2fec4c6010f9027d515d275ba5a2866a5d1051024a8c67ca55af164902ca9479a8a698392a99cc620b224840c6b5d5f05c3999ce151c83c811d03149cb2d2e3c881801e925173d29152b275204c4998ba7d7137b9a630e21448880561d1e375d889ae86d0621320454b437df2c7576166b92a4484eda183f880801b9b24d374ba9a017734e240888f9ff64274c68ca2002049477f2a8b2d8fc07c892ae6d36c97dd4aaf40132fc875df8f41c935c68f46fd1371c303242a3d720d20374726952acaa784afbe70172935cd6c995f60b223b40c91c3a2f6f16d7e435722c111d2035ab3c8f29f739407b49796a63ea3840e7d0ac758ba6796d7b03c4bc8b89cf1f77b264256b24385e8b07c8c88202345a0548e1e88246abe047466e70d105c27152c3c68c913388d8c05251ea1dcdd12e59dbc2068e931c4e726232323232629884f5e4e405223540e637791797959cd3316910a101c2a4d6179b5e2b3203a4ccd8ac154d95acd904446480ce76957b49bf92b56277121089014abaea92f262b757a073920ba6e46e73cc18e20af4bc79cb67bcea79df0a741657a927737f5299b3026931c65bdfccae029d4bfb0a7be5612d8f8821aa40f66aed9ccd4fa9406aee66d72a1e2f4615154af7ec5996b8ac90532093762595698d2ab993c7e1453a275ef48d1b3d12620a54ccd07cd9d7b2be471e8494021d16342feab887bb3d0721a440a6e66c9d643a6531ebec206414e87431f7fbfb4aa9f41205da9aa3d6e598af62bbf12718120af42725f39b4ef64a7ac95e848002dd21a7a4bca79cc9b43e81d2af4954c4c4c795bf2710f72634fb78d038357602e526aaf63fa60deb5a9c40a95cfc6e3be171c30bd904f254aca750dbfc643a219ad8555b93940ddb07219940f7a9ac94d2f1bb4dbf984005775d4dfbc96ce673093ee33be5c2853511ed96e2f5e227c080063421c412c8d4b94be7d55b3e230c42b48b265e4c394e962d100292028450c2464a422681f6dc985556bbfafff492404a53d5ade06ae44b2a2412e8b3f819a556f475990a8184853c02a9dacacb4ddba9bb1c814eaff496a74515b4d2e66439a411c89616cc4c6b268411288fa52c9f0caf452093f24be2a52a4a6da322d09a938a5abcd62a6c064f024212810af2fa4e4d96b84a7f0e46400822f43fad5a5249f39c3432e23572ac432055be7eec98d4ad8c7943a0d357aecca6ee546f97ace12031668f420a7123841028af57516fec9103218340ec77ae149ffd2cbe132288e2aae87838195506c2bcb851dee546f3202094cd613fcdb87d8b83903fa0d3553a379123a8d411e61279280e87511445411043926a02b3120000000c18930683c18048a6e8aaf003148004513426483e38242622188c0683e140180c0682c160180c0605e21888a24014c45a5a520e6a8033ed3d6f2bd0a288ee3e100eba9fccbf6828291e6f976847ea1c22fb8b79368af2107160064aa4ba0d61171eb1f507b2ed0d94fce9c58b3c42c232d57b2f9089138eabad3cb09ee936ecad98634635bb97556c15b6cc1e615385540b5d6def999d569d9f04c26f71803e9c8792ef3a21c02346c00047aa76df897531e53b2d18027abd48b2072f5d94973df08455b9c08dabdf35dab4d6f4772f32492513c0b617cffee23fd251de37c85bb490f67af4f708cf0e9f860a090fed10cd3b1825a8276e44e609fc4f09ef67c4f371684f5c27e5ba8b11c4b1c8ac4128963461d97eb8a881a68738e3301568df16b5ea80fcc67d0ccb3d7aee68954944e29bf27b90edafa45b0fc3b7493d877b15e794e16da1a1f254491587e0ca009d51f8c5bb6fd07cf894158293e78d54c2fc42cb4bbbf5898af2470600787b91f76641803fe269be35f8940782d84450170101d607e24e14a08343eb6f3c1854bb83548fde3f13c21ef62de4043d5b1c8862b2818df765810dbd1b2fe67a915f85b675117f51f6d1b2d54e70115f1777107f53f4e63e460081eb0706fb647c42f23d1972c6977a363ff766c16a771f36915791f42cb0211ec88d8a34c4c5744c007ef8ad321aa5e6e089028b88b81449ee64f8280a6428b2fb8588579f50532136a9769292ee049ca49f6424da23a4761efb37cf95f9d7ede8071d040508080c1306b49c0de2d4c464d68683e1ae0ef297b88fc35990e8ad70dedf569466b5800f524e2f98f8e3b7812c12faf1c5737848d7142528f65699afd9626345f9f1b609f5a784634d7a1ced3f649cb4678de884211153788ad9086849596c5f72746d80f97494986c460219f9090d0b6aa6f97c06a5eb2c6149584340742586f1bb71ea6bec7693314f9ec1805b2973f62414ee7bbfdb7b8b7c7b7e6b23faf89bb2450975351dd71a4429676ac06bb40cbf53ea3283fa79e9cb16f58d9b8728188c3e1eb09b53fc8eb8465c2b6d7be045d3d4f5e672eb9cbf8bb20ad01a75587a5214e8446b30214da2473c1b14cac3ba553ef0849d415e1f3454e5eb014d12bc1afffc867810212ca45b910c58cb503337ec1d1c033173dbb6601631e1c72681c6770d0d483e72af6be08f5739e3a034a3c222a5eccb9b0d987f6461626cbcf93c413aade4a0535237eabd1a95f831c664734145f72ddb62d6d85c4a9e36dd35ad7505e9b0df3dafca26f5aafda911d2a16b8d13b0dd0edb0ede3b067941337e19c4e2afa141210404483eb5d7b3d10f108244882625d94fcd83e025627f297b646180bbc86a49ed44ab3a047110ed69f959e26e6eab923af3060cf30a15e26c7ba8fb3798a9a40c7736a37e24b82f570749f4d308d590ba1723cb60da5ecddfe673c916afb978c8c524b02d19757968e6e9086df7ebf3892fb681e0aa40ee647ad37c2ed4af52d0fd552955c4fc39c9b2cbb0256ba61da70398475c9021f6d0e7fbfba88e58ff9c322ee15e06ecaf91f16aaabbe78f15720d38b5f7c1fabab19102bf1579c14d2c529d163ff131288ad151206fecb24a035140dff8533d2b9549b47f8e29479002f7baa6b7b22dd723431c63dec52e40c0d5349065e6fbc20d5d04298fa942411cb47c5c80527a34536b9be75ace0293045e6d598cc2960d07c998e93a6aa3c07e0f219972f93cb68795b79e9540b0eec989b68f237104052f8f8871b2304214f3131e66ade4c69771300f942e0ecd7987639c7785656f27a192f668be018e4e92c3301e2fe150c7e708ac8b88a4d168f05cc467702b132bf0219efea8a16c5d4f2d543b7c1de8b61dab9f7a48b4e91966b36876578efd73028457cd286aa88a01cdb2da4060f6773ca6998ffa8df860062ec197d3c7601e6cb89f902149574f8829e997802c0dfd0ecbe11fa7ac90bf7e1c1f7b23a307a253da0f5258e49773de31b64c06a64db507e87879d14fc9ac2baaede504062f27caa60467569a3bf723d1a4a61082f100f9894d4d337bf39e39a7311ab2e6d80fe9588cf2804116e6db9cca123453305412302c754c7cee25c843ac82c5a3f270a910aecacef3daa88b1dd0709b3d2798f869ee42b9514792567c1e7e783c3b80d1b23cf229f59f5248570cb0cf5b178157ad82bb394662234ad634ab4dddd7f01b1b2516440045508eb16c460b5857f09a494f0a4015dc70ef2471a2139e24ef26d1b9251d06073cb278e7dd6e98dcb20b169aba9a0982ff8b41c07535692e674f9dd26e27a5388ada0315f43b7321e838874c8449ad0f95bccc80a364613fb55ae438f36f448256d2b5df0ad7f72c0509e3539651bdfdcb00b0b77d4d4e44971f8abae80c2c4e867150d62e34f7f0401c5bf9a0f8d184fdc13200807556bfc061fa5b594c3e80d30c176483acf85b335f4936f6192a37e2ce7f50d50036deb802aafa8ce2625f1520fafda70626953afadc016283161c7451369a68f3cd27c4faa971ae6e98ac48c3a5e8d29de2bab68fe20071553ec414aadfaf3b48b29f72342d095ced63059c4a1b62895e54aad6c2b3da61cbc85eb48bf3ef7c688264f2c4dd5773d737919c3024ecf47a7d119455a6d36ae3c3b84ca1bbda2fe6c230e2712daaa5df87e31e5eedcc241300d0befbb172f03591400c4e70ff292541b58cbbfcd8202d15e23dfe31f03cb87422460fc954892c976344fb052c100fb1e34edaa9c14da4884374e337c5f4881641e9d6524a3df65175299530045b3e9390e278b84d4defdf9fa823340baac616989a13a87e3b8d9b686c048038c981e2f58ad4717d014abbc8af875a1e5bcb85809952702b4ad682eb89116a753f58acd8ee617906d096ec4fd8e5bd77a29191a3b7a071370e9dc4eb33e5b9aca3f6a431add3265f50e0ef59596c665ed0324d41df40969c86f5a432b5d833d9edd94167dce511eb171243f1ccc7459a25f985206ac32770f09ea2a62158bf501a1d4e61df5bf69c7e4ffd203851de5e88e1b749b52e58ef552a0115464ee1471dfe303def2fe2c848cebe18803f22eaa81862c5e16f37dc92c20d58294c042120bd8ae7c7ace44a18a7f518e9348b58388bfee3f4a91682d0eec3543e12ee1064b3ccec0c2ce102ff2bdbd463ed600971230291749b48aadc0e5e82114985de176a8dab79d4821c9a25c6000197ab8940fa81633e9a2170af37bcfe4e6507c5e62e6231709fcb31f3c6a80f9c0bd33dcfaf472033d72a88ebcb9805ec71888f9379bc4e557780589e5bddb8bd38782bfdcf73ec3a5ea6fd9ecca808991b394691831320647a8d44af0a43ba443688003cbc60f20aed5e6077afff20acc68cb3171198fbcd67b583a4a155296f5657500bb73229abb1ebb4469a9a1ae243880b4dc14a83b6c0266cde53c1eb9fdb2b389f016e29c80ac643ca1c6f82992768a02197ea7ec4f4bd18260c677e358760773c6a945edcb051565fbb4efbc6844ddc68ab5d03143a4ba3651b94ce50ed8dbf5f4911f1394121a4f1da8e93d46bc9c519dd6e8c265407d8d06b5e0d0f18f4dfeb7ac57e0922a79979dffccc722b1281a21f0cbd560540d9a960f5691c5b56195eed4082f1e16539548adf772966a5a09650d9e3148a78ee43ef7365316afce1ec2154f42489d89cf33367d6b974b381947c5a4cf03eb1ee2d4c815a5eadc8119da6bdbad7d6210567457b339346b61ba8b2833b9d6222ca4812c7c7082c7840bb6ad600686f0c314373ae4bd01b3b62289243bf6ef46b5c39f66e5c01a7d8025ab7b4c863cab94596847b06bc2f6c037aeb297149f63dfa9114fa972f7ae229b8023947e7135677eb139ce68662efc42a87b80d8234887a1486a1b2a30933020ce530948daadb93727e57c1aae1760622f168e4145eea6dc564c1552de77f913ae734feb4aeeeec81529ca3abc8f619489edd6906e7a71cecf80d05c2c9839996c69100810a97802a014ba64483370fac04c69230a0d28c2514e6b269ae00a1fc198f45c3e428698cc9d922b01a4d786da4bf722f19478df338eea645ea6e61482ee77fdc86361ad3228bf9dd16fb973d8c674c31b0631ccade871dfb265c898d1bba3070d2e611644b0021ed5e3b45e7227e769078826be305a6fa4dd1501ad85f5662ffcda090053ca2ae78fcb62057ebb1f6ece397b41ce7188de7ed1b088007ec0b7801e41ccfcb9c49a69e2d63bca4ac075c29f837fc9701101bb74ea378d93a9048291481bfdf67ea792b61094c6d7443f1b0103980d94a4aafb9d263360a20a1adb5f1c222babeb06dab984e9d49266804f45c6f167a5c72747409fb92684023d3a40bc02a4e15a6dc997ae536f26d5772a62855ee3fb89e742bc7153e9959c934bc61aa42168d265543d47189a5e20a186118c3309e282db4e3e84c0bde2a001f549b04d262e18a8fec93cdcf800b7a92764d5a99a0ffda19b91f8a01a35065e489bbafbeeaa40601173a98c3f78a460d29ad3fe501864ae59fd7125e2d7693912054edcb263d85eb095e23ad1042100dc03a6bc390716dcb49434e2733234c3b01581e0188150f1b765b4f9af861bdc64608855abe13cf81570ff3d3be70ed679ddd2635400acac6d7ca0f60aa40806d13cf10b4993339d79ab06aba110628878d2760e78710962cedd523657233a45c29cfad5aea724e2e75258d4004a2aba7d04eb72b1953b489e121d70a2a5ec1de3cf3007392f442568ec61b6747ebcd73a4aeae0e3868efbcf4a6a1ca9b1334a32e0721c839454518793ffc240cdac9561b7aa6c55799a6286085e3eccc7506856c054fb5f6e175bd34bb71391602fd6dfea72e377a798aa07ac97ca147fa0be8214667354b7f415ae1b524d33120832639a66fd641b007a66dc3a9d9806c02eb92a0f7d15373e2033f0cf1a982c8620161ba5c0c0772114f60709440be0519bbe97b123c9df6398b18b66ef98bd207fad71f152d5e018b6d3541fac5e7923c7e3bf614a57baf3d598da7f317703379b3ab91e2415ae75414e987471fb2540fcafc42d7824d245930d029dd88747a2f447c82feff4ec687df94fab5fed9171d8e37e6efaf10d0c827f03c05ca0c25a3ee77b786f027fcc6702002fed901067013c9eea948a336a4d81dd3a1a96839357b134342c3204b009d3c64fe9144855d7a584eb2cefd54f985725dcf8c976fb8cb98d67d789c87f3d276ae0ce86eb99d546be67d8f57856898910cb84a6c316ef66576812d939b292fd7469c29116c3601ae51223ee2c4d9b05b6efb20c09dc848273ea6f83f61f94cb10df2a491adc611164422a53f7166249a5a9e24756a3c8c626e5213e3db44908af6d5280362a9af762fa0a4830da4e8b19c7d74931488af3cbecd944f4e9573bb07a03c17fe61cad2afd941d104d0ffa481fdd243a39b7014a571c74e0a4f3da49f88b6d0dc3b792319575e8baafee80031a6763e9e8ff8ccd747a367b318368af03ce633676205818c711ee027d9af02e116806c349ad1a9c2749ceafe45c3396aae574a5c2ee1f849b68d8d11ad520fb11303ca895a5ca22ecfd11c45be8bcc3a94db8ab6563577b4f152d0c3823a3e279b0be4edc1b02cc873fec1f62c5235b23932a5e98d65a20e21679150ee2caa55f01400cb959acb63a06d0a1ec16929bbcd0944da59dd683114cacf6df0acd3dc99734dbb43aa3a8215e58a4f0be00a8d6de81e397cd7bddb586a3ce8d4da0d87154a76247c475da5e1b86ea168855a76d71fb50af4bc0851d1135f914a56786f119e32b3af083176c376c128b859d5dee390d5ad77995371816cd5450f5a7fd286dd9f011f250e6116a80cbcee7600f2ef434d7500b59d6c46da3548bad418c3f55e153424b54982a6f696eb1889ef1e3997b6be4cff73915106494b8e64f0dc2701a083aba4c4a3e7e3fde60d027227ec24cc143d5a7179c002909380d469a9258d17732151c31a19222c3dba7ab84080ec0c9d8771bd85e2b378126e26117c27833d5025f097cf60831d8343fe234cab5022ae732d151c92a464c40259d768eab6f2aba59807ce4a37746573367dd85a36c38c1826c95a4c567d371b07e87c5e5453be382af6152af17be7901fd1573a56916707102c82b3eeb441c164a0515657548f130934185d753b4453a13fa07bc1c7312b43e4984a469aa1a80c419491e35721afd37e097eaf73ee1b552c229c07688608e5d05b2561f2e4ad3a47b912633aafe315adc3a8a7d1b0acff92958e3014717c749f59226ed91d085912f2a35fd90405b88d5c97f803a6ec8f87d73d427df02ab21794cf027f7a820f130e76b2fe988a145360253f4006e6becc80a841cc7fdc2914e118b5722b4f0484d9fd2de105373ed93d31936453300ac7c0ac95f40f44e0e3357066b7f8ff6a860712708cb7adab434e06488cba5906e8e3a93f8723e58184d17ce1620f05d15a3b895137ef047a01d6a9010dccdbd389347761c96d8dadd48225a82b8f68d011c8f52014ad489070cb3ba82ce4e86f915f4aed85e7b5558036650a5eff3fc6c4285ec30810040f2ff9322b6060a5d6148044b15d019e6ee34e9465fe35769513018b213d6a87f36ebef2bc7120186fa9cbe0758e91816e8b73c218f56f7763d161da28d55599d220deabb1bea3d3eac08330218d68c80ec00c07558544b5f55cf23bc462bc425cd71a92626910fed3046027caf39878448c399c469c324631bdde7e2f62bf8f3d53700144050e88e6fd35fcfff5295d4a0070fcd368820fb43cffe0f3978890718d0f999c4a10d46bac6c867420405bfa228de93da2ca8cf62f654fffbb63680108e3d6225c2d46a6010ad49b49633d5193dd443ee7fe8e5fe6775cb72fbe9b42b9f7fdce9fa0173e10eaebff451350b1390a6ba356890d0cdbe4a6840c5c11b92392c20a6c9b046b1e4d9448caefa63cc8823a4539f5d57c8d94c9198173c4df1a30a5ce5e56575ec59ba45534d22e190123f70378c5c1b6b19b3655d907cb33b4531e163bd5af1a21aa937c78a771f5ef83c0d0278907eef8f755a741a0472f4202d3d7d92a04772b3220ce765d808e5796ba09402c318003343eb789a5fe2d0949ba747d1a33a794ce1c9522edaab6635efe28d22ff8ecd088c69037768d000e54ee8832b31fac310ed6569438de2f79ece63b72c39504293a66c096d516d38bb7003c0a479bea2005724c29c201c22fa3198a4d412d161112e5cb14f04663adac50a10a53a4574efe25cd298b3bd08280335d9643c52e6bc7ca82c5dd1178a3cf843badb40f001f4be33745062a94248a167e14b286c23ecf0f07e790c89f85d1d5ecf810391dad6744a2a35462d499ffb8d2a5232ca554fb58102f2677c4f40b47ca8ff6762605aca19ec09b11ce1099f4b263ac1311e4c9b37a6a0e771996e9c7bd58247fd62a5030c3c81ac80ceb913591ed36540ec46c77b636cbbb3cbb347f950ecc209619a5a367f887b2a322edbbbb58f0d0bb39ef2a6236531eb1273724cfa271d7797416b9ed8a867e70dacb694e5e1e31e8eabcd6a9e2390ae1a4a7edccbb0f398593af3fe922c715b8e5b9a16054d657eb045da2459efd6bf79303dfc925857b4f8e669b0adc5bcdefed84191adf9092e59571c9d09c8c5da63c404897e2e1e8212d4edc6354e23e4f61b8abf0fc0729455616feeb61656727d2da4b706dc72373531013f7621b3ce80e1391c6e49dac569429198ec539dc373b749885d8e670d7c3332f685cd908595e3496efa1a653961f9c984b88673774c005836efd5b1d8d17c92ffd669524e1616a2a14db996fd6234cf7faa1b6043d5b8a2777448983a1c7aeaa398e82ed91bab5d7d538e9697908f63528d09a7a0b9faed240f028281947d179174f49d1dbcb080239276c37c1416101c392d9938579b8aa6252a85870f355eb65f0b154c13066188567b39dd9958d62c010855f58d9e849d75c493c22433381a0c382065661913e2e215ebc585310333fb219f138877069d49f6e01211cdbf34c76269dfa2d715ef0b65598fedd03075101aa3e34a502be59d00b4487dc35f2627090b920b2a02ea6e3ad4ec5352f644b52493a8c3119a85a4d0ac040e80365148ade28bc7e002ad8a0e04590ea16425c74952ee5004dad62e171ea4d8b2aefaee8b2701a62f2260cefc67311a20aa2eafc80541e43b276ad0d3ddfe70612d806b74898d8b5a0e794f51c58cdd7db6abea430c2a9e3a31bc22a8a10e61d45bac5ce22413f4182c587935334fc6a4c082b7355c135ca6e38e1eec67ed8fee453a81e859f736d9fdb2163ca2545c11147de62d5bd2c275c6b7a517b567ee98e65fcc57d141e977fe05a3bd8e2dd6ed1e199200bac84deb7d6f8b40bdbdfb9416eb9a9f73cdb41848e043229bb25ae50aef8e3fd48e1bd52d01f19f5eb76037f5cb40d1ef558e42d1e6750314c2aa285f127b19767834cf474186c8f05eb7d712bfc5960553d036311d36ba25742b5e1310da96eaa2da0845532d43a97d912f235b5572555b9a061561f9844120f4a23d4b57ab7ddac37c94ad5eeb318b7999c5b7565929daa6dc094ad299bbaaf0d39126af377d605d837a78725f296ec098dfacc885f9cf9b0ef7dd3fced0bce82f3784f409c22cedefdc4046e6489129ef25af69ce10bfcc7bddb550f2984972671d9f5f4687c9ce3caeb9e8ebc74eeb3e3ef40a99a62715bf4a01a085722d69680fb4443281451e1ece7a9a4637be6e5a56e8f71d52cb780252ec8dd8de8dc9f254de43c10b09a6df5ed54a92ca5f651bb792a14a62793e63d03a92ec36fb670045bf89135861b41756d3e191c98dbfbcb18452c32e331874b974e64e2ba1a0bf6a26f62806356ac31f363b0c65a2748ff752596d23fb23edecadd94b6bc0b07c3057cd15ef92f6a7ebacf6a9bd8549b9c67fc7dc1666d006a2662a258304092b452a8797db6f411d04ea6c7f6bdf2262136b34967309cac98387e5f251ba29c321a2ccdc3c3a05b7ace98df3bc4c3adc62267f5ffc73df14804d2d59c943d59f9124b004c4a8715e21cef2b60ed7284cabee1442ce10c412054f558765ed4ef10fe2304bf3d2f36b47fdec101a8c945cf38d4d3c90b3bcdf0809e2b409a0e70edcc8b21955f196d2eb2be3d40e6c7a880356acdd039cbbb04d368c10200549fbea35f8dfa36b3a09f045e94a0c2a42513b1a987048eab8bbe94463ae3a35f802f44c0ad59c57c0338df8c55c3f0432fa5dbf0e6a79600769bb1dd11779bececb073dc36cafa25a4ac0c8580880785a81b13d5bb120a6940d4f13b747e4c9038abed629366c1d4b995fae3a51b19ef6c7890ec602c1fe3165d89c3d6224c935dd00c063f68d6c414d04a4e5b04946bac6699500703374412ce896c5414e000004d2abcf372acd2813a8021e458d9cd6a1b585682b590a1119c537598b4a457a5a17be84eb77f595336a67cce8d13918a0d0404e3489cbc335561d3f6cdf80305b1bd4fd389695468c3bb93daf2e1599bee01a5562ea19407f184ebdef8c5d0632cf273a8a2cd7434b35edd7337f28fb3aa4a345233d0de04dad6ea910675daa109b9202d64440851eb92e2580394c384a8ccd6d5a149511b818aca27ca35adb9f7c95c5fdcbcad1e3d83390f1b2735ff087d6f817c05b1059dd2ade80ee5e1bd8b2098bfda25f6e479df648ccba3488c5b3e4b5dfec95e93e443d34ba8a23883fe5521d4d4e5ac8c8c488a8261a408191b4181d7151049cea1466e642c91922a8dbb614d8b3b8e3919e50fded5e9c4bdb1b756da6422299dd39d891323ad264370a90246575e343f6ce316a22c2f0013f32be4be88497595425ce221b94168dcc47f8b3f1ebe499f009889b90a9a2abd4d52d43006daa3b5b50a488183bf20bddafd9881ab594daa45065f46e4b6d69dc54b10fb727bf1bf979ed063793bf90b795158ca3f4c2a2229ac72b5f88d71d5b5ea85ee7e68c1815cd3f4719940d2947e24e22e1e3aa5fc91479aac6ce0ee40c1e11b2a2bd97fc4cf7c2792c1e5e3bd23b8bd73c0282af950d05e842c08764c0b9b434215a4a508f57b1ea62333e2724839104789dc8e4f3e24c961ea88b2d5ee7591630078cf5c1e239e815956eb0108650895456b6de9af1315e1a0937358d110d231a6e584ad876ef6dcc868b974546d1d1295e58218ae6aa8a9847b466370ba8d5fd033b1c8bd5f11ff6cb20650dde6b4f1201fc6663d1b4e99e72703a93a73ed222574fb326dac90bb1df7c8f06b2d6f9a51c8e6488c60aab216ee88f276e6fc263ea53b313e8d234d94d07f449a1ac6c2ee60395e7ae3991ec995e8d87d8f7da73bb8f4c20e9de01386dd231357ed24b2c6640854fa9e513d9e38168d86b824c8eb4bb1245b221f20f0e99b2ca974522889648596160b6f86f3f6af1cab064c529c600ac9d2f492cb5ab38ec2f9c2a17d80fb3c11031e998f570f99af8980d2b82c268d5eaaf6c446e295aa11a33435111a22b2946acfad4d775515663b591a4da3ed9d9ea33c895f089714af6dee67ee46c4178d0b1c854f101bba1bb825ae52961628beee78db9d28b09c461a725a8287bb0d4a5fbb936f1cc3b7f62595956a877b09ef970c43bf5154399f10236494b04d8813f3343c1725269430f6a0378480d5675db9e4b00d0e618f14f818637751862314fc81b0620ccab61992eb607e883c42485cbac2b5f38f09cd7f48f6386cfe8ac661bd1250397b3f16f0a1353e84e77a11858dfcad605cd56d87993daa3ca41e2ac65861d660f0fc67a8a79cdc26ee7e3d7b748bd7256e3e32cc170a6f990608470f177c8eba0de6b39aa5f331f0e82a67a1d1cc0b2cfc6c5a68aac3f44fdcede7918052f52fd067801cb7869ab9faa4642ea26a4125e8a5667cb27d9e86879c768ba39232f59890b7f8f40d9ea10307700c5d7e22843a4e1b923489106e5e39db75d8a3fc9691231f8051032513b2f006530253bec14386f8d285235a357e71295e9042da9dc4e96e9c5a03af0c912c15986a55aaf34ead2a237d3426d164fc73e6753310f97d909f78839481850d182c6f5cf2d15001e39a39e0ece08147d6e0d5fc433cab92d75a4a33a0f2966dc20a5b926e3d10a57c004d88743fb48b54413a53963003ef481cc094b16fc10e21a7f240a70c7327fa480247552bc7a0ea00590382c94a43e7a7713c17a19e8b216e093105382503130208ddffd11e65a326391d80d58d5bccd3c7e85ef9761f729e0c43b893400e38d6894614ab6da37fdce311e8aa8366fb1d681ea6c53742e995010dfad09b4e3c427c927d14dd23e6281c10282f8a5af1d1a771b517c6f28e46f6e8a82c5806ecb5f4167a3cfecb1385eeb19938b20912568722c54bbef7c76ba7b89741a4cdc8b694b3368d2cc5a7e6c1b77d90cd554f11487cd1f982a652c7e24ebc9468a356b9f74eaa10d95f57d0ada076a8ce51820127e51462176bf2c097ae43d2cf180ce74f10076756d372cbd2860e4b9a48a7cf013cf670e97bf3d7f5b030c99d45235444b05e29242dd2d4858a295b636291ad205de9cb31b5fdfbc9127b9f42d04d9c46184b0f2f018bf4cac678a0e22e693d3baea936bea5bce375023d5e54f63ddf9ecb7adc903c820e9f5e1c3fb1251d3e7c0de22f19ffae5a5467496d11c78f1ae95c3a05bea406538287772e9dad0f71766c2a00b2cd5f6018b0f0c4fda652a0ac1cdd059a569cebef1e5f4b656e13d564db6108486e4874df2110934e7b99ee792ee5d17a9581688a16eae40e4e10faef314d7f08276c4765c3c921f0250997ae177d52d17580d5bc80786a19ec36178812409bc15a9f0eba9b81239bc1415c93c67f0c51675f68701fabc1e7288d308240ae6d42190c86e8b27e84f6789d0f122ba2fc82501a14d5f05639a9454a494145d81cfcb6ec98635c8c8d3f9a740dcca30a0e22533dd9e799e38225904caf00986ab12c2c6e824ed4cd8bef8cecbc66f9df561022b85eaf2a9770446603246077bb21f02d7077f6042140eaf58d6784f9722c9126621889914043232709f691da58946ed9c045aa02c80abab6da98e53a2e1cb1e32fb63ff4ed021a604610e45c7865098c5709cee470c0f0a03844e20da47a91243e927f20558a04f191fa81444a93eaacb1502cb18f74e2905ce81a7230948cd457242c4ce2ad4489c63c53b3330d12cff53d69db77c863ae3a95d4393b00f49346c76e200d3ac65f0eafcd4a9294bf307b9b70947d6067a7fdeeb16014766224a2fe139808227ef080888baa7aa4209e0f5e28c86ece1607697f1fc9a60b41756bd449399356e8f871e3062c58487177e2d9f44383c01f08e587d5a19c4268b260ab9fe1b633d64116f1b63882c3ef39122db793275526e65cff82e0e696ef7a751810b43f6b67c38b0a848a564378a9902cdf80c53778158eb7913b853f228aaed3be4e7c2e0ea5b45eb028af9a06cf38a714ce4c2ce20136e60b3668694c1e0fde66195691cbebeee85b714ad2f4cbd1b8ba9d34db87727ceab36b7bfeafecddb44dbfaef4d814bceae845707a53946f2f74f1efb02b8956fa24b973cd0f5453554863f6d26d64ad0ca928080e19935dfe057a714e7948e3a5b40a62b6b66ab8e22dd5c1c5c2623e8e6d43789b53331a031768c1160796899a696ff027915204be6c0e1c15f49de0d7ebf9f48e588f4bfc3cadaed36d7653930d0afa1085e0f3ee47c3a425c3b17bad5fa2863a1eda5e94a443007000562dc5806b5fb96a3c05833fe93f86e943767d86127e60eb7523a71205abb6870f3fcb61949c3baeca02956aa01b1577b14a564b17b011121e5dc1c21f4ee3a11899945d90742137eb629efa75e81f8848ac642748794c526253d613249ab266b6c3a469f47a35238d329a13c58b3bef5f63ee029d9bee41fe7e4ce54038763022780e0ad3f678c46384c675cd60079e8e3dfbedf0c0dfd44238d2396fe58865eedb40fdad6f9860f80d425e63217680c584ac4d963d20bdde44e0a78b4593fc9e5646769c14c15eb191345781687b8dd458920bf8b6399ce432a58c45212dbe04d215b72dadf9c7fdf86e54c438a68418fe52964baa786faa1cf4f6acd52b7ddea26c87e40b38433f3f27affe95bd1d610b4828118a22361e4c6d800ad84f4f99416c0eaf9c2b3468d99c88b8a6f54a8a22f6779f7d0bb73fc836f1f7c0120c1e4c67df2a7a40668196d6594782e5d5c984817dc60bf01f92254653265b6dfcd4722a1035427b8683e9d3b773f7613e471a58488be007ad1fd2b98ef4bb4b975ac0c9b2b3b59a1a68e3125a6e5223a38443b9a263411b57baffd52c96744e8c2624aca40840dbcd4c652bc0dbb58f52428b48e4c03558178b4c47dfdfc0454fbf36da0b6e888943b0af4d15a641c480a76b6e3c1bea75b60ffc2a4f4c79b3916f51420f0d92e0e93222ad57db5a474487d30a96f02e70791290a2794ca91be6d862115458c22fc8a6efa50484ee067acc3520deff6da0159f4dacc609b4f206e61a9d422a12e251291bb960510e7868c5158d535888b35a1d114365323c7038684e71e35bcd7741edcc134435f9b7e0e740947d2fc24e200426ed4add1716f91ab9e762cf7c642da6741abe3785a5529b508cb4c2b370d6177c689b018875193d0574fd4b2b272d7fc182832820ddeac29d75e997d4833ea3c4f243d680032772f5b11869989b8710f37ed6fa533e188e9c9d243f82a241a138423cbe77023a502765b0b9447bfdfbd7c15daf4edd9b5626dde0a113ed688ffb3d73dcfe08081118d9b770aa7c15af60a6eba7ced993d4814441b4d69aeeb9f89aff5c53ca8ab2e875417eacc77a72f2ef2b7fbe85a5245b6ecce71d439a113dc699e107940523f481c484bb6a4575b8ea2deac371fc8d99b57d21c0476a06724637c70ad281cb2a65fecdf34567cdaa9f7808e09accca5cf768a8b00087b704e81e8ff056ba0c3beb04001fa6799c04d3247b01991d62667bd2454bd8c3f0fe06e3d9719cc531d1c869bbc61afe45b15e7b27ccae31c4a2bac4d86121b3a9bc6213d166178a564650b9dc3023141d39474328780060170b45cbcdb96c4a0c6b0cbbac100348f10a95a88315b1c609bb62242211fee1ea99eea13daa3a1b8e3e92c92fb1b39b13e6c8f01245e8ee603b7dd8510a7add91b92cff81f49254b4888440fb1f3b4c0e7b0dac41b7f79c55c2926a6216c84ba880f31fde9c7adb700b0cc2e32429aa46fb48bcbfc3f25a9e6a4fb9a4e5d4d31acb5397279a0afdd1a3af3df5d69e30be5b0f0fc1d448ac0e39bd920d71ad0f062283de72767740506c54e876bd3ef2ed224238eb23421020eea0deade3e2c50d7131ceac6f6bb306073972534ba9b019ae3458ff975ba18a957898db400e8c4cfdd9567bd8041c212eff40123e2a68d42b058b426029f7e2797e8a1f3e24359a0ed46c1c1956827585906f57923cee1854070c2aeaaaf22d55dabf65e6925141820f9de64e32fa6503738130f56b6ddd659f792a76805f02f5e2214fd417d43c826b476dfe557d0859e7d30aca0117c74c4a9513ab8c5d4b4a24a0ce3db8efc2ebe0fae3dadbf36c7bb0af5acb26e3db47abfe165e76324f0da44a24e9bfd7d6b512193363dc5b1b3604a8d4ba9eaebfa6f01317e5b88350a4864e6582f7c7f992acc2eb3ffaf01ac238d12508262113a5596c1e87de5846f1aef8630b5161da9fab974772b4807436dac55c9e6551195e3d455fcff03001471b10aa1c2ad81446b0242819c788a26a798add55bdd44157b3af4d9547dfac88921b7faa0c9616f0e122147e32b387300bbbadb5408c798032187499ae2991e673e4d4e29c432f67552b93d810242b564a84808947000ba3ecb190f494fd19f86d491697e48987ed688be2e23143f9edb0078f6dd6b61501467f47b229e155b31cafd8c199437c5306dd3cbcc7d3c6c96bc075a51d6d6249a06e995ccbe00a9835f49f8f3889f606b15646f6766d43e6cc6154180e0fadb9bdcb4ee11c32a965235dcf1969b0b4e46e67b05bcf06374419b78d580f29769702a9393868d2d359dd41aada694a7bf08a12d61ec64612623f16ac44e55487e9573e63cf87594172b480a5f7892b79183c0d3ef17ceb8bc66608ff423a8f7b7094b44fd8ef0004f0364df9cce24b606c0f5c487c55b8e70e2f86cd6fdfc7abee2e6d1d435b8cdad9c44488ccb50f58eff3b32a2bf9265e9de1b6cf22160eb447045893f010e727685ea853c4a0f61a2eaca9204c5bee89956c9a3a854160133130a9e0cb1b875cc9598d226433227cee568dad3195cab146eed1101089ebe2d014e942b40a8add71f4acc05ec5934c5547670cb0c282d71ae4dfb19ecb73da05216ae284753543ccd754c5f67da4c39e149fa5c62e135372523c807387222ee7b8d0608fa1ff3022489c5ce105ea26a8a496fd39352c611ba54b062494323badcb8ac5e1cb617c17ec7cf239c3981f0933a1b92fbb54f084968cfcc1e20b1a87bffb810d6ee05e1fcfff8551774732a3e6e312ec8debb7549f3ca34114c9658107dc0cc540c14915350dafd85ba1292e2b61d29185909a62e11fc60ef24584b961a9a73930c747b2d6090e145a8827fea854dbbfd5d9c8c6e7f3bd1dc457a10a8da5497483dd117cbf9c645c22c0d2c107836121a84f3bca7cfaabb894462e72dee88d98d8d578da88ebae41fddc014fca2d04ab19ecc95550221b7f8547cf5c4b523b07a671dc1d3eda476b44bc0cbece575cd5d4d406ca4e820b839258aaccca580c9b719bdcd34a3480e9ddc1c86a1d216de143d0305ae9143fe3eef58711218c721c892b21f6cebbb53b523361bdef5b0e4c00a044d0b40278a389da13d934f585621c737664f0232600d1026660f1c4579c9682249b7684a827b591a6b22282fc3c4e93a0147ce6dd22f17ae543b63f70b9587ff9f047d5e9fab2306862dae5440dee189a61c4c493aa334531b60f6e4b905590f38784367c08cfa4846ad11e941c29693c0f86d63f3f8f55987f62cd8a505b3234defcf0ac61848d5cf7a5ddf8023d9d746be7a36c71286ddbf6a0bfddbecaca20d85c2557b76e8e75643039052023d4e01202f0419b7daa7876b701719612a4e961dacf145e83aa527c5102609615f60c393278264d7e6135469ed08426083f19a31bb73fa59d2bd1f6826b13f235c552b6f8e0a4dd11590af6c807d95a6f86e535208160cf6f37b93f0654ec24d921047ea635abed4a8051e3382c25cba5814670f97a01b1274db234821a960186e2fe11a294726a1a77ae6351f52a3f5d6c03694103e63475ed5f2aa5996668408db7cd57d187320da86c8a6973622550fde52319e7bb4d22597b190d7216704fd856815ceb4efa3839a48a530d938b0d8cb51af05d1ef71fbca40ee61eec83a132805cd26eed082a8d4cde6dec92049f373680dcf8df25b8e06381f93a7fec08dfcaf3879d6fb83d901d8ed918ee2d4aab8c11f3d3d6c6d7d54e4590b32ad2c03012dbf2a65380a721a9c8f95c3394c34f9a5ebdb0b60cbeb980f7dcaf4983d0e7532e22d2878df2cf552a4129217e73db98bae405994b54477500d37e6281a508dd20752103bf4044f6e20839c1410c4a0e5c1826c652ebf4808e14e3c2b2e1d421673f02296be94cb19c1cf8fbe6c7529722de5735f23be8456153031698bc2e9de2558c0e94a8e635b8f94d57d9a47370218386fe01ba502b3814e1381bac17c6192651d08355a2121d5a772ad84344b2d41d6b20e00476625bbc11391640f5e2d939318bb8249b947b4eeb515b65acebb3fcc06e541d3f6e608682812544238a7cbe4bb2cf2aa4ab8bc16af32c27c1272c5b921e622e824f3ec08a55bf0f8024956e8047bf37ecf73c69d009036e5279337166dac5701b39fd301be9bcc2a9e0fd8d1a0c591a389b75b20d9b14ae4e06d84593f387627f8ff7794e20aa37501d8333e6d61dc7e9f6be86beecc745474d3e725780cceaa01f9662c1c28331e3998fa8490253ff025b881ef27df87f9ac41f38c1c432c1a697db200b5bdc0414ac389918de6b168a706d42211e1e1ab373e37639521822ef7cddf3654fc3de59f48fecde696b90db615edbef1d16aebf920401bac1d46268f8e0ed0c823ec23c914bdbcf249ac3844bead29c4445bb3e1488bca8bb005af870548ef7781c22afe680aea53364063c6cbccd0ea82c882561f171403b640a9da1935a57c9f66b840b5ddfdbe54d8f28646bd386d7255496d8742a20bff89e04cc9e92192b840b74b82d1e35649d43fed1034bb5edcc42bca13b7d06f08036035844cab522fbef64c804989b484f628a14f817ca4554ea1121b548395069ec4811c81f11a6085d5be904663d28777525e2e8c79e1ea86d060b8b46cbe8103156d46944ae0cd0016990fa364dd50151d8b192e5628aa183b29d2514dbb9e5cb63211567079deb6e83b57a8a06298005e8d2aef4e13ce451fce0c1ea8197e952b57dc725a0c3e44a1c7337667b7ad81e4ae4882028e9b3762658b0f9f23b68107c817b3f40a7286c6c97f2e9b2ce894da5585b412116d9310e7cc5c3486bd1e5bf71ab5099f7aec2146f104ecf2608c78c04dd4a43c0a5146cd57047f6086710d41fb288f9f5a3c67758d60f22110d004e1fa800b11a585d62f846208a208473068e740c2d8dffb5f90f601f7d8d732fd804d9f90612026a8f51db4a7ba355ce3ef1f950999e7f61965f9c8d4fbed5bd463758a983df581ef8d1106edd7f902378e5178c81268c19f8be038f07627be59497b1c3f884868d1379d54c42ec16ccbba2a03faa466343a764506a32af793d4338b1e1d28a4d16457caf6e0cc774b04dac864f247ec36180ee708d7830862736fe6ec5c53d85134a3bd28c697ca1a4f26722bab019b41e4ea49fd86f9275b0a7d849486ff8dcdfeb3ee6df09932a36848efc81dba80791977367af47211a1af017dca9b603443a035e64050c0e3440b0a6d0013c0c3c0c3c0c3c0cac4dfcd6ee9bc5d7da97524ab97ce9ce096e4a29a59452c2cdf63723967c2d40cd7e877df7ba2e6c0ed70dbe0ddfa863481815d74cba975aaf2ec590203a476a5992bb598461489025d6ee2edcc574f6c090a43c59563e919f4b4fbd2f2466c764394b079d46e675b099310d2f246bddd7e919fbdf1701e94262d0cb417c907e722139e679e7ae514d2a53700bc91dfef7e4c6f3b4907495561f479d32e9718ebd2c24c87c3039f371fb3f050b8931cb9faf57585ed849e30a0932a39a8af3b4be63b1a3618584f511b5397364068ed0a84292122762e4e4a6db13baa34185c4f52b51e97ddcacffd76172f83869fa230890292497a54aee393f0d29247fc6f829af55daa85007db45e1d78d2144969fb075b0f5d919398294919a061412e4c428992a84b6ca1e73d078c275f9f2264d73cfc88180fc7833d24a40c309c939c94e72f4d3f405f5218d262425b1ff2a9fcbf366b8fd40413ae041ca4817a0c18464d1bb7b25435687cff0f83276f805791f3c9226349690202dc8d05953ac1ce399f124681a4a48d298d31553a7e92955339e0449483a9d4fad7a315d76d10dd08c27c1d24042d288ebf690699bf124384252e806bd1464c69fc70401b263044ec308c93fba42c86832ab346b10d44da3089abae87951800611123dff7650f3f7df8a8bc610925ad3e429af0eaa33ab836d690821c1c72ad56b0999a16d0d62cef8114405661d8ca40d2f42cac9649a74088c4437cb0d3abbc725d19e3f011921bf4878af12a3736b5f249f30fff8d36620a417d5dcc7d8e7392f8a49061da14d5b0c437691b8b2fe21647ade19cb4d17499a593559a99c4577747aecd0418f337cf4c8c5ed176716e494aa2604178971d7b27470cf663a6576f4f8138c8c84dc2231e8e7bb08532d93d51689a3a2e788b1a09fcfac45a25de7774e9564be6841db105a24cc2913e93967919dd23a3807901d673e8b24d5793643b4c7abcd74f0c9f13fc8503b635924c94c3a87b6f820c5b40394838c330a3a3916c8f1a123082a837fbc0e9321b1480ca2aa82281de2519881105824a97a72eb8e5ec991e38e070f64f215499d5c7395ce1c630c3241ce2041882b924accf7c894c39e7f3f32c28307da562469beaecad14f9d7a2a84159cce31975767d00e0e0810193dfec7095945c2cf98f05ed3b111a28acae494d20ca1a61a19f1f103f5a0878f1e2323659cd183535121a848149951daa3c674319a3230323232f22388191d728ac4df12da5f79e24b363ad882949172849822f1330851ef159b51c60e2c21a5702de8e57063fe161d6c2108214552eab40c1fa1d7f28f204072187472f80892836d1489dd62fd9b9672868f1f3978c0a3ec0002c4871919228a44f9f752d597d45665371449bfb66a2927952bc5a486802229dfe7a89f214c97cc0c1f39dc7404219f48b2d0cc18bc647e07671d08f144727a514274f4b4b04620a413c916622b68f93a841349ea7b3ba68d0c05f9e14307901c6a219b48f0754b931b379f51dc41c68e9383c719659455eee0908c1d1ae82de38c1e219a485e8d0d3a2daeabeeca01e4f438c347e94c245ebf670e760fc423c70ed0413990d9c10348de0ed0e9b143319118f3a86039696653f2a283ad4c073eccc8c1e38c327c9bcb38a307865c22613e5d450b3a1a358f74b0315aa2774debfadc0e118db1ebe22abbb4f63a4c48259282c5051944a955d3a3104a2c206412090891440e05844402128f404088237698910120040869848fd403041bd80004421851218bf0917aecc8a18844209472f8088223041163841c22070e7284116288068414c2012184102364103a3081182182c80181904000014418217f5840881f723020a40f401410c2070684ec21070142f47080903c1420040fe8878f0d0c20e40e39c608b1830142ea9063871919f81f6764e00021744894752f61d137e88c17859039d8880b21440e494a897c79fd7a360e2170682a84bcc143dc90acf651fef225f19ae33ad8da02216dd0103624c694595fdb4b4684ac61e510a28684d3ea0c5e1bdedac05521240d1a828664ffccb05a2ae62d9b0982903324e6cf6fafb67f613f1a628684f58c2ba7923e61e92943728a0515b2d9a93445081992655f4399e5bf6bb040113286e4b1efca41b6889f0bf25c84882131a7cf8a2df7d0f9643e42c2e0798ba6efdaa8830d0c497fa2493577d4d29575b0b52c42be90e0e9f137c6907911e285440d962a7446ffcd967111d2850451633bfa52e9c75b4c43b890a43cbbe5e81a622f57b6907c6a31a932bd599a3c2d24686808354f41fc6f2c240b89a57ac22fe52acdc11a45081612ebcba2a9f5d9d7fe2157307ab698b3cafe484646fe070ab14262e8fd186d3de5cd1f7a1294a0472a42aa901c448bd40ca52b8f65a89020eef6c33a7d78cc9942827958b18a4b21697329cf4da728249dca966fa4dbe6984321b182568ebb282635ce2754df39fddb8dba14ae458813bcf6b9fe1464cd99086942f2edeffbe9df2e0b2ef338e39b0949baf5634cfdbc901589216409c92d9796d4277569bddb102524265df51393e2c8c8c808904643481292ff4c3d66114ad7934c101f3e6e9190b87145d45fbc74ba923ad8ca0f1f40caaf1e0c428e106284c48ab3a57ea9627cccab89acc0031b10d94019e60596082942f2a71457fe7a538811132141d73c8c59096521640849f36e751bc75486b5b1102284241553552eed92d1c115231889d7a33a34781ec50046627f3ca55375fa8b44f10e9a410c5f24069da6dd932e356bb517896d736daed9773b4a5e245a96539756fd97ff8d418c5d240595947d5041968118ba4832f5a0741216848ef7102317986b8fb6569f75b0ad89818b643f5bcb512fc46926b3053e56c002316e915c5254fa524ab648ae2a1d1a46d6b5483ecfcd71c42c2d087916c4a045e2e79cfb539af9b6dbcc22418f18dfb849098df9228b64f7a4d674bc70a6e2128be4f029742e28619158e29e5594ea2993f92b1246df3be8ce1b3666d91589296c3a95d6366669b01549279bc5a3c5bef0b322e184f9c770adf551bc55eca73b974ebea92261d78269dcc890eba72231ef7f7ad9a818a8d864b66f4feac3a7488e9f3346642c532465af783df5189496598a44f33c152912a35816a5faf32ab4681489998248dbdc9c28126416697eba83b4e48622b1ad368c9893f61d2ba0484ad16031d85645dbf81349b3b3f667a37474b89e48ca32ef5c79ce6496b413899eadb1eeec745e0c279263fa967646eb0c333651bfe9f9b09b16f51788a18994ccad0cea96c94462051f93dfdad5cf0a2612534b837612f1f3499748d0d749d3b2992ce5499648cafdd89b4a6daa60a74a24dda9f54ebbdfd466a244a2c8ca9f44dfa6bc974924db970c1fdb8a1b172489e4ef74164405f1996e148924a9a22f5b4cd2736799871890480e4aac3c75d4766ad1239293a7c5a09e2b652cc711499d52c59229e8b77f4f2392646811d3b031663b3122692c6527e1ad7e675a44a2c88f7a4c31e9e07f9c5f88a188849d93f91df16d1e4a446238af9c94d260f6594424a5d9c6d3233f44524c1f358648fadc1acb4594c53a4d219245e7533935a5ddfa0c2112e4f484121a2f8348ceb4b4f60cdea3f42288a4cebaa052a564aacc128864cb5f164725ad41690510499ae4eab958b698cfff21c9faadc2c2e4c6cb11cd0b62f8818b6319a675ee43c2a694f572f7a71cdbc287a46f93363a7849b9f0f7909ca40771daf63a537b3d24f8f865551a193526e521319a9b8e23e7f762101e926dbd5f37a9f9b8983b249cdad5e8f9c8b4bd1d92827cc918791d92a45f66dd4c15d4764e87e4abe8b19da73924d8e94f112d92438b1187c41cf3e27e5abb68f9864382973c999eff37247c650a111d36e958b71b12fc3e281d3adeba6ada9060eda9eaf2212cf86c48d80be2d9d7212fd9bc8604b9cbf824f4c7fb931a12d53dac7cfe15230d69be929f13f9d1f20762a021b952848d8e5a693f674874cb9b3a2a8e92bdce14c43043f22571f9fffd2d43727a4cba63d6902139decb989ef78daa8c2161e336f3563f5b921892ff82a8663d8879203dc8e8b1436403224148b082118864c0176284214146dd2a253a1892ebdaaaccfe4292ae698aedae179294f2fc2c7759cc2fed42f2584ed5582fa37ee11ca7c7e789acc0031a0431b890947294dd24b67aedd942e297ff682c8df9b2cbe6878fd403d90501824aa0834f41ae14c4d042928eb625d46ce6879c74b0a9a5b48303a92410230b4973799b6fd2c442c2eb27edbdd35cbde61592426753b74b2b246c9c0abb2144e7fbaa906c252c68b885cf990ac959a95236fedab89553480e252d8a6d9039788c14923f59d09f93d9442e51487ef798849bd272495048f4d0496b87188be53f21a953e874677242b2e888d437bd09099f27ba43be4c48d21f25572df9fed7401063093702440c259c1849b011319090f0ff2537d97a84a4d31a2b25bd77493742923ab9d12a3737dd8945487eefd16d29733b37119246e9a7d856213186909ca19db4890f331d16430849a1498dd2ad37cfe6052359564c5975897909188969699fa6b66d7afa45e2bd49bfd3a3499ac51749724ed3684e3b637e2f9284c57c8fa774f6b2a0e645b2e54ad129bb4830b9d32857bf19eca4ba484e4a6ba9a924fcfdce45b2993c15ee2fc645a259ca723a9659fa7d8b048f31c6f4d31d44b9b648cc9e156e83d26a916c7226a3c511c2984518b2b8112e61c402c3804592d22ca5fd52f68a0475b9849ba7f27c31ae4834a1e7d3c88cb59dd28ae42a299eb462caae9a158997463ddea28c29ad421561a42229946e4807db1a8f471384818aa4f4af94c54d748ae40a59612fe69cf2548c2912d4dec5cb54965224663959ffa5725b4a253a83c79f7d200c5224c618c4da6a58ca744a3af8ec0cb74118a3484ed1de75cd5286515f14493905f1a9f4648a97b0870990192610d98088193e7e7040032323188ac494297fe5511f4637680d61802231c8a8fbeb6b90b5d7a1218c4f2476fd0739b2a2d98510310c4f2478c5e9d1dfbd223f87184627123dbe43c9146495a90d3d0e617022a92e05a1940e1783218c4d24f9c92dd5f0aa11b77e210c4d849189041d4bb2472721388481091bb1302ed1c6caa14f6847fbec2021a3c70e5486856189246942278ff93efe25111dc2a8445250259aad2aa9932927876518944890e182db8e9d4ce8d09f42be1a8448fc507a5ce44595e6f4106a0c22a93f974acd8a29e7676b0822395a2ae5275e530a5b92608719195095438d40e0d982d8a0ab8355a80188e4f54f4286b520347a6d851a7f484a266c752c3c054dd6f04362e8262d6b29dd5ea8d187a438d9b94d66cbc8089025430d3e24587d92fb7cfffe5829e37ffc0990193c58c175a1c61e1263e96479359f0aed590d3d248deaec9dd93fc531711e92632ef79799fd978e19430d3c24a64f5b1d8328ab4b221d6c48841a77484e9932a6bde37eb5496b416fa0861d127bcb62185dda3a245f5ed212ab17f5ffab418784b3ef1821f4203d7ee7903c1fc22da54da6e56064242d07e8861a72485232f5c48a6ad151e4232323233c08c2832087861a7148d80e1befc12d7048befdbc232e65b0ed3f488d37248767de58792ce8d1ab861b9266743c34ea5fa30d09ca2acc9f4c5aa4880e1b92542ed3d49e3fa9e9b286c4d121a4f58fb0861a125e6ce3dac5eff07ec2458d342455cea5730be5e2a1e1ca721bfb0ebdd7b6cacc98e74da58d7e326e7b86c4f8b3b3cc1eefd455b9861a664890964a53b28a9ddb353f428d3224488df1e6ee84681e1119124d8a7aed6c0bbe153386a4a4fee2d909f1e3492c86644bd3f1f7930a7dfb8621616574f6c8ab604890f639a88dff47cdf7179242b6d5925ffe5851f542924a7a34561032db25651712338c4e4a738a514dcc831f2938c10f1f66d4e042928aa25b72de53821e35b6909894ea5cc6c8f54c6a2d70fae12ba87c6a6421f92dd567d6b0fe0a4646c8f883821a5848f85bcd4d57da5a2e56e30a899f19343f6d1ceb80e4e8f10305d901da4b4180f8d091e3320935ac907c55624927cf9cfbc51a55483a551d96539cdbaaac0615928392b5791753630a968bd69ba578b7dbb57c50e1eb7b1adde2d535a490b03995bec7b56a4421a14aa7c5e76fca2451030a97d67eaea767c8f6ed68dfe9d211359e90bcfe97823aa961631737d47042c299da9e5113cf8ed92624b9299d3e1e9f4ce4abc184e4120f72467a9690685ab4d9bc5a8a49f64a406e7b37e79d3592901cd7e39946d7bbd1ab1e6a20214968cca5517450f164de0f358e9034f2a2a3525cc63bbf8611aeaa5235d15d19b5a4e3a353744fe11ad42842a2a68cce09197df4c4358890b863233e4cfececaa5c610124bffe554be0f0c35849074e96467d0b89bbe2ec148b4f0ef7ca1a6e3681b18c9b931ef53b4d68b8a7f91b43977bcf4e23996e8be48fc4ff23e3dc9d4f0622f124d566392de7732d413e14552ccec419556cab83289ec22593766cb8f312931fb7240441709dabe3a6ccbe598b49605915c24e8fd1419bee5d12c480c22b8481495ed1215fb829a7c8ba4b8fd299b8af296155b248aae8dd745512d92b2fbf8455121b3e7342d4aa19a5f9d2d7554641649a5f267ba7b278b64cfb04b1df4a7f42fc722b16d4fef3def2c6c460416d8ce7e7d8e796887dad46396933a1142e415091b8366bd5c1f73cc8bb822b9ae82cc7b3ba7d39530106945b2a6d6c8db95cc53212b92aa366be97f6c1558a9ac679755ae97955bd8e73cf31e115524a73b993b745675c5f6059154246d6f67cdaeafecb2a322712c08edb19a97bdee82c82992b7455ccc1aeeea9a4a848829125356b4586a8a482992d7c55296ded2b9248a90222995a7c658f9d4ac09898c22f1632efd781953c55744449194d206bdfca0fb538622a1482a5533fe35da34fd6dbb82082892468b8c3af76f339a9784c827aa58ada946e6d512229e481a1f25df9b5c14e48f192c7082482792642ed149e6577d44389174a12cfe88568b874e078a6c22498bc56c97c64586859c02229a484a8fe7b32db33372cf4482957a7e3531632241b5c5987e9946e74b15b984ad5bd2f63b8d442c915819cd82349d62be7b229548bc9329f7f396edae9201114a989b5755a6ab175a311beb157733d6cc2c476412924812cd2a9b1d1fde1fa2482492d44af75aaabed05c041209a3529d183ddaf5ef3d883c22412fa79434bc5e76cd3a22b934d9e89c7c4f10883422c92ee794615ee5f453189114475d96757c67d3f422124e99b2d12e3b953f24a288c4182f53ebc21749447236dde7a973d3ad8d228868d73acced333bf73c337374721d6d6a91432457279535b99ec4e7141143245feecc30a71e36e67b0b91987f2283ea6f73e4d8116440032618810736891022c95ce77457a9949e2f3888a453cf3a31e1f93f1544629eb9cc6ca13d27730391eca5436cf3fc2bfe0544e2d7498b13264f95f074b0f1e0b1e306f887a4589db22d26ef7a20e28784d3be6aaa553c830a81f421c983cca26af54f4f837c48120d1b3346bcf29f6e0f4916c3f4c4c2351e88e82169d6f23bf579d0072279481e9df710b556a1ed15ee40040f495bea747aedb49f63d4ce87c81d12748f8a7b6a36c72d931d12be945cfc6eae982845ea90982aec4b4cad9d6b4687a48b213ee6b7aed5ec227348cae1c694fa9a87881c92944c9ad62cf31e8744cd1de4c6e5827fb8c9804382becfae0d44de9028522f534a3f9b1553071b101f3ad8dc90b0d93dfee624cd2d2e3f44da90143e8cbe58f2f6d1251136245558d2fc7eeb076021b286241b8b22cd5d94caaf226a48d2b39cb4e8cb4a41643e500791342466b3aa58dbd13a67238286247d37e2a16497ad9b44ce6099dcf3246a592c4e015041c40ce9880e4aaa66741029031b6774c894d5cfeb8408190c2ab3e5a457bad49d85c818d20a599dc2d635c6e7122262a8a4df6dae954fd79042240c85b3ffa4b9ca4c1f8508188ab184362584525234a210f94282ce2497428b3e2bc920e285a4a0c666eb326ea6fcbb608c8da3492bc285bc6b35d6f2acd3dd46857ff9f28fb12d249fcbe536154f870acc0e7b8288169292eefd15516a544e3a59482add143c549a8a7163b090244a860955e335a351912b2c2b6621d7f672b1a161439ddc3eff0aeaaa41c40a89194a48cbde4b31968e1b44aa90a05452e3dd9bd3233b0082c44e840a4957da8332a554c0203285c4b9a8153fc4c8bca3242285c4732de59a8210ea31261285a43ea9e939549cff8924f884081492433ebf7216d9f970f220c80ef366fc065220f284049957df9ea2f9617804112724c63ecf0e5e8e1c3ec86822883421399479ae890bdd170482081392df3a840ed55b075b8e2b82c81212f733ae57f4b4eca7d7e9105142827c0d0f2ac8cbad699484840b399ffa2d4fbfa815031124245c50a253454eac74237284e41ca72daeba2b62840419edea9f64968cf9225284e43cb6f7d6ef7331ae081192fb923cb7d8b7917b8b0c21c92cc7f69349cfe8ca2242482ed99983e8186f647774b08d8c0441648c8c88acc00339464602d0051ac1489c53233aa2731ac0486ed3176a360975964d347e91606fbebde6a3b95ed1f04572acb82753de97ded5d0e845e29eb8b6f120fc540ce2458250b2d3bfb2e5dd547bd0d845524acbb15bd49755c734749118f2436d8d8a8f56522e92f23bcce57bb28ab5d3c04562c6301d540aaa4cebfb061ab7481a619a477950a1618ba48ed91acab272d0b216c973d147882633a5b6448be450714608ed1715ef328bc4cca31bc39cae4f715924c86c1072f377dfe6c7a2cd3aadbad7c0227965848a8dbf22414689f5fa8d8f61775724f7a8b5684cbef1316f4552658b7aeab65991f0c9b26d6dfcc79a79150996a24d63baac2a12acf2e83b6dfbfc9d54245e9b8e79352ae6102a925b73b8c8a0e2c3594e91a05b3408311b34985c4d911cc27ddd74e594834a91e0b1d7ff4f3db4a593148941f8e6f4b8f4399e90c62812d395c5d3a7e4f9cb484314492e3aca08d1ddb34cd1084552b95c65ce31082d0fa2018ac452cb6cff36cba562687c22f9e652ec4eebbbdc2e0c68782241e7cfb5644aa9130996b2d2a7c93c27125e740e2a74f77f2ba4b109abed6ddc74673fdbf5743d46efd22011d0d044721efd7649ed670f777b3b412313e6c793d1d47d9c7a8fa08189c419fba0e6a9c1058d4b24c8061b59398833a0618944ddcc19468633cbe8a15189040da12b285dda4c5547831289591dc3aae48536b94f2229a9d2a93f56922412348dea18f4e4e7e56944c291936371296bbc40031249b274053fa5c28c8a3e8d47245ecc729e513d2f77d411c9a62f6d8a779b29ec78462392830533e1694d4399cf8844cf0c72f3f1d2c9b88824f9b20f1646a559112a34149160d1b277bc19bd58727b1a8940956aca6ed072990622928314cde45ed521924e956cae4e3a5ecf3444a25ba6972d254678d21622396c06ad91a362ecb81122c154af6ed77883482a15d3d031d6decd4710893b4aa513a6b2fa5330104931bcf9c7a4a3b3c7034462b6e475594ec80c3358f08704f3d91c399d626cceee007de007d2818f111c0d3f24c8e914b731ca9ad0a51ad0e843f25bfc18a34e265539b3659cd183061f922f6e8fa7d5740f49c9c574da9ddd64a3d543c2c7182c26b1dd1df78e202a28c3c78f0e0401b2659cd103c9a09187c4a8ea2236457f2d190f493ae6694c9573a894924ee30e49aa2f7ab7ede5b55d7e201de6c72315fc08a202b31e3f5090206f06ff080204ed9034fa7266b0f052ca4f1d6c9d829c01a47f04018248a30e4959f9a4d828257e5cced103f16033c3875144830ec91f364bc693c53c37d20dd09883b929934577111d0668c82141855e9ed1a571b3dc1c87c44f7e6319f2b6c4e7470e874382cc2f9a538e296edd5a0ed078437297c9c8dc95cd91f64387290395b16e482eaf1cc53726cb0a5b1b92c4c48b1a3f978d96a6c186c428972ba80bfe75e9a7b18664313d57165f66de537ef8f8f163ed47102047430d8949e4dadd76c6cfb8494372f438f30ed14f351a926f5be4465ef2d39ad180c6199292ba8d4ab9c4e38f6686248f7eb916fef7f561591992d4a9dcae6917206448103d3266be1851c7aedf9833bb08ed22d195528e9742481749693183e7660d15f3c94552262573bcd1703af3661bd1bb3148efcc2d92c475d8f7b6b82d12467c8ce9d02efda4d722b9cb3b29f149060fc2a645c25b8c29d95a18bdab6791d4a3d3c76b102693686591242b5e94135d2abec35824a9a7dc7bef1b222e8445d2998714955f9120cbdd3565a5505f9d2b12bd34690d426863b42239db9ee92c3ec24335062b92d7f488af543e5e9f8fb10a4df6deab468f6b490bcae6e4828a833154911c63deec96261e2315a6d9d98657d95e69aa17640c5424666db424f3a838623705c6384582ca226327f5397acc6153249ec5682a75ec9061636394c246c62045c2864f1ba63339c62812e494a5b5ae649ef51745d2ec7a8dca188d4fef18a1480c276366d2b610724ea048ceeee0a7dcd38dd6cf27922d275995efbc2d84780c4f24e6a441f4a59497f9b5313a91583ac51c2da60b2712c326a152de86490ffd189b48ec90a1399968f39a75046368c29b4b8b917bd752d9b193f39892a58cbd35462612534a4f19753307b96b0c4c24957253231a7b358c3ac62592545d5d37682b9d92c812891af4266d6a7c4b28bf12c999fda3df8e4189c43a299ef3848eff718d3189047d69a5d3c5b244c7b0308624922e8c7de6189612c42047196344223169deb0a856ea7448247b8b7d4a5b574f9e47248e8899c6fddce5c6118996b1c53759b44ce24624c6944ec9eb2084ce3222f1a28de814fd3256bb88e4ddd3cb32fe6a6a2a2241fbbbd47988886b8948bc332b212261e3d6cf8e7f88a4d85954b2b18bd5d31049a2f365ffea0793262a44c2cfbe27e97715aa214278a7830a0d22f1a3a68e58fd5131238804b155dd95d72ada1e88241dfe4f55b48048ae18d387f130b63b9e3f246ac71c44fce8b8fe8e1f6eb5fdf434aad387248f0f6342457c484ab1e389e83e551ada43b296e6cd67a63e66eb2131272122b4935c8c6af290d8af1684a9a766a8060f49493578cce5a7c2c5cc1d92b7cb4c8ebd6bb87cb143927ed55df90b4ac8b9d421e9d3cf09b55367fd163a24689c28ab1bf72e9539247a6cb88d5c39e995974392550c27737a9967fd3824e77c313595da73ba1e0ec9565b662a6b97e8e60d891d5ad396890e3e7a3724c7b06f2fd2c64bf66d488a9e7c84e857b892b321295c124d978268dee86b48f08fab67b27335247dcce29f92309339e669484ad6b9c2996feccc414372109a3428b99d2141a66ce53b164a2fc50c49eaf4ac7436a1675386c430cab27ecec99014f4b7894af51892b2be6425e55e27b2189244474d9bff86217163f6b777789313c19058f9fd64903beec9eb2f24669355b92bd65e48f4cba366a4890815ea4252e5ca1cd252980b096349ab2a8d25ed71de427230cfb97c692d24590c1a2d5bf8ad70b3907cea99fae23934b58c85e428f2bd5237e85239be42b2b6e62c623e2fd3c70a09328fe9d5fa1a1d9f2a2495af6e25f1398ad2970a89959f7dd2533b85e4cd514d34884a6d4152489ebdafea9c12852411eb98c5639d760d8584cbaf5bb35d9e3b7e4262be52ef692d7d2e4e483e991963864a219e3621514d6965369dedfa9890207f3a65d396f5354b481edbb93f69a9129232c8d138529484a4383a8867abcea91f2424a79ef1937bd962b41c21d9b5b2e8a02d87fab411924ce98d9e545c84e4af33d99a1e46a7770c22249eb450f2ca643a4bc71842e279b2f7541d574999630821a973d8fe35753d9bcc6024bad8a7bca9b4fc63022331a8944d6c877e91a0c29bbe9b6fc824e38ba4f8a132a4c9f07f4d2f925e53ce8b84f7381fbce46d0e7517c92bf3315c4e624de6501749a9cf7d2d3fcc45d25b5c0f1effad4f848ba4ea4cdebb955b24988cdda1446f8be4d8e1de321f65e35e8b046df1c4ecc65de79a16c9f9e4c9f96716491a94a98ea1e665ad2c12446db77c476dc422a93593123a986ae7d0062c92da83cca0735fc74d321baf4816cb694c7da7b8f36db82239edc6aa33854a6b6db422399a52fae4bd2f8a6a831549a75cbe6d4bcf8eccc62a123fc693ffa754f2ae6ca822295eb8a0be672e6d52d94845a228ef646dfa53b7a96ca022b9b4b629b110a349a86c9c223966451955227343a66c982269739db4d49a33985f364a915c422bcc5736b320b6418a84cf39c6d4355f4eb6318a8437cd5525bd3f63d48628927346d552567615571ba148f4f022be62724a341ba048cac9fe2b89ab6c7dd9f844b2855042c66a570b56046c78a27c1e838ebd9eb3c6f646d8e8449529327730dbeb3971ae281db309734e9cf56ecd451359b6f895e75644eb994086d8e9f8adf4615c4c281a6475ce29ba44b7f3a54de6f89d5a22f9ad695fcd4a9c3e66ed62d2276da4049bcf333dc911224ee2347a32faf4c9ee8792f835763c13faf23bbd48ac49e8ac2063fcce8104db77eb513e55658fc8325a89d94ba323b00dcdb9be9973ca46234e3a93e9925e696c5418c1694ea67bcb54fc0bab606311bb5567140b8dd58a0190041b8ab844ab6dce0030041b89f063ce4d3ac67b610311aa49d90e659fe31d024da9a274251517360cb16c8f10993759d274858d4264a3c76f57ffe6f654d820c4db6147a48999912983503cfb5aa7204c23850d41f441e4f7c640f8164a36e8d9e664967fc20620725f1336fe90ef5569f53a50091b7e505cb6c3c3bc74b793b0d187048fb1b8902d9e16b336f890a826555cb3df3a051b7b4832fd9bb4939ad6eadec30790d743f2bd752c1937287711ca43921ab5ba59379e8c968387aa74f3ea3ccce3b366ad18ba47e68b8d3b2466799f9dbe8e76e243860f1e8d2588410eb46187cfd5652b8847d23af499c3670d72c3893e78201d8e5f7d32e651be07621f234836e6a0bdab55d8bcee6c94afbeea14bf1624830c1f2330c347094646c8f0c143510e09f23ee8b44994cef54e42c0461c924fa8d2699a14e4070e80a88e205f46965176f0c812c42087046cc021c132d6464b0bad8f15d878435225695a7d8e3e65f8f8d18133d8704362591e9d72565907db29bbc1ea9961900a8000413fcc28636404e5e0c7192687d911c48c1d3c78a02fd86843628eb93a65f074300292c3b4f128cf031e8847907206901d3e4e9081947e64646464f56e80041b6c48f251fbd023ec3e996d630d36d26ab0114d4362fe8d29a8a99d94b3d090d439d55212eba072a8d83883da3043d2e8f9985c548644ff149eb182c90f4a4486848b9edbbba24485b08c21b173072174e7dd656d312428a5535e8a06b1f9e73024dd8ab7e84ce1aa93604832bd33aa74f3cb5efa8504cb53312f245e520bef198d97cfb2d185449322174dcfc70190ecc065c00617cab0b185d25e45dfed762f6f75d73ecfb384de8c0d2d24975ba787bbb917cf8f3f030740960536b2909cc16547830e1a64ced1c1c6e38c32300536b090689de92ce9a9a0393e7ea01eb4151b57485232954ee93bc78d52e2f165fcf0d1c35f60c30a09be9a61e6447abeed021b5548dc0b35195e9dba846d6f076539ac6cf56e60830a09b2ccbfe3c6d26fd7994272b0532beada7e5ebb0d29245752325996ee17f7141b5148984dc9e37e8a470b0c6c402171e5ad47d46da38cdcc613923bc96e36a9fd79c273025b2596d9e2f15d72591a16af555cf3c598b3d184c4d159ada25e09efca340a369890589743d388ad133267ee051b4b48b2d3ba20a368d3d799a6820d252489196b53418b7d6e2c061b4948b653f56a6f1937efaec3061212c3854b3eda84828d2324876ec89c6e844add03368c90d456329f1c193fb47db61bb05184da5decca4eced6f2f664d4f09d3a9f2ecbd8c1c36d102129798a6fd99490cd9a1f425289d678f331294f72d91042d286d8b47d4ac6841ac148984fa6ed74d81190d771821c3ca8018ce44aa6392755b1b679f38be45db7ec49caa960f795a1862f124f6c55d83836eb762f123d4e7ecccf5a63b1e24592ba77d29a37a23d44bb4890fa65a5bb275d247fbe9d744bb7629f928b6453ed8d292793f19a635c24e84cc9621296af4bc57f201efc0878bcdf22dbb1373dd399cd125fdb8f293be7044164d8f1f81e3e76a02d6cc46b51831689b9e6b6f3db28fb2b6791e829ed6e968592c9375924af860bbe39ce092f5d07dbfd0862468d58e4c122a9f62fb5467f4b1de45724ecad565d525f3bb9ba22499ed9aca77d2b9d9382ec00adb5224935a7b12ae5fd267a5674173b5e5beba562ba42570e517a2f193b8ae1a0c62a9232ad93deceed6823aaa18ae452fa43cbda4c4552d29bc26a90222a92753c55aa7e5de31409f2d24613daf7dd84a7d114c939a6f4ca6866a732032ae0c006c8f8153c9063929111327e05271819a9518ac420c44ea8bccd955f22457265a8a0a739388a046ddef9a955144572a9a0ac6dd7e3750ad508459285eda5fec711224d1d41c8e8814630325203149be8a545b94bab5d8f1a9f48121f7438ddcce91b3e3ad8c8f815d4f084f29d171fbaabe3766ea27c673f56cc2053a313c91be75c94ca5e8313894155f8f4712af4e7bfc62612355484d88d9d2692aa2c27a13c668200f171821a99484cc2d4d857a88189e4d59c3a226731da9e409ec7061c0b352e912444ac9bcd46cf123a4078f027e81a96488e39e8caab644a47fe352a911c4c83aa8f55de207a4a24e58ba182be6bd3b1ed2492537dc6cfa66292484c9f6b84ec3879a7ab4824c52c7bbabcac426610241237a828de25746afbf811491bd37e63bcce117c958eda657aecc7ae57be6ee61c6ac4d788c451155390d7a2c9db5236d4604492fe79b8564b0d794ad545247925dfea0f2922a94e883b8f175b6a39aa9a88e4cc9c469aaa184544924e2d2b5fbfdf15cb7a428d4324faa63fb9ea159131a70c1f41809cb181911135445276b90d63e55d6d2aaa85488a6e49ad01415c64051e10e1213c400c4996730ab1ffd529e2223c200c49a5c357262156d3777c001892f3548c2eda6a0502a427f0802f24ec96ea789c921712935e713fe5a72e249e38fdfe321f52ace64262a7e09a346c6a0b093acc929ccbd1026321961b27f2691da3a5aa2582076421593d65ebe025de4e8a85a42a7d4a9a6fd68c4a1f7085a44ed9546770e0015648bae816b53bff747e3d880f1e2a1819c9614082f8e001a48df0802a24d8bb958af9e36c744a850431115949d6c2642c1f3c600a8979bbb3c6d86e0b6d4b21f12ceb64735cdb7d3f0ab56abc9ebcba085de11e8742c2a57df7d7bdb891bd19f3039e90a47f6347b49cd0262b3b4e8f337cf0a0e4e0010f331263f0002724b905d79821de765445075b0e761ce480f79967091ed084849f1f4f751b6d7309d5151ec084a4bdec16fd963ea3298f1d0508193d76e80892e30732e3014b48bed85e5971e66286fd014a480e7a2b443ea83b75fd014948ea113a5f8bb49ad359183c0009c9dbf92b88b6a06bf61e21593699ec0b2b1ae11899af1a1b79cb92a9153ed49a123a0f284262589ead986e1ef3e8c8c8c8c8161e4084241db9b37af94ea48e1e3084644db96ea4d68f70ddbce1014248503a3a87f0d31816e7602407ebd3a63c4bf3f69b8191911cc0b0915fd8e3f0858de0e8457212daf4ebf3c88b649dd512cdfb9a51c68e91111f3b70ec2229f35a707db3e822c973becd3c97cc4592cccebd319db07091b09aa9fe9b1ab35b24fcf868cfc1343d8f7ee4080e5b24e84e2a9dec33d59f453ad8768074d4223976ce641ed655a52f203fde0cdf8183164917e3c3820c297729cd710384cc40eb816316c9f39b938ed62e5da53d4a01323b78a86044070e592468914979d0975824aeb7b5cb7da5d8fbc2e2b23151d156d315ed7a8d51fe2ec2fbcec5f18ac49c3c9c775261eab22619872b12abe76dbb732cdaf8d88a24d11027d4b588cd16f7f001240438589194542625c472f8a668ae22713c8618d9691d6ce8065f46290e55a82b9fafab71bb9ee166413fcda74ada5460963747f54f06072a923e7cc9681f2d1ca748ccd9e4cc66cfe330c50c709482143682631498021ca248d2595136a8607529c770842239a59e8ca1648f4ecbe10045f2866a8de5e9b252d039fb446287ed31d7cae3fb164f247ea7e9a0712edfdb8aa31349c1c773e6ce5716dae744c258f84fb27ba201c72612945e92d37b5f1a3e63061c9a48daf7a42ed3c604a8870956802313091ba3155b4599ba5f39319118731a1d6428d5756bc1718924d1e21ded2d16e0b044729eaf57cb2f73e1a51f3e3a70031f3e46c0e3cbd8611007d01919c15189642b954c3e57e6d879c741892459feb515448cda873826916849893511252ac7a4914492e88faf39f7317cf99148aa99f713bb2ea6a126c40164060f560089c4183e676355ca0f1f397afc406c3f509700c7231274fcac5aa6644724e6de94612f7df57a12472312640eb3ff2694d60b6237030723127c3fa9968a62f266b48824aff0d714f29f62301591b0a2ea97a298f60ee244f077713a8ada8be50d702022d9d6f3bd654c976c37b4018e43245caeb4d3d9f2609de781c3105b529ea3267b80a310492aff762d997f060ff4c30c6e1c8448ec5439658b4fd1c1964307a8c79a06700c2239b64633a7f45599541d41fe04a923c89b913c087289431049ea922599f9b23f105a07c20a1777b517b59b931931bf8e7e1d4bd311e44f3032a223082012df2b596c5bbfe758da9176040172c68f1c4076b401e1b123c81915c0f187a4b8b94a477d08a5c282c30f89eb1533e7a473426805471f92a3fb7f77b05b80830f9cba97a7ea596ad6869c10311b5350312799ea60fbe1a30365fcf0914646980938f690b4a3d14a993e89a09b80430f89f31efc37e8d0dabde721290559a92e5dd0a3c1c643725276b2423c8a86d4ee90289f1d4285c60e7776ad66cac565e5cd4557b9ea90d8659b3f6a27e19e3c74480e5795ca3b863c9df51c923dfea97cb0f0e6f99543626e78390e89b1f19a7537a6ff8fe9601c704852fb537163cfa8189537248cd0b739c5fc9edaf46e48ae4d3bfd23c3544e761b122e3785294b31539889830d8926bb46eb5ed0bf4eae21d1f2a95e0db3fd62514382cccaa4936b6eb768d290a039aae9d3a5297fde6848d43da573b4f7e0384362508ff6fee7e230436292ae3184d9fbf85c10c051860471324df4ebf6c123873d10203b82f4f8329a074182a01f66ec193cf8812588410e0ce02043c29db44b6ad67489508e2139a54c32b47c968ecde11083357bc93a88b3f452c2118672874f11d23ec52a7fe00043e2a9a6eb51cb6ca7ac2f702a77d626329b9a547b6c2bb4e787c30b093b1bfc34f9e890f9c339ac0bd7de95e95967b658d40d596bbbf07070214134c50a4a76253fadfcc851868f1fe976b0a3036b6639706c21b94e85cab79025447338b490bc235c55dedd4ff43732827cc09185e48e2bb9b9f5ef41581ec08185c452d1d76369fbec1a4a38ae9014d25abd427a3cb5bc151243b34febdebcd7bd554878cd5da974a5064da24292f6af9c9b1ee3e9fcc100c7149264d6143b2775d14ded52480ca5d964c8cfdfa96438a290c879877a85b86adb9eb7458f9e4e1c5048fe1fcb5ad1b252ee0b8e27249cccc1b2b5ab4e485aabcdcb3a99cb3486a3090926b4663a357aabd385830949297399929dfa2ce058c2bb6afa47a51cb320bb804309099f4b4fe67f519ee6e3051c4948aeb3b8e2404272295d4ddfa9c47184640fabf531a6100e2324cc5ff7a687138e2224df7a88b48be32042928c6ed6af6cde665a39e01842a268cf5714d9e3104292881ea9b1993348398f8f0df41f6e0423495ce92dd110a567fe3cdc0046f2b9e7b593aa4168fd5ee0821bbf486c519da3a5dea8e68e2f92ce45ecfa73ce8d5e24ba0971295d8cf222b5f750d72bd1adafcb0d2dfbc972661789ae79a3c7547f431789a9b9bf2744874bd91bb948f4ec76da3d9d377091984a4c65998b75962b1f901f676ce0c62d922e7c7a65f094c3853dc8192638e3862db0ec49dde995cd03b9518bd64a754ce43d4bab7274107246745aec8d59e00d591484b094c2638c6ec422e9eb64d9d7f95ff2ec062c124d26bdcc6946c37d6ebc22412f8b6db6681d55dc1baed89156f80d56ec0c6eac2241af878db3d95fa39954912053ac97305de5e29f542457592a6de1e571175434ef2df7eae2b1aba5de69ee847edb9c22e9c3e7ca316fa93ca531456298f352152da5144995b33d9c5c8c5fe1428a6437d5231a544691bc5772babcd477cc8b2229a6fbbeec872241a59b93c14fa04856f5d83223f54f2455880c9f9ee389e416ade3a142c308954e24889f5332467bbc587322294474ba7f973791f075b941295913c91e42f5e8cc1042be9b8904759552941079ae5e6222695436518dea6531839748123636731def1e427ac312c96934a4ca5da87db96e5422792c96fc0efd3166c86e502269b34fc71c4d5658f56f4ce2f63815dd0acdd7d497e3863185800f3724917471ffddb7db2eb8851889e420f3a2f225b5fed3f11b904890493c89b985888f48ee4e499df0f831bb891d9124cb4dfb648a6afa6c23127453a9ec2eda9e4fc888c44c298e5896ce6cba2d2239f77ede8cd2a04ff68a487e4dfaf235327c0671221e1162e43d4708831b8848b67cc1ee364c857c7788c4cba466d264c7b314338426ab75b997aaa726d6999b53c8b039995e5d88e48df92da5f57e8a19234482a8d095af744ebfb45be1c6201253e89ce2053507018282fc08f88620123b2eff978c9e40246c6dcf77e84d326d7f0310496a3e45fbb49ebb1b7f484cf9b964bcbf4cd2573adcf04382b814d4664694b2f26ef421398e092b0d56c1d4e9061f92af4567bf4c1fd5c7dd43824cff7ea6362a6ba67a48de12174b2ef493e8f2461e92d3ba7e553fd667c837f0709f52d1d197b61b773063deab52bff633c43264c8df1f6df143c7f4e1861d92c24aa7c98ef99cdabf5187042593c6642994b2cef6a270830e09da9ac2c3777c393f41e1c61c12ef734c75ee0fa64275430e497973bb95123acecc72841b7148acca188fb712b6f6eb136ec021b164f059fb6f1fcbe41b12d3d5f9c99ad90cb272c30d093757e2fe448c8dce720937da90f463bfb163cc978a3b1b92cd3f2fe918f51a12f5acd3d1ad2c577b592da12d544e0b2715c10d35249f558e9ab42a54a92a0d49ad99c152e67b0b37d090d8235235c9a558513c37ce909ca962fe55bfab7bc9811b6648fc1ca62c8608e9a7a61468e146191284c8fe98a4e8c890942636349d8ed9646d6348caee317a7d54cca5a51b6248d079834cf992a668d58d3024954cd31faf72293102439276decdca1f5437be90f071645055164d36e64d70c30b09329756b6a5a5e9d18e8c8c8c0021e37924dd61c69f91c3ee4617122b0835d5f6694a7ee80617ead2aa4a559d4bedf512a2617e9e3e4c37b690f0e5a2aeb2579fff3432c237b490645e29669399ce616500791d24156e6421b973dac6d496ef63e56f602179934cae69be72ac70ba42f2e5cb96f1745ae558b2429297cc1b3ea51359325485a4e0e9e38cfcba2c0d5121296c760f4a094d21f9ec5a7392794c7e450a891feba63a6a7c18df4421316d9062caa389cb758142526db0942c658a58fe4f4872f95c4a77e5cfa46f27249fb4eba42dca5f599a90e0f2b1e34a88bc3433131293c96fd39883d2b5ea1212bb5654a8b39c41fda784a419fdb13cefa9f5bcdd4842e2c85587f83b9d53ad1b48480ee5f1c42fb76ceccc378e903832ebfbb76fddc6368721e1861112b747daf9a852d6252fc38d2224c59c1a66e5456a8d121020c8980ca8e1061112f38db2fef87b6ad9bb3184a491a5d77359e937af75b0dd1042620e7f71c3858912bb0946e25daac5ad665718031889965292273c8ad495518d0363fc620c5ffc608c5e249678d78ba72a6f29215e24e84d8fdda8348fa552792c148ac4c16030180621f1f42400131308202838220a8562d1583c2e0cb30f14000557361e3e3a32282422128d8543c14814108441816028241284a1280863309283b2a0493e7e581cd0c829589b3e3ef0049459fa6e3b996e6b9328402e204c31a8884620da1a7a166cba96200408451d5260db771f70149013a561dcee9653d7a9772a2aeea324dd623444ddf16654b50199027d98bc9cddeb1d9351d3f67ce416a420a692d45f8c453c4cc46eb0acf627019ee91a73b95f99a3fca26b2f81f58616bf8d04f0f0bd94b16f08ba5b8bb3f243ef7d0a2e9abfca16a209abcd5700a18506730b745ea9a0323caa25d0aafc5eb8e31832e946292344e278cec864148b1f985c349036501cf7faefebf9ff7d2ba696972816ee05723d5bbaa3671aca3aa8706a49fb7ea128399586dfc13c271b1fc343b6390a63c86bd69f91b65b7f40deb3454982c062c5d340eada082d81644cdac247a524d44a82e5af86687448dbb09581c8c7043b5030c8512bcb35cdcd0db92e589b0d0e55e247e03808b87d7ee9219b6ec4b11c25a387fe88032984a71a933970c47774af0deb31fcace81ded82cc22bc335b5c5e9791722262d8756152ac06ec924f35c157d80638b1818b0968cacb82d6f3366d65ac8f5cf83947a25cea33e1e7b80461630cdc736430b35fca1599c84cfe484c3af7a5ff2d66f2c346e91323dc73cb6e0bbb0c76c09d3486f1c9b74ff3c42b9d5f5292b4b941bdac5c78ce92debffe4d628eb15d1b68e94b628420f66bc15ca1bb84c8233085748127a17ea3a0fb91d9e9bf853b14bf21233def3b81b9f64002dc422004691446609881346275a32be956362812a0a560f99346b905600b75f280cd1ab96d046ab973ab542eab3b182ff82b1b76f9174f27238a90364dc1636fe665e61cbbae3ccd2e5a5b0c0ffb08d323a9726425a76247e6cd5745c4ed38ccd0453a944e72723e3f31da76ac8620f1fda981d67d24ed06e18c20bbf4bb4b21019693e9ed4d58ac8a8cecdd69627814ac9587457f72f32cf1a77198a0fc7aa74ce0211596a395e5dd395867e4fc4b4c590329b11515d3ba57c22399faf8dd80da2fac94806bf04b8e5e931663ea84486d190b6efada6932f8be00b64302254c5ddbda387faadbb9e9314579f422f6cedc7ab7cc19849558765f18155b633d298a4cef6e496e27ec5e80de2c7c2af1e3f1ed38b4577a9e9673012eccbc8d6a04e6bd4c9b5ea94f6f777f6045d730fdc784a9711b6a271f74bac3abfc4767e9fddfacac5319526c82fc04828d71a0836dbcdaac0c270a5642bd0602164ee8f234cf6d1ae02515a1739f494464a9a7c830cae2b8cff8413dd7128f040666a335cc345b0a846ad1c2a6b4c20fda5e46702397be69d433c21e49fdab7ce8093f94a04bad30a361601cd35d64a8185df32417db3f39d606e8e5c8cbc9fe41fff77a1c242f3c219d5e9e4a31fa8c6836035b499398a1688b5d9405d6055b5976a30d162c56ec409709b9cec42e6bf6540c44977cdda452e0306226792403e309b25ff1fbf83488f7e1f15d86d4c86702f682b2ac28ae311cba17d503f8a1c04d0891946040a71fc17132ebbcb49f3618f032d6b251f0c1af558c382f02e34ddf967215d55e212fdc77f124199d7a2c03f4c991ece14cc47cc3c1837f59f3ba30aa1ac0d8f1afefecbfb2d39210143ef945905dd7fee88a8eb4cad1797cbe749aefce906634463ef99d479d5cfbbf1dad5696d58528a5a332f2f6197931504dd7bf48e31f72ba4d3fd42218460cefef45ebed82941bd8a213dfe3d409e6ce05398399a171ea7b89898d623373a19de0678257276445c9173b03450828e320433d059042f00af5a042c50528e2d2a11130b85212e37dee71badd67b3954d72d9cca8bf26b219fecb799d9cde05e82acacb4625c0f7e20b39a0bb9f340535c0ef8c540f1b9a0a582150922ab391322db2ed330ef7ae8bf1eb7641ef074e05842942bd23cd8093291423007b57944aa58cf4dc5cd5ca99a014c305e888baab307b86ce411bc9f2d392f6c0d3015fdf4289c3e254da55ca4cdb63d5a416b9528a2464a3e1194a60d235392c3fbe2d460698cc665d6d6090c09597483bb6c2ab9e4a45d77aa30192e4495a0aaf35e7b5680888adb3bb58b63f155a083cea9b76f4d8b99d2011063d8911e579f43be69867f5c4f84ae3ed6d965fe38018f7b235e34a4d3191e0e0cf36161ccb3f360a3f12acf09dc79391141f909bb7e378abf28b30d1300ec5aafa98d0bdffa8aebb1887b6983772e7cdcd63c8824d26f35cf9456374be90f140a4e2a78f16884cb5cf4bddbd2b81ee837f6e7ca8a05cc98ee8f2ede21d52c144429ce66375dd5535401f596d85cad45b4d2c7317b14dd43418ccabc771769730b3458176e30d7b9b74549eeb3e3e49a445685103457944c3788a17908ba8bdc8560d01d7b233c3e6b77d66c359c70244ca532e714091ba87bd3488875fda47a4f0a436efc287af1badcb1402b86dab61703e9bec0999dc179ee5952c1540720d0cec5206df09b374940063a7fdba8720cf97b617ab3adb7558e19da9ca476a17a8e4e1323768d7631e8e16b54211ccbe6df7112512f8abea50760cd326e01f6014bb07bf90d1900fda238fee6ac2a8799e2dc083600807053e92bca274543c628750ca5d7168cd85ebc9e27c738297ac93461420ad442024488288ee479dd2c40b0c673c0d275eac747594f574ada9e87d352a41932549458f1bbf5a13af768ca7927beada578b789bd27ec7901d3b8cf9d2f7d25804c8360a41186ba90de4d8a8b87bf3097f9ec020482d210d844866c37cbb6660a05d14fe3cabcd6ae34984ea56a6e6deb44f0e97c73a5714212cc59c6cd6b7d41e817978b5ee077218b342899b8da1529206771c427636f680342597a82d0f2d8bb1b05a766d0330191684d5971b8c1251223c72d2f9ef056f262978563586bdbc65a2eb92bb03efa6198e570f91b4011addb26a72a3d74258e53b356cce1d0eb6ec33eb5cb59b080b20103fa76157de891643d6a234d5b58974cd644d6bfeeeb1591927e6b130fb148235c9ed17ca3516ac2ca3a90b1430b6da7e9fbc2c8172a25c1a8456e4b72b8c961e94ac127f01c5c94b21a5768f8eb2c6607a8356de52ea5157057cdc0451efe51370999035df14b3c588500462a4e880e2813ddc39bb2f4c12953db580ed67b14a90d40f3607ae28dd99bc4800bda4ea9b673f25fcee4bc96fd57de4b82516bfd6a3e42877cf3653e0a2ef8fa3666846802a673ab9ec2cdf45c0454f04bb4db0f78501cae0335dec18d98ed99888b8078aacaff52089c938faee7ad6621c1abc9a0d218a30e5bff2e31f3435f38332f2780e2d2ccee6982e91a6e32e112706f012fc8940da98cb2d223996c93701daf48226bc398b19a3c1392f52abd96945f507c7d71b8d790df5743d38b01d9feb982a19dd3f68d993ec6b370a4aec9329680d2b8e39fe2904ab888b2658121060426d6d5363625ad75e4038d7c3e92fa24b2a4a68e8fca62c44613a1356e1f41e328d14323244b1661b3092acbb5561bff863e79581c7199647c94da7d9590284cd6488f0c966a9b31140bc19dc0e40aa0d7f5fd3289020f50f57521fa6b9e420686fa7e5462d72aea411c2861f35e3a0c7a0d803bf2cb4e03dfe52216f8f858d1974a56b1542f84808202df074d4cce56967aac7d74f57438a2e2632f03876b36ac3634034813127214e8711489270aca5cb33a5b25b75e59541e25b977046b17c99aee136039b85629d950cfe9d07d7c3e2428996e48f0d217f807e914f0216755cebc463d295466378f3f94f348bb9173f47fae1f45245bb023d4b2af17dcfc5c45d9ca9de1cc56e67f827fc533622bc7cd3ffca84aec50d5dea0e431a7ee95b11e501eb007d2204555878b27be2c4bdfeaf2fd3cd92be0f40facf3e3a6643c67ed04eb6bbe69f07e4b95a7e66fed4d1fae8367b7ca6367a966318d73038f65e1421c97d383fc052629c2ff44f1bd86cccbdbab91afdec53986dac3bbe6a7e2449a1ef637d4fc4bd8cbfef22fcc25f0c3835ded10dd47589a9a929187c5bad286b355202cf89e094c3e4e6c5badfc3edb421d2a3f8d3d02977e62e445d3b03a21181cc0b49a3e565163c45c8ad6b49c3231aa48ef86c1dd126389b786efc28225640cdc82ff9cd5c872b79a20bce1bfc22cdd4591349c60c278c3e956f3dc0eebc973b15f662128df0bca9eda98f5fe3b9d8a8b50b5d64aa4553235d90fbc6697ac615d5cbfdb67dbc4f0b2f1111b29134d8530a4c17e1fad90d36fe5a1e914d06dec4104bf2692cb133f752fc9702ba8b73043ee211a987936c030800c0ab58d25ee25730f40025984168a0cec101d88c1190b55fe745c8f77fdbf88465d3b01849f9525d8ddc0880d226f6e7efffdf8d64ee0bb929988ca5d8ef1bfd0d8b243b338c64bbfcf566c0b164820dd60254af54080ad783d322c2a1e9374c8199c9b1d53a03402704298fb0095dbc536e92b30ab2f8bca8bf14e2ab36aa977d298136c361faa5f2683da146ea3ea24756d29fec04309207e22571f8784ffb8a9f0d888408db131640f71192fbd58c71392074f3ddd5d3d87f5c97f987a80530fe3226214692515527fd8f66aec1da977a5a5996e59228c5527f09f460092f4dcadede7cffd283f640081bef7c38ab51b9d1144478a7d05de42005fa9aa421feb9d6127aeb18dfa39a014488cf8b158dc12609055418572fc864ece218a2dc6377b730f767b2d93d64e0de240c489fdc87ff0eba13e1bee40c4cae481c99ae3cfa0fb79da1d76fef19914693e1040c9914b0094d38fd7e91501f09a3efe9e3d127ace284ccdd31c654ee4b8a35ea420833ab15783ce9173090ff6e27fddbdfbd4f6f8ce9d7b065dfaf209b093449d2fd6a9b7b87a8713bc5c8596df8d4bfe1da391867f58f3ca39c8b60920309ddd0b12c8cc1b1232ee37e8cc9ac997c26c980997b5cc4654c8f873814ff39778fd8b9161d619320b0c08a7b89d9f3c6c52fa0c1e8d3c2ca7942369a88d9cfe7a3b0266da0cbce4a0e4e0833f16f26e60828c378397526da9b05b985c35fe0b0ed2ecc14c267eece5d61b032b1e9f7fadc99ebe731ef0b09a5708848c75408efa45b34c8808b1d855ba9b359a4506fcda4c4bf606bdb41a26772ab02e721666d9f61722288698d3892967c84c12a7d0b7edea9c6fd9ce0c6d8689edd43edd4a40e90b3a99247c2f7264d052b2819b7130e42ab5b2336cb18de8bde7a5233a106b93c84d2a72312dbd08a1991f400ea98e1e704872d963e07a5ef2a2263a7e83be5fd883e369e8180d3f728a2a729a7bf6caaa7967d13b78bff7316ea32b745c0552f9d4f646680f198de7ff4b23edd2db815f61a537bb82896291983bd61a9866b15b169b774ba57f5f665d920c422ccdfeb1cb2e673e5514257c4f19491151a38d8a34687fb87ada4acb55f0e0848901b5a129dad72a0faf4788150a4ad458283aa1d61b7d6ab36122c03c529b022729d0fb5f5f2d10a29057cc1057e85969572059ce064f544f9fdc8491ce625f4038f82650518b24c4ab3f076ea80f5dd2aef96b819a44ec1640bc667775e378de2baa29402944022e18222f8d70a73cc6ab0c929cd5462e202b1a312585f9fe532db2269c14f88d6dc2eeb117c36d2066a92a2941bd8e42a512b6b5f22d952dda3baaed9752d278bb5773251018040fba09e1ed42b2fc84aba85a0eba25f7675a1ecec7697ab72cdbd8112da089c86d6638ba18f54fccd9a8e65c7170dadd7a9c05fe243d5fd2c2d9e39229fd538b1c995d543b12f841fc7cef3f7fbe3e9849287697f636caa78b3d876d31b23446e0a4b4b311208f5085084217faa211e948ab477e0ae30a9e069a324940deb138b7b63af8150bb47cb035601cf959c3cebdc50c705283104280201c481b03c3ea040f25b044db17e9906b63c34e835a4258f8a34f1f7094d62e8fb085035b0811e267928ed6f5cd6d012a100e9f25b5b6d69bbf5b0050ae096a338248d4482c633cc7e5a4a1354bddb52e7b49c50ac8aaf54f8426ff177da184d4523b46f66026e9be5085f6114399b4eda5c2d09c4da28897563e92e7fe74baffe6198579e05a5314f5bd221ab2d51b75a484989362c3154efcdefdddcd0be3494308c320c79b8ef51394e9d2ff0b8e48896609b1c70622806c47df50e954bc2f3f8ae7d0a050c6e0c5c9b73d4d802a53f0251907b8bac5020554a3cb285494a73c778617b03d0dd9ff214ae61529a39b45142e33aed4e1a6fc8d7822faa6d4cb0a452ae5961e788fc23fd82478d57f0a8dafcbe25838a6c94b4783c848da00d91607bcd5724f0ed6519a1a0d59110c88afccd130c8005de69161057732ae7436f65e796a0d736a664b0af9cc4c1f7f8ca0dd6a55c14edd311ef0b30499b062cb97f4c5252720690ee137638cc90128231f4e7ec944c97dc030953a75494df0fd2beddab03153ed3ae1f8218e703fa5292b70b87462edfdcf2641deb2ca33aef418e97658d60cceb656ca62026623f97351a77651d2f7b20e9606e80902f8df9a125513df1d0ee2e4248e0f5582df7e9b946f4df42e923f706df004ab2bfa4bcf2608a46a2f6262eee791157ff1c638540369ab684d014c590dd34d18a7977d4b407a5bcd4d7b03f4e2ce0d088e24bba6957ce85790e84d215e3c7e54c017c371705426067c841f638df433b3ca5de0d85cd978223c5e940f99d03ca4fdc3c056756ae37865cd53efb7258264ce04eeb07226ba650e3d7d9a7d95454427c091ff0a214e57c856473aa9e447994561b859f63668057bafc9936aa7cdf4b10e003a9bc9ec14d641c7da9e7c1a7797d309ff79b36ada2d39966dca800a61232b693bdfc9285f0a1bcd3e4d95afd2749af3f2e503b883325e8a5a619648c424c7144c73591f5dccd6b97c7584d881a1b8f68c687cf48cb2be5e2c679388d7f5e5398fc8484937a0c962e3bda103c715423ad97019e1e459cb60e48cd213838363f300be253f217f6be066a6456357b36a599d90fca063dba5350cc8768e23219dbc79100dcd5a4ae2b2ad706b38beddfe9567ccc8e1335d2e5aee7c3508e27ea81e6a59173dca43fe09ed0ae7b4422907b4c5ecffcbb1a113d886bab6a71bd7dcfc9516ff70c8aa98d9e887eb6afd14d43b93c0d9a63fee02e2092cea5491e24027b4160feaa563d02c144152653f545821e46a6d0af9fcaabe094de7925363e7588fd24814e812d5ce5f5d64fcc03d7ded55fb9e104cf5e23a46bffc648331f7d7b1b42a38a97b03a0b15af65a3177b01e7294601d7098d2f4b0fae7c411e4ad0ddb9477c41a822bb3d347a7ff427f7ab86024f823dd4e871755533dbbb8dc7c90a4aa24cd00f7e912dd4d0ea2dec7fa5eaa2cb44b570f11835bc3e8b079381904e35025f4adf61b0ebfc6695a950f0a30830333fd7e3c0715579de9054b8a60dd9e8faaccdc9ec8b4e3a0fccdb951b17df5783694cffe0beafe3026a1d3a4a4b0297edf6186f5cd182319af9e5c387a2b2ea93ef0bee725fc2f57f78df53d623971623fca893f542d508e61dcb0332241ea04806f42a0454163bcb22c3832950f50b28ba28ba2e1c0b9221a0581974914d4e65c661612b652273a83f138332921468ea03e460cc6e18d50c8a60a2f0e5b8a4233b9e2ddb093ee72f2a9587db36feed4562d2497cba3616f27a6679cf593e0f2d06df33ac2734cb0af0d942fb4eb9fd7601a34c01d54cb4a7c1343b7f32fd943926b0227bd966e0dfa2884ef4ffaf2a7bf866fca4022bbd0ae72a805bbc4140a1899ae5d46cb1832a6db07a8a12d98fff456e50a9ccc3b0f562ffc3bb242db6a9bf21326ec6018ab54ba6110bbf35b0ddc70f1b3a21dc8218b60078cde413fa8f59f99431c678470e5ab81e4190641d2c92f01e3bc2736210f89703797d0a1997dbe80329830d5e0b2b49dd18d87729669fbcf1c97f685f98f05838679332f91889b192e46331d10ee101913767a37015d983db107d2946e6ad5ed7bbca923f510b4b396590c60a043cd8634fc4b3038a05225ecac5319b1d6b0d1228f607ff66751897ab72c370a6a18d21832fee22d7834e470c1bbafc0e36f730ac272896a0393a388e2ad0a5f98b7cc0127af81afbef2d39ef67a8c4105c4fc8c1dd527b72c656f3440e9c1e96eef1446313657402e823ba9de1d26d3f25c6e8e481c003b21fca1da9892ce4a97c9fd13e7c39e67b049f1bf44821cc92421378ea286fa934c56eb8ee11bfbfa3a3ada89386a05a3355c767e27559b905a125ca423fb6332f69c2632e6dbefb9a2ecd2c7d1a2a6dd263f31f1b72ff6682927d21cbbc8d8b6c5494cdecfeb90974fddeb53bb68d8b93deef0aabcc318f5c84fac31d46ac90e0718dc00f2ca49048597ff7212803b748c4b81352e4f536f1b55a7318e90a84ef3b410f28692aa6b2adf391bf1aea803c44128bb8ed09f289881e31676e56eaedd2964760a3f45ed14c451a5b7303ea39309def1cadcd0ad2cc5cad852a5f63f5a43a2ad26b7c8498d8333c99143cddc7dbb6b2aaab01c47e8680054bb9363586f13051e19fe806987b05849f46f9cf36cf42363a1186089e9d42d40a9fcc268b274a3090c8344a6f72f402bc767f58661cdac5a24d98bb955a6e04aab27778d54391b8cdbb5df1887dc738b7a042de1931c1109755ba71208e821380f83e8cf02d823851d03d6df7fe3ad5c837a2c698e660424a1383349827f8d72808dd6dc457a27e4259bc1f0254b64bbb1465b1fa65ce11d03db5334eeac2a1b13f9c10eac2731fdea18f7735c467536faf57605666c575d46d6bf637dfb0a7ff2f9b3d887f27c81e48ee4e7770b8b12220fc7ecf2b2cd6f222ae6a579240a95874f255a623c4944f1f5c1f390739e41d8ff895cc687bd6e6be727699b471c76f340111283048b4a0500de521693029cb8d6112f6607853932ed27312ef3e2f3e536581bdaa64bd70dc237808c118b85f557cb9d963078ee22abb65224906004e3f4fb66cd05d5c8b4a1363257aad609854b3ec4881370be50a0001b076c0e8a81c79b41ca34965409417157eaa704b90bb03ea7aab7fdae1f9b3f31838eba71798d119ce95f47c25a3cffbdcef1c2ff71c35f9c45b55e10de226d95e18560fff61063ee38d738a9b71b971c3a099e14c1a508fef930d6954257df59c5c1008f4a4780d6016122bb423e51a1532af267e12e66467fb431cb3d5ebb23724276ee2ec7fa0c888be36e88203babf19b3fd0c963d95524464e4cc5148e2ad25c01cde28e615deb6a104190768a48b38e265aaa8cc6cbe6f7bfe31be1640c8eeff44d2682ffe6eddcb4b433b23eef99ccc63432627a5acbc67312ea1c76e16a73d9e9e59530367e4265148a4b2216426f1c8bd165efc3578236040c4abd4b768f8c524908cae901590ba8fe7a037049ba63cce7597b3f39c814bd9a1ee1d040d2d3ead0a995d78d624fea57eba4a855c2b9e573cd2281a1423881bdbd370a3d504a7b29b5915f38b984bc66800dda319bb1c0a67e70c82ff99f45f9b2bd51efebddc3eff69e99ed842d3d3820091bcc29c2eb2899b03bf99aa4ad8b92273f0e3d0d08b1519877cea4e666719877a9ca9329159bf604d97ab47a8584d17caac475804c1760f83d1d7000b86ddab857fb48dce83130cac9e38820f8e9ca571a3b58654f1706fa003253cbe9d421d4fab105a0b346092befa803e4d621620df11a8fe990c11736b8c287dfc928ce259b882429396eea51f271812d02a4c402fd75d0af0c4117fc5412fb317b7893aba8e2bb7e18ac47c9eab0c3e88e8c08b248daff2f0cc404b5a94a6fe3bc6933763343ba898b1e58425c5b958dc560d96d2c104a6924d66cec6835222fd78c1e5f46352dc3a1c818b10c0e489479ff3de3c502ec4b0c41aa62d7356c9329c1dafea10439a5cb6319b72b2f3815cba9c7488ee2691c7d949904bdd3c92ce5143a1533221c7e62a4e38bf1d01a88637ba2376a183b27441418b435f337792be5481f3a2a1d040c46472d58ed051ec4c096f78f3ccaf9df21bb215ce9ce53c7642b3ee1c0679365016e3fd9de7343316db6170e9b8c7f4a8464b6d6e494aae5619f19386c2383d6169e7e62119523d4394b44ab8f6f37e35152aa4b35fffe4a4cde988efba38a5c59fdd0f56f710fb9e961cdd61e071c3d17182671a1fe3660a135d2fed1cf6f21053bef46fb1a058c7200235a5794d9d83f0a9ac3c3a99758e97d6764d148f8f2ebc4ed071d65e31df5b02d6aea68f5ee026722dd049c2e20f169047a756e9b4ad2af26d7605bede691a5adf0e9673476905d347ceaa93150262000f7e27fc49da7015f88b08cb14be94d94255428e974c905419a529d16041a9fcfda81830af7e4744ddb5456239833a6078548c72552d3dd1a1af3cc42a42c34a2ebdb0227ee2d59b13e05dadd483751a6b0ac402ae7c3895f9e813197fd8b218cc0e58628f035a189e8a48549c8fbc57d6ff1e6cb20d64a45f690dc8035a3127e51ddae4e3d1b9a6abcf6d3550b24070ed5455a63f2cebbd1eb8a09bf9cf19723fd0b9486b3184f6c3ca01eab129f9448c801283030d44002a1abcfa6ea845d9cbf96c93b807550d32afef40401cd518ad17cffcdc00064c346b16cf50db832ca82619f6dc60088a7d0c9bfd5cead810d573363ce7173261c1e3554d08aeca33417341a6f5e97b8e27c7a645533900ccdde3f61ac44e1f9888ff5e936ee81452f1de14d1fcea90e619ab3e28f8deaba3cb5731a04812892e29e8259c4b5d1518c6ad86599a93829e613ccf166c76c05189b39193e48a940b0971933dc1302976bb59eda664e711eb97e1321428db93d0bc08eb90927c8048f8b542f62144f742b90d844a52a802b32134d828aba3044521667417a889cb83f4c4813986806a2f617a8407a8a96b15180113de72a4088a2580696499e058b3549e81e0543ae63407c1d544217bbc2121dc852640eff0420b9d988b1b53e8755ed9ab7e9b3cd6ec135d4f27a67f31e828590d52d335960c13875738d31dc89759d89e546be7955b181bbd016bc23717547db1bb18b36a41db6e8439ebd4c3eb26530a5c25c8011e0ac811465bd29c8111c24bdc17d712606db744c1c6211c6b716c79ceb6444eaaa5aff0f3163ae9294ce30e0fe8fdb82cc3690290a57d09949a347ab15ebba79a3713b313264267724f8d6cca0f5507c84e1daaff780e92f3e2e0ab6f382fa127f61739267d2b27483bb38a7b88f53cf9bf99ff35dc97ac7173e622006428610518439820ae5724765d779009f9fd0c197bd0097632b6766f3e976c8a33612ac892db4a4055eb3487a09d5da5f184616abb481293cd92b8ad2489b48103be27b92b8a6cb1b54d24a597e3fd5bb2d23d63015497d46b598d2d51446333a5b98884e2fece05c7e73a54263365017f4d34d02669b129c0b568490148899d14d07bfd7a917c89d2a547a6c744c13b4bee55ed43c0d2ef04904311253460fa533505a2840d4491b8716966cddee42a8d810e0d25a0a456a4a5533a3b4aa8c508cca6b5f7846c258a04741f1a90e37a58fb4ac1bb90e37a69c0d408b42f128a2bec3e226897c91d40c8699cd2ffed90f671423012541ba98ebc83ea12e1451354eb670fc8915b4cb0bac884e3c6db9d1b0f849834e1ad443b37dddfa58cd25e50ccb29ddac77b8fa700ad181ed22e5573652b28c463a2592a5074cf5f68d19764198d57f63c52745a3ed754769b1283c031094f3a80a3da68b59ec6878825c7a51d2215d5959b6048c515e668118924f5685431110ce295bf23958acbea40e1a32b4150702446c7664f3275a4206cb94c068983b73302b057f4afd236c4f5ab1c059cb4848eea6c81702c17c0feecef08b26c5d0968226c4d67d454ecb8cb09b40c40f1045401487e8e61b12c1ee0d3c0e76caf7e84b7c65d95c22d185e82c5084391bbb8fd1619faf5d055ca85b00314c320c6db43734752f4e1e93a473a3811e458e7a56c595de2cb45aef0aa41b57ca5b832042a28c1dbb019e94a1dbe46443a8337c8f289218e89f4f34ff6b93b145b072234d7f71f258c65b6d1e8d90cb2e3553197240ae8bde7ffba949d0d6047f105cb737268cecb7584a0038b1b8533981ec0648943e390b8cbe93735dd0f33540c49e968cd888b4e1d9a381360e6b8fac43a48efe3eba6ab426e2e4d01f29e8bd063b3ff42201f3f0c5d5cc8dc25fd34a6393a10b350b9096f41e89180a5d8a94271dd6a0ef4efa77287d63d3723362f3065957aaac4c95932940d2347311bbb1fc6ee3ea9983105e7377a271cc4dbd89961e37317134e71dff9e4388f8f44db241b83750d5e3d4307d0418d10a317f4aed7436246b8157835336c1b9108a9a2f3326944a8d4ff06f31ec8bbfb1e2b28da03cfd3089d2b5839e00f084000f49f96954c72c08d963a26697b3913d1ea31a84d72abc318290072d2636a37a4fa93343006cc48a65419439d89bc8147a6fb6ad941c5ec784db3e93789c6a661db374c0c01e1a8a72d8dab45026ce9b5288e5d32503cad8e03ae5bb50c3e05b8ba1750b89b7ac1b7d2562cac9c2e9ceabfa1bb385fcd529b88e2f33f00fbb14277ba7a46ed0efdd9267b1273177e9fc8ff5b7b2288f5af582bc015e84dffe004ca04a2ccdd430c797035a9a9c0c525dce345ab2d44616e0e0e3e1d9dc7b094a0ffc8459f5b14abbf06ec6589008a281fca6e9fda6863771032c8508f8e825497cebb16df9581e55c033c0ab9d212b2ac47bd2635d72fdabf548b5041b86da824d270e63534261156a0c748b503dca5f8a45b86fbe2c65c2d34b916547b36351f600439a1802674aca454f6f93bf03118330aa5b1d2732c084372c9ee58b68de0f874303e33d220686e50a7febd363443d39d7149ce4a0ebec658625c3200086438bb5538dc799e93272c6192ede9549a5f0634a8f5c82934b2b7fad3c92c9cffacd752c9991850eb4697b3a3474b77595cbbfc69da19acfabf43a0226a5171ce36256e30f0e2d0491a88531f72e24fbea15330a13d16a7f3599a70c6bd8502fd45d8060971fcf5ea1106a00b1add49ec21dd09965cd6c07a8dddcda0fa6d62d8275561be858984bcba2ef90c0c61d8165e7847dac7bf584d3853f4d7f48d00ae1e282b98e03d6c0ec4b13a3e84bd332978a5fedd8c5bf1380c3e8dcd52bf920fa0ed47a519fce5acf9eb0af1ec828673e6c53d8cb470249e40801d510300b8ee0fa7571c6ba51e81699e27d05e383e075b936dcf887abe09ebbc697e365092851cc0081724a9fffa2f10d44dfe0fb4a48cf1efb3073798d91a2025e053b3ff8358d6357547fcc9c120559d1a148c7e8a7ffece9344a941c4924434013bf40b49a32ad3df86b881e842abfdfda71a01e6ad975b0624acd7a0dc03db71518481d9ccf2537f93343de378483521036a621c1cad9db9862d458a96f0a7e56e5876ed5a4163f8a2cdbd442691948343c332705337699484d9b627e8d2d0fc37384085066e6f7b126bf9da4131623f7bdae55f480a12346de6b4d90550503b385058648c441c60a2532c3eaf4f5d7915f0cb6c896c65ef2779c3d408cd3649d1ab3fe88fe2390340722d71efd6628740ca44bb25a3b6a43968893a0d253a2086d693ab0f322e061b053718b85e6986b300c69a48e9c62229fd5c67b01e57ce267aab28e97407898e5e76268444f8826769ceb771b3c6f3679216873359e4c30d109568e4bee7d4a14cd562ee131c7289724b991cdd641b74b24a27835b246d58b3078ab58406b55a0ec583261517b0724c06eb9b38ab84312c601455cc8288bac1e3a3d7af3f686b65f1601082eed8d5fa47acf2e76f661d971e54f044c0071296ae5e125754076785995df1d2cec585c6168bb2451032db01b47d4a4000d6e9c175186e9250fd8112ade162647fd885a50cd04eb23e698c4f51f220ea3017e08f7d5d098672f1a8fbe9bf71fae83bc4385d77513e5de6249b62c0dea219b32800ae06a24ce985a411a64cf85f2a94830321b390b348aa2b8857a431447c9779700f0e59450c280cc984fa5b191638d5a6bfcff1906312759459f242dbade8f314068bfe3170a06062a6aaf3916fb97d5292d013b8a210b0f6f08e0e0c50a60d377a5318f9d8a72b4bb5507519358a52ae1139b3b449978df26e1b0771e875bc5d3ccc430a5bed61a514b660f15a77295e9aa5462385ddbbad54990998bd9aea5baf2c26a913aced0813dae30762d3ac194616559e5ba8e581a7952f3bb9bd60a9cc441013681da400c6fd8a55ee514f35862fc4f38d26914d4a68665a0dc18f9c85465b5641d453efbf6e883d5346e99d533c299bc04c5f4b6f0b71f6b56268aa682c38f9a1d80f2d9d9da4f7432a7b369648b0bf0cc37ea6d87239582d6b2b35c0c1aa6bc42c45940a064c15263da33c599bf0845935a48c033e0475f5be2206de7cbc8fbc23ac27842c352eb34705d9a6625cbbad55d06f6fb3c24aab052f1f86b990948ca1ea0d27ebc1776a4af68722fd150caad7a8973a7a5f88bfe4939831d71147f401fef1f5397afdcf581d575c2ab2a931ceb07c37e223ce0b4bf18465e67f1e01705c6cee5ab037c3feb15a3ab615e883fa71af54e0c83350f5414f863ca369a2ffb9de5a15f0eac63bb5cb0037ee24658c43a676a10b24de125a50212efa1c643da390772a3fb024cd6aab4c8d6ecc0a6ec9b81943ebb37d37831fb57a93c6530292747497effbce567d1efb59784f22119f2601b76d9c087f727927ad20b0970cc8a68f29600ec3acbd365d8f0efaa75090274016bae7f117ff9aec7e8cccde88ecc7e6e762d8666bb283d9f3a142f18a0a5f9f65885ccf5a0ab3c3893a59dfc6d5c2bc40cc1031499538db046d7d49a35e5992b85536d0e18fb91fda328a4773e186a1d79c64208f289363787be2ceada1e59d2adc4da1f64af4c162d10c670c12b4ee918a2d74e69fb407efd247ea7be5bf54ea468429eef59309b9b5795a4a591c55f2e54261840ef338fb427f18d96a731e56b1efbbacc91e127cfb82f9a4be58cca8eb3088660241fdce6f1c42913fa1d6da60fd58cd9ba4fe2bad055ca9bb48742cd5ba5371dfd380e3c8c2b90f8d49ef99b6d9952fc2b73760e060d5c23b3b80964504328922a73d880d351b678dfa74bfc6892d923cb242d798ea5ff9d038f5f99917f1a6f13fe09c95fae2bd6ea79cd31f04a37a715b38866e7ea65be0dda33e3567552765b1b867f09ca89d1e1091c193f51f8b95fac2863cea7268a08bc1a16930b90333affb0902220df669801b06a652888c838d8f6eee3ca877b0493d2594f3bff2a627a74b2e6d2abdc148ea194efa7617064635bca4f58cc1e66e9f12686002dc0783b0e2020697525bc0d6889ed48ab45fea830a741f6085008a04f01f01e4e400c6a475464f9889eaf98392974063aca58512605d91ab8ebf37e4036096a300d0a006bf50db2b25bf79a9ec7f3d9217ad42e8fa3fa235502d0986ae585a3da554634fe6d08a9351efeefecfec9581200ff27b120bea29edc6a32bde8f691632e73fff8e947dcba644ca892699b6f3711391e75be569063a05357c9d892792650f0f340ad0e1ca40d2e8d375c59aaa9e6a35178eed93fda99b6a7d7226ec87a28e2995ad06b51edab9e3aa7be0ee799c6d13ea25789d3dfa0e1eaf0dc2ccac5c2deea73094563fd855286eceec25cb7fceacafc1276ce486c6b669bc22e698de4d33e0f640b2df305473f5333b0f7265b709ac0a798f98eca95a5c421b7c3f8c5c8d955f65e39c55c3fab14d28c20d393b1684014eeb4b22d783f6214cb43eeaee771607063b81f36c749f41bdae087986683ca6eb1c634fe8a74a4be3aa04e289859a6103593f849818b10646a7f3668ac08468ea9cb2e04a5220151ecdabbd1318e142b9ea825a9f1e21ff7544a7d80449464eb3bc9d6ac6d4abf52cb72886ed7ce7c5fca74b0662f034d1502eb8484ee127a4d701571fe2ff647c9fea0f6f9cc7a38fe6adde3a27858b2ae06bcb839e0b30575b7127392857fce86d7ee44b39cd561cfb2319af5fd5761528c0ec0df3afe2b68a91099fabc8b7016920e753784ace5e640a0978bb7a2ee6e98781a4693a84d9df043bf308a7507ec19b8b5e43e8ff2a94b00bd017d464cc98af1f8e0a18fc5f9c07e9272665f75e166e05e9e57640613d71b1f86258719a7795972b1f0b1bf5f5ff344df5bada0c2e3207b780a8ea5295aeb51f74925a4e0cf025229612492bb8fc182ec040219fbeed1c3abc3fe62d5c144e637026ac66b99b1e960d1f3c16c54255a543e93ee76b0ef03bbbb4f5eec2a32b98869e891d6b16dacc37fcade486580b67b6c717a71047dda742e96a243c16022e92b8d3843838612d5e9510679b7dba2f40aef8a5038f9f43eed16a46a2a7f248b1a3114487adc82db31ed706e3b9d2ea5f64ecae52ea2583d34ea3b1a5b2ffbbf6ce41860260ca16bd0cafb3b33b9fdf41477bd864640f9c987168c54df16155ad1dc1c511bf899de51f95bbdf858101c093ac8f04ff00908921d4e47429c864fb618e49e8e3852a59fd75c70a030bf4e7199088523f32487afb48a6494fd2259e31192f407182803a0b4490f467a41787815523e6a669896f0145f75e31965d3fe9e020a03f3b99003dcbaf80b31423775fe32ef9f7af024bb2b99791b3a54d9f8c887334186a7961aa567bfab0439d8a0e359058b9b16446b66271b66cb645018fc92e617ad1254c860009bf879c517a696097f25966eeb0e1ee08acd9dc0a027db1d778ea705d99ea95f4963ed480fdb906cb7f3e3d4da77d70a4b66c2ee5bca7cf7d0df5a9f7b7566c19f45732f9cd92a2f85305481786bd2b66746466919fea04222c9797e408f862b2f77c00e36e84334692a6098f305049d5c7ba034ba7fb1c028c0dc8b757029996568984ff136c8daa379d0674cd02ae1dc5bb0c3660b0a4900330333333333333333333332bf5fd75fcc436eedd327991aa3e40d52425252565b2ae7d710edec13b78a33b7807efe07501950c9c0caa0cf7696b065ff1d28c54c271f598dfb307e1e314a18453f3fee926350937fe3c7367e670692292703ee7746962446b23e19847f0b88969bb7d48781f4a7a495848e9713cc2f3ce6cd12aa95f728ef0563aca183af6b8c2d508cf36878f23876962d3c1086f73599886b08e2cbf08672ef97d4841438851849fdda31b918e44b849224584b75aeee126fd6be343b8397ca7b45758f75843f8efbdc9fd2a79506921fc328f737aecfee6494238be261fd62452ba73108e99c6643d21ba2527082f864d8d922310cea4fff136f5c0e30c10aea4bc166dfdc1bf1473ec0db71ffcdf28172da6ee83efa9ec62d756c89ec30727540e3a7a8418eb71f6e0aba5859c365bbac6e8c1b9f1491ec2374c62f2e0c771f5d4a77c9e39050f7e5ac99aa553eee0e74917422c6778a6d8c1bb6c1f5dc298c7fc7570ccdb4e35a6d89ed274f0426707d5b9d32349cfc13b8fd22369578ea99683e7b1276c05bfad96e3e0655e0f424a2b04cbc2c159cfca23a1bf34ba6ff03388771cd7a15aad6ef037c4702956ac1cf6d9062f25f19baa910d7ecd49f677096963b80627a5e8aeb1ec43b0500dce858e35464e1a1c89e1327b434c1aa3c1ebaa8bcf297b5ce39dc10f513b071fc4d80c9ed54830ed94c199307e3f35313b6dc8e05c664a9ed514e5630c5e7b747d488b18f49052b89aff61c0223a90141e040c5e7f2cd57d922ff813a22d5fe5e920112ff8e92b1a257ae2538e2e78c93e63e465be731c5cb82a8fd5e68fb7e067079f93d9c6143bb4e0baa7c6160fcd826b1e22cd670e0bcee460ba3c56d77cdf155c0f12ada49355a96705e7fc7a2d69aae0c57d8eea924609d9a8e0bb472a9f278a67c8a6e05c4759bebea4e0b8c61c86ecf1e53886360adee70817bc420b0537aab2854a126b1fed13fca073c82249d2e5ce71829f3c47b69169821fd26715b4e573cf043747a4b75d74095e8ee2cd332e4a70c3638954dd6b65f924f8dea31a997a24787962b61c45a9fb507204bf73685be12246f0428ec12bc5a81c8448119cca6491d91db8550e2278d164563c2e3be21e8213edc1b28f2d04ff4d44438694e3f404c1b10b0f63c81d4e620c04af830df191579859f3075ef2349b347f8a0faef0a1fa454a0f9c74ad0eae64e23ae3819bc2324b4c5a953d3b70356688f92fc46c69a90edc509163bb628e4a73e0b5594e11e3b7e33a3870637dcb63f7f4e1dfc0178dd93174e4749d21800dbc90e3d673c7f17c8e5af8e11551bc2edbd9b4706d7268d2ca66e1da07f2955759781fc4dfd96b92953f165e2ef7a811213cca3d2c5cb9309ae5994b2af20ac7a399ac629a91dfc3159e59eee82366a1e3b6157ee8a1a494425b6c8fb2c2cd8c6015e15c735257e18589cccc1faaf026c33b120d69cbcd220689abef1b159ebb8a4be890ecb953e417bdefd73a53f8e1ffb1b7c34ae1548a39cac93352f813b5e57cfec63da3f072d8793c2845e15ca431cb508dbb2843e1fb4fba70671515a204c5ae151ab3d3f3093f5ad253e4705ae9f144927cd2d567a713ce7d741756359cf0bea30a61d5ffdb964df85d1ffa6e2b9af0e32864d75b96b4f9cf84d3417a9c038f1ec583093ff88a39d2243992f512ce5814ffd01b317ac412cef95a7c5415e792a312ae77943c060b75b7614af869298c0729859f7127e1fd79499a4c9d124a4970fe2b396573180927a89fe4e872080947246baf876d9fc3143ec2ff8ec39872295c858f231c8d16217c4e23bc9059eea9be9dc284116ef4b41952068b4c2dc2b920d172e8703943c729ab7308d75b221cf3284cb458b2a1624438361f23da86cfd03984e39176e58eb5706f0de1cdda86fc393b0e53083f5567b2d89184f0c36517bbfe06e16f1e8f2c52b2a0c13b4138390ec63c2a7681f063abff4c6287343980f0b5afcee3f1fcc10d19ea99a2064b15e3073ffa301f5fe8a0ac327d704a26859883289f37850f4eb64fb809963df8d7a5e59626456a450fae24b1742a9ba354250f5e84e79449838572091ebc8ec38d58f80f398cdcc10f553b52f428cb2f62073fc490516eda3486bb0e7e4a62694d7d6d2a4c07afceabcbd383d9cccec1558f39a39f071e232a07478384b238efb61c1a073f85b99c7379903f9370f0a28a7bfecedfdbe71b9c0977127fa61b9cac79da3d47994315dbe05d0ea4335d47a61ec7067f335465ccdbc9e36e0dae97a70667267d7aca63596a6970267a5a0b711fc739333468c9c265677033a710952c19fd3f667054d3233bda94c151b76fd7e841e6f827836f1e65be8e42bb5c7a0cae7a1cdfc5fe8e24b7183c8d395578f65f473b0c8eb5aa4ada8ad03083c1f5a0cd83ccfc057fa4344377dc5136d90bcec51c24bfcf9c66c52e78ae2949dad4f806910b7e10cb1a7218d6169c8ba839cc77b6de5d69c18f8346bef473d5ea2a0b7e1c7f869b448505373e86a80f195cc572053f967b280df692a26205374bc92709d93fc95f052faba5eceb3d15bc4fbf16526e31a6c714bc76f55f8f34876c1e52f0a73c685a560d29ec28f8e913ab323514bcbf998e2f6b8ea13ec1eb98e0a93376829b4432326e82333d5a9ee932c17793493177094ed418524a171b5ea1125cf90eff97d1adea4b829fb3c7982357340024f861a4d8c1a3cc008ee079e610f98e55d794000c2f8e5d59bf61c119c1d52c311f5f5c89c5348022b8395cc5dc91c7102546686c755138002278fd29471131575d07760e60088e56c787102d55b7769942f0c4b3263432a457b540000c2eb6f8a2060e20084e5fe6f03189bc6ad8030082b7e92aa87b044f26961ff8e9bfa34ee9529a8ff7812bae39bc944fc71f7d0ffcb5f620131342f2b01b000f3cb5cad1c6389790c3ec0076e0242b595b0b62ae6e0e4007feb4fa8650d69f2c84ec60003970c4728eb5bd4325f238001c38f3510e827fcc39801b78d911d55f3b35a5545245600036f0b2f6e63890bbac98a32dbe061728c05ab87ed1c24cfa5ce7fe162dfcee20a6fb286d7714a51ab37045f2b7b2f0ecbcfec4d3862c16fe79c764c99f52336761e1a5e50ac9d903b7baf2154ee50eb63bbef797cbbbc28f59faa73f58795b482bfc8eb9cf735e9b59e18fe460e383c794a4d65578c137a37bb8183bf944155e8599584de93bdc9da9f0f2a6be746a2939b231062afc3026df1c237a48e799e1028c30f0147ef812ff403d630a57c47292946411eee118a5f0fe3ca687162424fa430a3fb3967fb6a7efc8af5178d9f12f3976149fa4a2b1a5958118a2f0b4b2c44f7498c6165e289ce8b13b3ac50285bf4142b0398f7b93c45c70a0a03fe17a1c9ffd7fb2e9b997c696a0045e74e1313ce1a4564715647d1a5b28d04eb839864757e5acb03903c6c17e400c4ef89e7346912cef267c93b6efe8acf3b07e2c0bc4d0846be945ceff43ee8dd866c2f31c54a890926c7b60c2afea1862b4b05e135fc2b1adcc41089be6a6c34e70fc9b1358c2374b31d959c73dd95d1a5b9a560947d3e52085d3103aee141a5b6cb505d552200625dcee9b8a396eb1c8e94dc2eb20677d65a76a48c2b594163b85c544c209eb41ad69fe692c076240c28d25693db094cf23541ee124fbac293df2dc066238c2b7cc768f45f2cfa7af8d702dc771c755f59ac36e19e1698f9746a8b26c115ba4808b12180280188a889188424495bd32ac8761731c8d5d408c439472deea5562dfd66a21bdd8f8761cc3108570aa272449a44b4153dbc50a6a980c74d10517129021c30b2eb6f8a24612c2cb1fe46882859a45f701d88003be4001045eb0801a358e0b6c400615620cc2f9d86ed71c1d5c1c844003ccfc71c0b01882703d73101fb84de6d6940f6204c2991032e4cc3511ae4200e1494efff4287b10ebce3fb8e5266f313db0d051f383d359bb5227cda17dd8e9036a565e3572732b9bf11d36a7df4c0c3e78d7a7595e3ab6074b23364b52ed5c462a7cda07a93ddd86187a70d2796bfb6bcae7f3f3e0bf57f68d359e299986072fc712557cabbc839f2624ec6234861ddce87abf94e51e872c6bc4a8831fd7155efe2de6aa0131e8e0e68e62e5aed0c156c562cce1a8223e6887a5c9c1939029a59862e2e0c426f50edf1e07193c70705210db8a3d962c04f50d7ebbc77614d9af665e0c37f8bfa9bee33ccada99bac03c40868ce2024323461b5c1b995411a28ec1868db106c74f43acff4aa9c1ff602a478cca37ee9534f81d4c8eeb03ef1c5c6e63a0c18b186738b4541e626cccc08dba47db64a66d4a8446cae5cf1d7a204619bcca4174eb94bbcfe78c4106c72bfdc5acf0638cc14d2db51e872522046288e1307318f3a4d74c8c30f8116472ac1d8884ee6280c1fff05195428ab9f0a2035bd4179c29c9f2c83cfba4e565c830606c512d88e1052735c642a810952fa5185d88c1053796e5e05bda614ec12331b6e05784570ad50e2c7f31b470874ba47adc4d8a5864455b5448f93c88b946418c2cf892574e43363d648f0bc4c0823f1f6cb3eec2426a1fe30a9e86f8f87e729698e3e049fe20a386d8cee0165f54757170110618c7056acc2882973b928eb25f4cb11a3582194470530ecdff3f7d866c9614660cc1b52091c33d88a9e3c20c2178da71a09535d2c5d0d0416146109cb60b1d674e9bcd008297bbe683f01fc462beccf8819b35af49afc715ed1728f803c30232647c81829fe103dfbacc22e768a2c71d3ca307de59e58f4caea5ef04cce081273186bb981d45c7a9d9811ffd65a5cae5af7ea90ebc975bd51811e6c0fbe0952a6a9d81037f2cb8957d7da898a4193770739c327849d0e820996103c73c7fe0de95e53e8e5a78fe963c8c6e4dd6d1b4f0576359e8eccec2bbcfd97310a247164ea48f67c36b8ede434f2c3ced483db07066264761be1dca555ee1ad7f683967dd5c77b8c2e99c3e467a76cbf956f893672644d2eeb099154e188b8dc15cb38ad2aa7254e174e6723bf7d0daa954f895a3cb8e23073e591954f82924ad7296fa65644ee1a47ea98f69abc34a9bc2fb99e8955993c3b496c2499b330f635fccb192c20bef6cd11beb968265147e4892d7223c7fc5ac88c28e1d5543904e28fc341f459f24969e1550b8ea16f9842f39934cd957cf7478c2f5c956cf529bd6ef4e78ee51dc73db55449913de9d260bd3617da8d14d78c173a407613db234e124cfb00ea97d265c1b15f394344cf89db231b4e4583b85fe12deff4b78942a332ec712feb975bfa608915109ff7ad25c4d5a944f213228e1b64c9de6cf637f3f9131092f4bbf6646b255951019927035f78558ea1fc4db444624bcc8392b5b974f7f4b6440c26f49a9356d1ee1c48cf6a969cd233147f8d93e3e95c937658a34c2493339ac9c298c7026e70f72f472116e48525b9fbe43114e0c0d963ee813e15494f9ec954e528820c2f328660f5e43b8901c87f0e3d0f24c8ad95c46368413a4632c8d1dfa985b08b7d3cc3ca45c69a512c20939f4d3b0b11e841f472649104ec95f5988ee8c92e640f81e6dce29539601e1df8719d3e7e83fc57f704273f20d27f98269fce0594edb1f3d3c84b2fbe0761021cb07377dafadb9b77bf03da955ac75844ad5eac1f194c97b72c7316bb479f0a314cabd92c447a183072fc763352f9262ca9b3b60fe49cc2269ece0a648953ee4880fe5af8337a19274a78cb486950e9ea784755cf6ebedea1c3c9b2496356c2d4c5339b819adead7ebd2c799c6e138e634ef20a4140e7ede7e6d4917f19b23dfe08f7ac5ca0cb71ce7b8c195f9187d3b9ba7a4b4c1fbfc6157688f26e3b2c10f3bc4983f46d7e0fd6fbc78e01bdaa2a8065fdca3928f13d3e0d87b0e3e82ca598ea0c12b8dc1263ec79dc15badcebeec123aa4cf0caecb68e6309e36eabe32f82b29a584771cb8278f0c6ef5d6c8df7863703e4c374f12ab937ac4e0f6785d9e8d29f963c2e044d77d071f558ea3020647b3c76d9e3e8c07fe17fcf568d42abd3ab4c40bbee5302b566d1753d905c74ce44342784c395c48c47dc534645b702e87a1274e322db849739c27df472b175916fc20fce528730a1bec82053f844753a9fe0afe440f12994bd3e3205670566d2c42f3bb8d55704c22651f91ccd17550c1ed92c86179dc7cda53705b3d6a5228a5e04688f58c315551f0cc2ae4bb91b860a98282d7aa2d19ddf204ef4398c63495c7c4c309fe64d56a0abb09deffe5b0fc3287fc32139c8d29db51964c7e096eee50b27d0c11b15a25b8669f245c9349f0adc38791fc636a9f480612dcf00e62cc1f8ae760a35b540d641cc1cf8ed26cd4ccb5619a110e1be921d1ce1a838c22b8e2b1914387d93c76a40c22785f2affb14e12041943f0c3341d53cc1be5ca3a6408c14f737ddf95c34170f2bdd9a749aa39082d1096fcfe6919e4ea353f28b233ac5cb2b345ead37d453a24ed387ce838327ce0cd7f4b0a9fc8e80129635bdae6b1d693e66e1e261290c10337e63022faf2b7c694f96207be7df011ebf1bc78b25be0050364c8e01cc8d08127e529a6193b040f2a1939f0ecba5bcadd9481032fd62af82409cbb881f77792ca6214c9ceab0c1b383521ac684fc828e9d5c2ed1c8b6fd68ea4851b7bdbc6c32a7710df2cb6b2d596b276ef10538bb2583cdcb52bd544eed4cdaa3c84ba089a1e9b1a3662e144cd92cbed5797be6303166ebabf718bee952197aff03c8e572d44d5f46e1faef0a3cb9bb667de688513a27c1cab92071ba21e2fbc00e38bdb60856712b2f46f0aa1b1750ed38506bed85845b7d2edf5a6665fb51a52fde1620829725c6f61431564ff5e898d9a83ac291565099dc39834b53d061568d44bd7967a96474c5ac9e71c9d45650ebd53b8b9a32207f19429cc9d32aa4c3d359c1ba5302c336de5dc42aaedd6f307cf16a62e7f9014fec874946f66c2440b198533399685e481b4e4781585935953d8e8912714d777ca4d97db5aa4657b0f2c86850b28fccb5174f958448ec3b6f109370771b16de424b4deab305c608e011b9ef0d35d4e33dd97e3981b8d373ae1274f312d793096356f3638c11b9b70d6729843f4699a7072ecd92fe2431b99f0eae3dbce8e23b5342a26dcacd0ef31278b3476928d4bf8312a2c75ce41362ce1b447752f15f2c44cd246253628e1dd6c670fd2f71b9330a32ae5254542b6dd23c8886543129ec43cda1ee4c8e3a3c1f0620bbeaac046245c8f3ea13d23cbc25382141c2948c1f1458d2d6a981214b3c5390c1d283620e1c8bdf974a0b983601e5f7cb18247b815316274f46f01866981175d6c5152c0c531316c38c271f3f83444c89e25ad1b8df092c6778fd54b68336b2c6283115e497bbaff44b9cf908d453869252e4548561fb4a108d72557888876e1c4c58d44b8b182a5f1b03a7f1c431b88f0df3a36d35c217857c8213c8fee2d5daab2384b1a19360ce195794f18c91b294ceb356c14c21199f9603a59975a8c0384f0e33c96edd72e31e4c8326c0cc24feb7f6f953907de1d34b64c0ab8202a08e7a3544b848f09430e1b81a8c33b0893838e1e80f083c921cbcc476ffc018d4c1bf738bcab42d60fce579aa039b2481f9c6431fdd44b4fe8c8dee003e3215d1da2b1a96ee9251fcbdfc6f4d75dbc60630f252337f4e0b5a5346982876de4c10bfbaaa949e10d3cf81d9a7b8a49191b724f1b77705ac3c553b89c2a74ce861ddcf03873a4d9b45107a72bf289696f9556ce0a36e8e09cc749c4eb524aceff1c9c1c72873b8b1426fcc90014c2861cfcb83035d1566fe239266cc4c19f09d92ad3c5b10215f809ded060c0061cfca852f3c64be6284bb3f106c78247f729ebc940bbc19f9c5bf24be68b94ac5ec0461bdcf45f5e1d44cb06ef26ab7b94e52b91f33536d6e0d9c7f249338502c9830d35783968ac1463d8ec81750e061b6970c2471e79e4779f8db2ee0c36d0e094e7d888a1fd5138d838836f39c77bbc15fa72d8620c36cce04bb2304b693b1a6c94c1ef1872e5aa186d90c1b54c7945dd5f365a8e311483447458cab318bc944272c4ff65cf91da08839f6a5242ee28068353c1d37690f0caf0e7179c1472993cda4c3d51daf082d351b3f749bb7de64e17bccffe51cda7cf39e3e7822fa731a72a936c6cc1b9ea1ce438c7ea0c268260430bce67de4825d3f551ccc982f7c1c34d0e094fcf3158702c95e730842829c71d5e816e91aaf830afb9916e598b4a9f7248b2cd8615fcf3df101a91559e2a7832139fcec444d254f0628ad5d29eb3a3eb4cc18f98ead119230537ce63ebee2851f0725ca4b249fbf11e0a7e94c13ec9c6e0e1254ff0b324fba0719b3f879de0442cad7ce72175e836c18bd523d7133d4c703e0c21dd5b544eaf9e2538adde92adb4ade3f428c14f51e5797dfb27d39304efa333fb10f26614e920c10f6d891931e508fe7a8c98a443cd70be119c98b73f0fd377deb2085e120b1323dbb2558e08dedb470a362189566786e064da867fe74e7fcb08c10f5f29e72e5942864c109c14e93f728a0c10fc0b91a5fd26a6fc3ff02c922597c9cc101f781e55f69552cc1c991e38dff3f926c76ff0c08f33e6c07aaae324fec60efcc91d7fa88ef2abdb1b3a707aabab2fc6c7f6b66ce4c03bb58fe2cfbe34b5650307cecbf9e60d9b530ed1b2710327560833398b45a4b26cd8c02d89ede0c126520e965a389f2ec6885ea1853f922d3ebb64f287955978f5bdc13af82c973ab2f05242b2ac4e1a31a5c4c2c9d79be7ef2d7fdcc3c2ebe9e860a2c805ed5fe15ff24956e94c834f5ce1e54032678e835be1586d69673a9f7c2b2bfc9c254d75a4b828e72abc1ca4e8a87a532ae554e156acd8dbb2a5c2f5e843b51ce6d4d13254f822d9a5ed62e6c2f5a7f0bb7ef36fc6f057d69bc2d3e81fc78e2cc63cd697c24beeb1b536a4f0724e9283f31831a447e14fd09c32a490a9fb88c295cd7142e17a904edeb265fbf380c20f727ad2f439f0b0984f7841d3bb47a5f1841f4b8ac8ecc9628e523ae17d9a78924d39b85638e1e6a8b3534fce34feb1096f432b6d44f51fc96ac2490de549eef247e366c2dfcaea102596bf4631e1c751a473dc492ee1964ca710c262a5f488253c648f439790703b6ca4e66c3fc2cd293c4c872229dea223fc6bb1ed1c6ee635c61ae145c91fc3224779d383117eb40789e1162dc20b61176e2bc728c24dd163be978d1e573912e1cf7fa818ed677e6f22c2d7989d2a6d72e01f7a75882c63443526e34a6a3b65dbcc03bb9ca69a328433e9252cdf660be1b587ef28e7c854bf5142b861d519b22b5683f0cee3cf71ecd89cd1ac12c499824690c69606c2fbb83cbf9ac729a7c85180e8fa839745dd73cc1fc40f4eda46ca1865238524f6618bacedf028688a87e283d3c9b24da8c5fc9ec3ecc1cf71478bbe9ac3ccd9d6831b777f52dfe72946990727e59042a5647de1c10fd2e7ac2169a3398c76507770cc3a741c3a45c518db1c941d9cca1f66d246d192ffa83a78d5a939b0ac70d1c1710b59b2478ee4e3f8ccc1711599f1b0f0961cfa38a69c4b625347d7dca0e2502cad4a558b25b6a0e050c75c9c497c884b6a88f5062fba7db2ce9127ba226e7062537ffcd1050f32c96df0f3e74ef1d8410e6e4c36d41adcba4ee7e942c79d1a360d87863b83375ac1436bd3f6cb9f9919bc0ecb5dd358d4ac0caec7a16a535bfa6053898322839b6442867c9d2e43b6c082408dc1b518b257c81d43ec30ebe20b14705183175062f0c396cd8c92f2068c2f8c2b0c4e4b32f138f94fcc55b85060f0222695f5ff388ef9feb32f940c2fd8721d96e129295aa16d75c18f3cd3db79c71e5c9220174a466da1645ca0b48059281961282cd415fc4edf96599b5e76bd150893d6f2c72339aae0781e8fe3509b42053f96acc5d41e6ae87835ab29389a2707cbed9292821773e8d274b3d31ca7aedc505130124141c19ee0ca4bcee9f39a2a4a342b94139c93534995d3c31493ad26781da54a16fd561299534c2819564bf053ca397a1c58f575a05d29c18df3ba5c390761464d0d4125c1f90fcbb3351dc28b5d48f03c48515631a71cfbbd0ad411ae8ce0a79d57c7240d8dad2dec02b0810904800101e015e07da18a4035822282f771e44cff2887b10c1982a361ab6326ab4a084e0c1d4d22dc5c3d7d40a182e024c9413bee38b9bc1a2038169277ee301145f2e707fe47f93cae535efe2fa784f2817f39ba475a1af398376180715ce00ad50337071e3e26c966b6d9393c24140fb476e07bca531693643ccb573af0ad7290219a873970fd3ebaca5e3b7abbc241c9a81b948cb241c9c003502d8c163c8b9245c7c20df5eb9dbd9d83cc1258b836df1d3152ce34c4aff0bba31b4bd9e20a3facfce9537fd4d87e2bfcf843480b5f2b2b1cf1bf8f37896be8595761e4e8206aa49854856b9739f8ec9034748aa9f0e39883768bcfbf59830a3f489d2147e7db295cc91c9ed93a4ce19ce7b6fc211e6956548a47b52e8614fe5d648b2521d77146e1b94c8e275178df61ae3e494b050a8597bbdf83fcc75015665038196ac287390e6dafe9277c9594c3d0961e79c2d19a09b215d23c67e6ea3ae14cd05ceb97839fe60a71c255ab34abe6d1269c4fb7d629e49834e17f56b7b57d6469fb23135e9a8ec831698af95cc584eb9131e454f7250c933cd7e51c96f0263eaa9c29467df01e55c2e948e99eb41223450f1e51c2cdd5226d29a7a6059a8417913af4d4a42ecd41d704928497a52d4610892ad91d45a2641024f2116eb49f944f79e2083747a90e4255f27bff17026a44c9586244c930002d8215e1abf96692784d96c34f84df53e13c7cf8c8c34741448453d6ea9672487a6b877808dfd7633ab6fb78c2c6d0107e84bbdf5e9b0e65ea160289105e76741682a41c8783f0bdef72fe384f84891105e186f9f86d6248e1cab381703e1679cfe0177676a70208106e9a3415c6e39bfee069da483f41439e0ebe3cc80fce78f668625764597ba90f5eb0af0eb53ff4c863497c70a246f5dc75e962974a7bf0323406bf8c08e9c1ef50738694b93b499e290f4b78d8c63b38e2511875ed280795d47d2ebaa8a100c600d9c18f1c7ce52daadb98a60edec7eafb30ac2c7a08d1c1d33c576b39ea721b9f954073703e34f94026726aa409e5e0c699e46825bc46ca4e5517280ede7f6cce6d29c3c1eb9a7ff76eed383c8d6ff02578290472839f3df85f78ace91c3336046ac3111b1c4f7e95327c62a5454ba035b899b4c4e38fd2f1054b8f406af083c9f8eae821f3777312280d9e7facb982a4a896dbbae302a1c10d5599929d9a365a8e22d0195cff20492c731c6a5d98614066f03533ca4af6bb0ea9d40c50190abb203238912184e8caffd118dca41de5eb38b74a4689c4e0e79f937e4d31bb95654061f03a6a0f2e6d28f98a0f0243b71e161faf41b403d90e5286c65618f4052ffd690e77ad1e11eb0079c114405d7073a4229d5d39f6147b2e78eb91e4e0c5fd2498640b5ec84167f1f8bc3b55a805373e79922c17ca82ff9ed91dc51c47e7c82010167c8f41d265a413958adc5dc1eb1475e621e6ecac09086405bf2b22d7c5f4b8ab82ff16d24aff79d0916bae074405e7274d0891b9728e21794953a07298abb2d899ad039282e3b14ab23a9af44e6a14bc0b12bbf3554ca9b65182825bef5151ce52494d969ee0071ecbe4cef5114d72600dc8095e9af0d4922664110fb2d4042f6788eae6619ae58098e00759e63724a9f6fe8e2dc1f9d0e32d93b1b9dc3f9e12bcb7de1c77eee98a9851dd521290181a7539332624f817e342482d161fcd44001dc14fd9c92244f0202350e51654042f660e9a27bbc73f7c88e06f0e3385f0e8a47d3d43f0abb52e2138915e2a756625abd504c1ffcf19528368deee284070724711735b54fb68ff0ffc0e6d268b87cf7711e20347db262e35d32366db03a7638f5f4f61d192a9c4033f9b9fc72ff17e493e3b702a7b546dc630a1a3101df89bc43a2b72e4c04bf5ec9b16c238f0a360e1db6a7e4b42bd811f7cf2ad189ebc7f726403573b58c694466e33530b3f66be1c680c1d5dea305a3819e936ccd324a52bc7029b05dd9d6352164e980bf61ea5d7b6af702cbc54d3335bb73985c9b1b07023948799234cc255d3573869da3a0879d264134bbac2cf939285adf003ebdbb8d8715db4ceb1c2f39e4e1f0f95d25bdb2a1c0da6213d4277acf6d18419aa2819970a2fa7997c7736ab59d3a870c2c3e056297a28f51c185c9c7ac08c53ac29bc99d9c8f493525af852c0058d30b868412978f14e5bf99b53e00518678b6268d458c1174b0a57b23f8e792a7f743163147e90a24793c1a3ab30191a5b5b70711198218a4546bdee62dce550f83f96b435876921cc0085e3139b3b4ca9fc841b3eec628ce7b556ed06333ce1c6c70e5e65a6534adf09372e2ca36757ef8b199cf0a325ca7ae6ce41ceb3092ff969ca392255bd4aa50937aad5c7a39b9109cf3b9a549f623803134e325b1b97142623a54b381967d13eb0c9d1e7c0b284d7aaf12132643e49e91995f042cca3f59a861469c6c10c4ae0248a296c32ebcc9084229f4bd522749128739d4b126f0624b0938c9d367d943978c6234a06096638a264986046234ac6096630621166aabc1ec5687e293c43115885ca9b78cb58a4b094a3f0fa803123117ea41db587474184d771b0cb9fbeb7473c330ee1c5eada0e59dd93780ce1a4b5b3983c6d5299ba107ea8a952a8c4a0123d3983107e8e112a2e89c7fb853306e17c7c21f4c7b4c93c7bcc1084af261663058b60e1c181f03e8796dd9e3d5fac0b08cfc34afd31656c4f5bffe0585a4e2187b78fa6e90767b4537f8e914bfaa2197dc02ddedd42dade537af990b25d3af582197cf07f526beb35b5ed42f6e075d01c349447f32d133df8b94634456bfa4cee9107afe38fa386d8e6dd9ec4831f2a8564398c953707e13bf81d87ccb8b7a072bed9c1d1e82cb93d3986197570ca266dfed0267be6438734748efe3bc8660e8e471da5dfc710637d560ecee7ebefe81da5e5d138b83e95a5aac5e73227e1e0885df496f02977b45cda60c61bbcf7dc1f6abc498c0d991bbceb60d954c42c6ba8666df0f27730f160fbfa5f35638393834f1bf34716b335f871142231cd4c8eb419357871d1fd25f29f69766669f0f3a7999454613334940c3b836bb6f97abc3acccce0586f303bcd97513f995106bf838b10c933113c5b54c9e085740e2e96ab6763f0ed43c526063f8a0bb1101e33d3591606d77390b4e472e6e2319b0106ef3f8e9e2e760cdb9f1a5c64d105667ce1d099b165ec23cd0b6ec8dda375c1fb0c1a251ad55234e48c0b5e0eef56d9afb7524a99b185534a613e785b4c0b25634616fc784268f9d6050bbe97e44b39b860134b7205cf42a67b2386ade0bae6a083ecfe55c109d6f1588a8e5f33cf8c0a7ef8cb1efb45774f4ea97186195370d2a5884ed2af5e618614dca0fee1abe1d903bfe08c28789df512c2260a053f0a1e7d8ee051ae5cb1194f2819339ce07b58f7a179c8a6156634c1d58e3479abb29ac104e73c73b0c1c3740a09c330356a28e0a8306309ce59576c45cccc515a4a703a88b84b2197255c4c129cc91ae536c54dfc6c186074988104b77b6b72d958ca95c32338bfa131b4cac49a6104b71238d072f7dda71cc31b383968cb6c39d747a1865102b4817721c7d179089fc21f4617b5f0b6358a079121dc3bcea185977248dd9accfe443467166ee5f09e0e61230b37a509eb0f5b458d8513aed7b7f224d9aa0e58783f1e32e163abf2e6505fe17a12c92ea35199625738f9c43aca7c69d4563863a12694cb6a674ab1c28918f50e3a85dc211dd455789ea3780e65f2c7fdae2a1c8fe55a727f57458434b652e1f67bbb4729152a2a5c911021e768e5129cc28f16e45682799af05a094ce1af58df4db6eea8a8992e4ae17a4e2d91b5ac2d788ee98214dee634c152921441b25782517839795484f02fd2a1470944e1c792dd4ceda27a0e3d686cad20147e642f413c8c9e24c8240c50381f9bf5093ff95c4e92372397d734b63ce1780e2d4e423d6bd947630b062a305bd871d1092ff68690aafa301f329c70b3d99cd5ab6d7da86b70b1c531606cc28bc9296caccb4122832b48c116c780a1093f664b59ea731c3e8c9a93092f48260f36f23531ce83093f384f21390827dafda15ec2098bf4793ce70d1d765c58c2f5682f4d6fc97092ad842fe1034f521fda668d127ece641f7c82c51cb19b841b26327a643f3f32794978dffd29c739f6abf0d848944c2b88aa0a09677c553a87f1230ef2a8c79ba33d8ef0afb73a2dc498d3083f4731d69526af93a85119e1860e24c424314663cb8e8b45b8de514e392aa9768a70463b448e3deace3fb64b847393f28708f128cd4388f053e4fc16ffd12cb87708ffd23f479dddd37fec686cadc0106e9aaadce1dd2a84f39a27b4ec661a5b2b2084132bbadb32bb7a983f5a83f037baedb25c089b5e81205c950de69eed161c083767ee2429e19f332c07107e9c1d78a495bafae53e7f70c2edbcc20759543fb8fd11918368963dd284c65639bce8620b3b2efae087b92e043ffba8c1073fa829b190f056194ac5c2edc10f22499494ac0b430fce997cfca539ac6c9eae9107673aeafbeb935f9af0e026f37c72953ac8c126c57cf18230580b7707cfd7573eae5e8b1d3dece0c7ea38dbf56438f3b70efe7b592c374fd1d8ca2b1c1d9c1e8f65e4838fa7d70be32881e9c29439386e1322f957962021a62686938397153b88bd31a3ceaa38b8f6b1d3266b720b72515b3838b8c9a3fe308c654a1795c656175d1cff06bff367eef061a4b165543837f8919f773069166269ba2047185b8041d00ad706e7e3403b0e2a728a9aa3c0206c7072d8793df20e3144100cb206e78278bec9ed1aa34234b64a0a8c1adc9a1c2761462c54b4068cabc2a5c1ed64d3f15cd60a1d79d008e3f69c3ec955ece8cfe05c0ec2c775446bfb056084d150383378e641f27855d2bb864717a60c6e4798903c92a6b80e17fc8423833f1179a5e4564c3de8451724851b831f467f2013721c7dfad4144e0c5ed6fa143978c6a95b617051838b0ec89051e3306064e1c2e07a541ef847a1ffa3aae8a760050da8b26ac081c18fea7184cd9a2465ad0d38809001179840001a9081001422ee0b2d382fdc414b739ca93e5e835df02e86d4f751745d948e0b7ada8da8a87dcaaa64ce410e52a7152ebc8403b70557d34d3282f7a4c711174e0bce74479b2652597a59c0821da6496a21516104e353c0c52ae00487f1c0d2e0aee0d5d7e438fef168fb4c2b281f92c486ed899d14b4c08b2af8e236f359253ac41c1f1510b30a1993a91ba7e05c58f5f10f3d2950c940c1393b2e0a7ea4ad8856913bb45a0e0a8e9746f0b8b7f204efa754c5475227f8b1e5cf9e0bbffd56362003013061bc6001d704c7c3ac11e6523a731cdd35bef0620b3ac031c1edc9295eadc22938bab8c0dd124e097bc9678acbadd749b8799caf637a94fee9724970d67346939f0e3797f5c221c1a98d99b399cc5afb5c74f1859d0dee085e0e31215ae697c6d61658293823f8157627a231c4be34d33057042f6976cbbc313db88e6b1c5de01b16b4098e086ea698d32b3cf82d936e087edcff19827d502dabc018184e085e687d9099aad2768a34b64610fc0e3caad8a8071e10bc5e9ffc11a6638a089117f703376cca72949663c0f8e2c0381f38de39d2e6a0a730ae077eaa9cadcf46ad6f4a2f3450011932b0ca7441081729505250703cf0d3d7d986a4298a7715800d38c08bf7e2bd0043868c1a40b81d7471dfd2b131ad36e191071351619f6381c12e0e2e50e0450a5ed085171730a6016c5b9c0e3c4d2184f1286d52758117648b13fcd10569015c0ebc983ef668c173440b0f07de77d44af9787318961bb8be3e296c2ec5dc77391bb812d6d972d4e814d5510b3ff83085acf7fa2861a685735fd2b15f4a0f73350bffde7a543abf06935616676bac2d16be7c64b5106ec1c28918acb703f5384aee157e581ad2dfe5509a2fed0a374a8731756c2999528ac6568d305c605290260c08981280612870068609830b11582b5e60acb03cf46ecd1cf2bde9e28b15849132b055b852c17f323a9655c9686c992ab888b76b53d1b031cd381525c300868a3c8513d9f17ffba5a9ce1ca6f02e49b7466b4729dc983f5d8b5b4d0e314d0ab74ce23563888ec291f218f2da6a989c5451786b1f53ca398cf1209da170cd3b995c7a11149e7ba7bfc8b0149fef13ce4c28b10aab75eb9a279cd890e91fa9ea84631fe13707594254471a273c0d19f9c2b565f00d18470036e08016d826d234519689f58061e22ee1471ed515dca22749be251c8fa38ecf219fc204bb127e1c87901d5d8e52a20fdedfe75f929338acb4cbc463353433a4e2ac3f4c7b88866192888466972993d9b11911a57d1ac3c6b429fd6ffd050afe1a609070344d7618237a8a5eaa17ec11bef46d25cd39b81025497630477877b9ee5bc388826b8493c3f8ea8f4d5b571746782b6e9fea915b08e32fc2971c856ac694a366cba1085f624e39871c5e22bcd8e95130f3f07187614384ab12623e115f1e5de510fee6b6b6f4993684d361f759470e62d4430be15c0e3c1e896595333a23045d33f3991266d7d61d9675f5a6d920bce46e75d5d1bc2bb326083f8c39a514a239d2b4ac05c2d30cb9238a040dd7a401c2f1d451f6e8d1d49be11f8c918d2b754f8b56e9b8894ab39ade4792e607da5bec6c54c2be56cdaab4930609361ef38c03eb431b1ffce94cf770fdf9b377d81ebcf45817c246de43284d0f5e87da546e9993876e7db5353cb811fba386b46a7770ac5a354750edeea9006607dfb2d5d3a67caa4942ab0395d1016b043607c7bdb35da65af6e74d0ece4b8f7170a3075f1ec7b7191c9c4f5a371e47e31b7c71b1bb6f606e2086872a579936fc9792071ec22fdd0563836bfd9155fa585e831f91b1b229726a7025e634367a96ebb034f81672ec217f1c79a749d1e0e5482af3bd947c249b33f8d164f2749725dd438899c1b530213d3c5eab3234b7d62ede9a1ae36aaf91c10a3da6152c594e0c360627449cf5ffe5d32031627032e414727aca9915626160edc2469f6b1a9f1818fc94c31c3b54675ff0e3a0642ec7f19b022e507010302ff85172e98fde232a214c638baca0c616c55406ac0b67c9a1926593909c2dba380c05c605376ec6b643c99ba84d63ab03b605bf834a396244d4829f236382c751b8cb18ad8065c18931dd8751bd2e735d686c616571c0b0e0a59349111b33a50b2f1e900208d448bb8299159cfb7cfd4972c897b2685530bc6bace3b8fe322c1a5b2738362043460da3829f37ff7dd0631573e0076c0a9e858e34467365a8de4881cd98da1229a9afcca2e085d015deb27a7b94d6801f18149c6ca16b45dd6653ea094ecc5933b293f887ec7182e7e93eb6b46cb126f831643609a395ecd73726783153258922b93ac2b32538113d8c39a9594e16a129c1991cb9ca85bc1d795b92e07614a63bce1a5b7791e047679d2c8378ec087ed0d146761c7d23f8e171dc29ac5d783057236145f053fc7c0c518f59c910c1c99024530ecd1f840dc12b73ed34395a3e548810bc7ef9d46e29885bdb41702ad3559e2b919ca20582ff9f83bf7928b2c27ee0dd7cbe530f727ce0d4b8aaa4b41c5a4791f580102e868c07ceaa57c5bbb4570e233db60327a75ab2d3ccd179209b0edc7c611e53d942638a2c079ee51e9bac5ce2c01b99e06bd6e5a1a27603573e0ab1b2720e4be29b0d5c59514f3e52572dfc503284ca6b322112a385b33d1946ead3df85a80c195db3c036bea4c455eaeda2c43a230729edd0c30a5959702cbc4b1d4a2686498ef2a560e1e4fb494d6f59bdc251b1cfdcf1c6c72b21e50adf3e236a6aef387298af56940c56f42a4e154eca7f29480a49851f468d47492c64f8aaa0c2d5b88b9cc249d730f639630ac746a2626d47be1ddda5f034f6f5781ca9a32435295c19f55c92394c392677147e0ccdd2d0fe17731415859742884f3e1d190a3f5acf39ca329d66db8102eb13bbb6c7684856846bcb9b45857471d9138ee4c824e7efb213fee6f0293653cc7571c26a13a609b72a273bcfea67c2e90feab306f5ae910926bc605b1663844c6e91e3127ea61c43e7a9eff7e9b084f7d513357beb4a782571ea39ed222ecb9428ba7775ee306627e1a47c2127ed50a36cc84ac2cb983985f18e23974746c2b769e9483c028d59a8048de6621261341289442271201406d36f0f031408001034208dc582c16898c7a2ee031480035f341a3028202224161010141e120d44c2601818068582604018100805c2805038401506bd3ea5274411351db188f710dc93a61f8e7a777022ca208eae0a8dd017dcaab609c50dc2dbb7f3b55e1293023c212952e454d8baf8693705114e619b2ebcb2a7e5e78214740b07f9d39b57b021c613158521895421a4b0bb1e515a9856290b682215cf14183048a1a0f0ac5e8468be0821bc760ac2d9720803724138b31ac2895b8a952006d6e2840a0b847016b2467044b9bde878120c605c6e48bc1125a1a67c8642684f998e8019b0ece17ff0209c724e157a10c4d718e84ba9088ec11d610403bf091984d5647b05d4152016a06f565605e1260e21770b31b950f1e97b82178a21dd0e4195b30808508550b89763a6a256c80db03fc35380a2b9e19992150bf1f3506f815036496776ed0783d2a5939090452e91a1ee1a5a1e425346692f95c06c022ec25fa97201f563ac091f854be5f5126a37d7dc7b59c962045b7c30a6b8ad79759182b6a1029ebaa8900fa73b54164e633b8443f978236258419fc6c6a7506178acfc911ac6a8bb22103f21831f9652874afc333a574f739a30a96d236049b75d11c2da125f9170dabf472d0cb16350e1c4a34f885396f778a54cd01629d8cc3fb89d0a9d09603725a7738107115e2a282457a60265e5d7efb6c599485504497143e0520e22f537edae65e9c3105c4a1ce2efa89bc0deb79669f304d863a667b50fa0ff0521bd9e5ab6aa9233ca340c53d16b34c5ea8c60a11db474150f552175dce10f92f4b6b73ef6139044c86f92e5ae282982a00536d24b9c46ddac707b5516c846491004b19360320863aa3730e45c267e72779bc447f817cf7d02c986b02a6329a10b288d081fb16c9a732f50b24f8f9067f793f62100854376b511aadf46f43a6f1db4afdfdd921cd3aabe912761f1542f24b70883f222d7077033669b3ebdfdc8754469d169664bcb86ea9b696919a454502a0d21faf329b78a0a822e5a65f38cfb918c898e43ff9409245a620fb6b9a8509876882ee575f227544f2ded09c5f8577439cfc6baf66f538faf08d8ddaca1f770800619565a49788fb6595a1e981bff81954f742ffe7d8b588bf4f07b2f5eaee7ec53bc816265bf52ff4448d7498577dee4805b11a39a0072f62fa5c89e84e5748420723cb030684d453275873311755c7c4f48764b649820631c2f400244aab92865c9189d5cf6b3e7a28714e977d51761b52364e9b870a02adbe4edeaa0231a8aeca19180d84e75916fb2748422e4f74428ab71346870978175deb753a4d15d118744cbe854b791e840f8af971f8a05dff4388eaa36c9266be55a11e4ef01a7925ddeafb9e8629dfb5e448f7b6fb325edd783521275b0f6ef971732edb29d08c2bba822797113dccc43c057c0edb12233cd0d0d779c2012e7b9f77a466cda1c6590e0c37533d0dd86a6448051b21db96cbe8b757552aa780dbe965cdbd7821d42d0ed545dead93c4f5006ffd54e1a9accd91d7356ad9d8bf00f2b6b195612c7ecade6cee62056936539bb2aaa8e25c9ed9a42fa6cd8e8b6c74c45f3d950c58ff4d699f7f87fe1aa897a3f72a247a07f6d5243f7d48a6d119d5cf8e8cdb03a6459430fc417a1c86dc46c20197320fb0533a491ce51f888475dd3fba25a7e9444d13753a2275cdb37b6c19ce67d277e92ef98531aaa166ce7a1a017d92ec65bcb24b8c04c92512b882228dadd23ba27439065e48e3595bf6b1f78e373536c443f346fa0310ee114a35a07dae6fd43c12404d5b4845417aa833324e5348c9cfcf1c26005c94fb168f05761ce1bf9286132546ba3d1f2630199e691ce205f2152e7b069148e50f557300519a7c693e7f9c09ff9583bb8e768632f3a356edfe3e483756711401d50565c8373e32da62afa8228d021b0757c4135f3df31800f0043800ef3535b7b6f3397b18dabe5268a91a233816c03a5569d636eef0060077e4211e210a879ebe00c7ffe21ff08beb694b2fb7e3c0f4198c48f4d383fa397c6f693ae60a78af23c5ee36864bd4cf45803602f06b1b9f2bc2b6c5a33f0bee73e55bed672e6579c628e657203b7683086a3311d2db65f910e8a7bab6675ce5972bfb71b246e2057ec05e86eed71a9f135cc80907a1229bd26ec865f451d1bac87ca59da984fea1202d4a50b571cdc6122681eba7ed0a7fd276d5347baa70b7a90fd483790a4436fd2628a6ab466f73330d782f5e2b4f6dae245b2540c4192bbe9a505fdb9aee036422fda4d5ff520230ad30ad018332b6ddacc5d373a0bda48412b9a28d01bda2238101f02b170139e795955696ffc65d87b3123d43c061b2bbeb8070ed0866a70ce426997969444a4a38cf1ec67c29f9e219f75db7946b5de2281b040f5ba9bd4c752a8547e7fba1de9653563ed02ee1e6ec2c7a49eb18c5ba0058461f426b7905629b44eaa636f821da61fd116cde255edfc5c77f68c6a75dd885a6ce490ab0603c3d5073e5a7d28036cd0fc7876bd26740c27ccee75bb4e2bbcbbe49dda59793a565762b094ee3669e3ecd490c6f6803bd2260d7d2e78f9e86eae1d9a8e484fe0e30b7ca4039d71818cb137d7565c4c7e3a1a7dd39c9d1d480ce36a9e4f6c4a25aa4d842ec4ea94f5c7bed2d9b5c7c84512adead81f91134a34c34e42c8c1e4919ae9569103b192d36cb3cc1e3a5839b1ce06bb2cd847885080f36aa4b99011670791b367c4bd2e7f310251f5bc464adb5d6690dcd1469e105af7864bdbe8b1d6a52cdd984d5cb9cf49c572ca85748c86531ece9eb41a0c97873d5ccda9a30f6a2e81596dab885e94988540dc1373963d1ca5ef8f5fa1be52c9600b58a8f115eedf978be45dcf4c0b00174fb3a051a1f7c7bd81514162ce973141952a1cf1eef62f0b07119deede16ba40f25ea081655b116aecf1e2c2d0a99550cbfc0b18ab7efc1338a2b3854d0609089f715ed9770705f9f31090fbdbebbc5a645b26df8ce8d94262c6834a92937e66d96496e412d17eafdaebd7741d5cb939874db13fab2e993fdfbce36425443cc60260c5d77662bdaeff6aadb59b591a61d072cc6b95f9c18518dd56ee065dbcfabab7bea5c97ba7ef6af63da814dd53b749b97d7e92cc02b42bfa1f6a9005d8175e339edede3bb4cd194914c65adb30cbf4dd172cb1065b9993e256deb6c6eb5aa95e76c4c7b29535099cbd02f30a15a13ec3038de94d3f1f461d857dd14c448f2902b8d78f6a6b84dd221b4e19d2328e5e35567b5e46398d2ca901486b0812b53482d04154e9165d5e5d799635f10da283719c95df25ff5d4a4dfa1d7482dddab86da3111b1ea216315fa3244759e8d688143839a65fc8958940e5452e62e8af757fd85807ed7ca2d5c02989a58fc1e85a3eeeee50169187eadad0f9325607dcb9df2bc8ccf0ca0b2a27a5e5fe73873f865e0a9283eb325c10a9d74b11fbab49b60d6b97fb4d68ec29339b2d541d309654a86976f4741521470e96d8ded664b05e1e7f1d206c02cece312b49bd469872c94c51c764d3e5c577d4c60ef0bdb990437b1740ebd961ca0fbcdd54184f836e0803c76f57294bc7f6820160af3531bc6aadbec4e2074eb3fa93766fded42c4139bc24f142732a95b2aacc82366e4640bbf5513404a6d60982e492afd5b621a93d5edc964c2af721ef7fab280f5538a58f97985fac4d34c7231eeef75ff61416f77b05861cc5e68f54d7ab7405134d1bfbbc0b84b23a86d3ad75039072670b0dd682867c2f7d70750251b1a9631b980121d3e98ec4a507393daa37cbdba1a81f5de29523b10126efcf4197aa520c15e1350d33e0c48c8c04ae3ea6ec62bdfb5f3be3973045f711c52d1befe6f22c7d2aa7c6592fadabb31ea21076c5009b6c34b5ac0a1af7ba629034a66930a7d66c48bbc97757e38e4281d90e61bbf2d071ca9509f7b91d1ae9f295f2abddf82b0ae0b3af3635765bc5b0f340af1016aac3611de00db14a3ed4ebd8a0f7de500a141d26429ec08d57b309ba8e5ab6804d76a96412146916426c983aa99200b53a558732c37b7a5b4128990ac50e94e1cca55b97e01099b60739f7836ed6d83ccba1c3b288f108540fc213c1459104bbc2588e320f9a3031eaabb943ba93ead84b95e7be8e6a3278cbd968475fc35ee436fd9482dc441c51fbbcec9e5389cda072af92e96b25bea222d93818562941b818ef41b89a90b62fd460a74c9f0fd5a0e71bc01c401924e149a8ba8cb83ebf73d9956b414ac0242258122f342a68ae158523079a8253745cf148c114b246472c73c9c0dbba866f74696a99e19b24aca0ef946b4502ab70b64ff97a303c276da5dc1741b32da4c0d3b433884a765297e33e15b9959f2212d9e19f2b89c7eb51c45dec4810688800795dfba3554b0a299f6a1fc3a081942420973d07726ee0f324ddea8b47cb4af12066cae734a0e1699c6821d3545e67aee83a33c23f42dd1dabf08f2b02b4d36c24c9d4b841cce7de057e75548e2b7252601eaa9e9c75885aa350ebb59d885ac0f99d1617129291e0c7a0d4ee8864becb4d85afcd24c588d1d33d8a8711b14d1410109b26d62628940eb5bee029d496872170a4093e430c38ce36a9199ece8202176178a4aac81124937184ba52d2a6d928cf4082a3423a90ea1741c45a6a38f06101c14d58bc33a0d65cd2eff30856a869ced38878684c0ecbbe092ba3092b24b6f4cc2c5915bc31bc22b1957141bc318923a587378155faac7ec08de891b1fa4ea08d04e9824dde3c0c2bd452bdf5a588f885b1ea377a17425a1fc84747171c5520132bb12ba9a51e31604b3243413d81cb3bb0276ce9ae436161b7ca2b7916084ec69832c96a53d734cc8cce3f4c86dbad1e3b87188e6c35704aba0ee1a62aaa37f23e581b17c8d2d9c30dae4ef097278a0a86e542a74a3b05544c834dd1562064cc584642c328414a32a57fd12c986f6596ed109fba9ecce65bf9e985eb21be0d35953bdd2746fe067d1f317528e1e04c1f6610ae35c0b3229bcb0ff186dcbbd59d2a4194a038e2c4a31182a340649f730a8ed21d87511e48a16a8f41b4c86a8499ea855e0cbb035cb521d217508e90efd7710d834dab902aca5cd7d98d57ade44fc136efde6724cb7163cdb217168da5a5fd068a68233c50da1d4368b81eba4a340e7254f13ab03b578115738ef61313df4640658fde4ea4ab00f6ebf0d7138b47fe96bce61c47804813381da2b5dad98336c741a7ea4c483fd64160f83a51bc70c6d1f127b2851893d8feec9a4e12e5329c45c15195562e436dd81bc1088eecf038771a4120882504c17304debad61da73198cfe46436abe2428efdf0bee07a9c92d9be51b5460ea9cf3250d6540c74aeae4120a3d7cb70c3e2c2e6d793ae720fae8cc609ef144633a998b256983c093e70483d55b3d35e27586bef9dc70f826fec52ee2e2f2f4e852e33bdf859ca1e0e1b78ce6bbc557c518a02ce6e07b31d1c6493b1045bd624c1646e010fc644c231cf6dc987d50295e2bb2f126ed3b47fdba3423aed5190e8e2b245a63296028b334cacc428e33aeececabda2ea63a07bc7f18b4404860fb6a208a56b8a09df547b6c28e9a58a50271753a48dc63c5587d4d659627eb04d04882cf6e26315184a94f8544d110de4c0f5e513980b5310786fa15860ae3d47510f3cec0bd41d209fe35202c802e9edcc7f2defc7197f9624ffd0cf76d2e603da783340696b490a35be8251abc917060869a670eb19277861f1281930558897a448222403e48cfc3e5a7a0354e440ab2e77fdf4b31a47ea96e19cb1479c18cb3d4dcf636cd4578fb941214bbd662255b6057e420d4fa601886c9791b1b8425abd368bddc58aba95beaf69ce936cca327269cd52b4509b21dc60bc61f351bb542e172d2d2061368e809f77c8d336347e2a5397170c33c1e0b63a817d622b265be46fd4bfd45f8c32414bc495acb6a22b6d5b479614cc9df15c33bd543227e603b8ec06e680088e168c1418c848d43a1b939e3137cbb191a84ca026192cfe202a14951edde592e171a3a06e9dac14ea1c154f45d0ce133deb27a7a53384184dffaac6a5632f59c18e1aebf1b0d1c4858a91ba90cbca0d997b540dcc6c1878fee3dac6e9000371b1de6adccaf9fc275d589755b3028d4f7c7615bb2b981cff8cf66abef2d89ae0c42b54a51a5ba6510e745e84cae6159c863a60435c05fc32c9b32f26aec9536e4aa4186ef396b356fd6cebb36e6d3065dd0dfb2b85f29bcc9711589fcf49129330956609bc26068e47100d8cf833e17ae729b63e4ca665aece3be497c235e8299634eb20c5e07183615431492131d12a04f5349bd45d49a868421a640a76882b88a8a3b600be8c75f6327daeab628d2561a85ffa058b047126697a08881355326c537c1dd1970afbdc223d3f0f7a8df0ac9e826d36bfe8d2c70a7a8f58be3daa45edc1c794d5feb252c91fdd754a9f1c79896e63775edef94fa139f7c816fa8831cd71c580808680e8f0f18653cd1d9056f56fc35847ea888d4a1cd9448d62592a778c9fdb4e915b6406d93f68a82baebfafc511d7cdf6aa575bfdd4995ee925dabc919b6056a07a0c225cf5e969baf843c906da80fe828e812479ec8d88385f9f2034bca83f593087790cd5a478561e1ea8d53febc51aa47820b8efec7403591c07e89eba26f067f454b55087ecafa22864fbe448119085535a7f0180c7a31609e447c661523066100a4d499142650bcfc2186c64021b097152249b148ef9f00a339ad306ece935835dde2cf31cf4814fdc1fb7eee6b9955acb8e5e245021d3510626559f164505d1e6aa688a7cdb6bc2e70e9aa7b67052bd7210c669dc26b36209bd7e43ed136b938f809ae052c92bd9e43714cf3011aef7deea82253d6fd0beb34eb0a4884a74098524f904be3794b72197aabbce9f04f4ce7768be2fa7df332dde128deaeec391b0e23b40f22c89648ff2806f1047c146e7114bfb30b7860a61819c8b24453af981be0abcdde0982a148bf6b816feec90b8210d9cebb0063ae38651fc6ca11036cad0288a1a95326eea8d230f0ff20e81879b574c49fc611bfcb5388b16223f6b4bb45d2dee4ae047f9a6450c655e22d3256d6946bea814d2a3eb66a0b2dc85fb99bd1100f5a7fe50bec54bc3c57655800116b94e737159980accabbe75b7a866695f3863b5bac4aeda1939e926b7ad8d739ee714b0979977980e69c413a559c83608078be1b50199b9437754e676edd7d956ff9b858202fd389fe024039018ca2ecfd704de685588e71613527ca8feec4ffa1f636ef257d7b32bf00aa377f51639df0d670ca8eb24e6c2496cde3e7241a2c4a1541d1e5deaae3efdee41389e074926cc2fb3aec6d91c97b6c5d176221de06d1e4b29d11d7c858f00580d81d6a370e69f7a7e4cd9ca3ad1148f93b8faa1b88208b1d2f4d5d0cf980ae98f668285ad7dda5dbc04326c4c17cea63ca6703b9c8eaf1e48d4681ea73a2b09eb1c880ee4c8ef29a53f5af0ade76e8b92cdb8d251ced47b321028b1f760388511c0a24e65930069cc448b0450af7ca9ff7322bd0d5669951059c3028562f0fa153615db6c61e3679bd9e41e3efa30719e0d14a272c9d6f29074261460e65a1d6a2aa9288fe2bd7da18615025b4a4a11d00b5b73abcdd07d1cb2cea1e12bb8b33c5afaea4204e8df840dd04084f4dcf648f0f0b577709f839b0909feb1b6970e19166d3227844b6cb6faa891465ecd58200d61a8a611befea0dc85a908c06750da51652634a6f4461094bba9b63105731e39f24a5d49facd94da387239d4a836499437895c0a647b30923a4c41886a1a45c2b392c4d777826c954078b4259509093926e04dca8e37e3f6577ac6c2f79605b31e2ba58be9d4e76dab07d5832b304bfc4b3c3f5da8279f710cee87a8a4c1d06ade554568258b10e1689c0f3aa502eaf3676ef37ca74b2b92647cf1a7bd49095a2e4d64a0d6d2ccbba1b0856ed718cd734971ce750e2bc15a50dd3ebb90743598066f3a9402e28ba9095faba4bcef9d3cdc21b145bcaef6309dce6d2acfce2998ed7642ee9b1fb5421ae1d5c8e5e44661f59ffa3847a306c49e34a59fc46d4d780a011e9bd466a286d893c586f5acb31e9dae3bcd7179bade085a39b99040d3cf6d7a6776f29f906105503571c0b02936e112ff26cf498015e8ba69cb9cc6be65912557a0ec5a1f958bb00175b2ba604cde7d0252a1b389b66239c4f1c417f3d4b93f9909b0534e9226b44c4625c8527772f48f22ea608b2bb1d39b1f11bd5767909ae0d9883f430d999bb73342edc16caf2ccb3e65fce29f6f0ec4bff4d4015fcad282013788dada2ff11afcf93489492dcd37ffb50b0124450b5666f8fdc6450b5b2865c7132b90be40515dafd697a23d4406874437cf8324e175d9068241273e7a3ca98f7b095a831f5a162d70986d38892536d59f74542685da79fbb4d6190e4ee6c95e3cbb4bee05470cc924a7d615b264b246e4b046901be1aa258ab908555452e6813b6e6418b4d1d795cc42301c25dd9ea72bc5acc879d142edc9a332b82baec64547f9269c3330533fc68829c207bc31533d5340e5cdb7dde872ad58953989279cd3cdd318bf529c4da0a2886d0aedbd6ef4d49bfcece86a3e0c1de67043e0db4741215c087f120f4cb89b03c45112bcb42bf50b49a5d8dbd41ac6c7ba4d2bc3b504be6c7362d4e7225f5f09e24a1fff1f2884291804327ec56a311ab67525ef3b12531ec0d5cbba8b5491421b4a834b6680859c9480be78fb5f8a37c3eef2e34f0910203e5812d4cd64f277a884e7cbb13d122929a7779ee6267f2932c3ab121a9e77d7aa0b2176210eaa90f9ae1fcf0bba665f7c5749834ab72384ed920d92335e653e4e71b76c1678c8273cb1d37fca4921107f83136ac22b2507af5b9bed53a00b3f8d6a9f125e4e3c9e5a43f36ecee26774db6fe78deec8a6bcf11eb719a208b18ca704379f1b4ee267f501f868b2653a4ba0431f5300b3d041e1ef8116921906ae4477c88c602bd4d57dad77cff670ef954d86c2a985e2939955f9a0244af02bc0b5bc7c2cf292636400a658297220c319d3b52bf601a4ede3e2088392a9d868075ce9e21f2ade8d3cb7733aebe7d31ca2e27efd0031b8c2729fd09205a4ae3b35b3b16edd9b7af8cc64cace999c62760aa8a52ca2ff7c942ec92a28e20df5bdf507a7f6612a74fde57ed802b776a75460d512a06b0a1f5379639a5f28cb6a5d9c350ccf82e08772e862fa345ac0c108cb38b4dede3647a28ced0233503e4807ec310619d9ece6c528aa4e92621a826074ee7ab947a3c83c1931080512bc94ea59e30f61b9517ddd07382f853f45f32dd36e101e53f64b76c7e403a84ce8179a1823c737a60ba87eb978abf2e9ba1f610d730d4f123c4881c98285460937157c318919618358480e3a03f7694ab5842f46c76edc63e932cb44d4028058787b013dcd488b021cd8c09276b46969270793430f9824697b3702c6456948abfe3286110daf573fbc3b27311791bd5630498775d2988d3742900beddc738386c64925edba15ea41d2009232d0da584cefc0493173dcf7805002cd1538874fcb8354e95e3fdbce1bff83c38c5414b54185e9078d7b7a0da20daa7a0ffc0c00b3e1e927713a0b1527e92d7a107a16c03bf69f46d0db02dc17483fe68ca8ed82c6e18ec5f411b9ad662e5372394e28a21e2dfa2e897ee625a9431c91876fe47ae114d4c3a73c94c87ac9825f88122bd2ee432421919829cfa66fe1a912a7ffc38b45517cfbf8c029e7f96abc45c0b89b197b4806700b72c91a1f288cd309271744f2e52c1efcbb2cb126240f54bef68b1f330e94aa16bad5f28910accc7c3e5ebef0ea235934e37bc0545f441835e22422954a8cdc669b2fa24f890be8140426cad47cb2951481570caa7a8c1d47818de0a019b6b105366b6727ef6536da19b6ef22499378f44441b4c2549e600b40ff426fe77fbf97211f7070b6ab98d38a5d60ba293782dedb85455b0de0cd53142486b3c0ede628f15479e5dbd46f0afbc21bf5658b8615d576af75e8f97ba66cd974f50ccc67831688995ec7af501d98efcc6e392e86a29440355bc0a8083fcc20642c442da55502d14a3b3986ef5c87679824d31233b32cc351c0e181baa906ba1bdee0e6bb07305b37b2947bc7aa9ff1acd1816b0f845f053cd401d05386f41a20f45aa1b6d87469d12e4c0ca57643c29437c744bd0d9fdad3096976bc5ec51859e58de50f2efa961884012b12b25f257b024870f1e6d814c9d9b6d72570cfb3822b245606484b0241ed0b47fa88d25794d7570d61675a2d000a399d73a1cd06d86a1f47000f769a2162ce532076d933edce7c7b7b17af2ab6c06007142eeb7c72fd42cfead40a0d91cc91ae3e105a032a9df30847c5260032c98244fda269b62c3214999102957bc0d483a6628681472f5a569fec9933879cec9303ac64fda540de38f278208971c5a07a35a39e0b5b46ac24730dac726a691271aee0af674b35c9b820221b312419b41a275c1e102c1be15bee5257e812f0f05260a338a63d525546048de1ac7a6595972217faf2efa0d01f57b6ae938d7eb8bfbedbfddefb181e5591044928716ea3b768561c71106ccd1e34da4cea97fd791c39ca522199723a55ad4fd840fa9fe293dc5ef82245359837c9f7862707beec18037e7a7dbd8440b89244affeb78abc14709b1421d5614994beab88210c686fdb38bef3f0ff5c7de873432fe64f142d37e4f02f59c0671a2594b2bbcc83321daf3f3ce207011954abe16f11ba286dfee220c328d9c7623a71d392a1e3040200d7b0e2bfa6551e10dbe3448028c855eb0dbe72e16b4aa12f924c11eda878762561208b701a1ac2bde0fc022a2b8a83a245c7d60d808508b4abda89107f1df8162967a1e51f44a34888ca7e1dd3122262c4b329bc111cb4e4a421812ba61eb8581f347e3236cd51ad22e23937e12296cdca0287223c75be40736832a4e2f38ee2d0a6ab1bf7d6b70bc733f654a277b877dd8dbc97d33cbcef712ac46203adf998085220354d9419495561f34fb520354c54418468ed1f3c20cd548f53d6184ad91cceac6fb86d7cd4cfe4852ec8cecc669292bcd21d115184829fe8f90df4c3e2685ed1055b347553e4ebc38897e00dd3d412eec6cf942c33d81da3030217ecf01ff2400fc217fd0cba6c3d46284ae1ac9ee0599fd3d947ce98ad5beef681bb529e19a81cdb8abba3611226218cb0ceefb9971ba932fd0e7bcd1816f0c9849c3eff3baad10f002b6c5efde370a04779a40f3ff721b45035fce84878d4ad2a19500d9377168835b87667e8fc4ec2b4964f738f54ec48d80fccd1479d522b31f6e370a20fef525ed815baca5b04cced71d8e6569e6230c38f211953d803882d71d4dadce5e2e495d4edbafff770e77a10f50666e8ee28cff4c55dccebbba28b7e21afe962366c17cf69b107f10ccab07ba96c27a388bcc22940742a40710a4b8cb6661d5969224165bcd3cd3e4c99428686d59eb2655b1a10eb3ea829115996c35da20bdc22dd24e56231860e15ab7e8f79362c7f483528ddcf03c7b02d977525c8f65bc48b1c463eb5daa899b0dd0d55ae24ee0ac92290da6664716c6b54ccc66599038b30e96ad8e14c611137a8c7e88e1ded233daa24f19b7720af4cec036f6f8df2cd28a7df426a0adfdf7353dae1bce4ec6989c5d4304d9d329d35668c0ac3a29f8ab59a4e907a3be067d7e014711c4777dc0ff0a81e8b5ae4765b4816099c40856da9419ea662069b9ac1718a3d9dda03138bacc7df2f62d80327965211bea0d10bd1107695cbd021077d8a2959932db24508fa68ce329aa0f4fc70b2cea3fdc05b4ebf81f7f45eb75a53f8487110b517f62fa27a49ba53fc641f604848be4f43069ef98a64af90c5e9c136738dec81ab84888be2d0cc45187f645a734d8adc1142c476d1a37d305d4bdbe1b89dc445c379deb9ca5feef539635777392fef822efae5bcae6bbeee1747f6613de45d07eef8015e500ddb09f566a7e612bae9b4bb29c2ebc132bda4b7b1966aef5af3f06d40fa509cdf05babe8ba37df018878aafceee0edd710c6b728aaa3142a538d5870150507714bf33bc50ecc3fc8c2b82d151bc1017ed224d57ab4b8618f652591b6bb758ff94d5b87ac70651598a965cfc33ac05e1a8145cc52d8529fc7a14400a32195bc1f5400962a1abe4b9e33e8b024c2f2ac209d85344a48328a2c2ebd09d04f0670822ef6dd5a1dd385805d6ed422db6681cd26e2d3e1c98021e604ffe324dbe9bf4c56ab5b92a0b2930220d4c0a2739e9014768e31ea85ccb9b60bd13930c438f5148d17bc99b9d2d0b878c1734f0bb3903e7a66c665e52a35701df93629ad41104f943535c8bbaee67b61849fb4a31bff0d2919c3f29a0f72b7d5a2e21a698975e4f607ec7072b3935aa1f38cdd1dfe75df754b0f754eb793715fa3a2b2c1b008c156eba233ce1b5dc33bc29560eb486b035b98feb6a52f6a10ae33261d0cf432814b78786c0fbb556530ababae7180e933c2aebc194011cf6a5ac58fe2664b9d6207d0a3145a7559e8c20579da621b9912098cba0d74ced30cd57c54c333a17a25cd71a5915df6e54a2d444d09928a6b6cbbfefd0a56a63b99548470dae60b25d0808292177166c5d79bf468193b731444f96ccbb98f8d73c44fc9891a997488d4d712611a76be3d0bac1a4da9415fadc953f1cf26b966c2a417a6cc683fd812134111cba49973e7d678412018b408b9ff8f4fd6ab1c24401795976cf89d9083870a80cb11862bd589d9770e2ebf890e9f533db8a6ca86e980020f31c90dc1a669593d8ee4c40d22c9c92f70863b5ac7a780f675f041a880536defd01b72d76da9ea986c831415f8b2170729e86de063709146bebe4b0eb7f9ddcffb98374fd48a87e6c86ae177283534860611e2ce78ae7422db41f3f76a519fd739274388c82f8ba6d9d5111622c25be259fc385fcd7d60d56ad4e089c6395dbc826bd02e9c8d62dda68926f11e249e5d9e8e64c537290cc18425f048cbc7d7243672e1ba2860d7cb5aa6171681abc5277fe933eab935b0c902c7aa3e721a1446512f64850d64eb2304107129a16790c927ae7d26a50441e273f124a89dd0cd3e66e9b750423da98af84b7892b2cecedab1965057a0240c9be0d02c55f7825b7f47d89f01a84ec21fc8aae6d4eee37a0cec517c802a0e0596a31a13cb7533b006d4379733adb0592e42a30ff6dec9cf5fdbd4c15d3ed66a1914b180292be9cb54e66d477d9cb2d61dd4cbbcc6c35e18468edc23745735b368b6c411ef7b1d1cde99b538601fcdbd26cacfd2f9a5b55e570448406ddc6c744044799118f88a8c5f9519387d21c44ee9da9076240c12b5457c404b73a4bcf3d5d669963d845083d84bb7d3cf259b02af7111d48ef234e56ce911f42eaed45ba6f94d70f837d3f10d0509c3ac76803018b4b25a8bbcbe7e58e317b61fc7df200cd0f372f5a91d405ccfb6b27d897e41264497c1188456fb4418e8d9d30a60417052e229d8fc5a1d92acec70d6987b3565981f578533507fe64143c518079b3373b6328975fee7ac92ac177faa9d245beb94ca853f5c008189865d9c9441d155a188767699555fc7ef4afa6e64f2f86163c2770b7fce06cebe3e80c5d78f9492db6efe78479cda6b3344f5cc91a6be2f856152fb6fd4b8b61c2ad98ad4149a2f68b061c89521f4bd9aaec091332e9f58979893663ac790e6fb634dfdb6131d361dd8a84cf1cc63d4d43550fa4baf2f8118f49b8019f5b1b24894956e14f34bb7118c729a9e350ba672cef323ff49cebb320c5428b1e036672d12b7ba27d45552d1aeb93324f72212c8a7618a24f3b005493557ba09ffb23716b2819dcf8177817e0449f45204047b4db030dec282d431bd3691a2477025e3f44a80a3470b254720333333333333333333393cac7b66dd8565edbec44b6acdc9d7f88a03b333333732ac9daa0d0b898d0b898d0b89810f2a60a660a980a6a10cbee1a1e7214547f1cb8c630320f521444bfea388515cd1d32146e25e9e9f6c8cddd1d242888794efa73b5d5edc7d1d389a9861b1b330e3ba42748b1d13aae8aeb07f577821ce7aabc5a36e1a556d7213961a6f471c6dbe7b5ea07b909b2f865cd8fc243a54c990ea90952cab1e5306a8e7e41739920daa79cd743a6b8cc8198206764eaf45187d95fcc25c89fea327df4de6e3559e2dc109b11af6d250897ac77ad7c337e8e5182583976ab4f399e0439c80fd4aecdabc3149504e93fee181f67e9387fb88c8d04c92bdb3cdee83cd581046936bf87bccfd4d8c94710d5a3f81c7b5cca716d479092e7c8d5ba73cc388d20dc6cb834b9fbd5d73182e8919454cc5d6376aa8c5d0429c6f41fd6a720955cb4a10842c52d9374cdb3e95622760ba9993d8e086a5733a6e6741c82d029a6d298a437443d1577e7eea35bba2804617a5b3a8ccd9b363d8420c5d137958faec33cd92048e973201595e6a2e70a428bbc0add66c1821abe85f9200341ec14cfa703bfdcdb0b10642ddbbfe8bf24eec13f103e8eeca8d9a4cabad3c26dd0e082460d0a9cc0866fc00fe4dc61847cacfc8164f65b0dd90772a0b6a5f33b96bb1a1fc81b191e87cb814793690fc5ce3739f3e9814bd7415ff34ead44e641cbcae1b2549344e2c164f17298b2aa4d1ddd83bc0369ccf36f07d27bd8e0692d8aa5be760e590792c77f5142431b2a87a403f13ee7648e1b65f4cf399c512f53fefc8b0d3990c39dff4f3164e84c6d1c88a5fad171d6bd8d41870349d26e53928c30cf59195b6f20b7448d550c9abf2d2963cb0d04b98e1e25633ae3c7c938641b086b61e5df1b7256773610d4e2fa657364ec1a481fb6a398eab8ac86e4b2858f52e4a7bd50c616096af809fe046920c5fdafe8ad391a48f12d84a9e79462cc51672056e648af7934c221cd400e193ece0e6cc2a3accb40d8d4494ef3673c6673f8862403312d6f468ff372d00a9a1b720c47d13dc6d4618eefc440b4cca795dcd434a75a7c712daa041906df43ffe9e9976020698a6bd4755cd1de2abf40a8faedb8f8ae1b4f93b14523bd40ce4136e5420771291f61e0c58b172f900dd985a2e64b5d2bbde8182383e442dfb5a163f0d0a2c60d93051734b8e018e416f248c4cf4a2ed69f051734b8c8c26c905ab0b4a6532d23ea46addae396a50caea1e2e2048f010dd0750d1a37bc9506990542c7296fbca62b1d89b140342d8dbd493fc1b902d16e65ea644c195b36dc4616668b2e6adcb834a415c8a3ead178689aee365763ed0b590592697cbb7cbe920a848f8ff0601edb4c5b390552ca95a325f940fc2b2463cb0436fc043766142994318a4d9b5cb090512049850722213a96d48b4242811cee827a76b47e2bd1d8e209047bd18ecfcde242c5510ae904620aa11da3c7b0b08d394d209ac97e3c8b1e64eccb6102d1d5a206ddb270efde12482193a9f975e867c14309e4e83af78fa2492045e998a7b5a70a890492fceabf9f464bb6a5052d98a18223905d2d6d5eb94c453b8d40eef2388a1a9f9e2210e53cbad00ff52102693b7b44987b4a7fed1902e9526ae7c8bdf2a39285401eaf0a99ee3dfda6d80a508340b2cb3eab35ed78731e08e430f5071f64a30577cf0de3355660f703721c3d6fff2b5545351f90a2e71c9a93f95f73e61568f58098e3ee8aa7e3e3ea398c0bc903520a2bf1f639ac953ab7702d7207a4928fc5d5b49185d60a78465f21754070fbce18463ed88b8a0a990372efcb79871eea31bf382075bb4ef7c774b20a6f400e7c5fcff736e51cb4b401c1d356761ab96b40d8a41f8b97d557fea834207dca5d9b342bb34ad9cd80b81f7ecdf66abac5b49669216540ce36ede07bf5cdb4742db2e0589043b9c4b020468b2c5dcdcd39fa90dd2b08276fd2d7e2693f5ab45c41ea8f634bbf14d7820b1b59b482d051dab09cefb473985d01b382b829c729fbe838dc10b2550a5641ee7f4a570ec3aa20abb4ca4793408659011727300c064c05b9a25dba7cdce56934a82057c75ccc522943d5470527a8710a42dbbb576c6bcf109b822cf7167e76c75290ffe3f1d89739e48e854a0a62674f592f6c7cefc276334641a864eb1e6e3e7eaccd167f4441b2546a13e55523fa0905f13db0f429da473d19bd31c35590859971021a37dc0b080a7258cd95cc834b12deb1f10952ce69a6b25f3c41cea1742e25abfeb57c27881a67edf1a79f13240de571966d138f716d82dc29de33bff4bdc5022e68184d903cbf62e88ed19a83676c312313c4fc6dbaf5c1afedec982099885f6f568b99d15e82901746327cccf1e3eeb004f1eac3cf712ce530915782ec71faf02dfec60aae8094205c6ed1d43148af577ec699047156834475a874f731338e24485926a146821c74b01a69399ec8ecd7c8c26e4676012141d4743c3317a451838b2c50cf23c8694a3a4f93c7ae98750439698a5629979c5fb61b41ace01a2dc64a69db3d18418e267bdda1bf65c78f459034c7cca1f3c5947f3d278bbf41e3047f10165011840e4daaa1769108722eff78d699d3ea57882064a58770b99465f321c8c13a56a598e6eda3775b404350291f7ad1bb4210b52cc77dc766f8fa2004f19357ecd5aabbe40f82741dc7fe38d3842a08f2a57bdec82e10440b67a1a2e4a8a6050404b1e53c83aeeec5e934ea1f8829a66439ac1c7c943da2fa811cdead5ff172c7cdfa40b0adcb6e5a165fdb28cb02f281d8d5c1762df2195970e135549085dd8c3d90443e6cc8d8941e88bee263adbe1fafae7920eade871b365aa8782049a868aef18a3d2fef400ebf10651ff9c70e640fa19b9fafff21511dc8b1bfddd278649b57543a90b52c4e63796861e1823a07a2c907f51f6bc771c7ba1c88319f5a8818fbe0a3230e840fff53ce957a54381036e874fc871aea1b48f9ff03d968fdb4f951dd40f69c4d5bb23d58ce076a1b485bb1435ac750ff201bc8ded1c6f8c815f81a88efe7d3e9b2633bed6a20d5c7e29a336d35754f03e1e5baf43ad0a081f8f61fa874d2ce408e3d9adbf9767039facc40bccb8ec3e5e47eb36f19486e757571a6d6702403f12dc68ec4bcab71630cc4168f91559b42438b9385dd1103513da7b89cde2fbd3ae3c3408e5a3dac6091e0b70003a903cd121e9797b165a3781676e70bc48eb36af4b8e3c8d8aae1056246473947a2c9f24ed42e10e37857e866890ba468572efe5329d8455b207a4f5fca9147919543d502e172c3bc74b49c921b350ba41c5671554357f2b451b1400e11579ba3f7fcdbbe02e1238d8cefe17daab732b6bab0425a1d55dcb8efaa40b0cd51fb6df8c8d8ea820ae4ef387c30d335ea140853fa9d6b969402397455c9aa6e50a34092d3cbc17b5c9fdf0c14eaecc0bc731037ea1348d51e69b6be1b2937519d40f0d52c9bceffe7e781da0472b09c2fb352508ff790b15583092475dbddbcb5b841a3064a0197408e2e6a47fdf6b3a15502c166bdc623d96bc8b091047287ab931dab850c1b4820e45d5e0ffbc3b4caeb0ad6b1eec8730e4d1a59d8cd3042a621d4f52290c4b2d8e5a8520ea2151148164c323d3ecfb1c94ef03586400ed691a39d1d85d38b8cad2e8440ce91a1345c90b0ed3405338e2cec666010c8935261ad5a2e85ca03813ce539a436c21f90ec4fd4c354f71e7e2f63eb38dc07c4b6ebd461f6b2d8ddd8c27041830ba502f680b49792792a723fca7e8307c44e158d17de3f8a5ba085c9c2eea2803b50c3c7975d1ad40161adfbff630ecde3ff73403acf617820e280d81b355eeedef417cd0dc8a17e70af593b6803e25695ceb4c7488e5c03627d86ad142b2381094dd6a6dc13c428de1d5c9d56d2bd3b41f230fce730f8476763738218ce46af36e44d90da24c332957614cad504b1663ac6670bbe319d0972b410b74ad5f2b8252648953afe234f9ed2ccbb043178dfc805fbb79c324b90d4d677cce42aa647558238ee1bd762d2a451234a90f53a5aeb8db4a8cd7712c499680b2f1fa6ccc11358493cf6f1ace8fcb69128d37810f941b4c761c1428298ed99ad3737de46ef23c895f2fdb337c711648dcc98324d06efc04690a310e6155d12df7399710e58469043735f7c57b58b2087996b74f49cc1a255047935c7f1bf69b293326d1341d66c6ba639a5a5e6326c74c145d6d542601141ccee1c73c8241b522d872075ca5461c34543105ba3741cc7515608b24a878420cbcbaf7564a67b7307416855cbb8f519fd42b5822059079e63b56a24e272c1068254b146a7d74c2f531610c48eafbac2675ed887fe816c31c71c3a4cdb72b7f503d9c2c5e0f1d1c70a99ecb2b07d2006cdce2197a18cad172ffc861f2f5e5415960f6bc74576a48bd7646aec6f8c7943a9a68f3d23d83d90a3dfc698aeb4b117d5033926cba9ded86d1e88e1272e47c69cda7c593c90525feab417d3eb9deabd431f7c584ab3db815c294553328fd781f429c85ef4b02a6bd381a097f3b4fb660ec48fb23c0efd9603d13cba0b375f7139e738609ebf2adeb17020c7c78679a49f6cd83790f5431dbdaa9fd2901b88695a32cfbb7aac581b4849dbfac323b54cdab38168ba7fb959b3d7ab6b206b250ba99570d5408e959a8328dbd2408e92d1fbe16820b5ccd854647b06f2bb878eba39e888690682cb78183375cce741a70ca48e6262b9ea93e95674862503c177e6dc2d3d0642658bafd4ce393aeeb662ee8481d81f2b3a5356df48cba961c1400c1e537515743c0efb02d1a3ecd8a8d351c6a85e20aaf905dbeaba400ee5e7738e7f2afe935c2047fb7178fcd0ac56ee620b64978f3d6b6669582d9052de258ff3428df959207b3e910ab51e2c902a765e87b6b699ca2b90325488f138eda6ce301ad60a84fe4ee1cdd3e4326c1588a6d17d7398ad23315181a83963777ef7a8cdd62910a62afda79c7330224b81202d9943ed6414086a53293c8e0f0ff60205523a8f6231a27902c1b36c0e43e7a81348f17ec7b3686bb0bf09e4503afc8ecd9e43eb1c13c8d17818ae3d8c0d9ec7259092644a45bb5c5ef094405c7f0fef827b360984e8d48ecdfd4602215f3387954ffaf4c711c829967e99db079d5a3102b1a2a6f08d2290aba39029a48c77d49208e450e53d081d9fd08e320482ccaa66c8d4131df30d211054dd3ebbc30481186c63ecca9b8140588f2db4e6eb3830ec0fc899d2f12b79d2ff28777c40544bf7bbfb3f9f47d303d2ee745b8d878d1c0d0f48d539e7a59753f96e07046bcb79b53d47f1f2c6860e48eeb21f99268f1c90c26cd97e79200e0832e5a1bab21b1053bf5fcebd900d08617d39b0df94caaca363d81a90f35ccd96556c8ae5530c4b03f2e58c4ea6fab7c19e0141c7329e749d7caec9b032207ad861cad79d33764cb12036caa9ea6d101644cd8c29bd89e54a33bf829cac3bcdc79be27d6a5c41fca0c3d537a65b414c9f1d1f7375baa766057963d61c4a85eda042b90a3abefd656cb12a48753662529ba582f051b87d25b751410eeefeb5229e830ec3539034d6e64c41ce4f7bc9ccdecb4c29883fd51e0609cb8aa39282b89ae7bed75f33a68b519043830799361776ac431484f33895bc6c31c79b509023e9f43876d7becb61a020eec76dde9efa045927763b775a7a34c665504f905a4c7e2b07baa26527483bfea29bd9ba526438418ed1ed9e433bfb58ca2608776af1cccb9246553541fe7c751a64b24c1cf2753c4c90aef7b33e5766f6636c5c82b41d641c4da69da4651d835a82945e3b6b85d4de572b41c8d496e43e73d3a7b80d4a10be4c3dbabb0fe17b4f825099628ae727915dbb2488d2213cbcfa1c5ef43112a4a9ac95b93f5dd5d21483428290a761ac53f58f205a4a762f95e3cd72a123c8efa973e74eaf176a6b336823c83954bcb98aadc7619a11e414addc1c2fd3cc83dba08b20e5a7ccc1eac8eb96471174e878731cde7c98e12534116435db585e1e6fc252300c8a08b2c7727efa39b4e6830e4158cd515be4fbe3407b4390cb537f86ccc6bea0852054e986ba877c1cfdbd052504e1f2cbc68f2d4f8867b5a0514307418eb3777cdc79f738b9822087cabde8add18206826c271d6d8a0716ee51171410e450dd94e1fd2c2fe81f8e3ce50d69dc01800cea07522cc9fc3087c1d73e90c576d386f91c193cfc1a33ba4081712c11281f78552d79f9cf101f453d9d0a97b717e81e08e1357da1bfbfd772646cadab1ec81673bdd53f67c691858caacc0331e65ea7cdb8dea92333a0782025ebcfe98dcc2652cbd8b2a1859fdd8158b6317c901d87399c6bd0305b74a100ac1a346eb81616503b10f7536bde68715b07628e7f5c51c3a474206f9cc86ef84a92e5eb1cc8399fd6c77e553b9e52391037869ac8f464a97b1307a2e8a6f4683fada8713d0a07a2c71ee61c9c7dccd86206eb1bc8a3f193d3415d064f60c355c031d40d044d6b166db5b68114f9329bd65378d0111ba06c20474f930f33b6e37b55750de4d8bb3916a11ea64cb6005503d103d5cbb122c3c3e4dad062c68d2e5ebcd03410cae3c6ac8db5a281bc295ed95ece2762ffe919c8d1563df07835ea852c0d036a06e2af4d7acd5ccae1690ea7a14523e02a25a0652094e5788d7b94272a2b1948f61d5e22e5c26b60e0c50b2ebcc60d1d03e92d5cdbc5d679bab88c3733ac6adce0c2092a06d43090538e1e54e6727bbc1c30908391cf31dba63ca6f90ba439ad9afde0e2b8cd5e20def46de8e8748110df9b2abd31b64ae50239fc6bd76a48b56ab70562f273574951dbac4c0ba42095e26bfa48b340f2287524abd5b3a239b040f2ac1d57206a87ad0b9663eb6763056264654d31e1ed1753aa408c4c3925a9f7f072bea9408a9561316b7cecf8780aa498538e3388b852205e6a94e938755b3fa2408ea2ea4ac5d8ef671b1448c9c3cd13ab7902f972d28f2eb6331f2e7502397754d84fdd9aae276dc2a52a6d315a65229aa1d262f428e6ff01ca04723c1ef76848af7624eb12c8f19e5fa514522590d26cb4e987f1f2554f429e9ad2c7aff423811c599ef43ee7ebe9cb11881d5dcafd5fb6898d1188992ecba305df0e3c5e04c2894669a5ca9f1e2c4420f5c7f26174cefecf4a8740ce67fb9e3c692a04726c5975db6ae7161a0472fa0ff62fee354ef95c9cc04ca0402087be3c5bee5ff97615fc16bcd501fd01d172ce479fa3cc6dfdab417d70884db93aeeff6a5b04ed012957cd5f471de2bc736c1f9407a4ed181ee5e071c80fd60e88b7fa915e1f6d34b6ca07d501f1b53ad050e7d257530e0863bdb9c96270404a5ee132a59f3720af47163bbeac7b0e6eee416d408a5f1a4b2a63ad01b1e368b1e2a7bea899a60149467c534a32cd80fc417b6e8f83f538968b1e5406c4be9ce1673a0a1da68e19b1206ad67cfe0b17e332040b42678f3dcd3b74f60e7f05d9830be397bfc31524990fdda2e6b415a49c962b77ae2cea21594114ffa8be35a69c386b1584f6ee284c558efa2e5541584f2ff99efe52ca983c642aca63398c397fa3171012155d877e73d6f81b6d47c85310d47527bbb2660a72145af1d5e133e887a520bca739e93056aeda95148ca401840e3fa59d96ae9ceac209c2fe74ce51c2abe33733b4b09185a9e159d0b8616a1c8006061ad09b684d506ede769f2daad2e17272d19920ae65bad43176a7d07181c604c9b2650ce998dfbc9fbe04292b46a4e3fce6b9c312a4a0f9c31c2271275a578254f79da7337cf4dd8912a48f5366bcd64d7958695c7471fc91f5809e045142ba4bf7332eca432541ea8f4c3e756079e6fb489082e5cc1f666acdf74382e8e9c153e5be7e04492bdb6feb8e20defd57eedda9c7906904a12fefaaa3fa8ad23423c81a3e2a65db1cdac2b608c29679be554a8a2084e7cb4bd639655d4a0431c2a35c31d8bea78a1041ecf86d1b959e4390e2ff43cbb6f6c96e6308a278cce7de2ff79ef64290e7a42de3e6ddc79608410e5919fe29ac67f6d04190828ce5b87fd42a4c87200899fcede3a043e9572a1004df8cdd5c4fdd59394090a3decd56bd7aa0157ff1e2c58b3f905aa1e6038fe234da0fe494d5725a84872fbb0fc4dd3dd192e9536bcd049a0fe7f1403ddb56fb2e85de83d779155a0fc4c9d43977a862fb11dbe83c103b9c0f1b7f6becf26e3c10ba4c63cf7c3cdba9d738c0093e027720a474ea871ab337da0ee4c8b5634a29a4856ba0eb408ec3b8d47420f5c7de74719fc352295c25ed2ae5409c68cd698b35953f7af14205bfc58b17dd1d07d244db678a9b86836dee5ed36aa3f1256be5ebd7bf1d05713b5970838b1390172fb405fd06e29977c85d05fb987603398e553ac7715325198fee3610ade3dcbcbd0e1d3b2cd241b381ec29b5e7305866a8cab10692454da7e51c531acda881e859fe639ab4d2b04b1ac83956b6dc4c391a889b2d560c5b2935b37b06726c5fed5966a39aba6620c5c7b81c9e85eb9cc6058d2c6a70b182dfd26520a7570eb2c47cd3694a06425fb8f4d92b73f0283906528af697639952d47762207a7a876a6a4e1848a9975fb7763090e3a7c6bcde77defd023106dd783363b5170877b14f4fb6a63cacba0be4f8baa3346ea3b1746a2e90e4a34739c5c2a6d5a8b740d4d871570e5e3de818ed1a5cace05b0b95856c2c685f819cff726d0cf7d83b25b1016d05f2c67115cf8ae94377aa400e3bb68c4f652d2f1d2a10cd72c6c70c57cfca14c81adec1643a8b2e959702b1c2d5767c54792bf951207fc77154a5ebd8f3182890e3cdb1b472605a299b2790425a4e19c32d64c88b13c852e2bf96fd62e3ef4d20649faa273bf78ec39c0944b7fe28a64af161f42c81e45a77bb321d25905a63acd08eef1c8f9d0462071edcd9859140bc0e3a7598ef5143c9472056a8741ec791654b313502d9335a18cd8b40ead03f4779972e878508a40e1da8af47e21088393e86f9f83d21103dcacfd6bebc121a0b0239a88cb118d742ffaf060261727e2d7fa49f91a1fe411efaf333bb43e3e3b598010019b40fc86fbd712e3c027fd040c072e127e002740f6aafb5bdc89b07c41ce69862886ad88ff33b20edc54e51a276b2c94307a4ac96d13db16ef3941c906d663664e5c0e34e611c903cfa582d561a6f4098d59c4e33696d83ae81bd681a903f2a13f90d6ecf8074a92532aaa765607dc8c6bd7c8848b469e458676725552f8f63414a0fb43e4edbd0f63808018645f12bc8eae51f5790ae3e9e39f3b915e45461a373d4c152ab8315c40a7b721b1ec53e5e56410c93e55179bc187daf2a0876d57ae1db3399ada920079e74d3be8e64ca1fa8206894d28d211fa7207e689bd1f7837eef1453908245cc6846e7929b4b41b4f01dfaf8a58f84470ab2e5ec1f788daea794f128c879eed2a71b230a8207999bb93b0e878268df2252eff595161814e4e8bb5af9e65186ad7c821ca349a85a0e55bd4b4f103d3a8e8d8df9fe910c04ee84bde0c426dedf8d414d104adc72dccabf506dd145162aa051830456992047d173e46933c6741d9820871fca6b4e6e16736ad4f82c6ad0c8e2b960818d195b7d09a2f77c7ee6994b97ac006060019832d812247febb83ca4c3f0192e578258213fee8b39bbe7d44a9912e4d833c5e0917a1e6b87009e0441834cb9a6b6b11493c8922075b0923f2bee096cb80ab64c60fcc605be0b2d5c035436d404c66fd8480a70244e21663fc767a42563abc6dbc8c061013c302448e1bbe761dc6df559b0a0c68d2bfd003fc20f76432d83f5c521f0e2858d172fd811e4983f3ebaa8aafd31985ad0a04181d682060d2eb2200370230ef3a76cd630c240c08b205f7b1c19d6415f8739ac0862ff6dcad251ae51a99213d17bcf6f9c919210819bcdd74cc8d46a5ab4cd45050ff22b3b4565ec09bad8020f41d80e0feb446e43103c5bee8f58e6b87c0b418eeba7faca937fe59610c41c9395abd49257520741fadbf0b8ad0abf7e0a8290f1a7db167926590682582315b42c7eacfb202048ad29b52aa34affc53f903fe57ac32c7e207a06cf54e9a247515e1fb4915213bdd4f181d831eb87fff128a51cdb0361f3a3073555f791647a20fc7efe4ede9ab71be5814be9be633c28d353f6a1c3869a0bbe03399987e539a7479ecc546c07bc357fad18701d48298588f7fafee4dfe8e2045924d381d4b0a1add69903adf99773f618cf643990a4c38ff6cd619ec2a38b833958cf9a62180ee46c16562c7c2fd577195bf506f2c71e94486629d76c316337f0e1c54729bbac361cc7b96d3ba4e5d0bbc16ca817bc065603316b480b1a19be3ccaded882701a081af735849f874c7503080d58b0a85f39e580cf40a81c5692e968d73be5d0223643bda80197a15e3019ea45f218ea85b118c851f4cf562959b0f4c96cd1c50903c1e29a6a9cecc140ce16bc3d7f98831febf802b982472df5f77b816416ae3a67eb02f13387d1e2595f6b31178857f1b375183f98efec16c839d0f03985db4f2daa16c835b3c92c871d37cfcc02395d85cf4d398805be44e65d346cdbeac36f4b8c5720b5f9564cd99b3a6dac40ee4c625d1ab7430d5615ea051548213774edf64bcf483566b8d50a8e066cf1350e40c653208fc729a615ed94259d1b0db0c1522047efce70140876e6559e27d61a004381a89a3c46e5ca2012f21e3f81b833d3713fa6bcb971196bc54e20d47ea7aef70c3781d0710af9a07f31645b9c2c540b66c291cd6fca1f577f26e0259043a99dd1f59abcd876c1c58d2e6864b1124edb5cab5aeed18593c048d86b336f4ace74c6e8948f80023602c1e3e891c8cec71eab878b404c61f139eabd3011f01873937babac2d8f91b70f7347aa93a259f1107aed186b44e3422047699df2a6b8bf7a1e412068ae0c082499eb8c96bf6634abe3ff0246e01f90af92c6e01d3e907d400a9f838c1e6d3be4e6646cd138d703427578f7dac761958d621e90bd6cd378fc25e95335d56b31838b13d03012e01d90b673a50f2569b9634d00eb80b8669a72c37c53262a00ce0139e3fdaab21374c1c509ba2865555c01c641bb806f40cad781996a558e29d66c03c2ac94c7b1c27753766a40aaddf18b97a501e962f2d60f96b7a5d419103fd8cab29b57f4d32400cb80f0aef9e3cbd93b11c58254f6b7ebefa12132b3b028cb3e79d81de5aa1890b1af20f6db27cda14786116f5d41ca77a17723c3d658eac58bec6d05293af6adcf0aa16feb9a6059b157fe4cd9deac82b7ab3865c63bda6e2cc25d2ae6cdc5f15715e4283654fe4f6e2a30f158c3ceeaa820b4794e9634c74f41ea34cb98bda3f6ccf1c616bf6b8a7a21822d05a1ed93fa867b9b1b9f14840da3399f293ef21fa32065e6e8b2cdfbf79b431404eb60536ca31c0ab22689ca9bbd79950b28c81f9707e9c044cd37ff046132cf377e01bbc574be96dfe126062448d96227b1d09bd951ec1184cfe71b1fae43311c418e2ce6eb30bc07096c90c06f201c623482943c797a886d8a6631df210623c8f9c13f8a593c940f4d1b4a87188b206ea5ca39aacb3a8fefe7820535687c0d8aa10842e4ee57bb7688910862c76c7137c7051144dbf025111f8ee72729c621c861708bd9c62d68ccb8e1336e18156218821cee85bcad581934c7dbc818852025739390bd4c59e004346a286008310841cc30cb6ce66695ec1f04d92e4b5c98ea3c9e4341902d53ade44daea794812068e60767b1a37beb0910c48898d7f030050d9dff0339b8568e61333cecc8fd40b2b0aaebed60a376da07d2467598348721bbdde303b92b7c3eb5fd10177f0fc4dbcad3bf3a6ea1d503d1337398824b47712e28634b8b3f1a468c3c1066d3e37eb58ecb31c203512d8fcb7eb8ef40ee8ec8130b591f5aecb520c116336c54d981587397b3a85bea40f469ddc8f8d15d1e0d1dc831a6f077aa51df31390762d6e071c50e53a9e78a1c4821359e5bd5e6e5ea880331cd76c6fc3faaff351c48df15d7c32cf306a287ed6663695a8ee1064e2a3554d2cdd5a33b7bf4e0518a558c369072d039ceb30fd701c4600361ab3285051e812e53c32fc61ac8d51ebad745877f450da434d9f1d11e7bf4f5a481a89b5de61f8721400c34103a356cec98e3b51629639c813499a5723ab328b6b6022c608018662047961edae3b756862c7e86feb65d2a061948e31dfeba3466fac06d29c4180339fd55f3e3f0fbd63f62205cf4c6d544ba79f4c3409616aff45a713090cd2bec9cb85f207d58de61be9631bc40be98cb618eeec54f8ed185e3c6ec15527a3a768a760c2e90528ebe474f531ef1f816889bcbd2886ba6cb5d6ac1fef8a9dc5ecd8891052772835565811858b01857e8decd5d223bd653a4a6185620d77ceca86643d880185520a4ba6d07177aabc34f0562c761dcfb5aed85cca7404cbb56cbbd9102e163a54d9f739843a5390a844d8bfd387e7cb93a3206148861ef572d7b75fad7184f2059da658b8bfe0e623881781b3aba3c1dd8a67e34811ccef9cd877d22db172690c7bff572e8d8cce39740f2cfc9e3ec8f29aa9e4a20656fcf622481541f272b9dd96220811c798caa1295ebcd23631c8118ef5122d56b23906f2b680e12f2d9c394221036e6e9a83dca41c87e7d884104e2450799c1e3a02f5405fd106308c947e5f06b750a8134136b1fdda7f4bb1704726769ac983cf9eba781409ef4f9f1fa78359b9fa67f88f10352c4b966d4bce51d3e8de103f2a8576af3f0a1a115000c2c8062f480f8f187c64ffdd171aa9f058d1b5994c5e001d92ee5caf2514ec824f005c4d801ba3e9e925ac4d001f1fbffc1fc5a148f9103f29a86cbeefa3820ce680ce39a37e738e8c8d83a5f0363dc809cb9c34faa57be633a860dc89b03ed20c36eb6a8dee1cc801835e857d67fada75c3212c4a0013958ce95ce0e9bc98b8cad2c8ec3db033166408da7b74dc7cb4bba8755f749c58fe3da968b15bca220860c48713e5c637c3855552c88ea1d46bb1c59b49cd9c1a28e7270c1579062b23f1fcd9bead2c615c48f7ff9f34dcae2d80a62ca177a6e938c06b55841f6bc7b9dd577225fae008c55105ebf347d3cf519c75405b9ef577bc3b292e63515c4f359dd1c5bd09845460521c3dd4bc5473793f214c4686ee94f93c59292047ea31c00c31404a92c4f8d390e63aca5205ab74edf9d9d64ca5e9182b4dd9ed4519052e7ceb4c85cb85a5114e4a04a6399b5770efe96b165c32a14c4a41f5b7cb70a2fb56c1318a020a6dce431074da5e58bfc0439547ea5f658189e20c67ba6c5d85178d6e416fe5cb000031d01189d20a51c86cacf617fb28f728278bf49fb3e65630604ca36410ca6ffd5a7317b2e588001aa0c010c4d9083777a4a1b3b88e97d6899207bf4212f7e5af77747000313c4cc71741ffba6f4982c8ec3b3b04400e312c4d9d454a35a8294d5752f21568278393ce898b1a744d6f9719ceb3e7812e4f09af460b3e3c7d64a8214bdef3df49863eab08c04c1537c66f7b2f6fe0809c2e887621927eb008c471043b4af7f86d4ba4b7104312613bdcf303d736523881d3be273136c31a3860c1bca08c26a548a1db3585ce62c82944b2ac644541441308f9e3eda75ff489d0852e8a869b3c4450459ff92c59ce389de500f41cef9398c17271a82f439b2b49ba3b61064db545b1b422b78d811825851ad1eab668320d8ed5798b9e8db298220cd5f680cd79d5a59058214a3e1a3b64a1f2426406c711f5d3557b1926a59b11d58ee0e2f8773c3f803b9627ef378cb61d9666b00c30fa4ac398854f298f71982d107926df8fdc66a305003061fc82ffff9dbe3d49eee90b135fef097b1077207a959164ae3b3f7d703f9838ee3ea36a7340fa418311ea3e34f011e48493258d4acd51d88ff266eae1f565d643b10fc6f8347d1b4cf75ac037977cdbeb33da654493a10fdb6c3ea6ace599a9c0329f572ce698379a0d1cb811c6c4a6a0e7f27ed45195b591b80110742f96be7bf0dc3812c1e777698767b03d9c783917249b0c58cc3c94000c30d24afd49e364fdd0652ed54ced11f2e630b950da48bfdb19a8796d30eb335903d596ef7d02fc7ca1835e4714e677c0fb18cad3b1b30d240b808bbccf13b66a0a15ecc380331e520ed7294e3d0bf9b61021bf800186620a60f9fc3938eca408af1ec6359c867a867942cecbad0e2000c32d48b2e608c81d071a07bf12a7e6871171280210672b8e13010fe638f3eb85e5ab7310330c040f0d8a1741cbcc705607c81d4f7b3a359cc2d7f8e1b366acc386b66607881e4f7b7ef1b2c243cdf4601185d38f6fdd9e879f343e3b9406ed1f491c44f7d752563ebc609ce16b0aa9348bb49f5ca31b6079b0e33ba0c185a20e794c36fc5ac0d536d16089ab577f66329e9a88781857a01e30a04cdea9fca37598178e1791dcf63185520de87648ebca01c605081f0174d8384c650952930a640d254e5d3a7330c29905656fba6cc736044811436062dd768db9721185020472fdf71d2cf5f6501e30984b0ebf87d939606e9388114a7e73c76e3a42a04a309a435f1f8d1c3301348abfff16cc88e2f986509a4fa2c718f52b8cde8510239739c3f8739eacc95e324104434ea068d7775292381dc51ca917c4a5a9dc33c0239fe1473e712d3085dd89a8a40acaa18a7fe9599210c2210cbae3be45e4a0bfd600c8114ccc235c4e3c58b172f60088114c3c5982775cb350f02b9a6bd2acdc7a952000c20104d2a76a8d7711cbe34d41f5c99275e1f90373fdce5e6981e10362763d9f8875acd7840b80c9e2334ab640edf013945bcd27ed861b0246e066c09860ec85fead1b1cd0c03183920471e79b5c767ed1d963070502f8000e306e4eef0cf6bd6f1dd251836205bfae81467e37187cf4e00460dc8abb91d21a571e53d4f03520e1dc8b57b7b68ef8f1990b2aa3eeb35aa357d98b302fa000c1990d36c0eb3d1fb56470d742cc897363cc6d097ecc0d3052c88715dbac3fb6adbc66a780aacacae30d0af3068caff9f39476db42bc81f3f5f250f3fd9890755b782183d104dd5cdb024928cbdc2660549f7d23ebd3a0e76938c2d2ed2ab209bc57255bbdbce9e1a04aa6abc09b698a145ab829c739ca33506370b8f03029d8afe739ed74bf71815e464da9f6bea5aa04f41b8ea385969be779895b52948f5213b9bba7a2acd68d1a520fb07d97196d77caa03419382b4d3618efbfab4e3de2df82dd04641ce52497c2d95578efb1625383c8b1a85ac4541ec785fd4cb3b460fce1936bae8b250fca04141be1cf7d47ac5ac72db2708e3719ea5cecf2a4624700c78a23b118c69a8244ea6830261281288040281288aa141ef018313081040b0c834168b456391a688a20e1400037b4632423630221c8983c28038280a85014130100c060282603010080c8343a1a8208db1f007f6db22e916faa7ee6333b2cdeefb2a8a8bbd14b699718e77eb3f74429e12ed05a71ca81aae44348ccf02ea1ab3535cac6ecb26e4e1a142663261a58e39c031734332f6fea010403a32269356809a4b6499c0c018303b5de06d0a4be8238cf9091b01eb261eae467f6e2cba9918162c794db03f0c0c7f9d84df470a2485b3fefe6e1a3be2ce77b2b3793abf6522bc0b240d90c31e82ea21b99913282d6f5e85260920ca8cf84bab199bfea30e99737b8be5819b7b5231c7a7355068abc9a34b3ccca35435b4451113892831dd376845aae4533ac6839b4348b2abef50cdf7184b18aea208d8f31aa68ac90d0bf970d202714f1065e4dc1ef12488a82fb0b79c26bf3ea8d9991a37c05be3dee721bc911541360ec900914102400c236064185320ca1743df1150771855af1f42395889d134bb7a88854aa0d9d2738f187097341e1a0c49d8004c84a901e79bfb11efcf99afd36cb5ebfcd21db21ad1ce37467115e7dfe9e36ed6978fe503cae2f7c6ae5b725ce7d13890d8e6448e0eb914d06b0e7253bf772fdf7061cf32565eb4aec4f35717c44cc4c312c4e4187eeb9f77b97514b6fc83ee10a9e382135d247ec045bc54a63f526ccca9597d801a22ef7f4ba27f738c0b0a54d23326abdb57b0555d3e38f5f89d95156aa0b644a627402ff74856f0789af20942b8f209130e86ca95479788e366c4bb1f5fa3a2a127e6e0e9044420106225178808db4d174701445cc72489f13dd1175eeb82f6656fa0a0c8a1280a4b0851b884102c445cef34a96ae93a149285fe27df7bee259ba403939cfc604e449c6171fe2d266dd856787e3412111062f01d92e2c62a4b8c54b3c71ff66c2b653450f2416b12ba38714ff0f211264fa7d2aac41eb452b599da0abdc049888b0763b436b0ceca226ca25c0a4531a3e0517248120cb912281c4b4e0219a0eb7f0a957a77a20c0d71446118f2bcd9260dee32fc8b96d1f8d553c0fbe0ee38355ee82a984570013b74bf8c07fc31a9d34e3b4262d1b415c4d3ab84748808d817125b114a6d17a36e1dc8a7058c6a9a7bbb8118f5b30ff92c056bd595c05e89e3320b6134e23819d984e81c580d363d1530cfbd0d88abed1a13e6ca527f79bb541b945c2d4963e7a44a48ec020d03c8d50ce7f31d667b88bd5fb489058dca1454a514abb83592699819ec26efb68e1c97c5a0924aed14560216c04ef505109ef62bd17d1e65361667f63e7344c51968993a983d573470de557c0f5eee3ded68da33fc9dc9a3b3d6632baac6f7029d8b49a5a7ddfadf824b93301c1735099491bc12a00d2409de03a3e42f03327a78449a05072f0f4383d27e8d81e374c714a2defcea72a819f94db736a30fad44b439498db29d601a36f470f8050ae81e3c8c1b9094115643f1ef253d5036e407937d796b6ceec6ec8bfd15db2d34e1675ede452f82dc80f5e2b3e0be161cb576f493308836f81c40848f96266a2df353254f6f7daac7e5ed93ffcaed6e300887a4e0ebd724f6cfddf6c45fa859a7d7e4fb8e43547203f7d2ccc3dc513acf6e4997fad1340350c218e6e3b05808d9aa392d2e2fa4b20028c83080486da529e0720f453ac1257ae71a0ab4c34c6a7f0cacd04861a4a06f326c548090b7a665af7971d3cf846658e67223e23983e9cdd170610f65b0b852b34baa9a5e32473380aff45d6d450dd1463654f234d6f91e102b2c89b6fcdb759ecbe6f20ff05935e097b3f3bc6212b0d92086db1eb85724e30e04d51eeab1e20753abb103707f2e5444ba7052bbde0cd1bae745a31d481e4b20cf3a9f8c35475bf7280f1f631a34b7d85608206219af800f442bd504530dc273ca4c1e0f19e214bf8c4259942510701641f4d3c0c520e4efb1eaf9c7783374f354994f88ce4e4e829dc467592e157f4239285bf78c3a0daf56eef3ede601dfc0ecfe730dd1361e3d130ebff538f628aa397eba633141726f8edbf338c4cbd5e432eb3237ef03b3bce2104e85b89588dee87fd61f33f96b4cf10d83fbd4404cb0604214fad685c15e20b089425b2bfc694fa0798924cff22803c80085e0f11b9d4a7a73c1bbda2f1cc9af966d1f0f4935138000baca4c54945a7a296fa21ab04fe1ff2dc8d1d9fc6fe4186c9f9c31be6b42e5844d06ea85206044fefa20699f1ce817da1eb05408c8773b1fc0fb7e77990ef8b82c4fb64326d44fe3f83261ace89ca691cdd4c4c2ec3d3d9555cb6ec0b755777f41673252e7d6df9621f2bc67545625b9233826e5942bca7f1412d699b21eed5cff7a1ff6bf2c6e873202f17715350224bc1c9e2a0294ee9c2b8d8ce73510ebb00bcffa6c0c9067ac71f3de994028f09d4bfb8473a8dac009463e2c747974268a951a013890a716c2b8939fb6c13a37c9b57b452661d7a7f0f767fd30bb3cca277de4f776d1d437c8f6c63d361ab62768f819f3fbfcbe7d0bbd96d892b72857590cfdeeaaa91e958d19fcb34966dbdd81475a1fd00660c7ed02317a35bd3f622c2990ff5731fde37ff087dee71914dde0fa530fe960ec89dc857cddf7bac44450f125fb4feaa38aa8bf07fa61c0a030c1f1b55d0bdcf20ffc32e42bcfe6b5187554ac6a9c9a6fca4c82ceeeed4f8a1c691067334545080f3f56267ea49ea71c5572cd0a0f484073b9a88513d98ed4049a0504a6a288d1e3994e7ae4fe3a4b4108994a74417a75d15cf2d253e388d714939f1104e4b6cb5e425fcda88f44fce1759cff416b57f8dea6da7eb3c02846c1f09f51a6fcf43032ea5278df2e3fc7579902830bac94c1bb7f4121a3887e8ef26a442ebe87fdee90279b1b5f007bb4b05e05709b857b1360f56c21478c221900d204e4d08e9460905cef8a0222430e6f1b003d47e1e31c1a0daab249870fd4279f334e21236c8e8e7031fe4471434689dc37b6f34b4ccd8075c9a4237cd01c5b0df68b57a9209846472f01760358d023ac7004f0c5e94dbb639389defd94a3a3c7999fab151805e8d8fa6e2bec3d63ffab5c9f48c06c87a464e640c9a6212cee9505eb0ad8894db4054c24021507a81ab094f2279914329b8d74d3e2c9fd10e32476e94b18d922a0a947582a044c2e98b15519109a857a824cec0fcc8f09d456126fd8cdf8ed508aef7033537b6067405cb0cc80000b1e6ba1aa1903a6ca6c0999a56b907a7bdcf88384c1ba27e1870d8e15100d46b5c0878e3aae12cd47a99cb4e459ea108e3544d672fd0da03cec954a5f9af0cad198ed214ac6241453406004e95da3963fe6488638ffaf646bc1ee92a9bd5a22090c70bbd1ba0ea527c28cbfb592cbc4d8f367fa2ee293cf2a069b7c2cf94c915d29f4217e68d7ed9465bcd3c0f445f9ecd80f229308201794442f8926c33812120d81260e297d3313522fa7e2ae37dd86c955e0b97ab51dc1dd693ae36ecb2991397ee702c8649242d0c257ae69ddf4a756d9a78d01f71da08d64c90ea3f87ef0c224adac119a48f912f9c4ff2cc9a9c15b2383ec2c0637d7f19620c8d1fc579f207644c872747597fe6121fc724b6c22b95669776e0048637a31179a9598ddb04f96d68b853c6c366d639f8ac25c0906b234fac8d18bce256b6ffff2e274ca76209fb70a45a41c2afbda5933c4a42dbcc676765c7da7828bd7bf576d6ea32d616fd5b18180803180c22eb09cbccf4591c3591c59cca2c676831982b586ce866b171b14c5472b12145580a8805710644c17a0a101f06bf044163086538a48250c5801940d46192832700d48650034a204da1745dfdacbc9261d86489b54da21170bd0a92ffa673f4c5728ebf0ffe07e13d3f76f08a0c809528e60a9dc85d5d1cd0f21c9d29ca43407a14f4226b6462298621571806cfaf2968d9ecfc96c67935b5df7d7bd0348f5c0cc0affb940465423b6280a40058f7687d3d85f19b942cc5770b5b93c5de94247dc4e8a1444b09904863dc945ee3d7f8f765f4b0e05b2630229fa0d77288b885ec7dd0bc75b1eab71d0dac8fb2d74d2a4cf5e5ec6dbf6e6e87bcc7ba719644cdb6da85e77186349406cd1f5aa654ddc3d5e80ceec28305bcea2900572f52ce79989e1fd95f57517b7cab33f99bf09dd3d51eb2091016679dc92502a310eae6e0d4d19b9502963cc8a32449711d6249c4bc949081a6f9bbd114bd045669488342f2a1956fa09454e606dc0e10a3232feea5163185516428e535481a0064f5de0b80f0c58d19df8f6c620c4cf16a4d83e38632e33e4bfe9d86790ce9de8b7676e3884daf4798569c34ca6db8aa039b02ca2eb57dfd81920baf5432f475a9f83b304738fa86142ca2db801bc19fc69f837b29db1a64fc86f21ba04ba60561b02113ea12178fd8b6439d8b308791950c3840d12c47ad69e98bf1abeccbee4c9121a542a77d27e6ff1e98da3f18dca65ff8cb4b00dc889cabb03b72dcb16bc1b4bb4f2b9b08437fdad28487e632d559ba92b6cecb8549d57ef55bd865f03522559f7912f8fd673b34658c3d891b71982d4108af97ae93e5f1e11af275e6ed0f59d5abdbd64778a3db732546dd252b6ce37110c6d3ec12b884361a139604b9d4373a7c7b92a3241d460ea61cd8518de255a29b9b2aa05fc861a4b3c08a280f856c94077cca16968cd2c9783afcecd71b839104baad75d37bd9e726a5eccdbb3e1eef7d7e2208e2a61200a5305982391857d81c275327484ccb725d1d4bf99f481f61ff170dcd9501825878a1312cfb40926b8a232285a5a39d0a1d3a29ee8eae4d7e982ac4cfed81fe469141343c3122c2065b32aa877eb45647db51ec5db889ef01146302b9a2e743af45da20c4fba79489cdebd4cf0258bda6ffaac44195371fe8ecaa3a6783b86cd062ae7f074a22ad9f6d4a4973142a7e36ac0299f7cc4c701d677e68c578a819bebd00d9c9289d43c915e0e5ba48d86b1e1209012e1f31a7415b187ca69406c324aa1a8d3132418e4f01ef33fda3b4ac56c22e6182b0b8a11b6e7c993970e4f5c0af267e8d90fada695311414aa1d7d790107802e90b07fe00922abf57849d6fda58a3a0390f74e92f8354ac648f0581909a9ae522f3e4bf43ed83ba8475ebee7f515b40190c56075a36c0a64ffc93ec108c01e4b5d4ac9c90dc9f816098bfc28321feec29ac3ffe1283d11a1b23a692067b867e0ae02a80b37e98862417a9538950de6ddb140e78f65dc683f4c55319223339d627ce3710a689e50bc3cddd001fe13d552a2a9fcc05343ce24c1316574484a9488d0d644a2313f40413a74c2092107ea0f97ae8c3adcb502dac05ede212566e91fc608314ec3475ff627485844f1c45fde5221e4331571d37f278055cd85483524e0ef57f8fd8a514471e22641fb04abddb4d1bae5eaca10e8a40db6f2b72e2e67f256f42abf0aaeca355d1a8a5a552f5a4f9e9e1c5c88bdc083a19c2015fd7a095db16a51a571a0fa25369ef19825e0e0ff6a45dc77e81a57b2a0170680c5a4a9908ecc89052fb5148da27b512bfb40bcdc3c515b10c054ca1bcf6a492987613ef336e603b307a58760b4ef855a4c9717c000d36984e3de041e19925be3e425113ae4ded4ef9748a25ad09acf5ff303185dc63eb1eb8611afd43cf5c56197f909ab0f9fab87cea4fa45f24cb116c9108e9f9159c02e6d206c749d0c4f0e32cc0102458b535b9812c2736a348d04a4a6ac0f18cd62eadb0de5e937fb2ac81060fe32c74c0e90e49ba4f994824cd3971f74ab7f4931505348f9d50620246162ac8febaaa1b9e110c7606f97f2c6e537ae1d02180941782d842a91ee46fa6701e4cc51d6f01a882d3edd66135c3c18fe60d9c62b9acb1a7837782012e5b41add522f4a174d66d14548b078fdf2f647f49c4aa234f4290c03fa9434e45d11ff0e4086109882553f919f382436896f36ac6eea39b5c762cf8dd7d88e701b7e7e9440e8bb79651af9fec12591310cf2f4b1e49da609a13707abb3a836ae9580df9badcb5827509a9be98d1a58cd69db80e24106c87d63c2c2cb45f626a66c242ece157d41e61fdc680945513a336921ccefe4cbe912ef7c73676e7323506f064a581a640afd5ae53d62abf61dc2fe3f88c3b4b992eef78db4b51dfe61ed98d66ead24667bcf3b6968ee76c8dacf1eb4f9eb8fdb5093e80e7b2dcfb9626e5a7d5306031dbf078c7d43347cf92c052c8180e4238fd91f1e0783d8182259cb73cdc3cf6794469e2ed8db18768b28147e2c59558c5b8bd616a509dc9304886708da97dbbdbe4d1d69ef29c46087f62af5b5154b6b4533fd5738e391dfad4cae7b6092940216da2c5e325aa6a14a8a8849280601ce7626134917f03590fe646b4c149ac981daab2a40b4a1eae1eed9540d543a8690dc6f8f32479a7daf3722f6b709bdd5c2782226e37e889c7808b83bd86cacf051bec595781036b596ebee9772226f2d38e714f401c0fdab842d3d6a03dab742d4bd55b6c9fbe06d3fef691581717990d44baeae4d6de8ce91455509ff74921893c56bee659a98ed965a7b480144a106cbd4f4b1281d0dd5a42e7eed84c0979a3c5519aa488dc5a87fea722a198555b77dc74b8ebe132491090bfd2ac709e4085597007883d36bdf3f87877df1f407b75e50bd493d4470ec9df2d707ba3a7fda9a2ec3ed32299eb56af523ad230d0af7713cb7116a9e81082fa3f2cdafeb63e28d2105a4c72eea08638b31ec10332f1a9890dfa9c04e9bd167c432747ed54a582f7fd8d588eb7fb2b594384f2d606cbcf17546c6c031df2865379be2cf61bb84b5fd4e94dbb703dbb12f35e04284df974da39ad08bad706e64777e895f0fc0cdab312973a885d445e8506ce94e83072487d02e6df233ac33eba3548bc7f94d2f75ecde7d50da627be5da87dc46785a2e1800e843754aae4f48534feceb19af5b17d56eb3b3f5b2ccdb462f176355e69dee6bac8f5658577f5faccd116f3da2ac756b35ad66464d70b673925bc9b9cfb2171abdc6a506449b16a99cdc4d5c9e56906c555819d4a835f7952db8349d68260885244de117985fb20dc0a07f447c9f428fa44e7ea4f66acc54762327fba63ff5823aa5d183155922365c4339e094b1d2757bce58d299992227ce52add485d49e6b2a813d80182be762a01847a17677fb6663c7748b80fa20f3a6a71821bf21482d3f0d24434023d8668ce60767169afac7d991c2ff49dd60b074042703880ea0602c582b52a45941fd9631919d8ccf9767cd4104b7abcb0c0f10e16f157c8d06365c75a3caa4d0a46d8f8a0871b3d336f93fcaccd0a745095bda68a75992076c9d6863f2c2e12551dd421c45d587aa466553261bedf8deb36c02ada7c3794e36f8f139e98873005e61f23dc9494a4b559d3a5ec106443bab9b8c3f4f69969b5aad533a669b4c532a8cf0c7ad711166bdbfc8bab32a441bad41cb1db6b4a8bbbff32e551d5cdb3d06bd0c657b942091ddf7b6e0cf66fd480bf15fa5e0595dbaa4f4be4c1405397739672805d3c5c358091b9e061875ee5082e9f5ef44823a3ba560aa4ea32a0a46f3973ca96d8c6329185633a7ac00520fcbaa0232a5256bdb9416f9c9bb0014d61b250d2e53e886d39f22771664e29135adee7953cfd86b4a1a04bacdea6aab7a19029d40c0187ae1c6796f1c8f7e0ffd440d276b6f09fa01ebd47a35fa7d5980b5a7637e47c1cbe1b39c2a8054fc36a0c46ff16cb7ddd12fe53ba04847c445d02f43caf2c934fd64f4839563652d142ae01f4f28e60f031d4f2f6afa20486d0757a8977e254d326cc9b2a4cc6813c0887cab0637819527081f684e45d31c6a3c8199250821d4fb9ed4833dea434af4f4d2c56c4813ea1913cde41833d16690d99f37f625f3112fc5bfeb6ce342ad851a6962a4f4631d685d6e41a4c1fed9f0a3db847283d0ed68e048d1409e239f83ae73fb971a04964416fb194d7c5272c8acd30ed2851a41adb4796ff2182446c8f1b9dc8c6b6887160a198c283fcaefcf6e5848221c67e7a416fbb1045c6a76c0d9919ba85960cdfeb6140e12d4b660174a889f5129981a5e933d40286a4ea4e8b324d684b3d381394c6d7c423ada4bf70f024a4d300e1e58edfdc08b5213718270ea6e7fa0d781626a1b4c6ec8cb59e86472abf3a4f7d34fd888309ac39701414aebcc0d633f2e886352d827268b859c0648a10f02800c2e6cdfba718c35f0cde0925de9a3ca34c45e191cb53b94e200b4932edcf6d2cbcdcddf2c80bd3803f7f89a1c3352349cd0f57fef5bb526772b481c21a133b7a6c95d889f830c935c0914762a979e50481c42e2c2b307774311b631221a8ae2061c21072053345e36f5105b96fffd30d350e1c4aed4938250d8d730a7dc186186ab342df7c7e4960e365b0b29b7677089bb3231a9fe3dbbd34f8649c4d9d38f47f77785c76a1bdd3db496e0f0e80acf82088a9f254a31d165c1a3482767ed9d0d52a59c2001eae6e455aac1e3d18980b2123254889cdbd4b2d0c97152bcb9f86c7326be239ca6198aadd484d9512636debbe4b8407c2d536ccc53ba2aa5e6b6c57df9cacc840782743438801e34cc392ef89a1e3be364f07e91b9b927f074d604444f3399164d8ace3d02b1bfca3cece4d71fe0ca143433f74dcc01769d6772b379c76934266a1134f8d0b95e8048b8b0790c2235d1b71c8d851972a6d92f1d48088d1f147662845b76c16b4b578c00d9fe5222171f6813544041322f0ca3228effc24fe4a19801ed54f18342d417965585929c1aaaa250da32d43d6ee1bcea74493839b1c4cb9306c509e5ee2f9c249deb574fddc0a843e62e2b9e585ead8b866e36f10a3953802e4a8d3bef1575276419f64f394cb722cd99c032d0df301d8916723fc5bd2c77a271ca0c6c334c50409acc5190c46542beb4189ee3aea28d33c441a2d0220896baa57b09dd89d159bd2eab57eca44e19126de07f60c2b410e1faca984ee214f513f8f72513cc28fcf77cfe6c9160d63db1f48e1819c27a1a8f40623610cbe988b82f3ed0c35f6d31d8faea60052375f876ff94e496bd634e6f4a313dd4ee8d6bf23d8ea3170822b6b5cf27e0bbc04b0357011a01ab0eb7d706ad6a470135c68bbcd084348384a2fb8916580b59ef1f5e9e2379b77036580efa25adf24c625909d2c711981a85dc3d3945a57c7d1d9909f7b5a2aaf41878604940e91d51d682217af501cfb523b3f2b54b85f043a470a356b01f8cb9148f26713417cd9d7043feec78476a80abd7459d7a22f8d046c64a1acfb9103bb91379efd48938e6766ec76d863dafabdae4b7becff357eb6e8c549e0235cbe0d30f1ef7543e162ba3a9e26978408b2761d4e602f59cc91c6e16dc761cf279927549f7ce19492d521aa26d4f65b4daa13b600422e6ca28fbe44edf5c86020e22344c8711fc127213dd07de907044056e640309748a00b82b34389ab80a2a7204dc854941c9464c80234caacba6c877a40ec01d22053986d474fa9084fe1039610d898a1de043fc3a00b0b3e3b8e4f20aec5c73ee677373d03bdcc3822173ce4c67adfa3e1abb0c9e9cd6b095d997635b5b1116619d4bb2d16cd3b249dcf46624b873070146b54a6fff8d92ba3e0122324c52e61c4e4e480d0262087b54b23fedc3e53057e88480cbdc474cb65577b864f38fe9ff2e92dcd503de3fa0d43dfb5f1a292cd0a303d02b866f10607bb79023f43480051e986d2521e9a0b0c09386946b5d1495bf21c72e26b6e1f24596952bf273df3002454cf279c5a81ae6b69a734cfd4b026518841f741bea9f8da091e709cfbe681c4c8be221e51f1e9a963c5a34dd2d5a195c97c9b8d3ef3128ba5699a0801666f4e5f5ea72043da035cf2d4bf77a62d0ffb7b822b800401e00aca5cc3ccd69b667288e2cbda2e0fe1706eac93a5b1277f27f17a367c5c439064e1647f4945306d1e670b7435d446cbbe96ad473e9303294a849a59ca367309fb7cf3723c94850cf374f8615ae14c0b79131358b3d584e12622119cbc90b182a8e3f1455c41e86f54098897985a24c296a1c0d1b86d0cf054ff004aaf735167be904933bd94927c38d81a75ca8cb9d519bb1ecedee49cba9f9c694f16bd5a42c91a1b86a866dd9afe3a6e391ddbf9967825696fa624c23f2791b3d5431eb8e868f18bcb84704a1c2633530a2e23a9982a796954a162648308410f5bf08a94af0ed8b96cc3e89572435ef10137f68ceb7d0c4c20b34ce2552ca98f125b2d03753c750a28f8185319b784f69e4c4304d57f1862626752927787f2cab0611321b77c14b217320767c52c85c6047d515fd12212b57485f5ab911aa1192a791523a1621d3976003e99192a41132494be2b0f1954dc034aba6f3a37c892b3a3a2fa996843a7e160ff9873a529128ae8d3a96f9628f00e3391cea486503433b716b40250c7bb5190783a04e8d882ad4b83d220cd1f748964511c520accc55f587215bc29235b30486a1bcff78d9e322f16e7c53151319ddcfb5da9299b7047825016cc547e6d187ea0480ad926c482d1645bfd58e9e4cc5bb9e9b1c888a4ca2d516992a542cd954a135b61bea26a1cb8d37feb436310f14364ab940704952f874c1172a81766d17e46037370e91d00b4817bbdb9d76a71e997379cb8d20620fe35b98a27a423ed262ed8fd8d73051076d6ae4d559a67d3e5cfcb8aa3d52333de70056b2c86679a2f9ef662c8a9ecb0819dd92c81113df874b12b15060626673fa2fab9de6ab5d68ea52219d809af0b6c5cfca03818b5929640a9695793df2e4c152461173a61fd2a6da9682b6538cb38959728b32060f9bbd390e8dde11259ac255fa4b246ea2561e19abac53725164ace518796964cce72b058a7a64a038bcd351712f88ec103e9ba98e44c56c7c69bcab957e8f9ac46d45b4ffc31773b40ca1478f06752299d680c9b256287fa9a13694ab2a29953605273eccbd794644721284d3a225cc50099e9b66262e308a9d0814a0c296015c5854af83accab43fb8acd865463c0dabf9a96f9e1e6aa8e9a32a8467249456da24821465068ba68c1a6fafa7ec1793772e9a11351750b2c1fd25993a2a8693903e54e8011b099deb7340fe6a83e150a3cef6435f0b74cdf36bb0b2809f9949889274c34a902932b328fbde73c3c0a18b72f4406002797f70e2c29aad95335e20a33ed8bd4474afa066a447fbe57ac451cd902eba7bc492ba81bf3b2530ee0d2ca4362cbaf6f14c495d98204b7869fbc78e266e24ed857d57a546f36512735bbd4a2eeab03c36618dda6fad1ac59a5169aa398855fe6159812711509db8dbc1b2b0f2041aba48b7eb6c6e6460f9994a507ba8ab056623d453502dbfe9fa4ff26b7d21c2e97e4dcd29a9b631be0bc17c45a546b098ebef5360fa9265290a2a928b1fbe844fdcfb5f50919b1c00de781175fe37065dd26d4164810d97d9f5cc8a18da89b68714dd85de096925a266c50adc05e1c7b8eb3802a6dea40b58604ec1c25f3151c4989e075ab251f05378f015305ba5b0f9bc50081b2b2cb7e87e04b9c02f193a8ffa77cea0096661b9f0818828e3eefb7e390358681de57187cf4600602f6d6b222ba343d9920a078c99b584396044442b34027827835c6522b6f031ab1e2b6e267abaa6f11a2e0d92bef65ce8e353da8498a0ee05c814c117f708590f74b7d8bf2b57ae8b1176494a1c186dabc1854330aa17fc4678e0e7a7460d89406112ad2223f0221ba3ee8e2a13e1a9041148069b040edc5b3e534100c4e0bc5063293f6aa468ea3a4452ab3472b78f86e582aa00e363c03e73b1a4d484567905aba53a0bafbaaece8ed6db72f759c9292ca0ccc6507081f76b61dccb3a242c951e5a24d8b8dc4768d0074d256299e503a4019a91fc626643d1996f51817a63ac0b1881eba71104a73be9694585534498b9f3407537942be93882200741f9369732fb31824ab7df170e01f5428568f7867b26b60d04713179305690ac00c082cd7aa7203fe7b41da6600524cd3bce22d184b82597703333791536140e9fafdab10d951d0c9d713df10837a4e5cb8430a3e3bfe6cc322561609672830256596381f0c8404795edea114bcab768949c06b1cd21ac0de5801f0ab1153e1574d80086aa00c8b0facab0195b41ebe623446b65f6862dbbd9c82c80284c516092ae851c23b0a4f76d8a02230e0179633f387e703e06b0b360b8d3a95871f2ae02fb0714d987eb3d7e7143e2bab1c42745d5b2069b1462c5397c1f5854b172f2fa32d5bd0ca90a2d16336b6d5f347bf6908cc77f6461c8878ba3a5b545e2626a5fe95a89bee2fbedfa7ae5866ac552294d42174020cdf1dd9a2abdee0057813c7ea43a2249cfed9377495321273f0c11b126ae39a51e962b04e72a0e9885d6ae157c705601c44a899142187e3828040a4332f744811fa663e10ae00f302ce51485574028b0087e98ff0a4e1760ffeac78d72c9e13c79401558765e680434ea8453c2f444d9413584c9835945b145980ccefff3c2323ac70691747361241141151be1080e0f07f17dc9783784330213ca42284db9cee599c909e2fb00e18eacb7e734b357a80b812a62e1f15a5d4d0e39e175549ac8ed68e2ff20b4df55695b8bb0a9f69c10a6b7b55dc6c29600529e552da7f1e2a4c62f740ccaa2502e08792daa280615ae80f13229bcf0bebf821c8f2b70cba770dcc4cd612074aecb40d59e0ecf52e2da370255e31bbd0060a08a06a2fddd4f9c8a2814373456f5ad4d5c924124295f029b8141148c4ddcf810ef9d4c56eb17d514f44da59042126790a2b0ddd61727b8eb91632150e23f69dc43eccdc740e152d7df798afd6c45f4a1905e0c661df8d220c899ea209028d10d89163e156311c214fa6d5287bc959e7b42870884ce97006a839851d3460b01170305d98067f5030946c1f24cb4214c42401177c779a61d84c9f44330bdd2035b7919b6a76bb3244c58bb84291678b8b9e5d1408e2f2d9e60bd4c9838b24bb08853471ea7e91852987beee2881258c8e8d3fc71e680f38c8c5ca174fce3ea18e281271e47ac651f000672a03f2053d306ffffffffffffff3f000300031012107415a01e2009a7b7445f77f365f2bf37d7ae403b6846906029bab2bbbbf7ae43583009d3150db4dfb5f52d0984008a008a00d34e7773b51c659313de16f5978b314ffc6c66dae363512364f92de92c3ebe6e7d257f2782b31555423b5dc396f965f1a15e6ec00204e91fbbdbc76ea7a2fa734f5b9ba3943e994c51df597c3d2e76fffd72164595b2c96fb365bb74bb2e4f541de37b84ef2d76583fa63585946aba2099086aa22e675ff668b19ecbfe6a1e8296a89e3d5e75a64675a68aea689254427374a6ad2f14875eb15b63e88d15bbf585dad09d696b0cad51f59c56bf4739b5b53f25084aa3665f334f8cedd3ce3d64d4043aa3be7c89f15a107ed43aeac5a88c0afde7677dfd5a0def69c03cbf073b1aa34e774d3bc8645ed22d960f2ad0080aa3c5b5a49c2c626ced9cd6a55cf3d117f5ed6411cee8ae94ec3e735103efd92149ca703654992af29ead2f94487df9cefbf6df6d0cc6f76cedf69d54dc023a84840af96cbcf30e408354279b5febcf5d67e5bb0ba45ef8eef07d1033a9b1ce3f2a960ee7fd791bde7947487d5418dda7c78799c5b6bce19d37dc79f76853a592425949ca501e6daa324c1f92a40cdd513f4f39bfc1fcecc9c55a4a94cc43cc7706fd84f3879a01d54ade745026aa24c126b4350946a80c0a55366b49a3204230d9c6ad8d638b99bc0cdf5cebce0326eb44c6132f802b2a04c25834dccd67015145852a5c2c19c586503a56a5648402651c7a0fe89391404d1f2bc04222b244514412693098445164d930d0388828ea9e5c4630165bd9f7804e4822000432a02c499ac8328044c387f341bf676b0cc7435dd21f6c726599125d3f069c0e6daa4029948a2465381cda540567a881194188106448020944e4a8583871048410e3102148218514c2f51280509a0e043181428410222048a0442214496012232297140e3ca022d88e65b30f565471ff46f8a60ff5f35679270803087c741435f71444a24c0cddb4bf7b3966cfc3c8cca76972a472d2edb4ead5b46d4c241ba91e2484dbc78036e91807cca9a9d22ce2986878dbb532c279a3a5f3551204536eb8736d27b253f8e0d50eea5cad2a30b3cda7f3dc33a23fcbf0121c4ed430d3470ae716d3ded45bbbc540fca4d946ea755537ae643a4adfc9f13093b3e14836d70b8665b694ab056722a632d4e90a4e588f66bfa9e5676284a8e089a0616c61b26e434398360d954631b24ec0684c508cc2cac1a60bfdc16993497907f4773a1de8db53c8d82ada11dbba60d1def15df6870f10e953af590026c4d45c1b5531b3af4d3ac37d71483c1a32b7fcf7577f1399a64cad47a838ec98c3145acfd2f0e42ab3c4881305dba27b8932435ddeb9c3f328e963c5"
+  },
   "genesis": {
     "raw": {
+      "childrenDefault": {},
       "top": {
         "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xea030000",
         "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
@@ -79,8 +72,15 @@
         "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
         "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x02000000",
         "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
-      },
-      "childrenDefault": {}
+      }
     }
-  }
+  },
+  "id": "contracts-rococo",
+  "name": "Contracts on Rococo",
+  "properties": {
+    "tokenDecimals": 12,
+    "tokenSymbol": "ROC"
+  },
+  "protocolId": null,
+  "telemetryEndpoints": null
 }
diff --git a/cumulus/parachains/chain-specs/coretime-kusama.json b/cumulus/parachains/chain-specs/coretime-kusama.json
index 4ebaab82e75242f5c50c725cfdbde980c7e24459..f9310d6c7cc6e14f54b4cc6620bece8b626725d1 100644
--- a/cumulus/parachains/chain-specs/coretime-kusama.json
+++ b/cumulus/parachains/chain-specs/coretime-kusama.json
@@ -24,7 +24,9 @@
     "/dns/boot-node.helikon.io/tcp/7420/p2p/12D3KooWK4eKFpYftyuLdBdXrkdJXHKt7KZcNLb92Ufkvo17B9T2",
     "/dns/boot-node.helikon.io/tcp/7422/wss/p2p/12D3KooWK4eKFpYftyuLdBdXrkdJXHKt7KZcNLb92Ufkvo17B9T2",
     "/dns/coretime-kusama-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWFzW9AgxNfkVNCepVByS7URDCRDAA5p3XzBLVptqZvWoL",
-    "/dns/coretime-kusama-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWFzW9AgxNfkVNCepVByS7URDCRDAA5p3XzBLVptqZvWoL"
+    "/dns/coretime-kusama-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWFzW9AgxNfkVNCepVByS7URDCRDAA5p3XzBLVptqZvWoL",
+    "/dns/coretime-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWPrgxrrumrANp6Bp2SMEwMQHPHDbPzA1HbcrakZrbFi5P",
+    "/dns/coretime-kusama.bootnode.amforc.com/tcp/30013/p2p/12D3KooWPrgxrrumrANp6Bp2SMEwMQHPHDbPzA1HbcrakZrbFi5P"
   ],
   "telemetryEndpoints": null,
   "protocolId": null,
diff --git a/cumulus/parachains/chain-specs/coretime-rococo.json b/cumulus/parachains/chain-specs/coretime-rococo.json
index 082e7dd26a952ccf7d156ea25ad208d9468be71d..1638ecbb9332e95c034d97c9667aaf0adbc7898a 100644
--- a/cumulus/parachains/chain-specs/coretime-rococo.json
+++ b/cumulus/parachains/chain-specs/coretime-rococo.json
@@ -1,7 +1,4 @@
 {
-  "name": "Rococo Coretime",
-  "id": "coretime-rococo",
-  "chainType": "Live",
   "bootNodes": [
     "/dns/rococo-coretime-collator-node-0.polkadot.io/tcp/30333/p2p/12D3KooWHBUH9wGBx1Yq1ZePov9VL3AzxRPv5DTR4KadiCU6VKxy",
     "/dns/rococo-coretime-collator-node-1.polkadot.io/tcp/30333/p2p/12D3KooWB3SKxdj6kpwTkdMnHJi6YmadojCzmEqFkeFJjxN812XX",
@@ -10,18 +7,15 @@
     "/dns/rococo-coretime-collator-node-0.polkadot.io/tcp/443/wss/p2p/12D3KooWHBUH9wGBx1Yq1ZePov9VL3AzxRPv5DTR4KadiCU6VKxy",
     "/dns/rococo-coretime-collator-node-1.polkadot.io/tcp/443/wss/p2p/12D3KooWB3SKxdj6kpwTkdMnHJi6YmadojCzmEqFkeFJjxN812XX"
   ],
-  "telemetryEndpoints": null,
-  "protocolId": null,
-  "properties": {
-    "ss58Format": 42,
-    "tokenDecimals": 12,
-    "tokenSymbol": "ROC"
-  },
+  "chainType": "Live",
   "relay_chain": "rococo",
   "para_id": 1005,
-  "codeSubstitutes": {},
+  "codeSubstitutes": {
+    "1627199": "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"
+  },
   "genesis": {
     "raw": {
+      "childrenDefault": {},
       "top": {
         "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xed030000",
         "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
@@ -67,8 +61,16 @@
         "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
         "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x03000000",
         "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
-      },
-      "childrenDefault": {}
+      }
     }
-  }
+  },
+  "id": "coretime-rococo",
+  "name": "Rococo Coretime",
+  "properties": {
+    "ss58Format": 42,
+    "tokenDecimals": 12,
+    "tokenSymbol": "ROC"
+  },
+  "protocolId": null,
+  "telemetryEndpoints": null
 }
diff --git a/cumulus/parachains/chain-specs/coretime-westend.json b/cumulus/parachains/chain-specs/coretime-westend.json
index 586879b9abc2f043f170f20523132a1c7e02e74d..ca723aacd881cbe56dbedc123b062465c68ec40b 100644
--- a/cumulus/parachains/chain-specs/coretime-westend.json
+++ b/cumulus/parachains/chain-specs/coretime-westend.json
@@ -28,7 +28,9 @@
     "/dns/boot.gatotech.network/tcp/33350/p2p/12D3KooWN6FJDaZvWbtX1pSc6UdHgyF2UZtYxPp3UkXQZa8ko7uS",
     "/dns/boot.gatotech.network/tcp/35350/wss/p2p/12D3KooWN6FJDaZvWbtX1pSc6UdHgyF2UZtYxPp3UkXQZa8ko7uS",
     "/dns/coretime-westend.bootnodes.polkadotters.com/tcp/30358/wss/p2p/12D3KooWDc9T2vQ8rHvX7hAt9eLWktD9Q89NDTcLm5STkuNbzUGf",
-    "/dns/coretime-westend.bootnodes.polkadotters.com/tcp/30356/p2p/12D3KooWDc9T2vQ8rHvX7hAt9eLWktD9Q89NDTcLm5STkuNbzUGf"
+    "/dns/coretime-westend.bootnodes.polkadotters.com/tcp/30356/p2p/12D3KooWDc9T2vQ8rHvX7hAt9eLWktD9Q89NDTcLm5STkuNbzUGf",
+    "/dns/coretime-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWG9a9H9An96E3kgXL1sirHta117iuacJXnJRaUywkMiSd",
+    "/dns/coretime-westend.bootnode.amforc.com/tcp/30013/p2p/12D3KooWG9a9H9An96E3kgXL1sirHta117iuacJXnJRaUywkMiSd"
   ],
   "telemetryEndpoints": null,
   "protocolId": null,
diff --git a/cumulus/parachains/chain-specs/people-kusama.json b/cumulus/parachains/chain-specs/people-kusama.json
index 518a7be751509aeeb3973f654b371e3498355949..3352cb25a2898f5442b1e28b340def69fc4168f2 100644
--- a/cumulus/parachains/chain-specs/people-kusama.json
+++ b/cumulus/parachains/chain-specs/people-kusama.json
@@ -6,7 +6,27 @@
     "/dns/kusama-people-connect-0.polkadot.io/tcp/30334/p2p/12D3KooWQaqG5TNmDfRWrtH7tMsN7YeqwVkSfoZT4GkemSzezNi1",
     "/dns/kusama-people-connect-1.polkadot.io/tcp/30334/p2p/12D3KooWKhYoQH9LdSyvY3SVZY9gFf6ZV1bFh6317TRehUP3r5fm",
     "/dns/kusama-people-connect-0.polkadot.io/tcp/443/wss/p2p/12D3KooWQaqG5TNmDfRWrtH7tMsN7YeqwVkSfoZT4GkemSzezNi1",
-    "/dns/kusama-people-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWKhYoQH9LdSyvY3SVZY9gFf6ZV1bFh6317TRehUP3r5fm"
+    "/dns/kusama-people-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWKhYoQH9LdSyvY3SVZY9gFf6ZV1bFh6317TRehUP3r5fm",
+    "/dns/people-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWPjzgKZe5jdG6TY4gwcFq8QxyyhqsYbQo6N29pwGePWLA",
+    "/dns/people-kusama.bootnode.amforc.com/tcp/30004/p2p/12D3KooWPjzgKZe5jdG6TY4gwcFq8QxyyhqsYbQo6N29pwGePWLA",
+    "/dns/boot.gatotech.network/tcp/33240/p2p/12D3KooWLi9TzaKX4zniJpiM521PnYG4EocpdqjPpJUhXq9QGkRX",
+    "/dns/boot.gatotech.network/tcp/35240/wss/p2p/12D3KooWLi9TzaKX4zniJpiM521PnYG4EocpdqjPpJUhXq9QGkRX",
+    "/dns/people-kusama-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWGP1C9iWTHnZyeaSjYZ7LdK8douXWc1n1dBv25XEASHaj",
+    "/dns/people-kusama-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWGP1C9iWTHnZyeaSjYZ7LdK8douXWc1n1dBv25XEASHaj",
+    "/dns/kppl16.rotko.net/tcp/33756/p2p/12D3KooWSKQwgoydfbN6mNN2aNwdqfkR2ExAnTRs8mmdrPQTtDLo",
+    "/dns/kppl16.rotko.net/tcp/35756/wss/p2p/12D3KooWSKQwgoydfbN6mNN2aNwdqfkR2ExAnTRs8mmdrPQTtDLo",
+    "/dns/people-kusama-boot-ng.dwellir.com/tcp/30359/p2p/12D3KooWM6T8MMibxLZhhpq6F612CZ4FgnfDSJSkWDMiVUDe1aGb",
+    "/dns/people-kusama-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWM6T8MMibxLZhhpq6F612CZ4FgnfDSJSkWDMiVUDe1aGb",
+    "/dns/people-kusama-bootnode.turboflakes.io/tcp/30645/p2p/12D3KooWCR2Q8J2NFFfuofDak4zSgWkuBq7orP96HFaxLgAoDUBV",
+    "/dns/people-kusama-bootnode.turboflakes.io/tcp/30745/wss/p2p/12D3KooWCR2Q8J2NFFfuofDak4zSgWkuBq7orP96HFaxLgAoDUBV",
+    "/dns/boot-node.helikon.io/tcp/7510/p2p/12D3KooWM1X4setrMWjwnV8iDkAtYhqFHNkGozdWdq6sawWh5Yhv",
+    "/dns/boot-node.helikon.io/tcp/7512/wss/p2p/12D3KooWM1X4setrMWjwnV8iDkAtYhqFHNkGozdWdq6sawWh5Yhv",
+    "/dns/people-kusama.bootnodes.polkadotters.com/tcp/30377/p2p/12D3KooWHy7TAuK6EoVij2tfaeh3KkaEJxhTmumbEom3HfRnSEsp",
+    "/dns/people-kusama.bootnodes.polkadotters.com/tcp/30379/wss/p2p/12D3KooWHy7TAuK6EoVij2tfaeh3KkaEJxhTmumbEom3HfRnSEsp",
+    "/dns/boot.metaspan.io/tcp/25068/p2p/12D3KooWDoDLtLvQi8hhFVyubPZhaYuAwSAJrPFtyGWJ2NSfBiyP",
+    "/dns/boot.metaspan.io/tcp/25069/wss/p2p/12D3KooWDoDLtLvQi8hhFVyubPZhaYuAwSAJrPFtyGWJ2NSfBiyP",
+    "/dns/ibp-boot-kusama-people.luckyfriday.io/tcp/30342/p2p/12D3KooWM4bRafMH2StfBEQtyj5cMWfGLYbuikCZmvKv9m1MQVPn",
+    "/dns/ibp-boot-kusama-people.luckyfriday.io/tcp/443/wss/p2p/12D3KooWM4bRafMH2StfBEQtyj5cMWfGLYbuikCZmvKv9m1MQVPn"
   ],
   "telemetryEndpoints": null,
   "protocolId": null,
diff --git a/cumulus/parachains/chain-specs/people-rococo.json b/cumulus/parachains/chain-specs/people-rococo.json
index a4361b77df790ad816d3c95afcf93c0575ee2b85..952e1516c117cfc22e79fed91d48d0f8718b77b9 100644
--- a/cumulus/parachains/chain-specs/people-rococo.json
+++ b/cumulus/parachains/chain-specs/people-rococo.json
@@ -1,7 +1,4 @@
 {
-  "name": "Rococo People",
-  "id": "people-rococo",
-  "chainType": "Live",
   "bootNodes": [
     "/dns/rococo-people-collator-node-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWDZg5jMYhKXTu6RU491V5sxsFnP4oaEmZJEUfcRkYzps5",
     "/dns/rococo-people-collator-node-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWGGR5i6qQqfo7iDNp7vjDRKPWuDk53idGV6nFLwS12X5H",
@@ -10,18 +7,15 @@
     "/dns/rococo-people-collator-node-0.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWDZg5jMYhKXTu6RU491V5sxsFnP4oaEmZJEUfcRkYzps5",
     "/dns/rococo-people-collator-node-1.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWGGR5i6qQqfo7iDNp7vjDRKPWuDk53idGV6nFLwS12X5H"
   ],
-  "telemetryEndpoints": null,
-  "protocolId": null,
-  "properties": {
-    "ss58Format": 42,
-    "tokenDecimals": 12,
-    "tokenSymbol": "ROC"
-  },
   "relay_chain": "rococo",
   "para_id": 1004,
-  "codeSubstitutes": {},
+  "chainType": "Live",
+  "codeSubstitutes": {
+    "1209599": "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"
+  },
   "genesis": {
     "raw": {
+      "childrenDefault": {},
       "top": {
         "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xec030000",
         "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
@@ -73,8 +67,16 @@
         "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
         "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x03000000",
         "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
-      },
-      "childrenDefault": {}
+      }
     }
-  }
+  },
+  "id": "people-rococo",
+  "name": "Rococo People",
+  "properties": {
+    "ss58Format": 42,
+    "tokenDecimals": 12,
+    "tokenSymbol": "ROC"
+  },
+  "protocolId": null,
+  "telemetryEndpoints": null
 }
diff --git a/cumulus/parachains/chain-specs/people-westend.json b/cumulus/parachains/chain-specs/people-westend.json
index 26e165b4839fcaa895bfdf0f7f4c1242b8513968..8bfbb33264150f5d28fa80a93128f9708998db53 100644
--- a/cumulus/parachains/chain-specs/people-westend.json
+++ b/cumulus/parachains/chain-specs/people-westend.json
@@ -21,8 +21,8 @@
     "/dns/boot.stake.plus/tcp/46334/wss/p2p/12D3KooWLNWUF4H5WE3dy2rPB56gVcR48XY2rHwEaZ6pGTK6HYFi",
     "/dns/boot.gatotech.network/tcp/33340/p2p/12D3KooWHwURYtEHpexfrZa8k8hVgVi5FTFr4N8HBnn9kPDsWfgA",
     "/dns/boot.gatotech.network/tcp/35340/wss/p2p/12D3KooWHwURYtEHpexfrZa8k8hVgVi5FTFr4N8HBnn9kPDsWfgA",
-    "/dns/people-westend.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWQrMQFAXxJJJCtVr8nViBR6EDsuT1RyqU3eoCMebRQxTf",
-    "/dns/people-westend.bootnode.amforc.com/tcp/30346/p2p/12D3KooWQrMQFAXxJJJCtVr8nViBR6EDsuT1RyqU3eoCMebRQxTf",
+    "/dns/people-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWE1btdwDhNpApg8BEe2QwJxdVDtz6a6BRhgTeUh9HMhWs",
+    "/dns/people-westend.bootnode.amforc.com/tcp/30016/p2p/12D3KooWE1btdwDhNpApg8BEe2QwJxdVDtz6a6BRhgTeUh9HMhWs",
     "/dns/people-westend-bootnode.turboflakes.io/tcp/30650/p2p/12D3KooWQEhmZg3uMkuxVUx3jbsD84zEX4dUKtvHfmCoBWMhybKW",
     "/dns/people-westend-bootnode.turboflakes.io/tcp/30750/wss/p2p/12D3KooWQEhmZg3uMkuxVUx3jbsD84zEX4dUKtvHfmCoBWMhybKW",
     "/dns/wppl16.rotko.net/tcp/33766/p2p/12D3KooWHwUXBUo2WRMUBwPLC2ttVbnEk1KvDyESYAeKcNoCn7WS",
diff --git a/cumulus/parachains/common/src/impls.rs b/cumulus/parachains/common/src/impls.rs
index d70fdfeb7095a2dbd6f5fd9a53caeb1272476743..16cda1a4ed83850f4e67765a5e7092dad4a24305 100644
--- a/cumulus/parachains/common/src/impls.rs
+++ b/cumulus/parachains/common/src/impls.rs
@@ -202,7 +202,7 @@ mod tests {
 	use frame_system::{limits, EnsureRoot};
 	use pallet_collator_selection::IdentityCollator;
 	use polkadot_primitives::AccountId;
-	use sp_core::{ConstU64, H256};
+	use sp_core::H256;
 	use sp_runtime::{
 		traits::{BlakeTwo256, IdentityLookup},
 		BuildStorage, Perbill,
@@ -222,10 +222,8 @@ mod tests {
 	);
 
 	parameter_types! {
-		pub const BlockHashCount: u64 = 250;
 		pub BlockLength: limits::BlockLength = limits::BlockLength::max(2 * 1024);
 		pub const AvailableBlockRatio: Perbill = Perbill::one();
-		pub const MaxReserves: u32 = 50;
 	}
 
 	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
@@ -240,7 +238,6 @@ mod tests {
 		type Lookup = IdentityLookup<Self::AccountId>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type BlockLength = BlockLength;
 		type BlockWeights = ();
 		type DbWeight = ();
@@ -255,20 +252,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ConstU64<1>;
 		type AccountStore = System;
-		type MaxLocks = ();
-		type WeightInfo = ();
-		type MaxReserves = MaxReserves;
-		type ReserveIdentifier = [u8; 8];
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	pub struct OneAuthor;
diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml
index 7ac65b0ee1ded60939072ff61d6886fa53a10b94..113036b4c00ea697507166a1f1da8d44458bacdd 100644
--- a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml
+++ b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml
@@ -16,8 +16,8 @@ workspace = true
 sp-core = { path = "../../../../../../../substrate/primitives/core", default-features = false }
 sp-authority-discovery = { path = "../../../../../../../substrate/primitives/authority-discovery", default-features = false }
 sp-consensus-babe = { path = "../../../../../../../substrate/primitives/consensus/babe", default-features = false }
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../../../../../substrate/primitives/consensus/beefy" }
-grandpa = { package = "sc-consensus-grandpa", path = "../../../../../../../substrate/client/consensus/grandpa", default-features = false }
+sp-consensus-beefy = { path = "../../../../../../../substrate/primitives/consensus/beefy" }
+sc-consensus-grandpa = { path = "../../../../../../../substrate/client/consensus/grandpa", default-features = false }
 
 # Polkadot
 polkadot-primitives = { path = "../../../../../../../polkadot/primitives", default-features = false }
diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs
index 55437645b0523b577c2e9d455952f5526ba9df0b..074a1de5e1852279ad32aafe97e40289cecb6758 100644
--- a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs
+++ b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs
@@ -14,10 +14,10 @@
 // limitations under the License.
 
 // Substrate
-use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId;
-use grandpa::AuthorityId as GrandpaId;
+use sc_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
 use sp_consensus_babe::AuthorityId as BabeId;
+use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId;
 use sp_core::{sr25519, storage::Storage};
 
 // Polkadot
diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml
index e4688a1c9f022dd9aafd821ee39bfc5906a7b2a0..b952477c47a7c33277d9cd6bf09ea7a2ba1dd799 100644
--- a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml
+++ b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml
@@ -17,8 +17,8 @@ sp-core = { path = "../../../../../../../substrate/primitives/core", default-fea
 sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false }
 sp-authority-discovery = { path = "../../../../../../../substrate/primitives/authority-discovery", default-features = false }
 sp-consensus-babe = { path = "../../../../../../../substrate/primitives/consensus/babe", default-features = false }
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../../../../../substrate/primitives/consensus/beefy" }
-grandpa = { package = "sc-consensus-grandpa", path = "../../../../../../../substrate/client/consensus/grandpa", default-features = false }
+sp-consensus-beefy = { path = "../../../../../../../substrate/primitives/consensus/beefy" }
+sc-consensus-grandpa = { path = "../../../../../../../substrate/client/consensus/grandpa", default-features = false }
 pallet-staking = { path = "../../../../../../../substrate/frame/staking", default-features = false }
 
 # Polkadot
diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs
index 700b80e63f6cf68e6095b7e02d84bb285ce720f9..b9f12932b84e163214f0cfc12d32d7da24b5bc05 100644
--- a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs
+++ b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs
@@ -14,10 +14,10 @@
 // limitations under the License.
 
 // Substrate
-use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId;
-use grandpa::AuthorityId as GrandpaId;
+use sc_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
 use sp_consensus_babe::AuthorityId as BabeId;
+use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId;
 use sp_core::storage::Storage;
 use sp_runtime::Perbill;
 
diff --git a/cumulus/parachains/integration-tests/emulated/common/Cargo.toml b/cumulus/parachains/integration-tests/emulated/common/Cargo.toml
index b010d2a296382f2f2d5f8ffd889f4643a17098d0..d9ec813232309998e8e50557138773d14c65c04b 100644
--- a/cumulus/parachains/integration-tests/emulated/common/Cargo.toml
+++ b/cumulus/parachains/integration-tests/emulated/common/Cargo.toml
@@ -14,8 +14,8 @@ codec = { package = "parity-scale-codec", version = "3.6.12", default-features =
 paste = "1.0.14"
 
 # Substrate
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../../../substrate/primitives/consensus/beefy" }
-grandpa = { package = "sc-consensus-grandpa", path = "../../../../../substrate/client/consensus/grandpa" }
+sp-consensus-beefy = { path = "../../../../../substrate/primitives/consensus/beefy" }
+sc-consensus-grandpa = { path = "../../../../../substrate/client/consensus/grandpa" }
 sp-authority-discovery = { path = "../../../../../substrate/primitives/authority-discovery" }
 sp-runtime = { path = "../../../../../substrate/primitives/runtime" }
 frame-support = { path = "../../../../../substrate/frame/support" }
diff --git a/cumulus/parachains/integration-tests/emulated/common/src/lib.rs b/cumulus/parachains/integration-tests/emulated/common/src/lib.rs
index cbde0642f1a2965579196cda7e7ada4f291e9d98..4a9d3b3a5aaf5bb885bf4fa92759f67f9165a85a 100644
--- a/cumulus/parachains/integration-tests/emulated/common/src/lib.rs
+++ b/cumulus/parachains/integration-tests/emulated/common/src/lib.rs
@@ -20,11 +20,11 @@ pub mod xcm_helpers;
 pub use xcm_emulator;
 
 // Substrate
-use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId;
 use frame_support::parameter_types;
-use grandpa::AuthorityId as GrandpaId;
+use sc_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
 use sp_consensus_babe::AuthorityId as BabeId;
+use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId;
 use sp_core::{sr25519, storage::Storage, Pair, Public};
 use sp_runtime::{
 	traits::{AccountIdConversion, IdentifyAccount, Verify},
diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml
index 4fd7b5bfdf2de44a63d55a7db1e3994ed2328fdc..e0f29cd801c346a064a4773efa5754b0e2f399f4 100644
--- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml
+++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml
@@ -18,6 +18,7 @@ assert_matches = "1.5.0"
 sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false }
 sp-keyring = { path = "../../../../../../../substrate/primitives/keyring", default-features = false }
 sp-core = { path = "../../../../../../../substrate/primitives/core", default-features = false }
+frame-metadata-hash-extension = { path = "../../../../../../../substrate/frame/metadata-hash-extension" }
 frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false }
 frame-system = { path = "../../../../../../../substrate/frame/system", default-features = false }
 pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false }
diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs
index aeec9b44dab4ce7648e609e13136c381a5a50695..dc89ef1f7a44e6afc218de787bc47d452ae50fa8 100644
--- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs
+++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs
@@ -17,16 +17,15 @@
 
 use crate::imports::*;
 
-use sp_keyring::AccountKeyring::Alice;
-use sp_runtime::{generic, MultiSignature};
+use frame_system::RawOrigin;
 use xcm_fee_payment_runtime_api::{
-	dry_run::runtime_decl_for_xcm_dry_run_api::XcmDryRunApiV1,
+	dry_run::runtime_decl_for_dry_run_api::DryRunApiV1,
 	fees::runtime_decl_for_xcm_payment_api::XcmPaymentApiV1,
 };
 
 /// We are able to dry-run and estimate the fees for a teleport between relay and system para.
 /// Scenario: Alice on Westend relay chain wants to teleport WND to Asset Hub.
-/// We want to know the fees using the `XcmDryRunApi` and `XcmPaymentApi`.
+/// We want to know the fees using the `DryRunApi` and `XcmPaymentApi`.
 #[test]
 fn teleport_relay_system_para_works() {
 	let destination: Location = Parachain(1000).into(); // Asset Hub.
@@ -42,6 +41,7 @@ fn teleport_relay_system_para_works() {
 	<Westend as TestExt>::new_ext().execute_with(|| {
 		type Runtime = <Westend as Chain>::Runtime;
 		type RuntimeCall = <Westend as Chain>::RuntimeCall;
+		type OriginCaller = <Westend as Chain>::OriginCaller;
 
 		let call = RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets {
 			dest: Box::new(VersionedLocation::V4(destination.clone())),
@@ -50,9 +50,8 @@ fn teleport_relay_system_para_works() {
 			fee_asset_item: 0,
 			weight_limit: Unlimited,
 		});
-		let sender = Alice; // Is the same as `WestendSender`.
-		let extrinsic = construct_extrinsic_westend(sender, call);
-		let result = Runtime::dry_run_extrinsic(extrinsic).unwrap();
+		let origin = OriginCaller::system(RawOrigin::Signed(WestendSender::get()));
+		let result = Runtime::dry_run_call(origin, call).unwrap();
 		assert_eq!(result.forwarded_xcms.len(), 1);
 		let (destination_to_query, messages_to_query) = &result.forwarded_xcms[0];
 		assert_eq!(messages_to_query.len(), 1);
@@ -105,7 +104,7 @@ fn teleport_relay_system_para_works() {
 
 /// We are able to dry-run and estimate the fees for a multi-hop XCM journey.
 /// Scenario: Alice on PenpalA has some WND and wants to send them to PenpalB.
-/// We want to know the fees using the `XcmDryRunApi` and `XcmPaymentApi`.
+/// We want to know the fees using the `DryRunApi` and `XcmPaymentApi`.
 #[test]
 fn multi_hop_works() {
 	let destination = PenpalA::sibling_location_of(PenpalB::para_id());
@@ -142,6 +141,7 @@ fn multi_hop_works() {
 	<PenpalA as TestExt>::execute_with(|| {
 		type Runtime = <PenpalA as Chain>::Runtime;
 		type RuntimeCall = <PenpalA as Chain>::RuntimeCall;
+		type OriginCaller = <PenpalA as Chain>::OriginCaller;
 
 		let call = RuntimeCall::PolkadotXcm(pallet_xcm::Call::transfer_assets {
 			dest: Box::new(VersionedLocation::V4(destination.clone())),
@@ -150,9 +150,8 @@ fn multi_hop_works() {
 			fee_asset_item: 0,
 			weight_limit: Unlimited,
 		});
-		let sender = Alice; // Same as `PenpalASender`.
-		let extrinsic = construct_extrinsic_penpal(sender, call);
-		let result = Runtime::dry_run_extrinsic(extrinsic).unwrap();
+		let origin = OriginCaller::system(RawOrigin::Signed(PenpalASender::get()));
+		let result = Runtime::dry_run_call(origin, call).unwrap();
 		assert_eq!(result.forwarded_xcms.len(), 1);
 		let (destination_to_query, messages_to_query) = &result.forwarded_xcms[0];
 		assert_eq!(messages_to_query.len(), 1);
@@ -304,67 +303,3 @@ fn transfer_assets_para_to_para(test: ParaToParaThroughRelayTest) -> DispatchRes
 		test.args.weight_limit,
 	)
 }
-
-// Constructs the SignedExtra component of an extrinsic for the Westend runtime.
-fn construct_extrinsic_westend(
-	sender: sp_keyring::AccountKeyring,
-	call: westend_runtime::RuntimeCall,
-) -> westend_runtime::UncheckedExtrinsic {
-	type Runtime = <Westend as Chain>::Runtime;
-	let account_id = <Runtime as frame_system::Config>::AccountId::from(sender.public());
-	let tip = 0;
-	let extra: westend_runtime::SignedExtra = (
-		frame_system::CheckNonZeroSender::<Runtime>::new(),
-		frame_system::CheckSpecVersion::<Runtime>::new(),
-		frame_system::CheckTxVersion::<Runtime>::new(),
-		frame_system::CheckGenesis::<Runtime>::new(),
-		frame_system::CheckMortality::<Runtime>::from(sp_runtime::generic::Era::immortal()),
-		frame_system::CheckNonce::<Runtime>::from(
-			frame_system::Pallet::<Runtime>::account(&account_id).nonce,
-		),
-		frame_system::CheckWeight::<Runtime>::new(),
-		pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
-	);
-	let raw_payload = westend_runtime::SignedPayload::new(call, extra).unwrap();
-	let signature = raw_payload.using_encoded(|payload| sender.sign(payload));
-	let (call, extra, _) = raw_payload.deconstruct();
-	westend_runtime::UncheckedExtrinsic::new_signed(
-		call,
-		account_id.into(),
-		MultiSignature::Sr25519(signature),
-		extra,
-	)
-}
-
-// Constructs the SignedExtra component of an extrinsic for the Westend runtime.
-fn construct_extrinsic_penpal(
-	sender: sp_keyring::AccountKeyring,
-	call: penpal_runtime::RuntimeCall,
-) -> penpal_runtime::UncheckedExtrinsic {
-	type Runtime = <PenpalA as Chain>::Runtime;
-	let account_id = <Runtime as frame_system::Config>::AccountId::from(sender.public());
-	let tip = 0;
-	let extra: penpal_runtime::SignedExtra = (
-		frame_system::CheckNonZeroSender::<Runtime>::new(),
-		frame_system::CheckSpecVersion::<Runtime>::new(),
-		frame_system::CheckTxVersion::<Runtime>::new(),
-		frame_system::CheckGenesis::<Runtime>::new(),
-		frame_system::CheckEra::<Runtime>::from(generic::Era::immortal()),
-		frame_system::CheckNonce::<Runtime>::from(
-			frame_system::Pallet::<Runtime>::account(&account_id).nonce,
-		),
-		frame_system::CheckWeight::<Runtime>::new(),
-		pallet_asset_tx_payment::ChargeAssetTxPayment::<Runtime>::from(tip, None),
-	);
-	type SignedPayload =
-		generic::SignedPayload<penpal_runtime::RuntimeCall, penpal_runtime::SignedExtra>;
-	let raw_payload = SignedPayload::new(call, extra).unwrap();
-	let signature = raw_payload.using_encoded(|payload| sender.sign(payload));
-	let (call, extra, _) = raw_payload.deconstruct();
-	penpal_runtime::UncheckedExtrinsic::new_signed(
-		call,
-		account_id.into(),
-		MultiSignature::Sr25519(signature),
-		extra,
-	)
-}
diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs
index a1d871cdb618fdddfbbbc3e7812d0ec7f7ae7866..78788634e6ff45c10b5fbebc91da4843d8f595e3 100644
--- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs
+++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs
@@ -61,10 +61,13 @@ fn send_xcm_from_rococo_relay_to_westend_asset_hub_should_fail_on_not_applicable
 #[test]
 fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 	// Initially set only default version on all runtimes
-	AssetHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
-	BridgeHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
-	BridgeHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
-	AssetHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
+	let newer_xcm_version = xcm::prelude::XCM_VERSION;
+	let older_xcm_version = newer_xcm_version - 1;
+
+	AssetHubRococo::force_default_xcm_version(Some(older_xcm_version));
+	BridgeHubRococo::force_default_xcm_version(Some(older_xcm_version));
+	BridgeHubWestend::force_default_xcm_version(Some(older_xcm_version));
+	AssetHubWestend::force_default_xcm_version(Some(older_xcm_version));
 
 	// prepare data
 	let destination = asset_hub_westend_location();
@@ -87,42 +90,12 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 	);
 
 	// set destination version
-	AssetHubRococo::force_xcm_version(destination.clone(), xcm::v3::prelude::XCM_VERSION);
-
-	// TODO: remove this block, when removing `xcm:v2`
-	{
-		// send XCM from AssetHubRococo - fails - AssetHubRococo is set to the default/safe `2`
-		// version, which does not have the `ExportMessage` instruction. If the default `2` is
-		// changed to `3`, then this assert can go away"
-		assert_err!(
-			send_asset_from_asset_hub_rococo(destination.clone(), (native_token.clone(), amount)),
-			DispatchError::Module(sp_runtime::ModuleError {
-				index: 31,
-				error: [1, 0, 0, 0],
-				message: Some("SendFailure")
-			})
-		);
-
-		// set exact version for BridgeHubWestend to `2` without `ExportMessage` instruction
-		AssetHubRococo::force_xcm_version(
-			ParentThen(Parachain(BridgeHubRococo::para_id().into()).into()).into(),
-			xcm::v2::prelude::XCM_VERSION,
-		);
-		// send XCM from AssetHubRococo - fails - `ExportMessage` is not in `2`
-		assert_err!(
-			send_asset_from_asset_hub_rococo(destination.clone(), (native_token.clone(), amount)),
-			DispatchError::Module(sp_runtime::ModuleError {
-				index: 31,
-				error: [1, 0, 0, 0],
-				message: Some("SendFailure")
-			})
-		);
-	}
+	AssetHubRococo::force_xcm_version(destination.clone(), newer_xcm_version);
 
 	// set version with `ExportMessage` for BridgeHubRococo
 	AssetHubRococo::force_xcm_version(
 		ParentThen(Parachain(BridgeHubRococo::para_id().into()).into()).into(),
-		xcm::v3::prelude::XCM_VERSION,
+		newer_xcm_version,
 	);
 	// send XCM from AssetHubRococo - ok
 	assert_ok!(send_asset_from_asset_hub_rococo(
@@ -134,14 +107,11 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 	assert_bridge_hub_rococo_message_accepted(false);
 
 	// set version for remote BridgeHub on BridgeHubRococo
-	BridgeHubRococo::force_xcm_version(
-		bridge_hub_westend_location(),
-		xcm::v3::prelude::XCM_VERSION,
-	);
+	BridgeHubRococo::force_xcm_version(bridge_hub_westend_location(), newer_xcm_version);
 	// set version for AssetHubWestend on BridgeHubWestend
 	BridgeHubWestend::force_xcm_version(
 		ParentThen(Parachain(AssetHubWestend::para_id().into()).into()).into(),
-		xcm::v3::prelude::XCM_VERSION,
+		newer_xcm_version,
 	);
 
 	// send XCM from AssetHubRococo - ok
@@ -164,20 +134,4 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 			]
 		);
 	});
-
-	// TODO: remove this block, when removing `xcm:v2`
-	{
-		// set `2` version for remote BridgeHub on BridgeHubRococo, which does not have
-		// `UniversalOrigin` and `DescendOrigin`
-		BridgeHubRococo::force_xcm_version(
-			bridge_hub_westend_location(),
-			xcm::v2::prelude::XCM_VERSION,
-		);
-
-		// send XCM from AssetHubRococo - ok
-		assert_ok!(send_asset_from_asset_hub_rococo(destination, (native_token, amount)));
-		// message is not accepted on the local BridgeHub (`DestinationUnsupported`) because we
-		// cannot add `UniversalOrigin` and `DescendOrigin`
-		assert_bridge_hub_rococo_message_accepted(false);
-	}
 }
diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs
index 1c1c51404aa48a78d110dbcc2e28fefa01ee94bb..8196b27cfe028087e1a6279d4bac1f6c0cf691e5 100644
--- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs
+++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs
@@ -215,7 +215,7 @@ fn register_weth_token_from_ethereum_to_asset_hub() {
 
 		// Construct RegisterToken message and sent to inbound queue
 		let register_token_message = make_register_token_message();
-		send_inbound_message(register_token_message.clone()).unwrap();
+		assert_ok!(send_inbound_message(register_token_message.clone()));
 
 		assert_expected_events!(
 			BridgeHubRococo,
@@ -250,10 +250,10 @@ fn send_token_from_ethereum_to_asset_hub() {
 		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
 
 		// Construct RegisterToken message and sent to inbound queue
-		send_inbound_message(make_register_token_message()).unwrap();
+		assert_ok!(send_inbound_message(make_register_token_message()));
 
 		// Construct SendToken message and sent to inbound queue
-		send_inbound_message(make_send_token_message()).unwrap();
+		assert_ok!(send_inbound_message(make_send_token_message()));
 
 		// Check that the message was sent
 		assert_expected_events!(
@@ -332,14 +332,14 @@ fn send_token_from_ethereum_to_penpal() {
 		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
 
 		// Construct RegisterToken message and sent to inbound queue
-		send_inbound_message(make_register_token_message()).unwrap();
+		assert_ok!(send_inbound_message(make_register_token_message()));
 
 		// Construct SendToken message to AssetHub(only for increase the nonce as the same order in
 		// smoke test)
-		send_inbound_message(make_send_token_message()).unwrap();
+		assert_ok!(send_inbound_message(make_send_token_message()));
 
 		// Construct SendToken message and sent to inbound queue
-		send_inbound_message(make_send_token_to_penpal_message()).unwrap();
+		assert_ok!(send_inbound_message(make_send_token_to_penpal_message()));
 
 		assert_expected_events!(
 			BridgeHubRococo,
@@ -399,7 +399,7 @@ fn send_weth_asset_from_asset_hub_to_ethereum() {
 		type RuntimeEvent = <BridgeHubRococo as Chain>::RuntimeEvent;
 
 		// Construct RegisterToken message and sent to inbound queue
-		send_inbound_message(make_register_token_message()).unwrap();
+		assert_ok!(send_inbound_message(make_register_token_message()));
 
 		// Check that the register token message was sent using xcm
 		assert_expected_events!(
@@ -410,7 +410,7 @@ fn send_weth_asset_from_asset_hub_to_ethereum() {
 		);
 
 		// Construct SendToken message and sent to inbound queue
-		send_inbound_message(make_send_token_message()).unwrap();
+		assert_ok!(send_inbound_message(make_send_token_message()));
 
 		// Check that the send token message was sent using xcm
 		assert_expected_events!(
diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs
index b01be5e8dc84b4edf35651d0388baa1462b54c9b..8539df97be9331ea1126a56a70a47ac3a597ce5b 100644
--- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs
+++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs
@@ -61,10 +61,13 @@ fn send_xcm_from_westend_relay_to_rococo_asset_hub_should_fail_on_not_applicable
 #[test]
 fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 	// Initially set only default version on all runtimes
-	AssetHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
-	BridgeHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
-	BridgeHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
-	AssetHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION));
+	let newer_xcm_version = xcm::prelude::XCM_VERSION;
+	let older_xcm_version = newer_xcm_version - 1;
+
+	AssetHubRococo::force_default_xcm_version(Some(older_xcm_version));
+	BridgeHubRococo::force_default_xcm_version(Some(older_xcm_version));
+	BridgeHubWestend::force_default_xcm_version(Some(older_xcm_version));
+	AssetHubWestend::force_default_xcm_version(Some(older_xcm_version));
 
 	// prepare data
 	let destination = asset_hub_rococo_location();
@@ -87,42 +90,12 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 	);
 
 	// set destination version
-	AssetHubWestend::force_xcm_version(destination.clone(), xcm::v3::prelude::XCM_VERSION);
-
-	// TODO: remove this block, when removing `xcm:v2`
-	{
-		// send XCM from AssetHubRococo - fails - AssetHubRococo is set to the default/safe `2`
-		// version, which does not have the `ExportMessage` instruction. If the default `2` is
-		// changed to `3`, then this assert can go away"
-		assert_err!(
-			send_asset_from_asset_hub_westend(destination.clone(), (native_token.clone(), amount)),
-			DispatchError::Module(sp_runtime::ModuleError {
-				index: 31,
-				error: [1, 0, 0, 0],
-				message: Some("SendFailure")
-			})
-		);
-
-		// set exact version for BridgeHubWestend to `2` without `ExportMessage` instruction
-		AssetHubWestend::force_xcm_version(
-			ParentThen(Parachain(BridgeHubWestend::para_id().into()).into()).into(),
-			xcm::v2::prelude::XCM_VERSION,
-		);
-		// send XCM from AssetHubWestend - fails - `ExportMessage` is not in `2`
-		assert_err!(
-			send_asset_from_asset_hub_westend(destination.clone(), (native_token.clone(), amount)),
-			DispatchError::Module(sp_runtime::ModuleError {
-				index: 31,
-				error: [1, 0, 0, 0],
-				message: Some("SendFailure")
-			})
-		);
-	}
+	AssetHubWestend::force_xcm_version(destination.clone(), newer_xcm_version);
 
 	// set version with `ExportMessage` for BridgeHubWestend
 	AssetHubWestend::force_xcm_version(
 		ParentThen(Parachain(BridgeHubWestend::para_id().into()).into()).into(),
-		xcm::v3::prelude::XCM_VERSION,
+		newer_xcm_version,
 	);
 	// send XCM from AssetHubWestend - ok
 	assert_ok!(send_asset_from_asset_hub_westend(
@@ -134,14 +107,11 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 	assert_bridge_hub_westend_message_accepted(false);
 
 	// set version for remote BridgeHub on BridgeHubWestend
-	BridgeHubWestend::force_xcm_version(
-		bridge_hub_rococo_location(),
-		xcm::v3::prelude::XCM_VERSION,
-	);
+	BridgeHubWestend::force_xcm_version(bridge_hub_rococo_location(), newer_xcm_version);
 	// set version for AssetHubRococo on BridgeHubRococo
 	BridgeHubRococo::force_xcm_version(
 		ParentThen(Parachain(AssetHubRococo::para_id().into()).into()).into(),
-		xcm::v3::prelude::XCM_VERSION,
+		newer_xcm_version,
 	);
 
 	// send XCM from AssetHubWestend - ok
@@ -164,20 +134,4 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() {
 			]
 		);
 	});
-
-	// TODO: remove this block, when removing `xcm:v2`
-	{
-		// set `2` version for remote BridgeHub on BridgeHubRococo, which does not have
-		// `UniversalOrigin` and `DescendOrigin`
-		BridgeHubWestend::force_xcm_version(
-			bridge_hub_rococo_location(),
-			xcm::v2::prelude::XCM_VERSION,
-		);
-
-		// send XCM from AssetHubWestend - ok
-		assert_ok!(send_asset_from_asset_hub_westend(destination, (native_token, amount)));
-		// message is not accepted on the local BridgeHub (`DestinationUnsupported`) because we
-		// cannot add `UniversalOrigin` and `DescendOrigin`
-		assert_bridge_hub_westend_message_accepted(false);
-	}
 }
diff --git a/cumulus/parachains/pallets/collective-content/src/mock.rs b/cumulus/parachains/pallets/collective-content/src/mock.rs
index 5cb0126425e59a67332d880cc8b925f50b1753c2..91f9c29933d91dd9be6f604c28da869317a5003d 100644
--- a/cumulus/parachains/pallets/collective-content/src/mock.rs
+++ b/cumulus/parachains/pallets/collective-content/src/mock.rs
@@ -18,9 +18,7 @@
 pub use crate as pallet_collective_content;
 use crate::WeightInfo;
 use frame_support::{
-	derive_impl, ord_parameter_types, parameter_types,
-	traits::{ConstU32, ConstU64},
-	weights::Weight,
+	derive_impl, ord_parameter_types, parameter_types, traits::ConstU32, weights::Weight,
 };
 use frame_system::EnsureSignedBy;
 use sp_runtime::{traits::IdentityLookup, BuildStorage};
@@ -70,7 +68,6 @@ impl frame_system::Config for Test {
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = ();
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml b/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml
index 95ce7efdf3fba7b67ac54c9542dc862f9f82f2ce..b8670c2957d8f7d176d7216bd210a6d69bd7201f 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml
+++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml
@@ -18,6 +18,7 @@ scale-info = { version = "2.11.1", default-features = false, features = ["derive
 # Substrate
 frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true }
 frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false }
+frame-metadata-hash-extension = { path = "../../../../../substrate/frame/metadata-hash-extension", default-features = false }
 frame-support = { path = "../../../../../substrate/frame/support", default-features = false }
 frame-system = { path = "../../../../../substrate/frame/system", default-features = false }
 frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true }
@@ -27,6 +28,7 @@ pallet-asset-conversion-tx-payment = { path = "../../../../../substrate/frame/tr
 pallet-assets = { path = "../../../../../substrate/frame/assets", default-features = false }
 pallet-asset-conversion-ops = { path = "../../../../../substrate/frame/asset-conversion/ops", default-features = false }
 pallet-asset-conversion = { path = "../../../../../substrate/frame/asset-conversion", default-features = false }
+pallet-assets-freezer = { path = "../../../../../substrate/frame/assets-freezer", default-features = false }
 pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false }
 pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false }
 pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false }
@@ -72,7 +74,7 @@ xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-paym
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = ["bridging"] }
@@ -115,6 +117,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-asset-conversion-ops/runtime-benchmarks",
 	"pallet-asset-conversion/runtime-benchmarks",
+	"pallet-assets-freezer/runtime-benchmarks",
 	"pallet-assets/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
 	"pallet-collator-selection/runtime-benchmarks",
@@ -150,6 +153,7 @@ try-runtime = [
 	"pallet-asset-conversion-ops/try-runtime",
 	"pallet-asset-conversion-tx-payment/try-runtime",
 	"pallet-asset-conversion/try-runtime",
+	"pallet-assets-freezer/try-runtime",
 	"pallet-assets/try-runtime",
 	"pallet-aura/try-runtime",
 	"pallet-authorship/try-runtime",
@@ -189,6 +193,7 @@ std = [
 	"cumulus-primitives-utility/std",
 	"frame-benchmarking?/std",
 	"frame-executive/std",
+	"frame-metadata-hash-extension/std",
 	"frame-support/std",
 	"frame-system-benchmarking?/std",
 	"frame-system-rpc-runtime-api/std",
@@ -198,6 +203,7 @@ std = [
 	"pallet-asset-conversion-ops/std",
 	"pallet-asset-conversion-tx-payment/std",
 	"pallet-asset-conversion/std",
+	"pallet-assets-freezer/std",
 	"pallet-assets/std",
 	"pallet-aura/std",
 	"pallet-authorship/std",
@@ -248,7 +254,10 @@ std = [
 	"xcm/std",
 ]
 
+# Enable the metadata hash generation in the wasm builder.
+metadata-hash = ["substrate-wasm-builder/metadata-hash"]
+
 # A feature that should be enabled when the runtime should be built for on-chain
 # deployment. This will disable stuff that shouldn't be part of the on-chain wasm
 # to make it smaller, like logging for example.
-on-chain-release-build = ["sp-api/disable-logging"]
+on-chain-release-build = ["metadata-hash", "sp-api/disable-logging"]
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs
index 239ccac19ec7778039fb1ee56f4e772b3ddd3711..99e510e22695da8dff3867e84125c68b113f6973 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs
@@ -13,10 +13,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#[cfg(feature = "std")]
+#[cfg(all(not(feature = "metadata-hash"), feature = "std"))]
 fn main() {
 	substrate_wasm_builder::WasmBuilder::build_using_defaults();
 }
 
+#[cfg(all(feature = "metadata-hash", feature = "std"))]
+fn main() {
+	substrate_wasm_builder::WasmBuilder::init_with_defaults()
+		.enable_metadata_hash("ROC", 12)
+		.build();
+}
+
 #[cfg(not(feature = "std"))]
 fn main() {}
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs
index b0df11e1046a370721820911d238ea6af716b243..423f9549edcc8b9f932575111f623a6ec2a23664 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs
@@ -93,15 +93,15 @@ use pallet_xcm::{EnsureXcm, IsVoiceOfBody};
 use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate};
 #[cfg(feature = "runtime-benchmarks")]
 use xcm::latest::prelude::{
-	Asset, Fungible, Here, InteriorLocation, Junction, Junction::*, Location, NetworkId,
-	NonFungible, Parent, ParentThen, Response, XCM_VERSION,
+	Asset, Assets as XcmAssets, Fungible, Here, InteriorLocation, Junction, Junction::*, Location,
+	NetworkId, NonFungible, Parent, ParentThen, Response, XCM_VERSION,
 };
 use xcm::{
 	latest::prelude::{AssetId, BodyId},
-	IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm,
+	VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm,
 };
 use xcm_fee_payment_runtime_api::{
-	dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects},
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
 	fees::Error as XcmPaymentApiError,
 };
 
@@ -118,10 +118,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("statemine"),
 	impl_name: create_runtime_str!("statemine"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
-	transaction_version: 15,
+	transaction_version: 16,
 	state_version: 1,
 };
 
@@ -257,7 +257,7 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = MetadataDepositPerByte;
 	type ApprovalDeposit = ApprovalDeposit;
 	type StringLimit = AssetsStringLimit;
-	type Freezer = ();
+	type Freezer = AssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_local::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -267,6 +267,13 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `Assets` pallet
+pub type AssetsFreezerInstance = pallet_assets_freezer::Instance1;
+impl pallet_assets_freezer::Config<AssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
 	pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0);
@@ -295,7 +302,7 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ConstU128<0>;
 	type ApprovalDeposit = ApprovalDeposit;
 	type StringLimit = ConstU32<50>;
-	type Freezer = ();
+	type Freezer = PoolAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_pool::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -303,6 +310,13 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `PoolAssets` pallet
+pub type PoolAssetsFreezerInstance = pallet_assets_freezer::Instance3;
+impl pallet_assets_freezer::Config<PoolAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 /// Union fungibles implementation for `Assets` and `ForeignAssets`.
 pub type LocalAndForeignAssets = fungibles::UnionOf<
 	Assets,
@@ -411,7 +425,7 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ForeignAssetsMetadataDepositPerByte;
 	type ApprovalDeposit = ForeignAssetsApprovalDeposit;
 	type StringLimit = ForeignAssetsAssetsStringLimit;
-	type Freezer = ();
+	type Freezer = ForeignAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_foreign::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -421,6 +435,13 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type BenchmarkHelper = xcm_config::XcmBenchmarkHelper;
 }
 
+// Allow Freezes for the `ForeignAssets` pallet
+pub type ForeignAssetsFreezerInstance = pallet_assets_freezer::Instance2;
+impl pallet_assets_freezer::Config<ForeignAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	// One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
 	pub const DepositBase: Balance = deposit(1, 88);
@@ -953,6 +974,9 @@ construct_runtime!(
 		NftFractionalization: pallet_nft_fractionalization = 54,
 		PoolAssets: pallet_assets::<Instance3> = 55,
 		AssetConversion: pallet_asset_conversion = 56,
+		AssetsFreezer: pallet_assets_freezer::<Instance1> = 57,
+		ForeignAssetsFreezer: pallet_assets_freezer::<Instance2> = 58,
+		PoolAssetsFreezer: pallet_assets_freezer::<Instance3> = 59,
 
 		// TODO: the pallet instance should be removed once all pools have migrated
 		// to the new account IDs.
@@ -979,6 +1003,7 @@ pub type SignedExtra = (
 	frame_system::CheckWeight<Runtime>,
 	pallet_asset_conversion_tx_payment::ChargeAssetTxPayment<Runtime>,
 	cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim<Runtime>,
+	frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 /// Unchecked extrinsic type as expected by this runtime.
 pub type UncheckedExtrinsic =
@@ -991,10 +1016,15 @@ pub type Migrations = (
 	cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4<Runtime>,
 	cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5<Runtime>,
 	pallet_collator_selection::migration::v2::MigrationToV2<Runtime>,
+	frame_support::migrations::RemovePallet<StateTrieMigrationName, RocksDbWeight>,
 	// permanent
 	pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>,
 );
 
+parameter_types! {
+	pub const StateTrieMigrationName: &'static str = "StateTrieMigration";
+}
+
 /// Migration to initialize storage versions for pallets added after genesis.
 ///
 /// This is now done automatically (see <https://github.com/paritytech/polkadot-sdk/pull/1297>),
@@ -1294,15 +1324,8 @@ impl_runtime_apis! {
 
 	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
 		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
-			let acceptable = vec![
-				// native token
-				VersionedAssetId::from(AssetId(xcm_config::TokenLocation::get()))
-			];
-
-			Ok(acceptable
-				.into_iter()
-				.filter_map(|asset| asset.into_version(xcm_version).ok())
-				.collect())
+			let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
 		}
 
 		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
@@ -1331,67 +1354,13 @@ impl_runtime_apis! {
 		}
 	}
 
-	impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi<Block, RuntimeCall, RuntimeEvent> for Runtime {
-		fn dry_run_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> Result<ExtrinsicDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			use xcm_executor::RecordXcm;
-			use xcm::prelude::*;
-
-			pallet_xcm::Pallet::<Runtime>::set_record_xcm(true);
-			let result = Executive::apply_extrinsic(extrinsic).map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_extrinsic",
-					"Applying extrinsic failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::InvalidExtrinsic
-			})?;
-			let local_xcm = pallet_xcm::Pallet::<Runtime>::recorded_xcm();
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(ExtrinsicDryRunEffects {
-				local_xcm: local_xcm.map(VersionedXcm::<()>::V4),
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
 		}
 
-		fn dry_run_xcm(origin_location: VersionedLocation, program: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			use xcm::prelude::*;
-
-			let origin_location: Location = origin_location.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Location version conversion failed with error: {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let program: Xcm<RuntimeCall> = program.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Xcm version conversion failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let mut hash = program.using_encoded(sp_core::hashing::blake2_256);
-			let result = xcm_executor::XcmExecutor::<xcm_config::XcmConfig>::prepare_and_execute(
-				origin_location,
-				program,
-				&mut hash,
-				Weight::MAX, // Max limit available for execution.
-				Weight::zero(),
-			);
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(XcmDryRunEffects {
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
 		}
 	}
 
@@ -1534,7 +1503,7 @@ impl_runtime_apis! {
 				}
 
 				fn set_up_complex_asset_transfer(
-				) -> Option<(xcm::v4::Assets, u32, Location, Box<dyn FnOnce()>)> {
+				) -> Option<(XcmAssets, u32, Location, Box<dyn FnOnce()>)> {
 					// Transfer to Relay some local AH asset (local-reserve-transfer) while paying
 					// fees using teleported native token.
 					// (We don't care that Relay doesn't accept incoming unknown AH local asset)
@@ -1565,7 +1534,7 @@ impl_runtime_apis! {
 					);
 					let transfer_asset: Asset = (asset_location, asset_amount).into();
 
-					let assets: xcm::v4::Assets = vec![fee_asset.clone(), transfer_asset].into();
+					let assets: XcmAssets = vec![fee_asset.clone(), transfer_asset].into();
 					let fee_index = if assets.get(0).unwrap().eq(&fee_asset) { 0 } else { 1 };
 
 					// verify transferred successfully
@@ -1633,7 +1602,7 @@ impl_runtime_apis! {
 				fn valid_destination() -> Result<Location, BenchmarkError> {
 					Ok(TokenLocation::get())
 				}
-				fn worst_case_holding(depositable_count: u32) -> xcm::v4::Assets {
+				fn worst_case_holding(depositable_count: u32) -> XcmAssets {
 					// A mix of fungible, non-fungible, and concrete assets.
 					let holding_non_fungibles = MaxAssetsIntoHolding::get() / 2 - depositable_count;
 					let holding_fungibles = holding_non_fungibles.saturating_sub(2);  // -2 for two `iter::once` bellow
@@ -1694,15 +1663,13 @@ impl_runtime_apis! {
 					(0u64, Response::Version(Default::default()))
 				}
 
-				fn worst_case_asset_exchange() -> Result<(xcm::v4::Assets, xcm::v4::Assets), BenchmarkError> {
+				fn worst_case_asset_exchange() -> Result<(XcmAssets, XcmAssets), BenchmarkError> {
 					Err(BenchmarkError::Skip)
 				}
 
 				fn universal_alias() -> Result<(Location, Junction), BenchmarkError> {
-					match xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias() {
-						Some(alias) => Ok(alias),
-						None => Err(BenchmarkError::Skip)
-					}
+					xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias()
+					.ok_or(BenchmarkError::Skip)
 				}
 
 				fn transact_origin_and_runtime_call() -> Result<(Location, RuntimeCall), BenchmarkError> {
@@ -1713,9 +1680,9 @@ impl_runtime_apis! {
 					Ok(TokenLocation::get())
 				}
 
-				fn claimable_asset() -> Result<(Location, Location, xcm::v4::Assets), BenchmarkError> {
+				fn claimable_asset() -> Result<(Location, Location, XcmAssets), BenchmarkError> {
 					let origin = TokenLocation::get();
-					let assets: xcm::v4::Assets = (TokenLocation::get(), 1_000 * UNITS).into();
+					let assets: XcmAssets = (TokenLocation::get(), 1_000 * UNITS).into();
 					let ticket = Location { parents: 0, interior: Here };
 					Ok((origin, ticket, assets))
 				}
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs
index 664d2b9c9dd593536404f02d895a414e6c232bfa..cf5a3905e581641fb504d43318cc562c32bca8b8 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs
@@ -699,8 +699,7 @@ pub mod bridging {
 							false => None,
 						}
 					});
-			assert!(alias.is_some(), "we expect here BridgeHubRococo to Westend mapping at least");
-			Some(alias.unwrap())
+			Some(alias.expect("we expect here BridgeHubRococo to Westend mapping at least"))
 		}
 	}
 }
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml b/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml
index 3d27f52d0d5c3a1849c84f433de267c400b92dd1..f310b2e031335910744ffd35f4770f88ac58df86 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml
+++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml
@@ -18,6 +18,7 @@ scale-info = { version = "2.11.1", default-features = false, features = ["derive
 # Substrate
 frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true }
 frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false }
+frame-metadata-hash-extension = { path = "../../../../../substrate/frame/metadata-hash-extension", default-features = false }
 frame-support = { path = "../../../../../substrate/frame/support", default-features = false }
 frame-system = { path = "../../../../../substrate/frame/system", default-features = false }
 frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true }
@@ -27,6 +28,7 @@ pallet-asset-conversion-ops = { path = "../../../../../substrate/frame/asset-con
 pallet-asset-conversion-tx-payment = { path = "../../../../../substrate/frame/transaction-payment/asset-conversion-tx-payment", default-features = false }
 pallet-assets = { path = "../../../../../substrate/frame/assets", default-features = false }
 pallet-asset-conversion = { path = "../../../../../substrate/frame/asset-conversion", default-features = false }
+pallet-assets-freezer = { path = "../../../../../substrate/frame/assets-freezer", default-features = false }
 pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false }
 pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false }
 pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false }
@@ -72,7 +74,7 @@ xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-paym
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
 pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = ["bridging"] }
@@ -114,6 +116,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-asset-conversion-ops/runtime-benchmarks",
 	"pallet-asset-conversion/runtime-benchmarks",
+	"pallet-assets-freezer/runtime-benchmarks",
 	"pallet-assets/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
 	"pallet-collator-selection/runtime-benchmarks",
@@ -149,6 +152,7 @@ try-runtime = [
 	"pallet-asset-conversion-ops/try-runtime",
 	"pallet-asset-conversion-tx-payment/try-runtime",
 	"pallet-asset-conversion/try-runtime",
+	"pallet-assets-freezer/try-runtime",
 	"pallet-assets/try-runtime",
 	"pallet-aura/try-runtime",
 	"pallet-authorship/try-runtime",
@@ -189,6 +193,7 @@ std = [
 	"cumulus-primitives-utility/std",
 	"frame-benchmarking?/std",
 	"frame-executive/std",
+	"frame-metadata-hash-extension/std",
 	"frame-support/std",
 	"frame-system-benchmarking?/std",
 	"frame-system-rpc-runtime-api/std",
@@ -198,6 +203,7 @@ std = [
 	"pallet-asset-conversion-ops/std",
 	"pallet-asset-conversion-tx-payment/std",
 	"pallet-asset-conversion/std",
+	"pallet-assets-freezer/std",
 	"pallet-assets/std",
 	"pallet-aura/std",
 	"pallet-authorship/std",
@@ -247,7 +253,10 @@ std = [
 	"xcm/std",
 ]
 
+# Enable the metadata hash generation in the wasm builder.
+metadata-hash = ["substrate-wasm-builder/metadata-hash"]
+
 # A feature that should be enabled when the runtime should be built for on-chain
 # deployment. This will disable stuff that shouldn't be part of the on-chain wasm
 # to make it smaller, like logging for example.
-on-chain-release-build = ["sp-api/disable-logging"]
+on-chain-release-build = ["metadata-hash", "sp-api/disable-logging"]
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs
index 239ccac19ec7778039fb1ee56f4e772b3ddd3711..cf9664aeb2f3e4ae8cfd74c24c833ba7021a3432 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs
@@ -13,10 +13,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#[cfg(feature = "std")]
+#[cfg(all(not(feature = "metadata-hash"), feature = "std"))]
 fn main() {
 	substrate_wasm_builder::WasmBuilder::build_using_defaults();
 }
 
+#[cfg(all(feature = "metadata-hash", feature = "std"))]
+fn main() {
+	substrate_wasm_builder::WasmBuilder::init_with_defaults()
+		.enable_metadata_hash("WND", 12)
+		.build();
+}
+
 #[cfg(not(feature = "std"))]
 fn main() {}
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
index 062babef18d366a52e946ca9ff36c5737d4e34d3..6764242cc3395ac4a645b60c1bf2ee6066a567d9 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
@@ -85,22 +85,19 @@ pub use sp_runtime::BuildStorage;
 
 use assets_common::{foreign_creators::ForeignCreators, matching::FromSiblingParachain};
 use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate};
-use xcm::{
-	prelude::{VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm},
-	IntoVersion,
-};
+use xcm::prelude::{VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm};
 
 // We exclude `Assets` since it's the name of a pallet
 use xcm::latest::prelude::AssetId;
 
 #[cfg(feature = "runtime-benchmarks")]
 use xcm::latest::prelude::{
-	Asset, Fungible, Here, InteriorLocation, Junction, Junction::*, Location, NetworkId,
-	NonFungible, Parent, ParentThen, Response, XCM_VERSION,
+	Asset, Assets as XcmAssets, Fungible, Here, InteriorLocation, Junction, Junction::*, Location,
+	NetworkId, NonFungible, Parent, ParentThen, Response, XCM_VERSION,
 };
 
 use xcm_fee_payment_runtime_api::{
-	dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects},
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
 	fees::Error as XcmPaymentApiError,
 };
 
@@ -120,10 +117,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("westmint"),
 	impl_name: create_runtime_str!("westmint"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
-	transaction_version: 15,
+	transaction_version: 16,
 	state_version: 1,
 };
 
@@ -258,7 +255,7 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = MetadataDepositPerByte;
 	type ApprovalDeposit = ApprovalDeposit;
 	type StringLimit = AssetsStringLimit;
-	type Freezer = ();
+	type Freezer = AssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_local::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -268,6 +265,13 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `Assets` pallet
+pub type AssetsFreezerInstance = pallet_assets_freezer::Instance1;
+impl pallet_assets_freezer::Config<AssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
 	pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0);
@@ -295,7 +299,7 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ConstU128<0>;
 	type ApprovalDeposit = ConstU128<0>;
 	type StringLimit = ConstU32<50>;
-	type Freezer = ();
+	type Freezer = PoolAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_pool::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -303,6 +307,13 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `PoolAssets` pallet
+pub type PoolAssetsFreezerInstance = pallet_assets_freezer::Instance3;
+impl pallet_assets_freezer::Config<PoolAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 /// Union fungibles implementation for `Assets` and `ForeignAssets`.
 pub type LocalAndForeignAssets = fungibles::UnionOf<
 	Assets,
@@ -408,7 +419,7 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ForeignAssetsMetadataDepositPerByte;
 	type ApprovalDeposit = ForeignAssetsApprovalDeposit;
 	type StringLimit = ForeignAssetsAssetsStringLimit;
-	type Freezer = ();
+	type Freezer = ForeignAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_foreign::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -418,6 +429,13 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type BenchmarkHelper = xcm_config::XcmBenchmarkHelper;
 }
 
+// Allow Freezes for the `ForeignAssets` pallet
+pub type ForeignAssetsFreezerInstance = pallet_assets_freezer::Instance2;
+impl pallet_assets_freezer::Config<ForeignAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	// One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
 	pub const DepositBase: Balance = deposit(1, 88);
@@ -946,6 +964,9 @@ construct_runtime!(
 		NftFractionalization: pallet_nft_fractionalization = 54,
 		PoolAssets: pallet_assets::<Instance3> = 55,
 		AssetConversion: pallet_asset_conversion = 56,
+		AssetsFreezer: pallet_assets_freezer::<Instance1> = 57,
+		ForeignAssetsFreezer: pallet_assets_freezer::<Instance2> = 58,
+		PoolAssetsFreezer: pallet_assets_freezer::<Instance3> = 59,
 
 		StateTrieMigration: pallet_state_trie_migration = 70,
 
@@ -974,6 +995,7 @@ pub type SignedExtra = (
 	frame_system::CheckWeight<Runtime>,
 	pallet_asset_conversion_tx_payment::ChargeAssetTxPayment<Runtime>,
 	cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim<Runtime>,
+	frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 /// Unchecked extrinsic type as expected by this runtime.
 pub type UncheckedExtrinsic =
@@ -1330,15 +1352,8 @@ impl_runtime_apis! {
 
 	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
 		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
-			let acceptable = vec![
-				// native token
-				VersionedAssetId::from(AssetId(xcm_config::WestendLocation::get()))
-			];
-
-			Ok(acceptable
-				.into_iter()
-				.filter_map(|asset| asset.into_version(xcm_version).ok())
-				.collect())
+			let acceptable_assets = vec![AssetId(xcm_config::WestendLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
 		}
 
 		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
@@ -1367,67 +1382,13 @@ impl_runtime_apis! {
 		}
 	}
 
-	impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi<Block, RuntimeCall, RuntimeEvent> for Runtime {
-		fn dry_run_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> Result<ExtrinsicDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			use xcm_executor::RecordXcm;
-			use xcm::prelude::*;
-
-			pallet_xcm::Pallet::<Runtime>::set_record_xcm(true);
-			let result = Executive::apply_extrinsic(extrinsic).map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_extrinsic",
-					"Applying extrinsic failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::InvalidExtrinsic
-			})?;
-			let local_xcm = pallet_xcm::Pallet::<Runtime>::recorded_xcm();
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(ExtrinsicDryRunEffects {
-				local_xcm: local_xcm.map(VersionedXcm::<()>::V4),
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
 		}
 
-		fn dry_run_xcm(origin_location: VersionedLocation, program: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			use xcm::prelude::*;
-
-			let origin_location: Location = origin_location.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Location version conversion failed with error: {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let program: Xcm<RuntimeCall> = program.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Xcm version conversion failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let mut hash = program.using_encoded(sp_core::hashing::blake2_256);
-			let result = xcm_executor::XcmExecutor::<xcm_config::XcmConfig>::prepare_and_execute(
-				origin_location,
-				program,
-				&mut hash,
-				Weight::MAX, // Max limit available for execution.
-				Weight::zero(),
-			);
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(XcmDryRunEffects {
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
 		}
 	}
 
@@ -1628,7 +1589,7 @@ impl_runtime_apis! {
 				}
 
 				fn set_up_complex_asset_transfer(
-				) -> Option<(xcm::v4::Assets, u32, Location, Box<dyn FnOnce()>)> {
+				) -> Option<(XcmAssets, u32, Location, Box<dyn FnOnce()>)> {
 					// Transfer to Relay some local AH asset (local-reserve-transfer) while paying
 					// fees using teleported native token.
 					// (We don't care that Relay doesn't accept incoming unknown AH local asset)
@@ -1659,7 +1620,7 @@ impl_runtime_apis! {
 					);
 					let transfer_asset: Asset = (asset_location, asset_amount).into();
 
-					let assets: xcm::v4::Assets = vec![fee_asset.clone(), transfer_asset].into();
+					let assets: XcmAssets = vec![fee_asset.clone(), transfer_asset].into();
 					let fee_index = if assets.get(0).unwrap().eq(&fee_asset) { 0 } else { 1 };
 
 					// verify transferred successfully
@@ -1732,7 +1693,7 @@ impl_runtime_apis! {
 				fn valid_destination() -> Result<Location, BenchmarkError> {
 					Ok(WestendLocation::get())
 				}
-				fn worst_case_holding(depositable_count: u32) -> xcm::v4::Assets {
+				fn worst_case_holding(depositable_count: u32) -> XcmAssets {
 					// A mix of fungible, non-fungible, and concrete assets.
 					let holding_non_fungibles = MaxAssetsIntoHolding::get() / 2 - depositable_count;
 					let holding_fungibles = holding_non_fungibles - 2; // -2 for two `iter::once` bellow
@@ -1793,15 +1754,13 @@ impl_runtime_apis! {
 					(0u64, Response::Version(Default::default()))
 				}
 
-				fn worst_case_asset_exchange() -> Result<(xcm::v4::Assets, xcm::v4::Assets), BenchmarkError> {
+				fn worst_case_asset_exchange() -> Result<(XcmAssets, XcmAssets), BenchmarkError> {
 					Err(BenchmarkError::Skip)
 				}
 
 				fn universal_alias() -> Result<(Location, Junction), BenchmarkError> {
-					match xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias() {
-						Some(alias) => Ok(alias),
-						None => Err(BenchmarkError::Skip)
-					}
+					xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias()
+					.ok_or(BenchmarkError::Skip)
 				}
 
 				fn transact_origin_and_runtime_call() -> Result<(Location, RuntimeCall), BenchmarkError> {
@@ -1812,9 +1771,9 @@ impl_runtime_apis! {
 					Ok(WestendLocation::get())
 				}
 
-				fn claimable_asset() -> Result<(Location, Location, xcm::v4::Assets), BenchmarkError> {
+				fn claimable_asset() -> Result<(Location, Location, XcmAssets), BenchmarkError> {
 					let origin = WestendLocation::get();
-					let assets: xcm::v4::Assets = (AssetId(WestendLocation::get()), 1_000 * UNITS).into();
+					let assets: XcmAssets = (AssetId(WestendLocation::get()), 1_000 * UNITS).into();
 					let ticket = Location { parents: 0, interior: Here };
 					Ok((origin, ticket, assets))
 				}
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs
index 35a42627ad71004642b278bba1ff1a564929061f..ff1fc99cba8a7f982ab7f2a58602a48ab3420701 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs
@@ -648,8 +648,7 @@ pub mod bridging {
 						false => None,
 					}
 				});
-			assert!(alias.is_some(), "we expect here BridgeHubWestend to Rococo mapping at least");
-			Some(alias.unwrap())
+			Some(alias.expect("we expect here BridgeHubWestend to Rococo mapping at least"))
 		}
 	}
 }
diff --git a/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml b/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml
index 776c7dce0b486d30fcf967bea01333df199789b1..af5b4a64680724abcbf0d659ba8a7b2b45cd0e80 100644
--- a/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml
+++ b/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml
@@ -24,7 +24,7 @@ sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-fea
 sp-std = { path = "../../../../../substrate/primitives/std", default-features = false }
 
 # Cumulus
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
 pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false }
 parachains-common = { path = "../../../common", default-features = false }
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml
index 0fb12531b8ee8f3bed0cb3266f19a188150217e5..5e8639eed36b99413e66684ce627ae049eb6d0ad 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml
@@ -22,7 +22,6 @@ scale-info = { version = "2.11.1", default-features = false, features = [
 	"derive",
 ] }
 serde = { optional = true, features = ["derive"], workspace = true, default-features = true }
-tuplex = { version = "0.1", default-features = false }
 
 # Substrate
 frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true }
@@ -66,12 +65,11 @@ polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", def
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = [
-	"parameterized-consensus-hook",
-] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = [
@@ -219,9 +217,9 @@ std = [
 	"sp-version/std",
 	"substrate-wasm-builder",
 	"testnet-parachains-constants/std",
-	"tuplex/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
@@ -264,6 +262,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 
 try-runtime = [
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs
index 9043175a701c75c1240ccd5904bf512ece68697f..12707d78550092a254fae909cbfee12f7ef0ca96 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs
@@ -70,7 +70,7 @@ use frame_support::{
 	genesis_builder_helper::{build_state, get_preset},
 	parameter_types,
 	traits::{ConstBool, ConstU32, ConstU64, ConstU8, Get, TransformOrigin},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::{
@@ -97,7 +97,11 @@ pub use sp_runtime::BuildStorage;
 
 use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate};
 use rococo_runtime_constants::system_parachain::{ASSET_HUB_ID, BRIDGE_HUB_ID};
-use xcm::latest::prelude::*;
+use xcm::prelude::*;
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
 
@@ -210,7 +214,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("bridge-hub-rococo"),
 	impl_name: create_runtime_str!("bridge-hub-rococo"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 5,
@@ -962,6 +966,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::TokenLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs
index 8c2435599f59780be56dcaa5060addee4c5c1d15..11e1439a1f6df2423421faf85ce6dd75c37e045b 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs
@@ -16,10 +16,10 @@
 
 //! Autogenerated weights for `pallet_bridge_grandpa`
 //!
-//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2024-05-23, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-vicqj8em-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-rococo-dev")`, DB CACHE: 1024
 
 // Executed Command:
@@ -48,32 +48,52 @@ use core::marker::PhantomData;
 /// Weight functions for `pallet_bridge_grandpa`.
 pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_bridge_grandpa::WeightInfo for WeightInfo<T> {
+	/// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:0)
+	/// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeWestendGrandpa::PalletOperatingMode` (r:1 w:0)
 	/// Proof: `BridgeWestendGrandpa::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeWestendGrandpa::BestFinalized` (r:1 w:1)
 	/// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`)
-	/// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:0)
-	/// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::FreeHeadersRemaining` (r:1 w:0)
+	/// Proof: `BridgeWestendGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1)
 	/// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeWestendGrandpa::ImportedHashes` (r:1 w:1)
 	/// Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0 w:2)
 	/// Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`)
-	/// The range of component `p` is `[1, 838]`.
+	/// The range of component `p` is `[1, 168]`.
 	/// The range of component `v` is `[50, 100]`.
-	fn submit_finality_proof(p: u32, v: u32, ) -> Weight {
+	fn submit_finality_proof(p: u32, _v: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `335 + p * (60 ±0)`
+		//  Measured:  `438 + p * (60 ±0)`
 		//  Estimated: `51735`
-		// Minimum execution time: 310_124_000 picoseconds.
-		Weight::from_parts(18_294_977, 0)
+		// Minimum execution time: 300_829_000 picoseconds.
+		Weight::from_parts(321_573_000, 0)
 			.saturating_add(Weight::from_parts(0, 51735))
-			// Standard Error: 5_665
-			.saturating_add(Weight::from_parts(55_380_719, 0).saturating_mul(p.into()))
-			// Standard Error: 94_494
-			.saturating_add(Weight::from_parts(2_765_959, 0).saturating_mul(v.into()))
-			.saturating_add(T::DbWeight::get().reads(5))
+			// Standard Error: 25_917
+			.saturating_add(Weight::from_parts(48_613_160, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(6))
 			.saturating_add(T::DbWeight::get().writes(5))
 	}
+	/// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:1)
+	/// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1)
+	/// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::ImportedHashes` (r:1 w:1)
+	/// Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::BestFinalized` (r:0 w:1)
+	/// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0 w:2)
+	/// Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`)
+	fn force_set_pallet_state() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `452`
+		//  Estimated: `51735`
+		// Minimum execution time: 101_007_000 picoseconds.
+		Weight::from_parts(129_904_000, 0)
+			.saturating_add(Weight::from_parts(0, 51735))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(6))
+	}
 }
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml
index 3fbb95a17d04744c896047554c3ceb1b1e610676..ba8e4cdc8147cca39cf0432cb72bdb924672169a 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml
@@ -18,7 +18,6 @@ hex-literal = { version = "0.4.1" }
 log = { workspace = true }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 serde = { optional = true, features = ["derive"], workspace = true, default-features = true }
-tuplex = { version = "0.1", default-features = false }
 
 # Substrate
 frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true }
@@ -62,10 +61,11 @@ polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", def
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = ["bridging"] }
@@ -181,10 +181,10 @@ std = [
 	"sp-version/std",
 	"substrate-wasm-builder",
 	"testnet-parachains-constants/std",
-	"tuplex/std",
 	"westend-runtime-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
@@ -219,6 +219,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 
 try-runtime = [
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs
index 50911b4d780fd2a553c1f7eac2f3b7146765cb15..6b2d67e29c4a6e5f4bf1bc0b2b95c0d727f2a4fb 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs
@@ -64,7 +64,7 @@ use frame_support::{
 	genesis_builder_helper::{build_state, get_preset},
 	parameter_types,
 	traits::{ConstBool, ConstU32, ConstU64, ConstU8, Get, TransformOrigin},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::{
@@ -75,13 +75,18 @@ pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 pub use sp_runtime::{MultiAddress, Perbill, Permill};
 use xcm_config::{XcmOriginToTransactDispatchOrigin, XcmRouter};
 
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
+
 use bp_runtime::HeaderId;
 
 #[cfg(any(feature = "std", test))]
 pub use sp_runtime::BuildStorage;
 
 use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate};
-use xcm::latest::prelude::*;
+use xcm::prelude::*;
 
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
 
@@ -184,7 +189,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("bridge-hub-westend"),
 	impl_name: create_runtime_str!("bridge-hub-westend"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 5,
@@ -711,6 +716,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::WestendLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::WestendLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs
index e87ed668dfc7acb1a92a7535d92392a272370277..e98be6ba39be74c3532290ea4a7b483640466c10 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs
+++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs
@@ -16,10 +16,10 @@
 
 //! Autogenerated weights for `pallet_bridge_grandpa`
 //!
-//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-12-13, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2024-05-23, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-vicqj8em-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-westend-dev")`, DB CACHE: 1024
 
 // Executed Command:
@@ -48,32 +48,54 @@ use core::marker::PhantomData;
 /// Weight functions for `pallet_bridge_grandpa`.
 pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_bridge_grandpa::WeightInfo for WeightInfo<T> {
+	/// Storage: `BridgeRococoGrandpa::CurrentAuthoritySet` (r:1 w:0)
+	/// Proof: `BridgeRococoGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeRococoGrandpa::PalletOperatingMode` (r:1 w:0)
 	/// Proof: `BridgeRococoGrandpa::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeRococoGrandpa::BestFinalized` (r:1 w:1)
 	/// Proof: `BridgeRococoGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`)
-	/// Storage: `BridgeRococoGrandpa::CurrentAuthoritySet` (r:1 w:0)
-	/// Proof: `BridgeRococoGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeRococoGrandpa::FreeHeadersRemaining` (r:1 w:0)
+	/// Proof: `BridgeRococoGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeRococoGrandpa::ImportedHashesPointer` (r:1 w:1)
 	/// Proof: `BridgeRococoGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeRococoGrandpa::ImportedHashes` (r:1 w:1)
 	/// Proof: `BridgeRococoGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`)
 	/// Storage: `BridgeRococoGrandpa::ImportedHeaders` (r:0 w:2)
 	/// Proof: `BridgeRococoGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`)
-	/// The range of component `p` is `[1, 838]`.
+	/// The range of component `p` is `[1, 168]`.
 	/// The range of component `v` is `[50, 100]`.
 	fn submit_finality_proof(p: u32, v: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `231 + p * (60 ±0)`
+		//  Measured:  `268 + p * (60 ±0)`
 		//  Estimated: `51735`
-		// Minimum execution time: 303_549_000 picoseconds.
-		Weight::from_parts(306_232_000, 0)
+		// Minimum execution time: 291_721_000 picoseconds.
+		Weight::from_parts(37_495_589, 0)
 			.saturating_add(Weight::from_parts(0, 51735))
-			// Standard Error: 4_641
-			.saturating_add(Weight::from_parts(55_196_301, 0).saturating_mul(p.into()))
-			// Standard Error: 35_813
-			.saturating_add(Weight::from_parts(70_584, 0).saturating_mul(v.into()))
-			.saturating_add(T::DbWeight::get().reads(5))
+			// Standard Error: 22_170
+			.saturating_add(Weight::from_parts(45_403_072, 0).saturating_mul(p.into()))
+			// Standard Error: 73_977
+			.saturating_add(Weight::from_parts(2_130_216, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().reads(6))
 			.saturating_add(T::DbWeight::get().writes(5))
 	}
+	/// Storage: `BridgeRococoGrandpa::CurrentAuthoritySet` (r:1 w:1)
+	/// Proof: `BridgeRococoGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeRococoGrandpa::ImportedHashesPointer` (r:1 w:1)
+	/// Proof: `BridgeRococoGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeRococoGrandpa::ImportedHashes` (r:1 w:1)
+	/// Proof: `BridgeRococoGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeRococoGrandpa::BestFinalized` (r:0 w:1)
+	/// Proof: `BridgeRococoGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`)
+	/// Storage: `BridgeRococoGrandpa::ImportedHeaders` (r:0 w:2)
+	/// Proof: `BridgeRococoGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`)
+	fn force_set_pallet_state() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `282`
+		//  Estimated: `51735`
+		// Minimum execution time: 77_426_000 picoseconds.
+		Weight::from_parts(90_926_000, 0)
+			.saturating_add(Weight::from_parts(0, 51735))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(6))
+	}
 }
diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml b/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml
index 5a8fa18b92901dc20f0b19520bacb35f6b52f72c..80f0114cc4cadb6cd7871454eead80a0988d5e7e 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml
+++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml
@@ -29,7 +29,7 @@ pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-
 
 # Cumulus
 asset-test-utils = { path = "../../assets/test-utils" }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
 parachains-common = { path = "../../../common", default-features = false }
 parachains-runtimes-test-utils = { path = "../../test-utils", default-features = false }
diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs
index 9285a1e7ad4500a4c2c7db73d9966dd711d852be..ee3fc1ed2c41f1ff2a729dcf784f832a5a563a58 100644
--- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs
+++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs
@@ -39,8 +39,8 @@ pub fn prepare_inbound_xcm<InnerXcmRuntimeCall>(
 	xcm_message: Xcm<InnerXcmRuntimeCall>,
 	destination: InteriorLocation,
 ) -> Vec<u8> {
-	let location = xcm::VersionedInteriorLocation::V4(destination);
-	let xcm = xcm::VersionedXcm::<InnerXcmRuntimeCall>::V4(xcm_message);
+	let location = xcm::VersionedInteriorLocation::from(destination);
+	let xcm = xcm::VersionedXcm::<InnerXcmRuntimeCall>::from(xcm_message);
 	// this is the `BridgeMessage` from polkadot xcm builder, but it has no constructor
 	// or public fields, so just tuple
 	// (double encoding, because `.encode()` is called on original Xcm BLOB when it is pushed
diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml b/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml
index a7f517222420dce6ee44e6590a51a3e3f101cf0b..fe4de3114be0d0b92643946f0deafe030a8b88f8 100644
--- a/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml
+++ b/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml
@@ -66,12 +66,13 @@ polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", def
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/constants", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
 pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
@@ -130,6 +131,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 try-runtime = [
 	"cumulus-pallet-aura-ext/try-runtime",
@@ -236,6 +238,7 @@ std = [
 	"westend-runtime-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs
index 6a4a182079671f297d18bc40de0bc557911735cd..6f13c3d9d5dec23021ce5207b42993a29319f23e 100644
--- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs
+++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs
@@ -55,8 +55,6 @@ use xcm_builder::{AliasesIntoAccountId32, PayOverXcm};
 
 #[cfg(feature = "runtime-benchmarks")]
 use crate::impls::benchmarks::{OpenHrmpChannel, PayWithEnsure};
-#[cfg(feature = "runtime-benchmarks")]
-use testnet_parachains_constants::westend::currency::DOLLARS;
 
 /// The Fellowship members' ranks.
 pub mod ranks {
@@ -270,16 +268,6 @@ parameter_types! {
 	pub SelfParaId: ParaId = ParachainInfo::parachain_id();
 }
 
-#[cfg(feature = "runtime-benchmarks")]
-parameter_types! {
-	// Benchmark bond. Needed to make `propose_spend` work.
-	pub const TenPercent: Permill = Permill::from_percent(10);
-	// Benchmark minimum. Needed to make `propose_spend` work.
-	pub const BenchmarkProposalBondMinimum: Balance = 1 * DOLLARS;
-	// Benchmark maximum. Needed to make `propose_spend` work.
-	pub const BenchmarkProposalBondMaximum: Balance = 10 * DOLLARS;
-}
-
 /// [`PayOverXcm`] setup to pay the Fellowship Treasury.
 pub type FellowshipTreasuryPaymaster = PayOverXcm<
 	FellowshipTreasuryInteriorLocation,
@@ -302,20 +290,6 @@ impl pallet_treasury::Config<FellowshipTreasuryInstance> for Runtime {
 	// TODO: replace with `NeverEnsure` once polkadot-sdk 1.5 is released.
 	type ApproveOrigin = NeverEnsureOrigin<()>;
 	type OnSlash = ();
-	#[cfg(not(feature = "runtime-benchmarks"))]
-	type ProposalBond = HundredPercent;
-	#[cfg(not(feature = "runtime-benchmarks"))]
-	type ProposalBondMinimum = MaxBalance;
-	#[cfg(not(feature = "runtime-benchmarks"))]
-	type ProposalBondMaximum = MaxBalance;
-
-	#[cfg(feature = "runtime-benchmarks")]
-	type ProposalBond = TenPercent;
-	#[cfg(feature = "runtime-benchmarks")]
-	type ProposalBondMinimum = BenchmarkProposalBondMinimum;
-	#[cfg(feature = "runtime-benchmarks")]
-	type ProposalBondMaximum = BenchmarkProposalBondMaximum;
-	// end.
 
 	type WeightInfo = weights::pallet_treasury::WeightInfo<Runtime>;
 	type PalletId = FellowshipTreasuryPalletId;
diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs
index 5cb24c4edb717fd1759d1deab3759ae1f796f680..1d3b8c4581a834dca11013e20e7c4fecadb5e61c 100644
--- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs
@@ -73,7 +73,7 @@ use frame_support::{
 		fungible::HoldConsideration, ConstBool, ConstU16, ConstU32, ConstU64, ConstU8,
 		EitherOfDiverse, InstanceFilter, LinearStoragePrice, TransformOrigin,
 	},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::{
@@ -103,7 +103,11 @@ use pallet_xcm::{EnsureXcm, IsVoiceOfBody};
 use polkadot_runtime_common::{
 	impls::VersionedLocatableAsset, BlockHashCount, SlowAdjustingFeeUpdate,
 };
-use xcm::latest::{prelude::*, BodyId};
+use xcm::prelude::*;
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
 
@@ -118,7 +122,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("collectives-westend"),
 	impl_name: create_runtime_str!("collectives-westend"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 6,
@@ -936,6 +940,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::WndLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::WndLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs
index f40940a8b25faa7c441b1ac9b237cb34e671cf17..dbe681f51bb2a8a1f61f9e923e16914dd2eb2fd8 100644
--- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs
+++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs
@@ -58,6 +58,17 @@ impl<T: frame_system::Config> pallet_core_fellowship::WeightInfo for WeightInfo<
 			.saturating_add(Weight::from_parts(0, 0))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
+	/// Storage: `AmbassadorCore::Params` (r:0 w:1)
+	/// Proof: `AmbassadorCore::Params` (`max_values`: Some(1), `max_size`: Some(364), added: 859, mode: `MaxEncodedLen`)
+	fn set_partial_params() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 11_000_000 picoseconds.
+		Weight::from_parts(11_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
 	/// Storage: `AmbassadorCore::Member` (r:1 w:1)
 	/// Proof: `AmbassadorCore::Member` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`)
 	/// Storage: `AmbassadorCollective::Members` (r:1 w:1)
diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs
index 471ee82ead729ea5abff616f0c9fe3a86704fd91..7e6264c0c10d708f1a089cb861094e121f0c5604 100644
--- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs
+++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs
@@ -57,6 +57,17 @@ impl<T: frame_system::Config> pallet_core_fellowship::WeightInfo for WeightInfo<
 			.saturating_add(Weight::from_parts(0, 0))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
+	/// Storage: `FellowshipCore::Params` (r:0 w:1)
+	/// Proof: `FellowshipCore::Params` (`max_values`: Some(1), `max_size`: Some(364), added: 859, mode: `MaxEncodedLen`)
+	fn set_partial_params() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 11_000_000 picoseconds.
+		Weight::from_parts(12_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
 	/// Storage: `FellowshipCore::Member` (r:1 w:1)
 	/// Proof: `FellowshipCore::Member` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`)
 	/// Storage: `FellowshipCollective::Members` (r:1 w:1)
diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs
index 58540e646d8c3885bf84da512e2ddc3e42abc80e..5c513c3754ce84605465aa48ac43e7731e798d2a 100644
--- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs
+++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs
@@ -62,43 +62,6 @@ impl<T: frame_system::Config> pallet_treasury::WeightInfo for WeightInfo<T> {
 			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().writes(3))
 	}
-	/// Storage: `FellowshipTreasury::ProposalCount` (r:1 w:1)
-	/// Proof: `FellowshipTreasury::ProposalCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `FellowshipTreasury::Proposals` (r:0 w:1)
-	/// Proof: `FellowshipTreasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	fn propose_spend() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `143`
-		//  Estimated: `1489`
-		// Minimum execution time: 264_000_000 picoseconds.
-		Weight::from_parts(277_000_000, 0)
-			.saturating_add(Weight::from_parts(0, 1489))
-			.saturating_add(T::DbWeight::get().reads(1))
-			.saturating_add(T::DbWeight::get().writes(2))
-	}
-	/// Storage: `FellowshipTreasury::Proposals` (r:1 w:1)
-	/// Proof: `FellowshipTreasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:1 w:1)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
-	fn reject_proposal() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `301`
-		//  Estimated: `3593`
-		// Minimum execution time: 289_000_000 picoseconds.
-		Weight::from_parts(312_000_000, 0)
-			.saturating_add(Weight::from_parts(0, 3593))
-			.saturating_add(T::DbWeight::get().reads(2))
-			.saturating_add(T::DbWeight::get().writes(2))
-	}
-	/// The range of component `p` is `[0, 99]`.
-	fn approve_proposal(_p: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 0_000 picoseconds.
-		Weight::from_parts(0, 0)
-			.saturating_add(Weight::from_parts(0, 0))
-	}
 	/// Storage: `FellowshipTreasury::Approvals` (r:1 w:1)
 	/// Proof: `FellowshipTreasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`)
 	fn remove_approval() -> Weight {
diff --git a/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml b/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml
index 4040e977fafd244f238986d6da268f997836bfd9..e43a69482c79f1d67e30d6c65ea67840a7893816 100644
--- a/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml
+++ b/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml
@@ -63,11 +63,12 @@ rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/cons
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
 pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
@@ -140,6 +141,7 @@ std = [
 	"testnet-parachains-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
@@ -169,6 +171,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 
 try-runtime = [
diff --git a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs
index 85a85e7086cb0d2ba62e3e315ac1870933966be8..59aae99d6a16169e7df72ff1fa9c8570fc56f855 100644
--- a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs
+++ b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs
@@ -51,7 +51,7 @@ use frame_support::{
 	genesis_builder_helper::{build_state, get_preset},
 	parameter_types,
 	traits::{ConstBool, ConstU16, ConstU32, ConstU64, ConstU8},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::limits::{BlockLength, BlockWeights};
@@ -62,7 +62,12 @@ use parachains_common::{
 };
 pub use parachains_common::{AuraId, Balance};
 use testnet_parachains_constants::rococo::{consensus::*, currency::*, fee::WeightToFee, time::*};
+use xcm::prelude::*;
 use xcm_config::CollatorSelectionUpdateOrigin;
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 #[cfg(any(feature = "std", test))]
 pub use sp_runtime::BuildStorage;
@@ -137,7 +142,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("contracts-rococo"),
 	impl_name: create_runtime_str!("contracts-rococo"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 7,
@@ -585,6 +590,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::RelayLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml b/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml
index b92dc57989cf02d6e64c18eb05af963a00f960d7..dc99fe331f78671b0b43842e0762db8bd96a840b 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml
+++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml
@@ -62,10 +62,11 @@ rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/cons
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
@@ -138,6 +139,7 @@ std = [
 	"testnet-parachains-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
@@ -167,6 +169,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 
 try-runtime = [
diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs
index 742dd50f6fa1f421d6ce4abf221e05f6902cc2ae..ec3a4f31202fd5f5333a1057bb06ca5dde247619 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs
+++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs
@@ -232,5 +232,5 @@ impl pallet_broker::Config for Runtime {
 	type WeightInfo = weights::pallet_broker::WeightInfo<Runtime>;
 	type PalletId = BrokerPalletId;
 	type AdminOrigin = EnsureRoot<AccountId>;
-	type PriceAdapter = pallet_broker::Linear;
+	type PriceAdapter = pallet_broker::CenterTargetPrice<Balance>;
 }
diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs
index 4f4935de133bf34c9950272e80ff5be2172c0b34..522ee574176a2733b357100599cedd1f3ce986b2 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs
+++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs
@@ -41,7 +41,7 @@ use frame_support::{
 	genesis_builder_helper::{build_state, get_preset},
 	parameter_types,
 	traits::{ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, TransformOrigin},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::{
@@ -72,10 +72,14 @@ use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 use testnet_parachains_constants::rococo::{consensus::*, currency::*, fee::WeightToFee, time::*};
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
-use xcm::latest::prelude::*;
+use xcm::prelude::*;
 use xcm_config::{
 	FellowshipLocation, GovernanceLocation, RocRelayLocation, XcmOriginToTransactDispatchOrigin,
 };
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 /// The address format for describing accounts.
 pub type Address = MultiAddress<AccountId, ()>;
@@ -112,6 +116,7 @@ pub type Migrations = (
 	cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4<Runtime>,
 	cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5<Runtime>,
 	pallet_broker::migration::MigrateV0ToV1<Runtime>,
+	pallet_broker::migration::MigrateV1ToV2<Runtime>,
 	// permanent
 	pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>,
 );
@@ -137,7 +142,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("coretime-rococo"),
 	impl_name: create_runtime_str!("coretime-rococo"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
@@ -655,6 +660,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::RocRelayLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::RocRelayLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs
index 89b1c4c86632ff0d19ee4fe1428978303ef92082..5c9175a18d98a0b6c0c791945dcd9f2cd1892cc4 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs
+++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs
@@ -154,8 +154,8 @@ impl<T: frame_system::Config> pallet_broker::WeightInfo for WeightInfo<T> {
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::SaleInfo` (r:1 w:1)
 	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:2)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:2)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:0)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Workplan` (r:0 w:1)
@@ -337,8 +337,8 @@ impl<T: frame_system::Config> pallet_broker::WeightInfo for WeightInfo<T> {
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:1)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:1)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	fn drop_renewal() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `957`
diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml b/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml
index a377e243af3a80b4a2643bc0f142a00a126d2ead..78018537f5d3ce07d75ed8a465d5e17dba157028 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml
+++ b/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml
@@ -61,10 +61,11 @@ westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/co
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
@@ -137,6 +138,7 @@ std = [
 	"westend-runtime-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
@@ -165,6 +167,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 
 try-runtime = [
diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs
index 41cbc62fa2115ff3828e6910b750622a91ff0251..a5e219b9897e0710e008ffa6b800624710877bcc 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs
+++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs
@@ -245,5 +245,5 @@ impl pallet_broker::Config for Runtime {
 	type WeightInfo = weights::pallet_broker::WeightInfo<Runtime>;
 	type PalletId = BrokerPalletId;
 	type AdminOrigin = EnsureRoot<AccountId>;
-	type PriceAdapter = pallet_broker::Linear;
+	type PriceAdapter = pallet_broker::CenterTargetPrice<Balance>;
 }
diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs
index fca1b0e7c6ec4146300e996233ed3962dc6b5c23..8830f1a42a2a1b30cb8af7ba94d55e48b1536c44 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs
@@ -41,7 +41,7 @@ use frame_support::{
 	genesis_builder_helper::{build_state, get_preset},
 	parameter_types,
 	traits::{ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, TransformOrigin},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::{
@@ -72,10 +72,14 @@ use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 use testnet_parachains_constants::westend::{consensus::*, currency::*, fee::WeightToFee, time::*};
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
-use xcm::latest::prelude::*;
+use xcm::prelude::*;
 use xcm_config::{
 	FellowshipLocation, GovernanceLocation, TokenRelayLocation, XcmOriginToTransactDispatchOrigin,
 };
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 /// The address format for describing accounts.
 pub type Address = MultiAddress<AccountId, ()>;
@@ -111,6 +115,7 @@ pub type Migrations = (
 	pallet_collator_selection::migration::v2::MigrationToV2<Runtime>,
 	cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4<Runtime>,
 	pallet_broker::migration::MigrateV0ToV1<Runtime>,
+	pallet_broker::migration::MigrateV1ToV2<Runtime>,
 	// permanent
 	pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>,
 );
@@ -136,7 +141,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("coretime-westend"),
 	impl_name: create_runtime_str!("coretime-westend"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
@@ -646,6 +651,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::TokenRelayLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::TokenRelayLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs
index 13d5fcf3898bcc07fce13c7ee2deeb8c2b9fa76f..7e1c832a90924e39c7bc7d7b24d8163ce5d65589 100644
--- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs
+++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs
@@ -152,8 +152,8 @@ impl<T: frame_system::Config> pallet_broker::WeightInfo for WeightInfo<T> {
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::SaleInfo` (r:1 w:1)
 	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:2)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:2)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:1 w:0)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Workplan` (r:0 w:1)
@@ -335,8 +335,8 @@ impl<T: frame_system::Config> pallet_broker::WeightInfo for WeightInfo<T> {
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:1)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:1)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	fn drop_renewal() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `556`
diff --git a/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml b/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml
index ccd73fb5ee6a68ac5eb8797ad22c14f8072987d8..92a5bbbd1376088909f315371dff6be13ffa69af 100644
--- a/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml
+++ b/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml
@@ -47,7 +47,7 @@ xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkad
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false }
 cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false }
diff --git a/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs b/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs
index b4ee0f5ae7108dcf8d711aea8522ec3c41d9673f..b8a328c3db696100a558e355286463e524f2f931 100644
--- a/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs
@@ -100,7 +100,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("glutton-westend"),
 	impl_name: create_runtime_str!("glutton-westend"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
@@ -296,6 +296,7 @@ pub type SignedExtra = (
 	frame_system::CheckGenesis<Runtime>,
 	frame_system::CheckEra<Runtime>,
 	frame_system::CheckNonce<Runtime>,
+	frame_system::CheckWeight<Runtime>,
 );
 /// Unchecked extrinsic type as expected by this runtime.
 pub type UncheckedExtrinsic =
diff --git a/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml b/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml
index 2b990d9270fb90dc5919d78f8caa0c88abc09c8c..d4e65da3cd6426f7a21a2c96d03d53d8161410fb 100644
--- a/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml
+++ b/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml
@@ -59,10 +59,11 @@ rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/cons
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
@@ -135,6 +136,7 @@ std = [
 	"testnet-parachains-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
@@ -163,6 +165,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 
 try-runtime = [
diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs b/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs
index 68e34a0e567ea5ccd3694df43e12757cffad2efc..bd189c31114cbf72551c905defaefaff98c18775 100644
--- a/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs
+++ b/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs
@@ -32,7 +32,7 @@ use frame_support::{
 	traits::{
 		ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, Everything, TransformOrigin,
 	},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::{
@@ -65,11 +65,15 @@ use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 use testnet_parachains_constants::rococo::{consensus::*, currency::*, fee::WeightToFee, time::*};
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
-use xcm::latest::prelude::BodyId;
+use xcm::prelude::*;
 use xcm_config::{
 	FellowshipLocation, GovernanceLocation, PriceForSiblingParachainDelivery, XcmConfig,
 	XcmOriginToTransactDispatchOrigin,
 };
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 /// The address format for describing accounts.
 pub type Address = MultiAddress<AccountId, ()>;
@@ -128,7 +132,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("people-rococo"),
 	impl_name: create_runtime_str!("people-rococo"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
@@ -621,6 +625,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::RelayLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/people/people-westend/Cargo.toml b/cumulus/parachains/runtimes/people/people-westend/Cargo.toml
index cc7b6a6e2ff824ed377b705d47e0cb4e9e57b084..b040613d19e75a51d3008af0f71aa7953e82be29 100644
--- a/cumulus/parachains/runtimes/people/people-westend/Cargo.toml
+++ b/cumulus/parachains/runtimes/people/people-westend/Cargo.toml
@@ -59,10 +59,11 @@ westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/co
 xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../../../../polkadot/xcm/xcm-builder", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false }
+xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
@@ -135,6 +136,7 @@ std = [
 	"westend-runtime-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
+	"xcm-fee-payment-runtime-api/std",
 	"xcm/std",
 ]
 
@@ -163,6 +165,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api/runtime-benchmarks",
 ]
 
 try-runtime = [
diff --git a/cumulus/parachains/runtimes/people/people-westend/src/lib.rs b/cumulus/parachains/runtimes/people/people-westend/src/lib.rs
index 4d838fb9961fe291fb260ed72725ec9ea15c3cf5..f071a5f0c9b128f25861c641d670b19564c1bc25 100644
--- a/cumulus/parachains/runtimes/people/people-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/people/people-westend/src/lib.rs
@@ -32,7 +32,7 @@ use frame_support::{
 	traits::{
 		ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, Everything, TransformOrigin,
 	},
-	weights::{ConstantMultiplier, Weight},
+	weights::{ConstantMultiplier, Weight, WeightToFee as _},
 	PalletId,
 };
 use frame_system::{
@@ -65,11 +65,15 @@ use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 use testnet_parachains_constants::westend::{consensus::*, currency::*, fee::WeightToFee, time::*};
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
-use xcm::latest::prelude::BodyId;
+use xcm::prelude::*;
 use xcm_config::{
 	FellowshipLocation, GovernanceLocation, PriceForSiblingParachainDelivery, XcmConfig,
 	XcmOriginToTransactDispatchOrigin,
 };
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 /// The address format for describing accounts.
 pub type Address = MultiAddress<AccountId, ()>;
@@ -128,7 +132,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("people-westend"),
 	impl_name: create_runtime_str!("people-westend"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
@@ -621,6 +625,48 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
+		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+			let acceptable_assets = vec![AssetId(xcm_config::RelayLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
+		}
+
+		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
+		}
+
+		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
+			PolkadotXcm::query_xcm_weight(message)
+		}
+
+		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
+			PolkadotXcm::query_delivery_fees(destination, message)
+		}
+	}
+
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
+		}
+
+		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			PolkadotXcm::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
+		}
+	}
+
 	impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
 		fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
 			ParachainSystem::collect_collation_info(header)
diff --git a/cumulus/parachains/runtimes/starters/seedling/Cargo.toml b/cumulus/parachains/runtimes/starters/seedling/Cargo.toml
index 469269e37ff42f7679e34d9b8f6f143acc34e5b0..910944f54a5ff3433f11fab1d33aa0e88abc35b2 100644
--- a/cumulus/parachains/runtimes/starters/seedling/Cargo.toml
+++ b/cumulus/parachains/runtimes/starters/seedling/Cargo.toml
@@ -36,7 +36,7 @@ sp-version = { path = "../../../../../substrate/primitives/version", default-fea
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-solo-to-para = { path = "../../../../pallets/solo-to-para", default-features = false }
 cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false }
 cumulus-primitives-timestamp = { path = "../../../../primitives/timestamp", default-features = false }
diff --git a/cumulus/parachains/runtimes/starters/shell/Cargo.toml b/cumulus/parachains/runtimes/starters/shell/Cargo.toml
index ff388d2fa2edef2991bff1669482fa318709e449..7a7fad537ac302a9e71889c949a04aacc79df3f3 100644
--- a/cumulus/parachains/runtimes/starters/shell/Cargo.toml
+++ b/cumulus/parachains/runtimes/starters/shell/Cargo.toml
@@ -41,7 +41,7 @@ xcm-executor = { package = "staging-xcm-executor", path = "../../../../../polkad
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false }
 parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false }
diff --git a/cumulus/parachains/runtimes/test-utils/Cargo.toml b/cumulus/parachains/runtimes/test-utils/Cargo.toml
index 475acb13b8b08cb97b7f3dd6718ff71c05d00cd9..c081bac4babe87413c40869917715d03c0c71a86 100644
--- a/cumulus/parachains/runtimes/test-utils/Cargo.toml
+++ b/cumulus/parachains/runtimes/test-utils/Cargo.toml
@@ -26,7 +26,7 @@ sp-tracing = { path = "../../../../substrate/primitives/tracing" }
 sp-core = { path = "../../../../substrate/primitives/core", default-features = false }
 
 # Cumulus
-cumulus-pallet-parachain-system = { path = "../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../pallets/xcmp-queue", default-features = false }
 pallet-collator-selection = { path = "../../../pallets/collator-selection", default-features = false }
 parachain-info = { package = "staging-parachain-info", path = "../../pallets/parachain-info", default-features = false }
diff --git a/cumulus/parachains/runtimes/testing/penpal/Cargo.toml b/cumulus/parachains/runtimes/testing/penpal/Cargo.toml
index 0ac79a3eab5a1a82903f4c4aa515b695250e4cf6..3262233053e7e130c230adbc0aef857572756b1d 100644
--- a/cumulus/parachains/runtimes/testing/penpal/Cargo.toml
+++ b/cumulus/parachains/runtimes/testing/penpal/Cargo.toml
@@ -69,7 +69,7 @@ xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-paym
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
 pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
diff --git a/cumulus/parachains/runtimes/testing/penpal/src/lib.rs b/cumulus/parachains/runtimes/testing/penpal/src/lib.rs
index 86a8b0f1d9ea0518e27492e59fc417b1a2836ce9..e77416e6cd5b681a83b3d8b0571401ef1543004b 100644
--- a/cumulus/parachains/runtimes/testing/penpal/src/lib.rs
+++ b/cumulus/parachains/runtimes/testing/penpal/src/lib.rs
@@ -64,7 +64,7 @@ pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
 use sp_runtime::{
 	create_runtime_str, generic, impl_opaque_keys,
-	traits::{AccountIdLookup, BlakeTwo256, Block as BlockT},
+	traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, Dispatchable},
 	transaction_validity::{TransactionSource, TransactionValidity},
 	ApplyExtrinsicResult,
 };
@@ -83,10 +83,10 @@ use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate};
 use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight};
 use xcm::{
 	latest::prelude::{AssetId as AssetLocationId, BodyId},
-	IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm,
+	VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm,
 };
 use xcm_fee_payment_runtime_api::{
-	dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects},
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
 	fees::Error as XcmPaymentApiError,
 };
 
@@ -849,24 +849,25 @@ impl_runtime_apis! {
 
 	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
 		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
-			if !matches!(xcm_version, 3 | 4) {
-				return Err(XcmPaymentApiError::UnhandledXcmVersion);
-			}
-			Ok([VersionedAssetId::V4(xcm_config::RelayLocation::get().into())]
-				.into_iter()
-				.filter_map(|asset| asset.into_version(xcm_version).ok())
-				.collect())
+			let acceptable_assets = vec![AssetLocationId(xcm_config::RelayLocation::get())];
+			PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
 		}
 
 		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
-			let local_asset = VersionedAssetId::V4(xcm_config::RelayLocation::get().into());
-			let asset = asset
-				.into_version(4)
-				.map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?;
-
-			if  asset != local_asset { return Err(XcmPaymentApiError::AssetNotFound); }
-
-			Ok(WeightToFee::weight_to_fee(&weight))
+			match asset.try_as::<AssetLocationId>() {
+				Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => {
+					// for native token
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
 		}
 
 		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
@@ -878,26 +879,20 @@ impl_runtime_apis! {
 		}
 	}
 
-	impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi<Block, RuntimeCall, RuntimeEvent> for Runtime {
-		fn dry_run_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> Result<ExtrinsicDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
 			use xcm_builder::InspectMessageQueues;
 			use xcm_executor::RecordXcm;
 			use xcm::prelude::*;
-
 			pallet_xcm::Pallet::<Runtime>::set_record_xcm(true);
-			let result = Executive::apply_extrinsic(extrinsic).map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_extrinsic",
-					"Applying extrinsic failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::InvalidExtrinsic
-			})?;
+			frame_system::Pallet::<Runtime>::reset_events(); // To make sure we only record events from current call.
+			let result = call.dispatch(origin.into());
+			pallet_xcm::Pallet::<Runtime>::set_record_xcm(false);
 			let local_xcm = pallet_xcm::Pallet::<Runtime>::recorded_xcm();
 			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
 			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(ExtrinsicDryRunEffects {
-				local_xcm: local_xcm.map(VersionedXcm::<()>::V4),
+			Ok(CallDryRunEffects {
+				local_xcm: local_xcm.map(VersionedXcm::<()>::from),
 				forwarded_xcms,
 				emitted_events: events,
 				execution_result: result,
@@ -910,7 +905,7 @@ impl_runtime_apis! {
 
 			let origin_location: Location = origin_location.try_into().map_err(|error| {
 				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
+					target: "xcm::DryRunApi::dry_run_xcm",
 					"Location version conversion failed with error: {:?}",
 					error,
 				);
@@ -918,13 +913,14 @@ impl_runtime_apis! {
 			})?;
 			let program: Xcm<RuntimeCall> = program.try_into().map_err(|error| {
 				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
+					target: "xcm::DryRunApi::dry_run_xcm",
 					"Xcm version conversion failed with error {:?}",
 					error,
 				);
 				XcmDryRunApiError::VersionedConversionFailed
 			})?;
 			let mut hash = program.using_encoded(sp_core::hashing::blake2_256);
+			frame_system::Pallet::<Runtime>::reset_events(); // To make sure we only record events from current call.
 			let result = xcm_executor::XcmExecutor::<xcm_config::XcmConfig>::prepare_and_execute(
 				origin_location,
 				program,
diff --git a/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml b/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml
index e74caf6b1f470ccc4f650ca375222f0b85233cea..cf734345a976f027ae31f2f38735b9b7aac59f7d 100644
--- a/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml
+++ b/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml
@@ -50,7 +50,7 @@ polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", def
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false }
 pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false }
 cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false }
 cumulus-ping = { path = "../../../pallets/ping", default-features = false }
diff --git a/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs b/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs
index b515e8ec5c9c75851f1152908f1664d92a4d262a..bf45b437f8bb0bba641ee1d622709ee4ed65732d 100644
--- a/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs
+++ b/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs
@@ -107,7 +107,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("test-parachain"),
 	impl_name: create_runtime_str!("test-parachain"),
 	authoring_version: 1,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 6,
diff --git a/cumulus/polkadot-parachain/Cargo.toml b/cumulus/polkadot-parachain/Cargo.toml
index a22606edb6c5c0013a10094a06efbac5ae486170..890cf51991699d559f0d416dd91e4347e506bff8 100644
--- a/cumulus/polkadot-parachain/Cargo.toml
+++ b/cumulus/polkadot-parachain/Cargo.toml
@@ -18,6 +18,7 @@ path = "src/main.rs"
 async-trait = "0.1.79"
 clap = { version = "4.5.3", features = ["derive"] }
 codec = { package = "parity-scale-codec", version = "3.6.12" }
+color-print = "0.3.4"
 futures = "0.3.28"
 hex-literal = "0.4.1"
 log = { workspace = true, default-features = true }
@@ -86,9 +87,9 @@ sp-inherents = { path = "../../substrate/primitives/inherents" }
 sp-api = { path = "../../substrate/primitives/api" }
 sp-consensus-aura = { path = "../../substrate/primitives/consensus/aura" }
 sc-sysinfo = { path = "../../substrate/client/sysinfo" }
-substrate-prometheus-endpoint = { path = "../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../substrate/utils/prometheus" }
 sc-transaction-pool-api = { path = "../../substrate/client/transaction-pool/api" }
-frame-rpc-system = { package = "substrate-frame-rpc-system", path = "../../substrate/utils/frame/rpc/system" }
+substrate-frame-rpc-system = { path = "../../substrate/utils/frame/rpc/system" }
 pallet-transaction-payment-rpc = { path = "../../substrate/frame/transaction-payment/rpc" }
 substrate-state-trie-migration-rpc = { path = "../../substrate/utils/frame/rpc/state-trie-migration-rpc" }
 
@@ -111,7 +112,6 @@ cumulus-client-service = { path = "../client/service" }
 cumulus-primitives-aura = { path = "../primitives/aura" }
 cumulus-primitives-core = { path = "../primitives/core" }
 cumulus-relay-chain-interface = { path = "../client/relay-chain-interface" }
-color-print = "0.3.4"
 
 [build-dependencies]
 substrate-build-script-utils = { path = "../../substrate/utils/build-script-utils" }
@@ -172,4 +172,3 @@ try-runtime = [
 	"sp-runtime/try-runtime",
 ]
 fast-runtime = ["bridge-hub-rococo-runtime/fast-runtime"]
-elastic-scaling-experimental = ["polkadot-service/elastic-scaling-experimental"]
diff --git a/cumulus/polkadot-parachain/src/chain_spec/mod.rs b/cumulus/polkadot-parachain/src/chain_spec/mod.rs
index 136a19e3166bd255e6eb7c95f07ee4613aa61e89..19047b073b057a06f19e86faf935ecb4fc3c96b5 100644
--- a/cumulus/polkadot-parachain/src/chain_spec/mod.rs
+++ b/cumulus/polkadot-parachain/src/chain_spec/mod.rs
@@ -54,7 +54,7 @@ impl Extensions {
 }
 
 /// Generic chain spec for all polkadot-parachain runtimes
-pub type GenericChainSpec = sc_service::GenericChainSpec<(), Extensions>;
+pub type GenericChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// Helper function to generate a crypto pair from seed
 pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
diff --git a/cumulus/polkadot-parachain/src/cli.rs b/cumulus/polkadot-parachain/src/cli.rs
index f7d2fd0f0be3c938ac5a9376d6896a0b073fa364..fa4b4da1ba9cadcd2d2d16c772e9d1ceed26f486 100644
--- a/cumulus/polkadot-parachain/src/cli.rs
+++ b/cumulus/polkadot-parachain/src/cli.rs
@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
 
+use clap::{CommandFactory, FromArgMatches};
 use std::path::PathBuf;
 
 /// Sub-commands supported by the collator.
@@ -108,18 +109,19 @@ pub struct RelayChainCli {
 }
 
 impl RelayChainCli {
-	/// Parse the relay chain CLI parameters using the para chain `Configuration`.
+	/// Parse the relay chain CLI parameters using the parachain `Configuration`.
 	pub fn new<'a>(
 		para_config: &sc_service::Configuration,
 		relay_chain_args: impl Iterator<Item = &'a String>,
 	) -> Self {
+		let polkadot_cmd = polkadot_cli::RunCmd::command().no_binary_name(true);
+		let matches = polkadot_cmd.get_matches_from(relay_chain_args);
+		let base = FromArgMatches::from_arg_matches(&matches).unwrap_or_else(|e| e.exit());
+
 		let extension = crate::chain_spec::Extensions::try_get(&*para_config.chain_spec);
 		let chain_id = extension.map(|e| e.relay_chain.clone());
+
 		let base_path = para_config.base_path.path().join("polkadot");
-		Self {
-			base_path: Some(base_path),
-			chain_id,
-			base: clap::Parser::parse_from(relay_chain_args),
-		}
+		Self { base, chain_id, base_path: Some(base_path) }
 	}
 }
diff --git a/cumulus/polkadot-parachain/src/command.rs b/cumulus/polkadot-parachain/src/command.rs
index 041187de488f33c2c0fe65e4464d165a46c0333e..6b3f4b4cd0a7f462da66a219e4180c4132464bd2 100644
--- a/cumulus/polkadot-parachain/src/command.rs
+++ b/cumulus/polkadot-parachain/src/command.rs
@@ -530,13 +530,9 @@ pub fn run() -> Result<()> {
 		}),
 		Some(Subcommand::PurgeChain(cmd)) => {
 			let runner = cli.create_runner(cmd)?;
+			let polkadot_cli = RelayChainCli::new(runner.config(), cli.relaychain_args.iter());
 
 			runner.sync_run(|config| {
-				let polkadot_cli = RelayChainCli::new(
-					&config,
-					[RelayChainCli::executable_name()].iter().chain(cli.relaychain_args.iter()),
-				);
-
 				let polkadot_config = SubstrateCli::create_configuration(
 					&polkadot_cli,
 					&polkadot_cli,
@@ -603,6 +599,7 @@ pub fn run() -> Result<()> {
 		Some(Subcommand::Key(cmd)) => Ok(cmd.run(&cli)?),
 		None => {
 			let runner = cli.create_runner(&cli.run.normalize())?;
+			let polkadot_cli = RelayChainCli::new(runner.config(), cli.relaychain_args.iter());
 			let collator_options = cli.run.collator_options();
 
 			runner.run_node_until_exit(|config| async move {
@@ -648,11 +645,6 @@ pub fn run() -> Result<()> {
 					.map(|e| e.para_id)
 					.ok_or("Could not find parachain extension in chain-spec.")?;
 
-				let polkadot_cli = RelayChainCli::new(
-					&config,
-					[RelayChainCli::executable_name()].iter().chain(cli.relaychain_args.iter()),
-				);
-
 				let id = ParaId::from(para_id);
 
 				let parachain_account =
@@ -667,7 +659,7 @@ pub fn run() -> Result<()> {
 				info!("Parachain Account: {}", parachain_account);
 				info!("Is collating: {}", if config.role.is_authority() { "yes" } else { "no" });
 
-				match polkadot_config.network.network_backend {
+				match config.network.network_backend {
 					sc_network::config::NetworkBackendType::Libp2p =>
 						start_node::<sc_network::NetworkWorker<_, _>>(
 							config,
@@ -1017,7 +1009,7 @@ mod tests {
 		cfg_file_path
 	}
 
-	pub type DummyChainSpec<E> = sc_service::GenericChainSpec<(), E>;
+	pub type DummyChainSpec<E> = sc_service::GenericChainSpec<E>;
 
 	pub fn create_default_with_extensions<E: Extension>(
 		id: &str,
diff --git a/cumulus/polkadot-parachain/src/common/aura.rs b/cumulus/polkadot-parachain/src/common/aura.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9f72d847926f3a7be480911bdb273e33bf6c0afb
--- /dev/null
+++ b/cumulus/polkadot-parachain/src/common/aura.rs
@@ -0,0 +1,68 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Cumulus.
+
+// Cumulus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Cumulus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Aura-related primitives for cumulus parachain collators.
+
+use codec::Codec;
+use cumulus_primitives_aura::AuraUnincludedSegmentApi;
+use cumulus_primitives_core::BlockT;
+use sp_consensus_aura::AuraApi;
+use sp_runtime::app_crypto::{AppCrypto, AppPair, AppSignature, Pair};
+
+/// Convenience trait for defining the basic bounds of an `AuraId`.
+pub trait AuraIdT: AppCrypto<Pair = Self::BoundedPair> + Codec + Send {
+	/// Extra bounds for the `Pair`.
+	type BoundedPair: AppPair + AppCrypto<Signature = Self::BoundedSignature>;
+
+	/// Extra bounds for the `Signature`.
+	type BoundedSignature: AppSignature
+		+ TryFrom<Vec<u8>>
+		+ std::hash::Hash
+		+ sp_runtime::traits::Member
+		+ Codec;
+}
+
+impl<T> AuraIdT for T
+where
+	T: AppCrypto + Codec + Send + Sync,
+	<<T as AppCrypto>::Pair as AppCrypto>::Signature:
+		TryFrom<Vec<u8>> + std::hash::Hash + sp_runtime::traits::Member + Codec,
+{
+	type BoundedPair = <T as AppCrypto>::Pair;
+	type BoundedSignature = <<T as AppCrypto>::Pair as AppCrypto>::Signature;
+}
+
+/// Convenience trait for defining the basic bounds of a parachain runtime that supports
+/// the Aura consensus.
+pub trait AuraRuntimeApi<Block: BlockT, AuraId: AuraIdT>:
+	sp_api::ApiExt<Block>
+	+ AuraApi<Block, <AuraId::BoundedPair as Pair>::Public>
+	+ AuraUnincludedSegmentApi<Block>
+	+ Sized
+{
+	/// Check if the runtime has the Aura API.
+	fn has_aura_api(&self, at: Block::Hash) -> bool {
+		self.has_api::<dyn AuraApi<Block, <AuraId::BoundedPair as Pair>::Public>>(at)
+			.unwrap_or(false)
+	}
+}
+
+impl<T, Block: BlockT, AuraId: AuraIdT> AuraRuntimeApi<Block, AuraId> for T where
+	T: sp_api::ApiExt<Block>
+		+ AuraApi<Block, <AuraId::BoundedPair as Pair>::Public>
+		+ AuraUnincludedSegmentApi<Block>
+{
+}
diff --git a/cumulus/polkadot-parachain/src/common/mod.rs b/cumulus/polkadot-parachain/src/common/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5adbb4137cd3da4070dc7f271cf2ac1c826e395c
--- /dev/null
+++ b/cumulus/polkadot-parachain/src/common/mod.rs
@@ -0,0 +1,67 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Cumulus.
+
+// Cumulus is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Cumulus is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Cumulus parachain collator primitives.
+
+#![warn(missing_docs)]
+
+pub mod aura;
+
+use cumulus_primitives_core::CollectCollationInfo;
+use sp_api::{ApiExt, CallApiAt, ConstructRuntimeApi, Metadata};
+use sp_block_builder::BlockBuilder;
+use sp_runtime::traits::Block as BlockT;
+use sp_session::SessionKeys;
+use sp_transaction_pool::runtime_api::TaggedTransactionQueue;
+
+/// Convenience trait that defines the basic bounds for the `RuntimeApi` of a parachain node.
+pub trait NodeRuntimeApi<Block: BlockT>:
+	ApiExt<Block>
+	+ Metadata<Block>
+	+ SessionKeys<Block>
+	+ BlockBuilder<Block>
+	+ TaggedTransactionQueue<Block>
+	+ CollectCollationInfo<Block>
+	+ Sized
+{
+}
+
+impl<T, Block: BlockT> NodeRuntimeApi<Block> for T where
+	T: ApiExt<Block>
+		+ Metadata<Block>
+		+ SessionKeys<Block>
+		+ BlockBuilder<Block>
+		+ TaggedTransactionQueue<Block>
+		+ CollectCollationInfo<Block>
+{
+}
+
+/// Convenience trait that defines the basic bounds for the `ConstructRuntimeApi` of a parachain
+/// node.
+pub trait ConstructNodeRuntimeApi<Block: BlockT, C: CallApiAt<Block>>:
+	ConstructRuntimeApi<Block, C, RuntimeApi = Self::BoundedRuntimeApi> + Send + Sync + 'static
+{
+	/// Basic bounds for the `RuntimeApi` of a parachain node.
+	type BoundedRuntimeApi: NodeRuntimeApi<Block>;
+}
+
+impl<T, Block: BlockT, C: CallApiAt<Block>> ConstructNodeRuntimeApi<Block, C> for T
+where
+	T: ConstructRuntimeApi<Block, C> + Send + Sync + 'static,
+	T::RuntimeApi: NodeRuntimeApi<Block>,
+{
+	type BoundedRuntimeApi = T::RuntimeApi;
+}
diff --git a/cumulus/polkadot-parachain/src/fake_runtime_api/asset_hub_polkadot_aura.rs b/cumulus/polkadot-parachain/src/fake_runtime_api/asset_hub_polkadot_aura.rs
index 82c02943c5fc9ee8337cca377ddf2271b454cdda..0b79d338c16813238e70a29d454e91882113128f 100644
--- a/cumulus/polkadot-parachain/src/fake_runtime_api/asset_hub_polkadot_aura.rs
+++ b/cumulus/polkadot-parachain/src/fake_runtime_api/asset_hub_polkadot_aura.rs
@@ -105,12 +105,6 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
-		fn offchain_worker(_: &<Block as BlockT>::Header) {
-			unimplemented!()
-		}
-	}
-
 	impl sp_session::SessionKeys<Block> for Runtime {
 		fn generate_session_keys(_: Option<Vec<u8>>) -> Vec<u8> {
 			unimplemented!()
diff --git a/cumulus/polkadot-parachain/src/fake_runtime_api/aura.rs b/cumulus/polkadot-parachain/src/fake_runtime_api/aura.rs
index 6b718e9121642e37640ad09ee9364974a3d0aa38..823eb9ab584a06ea1370d6b4c03ce124c426f9fe 100644
--- a/cumulus/polkadot-parachain/src/fake_runtime_api/aura.rs
+++ b/cumulus/polkadot-parachain/src/fake_runtime_api/aura.rs
@@ -105,12 +105,6 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
-		fn offchain_worker(_: &<Block as BlockT>::Header) {
-			unimplemented!()
-		}
-	}
-
 	impl sp_session::SessionKeys<Block> for Runtime {
 		fn generate_session_keys(_: Option<Vec<u8>>) -> Vec<u8> {
 			unimplemented!()
diff --git a/cumulus/polkadot-parachain/src/main.rs b/cumulus/polkadot-parachain/src/main.rs
index 0757bea84aae83b64ec24982874c28f095057e75..2bf659228bc6020276858fcd2b154e5c0e37f82b 100644
--- a/cumulus/polkadot-parachain/src/main.rs
+++ b/cumulus/polkadot-parachain/src/main.rs
@@ -22,6 +22,7 @@
 mod chain_spec;
 mod cli;
 mod command;
+mod common;
 mod fake_runtime_api;
 mod rpc;
 mod service;
diff --git a/cumulus/polkadot-parachain/src/rpc.rs b/cumulus/polkadot-parachain/src/rpc.rs
index caee14e555220fc0e704b5edbe93a5ad76762eff..7437bb1f4b9372f2454cbe6d491d302056606571 100644
--- a/cumulus/polkadot-parachain/src/rpc.rs
+++ b/cumulus/polkadot-parachain/src/rpc.rs
@@ -54,15 +54,15 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	C::Api: frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
+	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
 	C::Api: BlockBuilder<Block>,
 	P: TransactionPool + Sync + Send + 'static,
 	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
 	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashingFor<Block>>,
 {
-	use frame_rpc_system::{System, SystemApiServer};
 	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
+	use substrate_frame_rpc_system::{System, SystemApiServer};
 	use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer};
 
 	let mut module = RpcExtension::new(());
@@ -88,14 +88,14 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	C::Api: frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
+	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
 	C::Api: BlockBuilder<Block>,
 	P: TransactionPool + Sync + Send + 'static,
 {
-	use frame_rpc_system::{System, SystemApiServer};
 	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
 	use sc_rpc::dev::{Dev, DevApiServer};
+	use substrate_frame_rpc_system::{System, SystemApiServer};
 
 	let mut module = RpcExtension::new(());
 	let FullDeps { client, pool, deny_unsafe } = deps;
diff --git a/cumulus/polkadot-parachain/src/service.rs b/cumulus/polkadot-parachain/src/service.rs
index 12eda3e8a9cbe21f528398125e50ed57a4bc1933..9cd3a0037223d6dd4241e5c1b6d3c61f5dff3d3f 100644
--- a/cumulus/polkadot-parachain/src/service.rs
+++ b/cumulus/polkadot-parachain/src/service.rs
@@ -14,13 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
 
-use codec::{Codec, Decode};
+use codec::Decode;
 use cumulus_client_cli::CollatorOptions;
 use cumulus_client_collator::service::CollatorService;
 use cumulus_client_consensus_aura::collators::lookahead::{self as aura, Params as AuraParams};
-use cumulus_client_consensus_common::{
-	ParachainBlockImport as TParachainBlockImport, ParachainCandidate, ParachainConsensus,
-};
+use cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport;
 use cumulus_client_consensus_proposer::Proposer;
 #[allow(deprecated)]
 use cumulus_client_service::old_consensus;
@@ -28,21 +26,26 @@ use cumulus_client_service::{
 	build_network, build_relay_chain_interface, prepare_node_config, start_relay_chain_tasks,
 	BuildNetworkParams, CollatorSybilResistance, DARecoveryProfile, StartRelayChainTasksParams,
 };
-use cumulus_primitives_core::{
-	relay_chain::{Hash as PHash, PersistedValidationData, ValidationCode},
-	ParaId,
-};
+use cumulus_primitives_core::{relay_chain::ValidationCode, ParaId};
 use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};
 use sc_rpc::DenyUnsafe;
-use sp_core::Pair;
 
 use jsonrpsee::RpcModule;
 
-use crate::{fake_runtime_api::aura::RuntimeApi as FakeRuntimeApi, rpc};
-pub use parachains_common::{AccountId, AuraId, Balance, Block, Hash, Header, Nonce};
+use crate::{
+	common::{
+		aura::{AuraIdT, AuraRuntimeApi},
+		ConstructNodeRuntimeApi,
+	},
+	fake_runtime_api::aura::RuntimeApi as FakeRuntimeApi,
+	rpc,
+};
+pub use parachains_common::{AccountId, AuraId, Balance, Block, Hash, Nonce};
 
 use cumulus_client_consensus_relay_chain::Verifier as RelayChainVerifier;
-use futures::{lock::Mutex, prelude::*};
+use futures::prelude::*;
+use prometheus_endpoint::Registry;
+use sc_client_api::Backend as ClientApiBackend;
 use sc_consensus::{
 	import_queue::{BasicQueue, Verifier as VerifierT},
 	BlockImportParams, ImportQueue,
@@ -52,8 +55,8 @@ use sc_network::{config::FullNetworkConfiguration, service::traits::NetworkBacke
 use sc_network_sync::SyncingService;
 use sc_service::{Configuration, PartialComponents, TFullBackend, TFullClient, TaskManager};
 use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};
-use sp_api::{ApiExt, ConstructRuntimeApi, ProvideRuntimeApi};
-use sp_consensus_aura::AuraApi;
+use sp_api::{ConstructRuntimeApi, ProvideRuntimeApi};
+use sp_blockchain::HeaderBackend;
 use sp_core::traits::SpawnEssentialNamed;
 use sp_keystore::KeystorePtr;
 use sp_runtime::{
@@ -61,7 +64,6 @@ use sp_runtime::{
 	traits::{Block as BlockT, Header as HeaderT},
 };
 use std::{marker::PhantomData, sync::Arc, time::Duration};
-use substrate_prometheus_endpoint::Registry;
 
 use polkadot_primitives::CollatorPair;
 
@@ -100,13 +102,7 @@ pub fn new_partial<RuntimeApi, BIQ>(
 	build_import_queue: BIQ,
 ) -> Result<Service<RuntimeApi>, sc_service::Error>
 where
-	RuntimeApi: ConstructRuntimeApi<Block, ParachainClient<RuntimeApi>> + Send + Sync + 'static,
-	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
-		+ sp_api::Metadata<Block>
-		+ sp_session::SessionKeys<Block>
-		+ sp_api::ApiExt<Block>
-		+ sp_offchain::OffchainWorkerApi<Block>
-		+ sp_block_builder::BlockBuilder<Block>,
+	RuntimeApi: ConstructNodeRuntimeApi<Block, ParachainClient<RuntimeApi>>,
 	BIQ: FnOnce(
 		Arc<ParachainClient<RuntimeApi>>,
 		ParachainBlockImport<RuntimeApi>,
@@ -200,16 +196,7 @@ async fn start_node_impl<RuntimeApi, RB, BIQ, SC, Net>(
 	hwbench: Option<sc_sysinfo::HwBench>,
 ) -> sc_service::error::Result<(TaskManager, Arc<ParachainClient<RuntimeApi>>)>
 where
-	RuntimeApi: ConstructRuntimeApi<Block, ParachainClient<RuntimeApi>> + Send + Sync + 'static,
-	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
-		+ sp_api::Metadata<Block>
-		+ sp_session::SessionKeys<Block>
-		+ sp_api::ApiExt<Block>
-		+ sp_offchain::OffchainWorkerApi<Block>
-		+ sp_block_builder::BlockBuilder<Block>
-		+ cumulus_primitives_core::CollectCollationInfo<Block>
-		+ pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>
-		+ frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
+	RuntimeApi: ConstructNodeRuntimeApi<Block, ParachainClient<RuntimeApi>>,
 	RB: Fn(
 			DenyUnsafe,
 			Arc<ParachainClient<RuntimeApi>>,
@@ -471,7 +458,7 @@ where
 	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
 		+ sp_block_builder::BlockBuilder<Block>
 		+ pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>
-		+ frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
+		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
 {
 	let deps = rpc::FullDeps { client, pool, deny_unsafe };
 
@@ -529,61 +516,6 @@ impl<R> BuildOnAccess<R> {
 	}
 }
 
-/// Special [`ParachainConsensus`] implementation that waits for the upgrade from
-/// shell to a parachain runtime that implements Aura.
-struct WaitForAuraConsensus<Client, AuraId> {
-	client: Arc<Client>,
-	aura_consensus: Arc<Mutex<BuildOnAccess<Box<dyn ParachainConsensus<Block>>>>>,
-	relay_chain_consensus: Arc<Mutex<Box<dyn ParachainConsensus<Block>>>>,
-	_phantom: PhantomData<AuraId>,
-}
-
-impl<Client, AuraId> Clone for WaitForAuraConsensus<Client, AuraId> {
-	fn clone(&self) -> Self {
-		Self {
-			client: self.client.clone(),
-			aura_consensus: self.aura_consensus.clone(),
-			relay_chain_consensus: self.relay_chain_consensus.clone(),
-			_phantom: PhantomData,
-		}
-	}
-}
-
-#[async_trait::async_trait]
-impl<Client, AuraId> ParachainConsensus<Block> for WaitForAuraConsensus<Client, AuraId>
-where
-	Client: sp_api::ProvideRuntimeApi<Block> + Send + Sync,
-	Client::Api: AuraApi<Block, AuraId>,
-	AuraId: Send + Codec + Sync,
-{
-	async fn produce_candidate(
-		&mut self,
-		parent: &Header,
-		relay_parent: PHash,
-		validation_data: &PersistedValidationData,
-	) -> Option<ParachainCandidate<Block>> {
-		if self
-			.client
-			.runtime_api()
-			.has_api::<dyn AuraApi<Block, AuraId>>(parent.hash())
-			.unwrap_or(false)
-		{
-			self.aura_consensus
-				.lock()
-				.await
-				.get_mut()
-				.produce_candidate(parent, relay_parent, validation_data)
-				.await
-		} else {
-			self.relay_chain_consensus
-				.lock()
-				.await
-				.produce_candidate(parent, relay_parent, validation_data)
-				.await
-		}
-	}
-}
-
 struct Verifier<Client, AuraId> {
 	client: Arc<Client>,
 	aura_verifier: BuildOnAccess<Box<dyn VerifierT<Block>>>,
@@ -592,22 +524,16 @@ struct Verifier<Client, AuraId> {
 }
 
 #[async_trait::async_trait]
-impl<Client, AuraId> VerifierT<Block> for Verifier<Client, AuraId>
+impl<Client, AuraId: AuraIdT> VerifierT<Block> for Verifier<Client, AuraId>
 where
 	Client: sp_api::ProvideRuntimeApi<Block> + Send + Sync,
-	Client::Api: AuraApi<Block, AuraId>,
-	AuraId: Send + Sync + Codec,
+	Client::Api: AuraRuntimeApi<Block, AuraId>,
 {
 	async fn verify(
 		&mut self,
 		block_import: BlockImportParams<Block>,
 	) -> Result<BlockImportParams<Block>, String> {
-		if self
-			.client
-			.runtime_api()
-			.has_api::<dyn AuraApi<Block, AuraId>>(*block_import.header.parent_hash())
-			.unwrap_or(false)
-		{
+		if self.client.runtime_api().has_aura_api(*block_import.header.parent_hash()) {
 			self.aura_verifier.get_mut().verify(block_import).await
 		} else {
 			self.relay_chain_verifier.verify(block_import).await
@@ -617,7 +543,7 @@ where
 
 /// Build the import queue for parachain runtimes that started with relay chain consensus and
 /// switched to aura.
-pub fn build_relay_to_aura_import_queue<RuntimeApi, AuraId: AppCrypto>(
+pub fn build_relay_to_aura_import_queue<RuntimeApi, AuraId: AuraIdT>(
 	client: Arc<ParachainClient<RuntimeApi>>,
 	block_import: ParachainBlockImport<RuntimeApi>,
 	config: &Configuration,
@@ -625,16 +551,8 @@ pub fn build_relay_to_aura_import_queue<RuntimeApi, AuraId: AppCrypto>(
 	task_manager: &TaskManager,
 ) -> Result<sc_consensus::DefaultImportQueue<Block>, sc_service::Error>
 where
-	RuntimeApi: ConstructRuntimeApi<Block, ParachainClient<RuntimeApi>> + Send + Sync + 'static,
-	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
-		+ sp_api::Metadata<Block>
-		+ sp_session::SessionKeys<Block>
-		+ sp_api::ApiExt<Block>
-		+ sp_offchain::OffchainWorkerApi<Block>
-		+ sp_block_builder::BlockBuilder<Block>
-		+ sp_consensus_aura::AuraApi<Block, <<AuraId as AppCrypto>::Pair as Pair>::Public>,
-	<<AuraId as AppCrypto>::Pair as Pair>::Signature:
-		TryFrom<Vec<u8>> + std::hash::Hash + sp_runtime::traits::Member + Codec,
+	RuntimeApi: ConstructNodeRuntimeApi<Block, ParachainClient<RuntimeApi>>,
+	RuntimeApi::RuntimeApi: AuraRuntimeApi<Block, AuraId>,
 {
 	let verifier_client = client.clone();
 
@@ -714,11 +632,7 @@ pub async fn start_generic_aura_lookahead_node<Net: NetworkBackend<Block, Hash>>
 ///
 /// Uses the lookahead collator to support async backing.
 #[sc_tracing::logging::prefix_logs_with("Parachain")]
-pub async fn start_asset_hub_lookahead_node<
-	RuntimeApi,
-	AuraId: AppCrypto + Send + Codec + Sync,
-	Net,
->(
+pub async fn start_asset_hub_lookahead_node<RuntimeApi, AuraId: AuraIdT, Net>(
 	parachain_config: Configuration,
 	polkadot_config: Configuration,
 	collator_options: CollatorOptions,
@@ -726,20 +640,10 @@ pub async fn start_asset_hub_lookahead_node<
 	hwbench: Option<sc_sysinfo::HwBench>,
 ) -> sc_service::error::Result<(TaskManager, Arc<ParachainClient<RuntimeApi>>)>
 where
-	RuntimeApi: ConstructRuntimeApi<Block, ParachainClient<RuntimeApi>> + Send + Sync + 'static,
-	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
-		+ sp_api::Metadata<Block>
-		+ sp_session::SessionKeys<Block>
-		+ sp_api::ApiExt<Block>
-		+ sp_offchain::OffchainWorkerApi<Block>
-		+ sp_block_builder::BlockBuilder<Block>
-		+ cumulus_primitives_core::CollectCollationInfo<Block>
-		+ sp_consensus_aura::AuraApi<Block, <<AuraId as AppCrypto>::Pair as Pair>::Public>
+	RuntimeApi: ConstructNodeRuntimeApi<Block, ParachainClient<RuntimeApi>>,
+	RuntimeApi::RuntimeApi: AuraRuntimeApi<Block, AuraId>
 		+ pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>
-		+ frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>
-		+ cumulus_primitives_aura::AuraUnincludedSegmentApi<Block>,
-	<<AuraId as AppCrypto>::Pair as Pair>::Signature:
-		TryFrom<Vec<u8>> + std::hash::Hash + sp_runtime::traits::Member + Codec,
+		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
 	Net: NetworkBackend<Block, Hash>,
 {
 	start_node_impl::<RuntimeApi, _, _, _, Net>(
@@ -807,11 +711,7 @@ where
 
 					// Check if we have upgraded to an Aura compatible runtime and transition if
 					// necessary.
-					if client
-						.runtime_api()
-						.has_api::<dyn AuraApi<Block, AuraId>>(last_head_hash)
-						.unwrap_or(false)
-					{
+					if client.runtime_api().has_aura_api(last_head_hash) {
 						// Respond to this request before transitioning to Aura.
 						request.complete(None);
 						break
@@ -930,14 +830,14 @@ fn start_relay_chain_consensus(
 }
 
 /// Start consensus using the lookahead aura collator.
-fn start_lookahead_aura_consensus(
-	client: Arc<ParachainClient<FakeRuntimeApi>>,
-	block_import: ParachainBlockImport<FakeRuntimeApi>,
+fn start_lookahead_aura_consensus<RuntimeApi>(
+	client: Arc<ParachainClient<RuntimeApi>>,
+	block_import: ParachainBlockImport<RuntimeApi>,
 	prometheus_registry: Option<&Registry>,
 	telemetry: Option<TelemetryHandle>,
 	task_manager: &TaskManager,
 	relay_chain_interface: Arc<dyn RelayChainInterface>,
-	transaction_pool: Arc<sc_transaction_pool::FullPool<Block, ParachainClient<FakeRuntimeApi>>>,
+	transaction_pool: Arc<sc_transaction_pool::FullPool<Block, ParachainClient<RuntimeApi>>>,
 	sync_oracle: Arc<SyncingService<Block>>,
 	keystore: KeystorePtr,
 	relay_chain_slot_duration: Duration,
@@ -946,7 +846,16 @@ fn start_lookahead_aura_consensus(
 	overseer_handle: OverseerHandle,
 	announce_block: Arc<dyn Fn(Hash, Option<Vec<u8>>) + Send + Sync>,
 	backend: Arc<ParachainBackend>,
-) -> Result<(), sc_service::Error> {
+) -> Result<(), sc_service::Error>
+where
+	RuntimeApi: ConstructNodeRuntimeApi<Block, ParachainClient<RuntimeApi>>,
+	RuntimeApi::RuntimeApi: AuraRuntimeApi<Block, AuraId>,
+{
+	let info = backend.blockchain().info();
+	if !client.runtime_api().has_aura_api(info.finalized_hash) {
+		return Err(sc_service::error::Error::Other("Missing aura runtime APIs".to_string()));
+	}
+
 	let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording(
 		task_manager.spawn_handle(),
 		client.clone(),
diff --git a/cumulus/primitives/storage-weight-reclaim/src/lib.rs b/cumulus/primitives/storage-weight-reclaim/src/lib.rs
index c09c12d7a0abf8ac3c64974390d47880af6ec6e9..35fa334f51c6996c48825cec03a0a90df5b0acbe 100644
--- a/cumulus/primitives/storage-weight-reclaim/src/lib.rs
+++ b/cumulus/primitives/storage-weight-reclaim/src/lib.rs
@@ -201,7 +201,7 @@ mod tests {
 	use super::*;
 	use frame_support::{
 		assert_ok,
-		dispatch::DispatchClass,
+		dispatch::{DispatchClass, PerDispatchClass},
 		weights::{Weight, WeightMeter},
 	};
 	use frame_system::{BlockWeight, CheckWeight};
@@ -215,7 +215,7 @@ mod tests {
 			pages: 0u64,
 		});
 	const ALICE: AccountId32 = AccountId32::new([1u8; 32]);
-	const LEN: usize = 0;
+	const LEN: usize = 150;
 
 	pub fn new_test_ext() -> sp_io::TestExternalities {
 		let ext: sp_io::TestExternalities = cumulus_test_runtime::RuntimeGenesisConfig::default()
@@ -256,6 +256,10 @@ mod tests {
 		});
 	}
 
+	fn get_storage_weight() -> PerDispatchClass<Weight> {
+		BlockWeight::<Test>::get()
+	}
+
 	#[test]
 	fn basic_refund() {
 		// The real cost will be 100 bytes of storage size
@@ -268,6 +272,9 @@ mod tests {
 			let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() };
 			let post_info = PostDispatchInfo::default();
 
+			// Should add 500 + 150 (len) to weight.
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
@@ -283,7 +290,7 @@ mod tests {
 				&Ok(())
 			));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 600);
+			assert_eq!(get_storage_weight().total().proof_size(), 1250);
 		})
 	}
 
@@ -299,6 +306,9 @@ mod tests {
 			let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() };
 			let post_info = PostDispatchInfo::default();
 
+			// Adds 500 + 150 (len) weight
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
@@ -313,7 +323,7 @@ mod tests {
 				&Ok(())
 			));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 1000);
+			assert_eq!(get_storage_weight().total().proof_size(), 1650);
 		})
 	}
 
@@ -327,6 +337,9 @@ mod tests {
 			let info = DispatchInfo { weight: Weight::from_parts(0, 100), ..Default::default() };
 			let post_info = PostDispatchInfo::default();
 
+			// Weight added should be 100 + 150 (len)
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
@@ -342,7 +355,10 @@ mod tests {
 				&Ok(())
 			));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 1100);
+			assert_eq!(
+				get_storage_weight().total().proof_size(),
+				1100 + LEN as u64 + info.weight.proof_size()
+			);
 		})
 	}
 
@@ -354,6 +370,8 @@ mod tests {
 			let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() };
 			let post_info = PostDispatchInfo::default();
 
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
@@ -368,7 +386,8 @@ mod tests {
 				&Ok(())
 			));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 0);
+			// Proof size should be exactly equal to extrinsic length
+			assert_eq!(get_storage_weight().total().proof_size(), LEN as u64);
 		});
 	}
 
@@ -382,12 +401,17 @@ mod tests {
 			let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() };
 			let post_info = PostDispatchInfo::default();
 
+			// Adds 500 + 150 (len) weight, total weight is 1950
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
 			assert_eq!(pre, Some(300));
 
+			// Refund 500 unspent weight according to `post_info`, total weight is now 1650
 			assert_ok!(CheckWeight::<Test>::post_dispatch(None, &info, &post_info, 0, &Ok(())));
+			// Recorded proof size is negative -200, total weight is now 1450
 			assert_ok!(StorageWeightReclaim::<Test>::post_dispatch(
 				Some(pre),
 				&info,
@@ -396,7 +420,7 @@ mod tests {
 				&Ok(())
 			));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 800);
+			assert_eq!(get_storage_weight().total().proof_size(), 1450);
 		});
 	}
 
@@ -416,6 +440,9 @@ mod tests {
 				pays_fee: Default::default(),
 			};
 
+			// Should add 300 + 150 (len) of weight
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
@@ -432,7 +459,8 @@ mod tests {
 				&Ok(())
 			));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 900);
+			// Reclaimed 100
+			assert_eq!(get_storage_weight().total().proof_size(), 1350);
 		})
 	}
 
@@ -451,6 +479,9 @@ mod tests {
 				pays_fee: Default::default(),
 			};
 
+			// Adds 50 + 150 (len) weight, total weight 1200
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
@@ -458,7 +489,56 @@ mod tests {
 
 			// The `CheckWeight` extension will refund `actual_weight` from `PostDispatchInfo`
 			// we always need to call `post_dispatch` to verify that they interoperate correctly.
+
+			// Refunds unspent 25 weight according to `post_info`, 1175
 			assert_ok!(CheckWeight::<Test>::post_dispatch(None, &info, &post_info, 0, &Ok(())));
+			// Adds 200 - 25 (unspent) == 175 weight, total weight 1350
+			assert_ok!(StorageWeightReclaim::<Test>::post_dispatch(
+				Some(pre),
+				&info,
+				&post_info,
+				LEN,
+				&Ok(())
+			));
+
+			assert_eq!(get_storage_weight().total().proof_size(), 1350);
+		})
+	}
+
+	#[test]
+	fn test_nothing_relcaimed() {
+		let mut test_ext = setup_test_externalities(&[100, 200]);
+
+		test_ext.execute_with(|| {
+			set_current_storage_weight(0);
+			// Benchmarked storage weight: 100
+			let info = DispatchInfo { weight: Weight::from_parts(100, 100), ..Default::default() };
+
+			// Actual proof size is 100
+			let post_info = PostDispatchInfo {
+				actual_weight: Some(Weight::from_parts(50, 100)),
+				pays_fee: Default::default(),
+			};
+
+			// Adds benchmarked weight 100 + 150 (len), total weight is now 250
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
+			// Weight should go up by 150 len + 100 proof size weight, total weight 250
+			assert_eq!(get_storage_weight().total().proof_size(), 250);
+
+			let pre = StorageWeightReclaim::<Test>(PhantomData)
+				.pre_dispatch(&ALICE, CALL, &info, LEN)
+				.unwrap();
+			// Should return `setup_test_externalities` proof recorder value: 100.
+			assert_eq!(pre, Some(100));
+
+			// The `CheckWeight` extension will refund `actual_weight` from `PostDispatchInfo`
+			// we always need to call `post_dispatch` to verify that they interoperate correctly.
+			// Nothing to refund, unspent is 0, total weight 250
+			assert_ok!(CheckWeight::<Test>::post_dispatch(None, &info, &post_info, LEN, &Ok(())));
+			// `setup_test_externalities` proof recorder value: 200, so this means the extrinsic
+			// actually used 100 proof size.
+			// Nothing to refund or add, weight matches proof recorder
 			assert_ok!(StorageWeightReclaim::<Test>::post_dispatch(
 				Some(pre),
 				&info,
@@ -467,7 +547,9 @@ mod tests {
 				&Ok(())
 			));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 1150);
+			// Check block len weight was not reclaimed:
+			// 100 weight + 150 extrinsic len == 250 proof size
+			assert_eq!(get_storage_weight().total().proof_size(), 250);
 		})
 	}
 
@@ -487,11 +569,15 @@ mod tests {
 				pays_fee: Default::default(),
 			};
 
+			// Adds 300 + 150 (len) weight, total weight 1450
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
 			assert_eq!(pre, Some(100));
 
+			// This refunds 100 - 50(unspent), total weight is now 1400
 			assert_ok!(StorageWeightReclaim::<Test>::post_dispatch(
 				Some(pre),
 				&info,
@@ -504,7 +590,8 @@ mod tests {
 			// we always need to call `post_dispatch` to verify that they interoperate correctly.
 			assert_ok!(CheckWeight::<Test>::post_dispatch(None, &info, &post_info, 0, &Ok(())));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 900);
+			// Above call refunds 50 (unspent), total weight is 1350 now
+			assert_eq!(get_storage_weight().total().proof_size(), 1350);
 		})
 	}
 
@@ -523,11 +610,15 @@ mod tests {
 				pays_fee: Default::default(),
 			};
 
+			// Adds 50 + 150 (len) weight, total weight is 1200
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&info, LEN));
+
 			let pre = StorageWeightReclaim::<Test>(PhantomData)
 				.pre_dispatch(&ALICE, CALL, &info, LEN)
 				.unwrap();
 			assert_eq!(pre, Some(100));
 
+			// Adds additional 150 weight recorded
 			assert_ok!(StorageWeightReclaim::<Test>::post_dispatch(
 				Some(pre),
 				&info,
@@ -540,7 +631,7 @@ mod tests {
 			// we always need to call `post_dispatch` to verify that they interoperate correctly.
 			assert_ok!(CheckWeight::<Test>::post_dispatch(None, &info, &post_info, 0, &Ok(())));
 
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 1150);
+			assert_eq!(get_storage_weight().total().proof_size(), 1350);
 		})
 	}
 
@@ -644,7 +735,7 @@ mod tests {
 
 			// We reclaimed 3 bytes of storage size!
 			assert_eq!(reclaimed, Some(Weight::from_parts(0, 3)));
-			assert_eq!(BlockWeight::<Test>::get().total().proof_size(), 10);
+			assert_eq!(get_storage_weight().total().proof_size(), 10);
 			assert_eq!(remaining_weight_meter.remaining(), Weight::from_parts(10, 8));
 		}
 	}
diff --git a/cumulus/test/runtime/Cargo.toml b/cumulus/test/runtime/Cargo.toml
index eb160bd3355e1ac409117b361688a953fb6bb1d3..b14e3b7f040e74cfabe834d770859433cdb1553d 100644
--- a/cumulus/test/runtime/Cargo.toml
+++ b/cumulus/test/runtime/Cargo.toml
@@ -41,9 +41,8 @@ sp-transaction-pool = { path = "../../../substrate/primitives/transaction-pool",
 sp-version = { path = "../../../substrate/primitives/version", default-features = false }
 
 # Cumulus
-cumulus-pallet-parachain-system = { path = "../../pallets/parachain-system", default-features = false, features = [
-	"parameterized-consensus-hook",
-] }
+cumulus-pallet-parachain-system = { path = "../../pallets/parachain-system", default-features = false }
+parachain-info = { package = "staging-parachain-info", path = "../../parachains/pallets/parachain-info", default-features = false }
 cumulus-primitives-aura = { path = "../../primitives/aura", default-features = false }
 pallet-collator-selection = { path = "../../pallets/collator-selection", default-features = false }
 cumulus-pallet-aura-ext = { path = "../../pallets/aura-ext", default-features = false }
@@ -76,6 +75,7 @@ std = [
 	"pallet-sudo/std",
 	"pallet-timestamp/std",
 	"pallet-transaction-payment/std",
+	"parachain-info/std",
 	"scale-info/std",
 	"sp-api/std",
 	"sp-block-builder/std",
diff --git a/cumulus/test/runtime/src/lib.rs b/cumulus/test/runtime/src/lib.rs
index 22dc5d857b7c07a7285d3ad2b76f87b15dc5718d..26c6635e1ad3200e1a78fb9f0645bf7ba989ac4b 100644
--- a/cumulus/test/runtime/src/lib.rs
+++ b/cumulus/test/runtime/src/lib.rs
@@ -66,7 +66,7 @@ use frame_system::{
 pub use pallet_balances::Call as BalancesCall;
 pub use pallet_glutton::Call as GluttonCall;
 pub use pallet_sudo::Call as SudoCall;
-pub use pallet_timestamp::Call as TimestampCall;
+pub use pallet_timestamp::{Call as TimestampCall, Now};
 #[cfg(any(feature = "std", test))]
 pub use sp_runtime::BuildStorage;
 pub use sp_runtime::{Perbill, Permill};
@@ -280,7 +280,7 @@ type ConsensusHook = cumulus_pallet_aura_ext::FixedVelocityConsensusHook<
 >;
 impl cumulus_pallet_parachain_system::Config for Runtime {
 	type WeightInfo = ();
-	type SelfParaId = ParachainId;
+	type SelfParaId = parachain_info::Pallet<Runtime>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSystemEvent = ();
 	type OutboundXcmpMessageSource = ();
@@ -294,6 +294,8 @@ impl cumulus_pallet_parachain_system::Config for Runtime {
 	type ConsensusHook = ConsensusHook;
 }
 
+impl parachain_info::Config for Runtime {}
+
 impl pallet_aura::Config for Runtime {
 	type AuthorityId = AuraId;
 	type DisabledValidators = ();
@@ -302,11 +304,6 @@ impl pallet_aura::Config for Runtime {
 	type SlotDuration = ConstU64<SLOT_DURATION>;
 }
 
-parameter_types! {
-	// will be set by test_pallet during genesis init
-	pub storage ParachainId: cumulus_primitives_core::ParaId = PARACHAIN_ID.into();
-}
-
 impl test_pallet::Config for Runtime {}
 
 construct_runtime! {
@@ -315,6 +312,7 @@ construct_runtime! {
 		System: frame_system,
 		ParachainSystem: cumulus_pallet_parachain_system,
 		Timestamp: pallet_timestamp,
+		ParachainInfo: parachain_info,
 		Balances: pallet_balances,
 		Sudo: pallet_sudo,
 		TransactionPayment: pallet_transaction_payment,
@@ -501,7 +499,7 @@ impl_runtime_apis! {
 
 	impl crate::GetLastTimestamp<Block> for Runtime {
 		fn get_last_timestamp() -> u64 {
-			Timestamp::now()
+			Now::<Runtime>::get()
 		}
 	}
 
diff --git a/cumulus/test/runtime/src/test_pallet.rs b/cumulus/test/runtime/src/test_pallet.rs
index 5d11b7f490c68351ea0612e809872a0f217681d3..7f43f713fadc4c96776adfea90cdd17365a6b1cd 100644
--- a/cumulus/test/runtime/src/test_pallet.rs
+++ b/cumulus/test/runtime/src/test_pallet.rs
@@ -78,7 +78,6 @@ pub mod pallet {
 	#[derive(frame_support::DefaultNoBound)]
 	#[pallet::genesis_config]
 	pub struct GenesisConfig<T: Config> {
-		pub self_para_id: Option<cumulus_primitives_core::ParaId>,
 		#[serde(skip)]
 		pub _config: sp_std::marker::PhantomData<T>,
 	}
@@ -87,9 +86,6 @@ pub mod pallet {
 	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
 		fn build(&self) {
 			sp_io::storage::set(TEST_RUNTIME_UPGRADE_KEY, &[1, 2, 3, 4]);
-			self.self_para_id.map(|para_id| {
-				crate::ParachainId::set(&para_id);
-			});
 		}
 	}
 }
diff --git a/cumulus/test/service/Cargo.toml b/cumulus/test/service/Cargo.toml
index c54e19d0238034d83d5dd77164bbdc017ef4e728..732d884528f8974b4d09b33c118f41b74d22f348 100644
--- a/cumulus/test/service/Cargo.toml
+++ b/cumulus/test/service/Cargo.toml
@@ -85,7 +85,7 @@ cumulus-test-runtime = { path = "../runtime" }
 cumulus-relay-chain-minimal-node = { path = "../../client/relay-chain-minimal-node" }
 cumulus-client-pov-recovery = { path = "../../client/pov-recovery" }
 cumulus-test-relay-sproof-builder = { path = "../relay-sproof-builder" }
-cumulus-pallet-parachain-system = { path = "../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] }
+cumulus-pallet-parachain-system = { path = "../../pallets/parachain-system", default-features = false }
 cumulus-primitives-storage-weight-reclaim = { path = "../../primitives/storage-weight-reclaim" }
 pallet-timestamp = { path = "../../../substrate/frame/timestamp" }
 
diff --git a/cumulus/test/service/src/chain_spec.rs b/cumulus/test/service/src/chain_spec.rs
index 4db2513e2b6311675c8d3b565a817d1b7ce95f8b..174d478f2575caae3f6afe14810c8fe7f6719cb8 100644
--- a/cumulus/test/service/src/chain_spec.rs
+++ b/cumulus/test/service/src/chain_spec.rs
@@ -17,7 +17,7 @@
 #![allow(missing_docs)]
 
 use cumulus_primitives_core::ParaId;
-use cumulus_test_runtime::{AccountId, RuntimeGenesisConfig, Signature};
+use cumulus_test_runtime::{AccountId, Signature};
 use parachains_common::AuraId;
 use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
 use sc_service::ChainType;
@@ -26,7 +26,7 @@ use sp_core::{sr25519, Pair, Public};
 use sp_runtime::traits::{IdentifyAccount, Verify};
 
 /// Specialized `ChainSpec` for the normal parachain runtime.
-pub type ChainSpec = sc_service::GenericChainSpec<RuntimeGenesisConfig, Extensions>;
+pub type ChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// Helper function to generate a crypto pair from seed
 pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
@@ -142,7 +142,9 @@ pub fn testnet_genesis(
 			balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 60)).collect(),
 		},
 		"sudo": cumulus_test_runtime::SudoConfig { key: Some(root_key) },
-		"testPallet": cumulus_test_runtime::TestPalletConfig { self_para_id: Some(self_para_id), ..Default::default() },
+		"parachainInfo": {
+			"parachainId": self_para_id,
+		},
 		"aura": cumulus_test_runtime::AuraConfig { authorities: invulnerables }
 	})
 }
diff --git a/cumulus/test/service/src/lib.rs b/cumulus/test/service/src/lib.rs
index f2a612803861ce143aa08d6ae7abbf8963c31ef3..6f8b9d19bb29ba7445b2b67fdd9b0ac4a3263553 100644
--- a/cumulus/test/service/src/lib.rs
+++ b/cumulus/test/service/src/lib.rs
@@ -152,7 +152,7 @@ impl RecoveryHandle for FailingRecoveryHandle {
 		message: AvailabilityRecoveryMessage,
 		origin: &'static str,
 	) {
-		let AvailabilityRecoveryMessage::RecoverAvailableData(ref receipt, _, _, _) = message;
+		let AvailabilityRecoveryMessage::RecoverAvailableData(ref receipt, _, _, _, _) = message;
 		let candidate_hash = receipt.hash();
 
 		// For every 3rd block we immediately signal unavailability to trigger
@@ -160,7 +160,8 @@ impl RecoveryHandle for FailingRecoveryHandle {
 		if self.counter % 3 == 0 && self.failed_hashes.insert(candidate_hash) {
 			tracing::info!(target: LOG_TARGET, ?candidate_hash, "Failing pov recovery.");
 
-			let AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, back_sender) = message;
+			let AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, back_sender) =
+				message;
 			back_sender
 				.send(Err(RecoveryError::Unavailable))
 				.expect("Return channel should work here.");
diff --git a/cumulus/xcm/xcm-emulator/src/lib.rs b/cumulus/xcm/xcm-emulator/src/lib.rs
index a50f33951d056d56ab281934cc7987018d91f7c6..1a3f3930cb3478d9e7811c49becbfdd7874bbe48 100644
--- a/cumulus/xcm/xcm-emulator/src/lib.rs
+++ b/cumulus/xcm/xcm-emulator/src/lib.rs
@@ -215,6 +215,7 @@ pub trait Chain: TestExt {
 	type RuntimeOrigin;
 	type RuntimeEvent;
 	type System;
+	type OriginCaller;
 
 	fn account_id_of(seed: &str) -> AccountId {
 		helpers::get_account_id_from_seed::<sr25519::Public>(seed)
@@ -366,6 +367,7 @@ macro_rules! decl_test_relay_chains {
 				type RuntimeOrigin = $runtime::RuntimeOrigin;
 				type RuntimeEvent = $runtime::RuntimeEvent;
 				type System = $crate::SystemPallet::<Self::Runtime>;
+				type OriginCaller = $runtime::OriginCaller;
 
 				fn account_data_of(account: $crate::AccountIdOf<Self::Runtime>) -> $crate::AccountData<$crate::Balance> {
 					<Self as $crate::TestExt>::ext_wrapper(|| $crate::SystemPallet::<Self::Runtime>::account(account).data.into())
@@ -600,6 +602,7 @@ macro_rules! decl_test_parachains {
 				type RuntimeOrigin = $runtime::RuntimeOrigin;
 				type RuntimeEvent = $runtime::RuntimeEvent;
 				type System = $crate::SystemPallet::<Self::Runtime>;
+				type OriginCaller = $runtime::OriginCaller;
 				type Network = N;
 
 				fn account_data_of(account: $crate::AccountIdOf<Self::Runtime>) -> $crate::AccountData<$crate::Balance> {
diff --git a/docker/dockerfiles/binary_injected.Dockerfile b/docker/dockerfiles/binary_injected.Dockerfile
index c8930bd83f0274990aff281e84d75b7add9d1289..26c0ef7ae6414a472c04b17294d964572c14213a 100644
--- a/docker/dockerfiles/binary_injected.Dockerfile
+++ b/docker/dockerfiles/binary_injected.Dockerfile
@@ -32,7 +32,7 @@ LABEL io.parity.image.authors=${AUTHORS} \
 USER root
 WORKDIR /app
 
-# add polkadot binary to docker image
+# add binary to docker image
 # sample for polkadot: COPY ./polkadot ./polkadot-*-worker /usr/local/bin/
 COPY entrypoint.sh .
 COPY "bin/*" "/usr/local/bin/"
diff --git a/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile b/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile
index 196ba861f503c0fc82b6eb0e428df600ce6bfd49..e17952ccee804d5ff82339c1770f96f28c1cdab8 100644
--- a/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile
+++ b/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile
@@ -1,7 +1,7 @@
 # this image is built on top of existing Zombienet image
 ARG ZOMBIENET_IMAGE
 # this image uses substrate-relay image built elsewhere
-ARG SUBSTRATE_RELAY_IMAGE=docker.io/paritytech/substrate-relay:v1.5.0
+ARG SUBSTRATE_RELAY_IMAGE=docker.io/paritytech/substrate-relay:v1.6.4
 
 # metadata
 ARG VCS_REF
diff --git a/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile b/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile
index 7e460bb22e892a30d360a69815e43b8c197d0fda..b68bf93fce994620567e9d61879057a2b4632312 100644
--- a/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile
+++ b/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile
@@ -1,5 +1,5 @@
 # This is the build stage for Polkadot. Here we create the binary in a temporary image.
-FROM docker.io/paritytech/ci-linux:production as builder
+FROM docker.io/paritytech/ci-unified:bullseye-1.77.0-2024-04-10-v20240408 as builder
 
 WORKDIR /polkadot
 COPY . /polkadot
@@ -19,7 +19,8 @@ LABEL description="Multistage Docker image for Polkadot: a platform for web3" \
 
 COPY --from=builder /polkadot/target/release/polkadot /usr/local/bin
 
-RUN useradd -m -u 1000 -U -s /bin/sh -d /polkadot polkadot && \
+USER root
+RUN useradd -m -u 1001 -U -s /bin/sh -d /polkadot polkadot && \
 	mkdir -p /data /polkadot/.local/share && \
 	chown -R polkadot:polkadot /data && \
 	ln -s /data /polkadot/.local/share/polkadot && \
diff --git a/docker/scripts/chain-spec-builder/build-injected.sh b/docker/scripts/chain-spec-builder/build-injected.sh
new file mode 100755
index 0000000000000000000000000000000000000000..ede6cee3851382829d9f1793749a1358cf780edd
--- /dev/null
+++ b/docker/scripts/chain-spec-builder/build-injected.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+# Sample call:
+# $0 /path/to/folder_with_binary
+# This script replace the former dedicated Dockerfile
+# and shows how to use the generic binary_injected.dockerfile
+
+PROJECT_ROOT=`git rev-parse --show-toplevel`
+
+export BINARY=chain-spec-builder
+export ARTIFACTS_FOLDER=$1
+# export TAGS=...
+
+$PROJECT_ROOT/docker/scripts/build-injected.sh
diff --git a/docker/scripts/chain-spec-builder/test-build.sh b/docker/scripts/chain-spec-builder/test-build.sh
new file mode 100755
index 0000000000000000000000000000000000000000..a42cab97703481c03698c417b9e995618db8c0c1
--- /dev/null
+++ b/docker/scripts/chain-spec-builder/test-build.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+TMP=$(mktemp -d)
+ENGINE=${ENGINE:-podman}
+
+export TAGS=latest,beta,7777,1.0.2-rc23
+
+# Fetch some binaries
+$ENGINE run --user root --rm -i \
+  --pull always \
+  -v "$TMP:/export" \
+  --entrypoint /bin/bash \
+  parity/chain-spec-builder -c \
+  'cp "$(which chain-spec-builder)" /export'
+
+echo "Checking binaries we got:"
+ls -al $TMP
+
+./build-injected.sh $TMP
diff --git a/docs/RELEASE.md b/docs/RELEASE.md
index e73be2779a99426203e209da846f938c0f73cceb..653e6a2a3e929e052cdd839884ed30c5b5327201 100644
--- a/docs/RELEASE.md
+++ b/docs/RELEASE.md
@@ -45,7 +45,7 @@ variable.
 
 ## Westend & Rococo
 
-For the these networks, in addition to incrementing the `Cargo.toml` version we also increment the `spec_version` and
+For these networks, in addition to incrementing the `Cargo.toml` version we also increment the `spec_version` and
 sometimes the `transaction_version`. The spec version is also following the node version. Its schema is: `M_mmm_ppp` and
 for example `1_002_000` is the node release `1.2.0`. This versioning has no further meaning, and is only done to map
 from an on chain `spec_version` easily to the release in this repository.  
diff --git a/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png b/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png
new file mode 100644
index 0000000000000000000000000000000000000000..8909dc96a62a93f2bd8b9204e3f1a6885dffae52
Binary files /dev/null and b/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png differ
diff --git a/docs/images/Polkadot_Logo_Horizontal_Pink_White.png b/docs/images/Polkadot_Logo_Horizontal_Pink_White.png
new file mode 100644
index 0000000000000000000000000000000000000000..ea814ea28d5c813613c087f0a2fe0e3e1f8f4b52
Binary files /dev/null and b/docs/images/Polkadot_Logo_Horizontal_Pink_White.png differ
diff --git a/docs/mermaid/IA.mmd b/docs/mermaid/IA.mmd
index 4eb50bcf96a8932de3fa90748fcfeb3ca7f02a5f..37417497e1f84f3a54fb3e55da631c9ce363e700 100644
--- a/docs/mermaid/IA.mmd
+++ b/docs/mermaid/IA.mmd
@@ -1,5 +1,6 @@
 flowchart
     parity[paritytech.github.io] --> devhub[polkadot_sdk_docs]
+	polkadot_network[polkadot.network] --> devhub[polkadot_sdk_docs]
 
     devhub --> polkadot_sdk
     devhub --> reference_docs
@@ -8,7 +9,5 @@ flowchart
     polkadot_sdk --> substrate
     polkadot_sdk --> frame
     polkadot_sdk --> cumulus
-    polkadot_sdk --> polkadot
+    polkadot_sdk --> polkadot[polkadot node]
     polkadot_sdk --> xcm
-
-
diff --git a/docs/sdk/Cargo.toml b/docs/sdk/Cargo.toml
index 269ed4d012c8366bf5d7d9ae4bd18803dd0dea79..ee603f8c49465d79040dbc712051960c5696234a 100644
--- a/docs/sdk/Cargo.toml
+++ b/docs/sdk/Cargo.toml
@@ -15,7 +15,7 @@ workspace = true
 
 [dependencies]
 # Needed for all FRAME-based code
-parity-scale-codec = { version = "3.6.12", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
 scale-info = { version = "2.6.0", default-features = false }
 frame = { package = "polkadot-sdk-frame", path = "../../substrate/frame", features = [
 	"experimental",
@@ -30,6 +30,7 @@ simple-mermaid = "0.1.1"
 docify = "0.2.8"
 
 # Polkadot SDK deps, typically all should only be in scope such that we can link to their doc item.
+polkadot-sdk = { path = "../../umbrella", features = ["runtime"] }
 node-cli = { package = "staging-node-cli", path = "../../substrate/bin/node/cli" }
 kitchensink-runtime = { path = "../../substrate/bin/node/runtime" }
 chain-spec-builder = { package = "staging-chain-spec-builder", path = "../../substrate/bin/utils/chain-spec-builder" }
@@ -38,6 +39,7 @@ frame-system = { path = "../../substrate/frame/system", default-features = false
 frame-support = { path = "../../substrate/frame/support", default-features = false }
 frame-executive = { path = "../../substrate/frame/executive", default-features = false }
 pallet-example-single-block-migrations = { path = "../../substrate/frame/examples/single-block-migrations" }
+frame-metadata-hash-extension = { path = "../../substrate/frame/metadata-hash-extension" }
 
 # Substrate Client
 sc-network = { path = "../../substrate/client/network" }
@@ -53,14 +55,13 @@ sc-consensus-manual-seal = { path = "../../substrate/client/consensus/manual-sea
 sc-consensus-pow = { path = "../../substrate/client/consensus/pow" }
 sc-executor = { path = "../../substrate/client/executor" }
 sc-service = { path = "../../substrate/client/service" }
+sc-chain-spec = { path = "../../substrate/client/chain-spec" }
 
 substrate-wasm-builder = { path = "../../substrate/utils/wasm-builder" }
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../cumulus/pallets/aura-ext" }
-cumulus-pallet-parachain-system = { path = "../../cumulus/pallets/parachain-system", features = [
-	"parameterized-consensus-hook",
-] }
+cumulus-pallet-parachain-system = { path = "../../cumulus/pallets/parachain-system" }
 parachain-info = { package = "staging-parachain-info", path = "../../cumulus/parachains/pallets/parachain-info" }
 cumulus-primitives-proof-size-hostfunction = { path = "../../cumulus/primitives/proof-size-hostfunction" }
 cumulus-client-service = { path = "../../cumulus/client/service" }
@@ -82,22 +83,33 @@ pallet-democracy = { path = "../../substrate/frame/democracy" }
 pallet-uniques = { path = "../../substrate/frame/uniques" }
 pallet-nfts = { path = "../../substrate/frame/nfts" }
 pallet-scheduler = { path = "../../substrate/frame/scheduler" }
+pallet-referenda = { path = "../../substrate/frame/referenda" }
+pallet-broker = { path = "../../substrate/frame/broker" }
+pallet-babe = { path = "../../substrate/frame/babe" }
 
 # Primitives
 sp-io = { path = "../../substrate/primitives/io" }
+sp-std = { path = "../../substrate/primitives/std" }
+sp-tracing = { path = "../../substrate/primitives/tracing" }
+sp-runtime-interface = { path = "../../substrate/primitives/runtime-interface" }
 sp-api = { path = "../../substrate/primitives/api" }
 sp-core = { path = "../../substrate/primitives/core" }
 sp-keyring = { path = "../../substrate/primitives/keyring" }
 sp-runtime = { path = "../../substrate/primitives/runtime" }
 sp-arithmetic = { path = "../../substrate/primitives/arithmetic" }
-
-# Misc pallet dependencies
-pallet-referenda = { path = "../../substrate/frame/referenda" }
-pallet-broker = { path = "../../substrate/frame/broker" }
-pallet-babe = { path = "../../substrate/frame/babe" }
-
+sp-genesis-builder = { path = "../../substrate/primitives/genesis-builder" }
 sp-offchain = { path = "../../substrate/primitives/offchain" }
 sp-version = { path = "../../substrate/primitives/version" }
 
+
 # XCM
 xcm = { package = "staging-xcm", path = "../../polkadot/xcm" }
+xcm-docs = { path = "../../polkadot/xcm/docs" }
+
+# runtime guides
+chain-spec-guide-runtime = { path = "./src/reference_docs/chain_spec_runtime" }
+
+# Templates
+minimal-template-runtime = { path = "../../templates/minimal/runtime" }
+solochain-template-runtime = { path = "../../templates/solochain/runtime" }
+parachain-template-runtime = { path = "../../templates/parachain/runtime" }
diff --git a/docs/sdk/src/guides/enable_metadata_hash.rs b/docs/sdk/src/guides/enable_metadata_hash.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b9cbae8533538d685f39d1cde979758dcc59955b
--- /dev/null
+++ b/docs/sdk/src/guides/enable_metadata_hash.rs
@@ -0,0 +1,88 @@
+//! # Enable metadata hash verification
+//!
+//! This guide will teach you how to enable the metadata hash verification in your runtime.
+//!
+//! ## What is metadata hash verification?
+//!
+//! Each FRAME based runtime exposes metadata about itself. This metadata is used by consumers of
+//! the runtime to interpret the state, to construct transactions etc. Part of this metadata are the
+//! type information. These type information can be used to e.g. decode storage entries or to decode
+//! a transaction. So, the metadata is quite useful for wallets to interact with a FRAME based
+//! chain. Online wallets can fetch the metadata directly from any node of the chain they are
+//! connected to, but offline wallets can not do this. So, for the offline wallet to have access to
+//! the metadata it needs to be transferred and stored on the device. The problem is that the
+//! metadata has a size of several hundreds of kilobytes, which takes quite a while to transfer to
+//! these offline wallets and the internal storage of these devices is also not big enough to store
+//! the metadata for one or more networks. The next problem is that the offline wallet/user can not
+//! trust the metadata to be correct. It is very important for the metadata to be correct or
+//! otherwise an attacker could change them in a way that the offline wallet decodes a transaction
+//! in a different way than what it will be decoded to on chain. So, the user may signs an incorrect
+//! transaction leading to unexpecting behavior.
+//!
+//! The metadata hash verification circumvents the issues of the huge metadata and the need to trust
+//! some metadata blob to be correct. To generate a hash for the metadata, the metadata is chunked,
+//! these chunks are put into a merkle tree and then the root of this merkle tree is the "metadata
+//! hash". For a more technical explanation on how it works, see
+//! [RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html). At compile
+//! time the metadata hash is generated and "backed" into the runtime. This makes it extremely cheap
+//! for the runtime to verify on chain that the metadata hash is correct. By having the runtime
+//! verify the hash on chain, the user also doesn't need to trust the offchain metadata. If the
+//! metadata hash doesn't match the on chain metadata hash the transaction will be rejected. The
+//! metadata hash itself is added to the data of the transaction that is signed, this means the
+//! actual hash does not appear in the transaction. On chain the same procedure is repeated with the
+//! metadata hash that is known by the runtime and if the metadata hash doesn't match the signature
+//! verification will fail. As the metadata hash is actually the root of a merkle tree, the offline
+//! wallet can get proofs of individual types to decode a transaction. This means that the offline
+//! wallet does not require the entire metadata to be present on the device.
+//!
+//! ## Integrating metadata hash verification into your runtime
+//!
+//! The integration of the metadata hash verification is split into two parts, first the actual
+//! integration into the runtime and secondly the enabling of the metadata hash generation at
+//! compile time.
+//!
+//! ### Runtime integration
+//!
+//! From the runtime side only the
+//! [`CheckMetadataHash`](frame_metadata_hash_extension::CheckMetadataHash) needs to be added to the
+//! list of signed extension:
+#![doc = docify::embed!("../../templates/parachain/runtime/src/lib.rs", template_signed_extra)]
+//!
+//! > **Note:**
+//! >
+//! > Adding the signed extension changes the encoding of the transaction and adds one extra byte
+//! > per transaction!
+//!
+//! This signed extension will make sure to decode the requested `mode` and will add the metadata
+//! hash to the signed data depending on the requested `mode`. The `mode` gives the user/wallet
+//! control over deciding if the metadata hash should be verified or not. The metadata hash itself
+//! is drawn from the `RUNTIME_METADATA_HASH` environment variable. If the environment variable is
+//! not set, any transaction that requires the metadata hash is rejected with the error
+//! `CannotLookup`. This is a security measurement to prevent including invalid transactions.
+//!
+//! <div class="warning">
+//!
+//! The extension does not work with the native runtime, because the
+//! `RUNTIME_METADATA_HASH` environment variable is not set when building the
+//! `frame-metadata-hash-extension` crate.
+//!
+//! </div>
+//!
+//! ### Enable metadata hash generation
+//!
+//! The metadata hash generation needs to be enabled when building the wasm binary. The
+//! `substrate-wasm-builder` supports this out of the box:
+#![doc = docify::embed!("../../templates/parachain/runtime/build.rs", template_enable_metadata_hash)]
+//!
+//! > **Note:**
+//! >
+//! > The `metadata-hash` feature needs to be enabled for the `substrate-wasm-builder` to enable the
+//! > code for being able to generate the metadata hash. It is also recommended to put the metadata
+//! > hash generation behind a feature in the runtime as shown above. The reason behind is that it
+//! > adds a lot of code which increases the compile time and the generation itself also increases
+//! > the compile time. Thus, it is recommended to enable the feature only when the metadata hash is
+//! > required (e.g. for an on-chain build).
+//!
+//! The two parameters to `enable_metadata_hash` are the token symbol and the number of decimals of
+//! the primary token of the chain. These information are included for the wallets to show token
+//! related operations in a more user friendly way.
diff --git a/docs/sdk/src/guides/mod.rs b/docs/sdk/src/guides/mod.rs
index 2dc807af8eaed45d78109bd1b22528d94e24bf06..485cdc30636f2751145188c5d13a99b7d6fd6726 100644
--- a/docs/sdk/src/guides/mod.rs
+++ b/docs/sdk/src/guides/mod.rs
@@ -1,7 +1,16 @@
 //! # Polkadot SDK Docs Guides
 //!
-//! This crate contains a collection of guides that are foundational to the developers of
-//! Polkadot SDK. They are common user-journeys that are traversed in the Polkadot ecosystem.
+//! This crate contains a collection of guides that are foundational to the developers of Polkadot
+//! SDK. They are common user-journeys that are traversed in the Polkadot ecosystem.
+//!
+//! 1. [`crate::guides::your_first_pallet`] is your starting point with Polkadot SDK. It contains
+//!    the basics of
+//! building a simple crypto currency with FRAME.
+//! 2. [`crate::guides::your_first_runtime`] is the next step in your journey. It contains the
+//!    basics of building a runtime that contains this pallet, plus a few common pallets from FRAME.
+//!
+//!
+//! Other guides are related to other miscellaneous topics and are listed as modules below.
 
 /// Write your first simple pallet, learning the most most basic features of FRAME along the way.
 pub mod your_first_pallet;
@@ -11,18 +20,21 @@ pub mod your_first_pallet;
 pub mod your_first_runtime;
 
 /// Running the given runtime with a node. No specific consensus mechanism is used at this stage.
-pub mod your_first_node;
-
-/// How to change the consensus engine of both the node and the runtime.
-pub mod changing_consensus;
+// TODO
+// pub mod your_first_node;
 
 /// How to enhance a given runtime and node to be cumulus-enabled, run it as a parachain and connect
 /// it to a relay-chain.
-pub mod cumulus_enabled_parachain;
+// TODO
+// pub mod cumulus_enabled_parachain;
 
 /// How to make a given runtime XCM-enabled, capable of sending messages (`Transact`) between itself
 /// and the relay chain to which it is connected.
-pub mod xcm_enabled_parachain;
+// TODO
+// pub mod xcm_enabled_parachain;
 
 /// How to enable storage weight reclaiming in a parachain node and runtime.
 pub mod enable_pov_reclaim;
+
+/// How to enable metadata hash verification in the runtime.
+pub mod enable_metadata_hash;
diff --git a/docs/sdk/src/guides/your_first_pallet/mod.rs b/docs/sdk/src/guides/your_first_pallet/mod.rs
index c6e0dd0edf8925105661591d0831d65ff8ed02be..da4624f5ac2b85dcf884798fefca42da229760e0 100644
--- a/docs/sdk/src/guides/your_first_pallet/mod.rs
+++ b/docs/sdk/src/guides/your_first_pallet/mod.rs
@@ -14,18 +14,14 @@
 //! > FRAME-based runtimes use various techniques to re-use a currency pallet instead of writing
 //! > one. Further advanced FRAME related topics are discussed in [`crate::reference_docs`].
 //!
-//! ## Topics Covered
+//! ## Writing Your First Pallet
 //!
-//! The following FRAME topics are covered in this guide:
+//! To get started, use one of the templates mentioned in [`crate::polkadot_sdk::templates`]. We
+//! recommend using the `polkadot-sdk-minimal-template`. You might need to change small parts of
+//! this guide, namely the crate/package names, based on which tutorial you use.
 //!
-//! - [Storage](frame::pallet_macros::storage)
-//! - [Call](frame::pallet_macros::call)
-//! - [Event](frame::pallet_macros::event)
-//! - [Error](frame::pallet_macros::error)
-//! - Basics of testing a pallet
-//! - [Constructing a runtime](frame::runtime::prelude::construct_runtime)
-//!
-//! ## Writing Your First Pallet
+//! > Be aware that you can read the entire source code backing this tutorial by clicking on the
+//! > [`source`](./mod.rs.html) button at the top right of the page.
 //!
 //! You should have studied the following modules as a prelude to this guide:
 //!
@@ -33,16 +29,28 @@
 //! - [`crate::reference_docs::trait_based_programming`]
 //! - [`crate::polkadot_sdk::frame_runtime`]
 //!
+//! ## Topics Covered
+//!
+//! The following FRAME topics are covered in this guide:
+//!
+//! - [`pallet::storage`]
+//! - [`pallet::call`]
+//! - [`pallet::event`]
+//! - [`pallet::error`]
+//! - Basics of testing a pallet
+//! - [Constructing a runtime](frame::runtime::prelude::construct_runtime)
+//!
 //! ### Shell Pallet
 //!
 //! Consider the following as a "shell pallet". We continue building the rest of this pallet based
 //! on this template.
 //!
-//! [`pallet::config`](frame::pallet_macros::config) and
-//! [`pallet::pallet`](frame::pallet_macros::pallet) are both mandatory parts of any pallet. Refer
-//! to the documentation of each to get an overview of what they do.
+//! [`pallet::config`] and [`pallet::pallet`] are both mandatory parts of any pallet. Refer to the
+//! documentation of each to get an overview of what they do.
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", shell_pallet)]
 //!
+//! All of the code that follows in this guide should live inside of the `mod pallet`.
+//!
 //! ### Storage
 //!
 //! First, we will need to create two onchain storage declarations.
@@ -55,15 +63,14 @@
 //! > generic bounded type in the `Config` trait, and then specify it in the implementation.
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Balance)]
 //!
-//! The definition of these two storage items, based on [`frame::pallet_macros::storage`] details,
-//! is as follows:
+//! The definition of these two storage items, based on [`pallet::storage`] details, is as follows:
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", TotalIssuance)]
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Balances)]
 //!
 //! ### Dispatchables
 //!
-//! Next, we will define the dispatchable functions. As per [`frame::pallet_macros::call`], these
-//! will be defined as normal `fn`s attached to `struct Pallet`.
+//! Next, we will define the dispatchable functions. As per [`pallet::call`], these will be defined
+//! as normal `fn`s attached to `struct Pallet`.
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", impl_pallet)]
 //!
 //! The logic of the functions is self-explanatory. Instead, we will focus on the FRAME-related
@@ -79,7 +86,6 @@
 //!   was signed by `who`.
 #![doc = docify::embed!("../../substrate/frame/system/src/lib.rs", ensure_signed)]
 //!
-//!
 //! - Where does `mutate`, `get` and `insert` and other storage APIs come from? All of them are
 //! explained in the corresponding `type`, for example, for `Balances::<T>::insert`, you can look
 //! into [`frame::prelude::StorageMap::insert`].
@@ -95,8 +101,7 @@
 //!
 //! - Why are all `get` and `mutate` functions returning an `Option`? This is the default behavior
 //!   of FRAME storage APIs. You can learn more about how to override this by looking into
-//!   [`frame::pallet_macros::storage`], and
-//!   [`frame::prelude::ValueQuery`]/[`frame::prelude::OptionQuery`]
+//!   [`pallet::storage`], and [`frame::prelude::ValueQuery`]/[`frame::prelude::OptionQuery`]
 //!
 //! ### Improving Errors
 //!
@@ -116,6 +121,25 @@
 //!
 //! ### Your First (Test) Runtime
 //!
+//! The typical testing code of a pallet lives in a module that imports some preludes useful for
+//! testing, similar to:
+//!
+//! ```
+//! pub mod pallet {
+//! 	// snip -- actually pallet code.
+//! }
+//!
+//! #[cfg(test)]
+//! mod tests {
+//! 	// bring in the testing prelude of frame
+//! 	use frame::testing_prelude::*;
+//! 	// bring in all pallet items
+//! 	use super::pallet::*;
+//!
+//! 	// snip -- rest of the testing code.
+//! }
+//! ```
+//!
 //! Next, we create a "test runtime" in order to test our pallet. Recall from
 //! [`crate::polkadot_sdk::frame_runtime`] that a runtime is a collection of pallets, expressed
 //! through [`frame::runtime::prelude::construct_runtime`]. All runtimes also have to include
@@ -166,7 +190,6 @@
 //! As noted above, the `T::AccountId` is now `u64`. Moreover, `Runtime` is replacing `<T: Config>`.
 //! This is why for example you see `Balances::<Runtime>::get(..)`. Finally, notice that the
 //! dispatchables are simply functions that can be called on top of the `Pallet` struct.
-// TODO: hard to explain exactly `RuntimeOrigin::signed(ALICE)` at this point.
 //!
 //! Congratulations! You have written your first pallet and tested it! Next, we learn a few optional
 //! steps to improve our pallet.
@@ -236,8 +259,7 @@
 //!   by one character. FRAME errors are exactly a solution to maintain readability, whilst fixing
 //!   the drawbacks mentioned. In short, we use an enum to represent different variants of our
 //!   error. These variants are then mapped in an efficient way (using only `u8` indices) to
-//!   [`sp_runtime::DispatchError::Module`]. Read more about this in
-//!   [`frame::pallet_macros::error`].
+//!   [`sp_runtime::DispatchError::Module`]. Read more about this in [`pallet::error`].
 //!
 //! - **Event**: Events are akin to the return type of dispatchables. They are mostly data blobs
 //!   emitted by the runtime to let outside world know what is happening inside the pallet. Since
@@ -246,20 +268,16 @@
 //!   use passive tense for event names (eg. `SomethingHappened`). This allows other sub-systems or
 //!   external parties (eg. a light-node, a DApp) to listen to particular events happening, without
 //!   needing to re-execute the whole state transition function.
-// TODO: both need to be improved a lot at the pallet-macro rust-doc level. Also my explanation
-// of event is probably not the best.
 //!
 //! With the explanation out of the way, let's see how these components can be added. Both follow a
-//! fairly familiar syntax: normal Rust enums, with extra
-//! [`#[frame::event]`](frame::pallet_macros::event) and
-//! [`#[frame::error]`](frame::pallet_macros::error) attributes attached.
+//! fairly familiar syntax: normal Rust enums, with extra [`pallet::event`] and [`pallet::error`]
+//! attributes attached.
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Event)]
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Error)]
 //!
-//! One slightly custom part of this is the [`#[pallet::generate_deposit(pub(super) fn
-//! deposit_event)]`](frame::pallet_macros::generate_deposit) part. Without going into too
-//! much detail, in order for a pallet to emit events to the rest of the system, it needs to do two
-//! things:
+//! One slightly custom part of this is the [`pallet::generate_deposit`] part. Without going into
+//! too much detail, in order for a pallet to emit events to the rest of the system, it needs to do
+//! two things:
 //!
 //! 1. Declare a type in its `Config` that refers to the overarching event type of the runtime. In
 //! short, by doing this, the pallet is expressing an important bound: `type RuntimeEvent:
@@ -268,8 +286,8 @@
 //! store it where needed.
 //!
 //! 2. But, doing this conversion and storing is too much to expect each pallet to define. FRAME
-//! provides a default way of storing events, and this is what
-//! [`pallet::generate_deposit`](frame::pallet_macros::generate_deposit) is doing.
+//! provides a default way of storing events, and this is what [`pallet::generate_deposit`] is
+//! doing.
 #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", config_v2)]
 //!
 //! > These `Runtime*` types are better explained in
@@ -297,10 +315,17 @@
 //! - [`crate::reference_docs::defensive_programming`].
 //! - [`crate::reference_docs::frame_origin`].
 //! - [`crate::reference_docs::frame_runtime_types`].
-//! - The pallet we wrote in this guide was using `dev_mode`, learn more in
-//!   [`frame::pallet_macros::config`].
+//! - The pallet we wrote in this guide was using `dev_mode`, learn more in [`pallet::config`].
 //! - Learn more about the individual pallet items/macros, such as event and errors and call, in
 //!   [`frame::pallet_macros`].
+//!
+//! [`pallet::storage`]: ../../../frame_support/pallet_macros/attr.config.html
+//! [`pallet::call`]: ../../../frame_support/pallet_macros/attr.call.html
+//! [`pallet::event`]: ../../../frame_support/pallet_macros/attr.event.html
+//! [`pallet::error`]: ../../../frame_support/pallet_macros/attr.error.html
+//! [`pallet::pallet`]: ../../../frame_support/pallet_macros/attr.pallet.html
+//! [`pallet::config`]: ../../../frame_support/pallet_macros/attr.config.html
+//! [`pallet::generate_deposit`]: ../../../frame_support/pallet_macros/attr.generate_deposit.html
 
 #[docify::export]
 #[frame::pallet(dev_mode)]
@@ -418,16 +443,22 @@ pub mod pallet {
 	#[cfg(any(test, doc))]
 	pub(crate) mod tests {
 		use crate::guides::your_first_pallet::pallet::*;
+
+		#[docify::export(testing_prelude)]
 		use frame::testing_prelude::*;
-		const ALICE: u64 = 1;
-		const BOB: u64 = 2;
-		const CHARLIE: u64 = 3;
+
+		pub(crate) const ALICE: u64 = 1;
+		pub(crate) const BOB: u64 = 2;
+		pub(crate) const CHARLIE: u64 = 3;
 
 		#[docify::export]
+		// This runtime is only used for testing, so it should be somewhere like `#[cfg(test)] mod
+		// tests { .. }`
 		mod runtime {
 			use super::*;
 			// we need to reference our `mod pallet` as an identifier to pass to
 			// `construct_runtime`.
+			// YOU HAVE TO CHANGE THIS LINE BASED ON YOUR TEMPLATE
 			use crate::guides::your_first_pallet::pallet as pallet_currency;
 
 			construct_runtime!(
@@ -595,7 +626,7 @@ pub mod pallet {
 		#[test]
 		fn transfer_works() {
 			StateBuilder::default().build_and_execute(|| {
-				// given the the initial state, when:
+				// given the initial state, when:
 				assert_ok!(Pallet::<Runtime>::transfer(RuntimeOrigin::signed(ALICE), BOB, 50));
 
 				// then:
@@ -617,7 +648,7 @@ pub mod pallet {
 		#[test]
 		fn transfer_from_non_existent_fails() {
 			StateBuilder::default().build_and_execute(|| {
-				// given the the initial state, when:
+				// given the initial state, when:
 				assert_err!(
 					Pallet::<Runtime>::transfer(RuntimeOrigin::signed(CHARLIE), ALICE, 10),
 					"NonExistentAccount"
@@ -738,7 +769,7 @@ pub mod pallet_v2 {
 				// the final assertion.
 				System::set_block_number(ALICE);
 
-				// given the the initial state, when:
+				// given the initial state, when:
 				assert_ok!(Pallet::<Runtime>::transfer(RuntimeOrigin::signed(ALICE), BOB, 50));
 
 				// then:
diff --git a/docs/sdk/src/guides/your_first_runtime.rs b/docs/sdk/src/guides/your_first_runtime.rs
index 3e02ef1b1b28eedb7cea0ce38fb8b372a0caaf60..c58abc1120c13f5d9d724f7dd78464380f8840bf 100644
--- a/docs/sdk/src/guides/your_first_runtime.rs
+++ b/docs/sdk/src/guides/your_first_runtime.rs
@@ -1 +1,3 @@
 //! # Your first Runtime
+//!
+//! 🚧 <https://github.com/paritytech/polkadot-sdk/pull/3946>
diff --git a/docs/sdk/src/polkadot_sdk/polkadot.rs b/docs/sdk/src/polkadot_sdk/polkadot.rs
index 61a6877696cb9298ed831562923d96d4a701bcc4..e2dcca4dc7dfcd2726d24b9f7725a67bad50246b 100644
--- a/docs/sdk/src/polkadot_sdk/polkadot.rs
+++ b/docs/sdk/src/polkadot_sdk/polkadot.rs
@@ -6,14 +6,16 @@
 //!
 //! - [Polkadot Forum](https://forum.polkadot.network/)
 //! - [Polkadot Parachains](https://parachains.info/)
-//! - [Polkadot (multi-chain) Explorer](https://subscan.io/)
+//! - [Polkadot (multi-chain) Explorer: Subscan](https://subscan.io/)
 //! - Polkadot Fellowship
 //!     - [Manifesto](https://github.com/polkadot-fellows/manifesto)
 //!     - [Runtimes](https://github.com/polkadot-fellows/runtimes)
 //!     - [RFCs](https://github.com/polkadot-fellows/rfcs)
+//! 	- [Dashboard](https://polkadot-fellows.github.io/dashboard/)
 //! - [Polkadot Specs](spec.polkadot.network)
 //! - [The Polkadot Parachain Host Implementers' Guide](https://paritytech.github.io/polkadot-sdk/book/)
 //! - [Whitepaper](https://www.polkadot.network/whitepaper/)
+//! - [JAM Graypaper](https://graypaper.com)
 //!
 //! ## Alternative Node Implementations 🌈
 //!
diff --git a/docs/sdk/src/polkadot_sdk/templates.rs b/docs/sdk/src/polkadot_sdk/templates.rs
index 4bf0e839c798fc55dd1fa0696c6bfe8411c32bc8..e87eb9c2bc8abe72538f4bc88a8f6348e1e90343 100644
--- a/docs/sdk/src/polkadot_sdk/templates.rs
+++ b/docs/sdk/src/polkadot_sdk/templates.rs
@@ -1,19 +1,33 @@
 //! # Templates
 //!
-//! ### Internal
+//! This document enumerates a non-exhaustive list of templates that one can use to get started with
+//! polkadot-sdk.
 //!
-//! The following templates are maintained as a part of the `polkadot-sdk` repository:
+//! > Know more tools/templates that are not listed here? please contribute them by opening a PR.
 //!
-//! - classic [`substrate-node-template`]: is a white-labeled substrate-based blockchain with a
-//!   moderate amount of features. It can act as a great starting point for those who want to learn
-//!   Substrate/FRAME and want to have a template that is already doing something.
-//! - [`substrate-minimal-template`]: Same as the above, but it contains the least amount of code in
-//!   both the node and runtime. It is a great starting point for those who want to deeply learn
-//!   Substrate and FRAME.
-//! - classic [`cumulus-parachain-template`], which is the de-facto parachain template shipped with
-//!   Cumulus. It is the parachain-enabled version of [`substrate-node-template`].
+//! ## Internal
 //!
-//! ### External Templates
+//! The following [templates](https://github.com/paritytech/polkadot-sdk/blob/master/templates) are
+//! maintained as a part of the `polkadot-sdk` repository:
+//!
+//! - `minimal_template_node`/[`minimal_template_runtime`]: A minimal template that contains the
+//!   least amount of features to be a functioning blockchain. Suitable for learning, development
+//!   and testing. This template is not meant to be used in production.
+//! - `solochain_template_node`/[`solochain_template_runtime`]: Formerly known as
+//!   "substrate-node-template", is a white-labeled substrate-based blockchain (aka. solochain) that
+//!   contains moderate features, such as a basic consensus engine and some FRAME pallets. This
+//!   template can act as a good starting point for those who want to launch a solochain.
+//! - `parachain_template_node`/[`parachain_template_runtime`]: A parachain template ready to be
+//!   connected to a test relay-chain.
+//!
+//! These templates are always kept up to date, and are mirrored to external repositories for easy
+//! forking:
+//!
+//! - <https://github.com/paritytech/polkadot-sdk-minimal-template>
+//! - <https://github.com/paritytech/polkadot-sdk-solochain-template>
+//! - <https://github.com/paritytech/polkadot-sdk-parachain-template>
+//!
+//! ## External Templates
 //!
 //! Noteworthy templates outside of this repository.
 //!
@@ -22,23 +36,17 @@
 //! - [`frontier-parachain-template`](https://github.com/paritytech/frontier-parachain-template): A
 //!   parachain template for launching EVM-compatible parachains.
 //!
-//! [`minimal-template`]: https://github.com/paritytech/polkadot-sdk/blob/master/templates/minimal/
-//! [`parachain-template`]: https://github.com/paritytech/polkadot-sdk/blob/master/templates/parachain/
-
-// TODO: in general, we need to make a deliberate choice here of moving a few key templates to this
-// repo (nothing stays in `substrate-developer-hub`) and the everything else should be community
-// maintained. https://github.com/paritytech/polkadot-sdk-docs/issues/67
-
-// TODO: we should rename `substrate-node-template` to `substrate-basic-template`,
-// `substrate-blockchain-template`. `node` is confusing in the name.
-// `substrate-blockchain-template` and `cumulus-parachain-template` go well together 🤝. https://github.com/paritytech/polkadot-sdk-docs/issues/67
-
-// NOTE: a super important detail that I am looking forward to here is
-// <https://github.com/paritytech/polkadot-sdk/issues/62#issuecomment-1691523754> and
-// <https://github.com/paritytech/polkadot-sdk/issues/5>. Meaning that I would not spend time on
-// teaching someone too much detail about the ugly thing we call "node" nowadays. In the future, I
-// am sure we will either have a better "node-builder" code that can actually be tested, or an
-// "omni-node" that can run (almost) any wasm file. We should already build tutorials in this
-// direction IMO. This also affects all the templates. If we have a good neat runtime file, which we
-// are moving toward, and a good node-builder, we don't need all of these damn templates. These
-// templates are only there because the boilerplate is super horrible atm.
+//! ## OpenZeppelin
+//!
+//! In June 2023, OpenZeppelin was awarded a grant from the [Polkadot
+//! treasury](https://polkadot.polkassembly.io/treasury/406) for building a number of Polkadot-sdk
+//! based templates. These templates are expected to be a great starting point for developers.
+//!
+//! - <https://github.com/OpenZeppelin/polkadot-runtime-template/>
+//!
+//! ## POP-CLI
+//!
+//! Is a CLI tool capable of scaffolding a new polkadot-sdk-based project, possibly removing the
+//! need for templates.
+//!
+//! - <https://pop.r0gue.io/cli/>
diff --git a/docs/sdk/src/polkadot_sdk/xcm.rs b/docs/sdk/src/polkadot_sdk/xcm.rs
index 5dcdc9e1de076c4507cb64517360df73e6733dc7..58f54068642444e2010d3623d6a49d00f050ebf8 100644
--- a/docs/sdk/src/polkadot_sdk/xcm.rs
+++ b/docs/sdk/src/polkadot_sdk/xcm.rs
@@ -50,7 +50,7 @@
 //!
 //! ## Get started
 //!
-//! To learn how it works and to get started, go to the [XCM docs](https://paritytech.github.io/xcm-docs/).
+//! To learn how it works and to get started, go to the [XCM docs](xcm_docs).
 
 #[cfg(test)]
 mod tests {
diff --git a/docs/sdk/src/reference_docs/blockchain_scalibility.rs b/docs/sdk/src/reference_docs/blockchain_scalibility.rs
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/docs/sdk/src/reference_docs/chain_spec_genesis.rs b/docs/sdk/src/reference_docs/chain_spec_genesis.rs
index 2ac51a91f2de78cf10262e5b38c2ebf482c15183..557795cb410c01e3d2faea3941b8efd4d0372fa4 100644
--- a/docs/sdk/src/reference_docs/chain_spec_genesis.rs
+++ b/docs/sdk/src/reference_docs/chain_spec_genesis.rs
@@ -1,4 +1,186 @@
-//! Chain spec and genesis build.
+//! # What is chain-spec.
 //!
-//! What is chain-spec.
-//! What is genesis state and how to build it.
+//! A chain specification file defines the set of properties that are required to run the node as
+//! part of the chain. The chain specification consists of two main parts:
+//! - initial state of the runtime,
+//! - network / logical properties of the chain, the most important property being the list of
+//!   bootnodes.
+//!
+//! This document describes how the initial state is handled in pallets and runtime, and how to
+//! interact with the runtime in order to build the genesis state.
+//!
+//! For more information on chain specification and its properties, refer to
+//! [`sc_chain_spec#from-initial-state-to-raw-genesis`].
+//!
+//! The initial genesis state can be provided in the following formats:
+//!   - full
+//!   - patch
+//!   - raw
+//!
+//! Each of the formats is explained in [_chain-spec-format_][`sc_chain_spec#chain-spec-formats`].
+//!
+//!
+//! # `GenesisConfig` for `pallet`
+//!
+//! Every frame pallet may have its initial state which is defined by the `GenesisConfig` internal
+//! struct. It is a regular Rust struct, annotated with the [`pallet::genesis_config`] attribute.
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_bar_GenesisConfig)]
+//!
+//! The struct shall be defined within the pallet `mod`, as in the following code:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_bar)]
+//!
+//! The initial state conveyed in  the `GenesisConfig` struct is transformed into state storage
+//! items by means of the [`BuildGenesisConfig`] trait, which shall be implemented for the pallet's
+//! `GenesisConfig` struct. The [`pallet::genesis_build`] attribute shall be attached to the `impl`
+//! block:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_bar_build)]
+//!
+//! `GenesisConfig` may also contain more complicated types, including nested structs or enums, as
+//! in the example for `pallet_foo`:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_foo_GenesisConfig)]
+//!
+//! Note that [`serde`] attributes can be used to control how the data
+//! structures are stored into JSON. In the following example, the [`sp_core::bytes`] function is
+//! used to serialize the `values` field.
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", SomeFooData2)]
+//!
+//! Please note that fields of `GenesisConfig` may not be directly mapped to storage items. In the
+//! following example, the initial struct fields are used to compute (sum) the value that will be
+//! stored in the state as `ProcessedEnumValue`:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_foo_build)]
+//!
+//! # `GenesisConfig` for `runtimes`
+//!
+//! The runtime genesis config struct consists of configs for every pallet. For the [_demonstration
+//! runtime_][`chain_spec_guide_runtime`] used in this guide, it consists of `SystemConfig`,
+//! `BarConfig`, and `FooConfig`. This structure was automatically generated by a macro and it can
+//! be sneak-peeked here: [`RuntimeGenesisConfig`]. For further reading on generated runtime
+//! types, refer to [`frame_runtime_types`].
+//!
+//! The macro automatically adds an attribute that renames all the fields to [`camelCase`]. It is a
+//! good practice to add it to nested structures too, to have the naming of the JSON keys consistent
+//! across the chain-spec file.
+//!
+//! ## `Default` for `GenesisConfig`
+//!
+//! `GenesisConfig` of all pallets must implement the `Default` trait. These are aggregated into
+//! the runtime's `RuntimeGenesisConfig`'s `Default`.
+//!
+//! The default value of `RuntimeGenesisConfig` can be queried by the [`GenesisBuilder::get_preset`]
+//! function provided by the runtime with `id:None`.
+//!
+//! A default value for `RuntimeGenesisConfig` usually is not operational. This is because for some
+//! pallets it is not possible to define good defaults (e.g. an initial set of authorities).
+//!
+//! A default value is a base upon which a patch for `GenesisConfig` is applied. A good description
+//! of how it exactly works is provided in [`get_storage_for_patch`] (and also in
+//! [`GenesisBuilder::get_preset`]). A patch can be provided as an external file (manually created)
+//! or as a built-in runtime preset. More info on presets is in the material to follow.
+//!
+//! ## Implementing `GenesisBuilder` for runtime
+//!
+//! The runtime exposes a dedicated runtime API for interacting with its genesis config:
+//! [`sp_genesis_builder::GenesisBuilder`]. The implementation shall be provided within
+//! the [`sp_api::impl_runtime_apis`] macro, typically making use of some helpers provided:
+//! [`build_state`], [`get_preset`].
+//! A typical implementation of [`sp_genesis_builder::GenesisBuilder`] looks as follows:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/runtime.rs", runtime_impl)]
+//!
+//! Please note that two functions are customized: `preset_names` and `get_preset`. The first one
+//! just provides a `Vec` of the names of supported presets, while the latter delegates the call
+//! to a function that maps the name to an actual preset:
+//! [`chain_spec_guide_runtime::presets::get_builtin_preset`]
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", get_builtin_preset)]
+//!
+//! ## Genesis state presets for runtime
+//!
+//! The runtime may provide many flavors of initial genesis state. This may be useful for predefined
+//! testing networks, local development, or CI integration tests. Predefined genesis state may
+//! contain a list of pre-funded accounts, predefined authorities for consensus, sudo key, and many
+//! others useful for testing.
+//!
+//! Internally, presets can be provided in a number of ways:
+//! - JSON in string form:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_1)]
+//! - JSON using runtime types to serialize values:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_2)]
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_3)]
+//! It is worth noting that a preset does not have to be the full `RuntimeGenesisConfig`, in that
+//! sense that it does not have to contain all the keys of the struct. The preset is actually a JSON
+//! patch that will be merged with the default value of `RuntimeGenesisConfig`. This approach should
+//! simplify maintenance of built-in presets. The following example illustrates a runtime genesis
+//! config patch:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_4)]
+//!
+//! ## Note on the importance of testing presets
+//!
+//! It is recommended to always test presets by adding tests that convert the preset into the
+//! raw storage. Converting to raw storage involves the deserialization of the provided JSON blob,
+//! which enforces the verification of the preset. The following code shows one of the approaches
+//! that can be taken for testing:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", check_presets)]
+//!
+//! ## Note on the importance of using the `deny_unknown_fields` attribute
+//!
+//! It is worth noting that it is easy to make a hard-to-spot mistake, as in the following example
+//! ([`FooStruct`] does not contain `fieldC`):
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_invalid)]
+//! Even though `preset_invalid` contains a key that does not exist, the deserialization of the JSON
+//! blob does not fail. The misspelling is silently ignored due to the lack of the
+//! [`deny_unknown_fields`] attribute on the [`FooStruct`] struct, which is internally used in
+//! `GenesisConfig`.
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", invalid_preset_works)]
+//!
+//! ## Runtime `GenesisConfig` raw format
+//!
+//! A raw format of genesis config contains just the state's keys and values as they are stored in
+//! the storage. This format is used to directly initialize the genesis storage. This format is
+//! useful for long-term running chains, where the `GenesisConfig` structure for pallets may be
+//! evolving over time. The JSON representation created at some point in time may no longer be
+//! deserializable in the future, making a chain specification useless. The raw format is
+//! recommended for production chains.
+//!
+//! For a detailed description of how the raw format is built, please refer to
+//! [_chain-spec-raw-genesis_][`sc_chain_spec#from-initial-state-to-raw-genesis`]. Plain and
+//! corresponding raw examples of chain-spec are given in
+//! [_chain-spec-examples_][`sc_chain_spec#json-chain-specification-example`].
+//! The [`chain_spec_builder`] util supports building the raw storage.
+//!
+//! # Interacting with the tool
+//!
+//! The [`chain_spec_builder`] util allows interaction with the runtime in order to list or display
+//! presets and build the chain specification file. It is possible to use the tool with the
+//! [_demonstration runtime_][`chain_spec_guide_runtime`]. To build the required packages, just run
+//! the following command:
+//! ```ignore
+//! cargo build -p staging-chain-spec-builder -p chain-spec-guide-runtime --release
+//! ```
+//! The `chain-spec-builder` util can also be installed with `cargo install`:
+//! ```ignore
+//! cargo install staging-chain-spec-builder
+//! cargo build -p chain-spec-guide-runtime --release
+//! ```
+//! Here are some examples in the form of rust tests:
+//! ## Listing available preset names:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs", list_presets)]
+//! ## Displaying preset with given name
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs", get_preset)]
+//! ## Building chain-spec using given preset
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs", generate_chain_spec)]
+//!
+//! [`RuntimeGenesisConfig`]:
+//!     chain_spec_guide_runtime::runtime::RuntimeGenesisConfig
+//! [`FooStruct`]:
+//!     chain_spec_guide_runtime::pallets::FooStruct
+//! [`impl_runtime_apis`]: frame::runtime::prelude::impl_runtime_apis
+//! [`build_state`]: frame_support::genesis_builder_helper::build_state
+//! [`get_preset`]: frame_support::genesis_builder_helper::get_preset
+//! [`pallet::genesis_build`]: frame_support::pallet_macros::genesis_build
+//! [`pallet::genesis_config`]: frame_support::pallet_macros::genesis_config
+//! [`BuildGenesisConfig`]: frame_support::traits::BuildGenesisConfig
+//! [`chain_spec_builder`]: ../../../staging_chain_spec_builder/index.html
+//! [`serde`]: https://serde.rs/field-attrs.html
+//! [`get_storage_for_patch`]: sc_chain_spec::GenesisConfigBuilderRuntimeCaller::get_storage_for_patch
+//! [`GenesisBuilder::get_preset`]: sp_genesis_builder::GenesisBuilder::get_preset
+//! [`deny_unknown_fields`]: https://serde.rs/container-attrs.html#deny_unknown_fields
+//! [`camelCase`]: https://serde.rs/container-attrs.html#rename_all
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml b/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c6dd3af9d90be8039cf2aabbdf04964ff5dc886d
--- /dev/null
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml
@@ -0,0 +1,71 @@
+[package]
+name = "chain-spec-guide-runtime"
+description = "A minimal runtime for chain spec guide"
+version = "0.0.0"
+license = "MIT-0"
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+edition.workspace = true
+publish = false
+
+[dependencies]
+docify = "0.2.8"
+parity-scale-codec = { version = "3.6.12", default-features = false }
+scale-info = { version = "2.6.0", default-features = false }
+serde = { workspace = true, default-features = false }
+serde_json = { workspace = true }
+
+# this is a frame-based runtime, thus importing `frame` with runtime feature enabled.
+frame = { package = "polkadot-sdk-frame", path = "../../../../../substrate/frame", default-features = false, features = [
+	"experimental",
+	"runtime",
+] }
+
+# pallets that we want to use
+pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false }
+pallet-sudo = { path = "../../../../../substrate/frame/sudo", default-features = false }
+pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false }
+pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false }
+pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false }
+
+# genesis builder that allows us to interact with runtime genesis config
+sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false }
+sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false, features = ["serde"] }
+sp-core = { path = "../../../../../substrate/primitives/core", default-features = false }
+sp-std = { path = "../../../../../substrate/primitives/std", default-features = false }
+sp-keyring = { path = "../../../../../substrate/primitives/keyring", default-features = false }
+sp-application-crypto = { path = "../../../../../substrate/primitives/application-crypto", default-features = false, features = ["serde"] }
+
+[build-dependencies]
+substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true }
+
+[dev-dependencies]
+chain-spec-builder = { package = "staging-chain-spec-builder", path = "../../../../../substrate/bin/utils/chain-spec-builder" }
+sc-chain-spec = { path = "../../../../../substrate/client/chain-spec" }
+
+[features]
+default = ["std"]
+std = [
+	"parity-scale-codec/std",
+	"scale-info/std",
+
+	"frame/std",
+
+	"pallet-balances/std",
+	"pallet-sudo/std",
+	"pallet-timestamp/std",
+	"pallet-transaction-payment-rpc-runtime-api/std",
+	"pallet-transaction-payment/std",
+
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-genesis-builder/std",
+	"sp-keyring/std",
+	"sp-runtime/std",
+	"sp-std/std",
+
+	"serde/std",
+	"serde_json/std",
+	"substrate-wasm-builder",
+]
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/build.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e6f92757e225475ff744a4a0cf931787463d1544
--- /dev/null
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/build.rs
@@ -0,0 +1,23 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {
+	#[cfg(feature = "std")]
+	{
+		substrate_wasm_builder::WasmBuilder::build_using_defaults();
+	}
+}
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/lib.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4606104fb9680628f10dc4ff7738f9c4740ced62
--- /dev/null
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/lib.rs
@@ -0,0 +1,27 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+//! A minimal runtime that shows runtime genesis state.
+
+pub mod pallets;
+pub mod presets;
+pub mod runtime;
+
+#[cfg(feature = "std")]
+pub use runtime::{WASM_BINARY, WASM_BINARY_BLOATY};
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs
new file mode 100644
index 0000000000000000000000000000000000000000..be4455aa21979f8915d32b0a85c84e278ba3b83f
--- /dev/null
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs
@@ -0,0 +1,137 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Pallets for the chain-spec demo runtime.
+
+use frame::prelude::*;
+
+#[docify::export]
+#[frame::pallet(dev_mode)]
+pub mod pallet_bar {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub(super) type InitialAccount<T: Config> = StorageValue<Value = T::AccountId>;
+
+	/// Simple `GenesisConfig`.
+	#[pallet::genesis_config]
+	#[derive(DefaultNoBound)]
+	#[docify::export(pallet_bar_GenesisConfig)]
+	pub struct GenesisConfig<T: Config> {
+		pub initial_account: Option<T::AccountId>,
+	}
+
+	#[pallet::genesis_build]
+	#[docify::export(pallet_bar_build)]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		/// The storage building function that presents a direct mapping of the initial config
+		/// values to the storage items.
+		fn build(&self) {
+			InitialAccount::<T>::set(self.initial_account.clone());
+		}
+	}
+}
+
+/// The sample structure used in `GenesisConfig`.
+///
+/// This structure does not deny unknown fields. This may lead to some problems.
+#[derive(Default, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FooStruct {
+	pub field_a: u8,
+	pub field_b: u8,
+}
+
+/// The sample structure used in `GenesisConfig`.
+///
+/// This structure does not deny unknown fields. This may lead to some problems.
+#[derive(Default, serde::Serialize, serde::Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct SomeFooData1 {
+	pub a: u8,
+	pub b: u8,
+}
+
+/// Another sample structure used in `GenesisConfig`.
+///
+/// The user defined serialization is used.
+#[derive(Default, serde::Serialize, serde::Deserialize)]
+#[docify::export]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct SomeFooData2 {
+	#[serde(default, with = "sp_core::bytes")]
+	pub values: Vec<u8>,
+}
+
+/// Sample enum used in `GenesisConfig`.
+#[derive(Default, serde::Serialize, serde::Deserialize)]
+pub enum FooEnum {
+	#[default]
+	Data0,
+	Data1(SomeFooData1),
+	Data2(SomeFooData2),
+}
+
+#[docify::export]
+#[frame::pallet(dev_mode)]
+pub mod pallet_foo {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub type ProcessedEnumValue<T> = StorageValue<Value = u64>;
+	#[pallet::storage]
+	pub type SomeInteger<T> = StorageValue<Value = u32>;
+
+	/// The more sophisticated structure for conveying initial state.
+	#[docify::export(pallet_foo_GenesisConfig)]
+	#[pallet::genesis_config]
+	#[derive(DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub some_integer: u32,
+		pub some_enum: FooEnum,
+		pub some_struct: FooStruct,
+		#[serde(skip)]
+		_phantom: PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	#[docify::export(pallet_foo_build)]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		/// The build method that indirectly maps an initial config values into the storage items.
+		fn build(&self) {
+			let processed_value: u64 = match &self.some_enum {
+				FooEnum::Data0 => 0,
+				FooEnum::Data1(v) => (v.a + v.b).into(),
+				FooEnum::Data2(v) => v.values.iter().map(|v| *v as u64).sum(),
+			};
+			ProcessedEnumValue::<T>::set(Some(processed_value));
+			SomeInteger::<T>::set(Some(self.some_integer));
+		}
+	}
+}
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c51947f6cc7cb0c53f8fbf52f2f80a370b1f681c
--- /dev/null
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs
@@ -0,0 +1,166 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Presets for the chain-spec demo runtime.
+
+use crate::pallets::{FooEnum, SomeFooData1, SomeFooData2};
+use serde_json::{json, to_string, Value};
+use sp_application_crypto::Ss58Codec;
+use sp_keyring::AccountKeyring;
+use sp_std::vec;
+
+/// A demo preset with strings only.
+pub const PRESET_1: &str = "preset_1";
+/// A demo preset with real types.
+pub const PRESET_2: &str = "preset_2";
+/// Another demo preset with real types.
+pub const PRESET_3: &str = "preset_3";
+/// A single value patch preset.
+pub const PRESET_4: &str = "preset_4";
+/// A single value patch preset.
+pub const PRESET_INVALID: &str = "preset_invalid";
+
+#[docify::export]
+/// Function provides a preset demonstrating how use string representation of preset's internal
+/// values.
+fn preset_1() -> Value {
+	json!({
+		"bar": {
+			"initialAccount": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL",
+		},
+		"foo": {
+			"someEnum": {
+				"Data2": {
+					"values": "0x0c0f"
+				}
+			},
+			"someStruct" : {
+				"fieldA": 10,
+				"fieldB": 20
+			},
+			"someInteger": 100
+		},
+	})
+}
+
+#[docify::export]
+/// Function provides a preset demonstrating how use the actual types to create a preset.
+fn preset_2() -> Value {
+	json!({
+		"bar": {
+			"initialAccount": AccountKeyring::Ferdie.public().to_ss58check(),
+		},
+		"foo": {
+			"someEnum": FooEnum::Data2(SomeFooData2 { values: vec![12,16] }),
+			"someInteger": 200
+		},
+	})
+}
+
+#[docify::export]
+/// Function provides a preset demonstrating how use the actual types to create a preset.
+fn preset_3() -> Value {
+	json!({
+		"bar": {
+			"initialAccount": AccountKeyring::Alice.public().to_ss58check(),
+		},
+		"foo": {
+			"someEnum": FooEnum::Data1(
+				SomeFooData1 {
+					a: 12,
+					b: 16
+				}
+			),
+			"someInteger": 300
+		},
+	})
+}
+
+#[docify::export]
+/// Function provides a minimal preset demonstrating how to patch single key in
+/// `RuntimeGenesisConfig`.
+fn preset_4() -> Value {
+	json!({
+		"foo": {
+			"someEnum": {
+				"Data2": {
+					"values": "0x0c0f"
+				}
+			},
+		},
+	})
+}
+
+#[docify::export]
+/// Function provides an invalid preset demonstrating how important is use of
+/// [`deny_unknown_fields`] in data structures used in `GenesisConfig`.
+fn preset_invalid() -> Value {
+	json!({
+		"foo": {
+			"someStruct": {
+				"fieldC": 5
+			},
+		},
+	})
+}
+
+/// Provides a JSON representation of preset identified by given `id`.
+///
+/// If no preset with given `id` exits `None` is returned.
+#[docify::export]
+pub fn get_builtin_preset(id: &sp_genesis_builder::PresetId) -> Option<sp_std::vec::Vec<u8>> {
+	let preset = match id.try_into() {
+		Ok(PRESET_1) => preset_1(),
+		Ok(PRESET_2) => preset_2(),
+		Ok(PRESET_3) => preset_3(),
+		Ok(PRESET_4) => preset_4(),
+		Ok(PRESET_INVALID) => preset_invalid(),
+		_ => return None,
+	};
+
+	Some(
+		to_string(&preset)
+			.expect("serialization to json is expected to work. qed.")
+			.into_bytes(),
+	)
+}
+
+#[test]
+#[docify::export]
+fn check_presets() {
+	let builder = sc_chain_spec::GenesisConfigBuilderRuntimeCaller::<()>::new(
+		crate::WASM_BINARY.expect("wasm binary shall exists"),
+	);
+	assert!(builder.get_storage_for_named_preset(Some(&PRESET_1.to_string())).is_ok());
+	assert!(builder.get_storage_for_named_preset(Some(&PRESET_2.to_string())).is_ok());
+	assert!(builder.get_storage_for_named_preset(Some(&PRESET_3.to_string())).is_ok());
+	assert!(builder.get_storage_for_named_preset(Some(&PRESET_4.to_string())).is_ok());
+}
+
+#[test]
+#[docify::export]
+fn invalid_preset_works() {
+	let builder = sc_chain_spec::GenesisConfigBuilderRuntimeCaller::<()>::new(
+		crate::WASM_BINARY.expect("wasm binary shall exists"),
+	);
+	// Even though a preset contains invalid_key, conversion to raw storage does not fail. This is
+	// because the [`FooStruct`] structure is not annotated with `deny_unknown_fields` [`serde`]
+	// attribute.
+	// This may lead to hard to debug problems, that's why using ['deny_unknown_fields'] is
+	// recommended.
+	assert!(builder.get_storage_for_named_preset(Some(&PRESET_INVALID.to_string())).is_ok());
+}
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/runtime.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/runtime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6d9bc1260b11fa79004b40ded4ab20343cf29037
--- /dev/null
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/runtime.rs
@@ -0,0 +1,122 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A minimal runtime that shows runtime genesis state.
+
+// Make the WASM binary available.
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+use crate::{
+	pallets::{pallet_bar, pallet_foo},
+	presets::*,
+};
+use frame::{
+	deps::frame_support::{
+		genesis_builder_helper::{build_state, get_preset},
+		runtime,
+	},
+	prelude::*,
+	runtime::{
+		apis::{self, impl_runtime_apis, ExtrinsicInclusionMode},
+		prelude::*,
+	},
+};
+use sp_genesis_builder::PresetId;
+
+/// The runtime version.
+#[runtime_version]
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: create_runtime_str!("minimal-template-runtime"),
+	impl_name: create_runtime_str!("minimal-template-runtime"),
+	authoring_version: 1,
+	spec_version: 0,
+	impl_version: 1,
+	apis: RUNTIME_API_VERSIONS,
+	transaction_version: 1,
+	state_version: 1,
+};
+
+/// The signed extensions that are added to the runtime.
+type SignedExtra = ();
+
+// Composes the runtime by adding all the used pallets and deriving necessary types.
+#[runtime]
+mod runtime {
+	/// The main runtime type.
+	#[runtime::runtime]
+	#[runtime::derive(RuntimeCall, RuntimeEvent, RuntimeError, RuntimeOrigin, RuntimeTask)]
+	pub struct Runtime;
+
+	/// Mandatory system pallet that should always be included in a FRAME runtime.
+	#[runtime::pallet_index(0)]
+	pub type System = frame_system;
+
+	/// Sample pallet 1
+	#[runtime::pallet_index(1)]
+	pub type Bar = pallet_bar;
+
+	/// Sample pallet 2
+	#[runtime::pallet_index(2)]
+	pub type Foo = pallet_foo;
+}
+
+parameter_types! {
+	pub const Version: RuntimeVersion = VERSION;
+}
+
+/// Implements the types required for the system pallet.
+#[derive_impl(frame_system::config_preludes::SolochainDefaultConfig)]
+impl frame_system::Config for Runtime {
+	type Block = Block;
+	type Version = Version;
+}
+
+impl pallet_bar::Config for Runtime {}
+impl pallet_foo::Config for Runtime {}
+
+type Block = frame::runtime::types_common::BlockOf<Runtime, SignedExtra>;
+type Header = HeaderFor<Runtime>;
+
+#[docify::export(runtime_impl)]
+impl_runtime_apis! {
+	impl sp_genesis_builder::GenesisBuilder<Block> for Runtime {
+		fn build_state(config: Vec<u8>) -> sp_genesis_builder::Result {
+			build_state::<RuntimeGenesisConfig>(config)
+		}
+
+		fn get_preset(id: &Option<sp_genesis_builder::PresetId>) -> Option<Vec<u8>> {
+			get_preset::<RuntimeGenesisConfig>(id, get_builtin_preset)
+		}
+
+		fn preset_names() -> Vec<sp_genesis_builder::PresetId> {
+			vec![
+				PresetId::from(PRESET_1),
+				PresetId::from(PRESET_2),
+				PresetId::from(PRESET_3),
+				PresetId::from(PRESET_4),
+				PresetId::from(PRESET_INVALID)
+			]
+		}
+	}
+
+	impl apis::Core<Block> for Runtime {
+		fn version() -> RuntimeVersion { VERSION }
+		fn execute_block(_: Block) { }
+		fn initialize_block(_: &Header) -> ExtrinsicInclusionMode { ExtrinsicInclusionMode::default() }
+	}
+}
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d08f547bba616ad7be11cf7f2ca0e151e5e6583c
--- /dev/null
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs
@@ -0,0 +1,129 @@
+use serde_json::{json, Value};
+use std::{process::Command, str};
+
+const WASM_FILE_PATH: &str =
+	"../../../../../target/release/wbuild/chain-spec-guide-runtime/chain_spec_guide_runtime.wasm";
+
+const CHAIN_SPEC_BUILDER_PATH: &str = "../../../../../target/release/chain-spec-builder";
+
+fn get_chain_spec_builder_path() -> &'static str {
+	// dev-dependencies do not build binary. So let's do the naive work-around here:
+	let _ = std::process::Command::new("cargo")
+		.arg("build")
+		.arg("--release")
+		.arg("-p")
+		.arg("staging-chain-spec-builder")
+		.arg("--bin")
+		.arg("chain-spec-builder")
+		.status()
+		.expect("Failed to execute command");
+	CHAIN_SPEC_BUILDER_PATH
+}
+
+#[test]
+#[docify::export]
+fn list_presets() {
+	let output = Command::new(get_chain_spec_builder_path())
+		.arg("list-presets")
+		.arg("-r")
+		.arg(WASM_FILE_PATH)
+		.output()
+		.expect("Failed to execute command");
+
+	let output: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+
+	let expected_output = json!({
+		"presets":[
+			"preset_1",
+			"preset_2",
+			"preset_3",
+			"preset_4",
+			"preset_invalid"
+		]
+	});
+	assert_eq!(output, expected_output, "Output did not match expected");
+}
+
+#[test]
+#[docify::export]
+fn get_preset() {
+	let output = Command::new(get_chain_spec_builder_path())
+		.arg("display-preset")
+		.arg("-r")
+		.arg(WASM_FILE_PATH)
+		.arg("-p")
+		.arg("preset_2")
+		.output()
+		.expect("Failed to execute command");
+
+	let output: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+
+	//note: copy of chain_spec_guide_runtime::preset_1
+	let expected_output = json!({
+		"bar": {
+			"initialAccount": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL",
+		},
+		"foo": {
+			"someEnum": {
+				"Data2": {
+					"values": "0x0c10"
+				}
+			},
+			"someInteger": 200
+		},
+	});
+	assert_eq!(output, expected_output, "Output did not match expected");
+}
+
+#[test]
+#[docify::export]
+fn generate_chain_spec() {
+	let output = Command::new(get_chain_spec_builder_path())
+		.arg("-c")
+		.arg("/dev/stdout")
+		.arg("create")
+		.arg("-r")
+		.arg(WASM_FILE_PATH)
+		.arg("named-preset")
+		.arg("preset_2")
+		.output()
+		.expect("Failed to execute command");
+
+	let mut output: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+
+	//remove code field for better readability
+	if let Some(code) = output["genesis"]["runtimeGenesis"].as_object_mut().unwrap().get_mut("code")
+	{
+		*code = Value::String("0x123".to_string());
+	}
+
+	let expected_output = json!({
+	  "name": "Custom",
+	  "id": "custom",
+	  "chainType": "Live",
+	  "bootNodes": [],
+	  "telemetryEndpoints": null,
+	  "protocolId": null,
+	  "properties": null,
+	  "codeSubstitutes": {},
+	  "genesis": {
+		"runtimeGenesis": {
+		  "code": "0x123",
+		  "patch": {
+			"bar": {
+			  "initialAccount": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL"
+			},
+			"foo": {
+			  "someEnum": {
+				"Data2": {
+				  "values": "0x0c10"
+				}
+			  },
+			  "someInteger": 200
+			}
+		  }
+		}
+	  }
+	});
+	assert_eq!(output, expected_output, "Output did not match expected");
+}
diff --git a/docs/sdk/src/reference_docs/consensus_swapping.rs b/docs/sdk/src/reference_docs/consensus_swapping.rs
deleted file mode 100644
index e639761ee97b42fa68e1ba77250d490e28277e24..0000000000000000000000000000000000000000
--- a/docs/sdk/src/reference_docs/consensus_swapping.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//! Consensus Swapping
-//!
-//! Notes:
-//!
-//! - The typical workshop done by Joshy in some places where he swaps out the consensus to be PoW.
-//! - This could also be a tutorial rather than a ref doc, depending on the size.
diff --git a/docs/sdk/src/reference_docs/custom_host_functions.rs b/docs/sdk/src/reference_docs/custom_host_functions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..719b208a2bff7ed6fb1929cbdccae7dddda2ab00
--- /dev/null
+++ b/docs/sdk/src/reference_docs/custom_host_functions.rs
@@ -0,0 +1,27 @@
+//! # Custom Host Functions
+//!
+//! Host functions are functions that the wasm instance can use to communicate with the node. Learn
+//! more about this in [`crate::reference_docs::wasm_meta_protocol`].
+//!
+//! ## Finding Host Functions
+//!
+//! To declare a set of functions as host functions, you need to use the `#[runtime_interface]`
+//! ([`sp_runtime_interface`]) attribute macro. The most notable set of host functions are those
+//! that allow the runtime to access the chain state, namely [`sp_io::storage`]. Some other notable
+//! host functions are also defined in [`sp_io`].
+//!
+//! ## Adding New Host Functions
+//!
+//! > Adding a new host function is a big commitment and should be done with care. Namely, the nodes
+//! > in the network need to support all host functions forever in order to be able to sync
+//! > historical blocks.
+//!
+//! Adding host functions is only possible when you are using a node-template, so that you have
+//! access to the boilerplate of building your node.
+//!
+//! A group of host functions can always be grouped to gether as a tuple:
+#![doc = docify::embed!("../../substrate/primitives/io/src/lib.rs", SubstrateHostFunctions)]
+//!
+//! The host functions are attached to the node side's [`sc_executor::WasmExecutor`]. For example in
+//! the minimal template, the setup looks as follows:
+#![doc = docify::embed!("../../templates/minimal/node/src/service.rs", FullClient)]
diff --git a/docs/sdk/src/reference_docs/custom_runtime_api_rpc.rs b/docs/sdk/src/reference_docs/custom_runtime_api_rpc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..83a70606cb8dd51acf13f7774a0ccf40355ea41a
--- /dev/null
+++ b/docs/sdk/src/reference_docs/custom_runtime_api_rpc.rs
@@ -0,0 +1,77 @@
+//! # Custom RPC do's and don'ts
+//!
+//! **TLDR:** don't create new custom RPCs. Instead, rely on custom Runtime APIs, combined with
+//! `state_call`
+//!
+//! ## Background
+//!
+//! Polkadot-SDK offers the ability to query and subscribe storages directly. However what it does
+//! not have is [view functions](https://github.com/paritytech/polkadot-sdk/issues/216). This is an
+//! essential feature to avoid duplicated logic between runtime and the client SDK. Custom RPC was
+//! used as a solution. It allow the RPC node to expose new RPCs that clients can be used to query
+//! computed properties.
+//!
+//! ## Problems with Custom RPC
+//!
+//! Unfortunately, custom RPC comes with many problems. To list a few:
+//!
+//! - It is offchain logic executed by the RPC node and therefore the client has to trust the RPC
+//!   node.
+//! - To upgrade or add a new RPC logic, the RPC node has to be upgraded. This can cause significant
+//!   trouble when the RPC infrastructure is decentralized as we will need to coordinate multiple
+//!   parties to upgrade the RPC nodes.
+//! - A lot of boilerplate code are required to add custom RPC.
+//! - It prevents the dApp to use a light client or alternative client.
+//! - It makes ecosystem tooling integration much more complicated. For example, the dApp will not
+//!   be able to use [Chopsticks](https://github.com/AcalaNetwork/chopsticks) for testing as
+//!   Chopsticks will not have the custom RPC implementation.
+//! - Poorly implemented custom RPC can be a DoS vector.
+//!
+//! Hence, we should avoid custom RPC.
+//!
+//! ## Alternatives
+//!
+//! Generally, [`sc_rpc::state::StateBackend::call`] aka. `state_call` should be used instead of
+//! custom RPC.
+//!
+//! Usually, each custom RPC comes with a corresponding runtime API which implements the business
+//! logic. So instead of invoke the custom RPC, we can use `state_call` to invoke the runtime API
+//! directly. This is a trivial change on the dApp and no change on the runtime side. We may remove
+//! the custom RPC from the node side if wanted.
+//!
+//! There are some other cases that a simple runtime API is not enough. For example, implementation
+//! of Ethereum RPC requires an additional offchain database to index transactions. In this
+//! particular case, we can have the RPC implemented on another client.
+//!
+//! For example, the Acala EVM+ RPC are implemented by
+//! [eth-rpc-adapter](https://github.com/AcalaNetwork/bodhi.js/tree/master/packages/eth-rpc-adapter).
+//! Alternatively, the [Frontier](https://github.com/polkadot-evm/frontier) project  also provided
+//! Ethereum RPC compatibility directly in the node-side software.
+//!
+//! ## Create a new Runtime API
+//!
+//! For example, let's take a look a the process through which the account nonce can be queried
+//! through an RPC. First, a new runtime-api needs to be declared:
+#![doc = docify::embed!("../../substrate/frame/system/rpc/runtime-api/src/lib.rs", AccountNonceApi)]
+//!
+//! This API is implemented at the runtime level, always inside [`sp_api::impl_runtime_apis!`].
+//!
+//! As noted, this is already enough to make this API usable via `state_call`.
+//!
+//! ## Create a new custom RPC (Legacy)
+//!
+//! Should you wish to implement the legacy approach of exposing this runtime-api as a custom
+//! RPC-api, then a custom RPC server has to be defined.
+#![doc = docify::embed!("../../substrate/utils/frame/rpc/system/src/lib.rs", SystemApi)]
+//!
+//! ## Add a new RPC to the node (Legacy)
+//!
+//! Finally, this custom RPC needs to be integrated into the node side. This is usually done in a
+//! `rpc.rs` in a typical template, as follows:
+#![doc = docify::embed!("../../templates/minimal/node/src/rpc.rs", create_full)]
+//!
+//! ## Future
+//!
+//! - [XCQ](https://forum.polkadot.network/t/cross-consensus-query-language-xcq/7583) will be a good
+//! solution for most of the query needs.
+//! - [New JSON-RPC Specification](https://github.com/paritytech/json-rpc-interface-spec)
diff --git a/docs/sdk/src/reference_docs/extrinsic_encoding.rs b/docs/sdk/src/reference_docs/extrinsic_encoding.rs
index 8c8568a228fad140115e68feb3eec717ef30170c..31ce92c67e98a5911370472f2387bac3382a5230 100644
--- a/docs/sdk/src/reference_docs/extrinsic_encoding.rs
+++ b/docs/sdk/src/reference_docs/extrinsic_encoding.rs
@@ -191,7 +191,7 @@
 
 #[docify::export]
 pub mod call_data {
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 
 	// The outer enum composes calls within
 	// different pallets together. We have two
@@ -224,7 +224,7 @@ pub mod call_data {
 pub mod encoding_example {
 	use super::call_data::{Call, PalletACall};
 	use crate::reference_docs::signed_extensions::signed_extensions_example;
-	use parity_scale_codec::Encode;
+	use codec::Encode;
 	use sp_core::crypto::AccountId32;
 	use sp_keyring::sr25519::Keyring;
 	use sp_runtime::{
diff --git a/docs/sdk/src/reference_docs/fee_less_runtime.rs b/docs/sdk/src/reference_docs/fee_less_runtime.rs
index 1213c26282537fdee2d04ebd452289f0e6bc759f..9146b30ec5774355ce91dd02a5bb010dcf6fbada 100644
--- a/docs/sdk/src/reference_docs/fee_less_runtime.rs
+++ b/docs/sdk/src/reference_docs/fee_less_runtime.rs
@@ -1,5 +1,6 @@
 //! # Fee-Less Runtime
 //!
+//! 🚧 Work In Progress 🚧
 //!
 //! Notes:
 //!
diff --git a/docs/sdk/src/reference_docs/frame_logging.rs b/docs/sdk/src/reference_docs/frame_logging.rs
new file mode 100644
index 0000000000000000000000000000000000000000..301fa7ef83f827c3115a6a30bb8d1ad35b5bfd83
--- /dev/null
+++ b/docs/sdk/src/reference_docs/frame_logging.rs
@@ -0,0 +1,116 @@
+//! # FRAME Logging
+//!
+//! This reference docs briefly explores how to do logging and printing runtimes, mainly
+//! FRAME-based.
+//!
+//! ## Using `println!`
+//!
+//! To recap, as with standard Rust, you can use `println!` _in your tests_, but it will only print
+//! out if executed with `--nocapture`, or if the test panics.
+//!
+//! ```
+//! fn it_print() {
+//! 	println!("Hello, world!");
+//! }
+//! ```
+//!
+//! within the pallet, if you want to use the standard `println!`, it needs to be wrapped in
+//! [`sp_std::if_std`]. Of course, this means that this print code is only available to you in the
+//! `std` compiler flag, and never present in a wasm build.
+//!
+//! ```
+//! // somewhere in your pallet. This is not a real pallet code.
+//! mod pallet {
+//! 	struct Pallet;
+//! 	impl Pallet {
+//! 		fn print() {
+//! 			sp_std::if_std! {
+//! 				println!("Hello, world!");
+//! 			}
+//! 		}
+//! 	}
+//! }
+//! ```
+//!
+//! ## Using `log`
+//!
+//! First, ensure you are familiar with the `log` crate. In short, each log statement has:
+//!
+//! 1. `log-level`, signifying how important it is
+//! 2. `log-target`, signifying to which component it belongs.
+//!
+//! Add log statements to your pallet as such:
+//!
+//! You can add the log crate to the `Cargo.toml` of the pallet.
+//!
+//! ```text
+//! #[dependencies]
+//! log = { version = "x.y.z", default-features = false }
+//!
+//! #[features]
+//! std = [
+//! 	// snip -- other pallets
+//! 	"log/std"
+//! ]
+//! ```
+//!
+//! More conveniently, the `frame` umbrella crate re-exports the log crate as [`frame::log`].
+//!
+//! Then, the pallet can use this crate to emit log statements. In this statement, we use the info
+//! level, and the target is `pallet-example`.
+//!
+//! ```
+//! mod pallet {
+//! 	struct Pallet;
+//!
+//! 	impl Pallet {
+//! 		fn logs() {
+//! 			frame::log::info!(target: "pallet-example", "Hello, world!");
+//! 		}
+//! 	}
+//! }
+//! ```
+//!
+//! This will in itself just emit the log messages, **but unless if captured by a logger, they will
+//! not go anywhere**. [`sp_api`] provides a handy function to enable the runtime logging:
+//!
+//! ```
+//! // in your test
+//! fn it_also_prints() {
+//! 	sp_api::init_runtime_logger();
+//! 	// call into your pallet, and now it will print `log` statements.
+//! }
+//! ```
+//!
+//! Alternatively, you can use [`sp_tracing::try_init_simple`].
+//!
+//! `info`, `error` and `warn` logs are printed by default, but if you want lower level logs to also
+//! be printed, you must to add the following compiler flag:
+//!
+//! ```text
+//! RUST_LOG=pallet-example=trace cargo test
+//! ```
+//!
+//! ## Enabling Logs in Production
+//!
+//! All logs from the runtime are emitted by default, but there is a feature flag in [`sp_api`],
+//! called `disable-logging`, that can be used to disable all logs in the runtime. This is useful
+//! for production chains to reduce the size and overhead of the wasm runtime.
+#![doc = docify::embed!("../../substrate/primitives/api/src/lib.rs", init_runtime_logger)]
+//!
+//! Similar to the above, the proper `RUST_LOG` must also be passed to your compiler flag when
+//! compiling the runtime.
+//!
+//! ## Log Target Prefixing
+//!
+//! Many [`crate::polkadot_sdk::frame_runtime`] pallets emit logs with log target `runtime::<name of
+//! pallet>`, for example `runtime::system`. This then allows one to run a node with a wasm blob
+//! compiled with `LOG_TARGET=runtime=debug`, which enables the log target of all pallets who's log
+//! target starts with `runtime`.
+//!
+//! ## Low Level Primitives
+//!
+//! Under the hood, logging is another instance of host functions under the hood (as defined in
+//! [`crate::reference_docs::wasm_meta_protocol`]). The runtime uses a set of host functions under
+//! [`sp_io::logging`] and [`sp_io::misc`] to emit all logs and prints. You typically do not need to
+//! use these APIs directly.
diff --git a/docs/sdk/src/reference_docs/frame_offchain_workers.rs b/docs/sdk/src/reference_docs/frame_offchain_workers.rs
index 7999707e5ee018c4bb7634e7a506ff8fee8fa8ac..1ec9212e2306613b72ec4c6f433a68c92f5bb0d5 100644
--- a/docs/sdk/src/reference_docs/frame_offchain_workers.rs
+++ b/docs/sdk/src/reference_docs/frame_offchain_workers.rs
@@ -58,7 +58,6 @@
 //! [`frame::pallet_macros::hooks`].
 //!
 //! ```
-//! 
 //! #[frame::pallet]
 //! pub mod pallet {
 //! 	use frame::prelude::*;
diff --git a/docs/sdk/src/reference_docs/frame_runtime_types.rs b/docs/sdk/src/reference_docs/frame_runtime_types.rs
index 32cda5bc5345d7eee43efa9e2b99ac831c8fb3a8..1eed9857a1d5951245b4c4f6bef08f35d0c3f03a 100644
--- a/docs/sdk/src/reference_docs/frame_runtime_types.rs
+++ b/docs/sdk/src/reference_docs/frame_runtime_types.rs
@@ -102,6 +102,10 @@
 //! bounds, such as being [`frame::traits::IsSubType`]:
 #![doc = docify::embed!("./src/reference_docs/frame_runtime_types.rs", custom_runtime_call_usages)]
 //!
+//! > Once Rust's "_Associated Type Bounds RFC_" is usable, this syntax can be used to
+//! > simplify the above scenario. See [this](https://github.com/paritytech/polkadot-sdk/issues/3743)
+//! > issue for more information.
+//!
 //! ### Asserting Equality of Multiple Runtime Composite Enums
 //!
 //! Recall that in the above example, `<T as Config>::RuntimeCall` and `<T as
diff --git a/docs/sdk/src/reference_docs/frame_system_accounts.rs b/docs/sdk/src/reference_docs/frame_system_accounts.rs
index ae9d2c9e0cb3ca7a694d9e5330363c05f6f78cb0..523fe704308497d3116d36cfca086a617b3a9d3b 100644
--- a/docs/sdk/src/reference_docs/frame_system_accounts.rs
+++ b/docs/sdk/src/reference_docs/frame_system_accounts.rs
@@ -1,5 +1,7 @@
 //! # FRAME Accounts
 //!
+//! //! 🚧 Work In Progress 🚧
+//!
 //! How `frame_system` handles accountIds. Nonce. Consumers and Providers, reference counting.
 
 // - poorly understood topics, needs one great article to rul them all.
diff --git a/docs/sdk/src/reference_docs/light_nodes.rs b/docs/sdk/src/reference_docs/light_nodes.rs
deleted file mode 100644
index d6670bf03ab1a8e36ef1d8b80717d1b3833daff5..0000000000000000000000000000000000000000
--- a/docs/sdk/src/reference_docs/light_nodes.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//! # Light Clients
-//!
-//!
-//! Notes: should contain only high level information about light clients, then link to how to set
-//! it up in PAPI and SubXT
-//! <https://docs.substrate.io/learn/light-clients-in-substrate-connect/>
-//! <https://github.com/substrate-developer-hub/substrate-front-end-template/pull/277>
diff --git a/docs/sdk/src/reference_docs/metadata.rs b/docs/sdk/src/reference_docs/metadata.rs
index 702c1c30fd9cf2d09082b39fecf880065ebd5375..96f92ac0c412ba252092170e0788680300385901 100644
--- a/docs/sdk/src/reference_docs/metadata.rs
+++ b/docs/sdk/src/reference_docs/metadata.rs
@@ -1 +1,25 @@
 //! # Metadata
+//!
+//! The existence of metadata in polkadot-sdk goes back to the (forkless) upgrade-ability of all
+//! Substrate-based blockchains, which is achieved through
+//! [`crate::reference_docs::wasm_meta_protocol`]. You can learn more about the details of how to
+//! deal with these upgrades in [`crate::reference_docs::frame_runtime_upgrades_and_migrations`].
+//!
+//! Another consequence of upgrade-ability is that as a UI, wallet, or generally an offchain entity,
+//! it is hard to know the types internal to the runtime, specifically in light of the fact that
+//! they can change at any point in time.
+//!
+//! This is why all Substrate-based runtimes must expose a [`sp_api::Metadata`] api, which mandates
+//! the runtime to return a description of itself. The return type of this api is `Vec<u8>`, meaning
+//! that it is up to the runtime developer to decide on the format of this.
+//!
+//! All [`crate::polkadot_sdk::frame_runtime`] based runtimes expose a specific metadata language,
+//! maintained in <https://github.com/paritytech/frame-metadata> which is adopted in the Polkadot
+//! ecosystem.
+//!
+//! ## Metadata Explorers:
+//!
+//! A few noteworthy tools that inspect the (FRAME-based) metadata of a chain:
+//!
+//! <https://wiki.polkadot.network/docs/metadata>
+//! <https://paritytech.github.io/subxt-explorer/>
diff --git a/docs/sdk/src/reference_docs/mod.rs b/docs/sdk/src/reference_docs/mod.rs
index 145df8844f26e5b58d737a4290035e3886bf63fe..688339b7e3806c0ed86db5caabc253b0d45e7c41 100644
--- a/docs/sdk/src/reference_docs/mod.rs
+++ b/docs/sdk/src/reference_docs/mod.rs
@@ -40,7 +40,6 @@ pub mod runtime_vs_smart_contract;
 pub mod extrinsic_encoding;
 
 /// Learn about the signed extensions that form a part of extrinsics.
-// TODO: @jsdw https://github.com/paritytech/polkadot-sdk-docs/issues/42
 pub mod signed_extensions;
 
 /// Learn about *Origins*, a topic in FRAME that enables complex account abstractions to be built.
@@ -59,9 +58,11 @@ pub mod fee_less_runtime;
 
 /// Learn about metadata, the main means through which an upgradeable runtime communicates its
 /// properties to the outside world.
-// TODO: @jsdw https://github.com/paritytech/polkadot-sdk-docs/issues/47
 pub mod metadata;
 
+/// Learn about how to add custom host functions to the node.
+pub mod custom_host_functions;
+
 /// Learn about how frame-system handles `account-ids`, nonces, consumers and providers.
 pub mod frame_system_accounts;
 
@@ -76,29 +77,14 @@ pub mod frame_benchmarking_weight;
 pub mod frame_tokens;
 
 /// Learn about chain specification file and the genesis state of the blockchain.
-// TODO: @michalkucharczyk https://github.com/paritytech/polkadot-sdk-docs/issues/51
 pub mod chain_spec_genesis;
 
-/// Learn about all the memory limitations of the WASM runtime when it comes to memory usage.
-// TODO: @kianenigma https://github.com/paritytech/polkadot-sdk-docs/issues/52
-pub mod wasm_memory;
-
 /// Learn about Substrate's CLI, and how it can be extended.
-// TODO: @kianenigma https://github.com/paritytech/polkadot-sdk-docs/issues/53
 pub mod cli;
 
-/// Learn about Substrate's consensus algorithms, and how you can switch between two.
-// TODO: @JoshOrndorff @kianenigma https://github.com/paritytech/polkadot-sdk-docs/issues/54
-pub mod consensus_swapping;
-
 /// Learn about Runtime Upgrades and best practices for writing Migrations.
 pub mod frame_runtime_upgrades_and_migrations;
 
-/// Learn about light nodes, how they function, and how Substrate-based chains come
-/// light-node-first out of the box.
-// TODO: @jsdw @josepot https://github.com/paritytech/polkadot-sdk-docs/issues/68
-pub mod light_nodes;
-
 /// Learn about the offchain workers, how they function, and how to use them, as provided by the
 /// [`frame`] APIs.
 pub mod frame_offchain_workers;
@@ -106,3 +92,12 @@ pub mod frame_offchain_workers;
 /// Learn about the different ways through which multiple [`frame`] pallets can be combined to work
 /// together.
 pub mod frame_pallet_coupling;
+
+/// Learn about how to do logging in FRAME-based runtimes.
+pub mod frame_logging;
+
+/// Learn about the Polkadot Umbrella crate that re-exports all other crates.
+pub mod umbrella_crate;
+
+/// Learn about how to create custom RPC endpoints and runtime APIs.
+pub mod custom_runtime_api_rpc;
diff --git a/docs/sdk/src/reference_docs/signed_extensions.rs b/docs/sdk/src/reference_docs/signed_extensions.rs
index 28b1426536bcdf371865db74a104a27d51869c86..43a6bcc14c5d2f67703864c485264583acb19ea3 100644
--- a/docs/sdk/src/reference_docs/signed_extensions.rs
+++ b/docs/sdk/src/reference_docs/signed_extensions.rs
@@ -8,7 +8,7 @@
 
 #[docify::export]
 pub mod signed_extensions_example {
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 	use scale_info::TypeInfo;
 	use sp_runtime::traits::SignedExtension;
 
diff --git a/docs/sdk/src/reference_docs/umbrella_crate.rs b/docs/sdk/src/reference_docs/umbrella_crate.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0b3445cfc4bc0ce27b6dcb144618dd7001e6f20a
--- /dev/null
+++ b/docs/sdk/src/reference_docs/umbrella_crate.rs
@@ -0,0 +1,90 @@
+//! # Umbrella Crate
+//!
+//! The Polkadot-SDK "umbrella" is a crate that re-exports all other published crates. This makes it
+//! possible to have a very small `Cargo.toml` file that only has one dependency, the umbrella
+//! crate. This helps with selecting the right combination of crate versions, since otherwise 3rd
+//! party tools are needed to select a compatible set of versions.
+//!
+//! ## Features
+//!
+//! The umbrella crate supports no-std builds and can therefore be used in the runtime and node.
+//! There are two main features: `runtime` and `node`. The `runtime` feature enables all `no-std`
+//! crates, while the `node` feature enables all `std` crates. It should be used like any other
+//! crate in the repo, with `default-features = false`.
+//!
+//! For more fine-grained control, additionally, each crate can be enabled selectively. The umbrella
+//! exposes one feature per dependency. For example, if you only want to use the `frame-support`
+//! crate, you can enable the `frame-support` feature.
+//!
+//! The umbrella exposes a few more general features:
+//! - `tuples-96`: Needs to be enabled for runtimes that have more than 64 pallets.
+//! - `serde`: Specifically enable `serde` en/decoding support.
+//! - `experimental`: Experimental enable experimental features - should not yet used in production.
+//! - `with-tracing`: Enable tracing support.
+//! - `try-runtime`, `runtime-benchmarks` and `std`: These follow the standard conventions.
+//! - `runtime`: As described above, enable all `no-std` crates.
+//! - `node`: As described above, enable all `std` crates.
+//! - There does *not* exist a dedicated docs feature. To generate docs, enable the `runtime` and
+//!   `node` feature. For docs.rs the manifest contains specific configuration to make it show up
+//!   all re-exports.
+//!
+//! There is a specific [`zepter`](https://github.com/ggwpez/zepter) check in place to ensure that
+//! the features of the umbrella are correctly configured. This check is run in CI and locally when
+//! running `zepter`.
+//!
+//! ## Generation
+//!
+//! The umbrella crate needs to be updated every time when a new crate is added or removed from the
+//! workspace. It is checked in CI by calling its generation script. The generation script is
+//! located in `./scripts/generate-umbrella.py` and needs dependency `cargo_workspace`.
+//!
+//! Example: `python3 scripts/generate-umbrella.py --sdk . --version 1.9.0`
+//!
+//! ## Usage
+//!
+//! > Note: You can see a live example in the `staging-node-cli` and `kitchensink-runtime` crates.
+//!
+//! The umbrella crate can be added to your runtime crate like this:
+//!
+//! `polkadot-sdk = { path = "../../../../umbrella", features = ["runtime"], default-features =
+//! false }`
+//!
+//! or for a node:
+//!
+//! `polkadot-sdk = { path = "../../../../umbrella", features = ["node"], default-features = false
+//! }`
+//!
+//! In the code, it is then possible to bring all dependencies into scope via:
+//!
+//! `use polkadot_sdk::*;`
+//!
+//! ### Known Issues
+//!
+//! The only known issue so far is the fact that the `use` statement brings the dependencies only
+//! into the outer module scope - not the global crate scope. For example, the following code would
+//! need to be adjusted:
+//!
+//! ```rust
+//! use polkadot_sdk::*;
+//!
+//! mod foo {
+//!    // This does sadly not compile:
+//!    frame_support::parameter_types! { }
+//!
+//!    // Instead, we need to do this (or add an equivalent `use` statement):
+//!    polkadot_sdk::frame_support::parameter_types! { }
+//! }
+//! ```
+//!
+//! Apart from this, no issues are known. There could be some bugs with how macros locate their own
+//! re-exports. Please compile issues that arise from using this crate.
+//!
+//! ## Dependencies
+//!
+//! The umbrella crate re-exports all published crates, with a few exceptions:
+//! - Runtime crates like `rococo-runtime` etc are not exported. This otherwise leads to very weird
+//!   compile errors and should not be needed anyway.
+//! - Example and fuzzing crates are not exported. This is currently detected by checking the name
+//!   of the crate for these magic words. In the future, it will utilize custom metadata, as it is
+//!   done in the `rococo-runtime` crate.
+//! - The umbrella crate itself. Should be obvious :)
diff --git a/docs/sdk/src/reference_docs/wasm_memory.rs b/docs/sdk/src/reference_docs/wasm_memory.rs
deleted file mode 100644
index 4f4cda31094e40e8f308dbb06de4ab0ecd828777..0000000000000000000000000000000000000000
--- a/docs/sdk/src/reference_docs/wasm_memory.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//! # WASM Memory Limitations.
-//!
-//! Notes:
-//!
-//! - Stack: Need to use `Box<_>`
-//! - Heap: Substrate imposes a limit. PvF execution has its own limits
-//! - Heap: There is also a maximum amount that a single allocation can have.
diff --git a/docs/sdk/src/reference_docs/wasm_meta_protocol.rs b/docs/sdk/src/reference_docs/wasm_meta_protocol.rs
index 37d1460f0e1a3737217ac0c80ec41de769db4c1a..0e91e65c55e36d99d6dfbe03e7cda3af09dad942 100644
--- a/docs/sdk/src/reference_docs/wasm_meta_protocol.rs
+++ b/docs/sdk/src/reference_docs/wasm_meta_protocol.rs
@@ -1,11 +1,13 @@
 //! # WASM Meta Protocol
 //!
 //! All Substrate based chains adhere to a unique architectural design novel to the Polkadot
-//! ecosystem. We refer to this design as the "WASM Meta Protocol".
+//! ecosystem. We refer to this design as the "**WASM Meta Protocol**".
 //!
 //! Consider the fact that a traditional blockchain software is usually a monolithic artifact.
-//! Upgrading any part of the system implies upgrading the entire system. This has historically led
-//! to cumbersome forkful upgrades to be the status quo in the blockchain ecosystem.
+//! **Upgrading any part of the system implies upgrading the entire system**. This has historically
+//! led to cumbersome forkful upgrades to be the status quo in blockchain ecosystems. In other
+//! words, the entire node software is the specification of the blockchain's [`state transition
+//! function`](crate::reference_docs::blockchain_state_machines).
 //!
 //! Moreover, the idea of "storing code in the state" is explored in the context of smart contracts
 //! platforms, but has not been expanded further.
@@ -15,17 +17,16 @@
 //! that a smart contract platform stores the code of individual contracts in its state. As noted in
 //! [`crate::reference_docs::blockchain_state_machines`], this state transition function is called
 //! the **Runtime**, and WASM is chosen as the bytecode. The Runtime is stored under a special key
-//! in the state (see
-//! [`sp_core::storage::well_known_keys`](../../../sp_core/index.html)) and can be
-//! updated as a part of the state transition function's execution, just like a user's account
-//! balance can be updated.
+//! in the state (see [`sp_core::storage::well_known_keys`]) and can be updated as a part of the
+//! state transition function's execution, just like a user's account balance can be updated.
 //!
 //! > Note that while we drew an analogy between smart contracts and runtimes in the above, there
 //! > are fundamental differences between the two, explained in
 //! > [`crate::reference_docs::runtime_vs_smart_contract`].
 //!
-//! The rest of the system that is NOT the state transition function is called the **node**, and
-//! is a normal binary that is compiled from Rust to different hardware targets.
+//! The rest of the system that is NOT the state transition function is called the
+//! [**Node**](crate::reference_docs::glossary#node), and is a normal binary that is compiled from
+//! Rust to different hardware targets.
 //!
 //! This design enables all Substrate-based chains to be fork-less-ly upgradeable, because the
 //! Runtime can be updates on the fly, within the execution of a block, and the node is (for the
@@ -47,15 +48,18 @@
 #![doc = simple_mermaid::mermaid!("../../../mermaid/substrate_client_runtime.mmd")]
 //!
 //! A runtime must have a set of runtime APIs in order to have any meaningful blockchain
-//! functionality, but it can also expose more APIs. See TODO as an example of how to add custom
-//! runtime APIs to your FRAME-based runtime.
+//! functionality, but it can also expose more APIs. See
+//! [`crate::reference_docs::custom_runtime_api_rpc`] as an example of how to add custom runtime
+//! APIs to your FRAME-based runtime.
 //!
 //! Similarly, for a runtime to be "compatible" with a node, the node must implement the full set of
 //! host functions that the runtime at any point in time requires. Given the fact that a runtime can
 //! evolve in time, and a blockchain node (typically) wishes to be capable of re-executing all the
 //! previous blocks, this means that a node must always maintain support for the old host functions.
-//! This also implies that adding a new host function is a big commitment and should be done with
-//! care. This is why, for example, adding a new host function to Polkadot always requires an RFC.
+//! **This implies that adding a new host function is a big commitment and should be done with
+//! care**. This is why, for example, adding a new host function to Polkadot always requires an RFC.
+//! Learn how to add a new host function to your runtime in
+//! [`crate::reference_docs::custom_host_functions`].
 //!
 //! ## Node vs. Runtime
 //!
@@ -90,11 +94,11 @@
 //!
 //! In fact, [`sp_core::storage::well_known_keys`] are the only state keys that the node side is
 //! aware of. The rest of the state, including what logic the runtime has, what balance each user
-//! has and such are all only comprehensible to the runtime.
+//! has and such, are all only comprehensible to the runtime.
 #![doc = simple_mermaid::mermaid!("../../../mermaid/state.mmd")]
 //!
 //! In the above diagram, all of the state keys and values are opaque bytes to the node. The node
-//! does not know what they mean, and it does not now what is the type of the corresponding value
+//! does not know what they mean, and it does not know what is the type of the corresponding value
 //! (e.g. if it is a number of a vector). Contrary, the runtime knows both the meaning of their
 //! keys, and the type of the values.
 //!
@@ -105,9 +109,50 @@
 //!
 //! ## Native Runtime
 //!
-//! TODO
+//! Historically, the node software also kept a native copy of the runtime at the time of
+//! compilation within it. This used to be called the "Native Runtime". The main purpose of the
+//! native runtime used to be leveraging the faster execution time and better debugging
+//! infrastructure of native code. However, neither of the two arguments strongly hold and the
+//! native runtime is being fully removed from the node-sdk.
 //!
+//! See: <https://github.com/paritytech/polkadot-sdk/issues/62>
+//!
+//! > Also, note that the flags [`sc_cli::ExecutionStrategy::Native`] is already a noop and all
+//! > chains built with Substrate only use WASM execution.
+//!
+//! ### Runtime Versions
+//!
+//! An important detail of the native execution worth learning about is that the node software,
+//! obviously, only uses the native runtime if it is the same code as with the wasm blob stored
+//! onchain. Else, nodes who run the native runtime will come to a different state transition. How
+//! do nodes determine if two runtimes are the same? Through the very important
+//! [`sp_version::RuntimeVersion`]. All runtimes expose their version via a runtime api
+//! ([`sp_api::Core::version`]) that returns this struct. The node software, or other applications,
+//! inspect this struct to examine the identity of a runtime, and to determine if two runtimes are
+//! the same. Namely, [`sp_version::RuntimeVersion::spec_version`] is the main key that implies two
+//! runtimes are the same.
+//!
+//! Therefore, it is utmost important to make sure before any runtime upgrade, the spec version is
+//! updated.
 //!
 //! ## Example: Block Execution.
 //!
-//! TODO
+//! As a final example to recap, let's look at how Substrate-based nodes execute blocks. Blocks are
+//! received in the node side software as opaque blobs and in the networking layer.
+//!
+//! At some point, based on the consensus algorithm's rules, the node decides to import (aka.
+//! *validate*) a block.
+//!
+//! * First, the node will then fetch the state of the parent hash of the block that wishes to be
+//! imported.
+//! * The runtime is fetched from this state, and placed into a WASM execution environment.
+//! * The [`sp_api::Core::execute_block`] runtime API is called and the blocked is passed in as an
+//! argument.
+//! * The runtime will then execute the block, and update the state accordingly. Any state update is
+//!   issues via the [`sp_io::storage`] host functions.
+//! * Both the runtime and node will check the state-root of the state after the block execution to
+//!   match the one claimed in the block header.
+//!
+//! > Example taken from [this
+//! > lecture](https://polkadot-blockchain-academy.github.io/pba-book/substrate/wasm/page.html#example-2-block-import-9)
+//! > of the Polkadot Blockchain Academy.
diff --git a/polkadot/README.md b/polkadot/README.md
index d7435f27b946f096dc6902a15e556c2b3d58799e..47af79a3aa92470f6de863e1ab9f5e4b96308889 100644
--- a/polkadot/README.md
+++ b/polkadot/README.md
@@ -11,7 +11,7 @@ guides, like how to run a validator node, see the [Polkadot Wiki](https://wiki.p
 
 If you just wish to run a Polkadot node without compiling it yourself, you may either:
 
-- run the latest binary from our [releases](https://github.com/paritytech/polkadot-sdk/releases) page (make sure to also
+- run the [latest released binary](https://github.com/paritytech/polkadot-sdk/releases/latest) (make sure to also
   download all the `worker` binaries and put them in the same directory as `polkadot`), or
 - install Polkadot from one of our package repositories.
 
diff --git a/polkadot/cli/Cargo.toml b/polkadot/cli/Cargo.toml
index 719d00490a9d031c48fd8d047eec319d60b8e7b0..1917dcd579c4c6a723acc7f5fcde086f6e8e5e53 100644
--- a/polkadot/cli/Cargo.toml
+++ b/polkadot/cli/Cargo.toml
@@ -23,10 +23,10 @@ clap = { version = "4.5.3", features = ["derive"], optional = true }
 log = { workspace = true, default-features = true }
 thiserror = { workspace = true }
 futures = "0.3.30"
-pyro = { package = "pyroscope", version = "0.5.3", optional = true }
+pyroscope = { version = "0.5.3", optional = true }
 pyroscope_pprofrs = { version = "0.2", optional = true }
 
-service = { package = "polkadot-service", path = "../node/service", default-features = false, optional = true }
+polkadot-service = { path = "../node/service", default-features = false, optional = true }
 
 sp-core = { path = "../../substrate/primitives/core" }
 sp-io = { path = "../../substrate/primitives/io" }
@@ -48,7 +48,8 @@ substrate-build-script-utils = { path = "../../substrate/utils/build-script-util
 
 [features]
 default = ["cli", "db", "full-node"]
-db = ["service/db"]
+db = ["polkadot-service/db"]
+service = ["dep:polkadot-service"]
 cli = [
 	"clap",
 	"frame-benchmarking-cli",
@@ -60,24 +61,24 @@ cli = [
 runtime-benchmarks = [
 	"frame-benchmarking-cli?/runtime-benchmarks",
 	"polkadot-node-metrics/runtime-benchmarks",
+	"polkadot-service?/runtime-benchmarks",
 	"sc-service?/runtime-benchmarks",
-	"service/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 ]
-full-node = ["service/full-node"]
+full-node = ["polkadot-service/full-node"]
 try-runtime = [
-	"service/try-runtime",
+	"polkadot-service?/try-runtime",
 	"sp-runtime/try-runtime",
 ]
-fast-runtime = ["service/fast-runtime"]
-pyroscope = ["pyro", "pyroscope_pprofrs"]
+fast-runtime = ["polkadot-service/fast-runtime"]
+pyroscope = ["dep:pyroscope", "pyroscope_pprofrs"]
 
 # Configure the native runtimes to use.
-westend-native = ["service/westend-native"]
-rococo-native = ["service/rococo-native"]
+westend-native = ["polkadot-service/westend-native"]
+rococo-native = ["polkadot-service/rococo-native"]
 
-malus = ["full-node", "service/malus"]
+malus = ["full-node", "polkadot-service/malus"]
 runtime-metrics = [
 	"polkadot-node-metrics/runtime-metrics",
-	"service/runtime-metrics",
+	"polkadot-service/runtime-metrics",
 ]
diff --git a/polkadot/cli/src/command.rs b/polkadot/cli/src/command.rs
index f5ee538e8cec5f418c0f2bb06336f78a81425cae..b89054b4dc32178b0c42b3f365392e5202b88bc5 100644
--- a/polkadot/cli/src/command.rs
+++ b/polkadot/cli/src/command.rs
@@ -18,17 +18,17 @@ use crate::cli::{Cli, Subcommand, NODE_VERSION};
 use frame_benchmarking_cli::{BenchmarkCmd, ExtrinsicFactory, SUBSTRATE_REFERENCE_HARDWARE};
 use futures::future::TryFutureExt;
 use log::info;
-use sc_cli::SubstrateCli;
-use service::{
+use polkadot_service::{
 	self,
 	benchmarking::{benchmark_inherent_data, RemarkBuilder, TransferKeepAliveBuilder},
 	HeaderBackend, IdentifyVariant,
 };
+use sc_cli::SubstrateCli;
 use sp_core::crypto::Ss58AddressFormatRegistry;
 use sp_keyring::Sr25519Keyring;
 use std::net::ToSocketAddrs;
 
-pub use crate::{error::Error, service::BlockId};
+pub use crate::error::Error;
 #[cfg(feature = "hostperfcheck")]
 pub use polkadot_performance_test::PerfCheckError;
 #[cfg(feature = "pyroscope")]
@@ -85,55 +85,55 @@ impl SubstrateCli for Cli {
 			id
 		};
 		Ok(match id {
-			"kusama" => Box::new(service::chain_spec::kusama_config()?),
+			"kusama" => Box::new(polkadot_service::chain_spec::kusama_config()?),
 			name if name.starts_with("kusama-") && !name.ends_with(".json") =>
 				Err(format!("`{name}` is not supported anymore as the kusama native runtime no longer part of the node."))?,
-			"polkadot" => Box::new(service::chain_spec::polkadot_config()?),
+			"polkadot" => Box::new(polkadot_service::chain_spec::polkadot_config()?),
 			name if name.starts_with("polkadot-") && !name.ends_with(".json") =>
 				Err(format!("`{name}` is not supported anymore as the polkadot native runtime no longer part of the node."))?,
-			"paseo" => Box::new(service::chain_spec::paseo_config()?),
-			"rococo" => Box::new(service::chain_spec::rococo_config()?),
+			"paseo" => Box::new(polkadot_service::chain_spec::paseo_config()?),
+			"rococo" => Box::new(polkadot_service::chain_spec::rococo_config()?),
 			#[cfg(feature = "rococo-native")]
-			"dev" | "rococo-dev" => Box::new(service::chain_spec::rococo_development_config()?),
+			"dev" | "rococo-dev" => Box::new(polkadot_service::chain_spec::rococo_development_config()?),
 			#[cfg(feature = "rococo-native")]
-			"rococo-local" => Box::new(service::chain_spec::rococo_local_testnet_config()?),
+			"rococo-local" => Box::new(polkadot_service::chain_spec::rococo_local_testnet_config()?),
 			#[cfg(feature = "rococo-native")]
-			"rococo-staging" => Box::new(service::chain_spec::rococo_staging_testnet_config()?),
+			"rococo-staging" => Box::new(polkadot_service::chain_spec::rococo_staging_testnet_config()?),
 			#[cfg(not(feature = "rococo-native"))]
 			name if name.starts_with("rococo-") && !name.ends_with(".json") || name == "dev" =>
 				Err(format!("`{}` only supported with `rococo-native` feature enabled.", name))?,
-			"westend" => Box::new(service::chain_spec::westend_config()?),
+			"westend" => Box::new(polkadot_service::chain_spec::westend_config()?),
 			#[cfg(feature = "westend-native")]
-			"westend-dev" => Box::new(service::chain_spec::westend_development_config()?),
+			"westend-dev" => Box::new(polkadot_service::chain_spec::westend_development_config()?),
 			#[cfg(feature = "westend-native")]
-			"westend-local" => Box::new(service::chain_spec::westend_local_testnet_config()?),
+			"westend-local" => Box::new(polkadot_service::chain_spec::westend_local_testnet_config()?),
 			#[cfg(feature = "westend-native")]
-			"westend-staging" => Box::new(service::chain_spec::westend_staging_testnet_config()?),
+			"westend-staging" => Box::new(polkadot_service::chain_spec::westend_staging_testnet_config()?),
 			#[cfg(not(feature = "westend-native"))]
 			name if name.starts_with("westend-") && !name.ends_with(".json") =>
 				Err(format!("`{}` only supported with `westend-native` feature enabled.", name))?,
-			"wococo" => Box::new(service::chain_spec::wococo_config()?),
+			"wococo" => Box::new(polkadot_service::chain_spec::wococo_config()?),
 			#[cfg(feature = "rococo-native")]
-			"wococo-dev" => Box::new(service::chain_spec::wococo_development_config()?),
+			"wococo-dev" => Box::new(polkadot_service::chain_spec::wococo_development_config()?),
 			#[cfg(feature = "rococo-native")]
-			"wococo-local" => Box::new(service::chain_spec::wococo_local_testnet_config()?),
+			"wococo-local" => Box::new(polkadot_service::chain_spec::wococo_local_testnet_config()?),
 			#[cfg(not(feature = "rococo-native"))]
 			name if name.starts_with("wococo-") =>
 				Err(format!("`{}` only supported with `rococo-native` feature enabled.", name))?,
 			#[cfg(feature = "rococo-native")]
-			"versi-dev" => Box::new(service::chain_spec::versi_development_config()?),
+			"versi-dev" => Box::new(polkadot_service::chain_spec::versi_development_config()?),
 			#[cfg(feature = "rococo-native")]
-			"versi-local" => Box::new(service::chain_spec::versi_local_testnet_config()?),
+			"versi-local" => Box::new(polkadot_service::chain_spec::versi_local_testnet_config()?),
 			#[cfg(feature = "rococo-native")]
-			"versi-staging" => Box::new(service::chain_spec::versi_staging_testnet_config()?),
+			"versi-staging" => Box::new(polkadot_service::chain_spec::versi_staging_testnet_config()?),
 			#[cfg(not(feature = "rococo-native"))]
 			name if name.starts_with("versi-") =>
 				Err(format!("`{}` only supported with `rococo-native` feature enabled.", name))?,
 			path => {
 				let path = std::path::PathBuf::from(path);
 
-				let chain_spec = Box::new(service::GenericChainSpec::from_json_file(path.clone())?)
-					as Box<dyn service::ChainSpec>;
+				let chain_spec = Box::new(polkadot_service::GenericChainSpec::from_json_file(path.clone())?)
+					as Box<dyn polkadot_service::ChainSpec>;
 
 				// When `force_*` is given or the file name starts with the name of one of the known
 				// chains, we use the chain spec for the specific chain.
@@ -142,11 +142,11 @@ impl SubstrateCli for Cli {
 					chain_spec.is_wococo() ||
 					chain_spec.is_versi()
 				{
-					Box::new(service::RococoChainSpec::from_json_file(path)?)
+					Box::new(polkadot_service::RococoChainSpec::from_json_file(path)?)
 				} else if self.run.force_kusama || chain_spec.is_kusama() {
-					Box::new(service::GenericChainSpec::from_json_file(path)?)
+					Box::new(polkadot_service::GenericChainSpec::from_json_file(path)?)
 				} else if self.run.force_westend || chain_spec.is_westend() {
-					Box::new(service::WestendChainSpec::from_json_file(path)?)
+					Box::new(polkadot_service::WestendChainSpec::from_json_file(path)?)
 				} else {
 					chain_spec
 				}
@@ -155,7 +155,7 @@ impl SubstrateCli for Cli {
 	}
 }
 
-fn set_default_ss58_version(spec: &Box<dyn service::ChainSpec>) {
+fn set_default_ss58_version(spec: &Box<dyn polkadot_service::ChainSpec>) {
 	let ss58_version = if spec.is_kusama() {
 		Ss58AddressFormatRegistry::KusamaAccount
 	} else if spec.is_westend() {
@@ -176,7 +176,7 @@ fn set_default_ss58_version(spec: &Box<dyn service::ChainSpec>) {
 #[cfg(feature = "malus")]
 pub fn run_node(
 	run: Cli,
-	overseer_gen: impl service::OverseerGen,
+	overseer_gen: impl polkadot_service::OverseerGen,
 	malus_finality_delay: Option<u32>,
 ) -> Result<()> {
 	run_node_inner(run, overseer_gen, malus_finality_delay, |_logger_builder, _config| {})
@@ -184,7 +184,7 @@ pub fn run_node(
 
 fn run_node_inner<F>(
 	cli: Cli,
-	overseer_gen: impl service::OverseerGen,
+	overseer_gen: impl polkadot_service::OverseerGen,
 	maybe_malus_finality_delay: Option<u32>,
 	logger_hook: F,
 ) -> Result<()>
@@ -235,10 +235,10 @@ where
 			.flatten();
 
 		let database_source = config.database.clone();
-		let task_manager = service::build_full(
+		let task_manager = polkadot_service::build_full(
 			config,
-			service::NewFullParams {
-				is_parachain_node: service::IsParachainNode::No,
+			polkadot_service::NewFullParams {
+				is_parachain_node: polkadot_service::IsParachainNode::No,
 				enable_beefy,
 				force_authoring_backoff: cli.run.force_authoring_backoff,
 				jaeger_agent,
@@ -284,7 +284,7 @@ pub fn run() -> Result<()> {
 			.next()
 			.ok_or_else(|| Error::AddressResolutionMissing)?;
 		// The pyroscope agent requires a `http://` prefix, so we just do that.
-		let agent = pyro::PyroscopeAgent::builder(
+		let agent = pyroscope::PyroscopeAgent::builder(
 			"http://".to_owned() + address.to_string().as_str(),
 			"polkadot".to_owned(),
 		)
@@ -303,7 +303,7 @@ pub fn run() -> Result<()> {
 	match &cli.subcommand {
 		None => run_node_inner(
 			cli,
-			service::ValidatorOverseerGen,
+			polkadot_service::ValidatorOverseerGen,
 			None,
 			polkadot_node_metrics::logger_hook(),
 		),
@@ -319,7 +319,7 @@ pub fn run() -> Result<()> {
 
 			runner.async_run(|mut config| {
 				let (client, _, import_queue, task_manager) =
-					service::new_chain_ops(&mut config, None)?;
+					polkadot_service::new_chain_ops(&mut config, None)?;
 				Ok((cmd.run(client, import_queue).map_err(Error::SubstrateCli), task_manager))
 			})
 		},
@@ -331,7 +331,8 @@ pub fn run() -> Result<()> {
 
 			Ok(runner.async_run(|mut config| {
 				let (client, _, _, task_manager) =
-					service::new_chain_ops(&mut config, None).map_err(Error::PolkadotService)?;
+					polkadot_service::new_chain_ops(&mut config, None)
+						.map_err(Error::PolkadotService)?;
 				Ok((cmd.run(client, config.database).map_err(Error::SubstrateCli), task_manager))
 			})?)
 		},
@@ -342,7 +343,8 @@ pub fn run() -> Result<()> {
 			set_default_ss58_version(chain_spec);
 
 			Ok(runner.async_run(|mut config| {
-				let (client, _, _, task_manager) = service::new_chain_ops(&mut config, None)?;
+				let (client, _, _, task_manager) =
+					polkadot_service::new_chain_ops(&mut config, None)?;
 				Ok((cmd.run(client, config.chain_spec).map_err(Error::SubstrateCli), task_manager))
 			})?)
 		},
@@ -354,7 +356,7 @@ pub fn run() -> Result<()> {
 
 			Ok(runner.async_run(|mut config| {
 				let (client, _, import_queue, task_manager) =
-					service::new_chain_ops(&mut config, None)?;
+					polkadot_service::new_chain_ops(&mut config, None)?;
 				Ok((cmd.run(client, import_queue).map_err(Error::SubstrateCli), task_manager))
 			})?)
 		},
@@ -369,15 +371,18 @@ pub fn run() -> Result<()> {
 			set_default_ss58_version(chain_spec);
 
 			Ok(runner.async_run(|mut config| {
-				let (client, backend, _, task_manager) = service::new_chain_ops(&mut config, None)?;
+				let (client, backend, _, task_manager) =
+					polkadot_service::new_chain_ops(&mut config, None)?;
 				let aux_revert = Box::new(|client, backend, blocks| {
-					service::revert_backend(client, backend, blocks, config).map_err(|err| {
-						match err {
-							service::Error::Blockchain(err) => err.into(),
-							// Generic application-specific error.
-							err => sc_cli::Error::Application(err.into()),
-						}
-					})
+					polkadot_service::revert_backend(client, backend, blocks, config).map_err(
+						|err| {
+							match err {
+								polkadot_service::Error::Blockchain(err) => err.into(),
+								// Generic application-specific error.
+								err => sc_cli::Error::Application(err.into()),
+							}
+						},
+					)
 				});
 				Ok((
 					cmd.run(client, backend, Some(aux_revert)).map_err(Error::SubstrateCli),
@@ -400,21 +405,22 @@ pub fn run() -> Result<()> {
 					.into()),
 				#[cfg(feature = "runtime-benchmarks")]
 				BenchmarkCmd::Storage(cmd) => runner.sync_run(|mut config| {
-					let (client, backend, _, _) = service::new_chain_ops(&mut config, None)?;
+					let (client, backend, _, _) =
+						polkadot_service::new_chain_ops(&mut config, None)?;
 					let db = backend.expose_db();
 					let storage = backend.expose_storage();
 
 					cmd.run(config, client.clone(), db, storage).map_err(Error::SubstrateCli)
 				}),
 				BenchmarkCmd::Block(cmd) => runner.sync_run(|mut config| {
-					let (client, _, _, _) = service::new_chain_ops(&mut config, None)?;
+					let (client, _, _, _) = polkadot_service::new_chain_ops(&mut config, None)?;
 
 					cmd.run(client.clone()).map_err(Error::SubstrateCli)
 				}),
 				// These commands are very similar and can be handled in nearly the same way.
 				BenchmarkCmd::Extrinsic(_) | BenchmarkCmd::Overhead(_) =>
 					runner.sync_run(|mut config| {
-						let (client, _, _, _) = service::new_chain_ops(&mut config, None)?;
+						let (client, _, _, _) = polkadot_service::new_chain_ops(&mut config, None)?;
 						let header = client.header(client.info().genesis_hash).unwrap().unwrap();
 						let inherent_data = benchmark_inherent_data(header)
 							.map_err(|e| format!("generating inherent data: {:?}", e))?;
@@ -454,7 +460,7 @@ pub fn run() -> Result<()> {
 
 					if cfg!(feature = "runtime-benchmarks") {
 						runner.sync_run(|config| {
-							cmd.run_with_spec::<sp_runtime::traits::HashingFor<service::Block>, ()>(
+							cmd.run_with_spec::<sp_runtime::traits::HashingFor<polkadot_service::Block>, ()>(
 								Some(config.chain_spec),
 							)
 							.map_err(|e| Error::SubstrateCli(e))
@@ -481,7 +487,7 @@ pub fn run() -> Result<()> {
 		Some(Subcommand::Key(cmd)) => Ok(cmd.run(&cli)?),
 		Some(Subcommand::ChainInfo(cmd)) => {
 			let runner = cli.create_runner(cmd)?;
-			Ok(runner.sync_run(|config| cmd.run::<service::Block>(&config))?)
+			Ok(runner.sync_run(|config| cmd.run::<polkadot_service::Block>(&config))?)
 		},
 	}?;
 
diff --git a/polkadot/cli/src/error.rs b/polkadot/cli/src/error.rs
index 219289796522e495db1b7170a8efcec9b95a3530..1fcd2ca04bb05fa76d057343a2a31b65c88d09ea 100644
--- a/polkadot/cli/src/error.rs
+++ b/polkadot/cli/src/error.rs
@@ -17,7 +17,7 @@
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
 	#[error(transparent)]
-	PolkadotService(#[from] service::Error),
+	PolkadotService(#[from] polkadot_service::Error),
 
 	#[error(transparent)]
 	SubstrateCli(#[from] sc_cli::Error),
@@ -34,7 +34,7 @@ pub enum Error {
 
 	#[cfg(feature = "pyroscope")]
 	#[error("Failed to connect to pyroscope agent")]
-	PyroscopeError(#[from] pyro::error::PyroscopeError),
+	PyroscopeError(#[from] pyroscope::error::PyroscopeError),
 
 	#[error("Failed to resolve provided URL")]
 	AddressResolutionFailure(#[from] std::io::Error),
diff --git a/polkadot/cli/src/lib.rs b/polkadot/cli/src/lib.rs
index 4bb0dfb7583543937380d21da249bc612b842aba..944f8438f20fd6b126d47105ef26df07493c40ec 100644
--- a/polkadot/cli/src/lib.rs
+++ b/polkadot/cli/src/lib.rs
@@ -26,10 +26,12 @@ mod command;
 mod error;
 
 #[cfg(feature = "service")]
-pub use service::{self, Block, CoreApi, IdentifyVariant, ProvideRuntimeApi, TFullClient};
+pub use polkadot_service::{
+	self as service, Block, CoreApi, IdentifyVariant, ProvideRuntimeApi, TFullClient,
+};
 
 #[cfg(feature = "malus")]
-pub use service::overseer::validator_overseer_builder;
+pub use polkadot_service::overseer::validator_overseer_builder;
 
 #[cfg(feature = "cli")]
 pub use cli::*;
diff --git a/polkadot/core-primitives/Cargo.toml b/polkadot/core-primitives/Cargo.toml
index 9794f8286ac324b3f0fde27cb13db9d8d1cb8941..7d94196fa26dbbe95bfe543243c62099f1b4cb03 100644
--- a/polkadot/core-primitives/Cargo.toml
+++ b/polkadot/core-primitives/Cargo.toml
@@ -14,12 +14,12 @@ sp-core = { path = "../../substrate/primitives/core", default-features = false }
 sp-std = { path = "../../substrate/primitives/std", default-features = false }
 sp-runtime = { path = "../../substrate/primitives/runtime", default-features = false }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 
 [features]
 default = ["std"]
 std = [
-	"parity-scale-codec/std",
+	"codec/std",
 	"scale-info/std",
 	"sp-core/std",
 	"sp-runtime/std",
diff --git a/polkadot/core-primitives/src/lib.rs b/polkadot/core-primitives/src/lib.rs
index a74cdef3ad763a552fcb33586eb3e1956006ee47..072c045a8c7039da82e0128d00e1886a7817ec4d 100644
--- a/polkadot/core-primitives/src/lib.rs
+++ b/polkadot/core-primitives/src/lib.rs
@@ -20,7 +20,7 @@
 //!
 //! These core Polkadot types are used by the relay chain and the Parachains.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_runtime::{
 	generic,
diff --git a/polkadot/erasure-coding/Cargo.toml b/polkadot/erasure-coding/Cargo.toml
index b230631f72b0486a94990d575673990e81c20e66..3c14fd95eee3b29988a87b68047f585c32c5bbc0 100644
--- a/polkadot/erasure-coding/Cargo.toml
+++ b/polkadot/erasure-coding/Cargo.toml
@@ -13,12 +13,13 @@ workspace = true
 polkadot-primitives = { path = "../primitives" }
 polkadot-node-primitives = { package = "polkadot-node-primitives", path = "../node/primitives" }
 novelpoly = { package = "reed-solomon-novelpoly", version = "2.0.0" }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive", "std"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive", "std"] }
 sp-core = { path = "../../substrate/primitives/core" }
 sp-trie = { path = "../../substrate/primitives/trie" }
 thiserror = { workspace = true }
 
 [dev-dependencies]
+quickcheck = { version = "1.0.3", default-features = false }
 criterion = { version = "0.5.1", default-features = false, features = ["cargo_bench_support"] }
 
 [[bench]]
diff --git a/polkadot/erasure-coding/benches/README.md b/polkadot/erasure-coding/benches/README.md
index 94fca5400c610636831c08b5282d6d47f4199878..20f79827d280b23782368c4f56f2a85f5d4eed41 100644
--- a/polkadot/erasure-coding/benches/README.md
+++ b/polkadot/erasure-coding/benches/README.md
@@ -7,7 +7,8 @@ cargo bench
 ## `scaling_with_validators`
 
 This benchmark evaluates the performance of constructing the chunks and the erasure root from PoV and
-reconstructing the PoV from chunks. You can see the results of running this bench on 5950x below.
+reconstructing the PoV from chunks (either from systematic chunks or regular chunks).
+You can see the results of running this bench on 5950x below (only including recovery from regular chunks).
 Interestingly, with `10_000` chunks (validators) its slower than with `50_000` for both construction
 and reconstruction.
 ```
@@ -37,3 +38,6 @@ reconstruct/10000       time:   [496.35 ms 505.17 ms 515.42 ms]
 reconstruct/50000       time:   [276.56 ms 277.53 ms 278.58 ms]
                         thrpt:  [17.948 MiB/s 18.016 MiB/s 18.079 MiB/s]
 ```
+
+Results from running on an Apple M2 Pro, systematic recovery is generally 40 times faster than
+regular recovery, achieving 1 Gib/s.
diff --git a/polkadot/erasure-coding/benches/scaling_with_validators.rs b/polkadot/erasure-coding/benches/scaling_with_validators.rs
index 759385bbdef4ed85e5db087d2d93c7cb51250db8..3d743faa4169b48f651e99e2e005237d727841d7 100644
--- a/polkadot/erasure-coding/benches/scaling_with_validators.rs
+++ b/polkadot/erasure-coding/benches/scaling_with_validators.rs
@@ -53,12 +53,16 @@ fn construct_and_reconstruct_5mb_pov(c: &mut Criterion) {
 	}
 	group.finish();
 
-	let mut group = c.benchmark_group("reconstruct");
+	let mut group = c.benchmark_group("reconstruct_regular");
 	for n_validators in N_VALIDATORS {
 		let all_chunks = chunks(n_validators, &pov);
 
-		let mut c: Vec<_> = all_chunks.iter().enumerate().map(|(i, c)| (&c[..], i)).collect();
-		let last_chunks = c.split_off((c.len() - 1) * 2 / 3);
+		let chunks: Vec<_> = all_chunks
+			.iter()
+			.enumerate()
+			.take(polkadot_erasure_coding::recovery_threshold(n_validators).unwrap())
+			.map(|(i, c)| (&c[..], i))
+			.collect();
 
 		group.throughput(Throughput::Bytes(pov.len() as u64));
 		group.bench_with_input(
@@ -67,7 +71,31 @@ fn construct_and_reconstruct_5mb_pov(c: &mut Criterion) {
 			|b, &n| {
 				b.iter(|| {
 					let _pov: Vec<u8> =
-						polkadot_erasure_coding::reconstruct(n, last_chunks.clone()).unwrap();
+						polkadot_erasure_coding::reconstruct(n, chunks.clone()).unwrap();
+				});
+			},
+		);
+	}
+	group.finish();
+
+	let mut group = c.benchmark_group("reconstruct_systematic");
+	for n_validators in N_VALIDATORS {
+		let all_chunks = chunks(n_validators, &pov);
+
+		let chunks = all_chunks
+			.into_iter()
+			.take(polkadot_erasure_coding::systematic_recovery_threshold(n_validators).unwrap())
+			.collect::<Vec<_>>();
+
+		group.throughput(Throughput::Bytes(pov.len() as u64));
+		group.bench_with_input(
+			BenchmarkId::from_parameter(n_validators),
+			&n_validators,
+			|b, &n| {
+				b.iter(|| {
+					let _pov: Vec<u8> =
+						polkadot_erasure_coding::reconstruct_from_systematic(n, chunks.clone())
+							.unwrap();
 				});
 			},
 		);
diff --git a/polkadot/erasure-coding/fuzzer/Cargo.toml b/polkadot/erasure-coding/fuzzer/Cargo.toml
index 4e5ef9d229d82db298f57cd4f853042079b5a1f8..bd254f6d51651d27ac2a992285c80f9e1e272623 100644
--- a/polkadot/erasure-coding/fuzzer/Cargo.toml
+++ b/polkadot/erasure-coding/fuzzer/Cargo.toml
@@ -13,7 +13,7 @@ workspace = true
 polkadot-erasure-coding = { path = ".." }
 honggfuzz = "0.5"
 polkadot-primitives = { path = "../../primitives" }
-primitives = { package = "polkadot-node-primitives", path = "../../node/primitives" }
+polkadot-node-primitives = { path = "../../node/primitives" }
 
 [[bin]]
 name = "reconstruct"
diff --git a/polkadot/erasure-coding/fuzzer/src/reconstruct.rs b/polkadot/erasure-coding/fuzzer/src/reconstruct.rs
index b2f9690a6fd3791f04eca052a902ab660c777e07..6cb5742bc7d1267af24450900a700f42dc18cc24 100644
--- a/polkadot/erasure-coding/fuzzer/src/reconstruct.rs
+++ b/polkadot/erasure-coding/fuzzer/src/reconstruct.rs
@@ -16,7 +16,7 @@
 
 use honggfuzz::fuzz;
 use polkadot_erasure_coding::*;
-use primitives::AvailableData;
+use polkadot_node_primitives::AvailableData;
 
 fn main() {
 	loop {
diff --git a/polkadot/erasure-coding/fuzzer/src/round_trip.rs b/polkadot/erasure-coding/fuzzer/src/round_trip.rs
index 2e38becf651d447d71e2b26463f0c26df277994b..627c9724d494832ede0d5ced55a2524fd179052b 100644
--- a/polkadot/erasure-coding/fuzzer/src/round_trip.rs
+++ b/polkadot/erasure-coding/fuzzer/src/round_trip.rs
@@ -16,8 +16,8 @@
 
 use honggfuzz::fuzz;
 use polkadot_erasure_coding::*;
+use polkadot_node_primitives::{AvailableData, BlockData, PoV};
 use polkadot_primitives::PersistedValidationData;
-use primitives::{AvailableData, BlockData, PoV};
 use std::sync::Arc;
 
 fn main() {
diff --git a/polkadot/erasure-coding/src/lib.rs b/polkadot/erasure-coding/src/lib.rs
index e5155df4beba95aa9e7944e3e9a67d4e55a1db9c..9ebf5d11d7a78e9c7044db6743fcd33ff1dc5110 100644
--- a/polkadot/erasure-coding/src/lib.rs
+++ b/polkadot/erasure-coding/src/lib.rs
@@ -24,7 +24,7 @@
 //! f is the maximum number of faulty validators in the system.
 //! The data is coded so any f+1 chunks can be used to reconstruct the full data.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_primitives::{AvailableData, Proof};
 use polkadot_primitives::{BlakeTwo256, Hash as H256, HashT};
 use sp_core::Blake2Hasher;
@@ -69,6 +69,9 @@ pub enum Error {
 	/// Bad payload in reconstructed bytes.
 	#[error("Reconstructed payload invalid")]
 	BadPayload,
+	/// Unable to decode reconstructed bytes.
+	#[error("Unable to decode reconstructed payload: {0}")]
+	Decode(#[source] codec::Error),
 	/// Invalid branch proof.
 	#[error("Invalid branch proof")]
 	InvalidBranchProof,
@@ -110,6 +113,14 @@ pub const fn recovery_threshold(n_validators: usize) -> Result<usize, Error> {
 	Ok(needed + 1)
 }
 
+/// Obtain the threshold of systematic chunks that should be enough to recover the data.
+///
+/// If the regular `recovery_threshold` is a power of two, then it returns the same value.
+/// Otherwise, it returns the next lower power of two.
+pub fn systematic_recovery_threshold(n_validators: usize) -> Result<usize, Error> {
+	code_params(n_validators).map(|params| params.k())
+}
+
 fn code_params(n_validators: usize) -> Result<CodeParams, Error> {
 	// we need to be able to reconstruct from 1/3 - eps
 
@@ -127,6 +138,41 @@ fn code_params(n_validators: usize) -> Result<CodeParams, Error> {
 	})
 }
 
+/// Reconstruct the v1 available data from the set of systematic chunks.
+///
+/// Provide a vector containing chunk data. If too few chunks are provided, recovery is not
+/// possible.
+pub fn reconstruct_from_systematic_v1(
+	n_validators: usize,
+	chunks: Vec<Vec<u8>>,
+) -> Result<AvailableData, Error> {
+	reconstruct_from_systematic(n_validators, chunks)
+}
+
+/// Reconstruct the available data from the set of systematic chunks.
+///
+/// Provide a vector containing the first k chunks in order. If too few chunks are provided,
+/// recovery is not possible.
+pub fn reconstruct_from_systematic<T: Decode>(
+	n_validators: usize,
+	chunks: Vec<Vec<u8>>,
+) -> Result<T, Error> {
+	let code_params = code_params(n_validators)?;
+	let k = code_params.k();
+
+	for chunk_data in chunks.iter().take(k) {
+		if chunk_data.len() % 2 != 0 {
+			return Err(Error::UnevenLength)
+		}
+	}
+
+	let bytes = code_params.make_encoder().reconstruct_from_systematic(
+		chunks.into_iter().take(k).map(|data| WrappedShard::new(data)).collect(),
+	)?;
+
+	Decode::decode(&mut &bytes[..]).map_err(|err| Error::Decode(err))
+}
+
 /// Obtain erasure-coded chunks for v1 `AvailableData`, one for each validator.
 ///
 /// Works only up to 65536 validators, and `n_validators` must be non-zero.
@@ -285,13 +331,41 @@ pub fn branch_hash(root: &H256, branch_nodes: &Proof, index: usize) -> Result<H2
 
 #[cfg(test)]
 mod tests {
+	use std::sync::Arc;
+
 	use super::*;
 	use polkadot_node_primitives::{AvailableData, BlockData, PoV};
+	use polkadot_primitives::{HeadData, PersistedValidationData};
+	use quickcheck::{Arbitrary, Gen, QuickCheck};
 
 	// In order to adequately compute the number of entries in the Merkle
 	// trie, we must account for the fixed 16-ary trie structure.
 	const KEY_INDEX_NIBBLE_SIZE: usize = 4;
 
+	#[derive(Clone, Debug)]
+	struct ArbitraryAvailableData(AvailableData);
+
+	impl Arbitrary for ArbitraryAvailableData {
+		fn arbitrary(g: &mut Gen) -> Self {
+			// Limit the POV len to 1 mib, otherwise the test will take forever
+			let pov_len = (u32::arbitrary(g) % (1024 * 1024)).max(2);
+
+			let pov = (0..pov_len).map(|_| u8::arbitrary(g)).collect();
+
+			let pvd = PersistedValidationData {
+				parent_head: HeadData((0..u16::arbitrary(g)).map(|_| u8::arbitrary(g)).collect()),
+				relay_parent_number: u32::arbitrary(g),
+				relay_parent_storage_root: [u8::arbitrary(g); 32].into(),
+				max_pov_size: u32::arbitrary(g),
+			};
+
+			ArbitraryAvailableData(AvailableData {
+				pov: Arc::new(PoV { block_data: BlockData(pov) }),
+				validation_data: pvd,
+			})
+		}
+	}
+
 	#[test]
 	fn field_order_is_right_size() {
 		assert_eq!(MAX_VALIDATORS, 65536);
@@ -318,6 +392,25 @@ mod tests {
 		assert_eq!(reconstructed, available_data);
 	}
 
+	#[test]
+	fn round_trip_systematic_works() {
+		fn property(available_data: ArbitraryAvailableData, n_validators: u16) {
+			let n_validators = n_validators.max(2);
+			let kpow2 = systematic_recovery_threshold(n_validators as usize).unwrap();
+			let chunks = obtain_chunks(n_validators as usize, &available_data.0).unwrap();
+			assert_eq!(
+				reconstruct_from_systematic_v1(
+					n_validators as usize,
+					chunks.into_iter().take(kpow2).collect()
+				)
+				.unwrap(),
+				available_data.0
+			);
+		}
+
+		QuickCheck::new().quickcheck(property as fn(ArbitraryAvailableData, u16))
+	}
+
 	#[test]
 	fn reconstruct_does_not_panic_on_low_validator_count() {
 		let reconstructed = reconstruct_v1(1, [].iter().cloned());
diff --git a/polkadot/node/collation-generation/Cargo.toml b/polkadot/node/collation-generation/Cargo.toml
index 0a28c3a830d101a08a49a3c9eda3dc0f60c9665d..da5d10d7994970dde81b8530888c28c56dffb0b0 100644
--- a/polkadot/node/collation-generation/Cargo.toml
+++ b/polkadot/node/collation-generation/Cargo.toml
@@ -20,11 +20,11 @@ polkadot-primitives = { path = "../../primitives" }
 sp-core = { path = "../../../substrate/primitives/core" }
 sp-maybe-compressed-blob = { path = "../../../substrate/primitives/maybe-compressed-blob" }
 thiserror = { workspace = true }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
 
 [dev-dependencies]
 polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" }
 assert_matches = "1.4.0"
 rstest = "0.18.2"
 sp-keyring = { path = "../../../substrate/primitives/keyring" }
diff --git a/polkadot/node/collation-generation/src/lib.rs b/polkadot/node/collation-generation/src/lib.rs
index 374f090a2671a1c3a0f9c5f945cd16954a53bcce..0c2f8ee14a58033dce47947a4e923ea644213831 100644
--- a/polkadot/node/collation-generation/src/lib.rs
+++ b/polkadot/node/collation-generation/src/lib.rs
@@ -31,8 +31,8 @@
 
 #![deny(missing_docs)]
 
+use codec::Encode;
 use futures::{channel::oneshot, future::FutureExt, join, select};
-use parity_scale_codec::Encode;
 use polkadot_node_primitives::{
 	AvailableData, Collation, CollationGenerationConfig, CollationSecondedSignal, PoV,
 	SubmitCollationParams,
diff --git a/polkadot/node/collation-generation/src/tests.rs b/polkadot/node/collation-generation/src/tests.rs
index 10c391cba25d1cba13df33891e65f0abb10944c4..0feee79e763c94cbb6c1e1c16d6913ccd4a52bc2 100644
--- a/polkadot/node/collation-generation/src/tests.rs
+++ b/polkadot/node/collation-generation/src/tests.rs
@@ -34,15 +34,15 @@ use polkadot_primitives::{
 	AsyncBackingParams, BlockNumber, CollatorPair, HeadData, PersistedValidationData,
 	ScheduledCore, ValidationCode,
 };
+use polkadot_primitives_test_helpers::{
+	dummy_candidate_descriptor, dummy_hash, dummy_head_data, dummy_validator, make_candidate,
+};
 use rstest::rstest;
 use sp_keyring::sr25519::Keyring as Sr25519Keyring;
 use std::{
 	collections::{BTreeMap, VecDeque},
 	pin::Pin,
 };
-use test_helpers::{
-	dummy_candidate_descriptor, dummy_hash, dummy_head_data, dummy_validator, make_candidate,
-};
 
 type VirtualOverseer = TestSubsystemContextHandle<CollationGenerationMessage>;
 
diff --git a/polkadot/node/core/approval-voting/Cargo.toml b/polkadot/node/core/approval-voting/Cargo.toml
index 5bf80d59ede93b9fb3cab3ffdf409f895d24dbe4..7da3d7ddd781485d673b29980b6787b99aea9da6 100644
--- a/polkadot/node/core/approval-voting/Cargo.toml
+++ b/polkadot/node/core/approval-voting/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 [dependencies]
 futures = "0.3.30"
 futures-timer = "3.0.2"
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
 gum = { package = "tracing-gum", path = "../../gum" }
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
 schnellru = "0.2.1"
@@ -50,7 +50,7 @@ sp-consensus-babe = { path = "../../../../substrate/primitives/consensus/babe" }
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
 assert_matches = "1.4.0"
 kvdb-memorydb = "0.13.0"
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
 log = { workspace = true, default-features = true }
 env_logger = "0.11"
 
diff --git a/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs b/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs
index 9a5f0d29dbd3180676a01eba0b382dbb26ef11ea..687063dd0eb302c4b61b224ee74bb9c4a56fbe5b 100644
--- a/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs
+++ b/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs
@@ -61,7 +61,7 @@ fn main() -> Result<(), String> {
 			print!("\r[{}{}]", "#".repeat(n), "_".repeat(BENCH_COUNT - n));
 			std::io::stdout().flush().unwrap();
 			let (mut env, state) = prepare_test(config.clone(), options.clone(), false);
-			env.runtime().block_on(bench_approvals("approvals_throughput", &mut env, state))
+			env.runtime().block_on(bench_approvals(&mut env, state))
 		})
 		.collect();
 	println!("\rDone!{}", " ".repeat(BENCH_COUNT));
@@ -81,8 +81,8 @@ fn main() -> Result<(), String> {
 		("Sent to peers", 63547.0330, 0.001),
 	]));
 	messages.extend(average_usage.check_cpu_usage(&[
-		("approval-distribution", 7.0317, 0.1),
-		("approval-voting", 9.5751, 0.1),
+		("approval-distribution", 7.4075, 0.1),
+		("approval-voting", 9.9873, 0.1),
 	]));
 
 	if messages.is_empty() {
diff --git a/polkadot/node/core/approval-voting/src/approval_checking.rs b/polkadot/node/core/approval-voting/src/approval_checking.rs
index 693a28800114c5196076fcabc2a194bf36f7a218..96eb25626de8c167255027e1320b079eb8f60e2a 100644
--- a/polkadot/node/core/approval-voting/src/approval_checking.rs
+++ b/polkadot/node/core/approval-voting/src/approval_checking.rs
@@ -23,6 +23,7 @@ use polkadot_primitives::ValidatorIndex;
 use crate::{
 	persisted_entries::{ApprovalEntry, CandidateEntry, TrancheEntry},
 	time::Tick,
+	MAX_RECORDED_NO_SHOW_VALIDATORS_PER_CANDIDATE,
 };
 
 /// Result of counting the necessary tranches needed for approving a block.
@@ -32,6 +33,7 @@ pub struct TranchesToApproveResult {
 	pub required_tranches: RequiredTranches,
 	/// The total number of no_shows at the moment we are doing the counting.
 	pub total_observed_no_shows: usize,
+	pub no_show_validators: Vec<ValidatorIndex>,
 }
 
 /// The required tranches of assignments needed to determine whether a candidate is approved.
@@ -188,6 +190,8 @@ struct State {
 	/// The last tick at which a considered assignment was received.
 	last_assignment_tick: Option<Tick>,
 	total_observed_no_shows: usize,
+	// The validator's index that are no-shows.
+	no_show_validators: Vec<ValidatorIndex>,
 }
 
 impl State {
@@ -203,6 +207,7 @@ impl State {
 			return TranchesToApproveResult {
 				required_tranches: RequiredTranches::All,
 				total_observed_no_shows: self.total_observed_no_shows,
+				no_show_validators: self.no_show_validators.clone(),
 			}
 		}
 
@@ -217,6 +222,7 @@ impl State {
 					last_assignment_tick: self.last_assignment_tick,
 				},
 				total_observed_no_shows: self.total_observed_no_shows,
+				no_show_validators: self.no_show_validators.clone(),
 			}
 		}
 
@@ -234,6 +240,7 @@ impl State {
 					clock_drift,
 				},
 				total_observed_no_shows: self.total_observed_no_shows,
+				no_show_validators: self.no_show_validators.clone(),
 			}
 		} else {
 			TranchesToApproveResult {
@@ -244,6 +251,7 @@ impl State {
 					clock_drift,
 				},
 				total_observed_no_shows: self.total_observed_no_shows,
+				no_show_validators: self.no_show_validators.clone(),
 			}
 		}
 	}
@@ -253,11 +261,12 @@ impl State {
 	}
 
 	fn advance(
-		&self,
+		mut self,
 		new_assignments: usize,
 		new_no_shows: usize,
 		next_no_show: Option<Tick>,
 		last_assignment_tick: Option<Tick>,
+		no_show_validators: Vec<ValidatorIndex>,
 	) -> State {
 		let new_covered = if self.depth == 0 {
 			new_assignments
@@ -290,6 +299,17 @@ impl State {
 			(self.depth, covering, uncovered)
 		};
 
+		// Make sure we don't store too many no-show validators, since this metric
+		// is valuable if there are just a few of them to identify the problematic
+		// validators.
+		// If there are a lot then we've got bigger problems and no need to make this
+		// array unnecessarily large.
+		if self.no_show_validators.len() + no_show_validators.len() <
+			MAX_RECORDED_NO_SHOW_VALIDATORS_PER_CANDIDATE
+		{
+			self.no_show_validators.extend(no_show_validators);
+		}
+
 		State {
 			assignments,
 			depth,
@@ -299,6 +319,7 @@ impl State {
 			next_no_show,
 			last_assignment_tick,
 			total_observed_no_shows: self.total_observed_no_shows + new_no_shows,
+			no_show_validators: self.no_show_validators,
 		}
 	}
 }
@@ -354,8 +375,9 @@ fn count_no_shows(
 	block_tick: Tick,
 	no_show_duration: Tick,
 	drifted_tick_now: Tick,
-) -> (usize, Option<u64>) {
+) -> (usize, Option<u64>, Vec<ValidatorIndex>) {
 	let mut next_no_show = None;
+	let mut no_show_validators = Vec::new();
 	let no_shows = assignments
 		.iter()
 		.map(|(v_index, tick)| {
@@ -379,12 +401,14 @@ fn count_no_shows(
 				// the clock drift will be removed again to do the comparison above.
 				next_no_show = super::min_prefer_some(next_no_show, Some(no_show_at + clock_drift));
 			}
-
+			if is_no_show {
+				no_show_validators.push(*v_index);
+			}
 			is_no_show
 		})
 		.count();
 
-	(no_shows, next_no_show)
+	(no_shows, next_no_show, no_show_validators)
 }
 
 /// Determine the amount of tranches of assignments needed to determine approval of a candidate.
@@ -408,6 +432,7 @@ pub fn tranches_to_approve(
 		next_no_show: None,
 		last_assignment_tick: None,
 		total_observed_no_shows: 0,
+		no_show_validators: Vec::new(),
 	};
 
 	// The `ApprovalEntry` doesn't have any data for empty tranches. We still want to iterate over
@@ -446,7 +471,7 @@ pub fn tranches_to_approve(
 			//
 			// While we count the no-shows, we also determine the next possible no-show we might
 			// see within this tranche.
-			let (no_shows, next_no_show) = count_no_shows(
+			let (no_shows, next_no_show, no_show_validators) = count_no_shows(
 				assignments,
 				approvals,
 				clock_drift,
@@ -455,7 +480,7 @@ pub fn tranches_to_approve(
 				drifted_tick_now,
 			);
 
-			let s = s.advance(n_assignments, no_shows, next_no_show, last_assignment_tick);
+			let s = s.advance(n_assignments, no_shows, next_no_show, last_assignment_tick, no_show_validators);
 			let output = s.output(tranche, needed_approvals, n_validators, no_show_duration);
 
 			*state = match output.required_tranches {
@@ -482,9 +507,9 @@ pub fn tranches_to_approve(
 mod tests {
 	use super::*;
 	use crate::{approval_db, BTreeMap};
-	use ::test_helpers::{dummy_candidate_receipt, dummy_hash};
 	use bitvec::{bitvec, order::Lsb0 as BitOrderLsb0, vec::BitVec};
 	use polkadot_primitives::GroupIndex;
+	use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash};
 
 	#[test]
 	fn pending_is_not_approved() {
@@ -1186,7 +1211,7 @@ mod tests {
 			approvals.set(v_index, true);
 		}
 
-		let (no_shows, next_no_show) = count_no_shows(
+		let (no_shows, next_no_show, _) = count_no_shows(
 			&test.assignments,
 			&approvals,
 			test.clock_drift,
@@ -1390,6 +1415,7 @@ mod tests {
 			next_no_show: None,
 			last_assignment_tick: None,
 			total_observed_no_shows: 0,
+			no_show_validators: Default::default(),
 		};
 
 		assert_eq!(
@@ -1414,6 +1440,7 @@ mod tests {
 			next_no_show: None,
 			last_assignment_tick: None,
 			total_observed_no_shows: 0,
+			no_show_validators: Default::default(),
 		};
 
 		assert_eq!(
diff --git a/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs
index 249dcf912df50530e87f732edf2848664df1136e..11266f0b99d83ac4dcdb5e24251bbd1a5c5ee081 100644
--- a/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs
+++ b/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs
@@ -17,7 +17,7 @@
 //! Common helper functions for all versions of approval-voting database.
 use std::sync::Arc;
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_subsystem::{SubsystemError, SubsystemResult};
 use polkadot_node_subsystem_util::database::{DBTransaction, Database};
 use polkadot_primitives::{BlockNumber, CandidateHash, CandidateIndex, Hash};
@@ -64,7 +64,7 @@ impl DbBackend {
 #[derive(Debug, derive_more::From, derive_more::Display)]
 pub enum Error {
 	Io(std::io::Error),
-	InvalidDecoding(parity_scale_codec::Error),
+	InvalidDecoding(codec::Error),
 	InternalError(SubsystemError),
 }
 
diff --git a/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs
index 011d0a559c022d2294acf0cdcc22364bc301a8dd..53e9db64f63641ba7a816a75609b771fc594afb6 100644
--- a/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs
+++ b/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs
@@ -22,7 +22,7 @@
 //! its data in the database. Any breaking changes here will still
 //! require a db migration (check `node/service/src/parachains_db/upgrade.rs`).
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_primitives::approval::v1::{AssignmentCert, DelayTranche};
 use polkadot_primitives::{
 	BlockNumber, CandidateHash, CandidateReceipt, CoreIndex, GroupIndex, Hash, SessionIndex,
diff --git a/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs b/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs
index b0966ad01f7bff8242e3255968b3e85b4d0239ca..4c08d22f3ca2d4f91a27e2b319d8859100f0ec55 100644
--- a/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs
+++ b/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs
@@ -25,7 +25,9 @@ use polkadot_node_subsystem_util::database::Database;
 use polkadot_primitives::Id as ParaId;
 use std::{collections::HashMap, sync::Arc};
 
-use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash};
+use polkadot_primitives_test_helpers::{
+	dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash,
+};
 
 const DATA_COL: u32 = 0;
 
diff --git a/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs
index da42fc5be485caabdd8f8428bdf15c9bf6eb08e9..cd9256a5d47eda0da75b3ca0238fbdd2060d1294 100644
--- a/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs
+++ b/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs
@@ -16,7 +16,7 @@
 
 //! Version 2 of the DB schema.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_primitives::approval::{v1::DelayTranche, v2::AssignmentCertV2};
 use polkadot_node_subsystem::{SubsystemError, SubsystemResult};
 use polkadot_node_subsystem_util::database::{DBTransaction, Database};
diff --git a/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs b/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs
index 5fa915add4166fa1f042dadaae063aaa83941b92..06a3cc1e306b643b18dff67d11baca79ca378848 100644
--- a/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs
+++ b/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs
@@ -34,7 +34,9 @@ use polkadot_primitives::Id as ParaId;
 use sp_consensus_slots::Slot;
 use std::{collections::HashMap, sync::Arc};
 
-use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash};
+use polkadot_primitives_test_helpers::{
+	dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash,
+};
 
 const DATA_COL: u32 = 0;
 
diff --git a/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs
index 3e4f4302195256205905d3f931039cbf9631824c..7118fb6770fd79d80454524bd33abb2ba3d8f2ce 100644
--- a/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs
+++ b/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs
@@ -19,7 +19,7 @@
 //! Version 3 modifies the `our_approval` format of `ApprovalEntry`
 //! and adds a new field `pending_signatures` for `BlockEntry`
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_primitives::approval::v2::CandidateBitfield;
 use polkadot_node_subsystem::SubsystemResult;
 use polkadot_node_subsystem_util::database::{DBTransaction, Database};
diff --git a/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs b/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs
index 7c0cf9d4f7daaccd1887a03a2a06e9bb4e6b587e..d2a1d7d400b1495688865c0a0d30b04e44d14e20 100644
--- a/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs
+++ b/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs
@@ -33,7 +33,9 @@ use polkadot_primitives::Id as ParaId;
 use sp_consensus_slots::Slot;
 use std::{collections::HashMap, sync::Arc};
 
-use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash};
+use polkadot_primitives_test_helpers::{
+	dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash,
+};
 
 const DATA_COL: u32 = 0;
 
diff --git a/polkadot/node/core/approval-voting/src/criteria.rs b/polkadot/node/core/approval-voting/src/criteria.rs
index 57c0ac272dc5a5cad8b9c69831faa5ecfc778033..fb9d281e43bc3d0ed866ed0c2114ee64345fbdc9 100644
--- a/polkadot/node/core/approval-voting/src/criteria.rs
+++ b/polkadot/node/core/approval-voting/src/criteria.rs
@@ -16,8 +16,8 @@
 
 //! Assignment criteria VRF generation and checking.
 
+use codec::{Decode, Encode};
 use itertools::Itertools;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_node_primitives::approval::{
 	self as approval_types,
 	v1::{AssignmentCert, AssignmentCertKind, DelayTranche, RelayVRFStory},
diff --git a/polkadot/node/core/approval-voting/src/import.rs b/polkadot/node/core/approval-voting/src/import.rs
index f4be42a4845080ce90fb87ddc838e2c1ab792ed1..3ddef1e01c45b99ce797d64b78f2e2c88993471f 100644
--- a/polkadot/node/core/approval-voting/src/import.rs
+++ b/polkadot/node/core/approval-voting/src/import.rs
@@ -607,9 +607,8 @@ pub(crate) mod tests {
 	use super::*;
 	use crate::{
 		approval_db::common::{load_block_entry, DbBackend},
-		RuntimeInfo, RuntimeInfoConfig,
+		RuntimeInfo, RuntimeInfoConfig, MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS,
 	};
-	use ::test_helpers::{dummy_candidate_receipt, dummy_hash};
 	use assert_matches::assert_matches;
 	use polkadot_node_primitives::{
 		approval::v1::{VrfSignature, VrfTranscript},
@@ -622,6 +621,8 @@ pub(crate) mod tests {
 		node_features::FeatureIndex, ExecutorParams, Id as ParaId, IndexedVec, NodeFeatures,
 		SessionInfo, ValidatorId, ValidatorIndex,
 	};
+	use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash};
+	use schnellru::{ByLength, LruMap};
 	pub(crate) use sp_consensus_babe::{
 		digests::{CompatibleDigestItem, PreDigest, SecondaryVRFPreDigest},
 		AllowedSlots, BabeEpochConfiguration, Epoch as BabeEpoch,
@@ -658,6 +659,10 @@ pub(crate) mod tests {
 			clock: Box::new(MockClock::default()),
 			assignment_criteria: Box::new(MockAssignmentCriteria::default()),
 			spans: HashMap::new(),
+			per_block_assignments_gathering_times: LruMap::new(ByLength::new(
+				MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS,
+			)),
+			no_show_stats: Default::default(),
 		}
 	}
 
diff --git a/polkadot/node/core/approval-voting/src/lib.rs b/polkadot/node/core/approval-voting/src/lib.rs
index b5ed92fa39c873c0a1e5f40c52705a5803971b60..d4b6855a44d0e410bbec757cae25eb7bd4803acb 100644
--- a/polkadot/node/core/approval-voting/src/lib.rs
+++ b/polkadot/node/core/approval-voting/src/lib.rs
@@ -63,6 +63,12 @@ use sc_keystore::LocalKeystore;
 use sp_application_crypto::Pair;
 use sp_consensus::SyncOracle;
 use sp_consensus_slots::Slot;
+use std::time::Instant;
+
+// The max number of blocks we keep track of assignments gathering times. Normally,
+// this would never be reached because we prune the data on finalization, but we need
+// to also ensure the data is not growing unecessarily large.
+const MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS: u32 = 100;
 
 use futures::{
 	channel::oneshot,
@@ -182,6 +188,14 @@ struct MetricsInner {
 	time_recover_and_approve: prometheus::Histogram,
 	candidate_signatures_requests_total: prometheus::Counter<prometheus::U64>,
 	unapproved_candidates_in_unfinalized_chain: prometheus::Gauge<prometheus::U64>,
+	// The time it takes in each stage to gather enough assignments.
+	// We defined a `stage` as being the entire process of gathering enough assignments to
+	// be able to approve a candidate:
+	// E.g:
+	// - Stage 0: We wait for the needed_approvals assignments to be gathered.
+	// - Stage 1: We wait for enough tranches to cover all no-shows in stage 0.
+	// - Stage 2: We wait for enough tranches to cover all no-shows  of stage 1.
+	assignments_gathering_time_by_stage: prometheus::HistogramVec,
 }
 
 /// Approval Voting metrics.
@@ -302,6 +316,20 @@ impl Metrics {
 			metrics.unapproved_candidates_in_unfinalized_chain.set(count as u64);
 		}
 	}
+
+	pub fn observe_assignment_gathering_time(&self, stage: usize, elapsed_as_millis: usize) {
+		if let Some(metrics) = &self.0 {
+			let stage_string = stage.to_string();
+			// We don't want to have too many metrics entries with this label to not put unncessary
+			// pressure on the metrics infrastructure, so we cap the stage at 10, which is
+			// equivalent to having already a finalization lag to 10 * no_show_slots, so it should
+			// be more than enough.
+			metrics
+				.assignments_gathering_time_by_stage
+				.with_label_values(&[if stage < 10 { stage_string.as_str() } else { "inf" }])
+				.observe(elapsed_as_millis as f64);
+		}
+	}
 }
 
 impl metrics::Metrics for Metrics {
@@ -431,6 +459,17 @@ impl metrics::Metrics for Metrics {
 				)?,
 				registry,
 			)?,
+			assignments_gathering_time_by_stage: prometheus::register(
+				prometheus::HistogramVec::new(
+					prometheus::HistogramOpts::new(
+						"polkadot_parachain_assignments_gather_time_by_stage_ms",
+						"The time in ms it takes for each stage to gather enough assignments needed for approval",
+					)
+					.buckets(vec![0.0, 250.0, 500.0, 1000.0, 2000.0, 4000.0, 8000.0, 16000.0, 32000.0]),
+					&["stage"],
+				)?,
+				registry,
+			)?,
 		};
 
 		Ok(Metrics(Some(metrics)))
@@ -652,6 +691,7 @@ struct ApprovalStatus {
 	tranche_now: DelayTranche,
 	block_tick: Tick,
 	last_no_shows: usize,
+	no_show_validators: Vec<ValidatorIndex>,
 }
 
 #[derive(Copy, Clone)]
@@ -788,6 +828,73 @@ struct State {
 	clock: Box<dyn Clock + Send + Sync>,
 	assignment_criteria: Box<dyn AssignmentCriteria + Send + Sync>,
 	spans: HashMap<Hash, jaeger::PerLeafSpan>,
+	// Per block, candidate records about how long we take until we gather enough
+	// assignments, this is relevant because it gives us a good idea about how many
+	// tranches we trigger and why.
+	per_block_assignments_gathering_times:
+		LruMap<BlockNumber, HashMap<(Hash, CandidateHash), AssignmentGatheringRecord>>,
+	no_show_stats: NoShowStats,
+}
+
+// Regularly dump the no-show stats at this block number frequency.
+const NO_SHOW_DUMP_FREQUENCY: BlockNumber = 50;
+// The maximum number of validators we record no-shows for, per candidate.
+pub(crate) const MAX_RECORDED_NO_SHOW_VALIDATORS_PER_CANDIDATE: usize = 20;
+
+// No show stats per validator and per parachain.
+// This is valuable information when we have to debug live network issue, because
+// it gives information if things are going wrong only for some validators or just
+// for some parachains.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+struct NoShowStats {
+	per_validator_no_show: HashMap<SessionIndex, HashMap<ValidatorIndex, usize>>,
+	per_parachain_no_show: HashMap<u32, usize>,
+	last_dumped_block_number: BlockNumber,
+}
+
+impl NoShowStats {
+	// Print the no-show stats if NO_SHOW_DUMP_FREQUENCY blocks have passed since the last
+	// print.
+	fn maybe_print(&mut self, current_block_number: BlockNumber) {
+		if self.last_dumped_block_number > current_block_number ||
+			current_block_number - self.last_dumped_block_number < NO_SHOW_DUMP_FREQUENCY
+		{
+			return
+		}
+		if self.per_parachain_no_show.is_empty() && self.per_validator_no_show.is_empty() {
+			return
+		}
+
+		gum::debug!(
+			target: LOG_TARGET,
+			"Validators with no_show {:?} and parachains with no_shows {:?} since {:}",
+			self.per_validator_no_show,
+			self.per_parachain_no_show,
+			self.last_dumped_block_number
+		);
+
+		self.last_dumped_block_number = current_block_number;
+
+		self.per_validator_no_show.clear();
+		self.per_parachain_no_show.clear();
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct AssignmentGatheringRecord {
+	// The stage we are in.
+	// Candidate assignment gathering goes in stages, first we wait for needed_approvals(stage 0)
+	// Then if we have no-shows, we move into stage 1 and wait for enough tranches to cover all
+	// no-shows.
+	stage: usize,
+	// The time we started the stage.
+	stage_start: Option<Instant>,
+}
+
+impl Default for AssignmentGatheringRecord {
+	fn default() -> Self {
+		AssignmentGatheringRecord { stage: 0, stage_start: Some(Instant::now()) }
+	}
 }
 
 #[overseer::contextbounds(ApprovalVoting, prefix = self::overseer)]
@@ -826,21 +933,25 @@ impl State {
 		);
 
 		if let Some(approval_entry) = candidate_entry.approval_entry(&block_hash) {
-			let TranchesToApproveResult { required_tranches, total_observed_no_shows } =
-				approval_checking::tranches_to_approve(
-					approval_entry,
-					candidate_entry.approvals(),
-					tranche_now,
-					block_tick,
-					no_show_duration,
-					session_info.needed_approvals as _,
-				);
+			let TranchesToApproveResult {
+				required_tranches,
+				total_observed_no_shows,
+				no_show_validators,
+			} = approval_checking::tranches_to_approve(
+				approval_entry,
+				candidate_entry.approvals(),
+				tranche_now,
+				block_tick,
+				no_show_duration,
+				session_info.needed_approvals as _,
+			);
 
 			let status = ApprovalStatus {
 				required_tranches,
 				block_tick,
 				tranche_now,
 				last_no_shows: total_observed_no_shows,
+				no_show_validators,
 			};
 
 			Some((approval_entry, status))
@@ -893,6 +1004,116 @@ impl State {
 			},
 		}
 	}
+
+	fn mark_begining_of_gathering_assignments(
+		&mut self,
+		block_number: BlockNumber,
+		block_hash: Hash,
+		candidate: CandidateHash,
+	) {
+		if let Some(record) = self
+			.per_block_assignments_gathering_times
+			.get_or_insert(block_number, HashMap::new)
+			.and_then(|records| Some(records.entry((block_hash, candidate)).or_default()))
+		{
+			if record.stage_start.is_none() {
+				record.stage += 1;
+				gum::debug!(
+					target: LOG_TARGET,
+					stage = ?record.stage,
+					?block_hash,
+					?candidate,
+					"Started a new assignment gathering stage",
+				);
+				record.stage_start = Some(Instant::now());
+			}
+		}
+	}
+
+	fn mark_gathered_enough_assignments(
+		&mut self,
+		block_number: BlockNumber,
+		block_hash: Hash,
+		candidate: CandidateHash,
+	) -> AssignmentGatheringRecord {
+		let record = self
+			.per_block_assignments_gathering_times
+			.get(&block_number)
+			.and_then(|entry| entry.get_mut(&(block_hash, candidate)));
+		let stage = record.as_ref().map(|record| record.stage).unwrap_or_default();
+		AssignmentGatheringRecord {
+			stage,
+			stage_start: record.and_then(|record| record.stage_start.take()),
+		}
+	}
+
+	fn cleanup_assignments_gathering_timestamp(&mut self, remove_lower_than: BlockNumber) {
+		while let Some((block_number, _)) = self.per_block_assignments_gathering_times.peek_oldest()
+		{
+			if *block_number < remove_lower_than {
+				self.per_block_assignments_gathering_times.pop_oldest();
+			} else {
+				break
+			}
+		}
+	}
+
+	fn observe_assignment_gathering_status(
+		&mut self,
+		metrics: &Metrics,
+		required_tranches: &RequiredTranches,
+		block_hash: Hash,
+		block_number: BlockNumber,
+		candidate_hash: CandidateHash,
+	) {
+		match required_tranches {
+			RequiredTranches::All | RequiredTranches::Pending { .. } => {
+				self.mark_begining_of_gathering_assignments(
+					block_number,
+					block_hash,
+					candidate_hash,
+				);
+			},
+			RequiredTranches::Exact { .. } => {
+				let time_to_gather =
+					self.mark_gathered_enough_assignments(block_number, block_hash, candidate_hash);
+				if let Some(gathering_started) = time_to_gather.stage_start {
+					if gathering_started.elapsed().as_millis() > 6000 {
+						gum::trace!(
+							target: LOG_TARGET,
+							?block_hash,
+							?candidate_hash,
+							"Long assignment gathering time",
+						);
+					}
+					metrics.observe_assignment_gathering_time(
+						time_to_gather.stage,
+						gathering_started.elapsed().as_millis() as usize,
+					)
+				}
+			},
+		}
+	}
+
+	fn record_no_shows(
+		&mut self,
+		session_index: SessionIndex,
+		para_id: u32,
+		no_show_validators: &Vec<ValidatorIndex>,
+	) {
+		if !no_show_validators.is_empty() {
+			*self.no_show_stats.per_parachain_no_show.entry(para_id.into()).or_default() += 1;
+		}
+		for validator_index in no_show_validators {
+			*self
+				.no_show_stats
+				.per_validator_no_show
+				.entry(session_index)
+				.or_default()
+				.entry(*validator_index)
+				.or_default() += 1;
+		}
+	}
 }
 
 #[derive(Debug, Clone)]
@@ -914,6 +1135,7 @@ enum Action {
 		candidate: CandidateReceipt,
 		backing_group: GroupIndex,
 		distribute_assignment: bool,
+		core_index: Option<CoreIndex>,
 	},
 	NoteApprovedInChainSelection(Hash),
 	IssueApproval(CandidateHash, ApprovalVoteRequest),
@@ -941,6 +1163,10 @@ where
 		clock: subsystem.clock,
 		assignment_criteria,
 		spans: HashMap::new(),
+		per_block_assignments_gathering_times: LruMap::new(ByLength::new(
+			MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS,
+		)),
+		no_show_stats: NoShowStats::default(),
 	};
 
 	// `None` on start-up. Gets initialized/updated on leaf update
@@ -972,7 +1198,7 @@ where
 				subsystem.metrics.on_wakeup();
 				process_wakeup(
 					&mut ctx,
-					&state,
+					&mut state,
 					&mut overlayed_db,
 					&mut session_info_provider,
 					woken_block,
@@ -1174,6 +1400,7 @@ async fn handle_actions<Context>(
 				candidate,
 				backing_group,
 				distribute_assignment,
+				core_index,
 			} => {
 				// Don't launch approval work if the node is syncing.
 				if let Mode::Syncing(_) = *mode {
@@ -1230,6 +1457,7 @@ async fn handle_actions<Context>(
 										block_hash,
 										backing_group,
 										executor_params,
+										core_index,
 										&launch_approval_span,
 									)
 									.await
@@ -1467,6 +1695,7 @@ async fn distribution_messages_for_activation<Context>(
 											candidate: candidate_entry.candidate_receipt().clone(),
 											backing_group: approval_entry.backing_group(),
 											distribute_assignment: false,
+											core_index: Some(*core_index),
 										});
 									}
 								},
@@ -1582,6 +1811,8 @@ async fn handle_from_overseer<Context>(
 								"Imported new block.",
 							);
 
+							state.no_show_stats.maybe_print(block_batch.block_number);
+
 							for (c_hash, c_entry) in block_batch.imported_candidates {
 								metrics.on_candidate_imported();
 
@@ -1628,6 +1859,7 @@ async fn handle_from_overseer<Context>(
 			// `prune_finalized_wakeups` prunes all finalized block hashes. We prune spans
 			// accordingly.
 			wakeups.prune_finalized_wakeups(block_number, &mut state.spans);
+			state.cleanup_assignments_gathering_timestamp(block_number);
 
 			// // `prune_finalized_wakeups` prunes all finalized block hashes. We prune spans
 			// accordingly. let hash_set =
@@ -2474,7 +2706,7 @@ where
 
 async fn check_and_import_approval<T, Sender>(
 	sender: &mut Sender,
-	state: &State,
+	state: &mut State,
 	db: &mut OverlayedBackend<'_, impl Backend>,
 	session_info_provider: &mut RuntimeInfo,
 	metrics: &Metrics,
@@ -2706,7 +2938,7 @@ impl ApprovalStateTransition {
 // as necessary and schedules any further wakeups.
 async fn advance_approval_state<Sender>(
 	sender: &mut Sender,
-	state: &State,
+	state: &mut State,
 	db: &mut OverlayedBackend<'_, impl Backend>,
 	session_info_provider: &mut RuntimeInfo,
 	metrics: &Metrics,
@@ -2745,7 +2977,8 @@ where
 	let mut actions = Vec::new();
 	let block_hash = block_entry.block_hash();
 	let block_number = block_entry.block_number();
-
+	let session_index = block_entry.session();
+	let para_id = candidate_entry.candidate_receipt().descriptor().para_id;
 	let tick_now = state.clock.tick_now();
 
 	let (is_approved, status) = if let Some((approval_entry, status)) = state
@@ -2757,6 +2990,13 @@ where
 			approval_entry,
 			status.required_tranches.clone(),
 		);
+		state.observe_assignment_gathering_status(
+			&metrics,
+			&status.required_tranches,
+			block_hash,
+			block_entry.block_number(),
+			candidate_hash,
+		);
 
 		// Check whether this is approved, while allowing a maximum
 		// assignment tick of `now - APPROVAL_DELAY` - that is, that
@@ -2834,7 +3074,9 @@ where
 		if is_approved {
 			approval_entry.mark_approved();
 		}
-
+		if newly_approved {
+			state.record_no_shows(session_index, para_id.into(), &status.no_show_validators);
+		}
 		actions.extend(schedule_wakeup_action(
 			&approval_entry,
 			block_hash,
@@ -2937,7 +3179,7 @@ fn should_trigger_assignment(
 #[overseer::contextbounds(ApprovalVoting, prefix = self::overseer)]
 async fn process_wakeup<Context>(
 	ctx: &mut Context,
-	state: &State,
+	state: &mut State,
 	db: &mut OverlayedBackend<'_, impl Backend>,
 	session_info_provider: &mut RuntimeInfo,
 	relay_block: Hash,
@@ -3050,6 +3292,11 @@ async fn process_wakeup<Context>(
 			"Launching approval work.",
 		);
 
+		let candidate_core_index = block_entry
+			.candidates()
+			.iter()
+			.find_map(|(core_index, h)| (h == &candidate_hash).then_some(*core_index));
+
 		if let Some(claimed_core_indices) =
 			get_assignment_core_indices(&indirect_cert.cert.kind, &candidate_hash, &block_entry)
 		{
@@ -3062,7 +3309,6 @@ async fn process_wakeup<Context>(
 						true
 					};
 					db.write_block_entry(block_entry.clone());
-
 					actions.push(Action::LaunchApproval {
 						claimed_candidate_indices,
 						candidate_hash,
@@ -3074,10 +3320,12 @@ async fn process_wakeup<Context>(
 						candidate: candidate_receipt,
 						backing_group,
 						distribute_assignment,
+						core_index: candidate_core_index,
 					});
 				},
 				Err(err) => {
-					// Never happens, it should only happen if no cores are claimed, which is a bug.
+					// Never happens, it should only happen if no cores are claimed, which is a
+					// bug.
 					gum::warn!(
 						target: LOG_TARGET,
 						block_hash = ?relay_block,
@@ -3133,6 +3381,7 @@ async fn launch_approval<Context>(
 	block_hash: Hash,
 	backing_group: GroupIndex,
 	executor_params: ExecutorParams,
+	core_index: Option<CoreIndex>,
 	span: &jaeger::Span,
 ) -> SubsystemResult<RemoteHandle<ApprovalState>> {
 	let (a_tx, a_rx) = oneshot::channel();
@@ -3179,6 +3428,7 @@ async fn launch_approval<Context>(
 		candidate.clone(),
 		session_index,
 		Some(backing_group),
+		core_index,
 		a_tx,
 	))
 	.await;
diff --git a/polkadot/node/core/approval-voting/src/tests.rs b/polkadot/node/core/approval-voting/src/tests.rs
index 312d805bbefb7b2b2605093fa2cadde0a1f10511..64ae86bc013a5714868e2abcdd228f1f2b456af9 100644
--- a/polkadot/node/core/approval-voting/src/tests.rs
+++ b/polkadot/node/core/approval-voting/src/tests.rs
@@ -17,6 +17,10 @@
 use self::test_helpers::mock::new_leaf;
 use super::*;
 use crate::backend::V1ReadBackend;
+use overseer::prometheus::{
+	prometheus::{IntCounter, IntCounterVec},
+	Histogram, HistogramOpts, HistogramVec, Opts,
+};
 use polkadot_node_primitives::{
 	approval::{
 		v1::{
@@ -40,7 +44,7 @@ use polkadot_primitives::{
 	ApprovalVote, CandidateCommitments, CandidateEvent, CoreIndex, GroupIndex, Header,
 	Id as ParaId, IndexedVec, NodeFeatures, ValidationCode, ValidatorSignature,
 };
-use std::time::Duration;
+use std::{cmp::max, time::Duration};
 
 use assert_matches::assert_matches;
 use async_trait::async_trait;
@@ -64,7 +68,7 @@ use super::{
 	},
 };
 
-use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig};
+use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig};
 
 const SLOT_DURATION_MILLIS: u64 = 5000;
 
@@ -459,7 +463,8 @@ fn sign_approval_multiple_candidates(
 		.into()
 }
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<ApprovalVotingMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<ApprovalVotingMessage>;
 
 #[derive(Default)]
 struct HarnessConfigBuilder {
@@ -548,7 +553,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 		config;
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool);
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool);
 
 	let keystore = LocalKeystore::in_memory();
 	let _ = keystore.sr25519_generate_new(
@@ -3330,7 +3336,7 @@ async fn recover_available_data(virtual_overseer: &mut VirtualOverseer) {
 	assert_matches!(
 		virtual_overseer.recv().await,
 		AllMessages::AvailabilityRecovery(
-			AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx)
+			AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx)
 		) => {
 			tx.send(Ok(available_data)).unwrap();
 		},
@@ -5049,3 +5055,235 @@ fn subsystem_sends_pending_approvals_on_approval_restart() {
 		virtual_overseer
 	});
 }
+
+// Test we correctly update the timer when we mark the beginning of gathering assignments.
+#[test]
+fn test_gathering_assignments_statements() {
+	let mut state = State {
+		keystore: Arc::new(LocalKeystore::in_memory()),
+		slot_duration_millis: 6_000,
+		clock: Box::new(MockClock::default()),
+		assignment_criteria: Box::new(MockAssignmentCriteria::check_only(|_| Ok(0))),
+		spans: HashMap::new(),
+		per_block_assignments_gathering_times: LruMap::new(ByLength::new(
+			MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS,
+		)),
+		no_show_stats: NoShowStats::default(),
+	};
+
+	for i in 0..200i32 {
+		state.mark_begining_of_gathering_assignments(
+			i as u32,
+			Hash::repeat_byte(i as u8),
+			CandidateHash(Hash::repeat_byte(i as u8)),
+		);
+		assert!(
+			state.per_block_assignments_gathering_times.len() <=
+				MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS as usize
+		);
+
+		assert_eq!(
+			state
+				.per_block_assignments_gathering_times
+				.iter()
+				.map(|(block_number, _)| block_number)
+				.min(),
+			Some(max(0, i - MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS as i32 + 1) as u32).as_ref()
+		)
+	}
+	assert_eq!(
+		state.per_block_assignments_gathering_times.len(),
+		MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS as usize
+	);
+
+	let nothing_changes = state
+		.per_block_assignments_gathering_times
+		.iter()
+		.map(|(block_number, _)| *block_number)
+		.sorted()
+		.collect::<Vec<_>>();
+
+	for i in 150..200i32 {
+		state.mark_begining_of_gathering_assignments(
+			i as u32,
+			Hash::repeat_byte(i as u8),
+			CandidateHash(Hash::repeat_byte(i as u8)),
+		);
+		assert_eq!(
+			nothing_changes,
+			state
+				.per_block_assignments_gathering_times
+				.iter()
+				.map(|(block_number, _)| *block_number)
+				.sorted()
+				.collect::<Vec<_>>()
+		);
+	}
+
+	for i in 110..120 {
+		let block_hash = Hash::repeat_byte(i as u8);
+		let candidate_hash = CandidateHash(Hash::repeat_byte(i as u8));
+
+		state.mark_gathered_enough_assignments(i as u32, block_hash, candidate_hash);
+
+		assert!(state
+			.per_block_assignments_gathering_times
+			.get(&i)
+			.unwrap()
+			.get(&(block_hash, candidate_hash))
+			.unwrap()
+			.stage_start
+			.is_none());
+		state.mark_begining_of_gathering_assignments(i as u32, block_hash, candidate_hash);
+		let record = state
+			.per_block_assignments_gathering_times
+			.get(&i)
+			.unwrap()
+			.get(&(block_hash, candidate_hash))
+			.unwrap();
+
+		assert!(record.stage_start.is_some());
+		assert_eq!(record.stage, 1);
+	}
+
+	state.cleanup_assignments_gathering_timestamp(200);
+	assert_eq!(state.per_block_assignments_gathering_times.len(), 0);
+}
+
+// Test we note the time we took to transition RequiredTranche  from Pending to Exact and
+// that we increase the stage when we transition from Exact to Pending.
+#[test]
+fn test_observe_assignment_gathering_status() {
+	let mut state = State {
+		keystore: Arc::new(LocalKeystore::in_memory()),
+		slot_duration_millis: 6_000,
+		clock: Box::new(MockClock::default()),
+		assignment_criteria: Box::new(MockAssignmentCriteria::check_only(|_| Ok(0))),
+		spans: HashMap::new(),
+		per_block_assignments_gathering_times: LruMap::new(ByLength::new(
+			MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS,
+		)),
+		no_show_stats: NoShowStats::default(),
+	};
+
+	let metrics_inner = MetricsInner {
+		imported_candidates_total: IntCounter::new("dummy", "dummy").unwrap(),
+		assignments_produced: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")).unwrap(),
+		approvals_produced_total: IntCounterVec::new(Opts::new("dummy", "dummy"), &["dummy"])
+			.unwrap(),
+		no_shows_total: IntCounter::new("dummy", "dummy").unwrap(),
+		observed_no_shows: IntCounter::new("dummy", "dummy").unwrap(),
+		approved_by_one_third: IntCounter::new("dummy", "dummy").unwrap(),
+		wakeups_triggered_total: IntCounter::new("dummy", "dummy").unwrap(),
+		coalesced_approvals_buckets: Histogram::with_opts(HistogramOpts::new("dummy", "dummy"))
+			.unwrap(),
+		coalesced_approvals_delay: Histogram::with_opts(HistogramOpts::new("dummy", "dummy"))
+			.unwrap(),
+		candidate_approval_time_ticks: Histogram::with_opts(HistogramOpts::new("dummy", "dummy"))
+			.unwrap(),
+		block_approval_time_ticks: Histogram::with_opts(HistogramOpts::new("dummy", "dummy"))
+			.unwrap(),
+		time_db_transaction: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")).unwrap(),
+		time_recover_and_approve: Histogram::with_opts(HistogramOpts::new("dummy", "dummy"))
+			.unwrap(),
+		candidate_signatures_requests_total: IntCounter::new("dummy", "dummy").unwrap(),
+		unapproved_candidates_in_unfinalized_chain: prometheus::Gauge::<prometheus::U64>::new(
+			"dummy", "dummy",
+		)
+		.unwrap(),
+		assignments_gathering_time_by_stage: HistogramVec::new(
+			HistogramOpts::new("test", "test"),
+			&["stage"],
+		)
+		.unwrap(),
+	};
+
+	let metrics = Metrics(Some(metrics_inner));
+	let block_hash = Hash::repeat_byte(1);
+	let candidate_hash = CandidateHash(Hash::repeat_byte(1));
+	let block_number = 1;
+
+	// Transition from Pending to Exact and check stage 0 time is recorded.
+	state.observe_assignment_gathering_status(
+		&metrics,
+		&RequiredTranches::Pending {
+			considered: 0,
+			next_no_show: None,
+			maximum_broadcast: 0,
+			clock_drift: 0,
+		},
+		block_hash,
+		block_number,
+		candidate_hash,
+	);
+
+	state.observe_assignment_gathering_status(
+		&metrics,
+		&RequiredTranches::Exact {
+			needed: 2,
+			tolerated_missing: 2,
+			next_no_show: None,
+			last_assignment_tick: None,
+		},
+		block_hash,
+		block_number,
+		candidate_hash,
+	);
+
+	let value = metrics
+		.0
+		.as_ref()
+		.unwrap()
+		.assignments_gathering_time_by_stage
+		.get_metric_with_label_values(&["0"])
+		.unwrap();
+
+	assert_eq!(value.get_sample_count(), 1);
+
+	// Transition from Exact to Pending to Exact and check stage 1 time is recorded.
+	state.observe_assignment_gathering_status(
+		&metrics,
+		&RequiredTranches::Pending {
+			considered: 0,
+			next_no_show: None,
+			maximum_broadcast: 0,
+			clock_drift: 0,
+		},
+		block_hash,
+		block_number,
+		candidate_hash,
+	);
+
+	state.observe_assignment_gathering_status(
+		&metrics,
+		&RequiredTranches::Exact {
+			needed: 2,
+			tolerated_missing: 2,
+			next_no_show: None,
+			last_assignment_tick: None,
+		},
+		block_hash,
+		block_number,
+		candidate_hash,
+	);
+
+	let value = metrics
+		.0
+		.as_ref()
+		.unwrap()
+		.assignments_gathering_time_by_stage
+		.get_metric_with_label_values(&["0"])
+		.unwrap();
+
+	assert_eq!(value.get_sample_count(), 1);
+
+	let value = metrics
+		.0
+		.as_ref()
+		.unwrap()
+		.assignments_gathering_time_by_stage
+		.get_metric_with_label_values(&["1"])
+		.unwrap();
+
+	assert_eq!(value.get_sample_count(), 1);
+}
diff --git a/polkadot/node/core/av-store/Cargo.toml b/polkadot/node/core/av-store/Cargo.toml
index c5b3c382011b12ac80e130500d7c64b481989331..62f7ff0b61e64de81fa6b3c34987df042a865cbb 100644
--- a/polkadot/node/core/av-store/Cargo.toml
+++ b/polkadot/node/core/av-store/Cargo.toml
@@ -17,8 +17,8 @@ thiserror = { workspace = true }
 gum = { package = "tracing-gum", path = "../../gum" }
 bitvec = "1.0.0"
 
-parity-scale-codec = { version = "3.6.12", features = ["derive"] }
-erasure = { package = "polkadot-erasure-coding", path = "../../../erasure-coding" }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["derive"] }
+polkadot-erasure-coding = { path = "../../../erasure-coding" }
 polkadot-node-subsystem = { path = "../../subsystem" }
 polkadot-node-subsystem-util = { path = "../../subsystem-util" }
 polkadot-overseer = { path = "../../overseer" }
@@ -38,4 +38,4 @@ polkadot-node-subsystem-util = { path = "../../subsystem-util" }
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
 sp-keyring = { path = "../../../../substrate/primitives/keyring" }
 parking_lot = "0.12.1"
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
diff --git a/polkadot/node/core/av-store/src/lib.rs b/polkadot/node/core/av-store/src/lib.rs
index 68db4686a9740bb052f7d05031d148cd5b05e0a2..7b245c9e3c52f88d39ebe7d8252f1db128edcaca 100644
--- a/polkadot/node/core/av-store/src/lib.rs
+++ b/polkadot/node/core/av-store/src/lib.rs
@@ -26,6 +26,7 @@ use std::{
 	time::{Duration, SystemTime, SystemTimeError, UNIX_EPOCH},
 };
 
+use codec::{Decode, Encode, Error as CodecError, Input};
 use futures::{
 	channel::{
 		mpsc::{channel, Receiver as MpscReceiver, Sender as MpscSender},
@@ -34,7 +35,6 @@ use futures::{
 	future, select, FutureExt, SinkExt, StreamExt,
 };
 use futures_timer::Delay;
-use parity_scale_codec::{Decode, Encode, Error as CodecError, Input};
 use polkadot_node_subsystem_util::database::{DBTransaction, Database};
 use sp_consensus::SyncOracle;
 
@@ -48,8 +48,10 @@ use polkadot_node_subsystem::{
 };
 use polkadot_node_subsystem_util as util;
 use polkadot_primitives::{
-	BlockNumber, CandidateEvent, CandidateHash, CandidateReceipt, Hash, Header, ValidatorIndex,
+	BlockNumber, CandidateEvent, CandidateHash, CandidateReceipt, ChunkIndex, CoreIndex, Hash,
+	Header, NodeFeatures, ValidatorIndex,
 };
+use util::availability_chunks::availability_chunk_indices;
 
 mod metrics;
 pub use self::metrics::*;
@@ -208,9 +210,9 @@ fn load_chunk(
 	db: &Arc<dyn Database>,
 	config: &Config,
 	candidate_hash: &CandidateHash,
-	chunk_index: ValidatorIndex,
+	validator_index: ValidatorIndex,
 ) -> Result<Option<ErasureChunk>, Error> {
-	let key = (CHUNK_PREFIX, candidate_hash, chunk_index).encode();
+	let key = (CHUNK_PREFIX, candidate_hash, validator_index).encode();
 
 	query_inner(db, config.col_data, &key)
 }
@@ -219,10 +221,10 @@ fn write_chunk(
 	tx: &mut DBTransaction,
 	config: &Config,
 	candidate_hash: &CandidateHash,
-	chunk_index: ValidatorIndex,
+	validator_index: ValidatorIndex,
 	erasure_chunk: &ErasureChunk,
 ) {
-	let key = (CHUNK_PREFIX, candidate_hash, chunk_index).encode();
+	let key = (CHUNK_PREFIX, candidate_hash, validator_index).encode();
 
 	tx.put_vec(config.col_data, &key, erasure_chunk.encode());
 }
@@ -231,9 +233,9 @@ fn delete_chunk(
 	tx: &mut DBTransaction,
 	config: &Config,
 	candidate_hash: &CandidateHash,
-	chunk_index: ValidatorIndex,
+	validator_index: ValidatorIndex,
 ) {
-	let key = (CHUNK_PREFIX, candidate_hash, chunk_index).encode();
+	let key = (CHUNK_PREFIX, candidate_hash, validator_index).encode();
 
 	tx.delete(config.col_data, &key[..]);
 }
@@ -352,7 +354,7 @@ pub enum Error {
 	ChainApi(#[from] ChainApiError),
 
 	#[error(transparent)]
-	Erasure(#[from] erasure::Error),
+	Erasure(#[from] polkadot_erasure_coding::Error),
 
 	#[error(transparent)]
 	Io(#[from] io::Error),
@@ -1139,20 +1141,23 @@ fn process_message(
 				Some(meta) => {
 					let mut chunks = Vec::new();
 
-					for (index, _) in meta.chunks_stored.iter().enumerate().filter(|(_, b)| **b) {
+					for (validator_index, _) in
+						meta.chunks_stored.iter().enumerate().filter(|(_, b)| **b)
+					{
+						let validator_index = ValidatorIndex(validator_index as _);
 						let _timer = subsystem.metrics.time_get_chunk();
 						match load_chunk(
 							&subsystem.db,
 							&subsystem.config,
 							&candidate,
-							ValidatorIndex(index as _),
+							validator_index,
 						)? {
-							Some(c) => chunks.push(c),
+							Some(c) => chunks.push((validator_index, c)),
 							None => {
 								gum::warn!(
 									target: LOG_TARGET,
 									?candidate,
-									index,
+									?validator_index,
 									"No chunk found for set bit in meta"
 								);
 							},
@@ -1169,11 +1174,17 @@ fn process_message(
 			});
 			let _ = tx.send(a);
 		},
-		AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk, tx } => {
+		AvailabilityStoreMessage::StoreChunk { candidate_hash, validator_index, chunk, tx } => {
 			subsystem.metrics.on_chunks_received(1);
 			let _timer = subsystem.metrics.time_store_chunk();
 
-			match store_chunk(&subsystem.db, &subsystem.config, candidate_hash, chunk) {
+			match store_chunk(
+				&subsystem.db,
+				&subsystem.config,
+				candidate_hash,
+				validator_index,
+				chunk,
+			) {
 				Ok(true) => {
 					let _ = tx.send(Ok(()));
 				},
@@ -1191,6 +1202,8 @@ fn process_message(
 			n_validators,
 			available_data,
 			expected_erasure_root,
+			core_index,
+			node_features,
 			tx,
 		} => {
 			subsystem.metrics.on_chunks_received(n_validators as _);
@@ -1203,6 +1216,8 @@ fn process_message(
 				n_validators as _,
 				available_data,
 				expected_erasure_root,
+				core_index,
+				node_features,
 			);
 
 			match res {
@@ -1233,6 +1248,7 @@ fn store_chunk(
 	db: &Arc<dyn Database>,
 	config: &Config,
 	candidate_hash: CandidateHash,
+	validator_index: ValidatorIndex,
 	chunk: ErasureChunk,
 ) -> Result<bool, Error> {
 	let mut tx = DBTransaction::new();
@@ -1242,12 +1258,12 @@ fn store_chunk(
 		None => return Ok(false), // we weren't informed of this candidate by import events.
 	};
 
-	match meta.chunks_stored.get(chunk.index.0 as usize).map(|b| *b) {
+	match meta.chunks_stored.get(validator_index.0 as usize).map(|b| *b) {
 		Some(true) => return Ok(true), // already stored.
 		Some(false) => {
-			meta.chunks_stored.set(chunk.index.0 as usize, true);
+			meta.chunks_stored.set(validator_index.0 as usize, true);
 
-			write_chunk(&mut tx, config, &candidate_hash, chunk.index, &chunk);
+			write_chunk(&mut tx, config, &candidate_hash, validator_index, &chunk);
 			write_meta(&mut tx, config, &candidate_hash, &meta);
 		},
 		None => return Ok(false), // out of bounds.
@@ -1257,6 +1273,7 @@ fn store_chunk(
 		target: LOG_TARGET,
 		?candidate_hash,
 		chunk_index = %chunk.index.0,
+		validator_index = %validator_index.0,
 		"Stored chunk index for candidate.",
 	);
 
@@ -1264,13 +1281,14 @@ fn store_chunk(
 	Ok(true)
 }
 
-// Ok(true) on success, Ok(false) on failure, and Err on internal error.
 fn store_available_data(
 	subsystem: &AvailabilityStoreSubsystem,
 	candidate_hash: CandidateHash,
 	n_validators: usize,
 	available_data: AvailableData,
 	expected_erasure_root: Hash,
+	core_index: CoreIndex,
+	node_features: NodeFeatures,
 ) -> Result<(), Error> {
 	let mut tx = DBTransaction::new();
 
@@ -1303,8 +1321,8 @@ fn store_available_data(
 
 	// Important note: This check below is critical for consensus and the `backing` subsystem relies
 	// on it to ensure candidate validity.
-	let chunks = erasure::obtain_chunks_v1(n_validators, &available_data)?;
-	let branches = erasure::branches(chunks.as_ref());
+	let chunks = polkadot_erasure_coding::obtain_chunks_v1(n_validators, &available_data)?;
+	let branches = polkadot_erasure_coding::branches(chunks.as_ref());
 
 	if branches.root() != expected_erasure_root {
 		return Err(Error::InvalidErasureRoot)
@@ -1312,16 +1330,26 @@ fn store_available_data(
 
 	drop(erasure_span);
 
-	let erasure_chunks = chunks.iter().zip(branches.map(|(proof, _)| proof)).enumerate().map(
-		|(index, (chunk, proof))| ErasureChunk {
+	let erasure_chunks: Vec<_> = chunks
+		.iter()
+		.zip(branches.map(|(proof, _)| proof))
+		.enumerate()
+		.map(|(index, (chunk, proof))| ErasureChunk {
 			chunk: chunk.clone(),
 			proof,
-			index: ValidatorIndex(index as u32),
-		},
-	);
+			index: ChunkIndex(index as u32),
+		})
+		.collect();
 
-	for chunk in erasure_chunks {
-		write_chunk(&mut tx, &subsystem.config, &candidate_hash, chunk.index, &chunk);
+	let chunk_indices = availability_chunk_indices(Some(&node_features), n_validators, core_index)?;
+	for (validator_index, chunk_index) in chunk_indices.into_iter().enumerate() {
+		write_chunk(
+			&mut tx,
+			&subsystem.config,
+			&candidate_hash,
+			ValidatorIndex(validator_index as u32),
+			&erasure_chunks[chunk_index.0 as usize],
+		);
 	}
 
 	meta.data_available = true;
diff --git a/polkadot/node/core/av-store/src/tests.rs b/polkadot/node/core/av-store/src/tests.rs
index 652bf2a3fda4822fdae0020bcd48993ed8e771ed..04a223730bcd68b178925f3c8b04963b30854651 100644
--- a/polkadot/node/core/av-store/src/tests.rs
+++ b/polkadot/node/core/av-store/src/tests.rs
@@ -18,9 +18,9 @@ use super::*;
 
 use assert_matches::assert_matches;
 use futures::{channel::oneshot, executor, future, Future};
+use util::availability_chunks::availability_chunk_index;
 
 use self::test_helpers::mock::new_leaf;
-use ::test_helpers::TestCandidateBuilder;
 use parking_lot::Mutex;
 use polkadot_node_primitives::{AvailableData, BlockData, PoV, Proof};
 use polkadot_node_subsystem::{
@@ -31,9 +31,10 @@ use polkadot_node_subsystem::{
 use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_node_subsystem_util::{database::Database, TimeoutExt};
 use polkadot_primitives::{
-	CandidateHash, CandidateReceipt, CoreIndex, GroupIndex, HeadData, Header,
+	node_features, CandidateHash, CandidateReceipt, CoreIndex, GroupIndex, HeadData, Header,
 	PersistedValidationData, ValidatorId,
 };
+use polkadot_primitives_test_helpers::TestCandidateBuilder;
 use sp_keyring::Sr25519Keyring;
 
 mod columns {
@@ -44,7 +45,8 @@ mod columns {
 
 const TEST_CONFIG: Config = Config { col_data: columns::DATA, col_meta: columns::META };
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<AvailabilityStoreMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<AvailabilityStoreMessage>;
 
 #[derive(Clone)]
 struct TestClock {
@@ -127,7 +129,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 		.try_init();
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let subsystem = AvailabilityStoreSubsystem::with_pruning_config_and_clock(
 		store,
@@ -272,8 +275,7 @@ fn runtime_api_error_does_not_stop_the_subsystem() {
 		// but that's fine, we're still alive
 		let (tx, rx) = oneshot::channel();
 		let candidate_hash = CandidateHash(Hash::repeat_byte(33));
-		let validator_index = ValidatorIndex(5);
-		let query_chunk = AvailabilityStoreMessage::QueryChunk(candidate_hash, validator_index, tx);
+		let query_chunk = AvailabilityStoreMessage::QueryChunk(candidate_hash, 5.into(), tx);
 
 		overseer_send(&mut virtual_overseer, query_chunk.into()).await;
 
@@ -288,12 +290,13 @@ fn store_chunk_works() {
 
 	test_harness(TestState::default(), store.clone(), |mut virtual_overseer| async move {
 		let candidate_hash = CandidateHash(Hash::repeat_byte(33));
-		let validator_index = ValidatorIndex(5);
+		let chunk_index = ChunkIndex(5);
+		let validator_index = ValidatorIndex(2);
 		let n_validators = 10;
 
 		let chunk = ErasureChunk {
 			chunk: vec![1, 2, 3],
-			index: validator_index,
+			index: chunk_index,
 			proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(),
 		};
 
@@ -314,8 +317,12 @@ fn store_chunk_works() {
 
 		let (tx, rx) = oneshot::channel();
 
-		let chunk_msg =
-			AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk: chunk.clone(), tx };
+		let chunk_msg = AvailabilityStoreMessage::StoreChunk {
+			candidate_hash,
+			validator_index,
+			chunk: chunk.clone(),
+			tx,
+		};
 
 		overseer_send(&mut virtual_overseer, chunk_msg).await;
 		assert_eq!(rx.await.unwrap(), Ok(()));
@@ -336,18 +343,23 @@ fn store_chunk_does_nothing_if_no_entry_already() {
 
 	test_harness(TestState::default(), store.clone(), |mut virtual_overseer| async move {
 		let candidate_hash = CandidateHash(Hash::repeat_byte(33));
-		let validator_index = ValidatorIndex(5);
+		let chunk_index = ChunkIndex(5);
+		let validator_index = ValidatorIndex(2);
 
 		let chunk = ErasureChunk {
 			chunk: vec![1, 2, 3],
-			index: validator_index,
+			index: chunk_index,
 			proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(),
 		};
 
 		let (tx, rx) = oneshot::channel();
 
-		let chunk_msg =
-			AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk: chunk.clone(), tx };
+		let chunk_msg = AvailabilityStoreMessage::StoreChunk {
+			candidate_hash,
+			validator_index,
+			chunk: chunk.clone(),
+			tx,
+		};
 
 		overseer_send(&mut virtual_overseer, chunk_msg).await;
 		assert_eq!(rx.await.unwrap(), Err(()));
@@ -418,6 +430,8 @@ fn store_available_data_erasure_mismatch() {
 		let candidate_hash = CandidateHash(Hash::repeat_byte(1));
 		let validator_index = ValidatorIndex(5);
 		let n_validators = 10;
+		let core_index = CoreIndex(8);
+		let node_features = NodeFeatures::EMPTY;
 
 		let pov = PoV { block_data: BlockData(vec![4, 5, 6]) };
 
@@ -431,6 +445,8 @@ fn store_available_data_erasure_mismatch() {
 			candidate_hash,
 			n_validators,
 			available_data: available_data.clone(),
+			core_index,
+			node_features,
 			tx,
 			// A dummy erasure root should lead to failure.
 			expected_erasure_root: Hash::default(),
@@ -450,97 +466,187 @@ fn store_available_data_erasure_mismatch() {
 }
 
 #[test]
-fn store_block_works() {
-	let store = test_store();
-	let test_state = TestState::default();
-	test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move {
-		let candidate_hash = CandidateHash(Hash::repeat_byte(1));
-		let validator_index = ValidatorIndex(5);
-		let n_validators = 10;
-
-		let pov = PoV { block_data: BlockData(vec![4, 5, 6]) };
-
-		let available_data = AvailableData {
-			pov: Arc::new(pov),
-			validation_data: test_state.persisted_validation_data.clone(),
-		};
-		let (tx, rx) = oneshot::channel();
-
-		let chunks = erasure::obtain_chunks_v1(10, &available_data).unwrap();
-		let mut branches = erasure::branches(chunks.as_ref());
-
-		let block_msg = AvailabilityStoreMessage::StoreAvailableData {
-			candidate_hash,
-			n_validators,
-			available_data: available_data.clone(),
-			tx,
-			expected_erasure_root: branches.root(),
-		};
-
-		virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await;
-		assert_eq!(rx.await.unwrap(), Ok(()));
-
-		let pov = query_available_data(&mut virtual_overseer, candidate_hash).await.unwrap();
-		assert_eq!(pov, available_data);
-
-		let chunk = query_chunk(&mut virtual_overseer, candidate_hash, validator_index)
-			.await
-			.unwrap();
-
-		let branch = branches.nth(5).unwrap();
-		let expected_chunk = ErasureChunk {
-			chunk: branch.1.to_vec(),
-			index: ValidatorIndex(5),
-			proof: Proof::try_from(branch.0).unwrap(),
-		};
-
-		assert_eq!(chunk, expected_chunk);
-		virtual_overseer
-	});
-}
-
-#[test]
-fn store_pov_and_query_chunk_works() {
-	let store = test_store();
-	let test_state = TestState::default();
-
-	test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move {
-		let candidate_hash = CandidateHash(Hash::repeat_byte(1));
-		let n_validators = 10;
-
-		let pov = PoV { block_data: BlockData(vec![4, 5, 6]) };
-
-		let available_data = AvailableData {
-			pov: Arc::new(pov),
-			validation_data: test_state.persisted_validation_data.clone(),
-		};
-
-		let chunks_expected =
-			erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap();
-		let branches = erasure::branches(chunks_expected.as_ref());
-
-		let (tx, rx) = oneshot::channel();
-		let block_msg = AvailabilityStoreMessage::StoreAvailableData {
-			candidate_hash,
-			n_validators,
-			available_data,
-			tx,
-			expected_erasure_root: branches.root(),
-		};
-
-		virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await;
+fn store_pov_and_queries_work() {
+	// If the AvailabilityChunkMapping feature is not enabled,
+	// ValidatorIndex->ChunkIndex mapping should be 1:1 for all core indices.
+	{
+		let n_cores = 4;
+		for core_index in 0..n_cores {
+			let store = test_store();
+			let test_state = TestState::default();
+			let core_index = CoreIndex(core_index);
+
+			test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move {
+				let node_features = NodeFeatures::EMPTY;
+				let candidate_hash = CandidateHash(Hash::repeat_byte(1));
+				let n_validators = 10;
+
+				let pov = PoV { block_data: BlockData(vec![4, 5, 6]) };
+				let available_data = AvailableData {
+					pov: Arc::new(pov),
+					validation_data: test_state.persisted_validation_data.clone(),
+				};
+
+				let chunks =
+					polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data)
+						.unwrap();
+
+				let branches = polkadot_erasure_coding::branches(chunks.as_ref());
+
+				let (tx, rx) = oneshot::channel();
+				let block_msg = AvailabilityStoreMessage::StoreAvailableData {
+					candidate_hash,
+					n_validators,
+					available_data: available_data.clone(),
+					tx,
+					core_index,
+					expected_erasure_root: branches.root(),
+					node_features: node_features.clone(),
+				};
+
+				virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await;
+				assert_eq!(rx.await.unwrap(), Ok(()));
+
+				let pov: AvailableData =
+					query_available_data(&mut virtual_overseer, candidate_hash).await.unwrap();
+				assert_eq!(pov, available_data);
+
+				let query_all_chunks_res = query_all_chunks(
+					&mut virtual_overseer,
+					availability_chunk_indices(
+						Some(&node_features),
+						n_validators as usize,
+						core_index,
+					)
+					.unwrap(),
+					candidate_hash,
+				)
+				.await;
+				assert_eq!(query_all_chunks_res.len(), chunks.len());
+
+				let branches: Vec<_> = branches.collect();
+
+				for validator_index in 0..n_validators {
+					let chunk = query_chunk(
+						&mut virtual_overseer,
+						candidate_hash,
+						ValidatorIndex(validator_index as _),
+					)
+					.await
+					.unwrap();
+					let branch = &branches[validator_index as usize];
+					let expected_chunk = ErasureChunk {
+						chunk: branch.1.to_vec(),
+						index: validator_index.into(),
+						proof: Proof::try_from(branch.0.clone()).unwrap(),
+					};
+					assert_eq!(chunk, expected_chunk);
+					assert_eq!(chunk, query_all_chunks_res[validator_index as usize]);
+				}
 
-		assert_eq!(rx.await.unwrap(), Ok(()));
+				virtual_overseer
+			});
+		}
+	}
 
-		for i in 0..n_validators {
-			let chunk = query_chunk(&mut virtual_overseer, candidate_hash, ValidatorIndex(i as _))
-				.await
-				.unwrap();
+	// If the AvailabilityChunkMapping feature is enabled, let's also test the
+	// ValidatorIndex -> ChunkIndex mapping.
+	{
+		let n_cores = 4;
+		for core_index in 0..n_cores {
+			let store = test_store();
+			let test_state = TestState::default();
+
+			test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move {
+				let mut node_features = NodeFeatures::EMPTY;
+				let feature_bit = node_features::FeatureIndex::AvailabilityChunkMapping;
+				node_features.resize((feature_bit as u8 + 1) as usize, false);
+				node_features.set(feature_bit as u8 as usize, true);
+
+				let candidate_hash = CandidateHash(Hash::repeat_byte(1));
+				let n_validators = 10;
+
+				let pov = PoV { block_data: BlockData(vec![4, 5, 6]) };
+				let available_data = AvailableData {
+					pov: Arc::new(pov),
+					validation_data: test_state.persisted_validation_data.clone(),
+				};
+
+				let chunks =
+					polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data)
+						.unwrap();
+
+				let branches = polkadot_erasure_coding::branches(chunks.as_ref());
+				let core_index = CoreIndex(core_index);
+
+				let (tx, rx) = oneshot::channel();
+				let block_msg = AvailabilityStoreMessage::StoreAvailableData {
+					candidate_hash,
+					n_validators,
+					available_data: available_data.clone(),
+					tx,
+					core_index,
+					expected_erasure_root: branches.root(),
+					node_features: node_features.clone(),
+				};
+
+				virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await;
+				assert_eq!(rx.await.unwrap(), Ok(()));
+
+				let pov: AvailableData =
+					query_available_data(&mut virtual_overseer, candidate_hash).await.unwrap();
+				assert_eq!(pov, available_data);
+
+				let query_all_chunks_res = query_all_chunks(
+					&mut virtual_overseer,
+					availability_chunk_indices(
+						Some(&node_features),
+						n_validators as usize,
+						core_index,
+					)
+					.unwrap(),
+					candidate_hash,
+				)
+				.await;
+				assert_eq!(query_all_chunks_res.len(), chunks.len());
+
+				let branches: Vec<_> = branches.collect();
+
+				for validator_index in 0..n_validators {
+					let chunk = query_chunk(
+						&mut virtual_overseer,
+						candidate_hash,
+						ValidatorIndex(validator_index as _),
+					)
+					.await
+					.unwrap();
+					let expected_chunk_index = availability_chunk_index(
+						Some(&node_features),
+						n_validators as usize,
+						core_index,
+						ValidatorIndex(validator_index),
+					)
+					.unwrap();
+					let branch = &branches[expected_chunk_index.0 as usize];
+					let expected_chunk = ErasureChunk {
+						chunk: branch.1.to_vec(),
+						index: expected_chunk_index,
+						proof: Proof::try_from(branch.0.clone()).unwrap(),
+					};
+					assert_eq!(chunk, expected_chunk);
+					assert_eq!(
+						&chunk,
+						query_all_chunks_res
+							.iter()
+							.find(|c| c.index == expected_chunk_index)
+							.unwrap()
+					);
+				}
 
-			assert_eq!(chunk.chunk, chunks_expected[i as usize]);
+				virtual_overseer
+			});
 		}
-		virtual_overseer
-	});
+	}
 }
 
 #[test]
@@ -567,14 +673,17 @@ fn query_all_chunks_works() {
 
 		{
 			let chunks_expected =
-				erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap();
-			let branches = erasure::branches(chunks_expected.as_ref());
+				polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data)
+					.unwrap();
+			let branches = polkadot_erasure_coding::branches(chunks_expected.as_ref());
 			let (tx, rx) = oneshot::channel();
 			let block_msg = AvailabilityStoreMessage::StoreAvailableData {
 				candidate_hash: candidate_hash_1,
 				n_validators,
 				available_data,
 				tx,
+				core_index: CoreIndex(1),
+				node_features: NodeFeatures::EMPTY,
 				expected_erasure_root: branches.root(),
 			};
 
@@ -598,7 +707,7 @@ fn query_all_chunks_works() {
 
 			let chunk = ErasureChunk {
 				chunk: vec![1, 2, 3],
-				index: ValidatorIndex(1),
+				index: ChunkIndex(1),
 				proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(),
 			};
 
@@ -606,6 +715,7 @@ fn query_all_chunks_works() {
 			let store_chunk_msg = AvailabilityStoreMessage::StoreChunk {
 				candidate_hash: candidate_hash_2,
 				chunk,
+				validator_index: ValidatorIndex(1),
 				tx,
 			};
 
@@ -615,29 +725,29 @@ fn query_all_chunks_works() {
 			assert_eq!(rx.await.unwrap(), Ok(()));
 		}
 
-		{
-			let (tx, rx) = oneshot::channel();
-
-			let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash_1, tx);
-			virtual_overseer.send(FromOrchestra::Communication { msg }).await;
-			assert_eq!(rx.await.unwrap().len(), n_validators as usize);
-		}
-
-		{
-			let (tx, rx) = oneshot::channel();
+		let chunk_indices =
+			availability_chunk_indices(None, n_validators as usize, CoreIndex(0)).unwrap();
 
-			let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash_2, tx);
-			virtual_overseer.send(FromOrchestra::Communication { msg }).await;
-			assert_eq!(rx.await.unwrap().len(), 1);
-		}
+		assert_eq!(
+			query_all_chunks(&mut virtual_overseer, chunk_indices.clone(), candidate_hash_1)
+				.await
+				.len(),
+			n_validators as usize
+		);
 
-		{
-			let (tx, rx) = oneshot::channel();
+		assert_eq!(
+			query_all_chunks(&mut virtual_overseer, chunk_indices.clone(), candidate_hash_2)
+				.await
+				.len(),
+			1
+		);
+		assert_eq!(
+			query_all_chunks(&mut virtual_overseer, chunk_indices.clone(), candidate_hash_3)
+				.await
+				.len(),
+			0
+		);
 
-			let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash_3, tx);
-			virtual_overseer.send(FromOrchestra::Communication { msg }).await;
-			assert_eq!(rx.await.unwrap().len(), 0);
-		}
 		virtual_overseer
 	});
 }
@@ -659,14 +769,17 @@ fn stored_but_not_included_data_is_pruned() {
 		};
 
 		let (tx, rx) = oneshot::channel();
-		let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap();
-		let branches = erasure::branches(chunks.as_ref());
+		let chunks =
+			polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data).unwrap();
+		let branches = polkadot_erasure_coding::branches(chunks.as_ref());
 
 		let block_msg = AvailabilityStoreMessage::StoreAvailableData {
 			candidate_hash,
 			n_validators,
 			available_data: available_data.clone(),
 			tx,
+			node_features: NodeFeatures::EMPTY,
+			core_index: CoreIndex(1),
 			expected_erasure_root: branches.root(),
 		};
 
@@ -714,8 +827,9 @@ fn stored_data_kept_until_finalized() {
 		let parent = Hash::repeat_byte(2);
 		let block_number = 10;
 
-		let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap();
-		let branches = erasure::branches(chunks.as_ref());
+		let chunks =
+			polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data).unwrap();
+		let branches = polkadot_erasure_coding::branches(chunks.as_ref());
 
 		let (tx, rx) = oneshot::channel();
 		let block_msg = AvailabilityStoreMessage::StoreAvailableData {
@@ -723,6 +837,8 @@ fn stored_data_kept_until_finalized() {
 			n_validators,
 			available_data: available_data.clone(),
 			tx,
+			node_features: NodeFeatures::EMPTY,
+			core_index: CoreIndex(1),
 			expected_erasure_root: branches.root(),
 		};
 
@@ -989,8 +1105,10 @@ fn forkfullness_works() {
 			validation_data: test_state.persisted_validation_data.clone(),
 		};
 
-		let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data_1).unwrap();
-		let branches = erasure::branches(chunks.as_ref());
+		let chunks =
+			polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data_1)
+				.unwrap();
+		let branches = polkadot_erasure_coding::branches(chunks.as_ref());
 
 		let (tx, rx) = oneshot::channel();
 		let msg = AvailabilityStoreMessage::StoreAvailableData {
@@ -998,6 +1116,8 @@ fn forkfullness_works() {
 			n_validators,
 			available_data: available_data_1.clone(),
 			tx,
+			node_features: NodeFeatures::EMPTY,
+			core_index: CoreIndex(1),
 			expected_erasure_root: branches.root(),
 		};
 
@@ -1005,8 +1125,10 @@ fn forkfullness_works() {
 
 		rx.await.unwrap().unwrap();
 
-		let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data_2).unwrap();
-		let branches = erasure::branches(chunks.as_ref());
+		let chunks =
+			polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data_2)
+				.unwrap();
+		let branches = polkadot_erasure_coding::branches(chunks.as_ref());
 
 		let (tx, rx) = oneshot::channel();
 		let msg = AvailabilityStoreMessage::StoreAvailableData {
@@ -1014,6 +1136,8 @@ fn forkfullness_works() {
 			n_validators,
 			available_data: available_data_2.clone(),
 			tx,
+			node_features: NodeFeatures::EMPTY,
+			core_index: CoreIndex(1),
 			expected_erasure_root: branches.root(),
 		};
 
@@ -1126,6 +1250,25 @@ async fn query_chunk(
 	rx.await.unwrap()
 }
 
+async fn query_all_chunks(
+	virtual_overseer: &mut VirtualOverseer,
+	chunk_mapping: Vec<ChunkIndex>,
+	candidate_hash: CandidateHash,
+) -> Vec<ErasureChunk> {
+	let (tx, rx) = oneshot::channel();
+
+	let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash, tx);
+	virtual_overseer.send(FromOrchestra::Communication { msg }).await;
+
+	let resp = rx.await.unwrap();
+	resp.into_iter()
+		.map(|(val_idx, chunk)| {
+			assert_eq!(chunk.index, chunk_mapping[val_idx.0 as usize]);
+			chunk
+		})
+		.collect()
+}
+
 async fn has_all_chunks(
 	virtual_overseer: &mut VirtualOverseer,
 	candidate_hash: CandidateHash,
@@ -1206,12 +1349,12 @@ fn query_chunk_size_works() {
 
 	test_harness(TestState::default(), store.clone(), |mut virtual_overseer| async move {
 		let candidate_hash = CandidateHash(Hash::repeat_byte(33));
-		let validator_index = ValidatorIndex(5);
+		let chunk_index = ChunkIndex(5);
 		let n_validators = 10;
 
 		let chunk = ErasureChunk {
 			chunk: vec![1, 2, 3],
-			index: validator_index,
+			index: chunk_index,
 			proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(),
 		};
 
@@ -1232,8 +1375,12 @@ fn query_chunk_size_works() {
 
 		let (tx, rx) = oneshot::channel();
 
-		let chunk_msg =
-			AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk: chunk.clone(), tx };
+		let chunk_msg = AvailabilityStoreMessage::StoreChunk {
+			candidate_hash,
+			chunk: chunk.clone(),
+			tx,
+			validator_index: chunk_index.into(),
+		};
 
 		overseer_send(&mut virtual_overseer, chunk_msg).await;
 		assert_eq!(rx.await.unwrap(), Ok(()));
diff --git a/polkadot/node/core/backing/Cargo.toml b/polkadot/node/core/backing/Cargo.toml
index f426f73284e8c36d7bc11eef051c8dddbbf40518..ffd6de076889413e6872e7c765d849798afb338a 100644
--- a/polkadot/node/core/backing/Cargo.toml
+++ b/polkadot/node/core/backing/Cargo.toml
@@ -16,8 +16,8 @@ polkadot-primitives = { path = "../../../primitives" }
 polkadot-node-primitives = { path = "../../primitives" }
 polkadot-node-subsystem = { path = "../../subsystem" }
 polkadot-node-subsystem-util = { path = "../../subsystem-util" }
-erasure-coding = { package = "polkadot-erasure-coding", path = "../../../erasure-coding" }
-statement-table = { package = "polkadot-statement-table", path = "../../../statement-table" }
+polkadot-erasure-coding = { path = "../../../erasure-coding" }
+polkadot-statement-table = { path = "../../../statement-table" }
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
 gum = { package = "tracing-gum", path = "../../gum" }
 thiserror = { workspace = true }
@@ -34,4 +34,4 @@ futures = { version = "0.3.30", features = ["thread-pool"] }
 assert_matches = "1.4.0"
 rstest = "0.18.2"
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
diff --git a/polkadot/node/core/backing/src/error.rs b/polkadot/node/core/backing/src/error.rs
index 52684f3fe3063e95dcab48947cf86ca62c321372..568f7140264457af301776f9fb3f5641ef312a07 100644
--- a/polkadot/node/core/backing/src/error.rs
+++ b/polkadot/node/core/backing/src/error.rs
@@ -88,7 +88,7 @@ pub enum Error {
 	JoinMultiple(#[source] oneshot::Canceled),
 
 	#[error("Obtaining erasure chunks failed")]
-	ObtainErasureChunks(#[from] erasure_coding::Error),
+	ObtainErasureChunks(#[from] polkadot_erasure_coding::Error),
 
 	#[error(transparent)]
 	ValidationFailed(#[from] ValidationFailed),
diff --git a/polkadot/node/core/backing/src/lib.rs b/polkadot/node/core/backing/src/lib.rs
index a45edcbef52a91009e670cc5bb2c6a1a5923fa9e..1bda81c5197ef32e5659ab8393ef68384a288577 100644
--- a/polkadot/node/core/backing/src/lib.rs
+++ b/polkadot/node/core/backing/src/lib.rs
@@ -102,6 +102,7 @@ use polkadot_node_subsystem_util::{
 	runtime::{
 		self, prospective_parachains_mode, request_min_backing_votes, ProspectiveParachainsMode,
 	},
+	vstaging::{fetch_claim_queue, ClaimQueueSnapshot},
 	Validator,
 };
 use polkadot_primitives::{
@@ -111,8 +112,7 @@ use polkadot_primitives::{
 	PvfExecKind, SessionIndex, SigningContext, ValidationCode, ValidatorId, ValidatorIndex,
 	ValidatorSignature, ValidityAttestation,
 };
-use sp_keystore::KeystorePtr;
-use statement_table::{
+use polkadot_statement_table::{
 	generic::AttestedCandidate as TableAttestedCandidate,
 	v2::{
 		SignedStatement as TableSignedStatement, Statement as TableStatement,
@@ -120,6 +120,7 @@ use statement_table::{
 	},
 	Config as TableConfig, Context as TableContextTrait, Table,
 };
+use sp_keystore::KeystorePtr;
 use util::{runtime::request_node_features, vstaging::get_disabled_validators_with_fallback};
 
 mod error;
@@ -210,8 +211,8 @@ struct PerRelayParentState {
 	prospective_parachains_mode: ProspectiveParachainsMode,
 	/// The hash of the relay parent on top of which this job is doing it's work.
 	parent: Hash,
-	/// The `ParaId` assigned to the local validator at this relay parent.
-	assigned_para: Option<ParaId>,
+	/// Session index.
+	session_index: SessionIndex,
 	/// The `CoreIndex` assigned to the local validator at this relay parent.
 	assigned_core: Option<CoreIndex>,
 	/// The candidates that are backed by enough validators in their group, by hash.
@@ -231,8 +232,11 @@ struct PerRelayParentState {
 	/// If true, we're appending extra bits in the BackedCandidate validator indices bitfield,
 	/// which represent the assigned core index. True if ElasticScalingMVP is enabled.
 	inject_core_index: bool,
-	/// The core states for all cores.
-	cores: Vec<CoreState>,
+	/// The number of cores.
+	n_cores: u32,
+	/// Claim queue state. If the runtime API is not available, it'll be populated with info from
+	/// availability cores.
+	claim_queue: ClaimQueueSnapshot,
 	/// The validator index -> group mapping at this relay parent.
 	validator_to_group: Arc<IndexedVec<ValidatorIndex, Option<GroupIndex>>>,
 	/// The associated group rotation information.
@@ -534,6 +538,8 @@ async fn store_available_data(
 	candidate_hash: CandidateHash,
 	available_data: AvailableData,
 	expected_erasure_root: Hash,
+	core_index: CoreIndex,
+	node_features: NodeFeatures,
 ) -> Result<(), Error> {
 	let (tx, rx) = oneshot::channel();
 	// Important: the `av-store` subsystem will check if the erasure root of the `available_data`
@@ -546,6 +552,8 @@ async fn store_available_data(
 			n_validators,
 			available_data,
 			expected_erasure_root,
+			core_index,
+			node_features,
 			tx,
 		})
 		.await;
@@ -569,6 +577,8 @@ async fn make_pov_available(
 	candidate_hash: CandidateHash,
 	validation_data: PersistedValidationData,
 	expected_erasure_root: Hash,
+	core_index: CoreIndex,
+	node_features: NodeFeatures,
 ) -> Result<(), Error> {
 	store_available_data(
 		sender,
@@ -576,6 +586,8 @@ async fn make_pov_available(
 		candidate_hash,
 		AvailableData { pov, validation_data },
 		expected_erasure_root,
+		core_index,
+		node_features,
 	)
 	.await
 }
@@ -646,6 +658,7 @@ struct BackgroundValidationParams<S: overseer::CandidateBackingSenderTrait, F> {
 	tx_command: mpsc::Sender<(Hash, ValidatedCandidateCommand)>,
 	candidate: CandidateReceipt,
 	relay_parent: Hash,
+	session_index: SessionIndex,
 	persisted_validation_data: PersistedValidationData,
 	pov: PoVData,
 	n_validators: usize,
@@ -657,12 +670,14 @@ async fn validate_and_make_available(
 		impl overseer::CandidateBackingSenderTrait,
 		impl Fn(BackgroundValidationResult) -> ValidatedCandidateCommand + Sync,
 	>,
+	core_index: CoreIndex,
 ) -> Result<(), Error> {
 	let BackgroundValidationParams {
 		mut sender,
 		mut tx_command,
 		candidate,
 		relay_parent,
+		session_index,
 		persisted_validation_data,
 		pov,
 		n_validators,
@@ -692,6 +707,10 @@ async fn validate_and_make_available(
 		Err(e) => return Err(Error::UtilError(e)),
 	};
 
+	let node_features = request_node_features(relay_parent, session_index, &mut sender)
+		.await?
+		.unwrap_or(NodeFeatures::EMPTY);
+
 	let pov = match pov {
 		PoVData::Ready(pov) => pov,
 		PoVData::FetchFromValidator { from_validator, candidate_hash, pov_hash } =>
@@ -747,6 +766,8 @@ async fn validate_and_make_available(
 				candidate.hash(),
 				validation_data.clone(),
 				candidate.descriptor.erasure_root,
+				core_index,
+				node_features,
 			)
 			.await;
 
@@ -985,20 +1006,19 @@ macro_rules! try_runtime_api {
 fn core_index_from_statement(
 	validator_to_group: &IndexedVec<ValidatorIndex, Option<GroupIndex>>,
 	group_rotation_info: &GroupRotationInfo,
-	cores: &[CoreState],
+	n_cores: u32,
+	claim_queue: &ClaimQueueSnapshot,
 	statement: &SignedFullStatementWithPVD,
 ) -> Option<CoreIndex> {
 	let compact_statement = statement.as_unchecked();
 	let candidate_hash = CandidateHash(*compact_statement.unchecked_payload().candidate_hash());
 
-	let n_cores = cores.len();
-
 	gum::trace!(
 		target:LOG_TARGET,
 		?group_rotation_info,
 		?statement,
 		?validator_to_group,
-		n_cores = ?cores.len(),
+		n_cores,
 		?candidate_hash,
 		"Extracting core index from statement"
 	);
@@ -1010,7 +1030,7 @@ fn core_index_from_statement(
 			?group_rotation_info,
 			?statement,
 			?validator_to_group,
-			n_cores = ?cores.len() ,
+			n_cores,
 			?candidate_hash,
 			"Invalid validator index: {:?}",
 			statement_validator_index
@@ -1019,37 +1039,25 @@ fn core_index_from_statement(
 	};
 
 	// First check if the statement para id matches the core assignment.
-	let core_index = group_rotation_info.core_for_group(*group_index, n_cores);
+	let core_index = group_rotation_info.core_for_group(*group_index, n_cores as _);
 
-	if core_index.0 as usize > n_cores {
+	if core_index.0 > n_cores {
 		gum::warn!(target: LOG_TARGET, ?candidate_hash, ?core_index, n_cores, "Invalid CoreIndex");
 		return None
 	}
 
 	if let StatementWithPVD::Seconded(candidate, _pvd) = statement.payload() {
 		let candidate_para_id = candidate.descriptor.para_id;
-		let assigned_para_id = match &cores[core_index.0 as usize] {
-			CoreState::Free => {
-				gum::debug!(target: LOG_TARGET, ?candidate_hash, "Invalid CoreIndex, core is not assigned to any para_id");
-				return None
-			},
-			CoreState::Occupied(occupied) =>
-				if let Some(next) = &occupied.next_up_on_available {
-					next.para_id
-				} else {
-					return None
-				},
-			CoreState::Scheduled(scheduled) => scheduled.para_id,
-		};
+		let mut assigned_paras = claim_queue.iter_claims_for_core(&core_index);
 
-		if assigned_para_id != candidate_para_id {
+		if !assigned_paras.any(|id| id == &candidate_para_id) {
 			gum::debug!(
 				target: LOG_TARGET,
 				?candidate_hash,
 				?core_index,
-				?assigned_para_id,
+				assigned_paras = ?claim_queue.iter_claims_for_core(&core_index).collect::<Vec<_>>(),
 				?candidate_para_id,
-				"Invalid CoreIndex, core is assigned to a different para_id"
+				"Invalid CoreIndex, core is not assigned to this para_id"
 			);
 			return None
 		}
@@ -1110,6 +1118,8 @@ async fn construct_per_relay_parent_state<Context>(
 			Error::UtilError(TryFrom::try_from(e).expect("the conversion is infallible; qed"))
 		})?;
 
+	let maybe_claim_queue = try_runtime_api!(fetch_claim_queue(ctx.sender(), parent).await);
+
 	let signing_context = SigningContext { parent_hash: parent, session_index };
 	let validator = match Validator::construct(
 		&validators,
@@ -1134,31 +1144,35 @@ async fn construct_per_relay_parent_state<Context>(
 
 	let mut groups = HashMap::<CoreIndex, Vec<ValidatorIndex>>::new();
 	let mut assigned_core = None;
-	let mut assigned_para = None;
+
+	let has_claim_queue = maybe_claim_queue.is_some();
+	let mut claim_queue = maybe_claim_queue.unwrap_or_default().0;
 
 	for (idx, core) in cores.iter().enumerate() {
-		let core_para_id = match core {
-			CoreState::Scheduled(scheduled) => scheduled.para_id,
-			CoreState::Occupied(occupied) =>
-				if mode.is_enabled() {
+		let core_index = CoreIndex(idx as _);
+
+		if !has_claim_queue {
+			match core {
+				CoreState::Scheduled(scheduled) =>
+					claim_queue.insert(core_index, [scheduled.para_id].into_iter().collect()),
+				CoreState::Occupied(occupied) if mode.is_enabled() => {
 					// Async backing makes it legal to build on top of
 					// occupied core.
 					if let Some(next) = &occupied.next_up_on_available {
-						next.para_id
+						claim_queue.insert(core_index, [next.para_id].into_iter().collect())
 					} else {
 						continue
 					}
-				} else {
-					continue
 				},
-			CoreState::Free => continue,
-		};
+				_ => continue,
+			};
+		} else if !claim_queue.contains_key(&core_index) {
+			continue
+		}
 
-		let core_index = CoreIndex(idx as _);
 		let group_index = group_rotation_info.group_for_core(core_index, n_cores);
 		if let Some(g) = validator_groups.get(group_index.0 as usize) {
 			if validator.as_ref().map_or(false, |v| g.contains(&v.index())) {
-				assigned_para = Some(core_para_id);
 				assigned_core = Some(core_index);
 			}
 			groups.insert(core_index, g.clone());
@@ -1191,8 +1205,8 @@ async fn construct_per_relay_parent_state<Context>(
 	Ok(Some(PerRelayParentState {
 		prospective_parachains_mode: mode,
 		parent,
+		session_index,
 		assigned_core,
-		assigned_para,
 		backed: HashSet::new(),
 		table: Table::new(table_config),
 		table_context,
@@ -1201,7 +1215,8 @@ async fn construct_per_relay_parent_state<Context>(
 		fallbacks: HashMap::new(),
 		minimum_backing_votes,
 		inject_core_index,
-		cores,
+		n_cores: cores.len() as u32,
+		claim_queue: ClaimQueueSnapshot::from(claim_queue),
 		validator_to_group: validator_to_group.clone(),
 		group_rotation_info,
 	}))
@@ -1654,7 +1669,8 @@ async fn import_statement<Context>(
 	let core = core_index_from_statement(
 		&rp_state.validator_to_group,
 		&rp_state.group_rotation_info,
-		&rp_state.cores,
+		rp_state.n_cores,
+		&rp_state.claim_queue,
 		statement,
 	)
 	.ok_or(Error::CoreIndexUnavailable)?;
@@ -1788,10 +1804,11 @@ async fn background_validate_and_make_available<Context>(
 	>,
 ) -> Result<(), Error> {
 	let candidate_hash = params.candidate.hash();
+	let Some(core_index) = rp_state.assigned_core else { return Ok(()) };
 	if rp_state.awaiting_validation.insert(candidate_hash) {
 		// spawn background task.
 		let bg = async move {
-			if let Err(error) = validate_and_make_available(params).await {
+			if let Err(error) = validate_and_make_available(params, core_index).await {
 				if let Error::BackgroundValidationMpsc(error) = error {
 					gum::debug!(
 						target: LOG_TARGET,
@@ -1866,6 +1883,7 @@ async fn kick_off_validation_work<Context>(
 			tx_command: background_validation_tx.clone(),
 			candidate: attesting.candidate,
 			relay_parent: rp_state.parent,
+			session_index: rp_state.session_index,
 			persisted_validation_data,
 			pov,
 			n_validators: rp_state.table_context.validators.len(),
@@ -2019,6 +2037,7 @@ async fn validate_and_second<Context>(
 			tx_command: background_validation_tx.clone(),
 			candidate: candidate.clone(),
 			relay_parent: rp_state.parent,
+			session_index: rp_state.session_index,
 			persisted_validation_data,
 			pov: PoVData::Ready(pov),
 			n_validators: rp_state.table_context.validators.len(),
@@ -2075,23 +2094,24 @@ async fn handle_second_message<Context>(
 		return Ok(())
 	}
 
+	let assigned_paras = rp_state.assigned_core.and_then(|core| rp_state.claim_queue.0.get(&core));
+
 	// Sanity check that candidate is from our assignment.
-	if Some(candidate.descriptor().para_id) != rp_state.assigned_para {
+	if !matches!(assigned_paras, Some(paras) if paras.contains(&candidate.descriptor().para_id)) {
 		gum::debug!(
 			target: LOG_TARGET,
 			our_assignment_core = ?rp_state.assigned_core,
-			our_assignment_para = ?rp_state.assigned_para,
+			our_assignment_paras = ?assigned_paras,
 			collation = ?candidate.descriptor().para_id,
 			"Subsystem asked to second for para outside of our assignment",
 		);
-
-		return Ok(())
+		return Ok(());
 	}
 
 	gum::debug!(
 		target: LOG_TARGET,
 		our_assignment_core = ?rp_state.assigned_core,
-		our_assignment_para = ?rp_state.assigned_para,
+		our_assignment_paras = ?assigned_paras,
 		collation = ?candidate.descriptor().para_id,
 		"Current assignments vs collation",
 	);
diff --git a/polkadot/node/core/backing/src/tests/mod.rs b/polkadot/node/core/backing/src/tests/mod.rs
index d1969e656db673b70b070c9b708bab867bec9fcb..5f2bc7e18424390bbd012cdccc268c902820e4e3 100644
--- a/polkadot/node/core/backing/src/tests/mod.rs
+++ b/polkadot/node/core/backing/src/tests/mod.rs
@@ -16,10 +16,6 @@
 
 use self::test_helpers::mock::new_leaf;
 use super::*;
-use ::test_helpers::{
-	dummy_candidate_receipt_bad_sig, dummy_collator, dummy_collator_signature,
-	dummy_committed_candidate_receipt, dummy_hash, validator_pubkeys,
-};
 use assert_matches::assert_matches;
 use futures::{future, Future};
 use polkadot_node_primitives::{BlockData, InvalidCandidate, SignedFullStatement, Statement};
@@ -36,13 +32,20 @@ use polkadot_primitives::{
 	node_features, CandidateDescriptor, GroupRotationInfo, HeadData, PersistedValidationData,
 	PvfExecKind, ScheduledCore, SessionIndex, LEGACY_MIN_BACKING_VOTES,
 };
+use polkadot_primitives_test_helpers::{
+	dummy_candidate_receipt_bad_sig, dummy_collator, dummy_collator_signature,
+	dummy_committed_candidate_receipt, dummy_hash, validator_pubkeys,
+};
+use polkadot_statement_table::v2::Misbehavior;
 use rstest::rstest;
 use sp_application_crypto::AppCrypto;
 use sp_keyring::Sr25519Keyring;
 use sp_keystore::Keystore;
 use sp_tracing as _;
-use statement_table::v2::Misbehavior;
-use std::{collections::HashMap, time::Duration};
+use std::{
+	collections::{BTreeMap, HashMap, VecDeque},
+	time::Duration,
+};
 
 mod prospective_parachains;
 
@@ -75,6 +78,7 @@ pub(crate) struct TestState {
 	validator_groups: (Vec<Vec<ValidatorIndex>>, GroupRotationInfo),
 	validator_to_group: IndexedVec<ValidatorIndex, Option<GroupIndex>>,
 	availability_cores: Vec<CoreState>,
+	claim_queue: BTreeMap<CoreIndex, VecDeque<ParaId>>,
 	head_data: HashMap<ParaId, HeadData>,
 	signing_context: SigningContext,
 	relay_parent: Hash,
@@ -130,6 +134,10 @@ impl Default for TestState {
 			CoreState::Scheduled(ScheduledCore { para_id: chain_b, collator: None }),
 		];
 
+		let mut claim_queue = BTreeMap::new();
+		claim_queue.insert(CoreIndex(0), [chain_a].into_iter().collect());
+		claim_queue.insert(CoreIndex(1), [chain_b].into_iter().collect());
+
 		let mut head_data = HashMap::new();
 		head_data.insert(chain_a, HeadData(vec![4, 5, 6]));
 		head_data.insert(chain_b, HeadData(vec![5, 6, 7]));
@@ -153,6 +161,7 @@ impl Default for TestState {
 			validator_groups: (validator_groups, group_rotation_info),
 			validator_to_group,
 			availability_cores,
+			claim_queue,
 			head_data,
 			validation_data,
 			signing_context,
@@ -164,7 +173,8 @@ impl Default for TestState {
 	}
 }
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<CandidateBackingMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<CandidateBackingMessage>;
 
 fn test_harness<T: Future<Output = VirtualOverseer>>(
 	keystore: KeystorePtr,
@@ -172,7 +182,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 ) {
 	let pool = sp_core::testing::TaskExecutor::new();
 
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let subsystem = async move {
 		if let Err(e) = super::run(context, keystore, Metrics(None)).await {
@@ -196,8 +207,9 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 fn make_erasure_root(test: &TestState, pov: PoV, validation_data: PersistedValidationData) -> Hash {
 	let available_data = AvailableData { validation_data, pov: Arc::new(pov) };
 
-	let chunks = erasure_coding::obtain_chunks_v1(test.validators.len(), &available_data).unwrap();
-	erasure_coding::branches(&chunks).root()
+	let chunks =
+		polkadot_erasure_coding::obtain_chunks_v1(test.validators.len(), &available_data).unwrap();
+	polkadot_erasure_coding::branches(&chunks).root()
 }
 
 #[derive(Default, Clone)]
@@ -335,6 +347,26 @@ async fn test_startup(virtual_overseer: &mut VirtualOverseer, test_state: &TestS
 			tx.send(Ok(test_state.disabled_validators.clone())).unwrap();
 		}
 	);
+
+	assert_matches!(
+		virtual_overseer.recv().await,
+		AllMessages::RuntimeApi(
+			RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx))
+		) if parent == test_state.relay_parent => {
+			tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap();
+		}
+	);
+
+	assert_matches!(
+		virtual_overseer.recv().await,
+		AllMessages::RuntimeApi(
+			RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx))
+		) if parent == test_state.relay_parent => {
+			tx.send(Ok(
+				test_state.claim_queue.clone()
+			)).unwrap();
+		}
+	);
 }
 
 async fn assert_validation_requests(
@@ -367,6 +399,15 @@ async fn assert_validation_requests(
 			tx.send(Ok(Some(ExecutorParams::default()))).unwrap();
 		}
 	);
+
+	assert_matches!(
+		virtual_overseer.recv().await,
+		AllMessages::RuntimeApi(
+			RuntimeApiMessage::Request(_, RuntimeApiRequest::NodeFeatures(sess_idx, tx))
+		) if sess_idx == 1 => {
+			tx.send(Ok(NodeFeatures::EMPTY)).unwrap();
+		}
+	);
 }
 
 async fn assert_validate_from_exhaustive(
@@ -718,11 +759,16 @@ fn get_backed_candidate_preserves_order() {
 	// Assign the second core to the same para as the first one.
 	test_state.availability_cores[1] =
 		CoreState::Scheduled(ScheduledCore { para_id: test_state.chain_ids[0], collator: None });
+	*test_state.claim_queue.get_mut(&CoreIndex(1)).unwrap() =
+		[test_state.chain_ids[0]].into_iter().collect();
 	// Add another availability core for paraid 2.
 	test_state.availability_cores.push(CoreState::Scheduled(ScheduledCore {
 		para_id: test_state.chain_ids[1],
 		collator: None,
 	}));
+	test_state
+		.claim_queue
+		.insert(CoreIndex(2), [test_state.chain_ids[1]].into_iter().collect());
 
 	test_harness(test_state.keystore.clone(), |mut virtual_overseer| async move {
 		test_startup(&mut virtual_overseer, &test_state).await;
@@ -1091,7 +1137,8 @@ fn extract_core_index_from_statement_works() {
 	let core_index_1 = core_index_from_statement(
 		&test_state.validator_to_group,
 		&test_state.validator_groups.1,
-		&test_state.availability_cores,
+		test_state.availability_cores.len() as _,
+		&test_state.claim_queue.clone().into(),
 		&signed_statement_1,
 	)
 	.unwrap();
@@ -1101,7 +1148,8 @@ fn extract_core_index_from_statement_works() {
 	let core_index_2 = core_index_from_statement(
 		&test_state.validator_to_group,
 		&test_state.validator_groups.1,
-		&test_state.availability_cores,
+		test_state.availability_cores.len() as _,
+		&test_state.claim_queue.clone().into(),
 		&signed_statement_2,
 	);
 
@@ -1111,7 +1159,8 @@ fn extract_core_index_from_statement_works() {
 	let core_index_3 = core_index_from_statement(
 		&test_state.validator_to_group,
 		&test_state.validator_groups.1,
-		&test_state.availability_cores,
+		test_state.availability_cores.len() as _,
+		&test_state.claim_queue.clone().into(),
 		&signed_statement_3,
 	)
 	.unwrap();
@@ -1946,7 +1995,7 @@ fn candidate_backing_reorders_votes() {
 		data[32..36].copy_from_slice(idx.encode().as_slice());
 
 		let sig = ValidatorSignature::try_from(data).unwrap();
-		statement_table::generic::ValidityAttestation::Implicit(sig)
+		polkadot_statement_table::generic::ValidityAttestation::Implicit(sig)
 	};
 
 	let attested = TableAttestedCandidate {
@@ -2084,7 +2133,7 @@ fn retry_works() {
 		virtual_overseer.send(FromOrchestra::Communication { msg: statement }).await;
 
 		// Not deterministic which message comes first:
-		for _ in 0u32..5 {
+		for _ in 0u32..6 {
 			match virtual_overseer.recv().await {
 				AllMessages::Provisioner(ProvisionerMessage::ProvisionableData(
 					_,
@@ -2115,6 +2164,12 @@ fn retry_works() {
 				)) => {
 					tx.send(Ok(Some(ExecutorParams::default()))).unwrap();
 				},
+				AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+					_,
+					RuntimeApiRequest::NodeFeatures(1, tx),
+				)) => {
+					tx.send(Ok(NodeFeatures::EMPTY)).unwrap();
+				},
 				msg => {
 					assert!(false, "Unexpected message: {:?}", msg);
 				},
@@ -2662,32 +2717,7 @@ fn validator_ignores_statements_from_disabled_validators() {
 
 		virtual_overseer.send(FromOrchestra::Communication { msg: statement_3 }).await;
 
-		assert_matches!(
-			virtual_overseer.recv().await,
-			AllMessages::RuntimeApi(
-				RuntimeApiMessage::Request(_, RuntimeApiRequest::ValidationCodeByHash(hash, tx))
-			) if hash == validation_code.hash() => {
-				tx.send(Ok(Some(validation_code.clone()))).unwrap();
-			}
-		);
-
-		assert_matches!(
-			virtual_overseer.recv().await,
-			AllMessages::RuntimeApi(
-				RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))
-			) => {
-				tx.send(Ok(1u32.into())).unwrap();
-			}
-		);
-
-		assert_matches!(
-			virtual_overseer.recv().await,
-			AllMessages::RuntimeApi(
-				RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionExecutorParams(sess_idx, tx))
-			) if sess_idx == 1 => {
-				tx.send(Ok(Some(ExecutorParams::default()))).unwrap();
-			}
-		);
+		assert_validation_requests(&mut virtual_overseer, validation_code.clone()).await;
 
 		// Sending a `Statement::Seconded` for our assignment will start
 		// validation process. The first thing requested is the PoV.
diff --git a/polkadot/node/core/backing/src/tests/prospective_parachains.rs b/polkadot/node/core/backing/src/tests/prospective_parachains.rs
index 8a72902f0815030bf2d5d13d3f04fdb1763254aa..15bc0b4a113902ab118bb24f5075eb947b9d874c 100644
--- a/polkadot/node/core/backing/src/tests/prospective_parachains.rs
+++ b/polkadot/node/core/backing/src/tests/prospective_parachains.rs
@@ -67,15 +67,6 @@ async fn activate_leaf(
 		.min()
 		.unwrap_or(&leaf_number);
 
-	assert_matches!(
-		virtual_overseer.recv().await,
-		AllMessages::ProspectiveParachains(
-			ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx)
-		) if parent == leaf_hash => {
-			tx.send(min_relay_parents).unwrap();
-		}
-	);
-
 	let ancestry_len = leaf_number + 1 - min_min;
 
 	let ancestry_hashes = std::iter::successors(Some(leaf_hash), |h| Some(get_parent_hash(*h)))
@@ -117,6 +108,18 @@ async fn activate_leaf(
 					tx.send(Ok(Some(header))).unwrap();
 				}
 			);
+
+			if requested_len == 0 {
+				assert_matches!(
+					virtual_overseer.recv().await,
+					AllMessages::ProspectiveParachains(
+						ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx)
+					) if parent == leaf_hash => {
+						tx.send(min_relay_parents.clone()).unwrap();
+					}
+				);
+			}
+
 			requested_len += 1;
 		}
 	}
@@ -209,6 +212,26 @@ async fn activate_leaf(
 				tx.send(Ok(Vec::new())).unwrap();
 			}
 		);
+
+		assert_matches!(
+			virtual_overseer.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx))
+			) if parent == hash => {
+				tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap();
+			}
+		);
+
+		assert_matches!(
+			virtual_overseer.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx))
+			) if parent == hash => {
+				tx.send(Ok(
+					test_state.claim_queue.clone()
+				)).unwrap();
+			}
+		);
 	}
 }
 
@@ -1432,7 +1455,13 @@ fn concurrent_dependent_candidates() {
 				)) => {
 					tx.send(Ok(test_state.validator_groups.clone())).unwrap();
 				},
-
+				AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+					_,
+					RuntimeApiRequest::NodeFeatures(sess_idx, tx),
+				)) => {
+					assert_eq!(sess_idx, 1);
+					tx.send(Ok(NodeFeatures::EMPTY)).unwrap();
+				},
 				AllMessages::RuntimeApi(RuntimeApiMessage::Request(
 					_parent,
 					RuntimeApiRequest::AvailabilityCores(tx),
@@ -1598,7 +1627,8 @@ fn occupied_core_assignment() {
 		let previous_para_id = test_state.chain_ids[1];
 
 		// Set the core state to occupied.
-		let mut candidate_descriptor = ::test_helpers::dummy_candidate_descriptor(Hash::zero());
+		let mut candidate_descriptor =
+			polkadot_primitives_test_helpers::dummy_candidate_descriptor(Hash::zero());
 		candidate_descriptor.para_id = previous_para_id;
 		test_state.availability_cores[0] = CoreState::Occupied(OccupiedCore {
 			group_responsible: Default::default(),
diff --git a/polkadot/node/core/bitfield-signing/Cargo.toml b/polkadot/node/core/bitfield-signing/Cargo.toml
index 0663e0f1b699bbf44e0ecd51dcf646bc27966a2c..335e733987b017c0ee68f85d6dede42e3128b83c 100644
--- a/polkadot/node/core/bitfield-signing/Cargo.toml
+++ b/polkadot/node/core/bitfield-signing/Cargo.toml
@@ -21,4 +21,4 @@ thiserror = { workspace = true }
 
 [dev-dependencies]
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
diff --git a/polkadot/node/core/bitfield-signing/src/lib.rs b/polkadot/node/core/bitfield-signing/src/lib.rs
index 89851c4a033b58428fa8eac366aafcd5f7144140..e3effb7949eaea0381c556c47eae0a1b6f09dc33 100644
--- a/polkadot/node/core/bitfield-signing/src/lib.rs
+++ b/polkadot/node/core/bitfield-signing/src/lib.rs
@@ -27,15 +27,14 @@ use futures::{
 	FutureExt,
 };
 use polkadot_node_subsystem::{
-	errors::RuntimeApiError,
 	jaeger,
-	messages::{
-		AvailabilityStoreMessage, BitfieldDistributionMessage, RuntimeApiMessage, RuntimeApiRequest,
-	},
+	messages::{AvailabilityStoreMessage, BitfieldDistributionMessage},
 	overseer, ActivatedLeaf, FromOrchestra, OverseerSignal, PerLeafSpan, SpawnedSubsystem,
-	SubsystemError, SubsystemResult, SubsystemSender,
+	SubsystemError, SubsystemResult,
+};
+use polkadot_node_subsystem_util::{
+	self as util, request_availability_cores, runtime::recv_runtime, Validator,
 };
-use polkadot_node_subsystem_util::{self as util, Validator};
 use polkadot_primitives::{AvailabilityBitfield, CoreState, Hash, ValidatorIndex};
 use sp_keystore::{Error as KeystoreError, KeystorePtr};
 use std::{collections::HashMap, time::Duration};
@@ -69,7 +68,7 @@ pub enum Error {
 	MpscSend(#[from] mpsc::SendError),
 
 	#[error(transparent)]
-	Runtime(#[from] RuntimeApiError),
+	Runtime(#[from] util::runtime::Error),
 
 	#[error("Keystore failed: {0:?}")]
 	Keystore(KeystoreError),
@@ -79,8 +78,8 @@ pub enum Error {
 /// for whether we have the availability chunk for our validator index.
 async fn get_core_availability(
 	core: &CoreState,
-	validator_idx: ValidatorIndex,
-	sender: &Mutex<&mut impl SubsystemSender<overseer::BitfieldSigningOutgoingMessages>>,
+	validator_index: ValidatorIndex,
+	sender: &Mutex<&mut impl overseer::BitfieldSigningSenderTrait>,
 	span: &jaeger::Span,
 ) -> Result<bool, Error> {
 	if let CoreState::Occupied(core) = core {
@@ -90,14 +89,11 @@ async fn get_core_availability(
 		sender
 			.lock()
 			.await
-			.send_message(
-				AvailabilityStoreMessage::QueryChunkAvailability(
-					core.candidate_hash,
-					validator_idx,
-					tx,
-				)
-				.into(),
-			)
+			.send_message(AvailabilityStoreMessage::QueryChunkAvailability(
+				core.candidate_hash,
+				validator_index,
+				tx,
+			))
 			.await;
 
 		let res = rx.await.map_err(Into::into);
@@ -116,25 +112,6 @@ async fn get_core_availability(
 	}
 }
 
-/// delegates to the v1 runtime API
-async fn get_availability_cores(
-	relay_parent: Hash,
-	sender: &mut impl SubsystemSender<overseer::BitfieldSigningOutgoingMessages>,
-) -> Result<Vec<CoreState>, Error> {
-	let (tx, rx) = oneshot::channel();
-	sender
-		.send_message(
-			RuntimeApiMessage::Request(relay_parent, RuntimeApiRequest::AvailabilityCores(tx))
-				.into(),
-		)
-		.await;
-	match rx.await {
-		Ok(Ok(out)) => Ok(out),
-		Ok(Err(runtime_err)) => Err(runtime_err.into()),
-		Err(err) => Err(err.into()),
-	}
-}
-
 /// - get the list of core states from the runtime
 /// - for each core, concurrently determine chunk availability (see `get_core_availability`)
 /// - return the bitfield if there were no errors at any point in this process (otherwise, it's
@@ -143,12 +120,12 @@ async fn construct_availability_bitfield(
 	relay_parent: Hash,
 	span: &jaeger::Span,
 	validator_idx: ValidatorIndex,
-	sender: &mut impl SubsystemSender<overseer::BitfieldSigningOutgoingMessages>,
+	sender: &mut impl overseer::BitfieldSigningSenderTrait,
 ) -> Result<AvailabilityBitfield, Error> {
 	// get the set of availability cores from the runtime
 	let availability_cores = {
 		let _span = span.child("get-availability-cores");
-		get_availability_cores(relay_parent, sender).await?
+		recv_runtime(request_availability_cores(relay_parent, sender).await).await?
 	};
 
 	// Wrap the sender in a Mutex to share it between the futures.
diff --git a/polkadot/node/core/bitfield-signing/src/tests.rs b/polkadot/node/core/bitfield-signing/src/tests.rs
index 106ecc06b1569862d7adeacada748e03b586b4ec..eeaa524d1c631101915ad0209c67307499bab73d 100644
--- a/polkadot/node/core/bitfield-signing/src/tests.rs
+++ b/polkadot/node/core/bitfield-signing/src/tests.rs
@@ -16,9 +16,9 @@
 
 use super::*;
 use futures::{executor::block_on, pin_mut, StreamExt};
-use polkadot_node_subsystem::messages::AllMessages;
+use polkadot_node_subsystem::messages::{AllMessages, RuntimeApiMessage, RuntimeApiRequest};
 use polkadot_primitives::{CandidateHash, OccupiedCore};
-use test_helpers::dummy_candidate_descriptor;
+use polkadot_primitives_test_helpers::dummy_candidate_descriptor;
 
 fn occupied_core(para_id: u32, candidate_hash: CandidateHash) -> CoreState {
 	CoreState::Occupied(OccupiedCore {
@@ -64,7 +64,7 @@ fn construct_availability_bitfield_works() {
 					AllMessages::AvailabilityStore(
 						AvailabilityStoreMessage::QueryChunkAvailability(c_hash, vidx, tx),
 					) => {
-						assert_eq!(validator_index, vidx);
+						assert_eq!(validator_index, vidx.into());
 
 						tx.send(c_hash == hash_a).unwrap();
 					},
diff --git a/polkadot/node/core/candidate-validation/Cargo.toml b/polkadot/node/core/candidate-validation/Cargo.toml
index e79b3a734b8f6ed1f0d18c92a0697a8a5ba2e255..a0b25e6c25f9ccd3c5ab2e2ddd38b1f0aa0433a5 100644
--- a/polkadot/node/core/candidate-validation/Cargo.toml
+++ b/polkadot/node/core/candidate-validation/Cargo.toml
@@ -16,7 +16,7 @@ futures-timer = "3.0.2"
 gum = { package = "tracing-gum", path = "../../gum" }
 
 sp-maybe-compressed-blob = { package = "sp-maybe-compressed-blob", path = "../../../../substrate/primitives/maybe-compressed-blob" }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
 
 polkadot-primitives = { path = "../../../primitives" }
 polkadot-parachain-primitives = { path = "../../../parachain" }
@@ -35,4 +35,4 @@ futures = { version = "0.3.30", features = ["thread-pool"] }
 assert_matches = "1.4.0"
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
 sp-core = { path = "../../../../substrate/primitives/core" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
diff --git a/polkadot/node/core/candidate-validation/src/lib.rs b/polkadot/node/core/candidate-validation/src/lib.rs
index 08881dad1961f4beb4249c632f3a82c8f86cc68c..76619bd391f2bbefed07a8b8203a4c1bbcab75e7 100644
--- a/polkadot/node/core/candidate-validation/src/lib.rs
+++ b/polkadot/node/core/candidate-validation/src/lib.rs
@@ -53,7 +53,7 @@ use polkadot_primitives::{
 	ValidationCodeHash,
 };
 
-use parity_scale_codec::Encode;
+use codec::Encode;
 
 use futures::{channel::oneshot, prelude::*, stream::FuturesUnordered};
 
diff --git a/polkadot/node/core/candidate-validation/src/tests.rs b/polkadot/node/core/candidate-validation/src/tests.rs
index e492d51e239ed4bcdfd3a239f635fcd0b0f2154b..491ed7a335d8fb5a8a7531e64267e664e3bf91d3 100644
--- a/polkadot/node/core/candidate-validation/src/tests.rs
+++ b/polkadot/node/core/candidate-validation/src/tests.rs
@@ -15,14 +15,13 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::*;
-use ::test_helpers::{dummy_hash, make_valid_candidate_descriptor};
 use assert_matches::assert_matches;
 use futures::executor;
 use polkadot_node_core_pvf::PrepareError;
 use polkadot_node_subsystem::messages::AllMessages;
-use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_node_subsystem_util::reexports::SubsystemContext;
 use polkadot_primitives::{HeadData, Id as ParaId, UpwardMessage};
+use polkadot_primitives_test_helpers::{dummy_hash, make_valid_candidate_descriptor};
 use sp_core::testing::TaskExecutor;
 use sp_keyring::Sr25519Keyring;
 
@@ -47,8 +46,10 @@ fn correctly_checks_included_assumption() {
 	);
 
 	let pool = TaskExecutor::new();
-	let (mut ctx, mut ctx_handle) =
-		test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let (check_fut, check_result) = check_assumption_validation_data(
 		ctx.sender(),
@@ -119,8 +120,10 @@ fn correctly_checks_timed_out_assumption() {
 	);
 
 	let pool = TaskExecutor::new();
-	let (mut ctx, mut ctx_handle) =
-		test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let (check_fut, check_result) = check_assumption_validation_data(
 		ctx.sender(),
@@ -189,8 +192,10 @@ fn check_is_bad_request_if_no_validation_data() {
 	);
 
 	let pool = TaskExecutor::new();
-	let (mut ctx, mut ctx_handle) =
-		test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let (check_fut, check_result) = check_assumption_validation_data(
 		ctx.sender(),
@@ -243,8 +248,10 @@ fn check_is_bad_request_if_no_validation_code() {
 	);
 
 	let pool = TaskExecutor::new();
-	let (mut ctx, mut ctx_handle) =
-		test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let (check_fut, check_result) = check_assumption_validation_data(
 		ctx.sender(),
@@ -309,8 +316,10 @@ fn check_does_not_match() {
 	);
 
 	let pool = TaskExecutor::new();
-	let (mut ctx, mut ctx_handle) =
-		test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let (check_fut, check_result) = check_assumption_validation_data(
 		ctx.sender(),
@@ -850,7 +859,10 @@ fn candidate_validation_code_mismatch_is_invalid() {
 	let candidate_receipt = CandidateReceipt { descriptor, commitments_hash: Hash::zero() };
 
 	let pool = TaskExecutor::new();
-	let (_ctx, _ctx_handle) = test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (_ctx, _ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let v = executor::block_on(validate_candidate_exhaustive(
 		MockValidateCandidateBackend::with_hardcoded_result(Err(ValidationError::Invalid(
@@ -960,7 +972,10 @@ fn code_decompression_failure_is_error() {
 	let candidate_receipt = CandidateReceipt { descriptor, commitments_hash: Hash::zero() };
 
 	let pool = TaskExecutor::new();
-	let (_ctx, _ctx_handle) = test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (_ctx, _ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let v = executor::block_on(validate_candidate_exhaustive(
 		MockValidateCandidateBackend::with_hardcoded_result(Ok(validation_result)),
@@ -1012,7 +1027,10 @@ fn pov_decompression_failure_is_invalid() {
 	let candidate_receipt = CandidateReceipt { descriptor, commitments_hash: Hash::zero() };
 
 	let pool = TaskExecutor::new();
-	let (_ctx, _ctx_handle) = test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (_ctx, _ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let v = executor::block_on(validate_candidate_exhaustive(
 		MockValidateCandidateBackend::with_hardcoded_result(Ok(validation_result)),
@@ -1062,8 +1080,10 @@ fn precheck_works() {
 	let validation_code_hash = validation_code.hash();
 
 	let pool = TaskExecutor::new();
-	let (mut ctx, mut ctx_handle) =
-		test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let (check_fut, check_result) = precheck_pvf(
 		ctx.sender(),
@@ -1124,8 +1144,10 @@ fn precheck_invalid_pvf_blob_compression() {
 	let validation_code_hash = validation_code.hash();
 
 	let pool = TaskExecutor::new();
-	let (mut ctx, mut ctx_handle) =
-		test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+	let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+		AllMessages,
+		_,
+	>(pool.clone());
 
 	let (check_fut, check_result) = precheck_pvf(
 		ctx.sender(),
@@ -1183,7 +1205,9 @@ fn precheck_properly_classifies_outcomes() {
 
 		let pool = TaskExecutor::new();
 		let (mut ctx, mut ctx_handle) =
-			test_helpers::make_subsystem_context::<AllMessages, _>(pool.clone());
+			polkadot_node_subsystem_test_helpers::make_subsystem_context::<AllMessages, _>(
+				pool.clone(),
+			);
 
 		let (check_fut, check_result) = precheck_pvf(
 			ctx.sender(),
diff --git a/polkadot/node/core/chain-api/Cargo.toml b/polkadot/node/core/chain-api/Cargo.toml
index bd8531c207847142a3b2ecd4407ef11253251034..c58024876b9c77c371b9325c9da922a21211e698 100644
--- a/polkadot/node/core/chain-api/Cargo.toml
+++ b/polkadot/node/core/chain-api/Cargo.toml
@@ -21,7 +21,7 @@ sc-consensus-babe = { path = "../../../../substrate/client/consensus/babe" }
 [dev-dependencies]
 futures = { version = "0.3.30", features = ["thread-pool"] }
 maplit = "1.0.2"
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 polkadot-node-primitives = { path = "../../primitives" }
 polkadot-primitives = { path = "../../../primitives" }
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
diff --git a/polkadot/node/core/chain-api/src/tests.rs b/polkadot/node/core/chain-api/src/tests.rs
index eae8f6fa4ac591c565930047e4dcf590c914947f..4e85affc540fb1120222745dc9f7ddd5b1a7aacb 100644
--- a/polkadot/node/core/chain-api/src/tests.rs
+++ b/polkadot/node/core/chain-api/src/tests.rs
@@ -16,8 +16,8 @@
 
 use super::*;
 
+use codec::Encode;
 use futures::{channel::oneshot, future::BoxFuture};
-use parity_scale_codec::Encode;
 use std::collections::BTreeMap;
 
 use polkadot_node_primitives::BlockWeight;
diff --git a/polkadot/node/core/chain-selection/Cargo.toml b/polkadot/node/core/chain-selection/Cargo.toml
index b58053b5417eceb0bddfc2f34df5f1d84126c1c0..2aa929653ccc2a2fa07b16a7ad0a4ada025afb5a 100644
--- a/polkadot/node/core/chain-selection/Cargo.toml
+++ b/polkadot/node/core/chain-selection/Cargo.toml
@@ -19,7 +19,7 @@ polkadot-node-subsystem = { path = "../../subsystem" }
 polkadot-node-subsystem-util = { path = "../../subsystem-util" }
 kvdb = "0.13.0"
 thiserror = { workspace = true }
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 
 [dev-dependencies]
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
diff --git a/polkadot/node/core/chain-selection/src/db_backend/v1.rs b/polkadot/node/core/chain-selection/src/db_backend/v1.rs
index 7c7144bb763dfbf02adfcb958d18a97b6a96dbb8..8831b1e3c36cc1782036a7b5668bbdd0024bfed9 100644
--- a/polkadot/node/core/chain-selection/src/db_backend/v1.rs
+++ b/polkadot/node/core/chain-selection/src/db_backend/v1.rs
@@ -40,7 +40,7 @@ use crate::{
 use polkadot_node_primitives::BlockWeight;
 use polkadot_primitives::{BlockNumber, Hash};
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_subsystem_util::database::{DBTransaction, Database};
 
 use std::sync::Arc;
diff --git a/polkadot/node/core/chain-selection/src/lib.rs b/polkadot/node/core/chain-selection/src/lib.rs
index 07c245e839bf18a55f5ec61f02824fa87e9c6ed9..6c091b02709b777cdf75a021799e2b9538d606c4 100644
--- a/polkadot/node/core/chain-selection/src/lib.rs
+++ b/polkadot/node/core/chain-selection/src/lib.rs
@@ -26,8 +26,8 @@ use polkadot_node_subsystem::{
 use polkadot_node_subsystem_util::database::Database;
 use polkadot_primitives::{BlockNumber, ConsensusLog, Hash, Header};
 
+use codec::Error as CodecError;
 use futures::{channel::oneshot, future::Either, prelude::*};
-use parity_scale_codec::Error as CodecError;
 
 use std::{
 	sync::Arc,
diff --git a/polkadot/node/core/chain-selection/src/tests.rs b/polkadot/node/core/chain-selection/src/tests.rs
index 1fe87f04cd585abc1674d3a20766e7172fd819fa..2b1e1196ede334f6c6eac6cd08e46665c6d043cf 100644
--- a/polkadot/node/core/chain-selection/src/tests.rs
+++ b/polkadot/node/core/chain-selection/src/tests.rs
@@ -30,8 +30,8 @@ use std::{
 };
 
 use assert_matches::assert_matches;
+use codec::Encode;
 use futures::channel::oneshot;
-use parity_scale_codec::Encode;
 use parking_lot::Mutex;
 use sp_core::testing::TaskExecutor;
 
@@ -229,13 +229,15 @@ impl Clock for TestClock {
 
 const TEST_STAGNANT_INTERVAL: Duration = Duration::from_millis(20);
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<ChainSelectionMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<ChainSelectionMessage>;
 
 fn test_harness<T: Future<Output = VirtualOverseer>>(
 	test: impl FnOnce(TestBackend, TestClock, VirtualOverseer) -> T,
 ) {
 	let pool = TaskExecutor::new();
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool);
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool);
 
 	let backend = TestBackend::default();
 	let clock = TestClock::new(0);
diff --git a/polkadot/node/core/dispute-coordinator/Cargo.toml b/polkadot/node/core/dispute-coordinator/Cargo.toml
index 8bd510697c913f10020605d335fb1748a2bb43c3..2c08cfa9b1efa623ae157c6fd60f10c9330d30d2 100644
--- a/polkadot/node/core/dispute-coordinator/Cargo.toml
+++ b/polkadot/node/core/dispute-coordinator/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 [dependencies]
 futures = "0.3.30"
 gum = { package = "tracing-gum", path = "../../gum" }
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 kvdb = "0.13.0"
 thiserror = { workspace = true }
 schnellru = "0.2.1"
@@ -33,7 +33,7 @@ sp-keyring = { path = "../../../../substrate/primitives/keyring" }
 sp-core = { path = "../../../../substrate/primitives/core" }
 sp-keystore = { path = "../../../../substrate/primitives/keystore" }
 assert_matches = "1.4.0"
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
 futures-timer = "3.0.2"
 sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" }
 sp-tracing = { path = "../../../../substrate/primitives/tracing" }
diff --git a/polkadot/node/core/dispute-coordinator/src/db/v1.rs b/polkadot/node/core/dispute-coordinator/src/db/v1.rs
index 4950765cf510c047b811f50d0459c0add4c75d78..0101791550ee8192e705c84e06dbe9d269970fec 100644
--- a/polkadot/node/core/dispute-coordinator/src/db/v1.rs
+++ b/polkadot/node/core/dispute-coordinator/src/db/v1.rs
@@ -31,7 +31,7 @@ use polkadot_primitives::{
 
 use std::sync::Arc;
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 use crate::{
 	backend::{Backend, BackendWriteOp, OverlayedBackend},
@@ -258,7 +258,7 @@ pub enum Error {
 	#[error(transparent)]
 	Io(#[from] std::io::Error),
 	#[error(transparent)]
-	Codec(#[from] parity_scale_codec::Error),
+	Codec(#[from] codec::Error),
 }
 
 impl From<Error> for crate::error::Error {
@@ -375,9 +375,9 @@ fn load_cleaned_votes_watermark(
 mod tests {
 
 	use super::*;
-	use ::test_helpers::{dummy_candidate_receipt, dummy_hash};
 	use polkadot_node_primitives::DISPUTE_WINDOW;
 	use polkadot_primitives::{Hash, Id as ParaId};
+	use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash};
 
 	fn make_db() -> DbBackend {
 		let db = kvdb_memorydb::create(1);
diff --git a/polkadot/node/core/dispute-coordinator/src/error.rs b/polkadot/node/core/dispute-coordinator/src/error.rs
index cbda3dc1d121a622f38848d32afb389d82e01ed9..94bc8e9c9497e31bafaea512a7990523b342099d 100644
--- a/polkadot/node/core/dispute-coordinator/src/error.rs
+++ b/polkadot/node/core/dispute-coordinator/src/error.rs
@@ -21,7 +21,7 @@ use polkadot_node_subsystem::{errors::ChainApiError, SubsystemError};
 use polkadot_node_subsystem_util::runtime;
 
 use crate::{db, participation, LOG_TARGET};
-use parity_scale_codec::Error as CodecError;
+use codec::Error as CodecError;
 
 pub type Result<T> = std::result::Result<T, Error>;
 pub type FatalResult<T> = std::result::Result<T, FatalError>;
diff --git a/polkadot/node/core/dispute-coordinator/src/participation/mod.rs b/polkadot/node/core/dispute-coordinator/src/participation/mod.rs
index 05ea7323af1419d770cb7b68e15ee7887ceeaab8..b58ce570f8fff767a975487364cc6fe826c329e3 100644
--- a/polkadot/node/core/dispute-coordinator/src/participation/mod.rs
+++ b/polkadot/node/core/dispute-coordinator/src/participation/mod.rs
@@ -305,6 +305,7 @@ async fn participate(
 			req.candidate_receipt().clone(),
 			req.session(),
 			None,
+			None,
 			recover_available_data_tx,
 		))
 		.await;
diff --git a/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs b/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs
index 63bfc1d7d026cc7ae406f138d332d42b56fb5949..9176d00b2f5c4ed25166f9c10d0718678653ec5d 100644
--- a/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs
+++ b/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs
@@ -15,9 +15,9 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::{metrics::Metrics, ParticipationPriority};
-use ::test_helpers::{dummy_candidate_receipt, dummy_hash};
 use assert_matches::assert_matches;
 use polkadot_primitives::{BlockNumber, Hash};
+use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash};
 
 use super::{CandidateComparator, ParticipationRequest, QueueError, Queues};
 
diff --git a/polkadot/node/core/dispute-coordinator/src/participation/tests.rs b/polkadot/node/core/dispute-coordinator/src/participation/tests.rs
index 367454115f0be8e9aaccaf73b13e721a585c9dd7..a80553828ac69184d89695a3fe4ccc716e11b83f 100644
--- a/polkadot/node/core/dispute-coordinator/src/participation/tests.rs
+++ b/polkadot/node/core/dispute-coordinator/src/participation/tests.rs
@@ -22,10 +22,7 @@ use std::{sync::Arc, time::Duration};
 use sp_core::testing::TaskExecutor;
 
 use super::*;
-use ::test_helpers::{
-	dummy_candidate_commitments, dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash,
-};
-use parity_scale_codec::Encode;
+use codec::Encode;
 use polkadot_node_primitives::{AvailableData, BlockData, InvalidCandidate, PoV};
 use polkadot_node_subsystem::{
 	messages::{
@@ -40,6 +37,9 @@ use polkadot_node_subsystem_test_helpers::{
 use polkadot_primitives::{
 	BlakeTwo256, CandidateCommitments, HashT, Header, PersistedValidationData, ValidationCode,
 };
+use polkadot_primitives_test_helpers::{
+	dummy_candidate_commitments, dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash,
+};
 
 type VirtualOverseer = TestSubsystemContextHandle<DisputeCoordinatorMessage>;
 
@@ -132,7 +132,7 @@ pub async fn participation_missing_availability(ctx_handle: &mut VirtualOverseer
 	assert_matches!(
 		ctx_handle.recv().await,
 		AllMessages::AvailabilityRecovery(
-			AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx)
+			AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx)
 		) => {
 			tx.send(Err(RecoveryError::Unavailable)).unwrap();
 		},
@@ -151,7 +151,7 @@ async fn recover_available_data(virtual_overseer: &mut VirtualOverseer) {
 	assert_matches!(
 		virtual_overseer.recv().await,
 		AllMessages::AvailabilityRecovery(
-			AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx)
+			AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx)
 		) => {
 			tx.send(Ok(available_data)).unwrap();
 		},
@@ -195,7 +195,7 @@ fn same_req_wont_get_queued_if_participation_is_already_running() {
 		assert_matches!(
 			ctx_handle.recv().await,
 			AllMessages::AvailabilityRecovery(
-				AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx)
+				AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx)
 			) => {
 				tx.send(Err(RecoveryError::Unavailable)).unwrap();
 			},
@@ -260,7 +260,7 @@ fn reqs_get_queued_when_out_of_capacity() {
 		{
 			match ctx_handle.recv().await {
 				AllMessages::AvailabilityRecovery(
-					AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx),
+					AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx),
 				) => {
 					tx.send(Err(RecoveryError::Unavailable)).unwrap();
 					recover_available_data_msg_count += 1;
@@ -346,7 +346,7 @@ fn cannot_participate_if_cannot_recover_available_data() {
 		assert_matches!(
 			ctx_handle.recv().await,
 			AllMessages::AvailabilityRecovery(
-				AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx)
+				AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx)
 			) => {
 				tx.send(Err(RecoveryError::Unavailable)).unwrap();
 			},
@@ -412,7 +412,7 @@ fn cast_invalid_vote_if_available_data_is_invalid() {
 		assert_matches!(
 			ctx_handle.recv().await,
 			AllMessages::AvailabilityRecovery(
-				AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx)
+				AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx)
 			) => {
 				tx.send(Err(RecoveryError::Invalid)).unwrap();
 			},
diff --git a/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs b/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs
index 726dda596d7b8be26da55358c95c9080ec89d962..ed2400387ef7f52693c3ab9d6f35f69234caab99 100644
--- a/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs
+++ b/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs
@@ -18,11 +18,10 @@ use std::time::Duration;
 
 use assert_matches::assert_matches;
 
+use codec::Encode;
 use futures::future::join;
-use parity_scale_codec::Encode;
 use sp_core::testing::TaskExecutor;
 
-use ::test_helpers::{dummy_collator, dummy_collator_signature, dummy_hash};
 use polkadot_node_primitives::DISPUTE_CANDIDATE_LIFETIME_AFTER_FINALIZATION;
 use polkadot_node_subsystem::{
 	messages::{
@@ -40,6 +39,7 @@ use polkadot_primitives::{
 	BlakeTwo256, BlockNumber, CandidateDescriptor, CandidateEvent, CandidateReceipt, CoreIndex,
 	GroupIndex, Hash, HashT, HeadData, Id as ParaId,
 };
+use polkadot_primitives_test_helpers::{dummy_collator, dummy_collator_signature, dummy_hash};
 
 use crate::{scraping::Inclusions, LOG_TARGET};
 
diff --git a/polkadot/node/core/dispute-coordinator/src/tests.rs b/polkadot/node/core/dispute-coordinator/src/tests.rs
index 13cf2df88223ead28dcd98aeaa3c36db13444991..f97a625a9528e1d6034500ee1e2fd2447af98de4 100644
--- a/polkadot/node/core/dispute-coordinator/src/tests.rs
+++ b/polkadot/node/core/dispute-coordinator/src/tests.rs
@@ -51,7 +51,6 @@ use sp_core::{sr25519::Pair, testing::TaskExecutor, Pair as PairT};
 use sp_keyring::Sr25519Keyring;
 use sp_keystore::{Keystore, KeystorePtr};
 
-use ::test_helpers::{dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash};
 use polkadot_node_primitives::{Timestamp, ACTIVE_DURATION_SECS};
 use polkadot_node_subsystem::{
 	messages::{AllMessages, BlockDescription, RuntimeApiMessage, RuntimeApiRequest},
@@ -67,6 +66,7 @@ use polkadot_primitives::{
 	SessionInfo, SigningContext, ValidDisputeStatementKind, ValidatorId, ValidatorIndex,
 	ValidatorSignature,
 };
+use polkadot_primitives_test_helpers::{dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash};
 
 use crate::{
 	backend::Backend,
diff --git a/polkadot/node/core/prospective-parachains/Cargo.toml b/polkadot/node/core/prospective-parachains/Cargo.toml
index 5b4f12a5fbdaffd345cc8f01d92691232deb5046..b9573ee9851908fdcb77bc44bd21a83566ecaeb5 100644
--- a/polkadot/node/core/prospective-parachains/Cargo.toml
+++ b/polkadot/node/core/prospective-parachains/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 [dependencies]
 futures = "0.3.30"
 gum = { package = "tracing-gum", path = "../../gum" }
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 thiserror = { workspace = true }
 fatality = "0.1.1"
 bitvec = "1"
@@ -32,3 +32,4 @@ sc-keystore = { path = "../../../../substrate/client/keystore" }
 sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" }
 sp-keyring = { path = "../../../../substrate/primitives/keyring" }
 sp-keystore = { path = "../../../../substrate/primitives/keystore" }
+rstest = "0.18.2"
diff --git a/polkadot/node/core/prospective-parachains/src/lib.rs b/polkadot/node/core/prospective-parachains/src/lib.rs
index d5bb5ff76ba8e8e603f2ab6b915b6c8fdb2d5f3c..e4b6deffdf4a5280e23c8c4a81bdf2ae56bbb422 100644
--- a/polkadot/node/core/prospective-parachains/src/lib.rs
+++ b/polkadot/node/core/prospective-parachains/src/lib.rs
@@ -44,6 +44,7 @@ use polkadot_node_subsystem_util::{
 	inclusion_emulator::{Constraints, RelayChainBlockInfo},
 	request_session_index_for_child,
 	runtime::{prospective_parachains_mode, ProspectiveParachainsMode},
+	vstaging::fetch_claim_queue,
 };
 use polkadot_primitives::{
 	async_backing::CandidatePendingAvailability, BlockNumber, CandidateHash,
@@ -870,37 +871,51 @@ async fn fetch_backing_state<Context>(
 async fn fetch_upcoming_paras<Context>(
 	ctx: &mut Context,
 	relay_parent: Hash,
-) -> JfyiErrorResult<Vec<ParaId>> {
-	let (tx, rx) = oneshot::channel();
-
-	// This'll have to get more sophisticated with parathreads,
-	// but for now we can just use the `AvailabilityCores`.
-	ctx.send_message(RuntimeApiMessage::Request(
-		relay_parent,
-		RuntimeApiRequest::AvailabilityCores(tx),
-	))
-	.await;
-
-	let cores = rx.await.map_err(JfyiError::RuntimeApiRequestCanceled)??;
-	let mut upcoming = HashSet::new();
-	for core in cores {
-		match core {
-			CoreState::Occupied(occupied) => {
-				if let Some(next_up_on_available) = occupied.next_up_on_available {
-					upcoming.insert(next_up_on_available.para_id);
-				}
-				if let Some(next_up_on_time_out) = occupied.next_up_on_time_out {
-					upcoming.insert(next_up_on_time_out.para_id);
+) -> JfyiErrorResult<HashSet<ParaId>> {
+	Ok(match fetch_claim_queue(ctx.sender(), relay_parent).await? {
+		Some(claim_queue) => {
+			// Runtime supports claim queue - use it
+			claim_queue
+				.iter_all_claims()
+				.flat_map(|(_, paras)| paras.into_iter())
+				.copied()
+				.collect()
+		},
+		None => {
+			// fallback to availability cores - remove this branch once claim queue is released
+			// everywhere
+			let (tx, rx) = oneshot::channel();
+			ctx.send_message(RuntimeApiMessage::Request(
+				relay_parent,
+				RuntimeApiRequest::AvailabilityCores(tx),
+			))
+			.await;
+
+			let cores = rx.await.map_err(JfyiError::RuntimeApiRequestCanceled)??;
+
+			let mut upcoming = HashSet::with_capacity(cores.len());
+			for core in cores {
+				match core {
+					CoreState::Occupied(occupied) => {
+						// core sharing won't work optimally with this branch because the collations
+						// can't be prepared in advance.
+						if let Some(next_up_on_available) = occupied.next_up_on_available {
+							upcoming.insert(next_up_on_available.para_id);
+						}
+						if let Some(next_up_on_time_out) = occupied.next_up_on_time_out {
+							upcoming.insert(next_up_on_time_out.para_id);
+						}
+					},
+					CoreState::Scheduled(scheduled) => {
+						upcoming.insert(scheduled.para_id);
+					},
+					CoreState::Free => {},
 				}
-			},
-			CoreState::Scheduled(scheduled) => {
-				upcoming.insert(scheduled.para_id);
-			},
-			CoreState::Free => {},
-		}
-	}
+			}
 
-	Ok(upcoming.into_iter().collect())
+			upcoming
+		},
+	})
 }
 
 // Fetch ancestors in descending order, up to the amount requested.
diff --git a/polkadot/node/core/prospective-parachains/src/tests.rs b/polkadot/node/core/prospective-parachains/src/tests.rs
index 4bc47367278864e6f5e7136fe07a4fe1d1be88a5..221fbf4c4e60365855b24bcfff7d89cfbcc6d205 100644
--- a/polkadot/node/core/prospective-parachains/src/tests.rs
+++ b/polkadot/node/core/prospective-parachains/src/tests.rs
@@ -26,11 +26,15 @@ use polkadot_node_subsystem::{
 use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_primitives::{
 	async_backing::{AsyncBackingParams, BackingState, Constraints, InboundHrmpLimitations},
-	CommittedCandidateReceipt, HeadData, Header, PersistedValidationData, ScheduledCore,
+	CommittedCandidateReceipt, CoreIndex, HeadData, Header, PersistedValidationData, ScheduledCore,
 	ValidationCodeHash,
 };
 use polkadot_primitives_test_helpers::make_candidate;
-use std::sync::Arc;
+use rstest::rstest;
+use std::{
+	collections::{BTreeMap, VecDeque},
+	sync::Arc,
+};
 use test_helpers::mock::new_leaf;
 
 const ALLOWED_ANCESTRY_LEN: u32 = 3;
@@ -42,7 +46,8 @@ const ASYNC_BACKING_DISABLED_ERROR: RuntimeApiError =
 
 const MAX_POV_SIZE: u32 = 1_000_000;
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<ProspectiveParachainsMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<ProspectiveParachainsMessage>;
 
 fn dummy_constraints(
 	min_relay_parent_number: BlockNumber,
@@ -69,7 +74,8 @@ fn dummy_constraints(
 }
 
 struct TestState {
-	availability_cores: Vec<CoreState>,
+	claim_queue: BTreeMap<CoreIndex, VecDeque<ParaId>>,
+	runtime_api_version: u32,
 	validation_code_hash: ValidationCodeHash,
 }
 
@@ -78,13 +84,23 @@ impl Default for TestState {
 		let chain_a = ParaId::from(1);
 		let chain_b = ParaId::from(2);
 
-		let availability_cores = vec![
-			CoreState::Scheduled(ScheduledCore { para_id: chain_a, collator: None }),
-			CoreState::Scheduled(ScheduledCore { para_id: chain_b, collator: None }),
-		];
+		let mut claim_queue = BTreeMap::new();
+		claim_queue.insert(CoreIndex(0), [chain_a].into_iter().collect());
+		claim_queue.insert(CoreIndex(1), [chain_b].into_iter().collect());
+
 		let validation_code_hash = Hash::repeat_byte(42).into();
 
-		Self { availability_cores, validation_code_hash }
+		Self {
+			validation_code_hash,
+			claim_queue,
+			runtime_api_version: RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT,
+		}
+	}
+}
+
+impl TestState {
+	fn set_runtime_api_version(&mut self, version: u32) {
+		self.runtime_api_version = version;
 	}
 }
 
@@ -97,7 +113,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 ) -> View {
 	let pool = sp_core::testing::TaskExecutor::new();
 
-	let (mut context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (mut context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let mut view = View::new();
 	let subsystem = async move {
@@ -225,12 +242,39 @@ async fn handle_leaf_activation(
 	assert_matches!(
 		virtual_overseer.recv().await,
 		AllMessages::RuntimeApi(
-			RuntimeApiMessage::Request(parent, RuntimeApiRequest::AvailabilityCores(tx))
+			RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx))
 		) if parent == *hash => {
-			tx.send(Ok(test_state.availability_cores.clone())).unwrap();
+			tx.send(
+				Ok(test_state.runtime_api_version)
+			).unwrap();
 		}
 	);
 
+	if test_state.runtime_api_version < RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT {
+		assert_matches!(
+			virtual_overseer.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(parent, RuntimeApiRequest::AvailabilityCores(tx))
+			) if parent == *hash => {
+				tx.send(Ok(test_state.claim_queue.values().map(|paras| CoreState::Scheduled(
+					ScheduledCore {
+						para_id: *paras.front().unwrap(),
+						collator: None
+					}
+				)).collect())).unwrap();
+			}
+		);
+	} else {
+		assert_matches!(
+			virtual_overseer.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx))
+			) if parent == *hash => {
+				tx.send(Ok(test_state.claim_queue.clone())).unwrap();
+			}
+		);
+	}
+
 	send_block_header(virtual_overseer, *hash, *number).await;
 
 	// Check that subsystem job issues a request for ancestors.
@@ -275,14 +319,16 @@ async fn handle_leaf_activation(
 		);
 	}
 
-	for _ in 0..test_state.availability_cores.len() {
+	let paras: HashSet<_> = test_state.claim_queue.values().flatten().collect();
+
+	for _ in 0..paras.len() {
 		let message = virtual_overseer.recv().await;
 		// Get the para we are working with since the order is not deterministic.
-		let para_id = match message {
+		let para_id = match &message {
 			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
 				_,
 				RuntimeApiRequest::ParaBackingState(p_id, _),
-			)) => p_id,
+			)) => *p_id,
 			_ => panic!("received unexpected message {:?}", message),
 		};
 
@@ -503,9 +549,18 @@ fn should_do_no_work_if_async_backing_disabled_for_leaf() {
 // - Two for the same leaf A (one for parachain 1 and one for parachain 2)
 // - One for leaf B on parachain 1
 // - One for leaf C on parachain 2
+// Also tests a claim queue size larger than 1.
 #[test]
 fn introduce_candidates_basic() {
-	let test_state = TestState::default();
+	let mut test_state = TestState::default();
+
+	let chain_a = ParaId::from(1);
+	let chain_b = ParaId::from(2);
+	let mut claim_queue = BTreeMap::new();
+	claim_queue.insert(CoreIndex(0), [chain_a, chain_b].into_iter().collect());
+
+	test_state.claim_queue = claim_queue;
+
 	let view = test_harness(|mut virtual_overseer| async move {
 		// Leaf A
 		let leaf_a = TestLeaf {
@@ -2030,9 +2085,15 @@ fn check_pvd_query() {
 
 // Test simultaneously activating and deactivating leaves, and simultaneously deactivating
 // multiple leaves.
-#[test]
-fn correctly_updates_leaves() {
-	let test_state = TestState::default();
+// This test is parametrised with the runtime api version. For versions that don't support the claim
+// queue API, we check that av-cores are used.
+#[rstest]
+#[case(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)]
+#[case(8)]
+fn correctly_updates_leaves(#[case] runtime_api_version: u32) {
+	let mut test_state = TestState::default();
+	test_state.set_runtime_api_version(runtime_api_version);
+
 	let view = test_harness(|mut virtual_overseer| async move {
 		// Leaf A
 		let leaf_a = TestLeaf {
@@ -2138,15 +2199,12 @@ fn correctly_updates_leaves() {
 fn persists_pending_availability_candidate() {
 	let mut test_state = TestState::default();
 	let para_id = ParaId::from(1);
-	test_state.availability_cores = test_state
-		.availability_cores
+	test_state.claim_queue = test_state
+		.claim_queue
 		.into_iter()
-		.filter(|core| match core {
-			CoreState::Scheduled(scheduled_core) => scheduled_core.para_id == para_id,
-			_ => false,
-		})
+		.filter(|(_, paras)| matches!(paras.front(), Some(para) if para == &para_id))
 		.collect();
-	assert_eq!(test_state.availability_cores.len(), 1);
+	assert_eq!(test_state.claim_queue.len(), 1);
 
 	test_harness(|mut virtual_overseer| async move {
 		let para_head = HeadData(vec![1, 2, 3]);
@@ -2235,18 +2293,15 @@ fn persists_pending_availability_candidate() {
 }
 
 #[test]
-fn backwards_compatible() {
+fn backwards_compatible_with_non_async_backing_params() {
 	let mut test_state = TestState::default();
 	let para_id = ParaId::from(1);
-	test_state.availability_cores = test_state
-		.availability_cores
+	test_state.claim_queue = test_state
+		.claim_queue
 		.into_iter()
-		.filter(|core| match core {
-			CoreState::Scheduled(scheduled_core) => scheduled_core.para_id == para_id,
-			_ => false,
-		})
+		.filter(|(_, paras)| matches!(paras.front(), Some(para) if para == &para_id))
 		.collect();
-	assert_eq!(test_state.availability_cores.len(), 1);
+	assert_eq!(test_state.claim_queue.len(), 1);
 
 	test_harness(|mut virtual_overseer| async move {
 		let para_head = HeadData(vec![1, 2, 3]);
@@ -2348,20 +2403,30 @@ fn uses_ancestry_only_within_session() {
 			.await;
 
 		assert_matches!(
-					virtual_overseer.recv().await,
-					AllMessages::RuntimeApi(
-						RuntimeApiMessage::Request(parent, RuntimeApiRequest::AsyncBackingParams(tx))
-					) if parent == hash => {
-						tx.send(Ok(AsyncBackingParams { max_candidate_depth: 0, allowed_ancestry_len: ancestry_len
-		})).unwrap(); 			}
-				);
+		virtual_overseer.recv().await,
+		AllMessages::RuntimeApi(
+			RuntimeApiMessage::Request(
+				parent,
+				RuntimeApiRequest::AsyncBackingParams(tx)
+			)) if parent == hash => {
+				tx.send(Ok(AsyncBackingParams { max_candidate_depth: 0, allowed_ancestry_len: ancestry_len})).unwrap();
+		});
 
 		assert_matches!(
 			virtual_overseer.recv().await,
 			AllMessages::RuntimeApi(
-				RuntimeApiMessage::Request(parent, RuntimeApiRequest::AvailabilityCores(tx))
+				RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx))
+			) if parent == hash => {
+				tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap();
+			}
+		);
+
+		assert_matches!(
+			virtual_overseer.recv().await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx))
 			) if parent == hash => {
-				tx.send(Ok(Vec::new())).unwrap();
+				tx.send(Ok(BTreeMap::new())).unwrap();
 			}
 		);
 
diff --git a/polkadot/node/core/provisioner/Cargo.toml b/polkadot/node/core/provisioner/Cargo.toml
index d197832126442cd7bf67236395cfcc5800f00153..a81d22c6f82838c2d446a7d8cd0997013f161fa3 100644
--- a/polkadot/node/core/provisioner/Cargo.toml
+++ b/polkadot/node/core/provisioner/Cargo.toml
@@ -26,5 +26,5 @@ schnellru = "0.2.1"
 sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" }
 sp-keystore = { path = "../../../../substrate/primitives/keystore" }
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
 rstest = "0.18.2"
diff --git a/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs b/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs
index f6c49e52eeb981d6a6a22a6d9a85301933d3fde4..ecb7aac78396c8769170ca720addf91f056e09bc 100644
--- a/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs
+++ b/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs
@@ -29,7 +29,6 @@ use polkadot_primitives::{
 	CandidateHash, DisputeState, InvalidDisputeStatementKind, SessionIndex,
 	ValidDisputeStatementKind, ValidatorSignature,
 };
-use test_helpers;
 
 //
 // Unit tests for various functions
@@ -428,7 +427,7 @@ impl TestDisputes {
 		let onchain_votes_count = self.validators_count * 80 / 100;
 		let session_idx = 0;
 		let lf = leaf();
-		let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash);
+		let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash);
 		for _ in 0..dispute_count {
 			let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active);
 			self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone());
@@ -446,7 +445,7 @@ impl TestDisputes {
 		let onchain_votes_count = self.validators_count * 40 / 100;
 		let session_idx = 1;
 		let lf = leaf();
-		let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash);
+		let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash);
 		for _ in 0..dispute_count {
 			let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active);
 			self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone());
@@ -463,7 +462,7 @@ impl TestDisputes {
 		let local_votes_count = self.validators_count * 90 / 100;
 		let session_idx = 2;
 		let lf = leaf();
-		let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash);
+		let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash);
 		for _ in 0..dispute_count {
 			let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Confirmed);
 			self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone());
@@ -479,7 +478,7 @@ impl TestDisputes {
 		let onchain_votes_count = self.validators_count * 75 / 100;
 		let session_idx = 3;
 		let lf = leaf();
-		let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash);
+		let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash);
 		for _ in 0..dispute_count {
 			let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::ConcludedFor(0));
 			self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone());
@@ -495,7 +494,7 @@ impl TestDisputes {
 		let local_votes_count = self.validators_count * 90 / 100;
 		let session_idx = 4;
 		let lf = leaf();
-		let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash);
+		let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash);
 		for _ in 0..dispute_count {
 			let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::ConcludedFor(0));
 			self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone());
@@ -511,7 +510,7 @@ impl TestDisputes {
 		let onchain_votes_count = self.validators_count * 10 / 100;
 		let session_idx = 5;
 		let lf = leaf();
-		let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash);
+		let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash);
 		for _ in 0..dispute_count {
 			let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active);
 			self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone());
@@ -528,7 +527,7 @@ impl TestDisputes {
 		let local_votes_count = self.validators_count * 10 / 100;
 		let session_idx = 6;
 		let lf = leaf();
-		let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash);
+		let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash);
 		for _ in 0..dispute_count {
 			let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active);
 			self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone());
@@ -547,7 +546,7 @@ impl TestDisputes {
 			.map(|idx| {
 				(
 					ValidatorIndex(idx as u32),
-					(statement_kind.clone(), test_helpers::dummy_signature()),
+					(statement_kind.clone(), polkadot_primitives_test_helpers::dummy_signature()),
 				)
 			})
 			.collect::<BTreeMap<_, _>>()
diff --git a/polkadot/node/core/provisioner/src/tests.rs b/polkadot/node/core/provisioner/src/tests.rs
index d463b7f1663374618621d5ffb3a491feeab69ddc..0d3675777cbf4ad0ef6620ae05b1b0bdab11cdb9 100644
--- a/polkadot/node/core/provisioner/src/tests.rs
+++ b/polkadot/node/core/provisioner/src/tests.rs
@@ -15,9 +15,9 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::*;
-use ::test_helpers::{dummy_candidate_descriptor, dummy_hash};
 use bitvec::bitvec;
 use polkadot_primitives::{OccupiedCore, ScheduledCore};
+use polkadot_primitives_test_helpers::{dummy_candidate_descriptor, dummy_hash};
 
 const MOCK_GROUP_SIZE: usize = 5;
 
@@ -244,7 +244,6 @@ mod select_candidates {
 		super::*, build_occupied_core, common::test_harness, default_bitvec, occupied_core,
 		scheduled_core, MOCK_GROUP_SIZE,
 	};
-	use ::test_helpers::{dummy_candidate_descriptor, dummy_hash};
 	use futures::channel::mpsc;
 	use polkadot_node_subsystem::messages::{
 		AllMessages, RuntimeApiMessage,
@@ -257,6 +256,7 @@ mod select_candidates {
 	use polkadot_primitives::{
 		BlockNumber, CandidateCommitments, CommittedCandidateReceipt, PersistedValidationData,
 	};
+	use polkadot_primitives_test_helpers::{dummy_candidate_descriptor, dummy_hash};
 	use rstest::rstest;
 	use std::ops::Not;
 	use CoreState::{Free, Scheduled};
diff --git a/polkadot/node/core/pvf-checker/Cargo.toml b/polkadot/node/core/pvf-checker/Cargo.toml
index 91b12b8680977fba345e0ccfa9b06f1bcb24ef79..6dec407e2d2d1f91bcdf72b73b1db376dcdd07d5 100644
--- a/polkadot/node/core/pvf-checker/Cargo.toml
+++ b/polkadot/node/core/pvf-checker/Cargo.toml
@@ -28,6 +28,6 @@ sp-runtime = { path = "../../../../substrate/primitives/runtime" }
 sc-keystore = { path = "../../../../substrate/client/keystore" }
 sp-keyring = { path = "../../../../substrate/primitives/keyring" }
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
 sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" }
 futures-timer = "3.0.2"
diff --git a/polkadot/node/core/pvf-checker/src/tests.rs b/polkadot/node/core/pvf-checker/src/tests.rs
index b2365fe53e52c0f2e1c7cb18768c33cdd6801ca9..e12a44ddd2afc3f253063875b78b96d7f414116e 100644
--- a/polkadot/node/core/pvf-checker/src/tests.rs
+++ b/polkadot/node/core/pvf-checker/src/tests.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use ::test_helpers::{dummy_digest, dummy_hash, validator_pubkeys};
 use futures::{channel::oneshot, future::BoxFuture, prelude::*};
 use polkadot_node_subsystem::{
 	messages::{
@@ -30,6 +29,7 @@ use polkadot_primitives::{
 	BlockNumber, Hash, Header, PvfCheckStatement, SessionIndex, ValidationCode, ValidationCodeHash,
 	ValidatorId,
 };
+use polkadot_primitives_test_helpers::{dummy_digest, dummy_hash, validator_pubkeys};
 use sp_application_crypto::AppCrypto;
 use sp_core::testing::TaskExecutor;
 use sp_keyring::Sr25519Keyring;
diff --git a/polkadot/node/core/pvf/Cargo.toml b/polkadot/node/core/pvf/Cargo.toml
index ba9954a10668e154ee44cccc9888a6e3d3c5ed09..8aebe0b4c3f0c3875781ed537eadd4887ccf856b 100644
--- a/polkadot/node/core/pvf/Cargo.toml
+++ b/polkadot/node/core/pvf/Cargo.toml
@@ -25,7 +25,7 @@ tempfile = "3.3.0"
 thiserror = { workspace = true }
 tokio = { version = "1.24.2", features = ["fs", "process"] }
 
-parity-scale-codec = { version = "3.6.12", default-features = false, features = [
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
 	"derive",
 ] }
 
@@ -56,8 +56,8 @@ polkadot-node-core-pvf-common = { path = "common", features = ["test-utils"] }
 polkadot-node-core-pvf = { path = "", features = ["test-utils"] }
 rococo-runtime = { path = "../../../runtime/rococo" }
 
-adder = { package = "test-parachain-adder", path = "../../../parachain/test-parachains/adder" }
-halt = { package = "test-parachain-halt", path = "../../../parachain/test-parachains/halt" }
+test-parachain-adder = { path = "../../../parachain/test-parachains/adder" }
+test-parachain-halt = { path = "../../../parachain/test-parachains/halt" }
 
 [target.'cfg(target_os = "linux")'.dev-dependencies]
 libc = "0.2.153"
diff --git a/polkadot/node/core/pvf/common/Cargo.toml b/polkadot/node/core/pvf/common/Cargo.toml
index 5ad7409cc6c78d16cf292c1bf1c1542417abeb5d..491f6cc49642cb3202f87bf189e7467cfb607230 100644
--- a/polkadot/node/core/pvf/common/Cargo.toml
+++ b/polkadot/node/core/pvf/common/Cargo.toml
@@ -17,7 +17,7 @@ libc = "0.2.152"
 nix = { version = "0.28.0", features = ["resource", "sched"] }
 thiserror = { workspace = true }
 
-parity-scale-codec = { version = "3.6.12", default-features = false, features = [
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
 	"derive",
 ] }
 
diff --git a/polkadot/node/core/pvf/common/src/error.rs b/polkadot/node/core/pvf/common/src/error.rs
index adeb40c0b1958df624662f8e7533b6d06f49f543..7ee05448d3c5cb64f54d8ed64dd865da1ad8c87a 100644
--- a/polkadot/node/core/pvf/common/src/error.rs
+++ b/polkadot/node/core/pvf/common/src/error.rs
@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::prepare::{PrepareSuccess, PrepareWorkerSuccess};
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 pub use sc_executor_common::error::Error as ExecuteError;
 
 /// Result of PVF preparation from a worker, with checksum of the compiled PVF and stats of the
diff --git a/polkadot/node/core/pvf/common/src/execute.rs b/polkadot/node/core/pvf/common/src/execute.rs
index ae6096cacec457a209d656541999f915f4dbbc3b..46862f9f80b60324185363c595e221582ce53b1e 100644
--- a/polkadot/node/core/pvf/common/src/execute.rs
+++ b/polkadot/node/core/pvf/common/src/execute.rs
@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::error::InternalValidationError;
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_parachain_primitives::primitives::ValidationResult;
 use polkadot_primitives::ExecutorParams;
 use std::time::Duration;
diff --git a/polkadot/node/core/pvf/common/src/executor_interface.rs b/polkadot/node/core/pvf/common/src/executor_interface.rs
index 252e611db8a488cff776b5d7863c987318e7e013..47f9ed1604e781c045ea643d251da8e324c98287 100644
--- a/polkadot/node/core/pvf/common/src/executor_interface.rs
+++ b/polkadot/node/core/pvf/common/src/executor_interface.rs
@@ -215,19 +215,19 @@ type HostFunctions = (
 struct ValidationExternalities(sp_externalities::Extensions);
 
 impl sp_externalities::Externalities for ValidationExternalities {
-	fn storage(&self, _: &[u8]) -> Option<Vec<u8>> {
+	fn storage(&mut self, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("storage: unsupported feature for parachain validation")
 	}
 
-	fn storage_hash(&self, _: &[u8]) -> Option<Vec<u8>> {
+	fn storage_hash(&mut self, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("storage_hash: unsupported feature for parachain validation")
 	}
 
-	fn child_storage_hash(&self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage_hash(&mut self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("child_storage_hash: unsupported feature for parachain validation")
 	}
 
-	fn child_storage(&self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage(&mut self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("child_storage: unsupported feature for parachain validation")
 	}
 
@@ -275,11 +275,11 @@ impl sp_externalities::Externalities for ValidationExternalities {
 		panic!("child_storage_root: unsupported feature for parachain validation")
 	}
 
-	fn next_child_storage_key(&self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
+	fn next_child_storage_key(&mut self, _: &ChildInfo, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("next_child_storage_key: unsupported feature for parachain validation")
 	}
 
-	fn next_storage_key(&self, _: &[u8]) -> Option<Vec<u8>> {
+	fn next_storage_key(&mut self, _: &[u8]) -> Option<Vec<u8>> {
 		panic!("next_storage_key: unsupported feature for parachain validation")
 	}
 
@@ -372,7 +372,7 @@ impl sp_core::traits::ReadRuntimeVersion for ReadRuntimeVersion {
 			.map_err(|e| format!("Failed to read the static section from the PVF blob: {:?}", e))?
 		{
 			Some(version) => {
-				use parity_scale_codec::Encode;
+				use codec::Encode;
 				Ok(version.encode())
 			},
 			None => Err("runtime version section is not found".to_string()),
diff --git a/polkadot/node/core/pvf/common/src/lib.rs b/polkadot/node/core/pvf/common/src/lib.rs
index 0cd928201639636bd1e5725685e97ea57361313a..30d0aa4452811e76fa417c36c9ac395d5f5ae62d 100644
--- a/polkadot/node/core/pvf/common/src/lib.rs
+++ b/polkadot/node/core/pvf/common/src/lib.rs
@@ -32,7 +32,7 @@ pub use sp_tracing;
 
 const LOG_TARGET: &str = "parachain::pvf-common";
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use std::{
 	io::{self, Read, Write},
 	mem,
diff --git a/polkadot/node/core/pvf/common/src/prepare.rs b/polkadot/node/core/pvf/common/src/prepare.rs
index 28ab682ec136d962364019f2623f80d8e7ad6194..81e165a7b8a499432b4b766b43b9400172ba5822 100644
--- a/polkadot/node/core/pvf/common/src/prepare.rs
+++ b/polkadot/node/core/pvf/common/src/prepare.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use std::path::PathBuf;
 
 /// Result from prepare worker if successful.
@@ -31,6 +31,8 @@ pub struct PrepareWorkerSuccess {
 pub struct PrepareSuccess {
 	/// Canonical path to the compiled artifact.
 	pub path: PathBuf,
+	/// Size in bytes
+	pub size: u64,
 	/// Stats of the current preparation run.
 	pub stats: PrepareStats,
 }
diff --git a/polkadot/node/core/pvf/common/src/pvf.rs b/polkadot/node/core/pvf/common/src/pvf.rs
index 5f248f49b9a381c9f250f911bc1989518280c6de..e2ac36a2406ac28213107d1e0b42d8f215e04ea3 100644
--- a/polkadot/node/core/pvf/common/src/pvf.rs
+++ b/polkadot/node/core/pvf/common/src/pvf.rs
@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::prepare::PrepareJobKind;
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_parachain_primitives::primitives::ValidationCodeHash;
 use polkadot_primitives::ExecutorParams;
 use std::{fmt, sync::Arc, time::Duration};
diff --git a/polkadot/node/core/pvf/common/src/worker/mod.rs b/polkadot/node/core/pvf/common/src/worker/mod.rs
index 67e7bece407d13b012d85ee28bd369fc585a6c6f..70dcf055a2628707e8b70f98a0ab460074832da9 100644
--- a/polkadot/node/core/pvf/common/src/worker/mod.rs
+++ b/polkadot/node/core/pvf/common/src/worker/mod.rs
@@ -21,10 +21,10 @@ pub mod security;
 use crate::{
 	framed_recv_blocking, framed_send_blocking, SecurityStatus, WorkerHandshake, LOG_TARGET,
 };
+use codec::{Decode, Encode};
 use cpu_time::ProcessTime;
 use futures::never::Never;
 use nix::{errno::Errno, sys::resource::Usage};
-use parity_scale_codec::{Decode, Encode};
 use std::{
 	any::Any,
 	fmt::{self},
diff --git a/polkadot/node/core/pvf/execute-worker/Cargo.toml b/polkadot/node/core/pvf/execute-worker/Cargo.toml
index ac90fac4d57ad69db5bcf00df1fb9af15cdbd2e2..cf5b873e29d771e3806c8ec3085a7385b0d59b0b 100644
--- a/polkadot/node/core/pvf/execute-worker/Cargo.toml
+++ b/polkadot/node/core/pvf/execute-worker/Cargo.toml
@@ -16,7 +16,7 @@ cfg-if = "1.0"
 nix = { version = "0.28.0", features = ["process", "resource", "sched"] }
 libc = "0.2.152"
 
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 
 polkadot-node-core-pvf-common = { path = "../common" }
 polkadot-parachain-primitives = { path = "../../../../parachain" }
diff --git a/polkadot/node/core/pvf/execute-worker/src/lib.rs b/polkadot/node/core/pvf/execute-worker/src/lib.rs
index 55f5290bd87ee88ce55157a1988c63a2c9670bbf..35858ab36cec3fd2990403ae0afcf848e5cb317e 100644
--- a/polkadot/node/core/pvf/execute-worker/src/lib.rs
+++ b/polkadot/node/core/pvf/execute-worker/src/lib.rs
@@ -27,6 +27,7 @@ pub use polkadot_node_core_pvf_common::{
 //       separate spawned processes. Run with e.g. `RUST_LOG=parachain::pvf-execute-worker=trace`.
 const LOG_TARGET: &str = "parachain::pvf-execute-worker";
 
+use codec::{Decode, Encode};
 use cpu_time::ProcessTime;
 use nix::{
 	errno::Errno,
@@ -36,7 +37,6 @@ use nix::{
 	},
 	unistd::{ForkResult, Pid},
 };
-use parity_scale_codec::{Decode, Encode};
 use polkadot_node_core_pvf_common::{
 	error::InternalValidationError,
 	execute::{Handshake, JobError, JobResponse, JobResult, WorkerError, WorkerResponse},
diff --git a/polkadot/node/core/pvf/prepare-worker/Cargo.toml b/polkadot/node/core/pvf/prepare-worker/Cargo.toml
index 1850a204890720e697b9e505d8656597dd946844..f7daa0d7a89c3e65b3e6dee9ad3bcbe1e9ecf60e 100644
--- a/polkadot/node/core/pvf/prepare-worker/Cargo.toml
+++ b/polkadot/node/core/pvf/prepare-worker/Cargo.toml
@@ -20,7 +20,7 @@ tikv-jemalloc-ctl = { version = "0.5.0", optional = true }
 tikv-jemallocator = { version = "0.5.0", optional = true }
 nix = { version = "0.28.0", features = ["process", "resource", "sched"] }
 
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 
 polkadot-node-core-pvf-common = { path = "../common" }
 polkadot-primitives = { path = "../../../../primitives" }
diff --git a/polkadot/node/core/pvf/prepare-worker/src/lib.rs b/polkadot/node/core/pvf/prepare-worker/src/lib.rs
index d1b218f48ae897fb663f8285521f251f8a6817d3..ef33d11720eb5a7c4b7fa11b3484acbd5ad84d43 100644
--- a/polkadot/node/core/pvf/prepare-worker/src/lib.rs
+++ b/polkadot/node/core/pvf/prepare-worker/src/lib.rs
@@ -39,7 +39,7 @@ use polkadot_node_core_pvf_common::{
 	worker::{pipe2_cloexec, PipeFd, WorkerInfo},
 };
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_core_pvf_common::{
 	error::{PrepareError, PrepareWorkerResult},
 	executor_interface::create_runtime_from_artifact_bytes,
diff --git a/polkadot/node/core/pvf/src/artifacts.rs b/polkadot/node/core/pvf/src/artifacts.rs
index a3a48b61acb1743d2ed5df62457c6f9f4ba5fa79..119af34082a97f412a5a9135c1f92da3fd5ee9d9 100644
--- a/polkadot/node/core/pvf/src/artifacts.rs
+++ b/polkadot/node/core/pvf/src/artifacts.rs
@@ -142,6 +142,8 @@ pub enum ArtifactState {
 		/// This is updated when we get the heads up for this artifact or when we just discover
 		/// this file.
 		last_time_needed: SystemTime,
+		/// Size in bytes
+		size: u64,
 		/// Stats produced by successful preparation.
 		prepare_stats: PrepareStats,
 	},
@@ -169,6 +171,33 @@ pub struct Artifacts {
 	inner: HashMap<ArtifactId, ArtifactState>,
 }
 
+/// Parameters we use to cleanup artifacts
+/// After we hit the cache limit we remove the least used artifacts
+/// but only if they are stale more than minimum stale time
+#[derive(Debug)]
+pub struct ArtifactsCleanupConfig {
+	// Max size in bytes. Reaching it the least used artefacts are deleted
+	cache_limit: u64,
+	// Inactive time after which artefact is allowed to be deleted
+	min_stale_time: Duration,
+}
+
+impl Default for ArtifactsCleanupConfig {
+	fn default() -> Self {
+		Self {
+			cache_limit: 10 * 1024 * 1024 * 1024,              // 10 GiB
+			min_stale_time: Duration::from_secs(24 * 60 * 60), // 24 hours
+		}
+	}
+}
+
+#[cfg(test)]
+impl ArtifactsCleanupConfig {
+	pub fn new(cache_limit: u64, min_stale_time: Duration) -> Self {
+		Self { cache_limit, min_stale_time }
+	}
+}
+
 impl Artifacts {
 	#[cfg(test)]
 	pub(crate) fn empty() -> Self {
@@ -180,6 +209,11 @@ impl Artifacts {
 		self.inner.len()
 	}
 
+	#[cfg(test)]
+	fn artifact_ids(&self) -> Vec<ArtifactId> {
+		self.inner.keys().cloned().collect()
+	}
+
 	/// Create an empty table and the cache directory on-disk if it doesn't exist.
 	pub async fn new(cache_path: &Path) -> Self {
 		// Make sure that the cache path directory and all its parents are created.
@@ -234,12 +268,16 @@ impl Artifacts {
 		artifact_id: ArtifactId,
 		path: PathBuf,
 		last_time_needed: SystemTime,
+		size: u64,
 		prepare_stats: PrepareStats,
 	) {
 		// See the precondition.
 		always!(self
 			.inner
-			.insert(artifact_id, ArtifactState::Prepared { path, last_time_needed, prepare_stats })
+			.insert(
+				artifact_id,
+				ArtifactState::Prepared { path, last_time_needed, size, prepare_stats }
+			)
 			.is_none());
 	}
 
@@ -251,25 +289,40 @@ impl Artifacts {
 		})
 	}
 
-	/// Remove artifacts older than the given TTL and return id and path of the removed ones.
-	pub fn prune(&mut self, artifact_ttl: Duration) -> Vec<(ArtifactId, PathBuf)> {
+	/// Remove artifacts older than the given TTL when the total artifact size reaches the limit
+	/// and return id and path of the removed ones
+	pub fn prune(&mut self, cleanup_config: &ArtifactsCleanupConfig) -> Vec<(ArtifactId, PathBuf)> {
+		let mut to_remove = vec![];
 		let now = SystemTime::now();
 
-		let mut to_remove = vec![];
+		let mut total_size = 0;
+		let mut artifact_sizes = vec![];
+
 		for (k, v) in self.inner.iter() {
-			if let ArtifactState::Prepared { last_time_needed, ref path, .. } = *v {
-				if now
-					.duration_since(last_time_needed)
-					.map(|age| age > artifact_ttl)
-					.unwrap_or(false)
-				{
-					to_remove.push((k.clone(), path.clone()));
-				}
+			if let ArtifactState::Prepared { ref path, last_time_needed, size, .. } = *v {
+				total_size += size;
+				artifact_sizes.push((k.clone(), path.clone(), size, last_time_needed));
 			}
 		}
+		artifact_sizes
+			.sort_by_key(|&(_, _, _, last_time_needed)| std::cmp::Reverse(last_time_needed));
+
+		while total_size > cleanup_config.cache_limit {
+			let Some((artifact_id, path, size, last_time_needed)) = artifact_sizes.pop() else {
+				break
+			};
+
+			let used_recently = now
+				.duration_since(last_time_needed)
+				.map(|stale_time| stale_time < cleanup_config.min_stale_time)
+				.unwrap_or(true);
+			if used_recently {
+				break;
+			}
 
-		for artifact in &to_remove {
-			self.inner.remove(&artifact.0);
+			self.inner.remove(&artifact_id);
+			to_remove.push((artifact_id, path));
+			total_size -= size;
 		}
 
 		to_remove
@@ -278,6 +331,8 @@ impl Artifacts {
 
 #[cfg(test)]
 mod tests {
+	use crate::testing::artifact_id;
+
 	use super::*;
 
 	#[tokio::test]
@@ -307,4 +362,100 @@ mod tests {
 		assert!(entries.contains(&String::from("worker-prepare-test")));
 		assert_eq!(artifacts.len(), 0);
 	}
+
+	#[tokio::test]
+	async fn test_pruned_by_cache_size() {
+		let mock_now = SystemTime::now();
+		let tempdir = tempfile::tempdir().unwrap();
+		let cache_path = tempdir.path();
+
+		let path1 = generate_artifact_path(cache_path);
+		let path2 = generate_artifact_path(cache_path);
+		let path3 = generate_artifact_path(cache_path);
+		let artifact_id1 = artifact_id(1);
+		let artifact_id2 = artifact_id(2);
+		let artifact_id3 = artifact_id(3);
+
+		let mut artifacts = Artifacts::new(cache_path).await;
+		let cleanup_config = ArtifactsCleanupConfig::new(1500, Duration::from_secs(0));
+
+		artifacts.insert_prepared(
+			artifact_id1.clone(),
+			path1.clone(),
+			mock_now - Duration::from_secs(5),
+			1024,
+			PrepareStats::default(),
+		);
+		artifacts.insert_prepared(
+			artifact_id2.clone(),
+			path2.clone(),
+			mock_now - Duration::from_secs(10),
+			1024,
+			PrepareStats::default(),
+		);
+		artifacts.insert_prepared(
+			artifact_id3.clone(),
+			path3.clone(),
+			mock_now - Duration::from_secs(15),
+			1024,
+			PrepareStats::default(),
+		);
+
+		let pruned = artifacts.prune(&cleanup_config);
+
+		assert!(artifacts.artifact_ids().contains(&artifact_id1));
+		assert!(!pruned.contains(&(artifact_id1, path1)));
+		assert!(!artifacts.artifact_ids().contains(&artifact_id2));
+		assert!(pruned.contains(&(artifact_id2, path2)));
+		assert!(!artifacts.artifact_ids().contains(&artifact_id3));
+		assert!(pruned.contains(&(artifact_id3, path3)));
+	}
+
+	#[tokio::test]
+	async fn test_did_not_prune_by_cache_size_because_of_stale_time() {
+		let mock_now = SystemTime::now();
+		let tempdir = tempfile::tempdir().unwrap();
+		let cache_path = tempdir.path();
+
+		let path1 = generate_artifact_path(cache_path);
+		let path2 = generate_artifact_path(cache_path);
+		let path3 = generate_artifact_path(cache_path);
+		let artifact_id1 = artifact_id(1);
+		let artifact_id2 = artifact_id(2);
+		let artifact_id3 = artifact_id(3);
+
+		let mut artifacts = Artifacts::new(cache_path).await;
+		let cleanup_config = ArtifactsCleanupConfig::new(1500, Duration::from_secs(12));
+
+		artifacts.insert_prepared(
+			artifact_id1.clone(),
+			path1.clone(),
+			mock_now - Duration::from_secs(5),
+			1024,
+			PrepareStats::default(),
+		);
+		artifacts.insert_prepared(
+			artifact_id2.clone(),
+			path2.clone(),
+			mock_now - Duration::from_secs(10),
+			1024,
+			PrepareStats::default(),
+		);
+		artifacts.insert_prepared(
+			artifact_id3.clone(),
+			path3.clone(),
+			mock_now - Duration::from_secs(15),
+			1024,
+			PrepareStats::default(),
+		);
+
+		let pruned = artifacts.prune(&cleanup_config);
+
+		assert!(artifacts.artifact_ids().contains(&artifact_id1));
+		assert!(!pruned.contains(&(artifact_id1, path1)));
+		assert!(artifacts.artifact_ids().contains(&artifact_id2));
+		assert!(!pruned.contains(&(artifact_id2, path2)));
+		assert!(!artifacts.artifact_ids().contains(&artifact_id3));
+		assert!(pruned.contains(&(artifact_id3, path3)));
+	}
 }
diff --git a/polkadot/node/core/pvf/src/execute/worker_interface.rs b/polkadot/node/core/pvf/src/execute/worker_interface.rs
index 9dcadfb4c2a73fbbb27532709de8dd410146fd11..d15d7c15426ebd63d33aaf1166bc8f000e28eb7a 100644
--- a/polkadot/node/core/pvf/src/execute/worker_interface.rs
+++ b/polkadot/node/core/pvf/src/execute/worker_interface.rs
@@ -24,9 +24,9 @@ use crate::{
 	},
 	LOG_TARGET,
 };
+use codec::{Decode, Encode};
 use futures::FutureExt;
 use futures_timer::Delay;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_node_core_pvf_common::{
 	error::InternalValidationError,
 	execute::{Handshake, WorkerError, WorkerResponse},
diff --git a/polkadot/node/core/pvf/src/host.rs b/polkadot/node/core/pvf/src/host.rs
index 4065598a3ac46c32b4d821aac7712f62767a973e..462631d33b525a7d77817de87711a650517d4204 100644
--- a/polkadot/node/core/pvf/src/host.rs
+++ b/polkadot/node/core/pvf/src/host.rs
@@ -21,7 +21,7 @@
 //! [`ValidationHost`], that allows communication with that event-loop.
 
 use crate::{
-	artifacts::{ArtifactId, ArtifactPathId, ArtifactState, Artifacts},
+	artifacts::{ArtifactId, ArtifactPathId, ArtifactState, Artifacts, ArtifactsCleanupConfig},
 	execute::{self, PendingExecutionRequest},
 	metrics::Metrics,
 	prepare, Priority, SecurityStatus, ValidationError, LOG_TARGET,
@@ -293,7 +293,7 @@ pub async fn start(
 	let run_host = async move {
 		run(Inner {
 			cleanup_pulse_interval: Duration::from_secs(3600),
-			artifact_ttl: Duration::from_secs(3600 * 24),
+			cleanup_config: ArtifactsCleanupConfig::default(),
 			artifacts,
 			to_host_rx,
 			to_prepare_queue_tx,
@@ -337,7 +337,7 @@ impl AwaitingPrepare {
 
 struct Inner {
 	cleanup_pulse_interval: Duration,
-	artifact_ttl: Duration,
+	cleanup_config: ArtifactsCleanupConfig,
 	artifacts: Artifacts,
 
 	to_host_rx: mpsc::Receiver<ToHost>,
@@ -359,7 +359,7 @@ struct Fatal;
 async fn run(
 	Inner {
 		cleanup_pulse_interval,
-		artifact_ttl,
+		cleanup_config,
 		mut artifacts,
 		to_host_rx,
 		from_prepare_queue_rx,
@@ -415,7 +415,7 @@ async fn run(
 				break_if_fatal!(handle_cleanup_pulse(
 					&mut to_sweeper_tx,
 					&mut artifacts,
-					artifact_ttl,
+					&cleanup_config,
 				).await);
 			},
 			to_host = to_host_rx.next() => {
@@ -803,8 +803,12 @@ async fn handle_prepare_done(
 	}
 
 	*state = match result {
-		Ok(PrepareSuccess { path, stats: prepare_stats }) =>
-			ArtifactState::Prepared { path, last_time_needed: SystemTime::now(), prepare_stats },
+		Ok(PrepareSuccess { path, stats: prepare_stats, size }) => ArtifactState::Prepared {
+			path,
+			last_time_needed: SystemTime::now(),
+			size,
+			prepare_stats,
+		},
 		Err(error) => {
 			let last_time_failed = SystemTime::now();
 			let num_failures = *num_failures + 1;
@@ -859,9 +863,9 @@ async fn enqueue_prepare_for_execute(
 async fn handle_cleanup_pulse(
 	sweeper_tx: &mut mpsc::Sender<PathBuf>,
 	artifacts: &mut Artifacts,
-	artifact_ttl: Duration,
+	cleanup_config: &ArtifactsCleanupConfig,
 ) -> Result<(), Fatal> {
-	let to_remove = artifacts.prune(artifact_ttl);
+	let to_remove = artifacts.prune(cleanup_config);
 	gum::debug!(
 		target: LOG_TARGET,
 		"PVF pruning: {} artifacts reached their end of life",
@@ -959,7 +963,7 @@ fn pulse_every(interval: std::time::Duration) -> impl futures::Stream<Item = ()>
 #[cfg(test)]
 pub(crate) mod tests {
 	use super::*;
-	use crate::{artifacts::generate_artifact_path, PossiblyInvalidError};
+	use crate::{artifacts::generate_artifact_path, testing::artifact_id, PossiblyInvalidError};
 	use assert_matches::assert_matches;
 	use futures::future::BoxFuture;
 	use polkadot_node_core_pvf_common::prepare::PrepareStats;
@@ -981,14 +985,9 @@ pub(crate) mod tests {
 		}
 	}
 
-	/// Creates a new PVF which artifact id can be uniquely identified by the given number.
-	fn artifact_id(discriminator: u32) -> ArtifactId {
-		ArtifactId::from_pvf_prep_data(&PvfPrepData::from_discriminator(discriminator))
-	}
-
 	struct Builder {
 		cleanup_pulse_interval: Duration,
-		artifact_ttl: Duration,
+		cleanup_config: ArtifactsCleanupConfig,
 		artifacts: Artifacts,
 	}
 
@@ -997,8 +996,7 @@ pub(crate) mod tests {
 			Self {
 				// these are selected high to not interfere in tests in which pruning is irrelevant.
 				cleanup_pulse_interval: Duration::from_secs(3600),
-				artifact_ttl: Duration::from_secs(3600),
-
+				cleanup_config: ArtifactsCleanupConfig::default(),
 				artifacts: Artifacts::empty(),
 			}
 		}
@@ -1022,7 +1020,7 @@ pub(crate) mod tests {
 	}
 
 	impl Test {
-		fn new(Builder { cleanup_pulse_interval, artifact_ttl, artifacts }: Builder) -> Self {
+		fn new(Builder { cleanup_pulse_interval, artifacts, cleanup_config }: Builder) -> Self {
 			let (to_host_tx, to_host_rx) = mpsc::channel(10);
 			let (to_prepare_queue_tx, to_prepare_queue_rx) = mpsc::channel(10);
 			let (from_prepare_queue_tx, from_prepare_queue_rx) = mpsc::unbounded();
@@ -1032,7 +1030,7 @@ pub(crate) mod tests {
 
 			let run = run(Inner {
 				cleanup_pulse_interval,
-				artifact_ttl,
+				cleanup_config,
 				artifacts,
 				to_host_rx,
 				to_prepare_queue_tx,
@@ -1183,19 +1181,21 @@ pub(crate) mod tests {
 
 		let mut builder = Builder::default();
 		builder.cleanup_pulse_interval = Duration::from_millis(100);
-		builder.artifact_ttl = Duration::from_millis(500);
+		builder.cleanup_config = ArtifactsCleanupConfig::new(1024, Duration::from_secs(0));
 		let path1 = generate_artifact_path(cache_path);
 		let path2 = generate_artifact_path(cache_path);
 		builder.artifacts.insert_prepared(
 			artifact_id(1),
 			path1.clone(),
 			mock_now,
+			1024,
 			PrepareStats::default(),
 		);
 		builder.artifacts.insert_prepared(
 			artifact_id(2),
 			path2.clone(),
 			mock_now,
+			1024,
 			PrepareStats::default(),
 		);
 		let mut test = builder.build();
diff --git a/polkadot/node/core/pvf/src/prepare/worker_interface.rs b/polkadot/node/core/pvf/src/prepare/worker_interface.rs
index d64ee1510cad79a4ed1df808668d203b5817121b..22ee93319d84db14ed53a89efe872c7121d87cbd 100644
--- a/polkadot/node/core/pvf/src/prepare/worker_interface.rs
+++ b/polkadot/node/core/pvf/src/prepare/worker_interface.rs
@@ -25,7 +25,7 @@ use crate::{
 	},
 	LOG_TARGET,
 };
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_core_pvf_common::{
 	error::{PrepareError, PrepareResult, PrepareWorkerResult},
 	prepare::{PrepareStats, PrepareSuccess, PrepareWorkerSuccess},
@@ -234,6 +234,19 @@ async fn handle_response(
 		return Outcome::TimedOut
 	}
 
+	let size = match tokio::fs::metadata(cache_path).await {
+		Ok(metadata) => metadata.len(),
+		Err(err) => {
+			gum::warn!(
+				target: LOG_TARGET,
+				?cache_path,
+				"failed to read size of the artifact: {}",
+				err,
+			);
+			return Outcome::IoErr(err.to_string())
+		},
+	};
+
 	// The file name should uniquely identify the artifact even across restarts. In case the cache
 	// for some reason is not cleared correctly, we cannot
 	// accidentally execute an artifact compiled under a different wasmtime version, host
@@ -253,6 +266,7 @@ async fn handle_response(
 			worker,
 			result: Ok(PrepareSuccess {
 				path: artifact_path,
+				size,
 				stats: PrepareStats { cpu_time_elapsed, memory_stats: memory_stats.clone() },
 			}),
 		},
diff --git a/polkadot/node/core/pvf/src/testing.rs b/polkadot/node/core/pvf/src/testing.rs
index 60b0b4b8d3d0c49199800194570d8ef2783fc67f..8c75dafa69c2554df5d7739ae4bfe9b1ccdf5c87 100644
--- a/polkadot/node/core/pvf/src/testing.rs
+++ b/polkadot/node/core/pvf/src/testing.rs
@@ -21,8 +21,9 @@ pub use crate::{
 	worker_interface::{spawn_with_program_path, SpawnErr},
 };
 
-use crate::get_worker_version;
+use crate::{artifacts::ArtifactId, get_worker_version};
 use is_executable::IsExecutable;
+use polkadot_node_core_pvf_common::pvf::PvfPrepData;
 use polkadot_node_primitives::NODE_VERSION;
 use polkadot_primitives::ExecutorParams;
 use std::{
@@ -126,3 +127,8 @@ pub fn build_workers_and_get_paths() -> (PathBuf, PathBuf) {
 	let guard = mutex.lock().unwrap();
 	(guard.0.clone(), guard.1.clone())
 }
+
+/// Creates a new PVF which artifact id can be uniquely identified by the given number.
+pub fn artifact_id(discriminator: u32) -> ArtifactId {
+	ArtifactId::from_pvf_prep_data(&PvfPrepData::from_discriminator(discriminator))
+}
diff --git a/polkadot/node/core/pvf/src/worker_interface.rs b/polkadot/node/core/pvf/src/worker_interface.rs
index 93fffc80662266a6a1112f6d5120cb454bca6276..e63778d4692fb45f2c9ffd67ac1c6a07eab87a6d 100644
--- a/polkadot/node/core/pvf/src/worker_interface.rs
+++ b/polkadot/node/core/pvf/src/worker_interface.rs
@@ -17,9 +17,9 @@
 //! Common logic for implementation of worker processes.
 
 use crate::LOG_TARGET;
+use codec::Encode;
 use futures::FutureExt as _;
 use futures_timer::Delay;
-use parity_scale_codec::Encode;
 use pin_project::pin_project;
 use polkadot_node_core_pvf_common::{SecurityStatus, WorkerHandshake};
 use rand::Rng;
diff --git a/polkadot/node/core/pvf/tests/it/adder.rs b/polkadot/node/core/pvf/tests/it/adder.rs
index 9a7ddcb408909e6fcac2c812921174e81b7911bb..455e8c36c88d7c6718a2ce949c0fc961455d06f4 100644
--- a/polkadot/node/core/pvf/tests/it/adder.rs
+++ b/polkadot/node/core/pvf/tests/it/adder.rs
@@ -17,12 +17,12 @@
 //! PVF host integration tests checking the chain production pipeline.
 
 use super::TestHost;
-use adder::{hash_state, BlockData, HeadData};
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_parachain_primitives::primitives::{
 	BlockData as GenericBlockData, HeadData as GenericHeadData, RelayChainBlockNumber,
 	ValidationParams,
 };
+use test_parachain_adder::{hash_state, BlockData, HeadData};
 
 #[tokio::test]
 async fn execute_good_block_on_parent() {
@@ -34,7 +34,7 @@ async fn execute_good_block_on_parent() {
 
 	let ret = host
 		.validate_candidate(
-			adder::wasm_binary_unwrap(),
+			test_parachain_adder::wasm_binary_unwrap(),
 			ValidationParams {
 				parent_head: GenericHeadData(parent_head.encode()),
 				block_data: GenericBlockData(block_data.encode()),
@@ -68,7 +68,7 @@ async fn execute_good_chain_on_parent() {
 
 		let ret = host
 			.validate_candidate(
-				adder::wasm_binary_unwrap(),
+				test_parachain_adder::wasm_binary_unwrap(),
 				ValidationParams {
 					parent_head: GenericHeadData(parent_head.encode()),
 					block_data: GenericBlockData(block_data.encode()),
@@ -104,7 +104,7 @@ async fn execute_bad_block_on_parent() {
 
 	let _err = host
 		.validate_candidate(
-			adder::wasm_binary_unwrap(),
+			test_parachain_adder::wasm_binary_unwrap(),
 			ValidationParams {
 				parent_head: GenericHeadData(parent_head.encode()),
 				block_data: GenericBlockData(block_data.encode()),
@@ -126,7 +126,7 @@ async fn stress_spawn() {
 		let block_data = BlockData { state: 0, add: 512 };
 		let ret = host
 			.validate_candidate(
-				adder::wasm_binary_unwrap(),
+				test_parachain_adder::wasm_binary_unwrap(),
 				ValidationParams {
 					parent_head: GenericHeadData(parent_head.encode()),
 					block_data: GenericBlockData(block_data.encode()),
@@ -163,7 +163,7 @@ async fn execute_can_run_serially() {
 		let block_data = BlockData { state: 0, add: 512 };
 		let ret = host
 			.validate_candidate(
-				adder::wasm_binary_unwrap(),
+				test_parachain_adder::wasm_binary_unwrap(),
 				ValidationParams {
 					parent_head: GenericHeadData(parent_head.encode()),
 					block_data: GenericBlockData(block_data.encode()),
diff --git a/polkadot/node/core/pvf/tests/it/main.rs b/polkadot/node/core/pvf/tests/it/main.rs
index 6961b93832abed0d8608e8363a1fac3d2d510fdf..d62a1aef230990057c5c408a840f51bc66a5029f 100644
--- a/polkadot/node/core/pvf/tests/it/main.rs
+++ b/polkadot/node/core/pvf/tests/it/main.rs
@@ -17,7 +17,7 @@
 //! General PVF host integration tests checking the functionality of the PVF host itself.
 
 use assert_matches::assert_matches;
-use parity_scale_codec::Encode as _;
+use codec::Encode as _;
 #[cfg(all(feature = "ci-only-tests", target_os = "linux"))]
 use polkadot_node_core_pvf::SecurityStatus;
 use polkadot_node_core_pvf::{
@@ -163,7 +163,7 @@ async fn execute_job_terminates_on_timeout() {
 	let start = std::time::Instant::now();
 	let result = host
 		.validate_candidate(
-			halt::wasm_binary_unwrap(),
+			test_parachain_halt::wasm_binary_unwrap(),
 			ValidationParams {
 				block_data: BlockData(Vec::new()),
 				parent_head: Default::default(),
@@ -190,7 +190,7 @@ async fn ensure_parallel_execution() {
 	// Run some jobs that do not complete, thus timing out.
 	let host = TestHost::new().await;
 	let execute_pvf_future_1 = host.validate_candidate(
-		halt::wasm_binary_unwrap(),
+		test_parachain_halt::wasm_binary_unwrap(),
 		ValidationParams {
 			block_data: BlockData(Vec::new()),
 			parent_head: Default::default(),
@@ -200,7 +200,7 @@ async fn ensure_parallel_execution() {
 		Default::default(),
 	);
 	let execute_pvf_future_2 = host.validate_candidate(
-		halt::wasm_binary_unwrap(),
+		test_parachain_halt::wasm_binary_unwrap(),
 		ValidationParams {
 			block_data: BlockData(Vec::new()),
 			parent_head: Default::default(),
@@ -244,7 +244,7 @@ async fn execute_queue_doesnt_stall_if_workers_died() {
 	let start = std::time::Instant::now();
 	futures::future::join_all((0u8..=8).map(|_| {
 		host.validate_candidate(
-			halt::wasm_binary_unwrap(),
+			test_parachain_halt::wasm_binary_unwrap(),
 			ValidationParams {
 				block_data: BlockData(Vec::new()),
 				parent_head: Default::default(),
@@ -287,7 +287,7 @@ async fn execute_queue_doesnt_stall_with_varying_executor_params() {
 	let start = std::time::Instant::now();
 	futures::future::join_all((0u8..6).map(|i| {
 		host.validate_candidate(
-			halt::wasm_binary_unwrap(),
+			test_parachain_halt::wasm_binary_unwrap(),
 			ValidationParams {
 				block_data: BlockData(Vec::new()),
 				parent_head: Default::default(),
@@ -325,7 +325,10 @@ async fn deleting_prepared_artifact_does_not_dispute() {
 	let host = TestHost::new().await;
 	let cache_dir = host.cache_dir.path();
 
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default())
+		.await
+		.unwrap();
 
 	// Manually delete the prepared artifact from disk. The in-memory artifacts table won't change.
 	{
@@ -345,7 +348,7 @@ async fn deleting_prepared_artifact_does_not_dispute() {
 	// Try to validate, artifact should get recreated.
 	let result = host
 		.validate_candidate(
-			halt::wasm_binary_unwrap(),
+			test_parachain_halt::wasm_binary_unwrap(),
 			ValidationParams {
 				block_data: BlockData(Vec::new()),
 				parent_head: Default::default(),
@@ -365,7 +368,10 @@ async fn corrupted_prepared_artifact_does_not_dispute() {
 	let host = TestHost::new().await;
 	let cache_dir = host.cache_dir.path();
 
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default())
+		.await
+		.unwrap();
 
 	// Manually corrupting the prepared artifact from disk. The in-memory artifacts table won't
 	// change.
@@ -395,7 +401,7 @@ async fn corrupted_prepared_artifact_does_not_dispute() {
 	// Try to validate, artifact should get removed because of the corruption.
 	let result = host
 		.validate_candidate(
-			halt::wasm_binary_unwrap(),
+			test_parachain_halt::wasm_binary_unwrap(),
 			ValidationParams {
 				block_data: BlockData(Vec::new()),
 				parent_head: Default::default(),
@@ -412,7 +418,9 @@ async fn corrupted_prepared_artifact_does_not_dispute() {
 	);
 
 	// because of RuntimeConstruction we may retry
-	host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap();
+	host.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default())
+		.await
+		.unwrap();
 
 	// The actual artifact removal is done concurrently
 	// with sending of the result of the execution
@@ -437,7 +445,10 @@ async fn cache_cleared_on_startup() {
 	// Don't drop this host, it owns the `TempDir` which gets cleared on drop.
 	let host = TestHost::new().await;
 
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default())
+		.await
+		.unwrap();
 
 	// The cache dir should contain one artifact and one worker dir.
 	let cache_dir = host.cache_dir.path().to_owned();
@@ -461,7 +472,7 @@ async fn prechecking_within_memory_limits() {
 	let host = TestHost::new().await;
 	let result = host
 		.precheck_pvf(
-			::adder::wasm_binary_unwrap(),
+			::test_parachain_adder::wasm_binary_unwrap(),
 			ExecutorParams::from(&[ExecutorParam::PrecheckingMaxMemory(10 * 1024 * 1024)][..]),
 		)
 		.await;
@@ -480,7 +491,7 @@ async fn prechecking_out_of_memory() {
 	let host = TestHost::new().await;
 	let result = host
 		.precheck_pvf(
-			::adder::wasm_binary_unwrap(),
+			::test_parachain_adder::wasm_binary_unwrap(),
 			ExecutorParams::from(&[ExecutorParam::PrecheckingMaxMemory(512 * 1024)][..]),
 		)
 		.await;
@@ -497,12 +508,15 @@ async fn prepare_can_run_serially() {
 	.await;
 
 	let _stats = host
-		.precheck_pvf(::adder::wasm_binary_unwrap(), Default::default())
+		.precheck_pvf(::test_parachain_adder::wasm_binary_unwrap(), Default::default())
 		.await
 		.unwrap();
 
 	// Prepare a different wasm blob to prevent skipping work.
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default())
+		.await
+		.unwrap();
 }
 
 // CI machines should be able to enable all the security features.
@@ -555,7 +569,7 @@ async fn nonexistent_cache_dir() {
 	assert!(host.security_status().await.can_unshare_user_namespace_and_change_root);
 
 	let _stats = host
-		.precheck_pvf(::adder::wasm_binary_unwrap(), Default::default())
+		.precheck_pvf(::test_parachain_adder::wasm_binary_unwrap(), Default::default())
 		.await
 		.unwrap();
 }
@@ -574,7 +588,10 @@ async fn artifact_does_not_reprepare_on_non_meaningful_exec_parameter_change() {
 	let set2 =
 		ExecutorParams::from(&[ExecutorParam::PvfExecTimeout(PvfExecKind::Backing, 2500)][..]);
 
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set1).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set1)
+		.await
+		.unwrap();
 
 	let md1 = {
 		let mut cache_dir: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect();
@@ -590,7 +607,10 @@ async fn artifact_does_not_reprepare_on_non_meaningful_exec_parameter_change() {
 	// second attifact will be different
 	tokio::time::sleep(Duration::from_secs(2)).await;
 
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set2).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set2)
+		.await
+		.unwrap();
 
 	let md2 = {
 		let mut cache_dir: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect();
@@ -619,12 +639,18 @@ async fn artifact_does_reprepare_on_meaningful_exec_parameter_change() {
 	let set2 =
 		ExecutorParams::from(&[ExecutorParam::PvfPrepTimeout(PvfPrepKind::Prepare, 60000)][..]);
 
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set1).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set1)
+		.await
+		.unwrap();
 	let cache_dir_contents: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect();
 
 	assert_eq!(cache_dir_contents.len(), 2);
 
-	let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set2).await.unwrap();
+	let _stats = host
+		.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set2)
+		.await
+		.unwrap();
 	let cache_dir_contents: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect();
 
 	assert_eq!(cache_dir_contents.len(), 3); // new artifact has been added
diff --git a/polkadot/node/core/pvf/tests/it/process.rs b/polkadot/node/core/pvf/tests/it/process.rs
index e989eb874ba956da83fccd653f978a041f2411ea..b8fd2cdce0ce67e0b1cfbfc57634bfa4d8c63d46 100644
--- a/polkadot/node/core/pvf/tests/it/process.rs
+++ b/polkadot/node/core/pvf/tests/it/process.rs
@@ -18,9 +18,8 @@
 //! spawned by the host) and job processes (spawned by the workers to securely perform PVF jobs).
 
 use super::TestHost;
-use adder::{hash_state, BlockData, HeadData};
 use assert_matches::assert_matches;
-use parity_scale_codec::Encode;
+use codec::Encode;
 use polkadot_node_core_pvf::{
 	InvalidCandidate, PossiblyInvalidError, PrepareError, ValidationError,
 };
@@ -30,6 +29,7 @@ use polkadot_parachain_primitives::primitives::{
 use procfs::process;
 use rusty_fork::rusty_fork_test;
 use std::{future::Future, sync::Arc, time::Duration};
+use test_parachain_adder::{hash_state, BlockData, HeadData};
 
 const PREPARE_PROCESS_NAME: &'static str = "polkadot-prepare-worker";
 const EXECUTE_PROCESS_NAME: &'static str = "polkadot-execute-worker";
@@ -127,7 +127,7 @@ rusty_fork_test! {
 			let block_data = BlockData { state: 0, add: 512 };
 			host
 				.validate_candidate(
-					adder::wasm_binary_unwrap(),
+					test_parachain_adder::wasm_binary_unwrap(),
 					ValidationParams {
 						parent_head: GenericHeadData(parent_head.encode()),
 						block_data: GenericBlockData(block_data.encode()),
@@ -164,7 +164,7 @@ rusty_fork_test! {
 	fn execute_worker_timeout() {
 		test_wrapper(|host, sid| async move {
 			// Prepare the artifact ahead of time.
-			let binary = halt::wasm_binary_unwrap();
+			let binary = test_parachain_halt::wasm_binary_unwrap();
 			host.precheck_pvf(binary, Default::default()).await.unwrap();
 
 			let (result, _) = futures::join!(
@@ -216,7 +216,7 @@ rusty_fork_test! {
 	fn execute_worker_killed_during_job() {
 		test_wrapper(|host, sid| async move {
 			// Prepare the artifact ahead of time.
-			let binary = halt::wasm_binary_unwrap();
+			let binary = test_parachain_halt::wasm_binary_unwrap();
 			host.precheck_pvf(binary, Default::default()).await.unwrap();
 
 			let (result, _) = futures::join!(
@@ -272,7 +272,7 @@ rusty_fork_test! {
 	fn forked_execute_job_killed_during_job() {
 		test_wrapper(|host, sid| async move {
 			// Prepare the artifact ahead of time.
-			let binary = halt::wasm_binary_unwrap();
+			let binary = test_parachain_halt::wasm_binary_unwrap();
 			host.precheck_pvf(binary, Default::default()).await.unwrap();
 
 			let (result, _) = futures::join!(
@@ -340,7 +340,7 @@ rusty_fork_test! {
 	fn ensure_execute_processes_have_correct_num_threads() {
 		test_wrapper(|host, sid| async move {
 			// Prepare the artifact ahead of time.
-			let binary = halt::wasm_binary_unwrap();
+			let binary = test_parachain_halt::wasm_binary_unwrap();
 			host.precheck_pvf(binary, Default::default()).await.unwrap();
 
 			let _ = futures::join!(
diff --git a/polkadot/node/core/runtime-api/Cargo.toml b/polkadot/node/core/runtime-api/Cargo.toml
index 91f5c35b27949f9e0918eaad7adbe5f2557576e8..5524cc705457e45e18e6ea9919c567bf796225c7 100644
--- a/polkadot/node/core/runtime-api/Cargo.toml
+++ b/polkadot/node/core/runtime-api/Cargo.toml
@@ -29,4 +29,4 @@ async-trait = "0.1.79"
 futures = { version = "0.3.30", features = ["thread-pool"] }
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
 polkadot-node-primitives = { path = "../../primitives" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
diff --git a/polkadot/node/core/runtime-api/src/tests.rs b/polkadot/node/core/runtime-api/src/tests.rs
index 0113de83c89ec56403fec0e42207bc5d4e0c552e..7c382707264f117b45469a2de28ac4d3c957309b 100644
--- a/polkadot/node/core/runtime-api/src/tests.rs
+++ b/polkadot/node/core/runtime-api/src/tests.rs
@@ -27,13 +27,13 @@ use polkadot_primitives::{
 	PersistedValidationData, PvfCheckStatement, ScrapedOnChainVotes, SessionIndex, SessionInfo,
 	Slot, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature,
 };
+use polkadot_primitives_test_helpers::{dummy_committed_candidate_receipt, dummy_validation_code};
 use sp_api::ApiError;
 use sp_core::testing::TaskExecutor;
 use std::{
 	collections::{BTreeMap, HashMap, VecDeque},
 	sync::{Arc, Mutex},
 };
-use test_helpers::{dummy_committed_candidate_receipt, dummy_validation_code};
 
 #[derive(Default)]
 struct MockSubsystemClient {
diff --git a/polkadot/node/jaeger/Cargo.toml b/polkadot/node/jaeger/Cargo.toml
index f879f9550d014c0571558f5238f13ce9dad5fe4e..18b0c417aaf3d5798d81b8a2d4b11e4ddcc5f5fc 100644
--- a/polkadot/node/jaeger/Cargo.toml
+++ b/polkadot/node/jaeger/Cargo.toml
@@ -21,4 +21,4 @@ sp-core = { path = "../../../substrate/primitives/core" }
 thiserror = { workspace = true }
 tokio = "1.37"
 log = { workspace = true, default-features = true }
-parity-scale-codec = { version = "3.6.12", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
diff --git a/polkadot/node/jaeger/src/spans.rs b/polkadot/node/jaeger/src/spans.rs
index 68fa57e2ca14f859b7bcfcf02884deaa34d7d156..efc1a9f91d195eeeae3191bcccecec611250f3eb 100644
--- a/polkadot/node/jaeger/src/spans.rs
+++ b/polkadot/node/jaeger/src/spans.rs
@@ -83,9 +83,11 @@
 //! # }
 //! ```
 
-use parity_scale_codec::Encode;
+use codec::Encode;
 use polkadot_node_primitives::PoV;
-use polkadot_primitives::{BlakeTwo256, CandidateHash, Hash, HashT, Id as ParaId, ValidatorIndex};
+use polkadot_primitives::{
+	BlakeTwo256, CandidateHash, ChunkIndex, Hash, HashT, Id as ParaId, ValidatorIndex,
+};
 use sc_network_types::PeerId;
 
 use std::{fmt, sync::Arc};
@@ -338,8 +340,8 @@ impl Span {
 	}
 
 	#[inline(always)]
-	pub fn with_chunk_index(self, chunk_index: u32) -> Self {
-		self.with_string_tag("chunk-index", chunk_index)
+	pub fn with_chunk_index(self, chunk_index: ChunkIndex) -> Self {
+		self.with_string_tag("chunk-index", &chunk_index.0)
 	}
 
 	#[inline(always)]
diff --git a/polkadot/node/malus/Cargo.toml b/polkadot/node/malus/Cargo.toml
index 750074fa9b3cb6209d640b75189768fd94faccf2..fec148f7d38150936d733dfadf2030f1eea2c76c 100644
--- a/polkadot/node/malus/Cargo.toml
+++ b/polkadot/node/malus/Cargo.toml
@@ -48,7 +48,7 @@ clap = { version = "4.5.3", features = ["derive"] }
 futures = "0.3.30"
 futures-timer = "3.0.2"
 gum = { package = "tracing-gum", path = "../gum" }
-erasure = { package = "polkadot-erasure-coding", path = "../../erasure-coding" }
+polkadot-erasure-coding = { path = "../../erasure-coding" }
 rand = "0.8.5"
 
 # Required for worker binaries to build.
diff --git a/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs b/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs
index 739ed40db362a2ae330f14b7a24cc77c1ab76159..6921352cdfc29c6fc6593e609e30bcee876c4557 100644
--- a/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs
+++ b/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs
@@ -197,13 +197,13 @@ where
 
 					let pov_hash = pov.hash();
 					let erasure_root = {
-						let chunks = erasure::obtain_chunks_v1(
+						let chunks = polkadot_erasure_coding::obtain_chunks_v1(
 							n_validators as usize,
 							&malicious_available_data,
 						)
 						.unwrap();
 
-						let branches = erasure::branches(chunks.as_ref());
+						let branches = polkadot_erasure_coding::branches(chunks.as_ref());
 						branches.root()
 					};
 
diff --git a/polkadot/node/metrics/Cargo.toml b/polkadot/node/metrics/Cargo.toml
index e3a53cc6df1b435d3e2361d388624252c2df9d3d..55df8d3daf6d17d142aa7980884c5ad9b4f0e568 100644
--- a/polkadot/node/metrics/Cargo.toml
+++ b/polkadot/node/metrics/Cargo.toml
@@ -19,10 +19,10 @@ metered = { package = "prioritized-metered-channel", version = "0.6.1", default-
 sc-service = { path = "../../../substrate/client/service" }
 sc-cli = { path = "../../../substrate/client/cli" }
 
-substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" }
 sc-tracing = { path = "../../../substrate/client/tracing" }
 codec = { package = "parity-scale-codec", version = "3.6.12" }
-primitives = { package = "polkadot-primitives", path = "../../primitives" }
+polkadot-primitives = { path = "../../primitives" }
 bs58 = { version = "0.5.0", features = ["alloc"] }
 log = { workspace = true, default-features = true }
 
@@ -41,7 +41,7 @@ prometheus-parse = { version = "0.2.2" }
 default = []
 runtime-metrics = []
 runtime-benchmarks = [
+	"polkadot-primitives/runtime-benchmarks",
 	"polkadot-test-service/runtime-benchmarks",
-	"primitives/runtime-benchmarks",
 	"sc-service/runtime-benchmarks",
 ]
diff --git a/polkadot/node/metrics/src/lib.rs b/polkadot/node/metrics/src/lib.rs
index 9cb0f289a580ccadc68d2dd8197c46f162845b22..3445c3de107aacf138c5a790a306c547aa36329b 100644
--- a/polkadot/node/metrics/src/lib.rs
+++ b/polkadot/node/metrics/src/lib.rs
@@ -45,7 +45,7 @@ pub fn logger_hook() -> impl FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Con
 /// This module reexports Prometheus types and defines the [`Metrics`](metrics::Metrics) trait.
 pub mod metrics {
 	/// Reexport Substrate Prometheus types.
-	pub use substrate_prometheus_endpoint as prometheus;
+	pub use prometheus_endpoint as prometheus;
 
 	/// Subsystem- or job-specific Prometheus metrics.
 	///
diff --git a/polkadot/node/metrics/src/runtime/mod.rs b/polkadot/node/metrics/src/runtime/mod.rs
index 7cd24b01c117f24d9c4c41f367ab3b53f8aa504c..c5ece849aa3e01361880b0c1875d5c6a87936012 100644
--- a/polkadot/node/metrics/src/runtime/mod.rs
+++ b/polkadot/node/metrics/src/runtime/mod.rs
@@ -28,17 +28,17 @@
 #![cfg(feature = "runtime-metrics")]
 
 use codec::Decode;
-use primitives::{
+use polkadot_primitives::{
 	metric_definitions::{CounterDefinition, CounterVecDefinition, HistogramDefinition},
 	RuntimeMetricLabelValues, RuntimeMetricOp, RuntimeMetricUpdate,
 };
+use prometheus_endpoint::{
+	register, Counter, CounterVec, Histogram, HistogramOpts, Opts, PrometheusError, Registry, U64,
+};
 use std::{
 	collections::hash_map::HashMap,
 	sync::{Arc, Mutex, MutexGuard},
 };
-use substrate_prometheus_endpoint::{
-	register, Counter, CounterVec, Histogram, HistogramOpts, Opts, PrometheusError, Registry, U64,
-};
 mod parachain;
 
 /// Holds the registered Prometheus metric collections.
diff --git a/polkadot/node/metrics/src/runtime/parachain.rs b/polkadot/node/metrics/src/runtime/parachain.rs
index becc7c64d59d08b4896ee102d5c27a72e61cfd08..7aecaf5590f185398227fbf0b201d3b1890f3cf5 100644
--- a/polkadot/node/metrics/src/runtime/parachain.rs
+++ b/polkadot/node/metrics/src/runtime/parachain.rs
@@ -18,7 +18,7 @@
 //! All of the metrics have a correspondent runtime metric definition.
 
 use crate::runtime::RuntimeMetricsProvider;
-use primitives::metric_definitions::{
+use polkadot_primitives::metric_definitions::{
 	PARACHAIN_CREATE_INHERENT_BITFIELDS_SIGNATURE_CHECKS,
 	PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED, PARACHAIN_INHERENT_DATA_CANDIDATES_PROCESSED,
 	PARACHAIN_INHERENT_DATA_DISPUTE_SETS_PROCESSED, PARACHAIN_INHERENT_DATA_WEIGHT,
diff --git a/polkadot/node/metrics/src/tests.rs b/polkadot/node/metrics/src/tests.rs
index 861080228cd8dc90f9d074d54355983ab30e8e53..fde7c314413462799f82aa727b0a5a1a68bbd5f6 100644
--- a/polkadot/node/metrics/src/tests.rs
+++ b/polkadot/node/metrics/src/tests.rs
@@ -17,8 +17,8 @@
 //! Polkadot runtime metrics integration test.
 
 use hyper::{Client, Uri};
+use polkadot_primitives::metric_definitions::PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED;
 use polkadot_test_service::{node_config, run_validator_node, test_prometheus_config};
-use primitives::metric_definitions::PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED;
 use sp_keyring::AccountKeyring::*;
 use std::collections::HashMap;
 
diff --git a/polkadot/node/network/approval-distribution/src/tests.rs b/polkadot/node/network/approval-distribution/src/tests.rs
index 3159fe2ae5e8d4e4df0ba7bf2f4c42b44d658686..5ad034464767efc3757c3812967d88c71a6fbdd3 100644
--- a/polkadot/node/network/approval-distribution/src/tests.rs
+++ b/polkadot/node/network/approval-distribution/src/tests.rs
@@ -36,7 +36,6 @@ use polkadot_node_primitives::approval::{
 use polkadot_node_subsystem::messages::{
 	network_bridge_event, AllMessages, ApprovalCheckError, ReportPeerMessage,
 };
-use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_node_subsystem_util::{reputation::add_reputation, TimeoutExt as _};
 use polkadot_primitives::{AuthorityDiscoveryId, BlakeTwo256, CoreIndex, HashT};
 use polkadot_primitives_test_helpers::dummy_signature;
@@ -44,7 +43,8 @@ use rand::SeedableRng;
 use sp_authority_discovery::AuthorityPair as AuthorityDiscoveryPair;
 use sp_core::crypto::Pair as PairT;
 use std::time::Duration;
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<ApprovalDistributionMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<ApprovalDistributionMessage>;
 
 fn test_harness<T: Future<Output = VirtualOverseer>>(
 	mut state: State,
@@ -56,7 +56,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 		.try_init();
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let subsystem = ApprovalDistribution::new(Default::default());
 	{
@@ -3657,7 +3658,8 @@ fn batch_test_round(message_count: usize) {
 	let pool = sp_core::testing::TaskExecutor::new();
 	let mut state = State::default();
 
-	let (mut context, mut virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (mut context, mut virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 	let subsystem = ApprovalDistribution::new(Default::default());
 	let mut rng = rand_chacha::ChaCha12Rng::seed_from_u64(12345);
 	let mut sender = context.sender().clone();
diff --git a/polkadot/node/network/availability-distribution/Cargo.toml b/polkadot/node/network/availability-distribution/Cargo.toml
index 39e2985a88cfa5de7309d367df32e3c9aa3c8328..db3a0456d9adbe3bc94e5d69b0c3586a78206c8b 100644
--- a/polkadot/node/network/availability-distribution/Cargo.toml
+++ b/polkadot/node/network/availability-distribution/Cargo.toml
@@ -12,13 +12,14 @@ workspace = true
 [dependencies]
 futures = "0.3.30"
 gum = { package = "tracing-gum", path = "../../gum" }
-parity-scale-codec = { version = "3.6.12", features = ["std"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["std"] }
 polkadot-primitives = { path = "../../../primitives" }
 polkadot-erasure-coding = { path = "../../../erasure-coding" }
 polkadot-node-network-protocol = { path = "../protocol" }
 polkadot-node-subsystem = { path = "../../subsystem" }
 polkadot-node-subsystem-util = { path = "../../subsystem-util" }
 polkadot-node-primitives = { path = "../../primitives" }
+sc-network = { path = "../../../../substrate/client/network" }
 sp-core = { path = "../../../../substrate/primitives/core", features = ["std"] }
 sp-keystore = { path = "../../../../substrate/primitives/keystore" }
 thiserror = { workspace = true }
@@ -36,6 +37,7 @@ sc-network = { path = "../../../../substrate/client/network" }
 futures-timer = "3.0.2"
 assert_matches = "1.4.0"
 polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
+rstest = "0.18.2"
 polkadot-subsystem-bench = { path = "../../subsystem-bench" }
 
 
diff --git a/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs b/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs
index 5e3072be3a8c13d08bfec7fc5840320fcc33c6c5..6083a90e48126bbf5747880835f6753176be4559 100644
--- a/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs
+++ b/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs
@@ -53,11 +53,7 @@ fn main() -> Result<(), String> {
 				polkadot_subsystem_bench::availability::TestDataAvailability::Write,
 				false,
 			);
-			env.runtime().block_on(benchmark_availability_write(
-				"data_availability_write",
-				&mut env,
-				&state,
-			))
+			env.runtime().block_on(benchmark_availability_write(&mut env, &state))
 		})
 		.collect();
 	println!("\rDone!{}", " ".repeat(BENCH_COUNT));
@@ -77,9 +73,9 @@ fn main() -> Result<(), String> {
 		("Sent to peers", 18479.9000, 0.001),
 	]));
 	messages.extend(average_usage.check_cpu_usage(&[
-		("availability-distribution", 0.0123, 0.1),
-		("availability-store", 0.1597, 0.1),
-		("bitfield-distribution", 0.0223, 0.1),
+		("availability-distribution", 0.0127, 0.1),
+		("availability-store", 0.1626, 0.1),
+		("bitfield-distribution", 0.0224, 0.1),
 	]));
 
 	if messages.is_empty() {
diff --git a/polkadot/node/network/availability-distribution/src/error.rs b/polkadot/node/network/availability-distribution/src/error.rs
index c547a1abbc27604862cebef2790223a0b54fac37..72a809dd114080f185c8aee45f87ff8655c236a4 100644
--- a/polkadot/node/network/availability-distribution/src/error.rs
+++ b/polkadot/node/network/availability-distribution/src/error.rs
@@ -49,7 +49,7 @@ pub enum Error {
 
 	#[fatal]
 	#[error("Oneshot for receiving response from Chain API got cancelled")]
-	ChainApiSenderDropped(#[source] oneshot::Canceled),
+	ChainApiSenderDropped(#[from] oneshot::Canceled),
 
 	#[fatal]
 	#[error("Retrieving response from Chain API unexpectedly failed with error: {0}")]
@@ -82,6 +82,9 @@ pub enum Error {
 
 	#[error("Given validator index could not be found in current session")]
 	InvalidValidatorIndex,
+
+	#[error("Erasure coding error: {0}")]
+	ErasureCoding(#[from] polkadot_erasure_coding::Error),
 }
 
 /// General result abbreviation type alias.
@@ -104,7 +107,8 @@ pub fn log_error(
 				JfyiError::InvalidValidatorIndex |
 				JfyiError::NoSuchCachedSession { .. } |
 				JfyiError::QueryAvailableDataResponseChannel(_) |
-				JfyiError::QueryChunkResponseChannel(_) => gum::warn!(target: LOG_TARGET, error = %jfyi, ctx),
+				JfyiError::QueryChunkResponseChannel(_) |
+				JfyiError::ErasureCoding(_) => gum::warn!(target: LOG_TARGET, error = %jfyi, ctx),
 				JfyiError::FetchPoV(_) |
 				JfyiError::SendResponse |
 				JfyiError::NoSuchPoV |
diff --git a/polkadot/node/network/availability-distribution/src/lib.rs b/polkadot/node/network/availability-distribution/src/lib.rs
index c62ce1dd981a9ce8c4fe6e2b7c451a401e609b25..ec2c01f99b0186f80a42ad635426ace626139ffc 100644
--- a/polkadot/node/network/availability-distribution/src/lib.rs
+++ b/polkadot/node/network/availability-distribution/src/lib.rs
@@ -18,7 +18,9 @@ use futures::{future::Either, FutureExt, StreamExt, TryFutureExt};
 
 use sp_keystore::KeystorePtr;
 
-use polkadot_node_network_protocol::request_response::{v1, IncomingRequestReceiver};
+use polkadot_node_network_protocol::request_response::{
+	v1, v2, IncomingRequestReceiver, ReqProtocolNames,
+};
 use polkadot_node_subsystem::{
 	jaeger, messages::AvailabilityDistributionMessage, overseer, FromOrchestra, OverseerSignal,
 	SpawnedSubsystem, SubsystemError,
@@ -41,7 +43,7 @@ mod pov_requester;
 
 /// Responding to erasure chunk requests:
 mod responder;
-use responder::{run_chunk_receiver, run_pov_receiver};
+use responder::{run_chunk_receivers, run_pov_receiver};
 
 mod metrics;
 /// Prometheus `Metrics` for availability distribution.
@@ -58,6 +60,8 @@ pub struct AvailabilityDistributionSubsystem {
 	runtime: RuntimeInfo,
 	/// Receivers to receive messages from.
 	recvs: IncomingRequestReceivers,
+	/// Mapping of the req-response protocols to the full protocol names.
+	req_protocol_names: ReqProtocolNames,
 	/// Prometheus metrics.
 	metrics: Metrics,
 }
@@ -66,8 +70,10 @@ pub struct AvailabilityDistributionSubsystem {
 pub struct IncomingRequestReceivers {
 	/// Receiver for incoming PoV requests.
 	pub pov_req_receiver: IncomingRequestReceiver<v1::PoVFetchingRequest>,
-	/// Receiver for incoming availability chunk requests.
-	pub chunk_req_receiver: IncomingRequestReceiver<v1::ChunkFetchingRequest>,
+	/// Receiver for incoming v1 availability chunk requests.
+	pub chunk_req_v1_receiver: IncomingRequestReceiver<v1::ChunkFetchingRequest>,
+	/// Receiver for incoming v2 availability chunk requests.
+	pub chunk_req_v2_receiver: IncomingRequestReceiver<v2::ChunkFetchingRequest>,
 }
 
 #[overseer::subsystem(AvailabilityDistribution, error=SubsystemError, prefix=self::overseer)]
@@ -85,18 +91,27 @@ impl<Context> AvailabilityDistributionSubsystem {
 #[overseer::contextbounds(AvailabilityDistribution, prefix = self::overseer)]
 impl AvailabilityDistributionSubsystem {
 	/// Create a new instance of the availability distribution.
-	pub fn new(keystore: KeystorePtr, recvs: IncomingRequestReceivers, metrics: Metrics) -> Self {
+	pub fn new(
+		keystore: KeystorePtr,
+		recvs: IncomingRequestReceivers,
+		req_protocol_names: ReqProtocolNames,
+		metrics: Metrics,
+	) -> Self {
 		let runtime = RuntimeInfo::new(Some(keystore));
-		Self { runtime, recvs, metrics }
+		Self { runtime, recvs, req_protocol_names, metrics }
 	}
 
 	/// Start processing work as passed on from the Overseer.
 	async fn run<Context>(self, mut ctx: Context) -> std::result::Result<(), FatalError> {
-		let Self { mut runtime, recvs, metrics } = self;
+		let Self { mut runtime, recvs, metrics, req_protocol_names } = self;
 		let mut spans: HashMap<Hash, jaeger::PerLeafSpan> = HashMap::new();
 
-		let IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver } = recvs;
-		let mut requester = Requester::new(metrics.clone()).fuse();
+		let IncomingRequestReceivers {
+			pov_req_receiver,
+			chunk_req_v1_receiver,
+			chunk_req_v2_receiver,
+		} = recvs;
+		let mut requester = Requester::new(req_protocol_names, metrics.clone()).fuse();
 		let mut warn_freq = gum::Freq::new();
 
 		{
@@ -109,7 +124,13 @@ impl AvailabilityDistributionSubsystem {
 
 			ctx.spawn(
 				"chunk-receiver",
-				run_chunk_receiver(sender, chunk_req_receiver, metrics.clone()).boxed(),
+				run_chunk_receivers(
+					sender,
+					chunk_req_v1_receiver,
+					chunk_req_v2_receiver,
+					metrics.clone(),
+				)
+				.boxed(),
 			)
 			.map_err(FatalError::SpawnTask)?;
 		}
diff --git a/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs b/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs
index f99002d4188bf584b927510d86ec0ef3eb272baa..6c632fa7efee6ecec2d11f7bb9f42cd8164587f1 100644
--- a/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs
+++ b/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs
@@ -138,7 +138,7 @@ mod tests {
 	use assert_matches::assert_matches;
 	use futures::{executor, future};
 
-	use parity_scale_codec::Encode;
+	use codec::Encode;
 	use sc_network::ProtocolName;
 	use sp_core::testing::TaskExecutor;
 
@@ -169,10 +169,11 @@ mod tests {
 
 	fn test_run(pov_hash: Hash, pov: PoV) {
 		let pool = TaskExecutor::new();
-		let (mut context, mut virtual_overseer) = test_helpers::make_subsystem_context::<
-			AvailabilityDistributionMessage,
-			TaskExecutor,
-		>(pool.clone());
+		let (mut context, mut virtual_overseer) =
+			polkadot_node_subsystem_test_helpers::make_subsystem_context::<
+				AvailabilityDistributionMessage,
+				TaskExecutor,
+			>(pool.clone());
 		let keystore = make_ferdie_keystore();
 		let mut runtime = polkadot_node_subsystem_util::runtime::RuntimeInfo::new(Some(keystore));
 
diff --git a/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs b/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs
index f478defcaa96530d695eace0acad11057609d8e9..278608cc858df5e6f586606c5b66d37147d67e15 100644
--- a/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs
+++ b/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs
@@ -22,10 +22,12 @@ use futures::{
 	FutureExt, SinkExt,
 };
 
+use codec::Decode;
 use polkadot_erasure_coding::branch_hash;
 use polkadot_node_network_protocol::request_response::{
 	outgoing::{OutgoingRequest, Recipient, RequestError, Requests},
-	v1::{ChunkFetchingRequest, ChunkFetchingResponse},
+	v1::{self, ChunkResponse},
+	v2,
 };
 use polkadot_node_primitives::ErasureChunk;
 use polkadot_node_subsystem::{
@@ -34,9 +36,10 @@ use polkadot_node_subsystem::{
 	overseer,
 };
 use polkadot_primitives::{
-	AuthorityDiscoveryId, BlakeTwo256, CandidateHash, GroupIndex, Hash, HashT, OccupiedCore,
-	SessionIndex,
+	AuthorityDiscoveryId, BlakeTwo256, CandidateHash, ChunkIndex, GroupIndex, Hash, HashT,
+	OccupiedCore, SessionIndex,
 };
+use sc_network::ProtocolName;
 
 use crate::{
 	error::{FatalError, Result},
@@ -111,8 +114,8 @@ struct RunningTask {
 	/// This vector gets drained during execution of the task (it will be empty afterwards).
 	group: Vec<AuthorityDiscoveryId>,
 
-	/// The request to send.
-	request: ChunkFetchingRequest,
+	/// The request to send. We can store it as either v1 or v2, they have the same payload.
+	request: v2::ChunkFetchingRequest,
 
 	/// Root hash, for verifying the chunks validity.
 	erasure_root: Hash,
@@ -128,6 +131,16 @@ struct RunningTask {
 
 	/// Span tracking the fetching of this chunk.
 	span: jaeger::Span,
+
+	/// Expected chunk index. We'll validate that the remote did send us the correct chunk (only
+	/// important for v2 requests).
+	chunk_index: ChunkIndex,
+
+	/// Full protocol name for ChunkFetchingV1.
+	req_v1_protocol_name: ProtocolName,
+
+	/// Full protocol name for ChunkFetchingV2.
+	req_v2_protocol_name: ProtocolName,
 }
 
 impl FetchTaskConfig {
@@ -140,13 +153,17 @@ impl FetchTaskConfig {
 		sender: mpsc::Sender<FromFetchTask>,
 		metrics: Metrics,
 		session_info: &SessionInfo,
+		chunk_index: ChunkIndex,
 		span: jaeger::Span,
+		req_v1_protocol_name: ProtocolName,
+		req_v2_protocol_name: ProtocolName,
 	) -> Self {
 		let span = span
 			.child("fetch-task-config")
 			.with_trace_id(core.candidate_hash)
 			.with_string_tag("leaf", format!("{:?}", leaf))
 			.with_validator_index(session_info.our_index)
+			.with_chunk_index(chunk_index)
 			.with_uint_tag("group-index", core.group_responsible.0 as u64)
 			.with_relay_parent(core.candidate_descriptor.relay_parent)
 			.with_string_tag("pov-hash", format!("{:?}", core.candidate_descriptor.pov_hash))
@@ -165,7 +182,7 @@ impl FetchTaskConfig {
 			group: session_info.validator_groups.get(core.group_responsible.0 as usize)
 				.expect("The responsible group of a candidate should be available in the corresponding session. qed.")
 				.clone(),
-			request: ChunkFetchingRequest {
+			request: v2::ChunkFetchingRequest {
 				candidate_hash: core.candidate_hash,
 				index: session_info.our_index,
 			},
@@ -174,6 +191,9 @@ impl FetchTaskConfig {
 			metrics,
 			sender,
 			span,
+			chunk_index,
+			req_v1_protocol_name,
+			req_v2_protocol_name
 		};
 		FetchTaskConfig { live_in, prepared_running: Some(prepared_running) }
 	}
@@ -271,7 +291,8 @@ impl RunningTask {
 			count += 1;
 			let _chunk_fetch_span = span
 				.child("fetch-chunk-request")
-				.with_chunk_index(self.request.index.0)
+				.with_validator_index(self.request.index)
+				.with_chunk_index(self.chunk_index)
 				.with_stage(jaeger::Stage::AvailabilityDistribution);
 			// Send request:
 			let resp = match self
@@ -296,11 +317,12 @@ impl RunningTask {
 			drop(_chunk_fetch_span);
 			let _chunk_recombine_span = span
 				.child("recombine-chunk")
-				.with_chunk_index(self.request.index.0)
+				.with_validator_index(self.request.index)
+				.with_chunk_index(self.chunk_index)
 				.with_stage(jaeger::Stage::AvailabilityDistribution);
 			let chunk = match resp {
-				ChunkFetchingResponse::Chunk(resp) => resp.recombine_into_chunk(&self.request),
-				ChunkFetchingResponse::NoSuchChunk => {
+				Some(chunk) => chunk,
+				None => {
 					gum::debug!(
 						target: LOG_TARGET,
 						validator = ?validator,
@@ -320,11 +342,12 @@ impl RunningTask {
 			drop(_chunk_recombine_span);
 			let _chunk_validate_and_store_span = span
 				.child("validate-and-store-chunk")
-				.with_chunk_index(self.request.index.0)
+				.with_validator_index(self.request.index)
+				.with_chunk_index(self.chunk_index)
 				.with_stage(jaeger::Stage::AvailabilityDistribution);
 
 			// Data genuine?
-			if !self.validate_chunk(&validator, &chunk) {
+			if !self.validate_chunk(&validator, &chunk, self.chunk_index) {
 				bad_validators.push(validator);
 				continue
 			}
@@ -350,7 +373,7 @@ impl RunningTask {
 		validator: &AuthorityDiscoveryId,
 		network_error_freq: &mut gum::Freq,
 		canceled_freq: &mut gum::Freq,
-	) -> std::result::Result<ChunkFetchingResponse, TaskError> {
+	) -> std::result::Result<Option<ErasureChunk>, TaskError> {
 		gum::trace!(
 			target: LOG_TARGET,
 			origin = ?validator,
@@ -362,9 +385,13 @@ impl RunningTask {
 			"Starting chunk request",
 		);
 
-		let (full_request, response_recv) =
-			OutgoingRequest::new(Recipient::Authority(validator.clone()), self.request);
-		let requests = Requests::ChunkFetchingV1(full_request);
+		let (full_request, response_recv) = OutgoingRequest::new_with_fallback(
+			Recipient::Authority(validator.clone()),
+			self.request,
+			// Fallback to v1, for backwards compatibility.
+			v1::ChunkFetchingRequest::from(self.request),
+		);
+		let requests = Requests::ChunkFetching(full_request);
 
 		self.sender
 			.send(FromFetchTask::Message(
@@ -378,7 +405,58 @@ impl RunningTask {
 			.map_err(|_| TaskError::ShuttingDown)?;
 
 		match response_recv.await {
-			Ok(resp) => Ok(resp),
+			Ok((bytes, protocol)) => match protocol {
+				_ if protocol == self.req_v2_protocol_name =>
+					match v2::ChunkFetchingResponse::decode(&mut &bytes[..]) {
+						Ok(chunk_response) => Ok(Option::<ErasureChunk>::from(chunk_response)),
+						Err(e) => {
+							gum::warn!(
+								target: LOG_TARGET,
+								origin = ?validator,
+								relay_parent = ?self.relay_parent,
+								group_index = ?self.group_index,
+								session_index = ?self.session_index,
+								chunk_index = ?self.request.index,
+								candidate_hash = ?self.request.candidate_hash,
+								err = ?e,
+								"Peer sent us invalid erasure chunk data (v2)"
+							);
+							Err(TaskError::PeerError)
+						},
+					},
+				_ if protocol == self.req_v1_protocol_name =>
+					match v1::ChunkFetchingResponse::decode(&mut &bytes[..]) {
+						Ok(chunk_response) => Ok(Option::<ChunkResponse>::from(chunk_response)
+							.map(|c| c.recombine_into_chunk(&self.request.into()))),
+						Err(e) => {
+							gum::warn!(
+								target: LOG_TARGET,
+								origin = ?validator,
+								relay_parent = ?self.relay_parent,
+								group_index = ?self.group_index,
+								session_index = ?self.session_index,
+								chunk_index = ?self.request.index,
+								candidate_hash = ?self.request.candidate_hash,
+								err = ?e,
+								"Peer sent us invalid erasure chunk data"
+							);
+							Err(TaskError::PeerError)
+						},
+					},
+				_ => {
+					gum::warn!(
+						target: LOG_TARGET,
+						origin = ?validator,
+						relay_parent = ?self.relay_parent,
+						group_index = ?self.group_index,
+						session_index = ?self.session_index,
+						chunk_index = ?self.request.index,
+						candidate_hash = ?self.request.candidate_hash,
+						"Peer sent us invalid erasure chunk data - unknown protocol"
+					);
+					Err(TaskError::PeerError)
+				},
+			},
 			Err(RequestError::InvalidResponse(err)) => {
 				gum::warn!(
 					target: LOG_TARGET,
@@ -427,7 +505,23 @@ impl RunningTask {
 		}
 	}
 
-	fn validate_chunk(&self, validator: &AuthorityDiscoveryId, chunk: &ErasureChunk) -> bool {
+	fn validate_chunk(
+		&self,
+		validator: &AuthorityDiscoveryId,
+		chunk: &ErasureChunk,
+		expected_chunk_index: ChunkIndex,
+	) -> bool {
+		if chunk.index != expected_chunk_index {
+			gum::warn!(
+				target: LOG_TARGET,
+				candidate_hash = ?self.request.candidate_hash,
+				origin = ?validator,
+				chunk_index = ?chunk.index,
+				expected_chunk_index = ?expected_chunk_index,
+				"Validator sent the wrong chunk",
+			);
+			return false
+		}
 		let anticipated_hash =
 			match branch_hash(&self.erasure_root, chunk.proof(), chunk.index.0 as usize) {
 				Ok(hash) => hash,
@@ -459,6 +553,7 @@ impl RunningTask {
 				AvailabilityStoreMessage::StoreChunk {
 					candidate_hash: self.request.candidate_hash,
 					chunk,
+					validator_index: self.request.index,
 					tx,
 				}
 				.into(),
diff --git a/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs b/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs
index a5a81082e39ad8897845363960120956b1599a95..2cd4bf29a56356dc56dd2538467da0f2078fccaf 100644
--- a/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs
+++ b/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs
@@ -16,7 +16,7 @@
 
 use std::collections::HashMap;
 
-use parity_scale_codec::Encode;
+use codec::Encode;
 
 use futures::{
 	channel::{mpsc, oneshot},
@@ -24,21 +24,26 @@ use futures::{
 	task::{noop_waker, Context, Poll},
 	Future, FutureExt, StreamExt,
 };
+use rstest::rstest;
 
 use sc_network::{self as network, ProtocolName};
 use sp_keyring::Sr25519Keyring;
 
-use polkadot_node_network_protocol::request_response::{v1, Recipient};
+use polkadot_node_network_protocol::request_response::{
+	v1::{self, ChunkResponse},
+	Protocol, Recipient, ReqProtocolNames,
+};
 use polkadot_node_primitives::{BlockData, PoV, Proof};
 use polkadot_node_subsystem::messages::AllMessages;
-use polkadot_primitives::{CandidateHash, ValidatorIndex};
+use polkadot_primitives::{CandidateHash, ChunkIndex, ValidatorIndex};
 
 use super::*;
 use crate::{metrics::Metrics, tests::mock::get_valid_chunk_data};
 
 #[test]
 fn task_can_be_canceled() {
-	let (task, _rx) = get_test_running_task();
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	let (task, _rx) = get_test_running_task(&req_protocol_names, 0.into(), 0.into());
 	let (handle, kill) = oneshot::channel();
 	std::mem::drop(handle);
 	let running_task = task.run(kill);
@@ -49,96 +54,130 @@ fn task_can_be_canceled() {
 }
 
 /// Make sure task won't accept a chunk that has is invalid.
-#[test]
-fn task_does_not_accept_invalid_chunk() {
-	let (mut task, rx) = get_test_running_task();
+#[rstest]
+#[case(Protocol::ChunkFetchingV1)]
+#[case(Protocol::ChunkFetchingV2)]
+fn task_does_not_accept_invalid_chunk(#[case] protocol: Protocol) {
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	let chunk_index = ChunkIndex(1);
+	let validator_index = ValidatorIndex(0);
+	let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index);
 	let validators = vec![Sr25519Keyring::Alice.public().into()];
 	task.group = validators;
+	let protocol_name = req_protocol_names.get_name(protocol);
 	let test = TestRun {
 		chunk_responses: {
-			let mut m = HashMap::new();
-			m.insert(
+			[(
 				Recipient::Authority(Sr25519Keyring::Alice.public().into()),
-				ChunkFetchingResponse::Chunk(v1::ChunkResponse {
-					chunk: vec![1, 2, 3],
-					proof: Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(),
-				}),
-			);
-			m
+				get_response(
+					protocol,
+					protocol_name.clone(),
+					Some((
+						vec![1, 2, 3],
+						Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(),
+						chunk_index,
+					)),
+				),
+			)]
+			.into_iter()
+			.collect()
 		},
 		valid_chunks: HashSet::new(),
+		req_protocol_names,
 	};
 	test.run(task, rx);
 }
 
-#[test]
-fn task_stores_valid_chunk() {
-	let (mut task, rx) = get_test_running_task();
+#[rstest]
+#[case(Protocol::ChunkFetchingV1)]
+#[case(Protocol::ChunkFetchingV2)]
+fn task_stores_valid_chunk(#[case] protocol: Protocol) {
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	// In order for protocol version 1 to work, the chunk index needs to be equal to the validator
+	// index.
+	let chunk_index = ChunkIndex(0);
+	let validator_index =
+		if protocol == Protocol::ChunkFetchingV1 { ValidatorIndex(0) } else { ValidatorIndex(1) };
+	let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index);
+	let validators = vec![Sr25519Keyring::Alice.public().into()];
 	let pov = PoV { block_data: BlockData(vec![45, 46, 47]) };
-	let (root_hash, chunk) = get_valid_chunk_data(pov);
+	let (root_hash, chunk) = get_valid_chunk_data(pov, 10, chunk_index);
 	task.erasure_root = root_hash;
-	task.request.index = chunk.index;
-
-	let validators = vec![Sr25519Keyring::Alice.public().into()];
 	task.group = validators;
+	let protocol_name = req_protocol_names.get_name(protocol);
 
 	let test = TestRun {
 		chunk_responses: {
-			let mut m = HashMap::new();
-			m.insert(
+			[(
 				Recipient::Authority(Sr25519Keyring::Alice.public().into()),
-				ChunkFetchingResponse::Chunk(v1::ChunkResponse {
-					chunk: chunk.chunk.clone(),
-					proof: chunk.proof,
-				}),
-			);
-			m
-		},
-		valid_chunks: {
-			let mut s = HashSet::new();
-			s.insert(chunk.chunk);
-			s
+				get_response(
+					protocol,
+					protocol_name.clone(),
+					Some((chunk.chunk.clone(), chunk.proof, chunk_index)),
+				),
+			)]
+			.into_iter()
+			.collect()
 		},
+		valid_chunks: [(chunk.chunk)].into_iter().collect(),
+		req_protocol_names,
 	};
 	test.run(task, rx);
 }
 
-#[test]
-fn task_does_not_accept_wrongly_indexed_chunk() {
-	let (mut task, rx) = get_test_running_task();
-	let pov = PoV { block_data: BlockData(vec![45, 46, 47]) };
-	let (root_hash, chunk) = get_valid_chunk_data(pov);
-	task.erasure_root = root_hash;
-	task.request.index = ValidatorIndex(chunk.index.0 + 1);
+#[rstest]
+#[case(Protocol::ChunkFetchingV1)]
+#[case(Protocol::ChunkFetchingV2)]
+fn task_does_not_accept_wrongly_indexed_chunk(#[case] protocol: Protocol) {
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	// In order for protocol version 1 to work, the chunk index needs to be equal to the validator
+	// index.
+	let chunk_index = ChunkIndex(0);
+	let validator_index =
+		if protocol == Protocol::ChunkFetchingV1 { ValidatorIndex(0) } else { ValidatorIndex(1) };
+	let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index);
 
 	let validators = vec![Sr25519Keyring::Alice.public().into()];
+	let pov = PoV { block_data: BlockData(vec![45, 46, 47]) };
+	let (_, other_chunk) = get_valid_chunk_data(pov.clone(), 10, ChunkIndex(3));
+	let (root_hash, chunk) = get_valid_chunk_data(pov, 10, ChunkIndex(0));
+	task.erasure_root = root_hash;
+	task.request.index = chunk.index.into();
 	task.group = validators;
+	let protocol_name = req_protocol_names.get_name(protocol);
 
 	let test = TestRun {
 		chunk_responses: {
-			let mut m = HashMap::new();
-			m.insert(
+			[(
 				Recipient::Authority(Sr25519Keyring::Alice.public().into()),
-				ChunkFetchingResponse::Chunk(v1::ChunkResponse {
-					chunk: chunk.chunk.clone(),
-					proof: chunk.proof,
-				}),
-			);
-			m
+				get_response(
+					protocol,
+					protocol_name.clone(),
+					Some((other_chunk.chunk.clone(), chunk.proof, other_chunk.index)),
+				),
+			)]
+			.into_iter()
+			.collect()
 		},
 		valid_chunks: HashSet::new(),
+		req_protocol_names,
 	};
 	test.run(task, rx);
 }
 
 /// Task stores chunk, if there is at least one validator having a valid chunk.
-#[test]
-fn task_stores_valid_chunk_if_there_is_one() {
-	let (mut task, rx) = get_test_running_task();
+#[rstest]
+#[case(Protocol::ChunkFetchingV1)]
+#[case(Protocol::ChunkFetchingV2)]
+fn task_stores_valid_chunk_if_there_is_one(#[case] protocol: Protocol) {
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	// In order for protocol version 1 to work, the chunk index needs to be equal to the validator
+	// index.
+	let chunk_index = ChunkIndex(1);
+	let validator_index =
+		if protocol == Protocol::ChunkFetchingV1 { ValidatorIndex(1) } else { ValidatorIndex(2) };
+	let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index);
 	let pov = PoV { block_data: BlockData(vec![45, 46, 47]) };
-	let (root_hash, chunk) = get_valid_chunk_data(pov);
-	task.erasure_root = root_hash;
-	task.request.index = chunk.index;
 
 	let validators = [
 		// Only Alice has valid chunk - should succeed, even though she is tried last.
@@ -151,37 +190,45 @@ fn task_stores_valid_chunk_if_there_is_one() {
 	.iter()
 	.map(|v| v.public().into())
 	.collect::<Vec<_>>();
+
+	let (root_hash, chunk) = get_valid_chunk_data(pov, 10, chunk_index);
+	task.erasure_root = root_hash;
 	task.group = validators;
+	let protocol_name = req_protocol_names.get_name(protocol);
 
 	let test = TestRun {
 		chunk_responses: {
-			let mut m = HashMap::new();
-			m.insert(
-				Recipient::Authority(Sr25519Keyring::Alice.public().into()),
-				ChunkFetchingResponse::Chunk(v1::ChunkResponse {
-					chunk: chunk.chunk.clone(),
-					proof: chunk.proof,
-				}),
-			);
-			m.insert(
-				Recipient::Authority(Sr25519Keyring::Bob.public().into()),
-				ChunkFetchingResponse::NoSuchChunk,
-			);
-			m.insert(
-				Recipient::Authority(Sr25519Keyring::Charlie.public().into()),
-				ChunkFetchingResponse::Chunk(v1::ChunkResponse {
-					chunk: vec![1, 2, 3],
-					proof: Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(),
-				}),
-			);
-
-			m
-		},
-		valid_chunks: {
-			let mut s = HashSet::new();
-			s.insert(chunk.chunk);
-			s
+			[
+				(
+					Recipient::Authority(Sr25519Keyring::Alice.public().into()),
+					get_response(
+						protocol,
+						protocol_name.clone(),
+						Some((chunk.chunk.clone(), chunk.proof, chunk_index)),
+					),
+				),
+				(
+					Recipient::Authority(Sr25519Keyring::Bob.public().into()),
+					get_response(protocol, protocol_name.clone(), None),
+				),
+				(
+					Recipient::Authority(Sr25519Keyring::Charlie.public().into()),
+					get_response(
+						protocol,
+						protocol_name.clone(),
+						Some((
+							vec![1, 2, 3],
+							Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(),
+							chunk_index,
+						)),
+					),
+				),
+			]
+			.into_iter()
+			.collect()
 		},
+		valid_chunks: [(chunk.chunk)].into_iter().collect(),
+		req_protocol_names,
 	};
 	test.run(task, rx);
 }
@@ -189,14 +236,16 @@ fn task_stores_valid_chunk_if_there_is_one() {
 struct TestRun {
 	/// Response to deliver for a given validator index.
 	/// None means, answer with `NetworkError`.
-	chunk_responses: HashMap<Recipient, ChunkFetchingResponse>,
+	chunk_responses: HashMap<Recipient, (Vec<u8>, ProtocolName)>,
 	/// Set of chunks that should be considered valid:
 	valid_chunks: HashSet<Vec<u8>>,
+	/// Request protocol names
+	req_protocol_names: ReqProtocolNames,
 }
 
 impl TestRun {
 	fn run(self, task: RunningTask, rx: mpsc::Receiver<FromFetchTask>) {
-		sp_tracing::try_init_simple();
+		sp_tracing::init_for_tests();
 		let mut rx = rx.fuse();
 		let task = task.run_inner().fuse();
 		futures::pin_mut!(task);
@@ -240,20 +289,41 @@ impl TestRun {
 				let mut valid_responses = 0;
 				for req in reqs {
 					let req = match req {
-						Requests::ChunkFetchingV1(req) => req,
+						Requests::ChunkFetching(req) => req,
 						_ => panic!("Unexpected request"),
 					};
 					let response =
 						self.chunk_responses.get(&req.peer).ok_or(network::RequestFailure::Refused);
 
-					if let Ok(ChunkFetchingResponse::Chunk(resp)) = &response {
-						if self.valid_chunks.contains(&resp.chunk) {
-							valid_responses += 1;
+					if let Ok((resp, protocol)) = response {
+						let chunk = if protocol ==
+							&self.req_protocol_names.get_name(Protocol::ChunkFetchingV1)
+						{
+							Into::<Option<v1::ChunkResponse>>::into(
+								v1::ChunkFetchingResponse::decode(&mut &resp[..]).unwrap(),
+							)
+							.map(|c| c.chunk)
+						} else if protocol ==
+							&self.req_protocol_names.get_name(Protocol::ChunkFetchingV2)
+						{
+							Into::<Option<ErasureChunk>>::into(
+								v2::ChunkFetchingResponse::decode(&mut &resp[..]).unwrap(),
+							)
+							.map(|c| c.chunk)
+						} else {
+							unreachable!()
+						};
+
+						if let Some(chunk) = chunk {
+							if self.valid_chunks.contains(&chunk) {
+								valid_responses += 1;
+							}
 						}
+
+						req.pending_response
+							.send(response.cloned())
+							.expect("Sending response should succeed");
 					}
-					req.pending_response
-						.send(response.map(|r| (r.encode(), ProtocolName::from(""))))
-						.expect("Sending response should succeed");
 				}
 				return (valid_responses == 0) && self.valid_chunks.is_empty()
 			},
@@ -274,8 +344,12 @@ impl TestRun {
 	}
 }
 
-/// Get a `RunningTask` filled with dummy values.
-fn get_test_running_task() -> (RunningTask, mpsc::Receiver<FromFetchTask>) {
+/// Get a `RunningTask` filled with (mostly) dummy values.
+fn get_test_running_task(
+	req_protocol_names: &ReqProtocolNames,
+	validator_index: ValidatorIndex,
+	chunk_index: ChunkIndex,
+) -> (RunningTask, mpsc::Receiver<FromFetchTask>) {
 	let (tx, rx) = mpsc::channel(0);
 
 	(
@@ -283,16 +357,45 @@ fn get_test_running_task() -> (RunningTask, mpsc::Receiver<FromFetchTask>) {
 			session_index: 0,
 			group_index: GroupIndex(0),
 			group: Vec::new(),
-			request: ChunkFetchingRequest {
+			request: v2::ChunkFetchingRequest {
 				candidate_hash: CandidateHash([43u8; 32].into()),
-				index: ValidatorIndex(0),
+				index: validator_index,
 			},
 			erasure_root: Hash::repeat_byte(99),
 			relay_parent: Hash::repeat_byte(71),
 			sender: tx,
 			metrics: Metrics::new_dummy(),
 			span: jaeger::Span::Disabled,
+			req_v1_protocol_name: req_protocol_names.get_name(Protocol::ChunkFetchingV1),
+			req_v2_protocol_name: req_protocol_names.get_name(Protocol::ChunkFetchingV2),
+			chunk_index,
 		},
 		rx,
 	)
 }
+
+/// Make a versioned ChunkFetchingResponse.
+fn get_response(
+	protocol: Protocol,
+	protocol_name: ProtocolName,
+	chunk: Option<(Vec<u8>, Proof, ChunkIndex)>,
+) -> (Vec<u8>, ProtocolName) {
+	(
+		match protocol {
+			Protocol::ChunkFetchingV1 => if let Some((chunk, proof, _)) = chunk {
+				v1::ChunkFetchingResponse::Chunk(ChunkResponse { chunk, proof })
+			} else {
+				v1::ChunkFetchingResponse::NoSuchChunk
+			}
+			.encode(),
+			Protocol::ChunkFetchingV2 => if let Some((chunk, proof, index)) = chunk {
+				v2::ChunkFetchingResponse::Chunk(ErasureChunk { chunk, index, proof })
+			} else {
+				v2::ChunkFetchingResponse::NoSuchChunk
+			}
+			.encode(),
+			_ => unreachable!(),
+		},
+		protocol_name,
+	)
+}
diff --git a/polkadot/node/network/availability-distribution/src/requester/mod.rs b/polkadot/node/network/availability-distribution/src/requester/mod.rs
index 97e80d696e7ef2adabdbc24dda76172603e462f0..efbdceb43bddc6c9501fb5ed6dc3c2e42100df7b 100644
--- a/polkadot/node/network/availability-distribution/src/requester/mod.rs
+++ b/polkadot/node/network/availability-distribution/src/requester/mod.rs
@@ -18,10 +18,7 @@
 //! availability.
 
 use std::{
-	collections::{
-		hash_map::{Entry, HashMap},
-		hash_set::HashSet,
-	},
+	collections::{hash_map::HashMap, hash_set::HashSet},
 	iter::IntoIterator,
 	pin::Pin,
 };
@@ -32,13 +29,17 @@ use futures::{
 	Stream,
 };
 
+use polkadot_node_network_protocol::request_response::{v1, v2, IsRequest, ReqProtocolNames};
 use polkadot_node_subsystem::{
 	jaeger,
 	messages::{ChainApiMessage, RuntimeApiMessage},
 	overseer, ActivatedLeaf, ActiveLeavesUpdate,
 };
-use polkadot_node_subsystem_util::runtime::{get_occupied_cores, RuntimeInfo};
-use polkadot_primitives::{CandidateHash, Hash, OccupiedCore, SessionIndex};
+use polkadot_node_subsystem_util::{
+	availability_chunks::availability_chunk_index,
+	runtime::{get_occupied_cores, RuntimeInfo},
+};
+use polkadot_primitives::{CandidateHash, CoreIndex, Hash, OccupiedCore, SessionIndex};
 
 use super::{FatalError, Metrics, Result, LOG_TARGET};
 
@@ -77,6 +78,9 @@ pub struct Requester {
 
 	/// Prometheus Metrics
 	metrics: Metrics,
+
+	/// Mapping of the req-response protocols to the full protocol names.
+	req_protocol_names: ReqProtocolNames,
 }
 
 #[overseer::contextbounds(AvailabilityDistribution, prefix = self::overseer)]
@@ -88,9 +92,16 @@ impl Requester {
 	///
 	/// You must feed it with `ActiveLeavesUpdate` via `update_fetching_heads` and make it progress
 	/// by advancing the stream.
-	pub fn new(metrics: Metrics) -> Self {
+	pub fn new(req_protocol_names: ReqProtocolNames, metrics: Metrics) -> Self {
 		let (tx, rx) = mpsc::channel(1);
-		Requester { fetches: HashMap::new(), session_cache: SessionCache::new(), tx, rx, metrics }
+		Requester {
+			fetches: HashMap::new(),
+			session_cache: SessionCache::new(),
+			tx,
+			rx,
+			metrics,
+			req_protocol_names,
+		}
 	}
 
 	/// Update heads that need availability distribution.
@@ -197,56 +208,76 @@ impl Requester {
 		runtime: &mut RuntimeInfo,
 		leaf: Hash,
 		leaf_session_index: SessionIndex,
-		cores: impl IntoIterator<Item = OccupiedCore>,
+		cores: impl IntoIterator<Item = (CoreIndex, OccupiedCore)>,
 		span: jaeger::Span,
 	) -> Result<()> {
-		for core in cores {
+		for (core_index, core) in cores {
 			let mut span = span
 				.child("check-fetch-candidate")
 				.with_trace_id(core.candidate_hash)
 				.with_string_tag("leaf", format!("{:?}", leaf))
 				.with_candidate(core.candidate_hash)
 				.with_stage(jaeger::Stage::AvailabilityDistribution);
-			match self.fetches.entry(core.candidate_hash) {
-				Entry::Occupied(mut e) =>
+
+			if let Some(e) = self.fetches.get_mut(&core.candidate_hash) {
 				// Just book keeping - we are already requesting that chunk:
-				{
-					span.add_string_tag("already-requested-chunk", "true");
-					e.get_mut().add_leaf(leaf);
-				},
-				Entry::Vacant(e) => {
-					span.add_string_tag("already-requested-chunk", "false");
-					let tx = self.tx.clone();
-					let metrics = self.metrics.clone();
-
-					let task_cfg = self
-						.session_cache
-						.with_session_info(
-							context,
-							runtime,
-							// We use leaf here, the relay_parent must be in the same session as
-							// the leaf. This is guaranteed by runtime which ensures that cores are
-							// cleared at session boundaries. At the same time, only leaves are
-							// guaranteed to be fetchable by the state trie.
-							leaf,
-							leaf_session_index,
-							|info| FetchTaskConfig::new(leaf, &core, tx, metrics, info, span),
-						)
-						.await
-						.map_err(|err| {
-							gum::warn!(
-								target: LOG_TARGET,
-								error = ?err,
-								"Failed to spawn a fetch task"
-							);
-							err
+				span.add_string_tag("already-requested-chunk", "true");
+				e.add_leaf(leaf);
+			} else {
+				span.add_string_tag("already-requested-chunk", "false");
+				let tx = self.tx.clone();
+				let metrics = self.metrics.clone();
+
+				let session_info = self
+					.session_cache
+					.get_session_info(
+						context,
+						runtime,
+						// We use leaf here, the relay_parent must be in the same session as
+						// the leaf. This is guaranteed by runtime which ensures that cores are
+						// cleared at session boundaries. At the same time, only leaves are
+						// guaranteed to be fetchable by the state trie.
+						leaf,
+						leaf_session_index,
+					)
+					.await
+					.map_err(|err| {
+						gum::warn!(
+							target: LOG_TARGET,
+							error = ?err,
+							"Failed to spawn a fetch task"
+						);
+						err
+					})?;
+
+				if let Some(session_info) = session_info {
+					let n_validators =
+						session_info.validator_groups.iter().fold(0usize, |mut acc, group| {
+							acc = acc.saturating_add(group.len());
+							acc
 						});
-
-					if let Ok(Some(task_cfg)) = task_cfg {
-						e.insert(FetchTask::start(task_cfg, context).await?);
-					}
-					// Not a validator, nothing to do.
-				},
+					let chunk_index = availability_chunk_index(
+						session_info.node_features.as_ref(),
+						n_validators,
+						core_index,
+						session_info.our_index,
+					)?;
+
+					let task_cfg = FetchTaskConfig::new(
+						leaf,
+						&core,
+						tx,
+						metrics,
+						session_info,
+						chunk_index,
+						span,
+						self.req_protocol_names.get_name(v1::ChunkFetchingRequest::PROTOCOL),
+						self.req_protocol_names.get_name(v2::ChunkFetchingRequest::PROTOCOL),
+					);
+
+					self.fetches
+						.insert(core.candidate_hash, FetchTask::start(task_cfg, context).await?);
+				}
 			}
 		}
 		Ok(())
diff --git a/polkadot/node/network/availability-distribution/src/requester/session_cache.rs b/polkadot/node/network/availability-distribution/src/requester/session_cache.rs
index 8a48e19c2827d13fe2d15ea4cc5ded50f058ca03..a762c262dba3ec1df0c7609017b704d867f11141 100644
--- a/polkadot/node/network/availability-distribution/src/requester/session_cache.rs
+++ b/polkadot/node/network/availability-distribution/src/requester/session_cache.rs
@@ -20,8 +20,10 @@ use rand::{seq::SliceRandom, thread_rng};
 use schnellru::{ByLength, LruMap};
 
 use polkadot_node_subsystem::overseer;
-use polkadot_node_subsystem_util::runtime::RuntimeInfo;
-use polkadot_primitives::{AuthorityDiscoveryId, GroupIndex, Hash, SessionIndex, ValidatorIndex};
+use polkadot_node_subsystem_util::runtime::{request_node_features, RuntimeInfo};
+use polkadot_primitives::{
+	AuthorityDiscoveryId, GroupIndex, Hash, NodeFeatures, SessionIndex, ValidatorIndex,
+};
 
 use crate::{
 	error::{Error, Result},
@@ -62,6 +64,9 @@ pub struct SessionInfo {
 	///
 	/// `None`, if we are not in fact part of any group.
 	pub our_group: Option<GroupIndex>,
+
+	/// Node features.
+	pub node_features: Option<NodeFeatures>,
 }
 
 /// Report of bad validators.
@@ -87,39 +92,29 @@ impl SessionCache {
 		}
 	}
 
-	/// Tries to retrieve `SessionInfo` and calls `with_info` if successful.
-	///
+	/// Tries to retrieve `SessionInfo`.
 	/// If this node is not a validator, the function will return `None`.
-	///
-	/// Use this function over any `fetch_session_info` if all you need is a reference to
-	/// `SessionInfo`, as it avoids an expensive clone.
-	pub async fn with_session_info<Context, F, R>(
-		&mut self,
+	pub async fn get_session_info<'a, Context>(
+		&'a mut self,
 		ctx: &mut Context,
 		runtime: &mut RuntimeInfo,
 		parent: Hash,
 		session_index: SessionIndex,
-		with_info: F,
-	) -> Result<Option<R>>
-	where
-		F: FnOnce(&SessionInfo) -> R,
-	{
-		if let Some(o_info) = self.session_info_cache.get(&session_index) {
-			gum::trace!(target: LOG_TARGET, session_index, "Got session from lru");
-			return Ok(Some(with_info(o_info)))
+	) -> Result<Option<&'a SessionInfo>> {
+		gum::trace!(target: LOG_TARGET, session_index, "Calling `get_session_info`");
+
+		if self.session_info_cache.get(&session_index).is_none() {
+			if let Some(info) =
+				Self::query_info_from_runtime(ctx, runtime, parent, session_index).await?
+			{
+				gum::trace!(target: LOG_TARGET, session_index, "Storing session info in lru!");
+				self.session_info_cache.insert(session_index, info);
+			} else {
+				return Ok(None)
+			}
 		}
 
-		if let Some(info) =
-			self.query_info_from_runtime(ctx, runtime, parent, session_index).await?
-		{
-			gum::trace!(target: LOG_TARGET, session_index, "Calling `with_info`");
-			let r = with_info(&info);
-			gum::trace!(target: LOG_TARGET, session_index, "Storing session info in lru!");
-			self.session_info_cache.insert(session_index, info);
-			Ok(Some(r))
-		} else {
-			Ok(None)
-		}
+		Ok(self.session_info_cache.get(&session_index).map(|i| &*i))
 	}
 
 	/// Variant of `report_bad` that never fails, but just logs errors.
@@ -171,7 +166,6 @@ impl SessionCache {
 	///
 	/// Returns: `None` if not a validator.
 	async fn query_info_from_runtime<Context>(
-		&self,
 		ctx: &mut Context,
 		runtime: &mut RuntimeInfo,
 		relay_parent: Hash,
@@ -181,6 +175,9 @@ impl SessionCache {
 			.get_session_info_by_index(ctx.sender(), relay_parent, session_index)
 			.await?;
 
+		let node_features =
+			request_node_features(relay_parent, session_index, ctx.sender()).await?;
+
 		let discovery_keys = info.session_info.discovery_keys.clone();
 		let mut validator_groups = info.session_info.validator_groups.clone();
 
@@ -208,7 +205,13 @@ impl SessionCache {
 				})
 				.collect();
 
-			let info = SessionInfo { validator_groups, our_index, session_index, our_group };
+			let info = SessionInfo {
+				validator_groups,
+				our_index,
+				session_index,
+				our_group,
+				node_features,
+			};
 			return Ok(Some(info))
 		}
 		return Ok(None)
diff --git a/polkadot/node/network/availability-distribution/src/requester/tests.rs b/polkadot/node/network/availability-distribution/src/requester/tests.rs
index 0dedd4f091acd692c5b319f5669c1356bf335e2b..09567a8f87d322f4befca53c14712b72b9b0e0fc 100644
--- a/polkadot/node/network/availability-distribution/src/requester/tests.rs
+++ b/polkadot/node/network/availability-distribution/src/requester/tests.rs
@@ -14,21 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
-
-use std::future::Future;
-
 use futures::FutureExt;
+use std::{collections::HashMap, future::Future};
 
-use polkadot_node_network_protocol::jaeger;
+use polkadot_node_network_protocol::{jaeger, request_response::ReqProtocolNames};
 use polkadot_node_primitives::{BlockData, ErasureChunk, PoV};
-use polkadot_node_subsystem_test_helpers::mock::new_leaf;
 use polkadot_node_subsystem_util::runtime::RuntimeInfo;
 use polkadot_primitives::{
-	BlockNumber, CoreState, ExecutorParams, GroupIndex, Hash, Id as ParaId, NodeFeatures,
+	BlockNumber, ChunkIndex, CoreState, ExecutorParams, GroupIndex, Hash, Id as ParaId,
 	ScheduledCore, SessionIndex, SessionInfo,
 };
-use sp_core::traits::SpawnNamed;
+use sp_core::{testing::TaskExecutor, traits::SpawnNamed};
 
 use polkadot_node_subsystem::{
 	messages::{
@@ -38,19 +34,21 @@ use polkadot_node_subsystem::{
 	ActiveLeavesUpdate, SpawnGlue,
 };
 use polkadot_node_subsystem_test_helpers::{
-	make_subsystem_context, mock::make_ferdie_keystore, TestSubsystemContext,
-	TestSubsystemContextHandle,
+	make_subsystem_context,
+	mock::{make_ferdie_keystore, new_leaf},
+	TestSubsystemContext, TestSubsystemContextHandle,
 };
 
-use sp_core::testing::TaskExecutor;
-
-use crate::tests::mock::{get_valid_chunk_data, make_session_info, OccupiedCoreBuilder};
+use crate::tests::{
+	mock::{get_valid_chunk_data, make_session_info, OccupiedCoreBuilder},
+	node_features_with_mapping_enabled,
+};
 
 use super::Requester;
 
 fn get_erasure_chunk() -> ErasureChunk {
 	let pov = PoV { block_data: BlockData(vec![45, 46, 47]) };
-	get_valid_chunk_data(pov).1
+	get_valid_chunk_data(pov, 10, ChunkIndex(0)).1
 }
 
 #[derive(Clone)]
@@ -126,7 +124,7 @@ fn spawn_virtual_overseer(
 									.expect("Receiver should be alive.");
 							},
 							RuntimeApiRequest::NodeFeatures(_, tx) => {
-								tx.send(Ok(NodeFeatures::EMPTY))
+								tx.send(Ok(node_features_with_mapping_enabled()))
 									.expect("Receiver should be alive.");
 							},
 							RuntimeApiRequest::AvailabilityCores(tx) => {
@@ -146,6 +144,8 @@ fn spawn_virtual_overseer(
 													group_responsible: GroupIndex(1),
 													para_id,
 													relay_parent: hash,
+													n_validators: 10,
+													chunk_index: ChunkIndex(0),
 												}
 												.build()
 												.0,
@@ -201,7 +201,8 @@ fn test_harness<T: Future<Output = ()>>(
 #[test]
 fn check_ancestry_lookup_in_same_session() {
 	let test_state = TestState::new();
-	let mut requester = Requester::new(Default::default());
+	let mut requester =
+		Requester::new(ReqProtocolNames::new(&Hash::repeat_byte(0xff), None), Default::default());
 	let keystore = make_ferdie_keystore();
 	let mut runtime = RuntimeInfo::new(Some(keystore));
 
@@ -268,7 +269,8 @@ fn check_ancestry_lookup_in_same_session() {
 #[test]
 fn check_ancestry_lookup_in_different_sessions() {
 	let mut test_state = TestState::new();
-	let mut requester = Requester::new(Default::default());
+	let mut requester =
+		Requester::new(ReqProtocolNames::new(&Hash::repeat_byte(0xff), None), Default::default());
 	let keystore = make_ferdie_keystore();
 	let mut runtime = RuntimeInfo::new(Some(keystore));
 
diff --git a/polkadot/node/network/availability-distribution/src/responder.rs b/polkadot/node/network/availability-distribution/src/responder.rs
index 54b188f7f01fc7e22b4ea7679be0a67f8d9d0d37..fb08c47125038edffff6e5d7cd57d986ed5fe138 100644
--- a/polkadot/node/network/availability-distribution/src/responder.rs
+++ b/polkadot/node/network/availability-distribution/src/responder.rs
@@ -18,11 +18,12 @@
 
 use std::sync::Arc;
 
-use futures::channel::oneshot;
+use futures::{channel::oneshot, select, FutureExt};
 
+use codec::{Decode, Encode};
 use fatality::Nested;
 use polkadot_node_network_protocol::{
-	request_response::{v1, IncomingRequest, IncomingRequestReceiver},
+	request_response::{v1, v2, IncomingRequest, IncomingRequestReceiver, IsRequest},
 	UnifiedReputationChange as Rep,
 };
 use polkadot_node_primitives::{AvailableData, ErasureChunk};
@@ -66,33 +67,66 @@ pub async fn run_pov_receiver<Sender>(
 }
 
 /// Receiver task to be forked as a separate task to handle chunk requests.
-pub async fn run_chunk_receiver<Sender>(
+pub async fn run_chunk_receivers<Sender>(
 	mut sender: Sender,
-	mut receiver: IncomingRequestReceiver<v1::ChunkFetchingRequest>,
+	mut receiver_v1: IncomingRequestReceiver<v1::ChunkFetchingRequest>,
+	mut receiver_v2: IncomingRequestReceiver<v2::ChunkFetchingRequest>,
 	metrics: Metrics,
 ) where
 	Sender: SubsystemSender<AvailabilityStoreMessage>,
 {
+	let make_resp_v1 = |chunk: Option<ErasureChunk>| match chunk {
+		None => v1::ChunkFetchingResponse::NoSuchChunk,
+		Some(chunk) => v1::ChunkFetchingResponse::Chunk(chunk.into()),
+	};
+
+	let make_resp_v2 = |chunk: Option<ErasureChunk>| match chunk {
+		None => v2::ChunkFetchingResponse::NoSuchChunk,
+		Some(chunk) => v2::ChunkFetchingResponse::Chunk(chunk.into()),
+	};
+
 	loop {
-		match receiver.recv(|| vec![COST_INVALID_REQUEST]).await.into_nested() {
-			Ok(Ok(msg)) => {
-				answer_chunk_request_log(&mut sender, msg, &metrics).await;
-			},
-			Err(fatal) => {
-				gum::debug!(
-					target: LOG_TARGET,
-					error = ?fatal,
-					"Shutting down chunk receiver."
-				);
-				return
-			},
-			Ok(Err(jfyi)) => {
-				gum::debug!(
-					target: LOG_TARGET,
-					error = ?jfyi,
-					"Error decoding incoming chunk request."
-				);
+		select! {
+			res = receiver_v1.recv(|| vec![COST_INVALID_REQUEST]).fuse() => match res.into_nested() {
+				Ok(Ok(msg)) => {
+					answer_chunk_request_log(&mut sender, msg, make_resp_v1, &metrics).await;
+				},
+				Err(fatal) => {
+					gum::debug!(
+						target: LOG_TARGET,
+						error = ?fatal,
+						"Shutting down chunk receiver."
+					);
+					return
+				},
+				Ok(Err(jfyi)) => {
+					gum::debug!(
+						target: LOG_TARGET,
+						error = ?jfyi,
+						"Error decoding incoming chunk request."
+					);
+				}
 			},
+			res = receiver_v2.recv(|| vec![COST_INVALID_REQUEST]).fuse() => match res.into_nested() {
+				Ok(Ok(msg)) => {
+					answer_chunk_request_log(&mut sender, msg.into(), make_resp_v2, &metrics).await;
+				},
+				Err(fatal) => {
+					gum::debug!(
+						target: LOG_TARGET,
+						error = ?fatal,
+						"Shutting down chunk receiver."
+					);
+					return
+				},
+				Ok(Err(jfyi)) => {
+					gum::debug!(
+						target: LOG_TARGET,
+						error = ?jfyi,
+						"Error decoding incoming chunk request."
+					);
+				}
+			}
 		}
 	}
 }
@@ -124,15 +158,18 @@ pub async fn answer_pov_request_log<Sender>(
 /// Variant of `answer_chunk_request` that does Prometheus metric and logging on errors.
 ///
 /// Any errors of `answer_request` will simply be logged.
-pub async fn answer_chunk_request_log<Sender>(
+pub async fn answer_chunk_request_log<Sender, Req, MakeResp>(
 	sender: &mut Sender,
-	req: IncomingRequest<v1::ChunkFetchingRequest>,
+	req: IncomingRequest<Req>,
+	make_response: MakeResp,
 	metrics: &Metrics,
-) -> ()
-where
+) where
+	Req: IsRequest + Decode + Encode + Into<v1::ChunkFetchingRequest>,
+	Req::Response: Encode,
 	Sender: SubsystemSender<AvailabilityStoreMessage>,
+	MakeResp: Fn(Option<ErasureChunk>) -> Req::Response,
 {
-	let res = answer_chunk_request(sender, req).await;
+	let res = answer_chunk_request(sender, req, make_response).await;
 	match res {
 		Ok(result) => metrics.on_served_chunk(if result { SUCCEEDED } else { NOT_FOUND }),
 		Err(err) => {
@@ -177,39 +214,46 @@ where
 /// Answer an incoming chunk request by querying the av store.
 ///
 /// Returns: `Ok(true)` if chunk was found and served.
-pub async fn answer_chunk_request<Sender>(
+pub async fn answer_chunk_request<Sender, Req, MakeResp>(
 	sender: &mut Sender,
-	req: IncomingRequest<v1::ChunkFetchingRequest>,
+	req: IncomingRequest<Req>,
+	make_response: MakeResp,
 ) -> Result<bool>
 where
 	Sender: SubsystemSender<AvailabilityStoreMessage>,
+	Req: IsRequest + Decode + Encode + Into<v1::ChunkFetchingRequest>,
+	Req::Response: Encode,
+	MakeResp: Fn(Option<ErasureChunk>) -> Req::Response,
 {
-	let span = jaeger::Span::new(req.payload.candidate_hash, "answer-chunk-request");
+	// V1 and V2 requests have the same payload, so decoding into either one will work. It's the
+	// responses that differ, hence the `MakeResp` generic.
+	let payload: v1::ChunkFetchingRequest = req.payload.into();
+	let span = jaeger::Span::new(payload.candidate_hash, "answer-chunk-request");
 
 	let _child_span = span
 		.child("answer-chunk-request")
-		.with_trace_id(req.payload.candidate_hash)
-		.with_chunk_index(req.payload.index.0);
+		.with_trace_id(payload.candidate_hash)
+		.with_validator_index(payload.index);
 
-	let chunk = query_chunk(sender, req.payload.candidate_hash, req.payload.index).await?;
+	let chunk = query_chunk(sender, payload.candidate_hash, payload.index).await?;
 
 	let result = chunk.is_some();
 
 	gum::trace!(
 		target: LOG_TARGET,
-		hash = ?req.payload.candidate_hash,
-		index = ?req.payload.index,
+		hash = ?payload.candidate_hash,
+		index = ?payload.index,
 		peer = ?req.peer,
 		has_data = ?chunk.is_some(),
 		"Serving chunk",
 	);
 
-	let response = match chunk {
-		None => v1::ChunkFetchingResponse::NoSuchChunk,
-		Some(chunk) => v1::ChunkFetchingResponse::Chunk(chunk.into()),
-	};
+	let response = make_response(chunk);
+
+	req.pending_response
+		.send_response(response)
+		.map_err(|_| JfyiError::SendResponse)?;
 
-	req.send_response(response).map_err(|_| JfyiError::SendResponse)?;
 	Ok(result)
 }
 
diff --git a/polkadot/node/network/availability-distribution/src/tests/mock.rs b/polkadot/node/network/availability-distribution/src/tests/mock.rs
index 3df662fe546c07f7a7f58d02d0ceafd98a7e1b6c..b41c493a10721bbdd988125d1c355ad9e4cc4824 100644
--- a/polkadot/node/network/availability-distribution/src/tests/mock.rs
+++ b/polkadot/node/network/availability-distribution/src/tests/mock.rs
@@ -23,9 +23,9 @@ use sp_keyring::Sr25519Keyring;
 use polkadot_erasure_coding::{branches, obtain_chunks_v1 as obtain_chunks};
 use polkadot_node_primitives::{AvailableData, BlockData, ErasureChunk, PoV, Proof};
 use polkadot_primitives::{
-	CandidateCommitments, CandidateDescriptor, CandidateHash, CommittedCandidateReceipt,
-	GroupIndex, Hash, HeadData, Id as ParaId, IndexedVec, OccupiedCore, PersistedValidationData,
-	SessionInfo, ValidatorIndex,
+	CandidateCommitments, CandidateDescriptor, CandidateHash, ChunkIndex,
+	CommittedCandidateReceipt, GroupIndex, Hash, HeadData, Id as ParaId, IndexedVec, OccupiedCore,
+	PersistedValidationData, SessionInfo, ValidatorIndex,
 };
 use polkadot_primitives_test_helpers::{
 	dummy_collator, dummy_collator_signature, dummy_hash, dummy_validation_code,
@@ -75,13 +75,16 @@ pub struct OccupiedCoreBuilder {
 	pub group_responsible: GroupIndex,
 	pub para_id: ParaId,
 	pub relay_parent: Hash,
+	pub n_validators: usize,
+	pub chunk_index: ChunkIndex,
 }
 
 impl OccupiedCoreBuilder {
 	pub fn build(self) -> (OccupiedCore, (CandidateHash, ErasureChunk)) {
 		let pov = PoV { block_data: BlockData(vec![45, 46, 47]) };
 		let pov_hash = pov.hash();
-		let (erasure_root, chunk) = get_valid_chunk_data(pov.clone());
+		let (erasure_root, chunk) =
+			get_valid_chunk_data(pov.clone(), self.n_validators, self.chunk_index);
 		let candidate_receipt = TestCandidateBuilder {
 			para_id: self.para_id,
 			pov_hash,
@@ -133,8 +136,11 @@ impl TestCandidateBuilder {
 }
 
 // Get chunk for index 0
-pub fn get_valid_chunk_data(pov: PoV) -> (Hash, ErasureChunk) {
-	let fake_validator_count = 10;
+pub fn get_valid_chunk_data(
+	pov: PoV,
+	n_validators: usize,
+	chunk_index: ChunkIndex,
+) -> (Hash, ErasureChunk) {
 	let persisted = PersistedValidationData {
 		parent_head: HeadData(vec![7, 8, 9]),
 		relay_parent_number: Default::default(),
@@ -142,17 +148,17 @@ pub fn get_valid_chunk_data(pov: PoV) -> (Hash, ErasureChunk) {
 		relay_parent_storage_root: Default::default(),
 	};
 	let available_data = AvailableData { validation_data: persisted, pov: Arc::new(pov) };
-	let chunks = obtain_chunks(fake_validator_count, &available_data).unwrap();
+	let chunks = obtain_chunks(n_validators, &available_data).unwrap();
 	let branches = branches(chunks.as_ref());
 	let root = branches.root();
 	let chunk = branches
 		.enumerate()
 		.map(|(index, (proof, chunk))| ErasureChunk {
 			chunk: chunk.to_vec(),
-			index: ValidatorIndex(index as _),
+			index: ChunkIndex(index as _),
 			proof: Proof::try_from(proof).unwrap(),
 		})
-		.next()
-		.expect("There really should be 10 chunks.");
+		.nth(chunk_index.0 as usize)
+		.expect("There really should be enough chunks.");
 	(root, chunk)
 }
diff --git a/polkadot/node/network/availability-distribution/src/tests/mod.rs b/polkadot/node/network/availability-distribution/src/tests/mod.rs
index 214498979fb68307ce45705e396a7e306d53da87..3320871bceb5ad152c3dbd3483a86babbcf8994d 100644
--- a/polkadot/node/network/availability-distribution/src/tests/mod.rs
+++ b/polkadot/node/network/availability-distribution/src/tests/mod.rs
@@ -17,13 +17,14 @@
 use std::collections::HashSet;
 
 use futures::{executor, future, Future};
+use rstest::rstest;
 
-use polkadot_node_network_protocol::request_response::{IncomingRequest, ReqProtocolNames};
-use polkadot_primitives::{Block, CoreState, Hash};
+use polkadot_node_network_protocol::request_response::{
+	IncomingRequest, Protocol, ReqProtocolNames,
+};
+use polkadot_primitives::{node_features, Block, CoreState, Hash, NodeFeatures};
 use sp_keystore::KeystorePtr;
 
-use polkadot_node_subsystem_test_helpers as test_helpers;
-
 use super::*;
 
 mod state;
@@ -35,67 +36,130 @@ pub(crate) mod mock;
 
 fn test_harness<T: Future<Output = ()>>(
 	keystore: KeystorePtr,
+	req_protocol_names: ReqProtocolNames,
 	test_fx: impl FnOnce(TestHarness) -> T,
-) {
-	sp_tracing::try_init_simple();
+) -> std::result::Result<(), FatalError> {
+	sp_tracing::init_for_tests();
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
-	let genesis_hash = Hash::repeat_byte(0xff);
-	let req_protocol_names = ReqProtocolNames::new(&genesis_hash, None);
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let (pov_req_receiver, pov_req_cfg) = IncomingRequest::get_config_receiver::<
 		Block,
 		sc_network::NetworkWorker<Block, Hash>,
 	>(&req_protocol_names);
-	let (chunk_req_receiver, chunk_req_cfg) = IncomingRequest::get_config_receiver::<
+	let (chunk_req_v1_receiver, chunk_req_v1_cfg) = IncomingRequest::get_config_receiver::<
+		Block,
+		sc_network::NetworkWorker<Block, Hash>,
+	>(&req_protocol_names);
+	let (chunk_req_v2_receiver, chunk_req_v2_cfg) = IncomingRequest::get_config_receiver::<
 		Block,
 		sc_network::NetworkWorker<Block, Hash>,
 	>(&req_protocol_names);
 	let subsystem = AvailabilityDistributionSubsystem::new(
 		keystore,
-		IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver },
+		IncomingRequestReceivers { pov_req_receiver, chunk_req_v1_receiver, chunk_req_v2_receiver },
+		req_protocol_names,
 		Default::default(),
 	);
 	let subsystem = subsystem.run(context);
 
-	let test_fut = test_fx(TestHarness { virtual_overseer, pov_req_cfg, chunk_req_cfg, pool });
+	let test_fut = test_fx(TestHarness {
+		virtual_overseer,
+		pov_req_cfg,
+		chunk_req_v1_cfg,
+		chunk_req_v2_cfg,
+		pool,
+	});
 
 	futures::pin_mut!(test_fut);
 	futures::pin_mut!(subsystem);
 
-	executor::block_on(future::join(test_fut, subsystem)).1.unwrap();
+	executor::block_on(future::join(test_fut, subsystem)).1
+}
+
+pub fn node_features_with_mapping_enabled() -> NodeFeatures {
+	let mut node_features = NodeFeatures::new();
+	node_features.resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false);
+	node_features.set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true);
+	node_features
 }
 
 /// Simple basic check, whether the subsystem works as expected.
 ///
 /// Exceptional cases are tested as unit tests in `fetch_task`.
-#[test]
-fn check_basic() {
-	let state = TestState::default();
-	test_harness(state.keystore.clone(), move |harness| state.run(harness));
+#[rstest]
+#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV1)]
+#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV2)]
+#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV1)]
+#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV2)]
+fn check_basic(#[case] node_features: NodeFeatures, #[case] chunk_resp_protocol: Protocol) {
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	let state =
+		TestState::new(node_features.clone(), req_protocol_names.clone(), chunk_resp_protocol);
+
+	if node_features == node_features_with_mapping_enabled() &&
+		chunk_resp_protocol == Protocol::ChunkFetchingV1
+	{
+		// For this specific case, chunk fetching is not possible, because the ValidatorIndex is not
+		// equal to the ChunkIndex and the peer does not send back the actual ChunkIndex.
+		let _ = test_harness(state.keystore.clone(), req_protocol_names, move |harness| {
+			state.run_assert_timeout(harness)
+		});
+	} else {
+		test_harness(state.keystore.clone(), req_protocol_names, move |harness| state.run(harness))
+			.unwrap();
+	}
 }
 
 /// Check whether requester tries all validators in group.
-#[test]
-fn check_fetch_tries_all() {
-	let mut state = TestState::default();
+#[rstest]
+#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV1)]
+#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV2)]
+#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV1)]
+#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV2)]
+fn check_fetch_tries_all(
+	#[case] node_features: NodeFeatures,
+	#[case] chunk_resp_protocol: Protocol,
+) {
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	let mut state =
+		TestState::new(node_features.clone(), req_protocol_names.clone(), chunk_resp_protocol);
 	for (_, v) in state.chunks.iter_mut() {
 		// 4 validators in group, so this should still succeed:
 		v.push(None);
 		v.push(None);
 		v.push(None);
 	}
-	test_harness(state.keystore.clone(), move |harness| state.run(harness));
+
+	if node_features == node_features_with_mapping_enabled() &&
+		chunk_resp_protocol == Protocol::ChunkFetchingV1
+	{
+		// For this specific case, chunk fetching is not possible, because the ValidatorIndex is not
+		// equal to the ChunkIndex and the peer does not send back the actual ChunkIndex.
+		let _ = test_harness(state.keystore.clone(), req_protocol_names, move |harness| {
+			state.run_assert_timeout(harness)
+		});
+	} else {
+		test_harness(state.keystore.clone(), req_protocol_names, move |harness| state.run(harness))
+			.unwrap();
+	}
 }
 
 /// Check whether requester tries all validators in group
 ///
 /// Check that requester will retry the fetch on error on the next block still pending
 /// availability.
-#[test]
-fn check_fetch_retry() {
-	let mut state = TestState::default();
+#[rstest]
+#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV1)]
+#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV2)]
+#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV1)]
+#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV2)]
+fn check_fetch_retry(#[case] node_features: NodeFeatures, #[case] chunk_resp_protocol: Protocol) {
+	let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None);
+	let mut state =
+		TestState::new(node_features.clone(), req_protocol_names.clone(), chunk_resp_protocol);
 	state
 		.cores
 		.insert(state.relay_chain[2], state.cores.get(&state.relay_chain[1]).unwrap().clone());
@@ -126,5 +190,17 @@ fn check_fetch_retry() {
 		v.push(None);
 		v.push(None);
 	}
-	test_harness(state.keystore.clone(), move |harness| state.run(harness));
+
+	if node_features == node_features_with_mapping_enabled() &&
+		chunk_resp_protocol == Protocol::ChunkFetchingV1
+	{
+		// For this specific case, chunk fetching is not possible, because the ValidatorIndex is not
+		// equal to the ChunkIndex and the peer does not send back the actual ChunkIndex.
+		let _ = test_harness(state.keystore.clone(), req_protocol_names, move |harness| {
+			state.run_assert_timeout(harness)
+		});
+	} else {
+		test_harness(state.keystore.clone(), req_protocol_names, move |harness| state.run(harness))
+			.unwrap();
+	}
 }
diff --git a/polkadot/node/network/availability-distribution/src/tests/state.rs b/polkadot/node/network/availability-distribution/src/tests/state.rs
index 93411511e763af437d7813c9e5d83bac4609959e..befbff0a2f27efc0f91f1c23f9bdcc1ded704a8f 100644
--- a/polkadot/node/network/availability-distribution/src/tests/state.rs
+++ b/polkadot/node/network/availability-distribution/src/tests/state.rs
@@ -19,9 +19,9 @@ use std::{
 	time::Duration,
 };
 
-use network::ProtocolName;
+use network::{request_responses::OutgoingResponse, ProtocolName, RequestFailure};
 use polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle;
-use polkadot_node_subsystem_util::TimeoutExt;
+use polkadot_node_subsystem_util::{availability_chunks::availability_chunk_index, TimeoutExt};
 
 use futures::{
 	channel::{mpsc, oneshot},
@@ -35,7 +35,7 @@ use sp_core::{testing::TaskExecutor, traits::SpawnNamed};
 use sp_keystore::KeystorePtr;
 
 use polkadot_node_network_protocol::request_response::{
-	v1, IncomingRequest, OutgoingRequest, Requests,
+	v1, v2, IncomingRequest, OutgoingRequest, Protocol, ReqProtocolNames, Requests,
 };
 use polkadot_node_primitives::ErasureChunk;
 use polkadot_node_subsystem::{
@@ -47,19 +47,22 @@ use polkadot_node_subsystem::{
 };
 use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_primitives::{
-	CandidateHash, CoreState, ExecutorParams, GroupIndex, Hash, Id as ParaId, NodeFeatures,
-	ScheduledCore, SessionInfo, ValidatorIndex,
+	CandidateHash, ChunkIndex, CoreIndex, CoreState, ExecutorParams, GroupIndex, Hash,
+	Id as ParaId, NodeFeatures, ScheduledCore, SessionInfo, ValidatorIndex,
 };
 use test_helpers::mock::{make_ferdie_keystore, new_leaf};
 
 use super::mock::{make_session_info, OccupiedCoreBuilder};
 use crate::LOG_TARGET;
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<AvailabilityDistributionMessage>;
+type VirtualOverseer = polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<
+	AvailabilityDistributionMessage,
+>;
 pub struct TestHarness {
 	pub virtual_overseer: VirtualOverseer,
 	pub pov_req_cfg: RequestResponseConfig,
-	pub chunk_req_cfg: RequestResponseConfig,
+	pub chunk_req_v1_cfg: RequestResponseConfig,
+	pub chunk_req_v2_cfg: RequestResponseConfig,
 	pub pool: TaskExecutor,
 }
 
@@ -83,10 +86,19 @@ pub struct TestState {
 	/// Cores per relay chain block.
 	pub cores: HashMap<Hash, Vec<CoreState>>,
 	pub keystore: KeystorePtr,
+	pub node_features: NodeFeatures,
+	pub chunk_response_protocol: Protocol,
+	pub req_protocol_names: ReqProtocolNames,
+	pub our_chunk_index: ChunkIndex,
 }
 
-impl Default for TestState {
-	fn default() -> Self {
+impl TestState {
+	/// Initialize a default test state.
+	pub fn new(
+		node_features: NodeFeatures,
+		req_protocol_names: ReqProtocolNames,
+		chunk_response_protocol: Protocol,
+	) -> Self {
 		let relay_chain: Vec<_> = (1u8..10).map(Hash::repeat_byte).collect();
 		let chain_a = ParaId::from(1);
 		let chain_b = ParaId::from(2);
@@ -97,6 +109,14 @@ impl Default for TestState {
 
 		let session_info = make_session_info();
 
+		let our_chunk_index = availability_chunk_index(
+			Some(&node_features),
+			session_info.validators.len(),
+			CoreIndex(1),
+			ValidatorIndex(0),
+		)
+		.unwrap();
+
 		let (cores, chunks) = {
 			let mut cores = HashMap::new();
 			let mut chunks = HashMap::new();
@@ -123,6 +143,8 @@ impl Default for TestState {
 							group_responsible: GroupIndex(i as _),
 							para_id: *para_id,
 							relay_parent: *relay_parent,
+							n_validators: session_info.validators.len(),
+							chunk_index: our_chunk_index,
 						}
 						.build();
 						(CoreState::Occupied(core), chunk)
@@ -132,8 +154,8 @@ impl Default for TestState {
 				// Skip chunks for our own group (won't get fetched):
 				let mut chunks_other_groups = p_chunks.into_iter();
 				chunks_other_groups.next();
-				for (validator_index, chunk) in chunks_other_groups {
-					chunks.insert((validator_index, chunk.index), vec![Some(chunk)]);
+				for (candidate, chunk) in chunks_other_groups {
+					chunks.insert((candidate, ValidatorIndex(0)), vec![Some(chunk)]);
 				}
 			}
 			(cores, chunks)
@@ -145,18 +167,27 @@ impl Default for TestState {
 			session_info,
 			cores,
 			keystore,
+			node_features,
+			chunk_response_protocol,
+			req_protocol_names,
+			our_chunk_index,
 		}
 	}
-}
 
-impl TestState {
 	/// Run, but fail after some timeout.
 	pub async fn run(self, harness: TestHarness) {
 		// Make sure test won't run forever.
-		let f = self.run_inner(harness).timeout(Duration::from_secs(10));
+		let f = self.run_inner(harness).timeout(Duration::from_secs(5));
 		assert!(f.await.is_some(), "Test ran into timeout");
 	}
 
+	/// Run, and assert an expected timeout.
+	pub async fn run_assert_timeout(self, harness: TestHarness) {
+		// Make sure test won't run forever.
+		let f = self.run_inner(harness).timeout(Duration::from_secs(5));
+		assert!(f.await.is_none(), "Test should have run into timeout");
+	}
+
 	/// Run tests with the given mock values in `TestState`.
 	///
 	/// This will simply advance through the simulated chain and examines whether the subsystem
@@ -214,15 +245,41 @@ impl TestState {
 				)) => {
 					for req in reqs {
 						// Forward requests:
-						let in_req = to_incoming_req(&harness.pool, req);
-						harness
-							.chunk_req_cfg
-							.inbound_queue
-							.as_mut()
-							.unwrap()
-							.send(in_req.into_raw())
-							.await
-							.unwrap();
+						match self.chunk_response_protocol {
+							Protocol::ChunkFetchingV1 => {
+								let in_req = to_incoming_req_v1(
+									&harness.pool,
+									req,
+									self.req_protocol_names.get_name(Protocol::ChunkFetchingV1),
+								);
+
+								harness
+									.chunk_req_v1_cfg
+									.inbound_queue
+									.as_mut()
+									.unwrap()
+									.send(in_req.into_raw())
+									.await
+									.unwrap();
+							},
+							Protocol::ChunkFetchingV2 => {
+								let in_req = to_incoming_req_v2(
+									&harness.pool,
+									req,
+									self.req_protocol_names.get_name(Protocol::ChunkFetchingV2),
+								);
+
+								harness
+									.chunk_req_v2_cfg
+									.inbound_queue
+									.as_mut()
+									.unwrap()
+									.send(in_req.into_raw())
+									.await
+									.unwrap();
+							},
+							_ => panic!("Unexpected protocol"),
+						}
 					}
 				},
 				AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryChunk(
@@ -240,13 +297,16 @@ impl TestState {
 				AllMessages::AvailabilityStore(AvailabilityStoreMessage::StoreChunk {
 					candidate_hash,
 					chunk,
+					validator_index,
 					tx,
 					..
 				}) => {
 					assert!(
-						self.valid_chunks.contains(&(candidate_hash, chunk.index)),
+						self.valid_chunks.contains(&(candidate_hash, validator_index)),
 						"Only valid chunks should ever get stored."
 					);
+					assert_eq!(self.our_chunk_index, chunk.index);
+
 					tx.send(Ok(())).expect("Receiver is expected to be alive");
 					gum::trace!(target: LOG_TARGET, "'Stored' fetched chunk.");
 					remaining_stores -= 1;
@@ -265,14 +325,15 @@ impl TestState {
 							tx.send(Ok(Some(ExecutorParams::default())))
 								.expect("Receiver should be alive.");
 						},
-						RuntimeApiRequest::NodeFeatures(_, si_tx) => {
-							si_tx.send(Ok(NodeFeatures::EMPTY)).expect("Receiver should be alive.");
-						},
 						RuntimeApiRequest::AvailabilityCores(tx) => {
 							gum::trace!(target: LOG_TARGET, cores= ?self.cores[&hash], hash = ?hash, "Sending out cores for hash");
 							tx.send(Ok(self.cores[&hash].clone()))
 								.expect("Receiver should still be alive");
 						},
+						RuntimeApiRequest::NodeFeatures(_, tx) => {
+							tx.send(Ok(self.node_features.clone()))
+								.expect("Receiver should still be alive");
+						},
 						_ => {
 							panic!("Unexpected runtime request: {:?}", req);
 						},
@@ -286,7 +347,10 @@ impl TestState {
 						.unwrap_or_default();
 					response_channel.send(Ok(ancestors)).expect("Receiver is expected to be alive");
 				},
-				_ => {},
+
+				_ => {
+					panic!("Received unexpected message")
+				},
 			}
 		}
 
@@ -310,30 +374,47 @@ async fn overseer_recv(rx: &mut mpsc::UnboundedReceiver<AllMessages>) -> AllMess
 	rx.next().await.expect("Test subsystem no longer live")
 }
 
-fn to_incoming_req(
+fn to_incoming_req_v1(
 	executor: &TaskExecutor,
 	outgoing: Requests,
+	protocol_name: ProtocolName,
 ) -> IncomingRequest<v1::ChunkFetchingRequest> {
 	match outgoing {
-		Requests::ChunkFetchingV1(OutgoingRequest { payload, pending_response, .. }) => {
-			let (tx, rx): (oneshot::Sender<netconfig::OutgoingResponse>, oneshot::Receiver<_>) =
-				oneshot::channel();
-			executor.spawn(
-				"message-forwarding",
-				None,
-				async {
-					let response = rx.await;
-					let payload = response.expect("Unexpected canceled request").result;
-					pending_response
-						.send(
-							payload
-								.map_err(|_| network::RequestFailure::Refused)
-								.map(|r| (r, ProtocolName::from(""))),
-						)
-						.expect("Sending response is expected to work");
-				}
-				.boxed(),
-			);
+		Requests::ChunkFetching(OutgoingRequest {
+			pending_response,
+			fallback_request: Some((fallback_request, fallback_protocol)),
+			..
+		}) => {
+			assert_eq!(fallback_protocol, Protocol::ChunkFetchingV1);
+
+			let tx = spawn_message_forwarding(executor, protocol_name, pending_response);
+
+			IncomingRequest::new(
+				// We don't really care:
+				network::PeerId::random().into(),
+				fallback_request,
+				tx,
+			)
+		},
+		_ => panic!("Unexpected request!"),
+	}
+}
+
+fn to_incoming_req_v2(
+	executor: &TaskExecutor,
+	outgoing: Requests,
+	protocol_name: ProtocolName,
+) -> IncomingRequest<v2::ChunkFetchingRequest> {
+	match outgoing {
+		Requests::ChunkFetching(OutgoingRequest {
+			payload,
+			pending_response,
+			fallback_request: Some((_, fallback_protocol)),
+			..
+		}) => {
+			assert_eq!(fallback_protocol, Protocol::ChunkFetchingV1);
+
+			let tx = spawn_message_forwarding(executor, protocol_name, pending_response);
 
 			IncomingRequest::new(
 				// We don't really care:
@@ -345,3 +426,26 @@ fn to_incoming_req(
 		_ => panic!("Unexpected request!"),
 	}
 }
+
+fn spawn_message_forwarding(
+	executor: &TaskExecutor,
+	protocol_name: ProtocolName,
+	pending_response: oneshot::Sender<Result<(Vec<u8>, ProtocolName), RequestFailure>>,
+) -> oneshot::Sender<OutgoingResponse> {
+	let (tx, rx): (oneshot::Sender<netconfig::OutgoingResponse>, oneshot::Receiver<_>) =
+		oneshot::channel();
+	executor.spawn(
+		"message-forwarding",
+		None,
+		async {
+			let response = rx.await;
+			let payload = response.expect("Unexpected canceled request").result;
+			pending_response
+				.send(payload.map_err(|_| RequestFailure::Refused).map(|r| (r, protocol_name)))
+				.expect("Sending response is expected to work");
+		}
+		.boxed(),
+	);
+
+	tx
+}
diff --git a/polkadot/node/network/availability-recovery/Cargo.toml b/polkadot/node/network/availability-recovery/Cargo.toml
index eb503f502b2983367fc036c1aea3723958eada7e..1c9c861e6f733ebf7e23ae323d6685c9ce26a66b 100644
--- a/polkadot/node/network/availability-recovery/Cargo.toml
+++ b/polkadot/node/network/availability-recovery/Cargo.toml
@@ -25,15 +25,16 @@ polkadot-node-primitives = { path = "../../primitives" }
 polkadot-node-subsystem = { path = "../../subsystem" }
 polkadot-node-subsystem-util = { path = "../../subsystem-util" }
 polkadot-node-network-protocol = { path = "../protocol" }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sc-network = { path = "../../../../substrate/client/network" }
 
 [dev-dependencies]
 assert_matches = "1.4.0"
-env_logger = "0.11"
 futures-timer = "3.0.2"
+rstest = "0.18.2"
 log = { workspace = true, default-features = true }
 
+sp-tracing = { path = "../../../../substrate/primitives/tracing" }
 sp-core = { path = "../../../../substrate/primitives/core" }
 sp-keyring = { path = "../../../../substrate/primitives/keyring" }
 sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" }
diff --git a/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs b/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs
index d9bdc1a2d944d71231d0679fd5e5ef79a52cc782..c734ac99e870df128c5443e9cb3b83371bc1156f 100644
--- a/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs
+++ b/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs
@@ -23,7 +23,7 @@
 
 use polkadot_subsystem_bench::{
 	availability::{
-		benchmark_availability_read, prepare_test, DataAvailabilityReadOptions,
+		benchmark_availability_read, prepare_test, DataAvailabilityReadOptions, Strategy,
 		TestDataAvailability, TestState,
 	},
 	configuration::TestConfiguration,
@@ -37,7 +37,7 @@ const BENCH_COUNT: usize = 10;
 fn main() -> Result<(), String> {
 	let mut messages = vec![];
 
-	let options = DataAvailabilityReadOptions { fetch_from_backers: true };
+	let options = DataAvailabilityReadOptions { strategy: Strategy::FullFromBackers };
 	let mut config = TestConfiguration::default();
 	config.num_blocks = 3;
 	config.generate_pov_sizes();
@@ -51,11 +51,7 @@ fn main() -> Result<(), String> {
 			std::io::stdout().flush().unwrap();
 			let (mut env, _cfgs) =
 				prepare_test(&state, TestDataAvailability::Read(options.clone()), false);
-			env.runtime().block_on(benchmark_availability_read(
-				"data_availability_read",
-				&mut env,
-				&state,
-			))
+			env.runtime().block_on(benchmark_availability_read(&mut env, &state))
 		})
 		.collect();
 	println!("\rDone!{}", " ".repeat(BENCH_COUNT));
@@ -74,7 +70,7 @@ fn main() -> Result<(), String> {
 		("Received from peers", 307203.0000, 0.001),
 		("Sent to peers", 1.6667, 0.001),
 	]));
-	messages.extend(average_usage.check_cpu_usage(&[("availability-recovery", 12.8338, 0.1)]));
+	messages.extend(average_usage.check_cpu_usage(&[("availability-recovery", 12.8412, 0.1)]));
 
 	if messages.is_empty() {
 		Ok(())
diff --git a/polkadot/node/network/availability-recovery/src/error.rs b/polkadot/node/network/availability-recovery/src/error.rs
index 47277a521b81ee72261ab8d71ff9f0cf97bf56ad..eaec4cbc9d9426fce260a4fdc2744506bf34c830 100644
--- a/polkadot/node/network/availability-recovery/src/error.rs
+++ b/polkadot/node/network/availability-recovery/src/error.rs
@@ -16,20 +16,34 @@
 
 //! The `Error` and `Result` types used by the subsystem.
 
+use crate::LOG_TARGET;
+use fatality::{fatality, Nested};
 use futures::channel::oneshot;
-use thiserror::Error;
+use polkadot_node_network_protocol::request_response::incoming;
+use polkadot_node_subsystem::{RecoveryError, SubsystemError};
+use polkadot_primitives::Hash;
 
 /// Error type used by the Availability Recovery subsystem.
-#[derive(Debug, Error)]
+#[fatality(splitable)]
 pub enum Error {
-	#[error(transparent)]
-	Subsystem(#[from] polkadot_node_subsystem::SubsystemError),
+	#[fatal]
+	#[error("Spawning subsystem task failed: {0}")]
+	SpawnTask(#[source] SubsystemError),
+
+	/// Receiving subsystem message from overseer failed.
+	#[fatal]
+	#[error("Receiving message from overseer failed: {0}")]
+	SubsystemReceive(#[source] SubsystemError),
 
+	#[fatal]
 	#[error("failed to query full data from store")]
 	CanceledQueryFullData(#[source] oneshot::Canceled),
 
-	#[error("failed to query session info")]
-	CanceledSessionInfo(#[source] oneshot::Canceled),
+	#[error("`SessionInfo` is `None` at {0}")]
+	SessionInfoUnavailable(Hash),
+
+	#[error("failed to query node features from runtime")]
+	RequestNodeFeatures(#[source] polkadot_node_subsystem_util::runtime::Error),
 
 	#[error("failed to send response")]
 	CanceledResponseSender,
@@ -40,8 +54,38 @@ pub enum Error {
 	#[error(transparent)]
 	Erasure(#[from] polkadot_erasure_coding::Error),
 
+	#[fatal]
 	#[error(transparent)]
-	Util(#[from] polkadot_node_subsystem_util::Error),
+	Oneshot(#[from] oneshot::Canceled),
+
+	#[fatal(forward)]
+	#[error("Error during recovery: {0}")]
+	Recovery(#[from] RecoveryError),
+
+	#[fatal(forward)]
+	#[error("Retrieving next incoming request failed: {0}")]
+	IncomingRequest(#[from] incoming::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
+
+/// Utility for eating top level errors and log them.
+///
+/// We basically always want to try and continue on error, unless the error is fatal for the entire
+/// subsystem.
+pub fn log_error(result: Result<()>) -> std::result::Result<(), FatalError> {
+	match result.into_nested()? {
+		Ok(()) => Ok(()),
+		Err(jfyi) => {
+			jfyi.log();
+			Ok(())
+		},
+	}
+}
+
+impl JfyiError {
+	/// Log a `JfyiError`.
+	pub fn log(self) {
+		gum::warn!(target: LOG_TARGET, "{}", self);
+	}
+}
diff --git a/polkadot/node/network/availability-recovery/src/lib.rs b/polkadot/node/network/availability-recovery/src/lib.rs
index 94b9d9546cdecd4a244bc3de9e10c1db4c3c066d..167125f987ab8f9af4f1d8b91ebd33d80bd05039 100644
--- a/polkadot/node/network/availability-recovery/src/lib.rs
+++ b/polkadot/node/network/availability-recovery/src/lib.rs
@@ -19,7 +19,7 @@
 #![warn(missing_docs)]
 
 use std::{
-	collections::{HashMap, VecDeque},
+	collections::{BTreeMap, VecDeque},
 	iter::Iterator,
 	num::NonZeroUsize,
 	pin::Pin,
@@ -34,31 +34,41 @@ use futures::{
 	stream::{FuturesUnordered, StreamExt},
 	task::{Context, Poll},
 };
+use sc_network::ProtocolName;
 use schnellru::{ByLength, LruMap};
-use task::{FetchChunks, FetchChunksParams, FetchFull, FetchFullParams};
+use task::{
+	FetchChunks, FetchChunksParams, FetchFull, FetchFullParams, FetchSystematicChunks,
+	FetchSystematicChunksParams,
+};
 
-use fatality::Nested;
 use polkadot_erasure_coding::{
-	branch_hash, branches, obtain_chunks_v1, recovery_threshold, Error as ErasureEncodingError,
+	branches, obtain_chunks_v1, recovery_threshold, systematic_recovery_threshold,
+	Error as ErasureEncodingError,
 };
 use task::{RecoveryParams, RecoveryStrategy, RecoveryTask};
 
+use error::{log_error, Error, FatalError, Result};
 use polkadot_node_network_protocol::{
-	request_response::{v1 as request_v1, IncomingRequestReceiver},
+	request_response::{
+		v1 as request_v1, v2 as request_v2, IncomingRequestReceiver, IsRequest, ReqProtocolNames,
+	},
 	UnifiedReputationChange as Rep,
 };
-use polkadot_node_primitives::{AvailableData, ErasureChunk};
+use polkadot_node_primitives::AvailableData;
 use polkadot_node_subsystem::{
 	errors::RecoveryError,
 	jaeger,
 	messages::{AvailabilityRecoveryMessage, AvailabilityStoreMessage},
 	overseer, ActiveLeavesUpdate, FromOrchestra, OverseerSignal, SpawnedSubsystem,
-	SubsystemContext, SubsystemError, SubsystemResult,
+	SubsystemContext, SubsystemError,
+};
+use polkadot_node_subsystem_util::{
+	availability_chunks::availability_chunk_indices,
+	runtime::{ExtendedSessionInfo, RuntimeInfo},
 };
-use polkadot_node_subsystem_util::request_session_info;
 use polkadot_primitives::{
-	BlakeTwo256, BlockNumber, CandidateHash, CandidateReceipt, GroupIndex, Hash, HashT,
-	SessionIndex, SessionInfo, ValidatorIndex,
+	node_features, BlockNumber, CandidateHash, CandidateReceipt, ChunkIndex, CoreIndex, GroupIndex,
+	Hash, SessionIndex, ValidatorIndex,
 };
 
 mod error;
@@ -70,6 +80,8 @@ pub use metrics::Metrics;
 #[cfg(test)]
 mod tests;
 
+type RecoveryResult = std::result::Result<AvailableData, RecoveryError>;
+
 const LOG_TARGET: &str = "parachain::availability-recovery";
 
 // Size of the LRU cache where we keep recovered data.
@@ -77,19 +89,35 @@ const LRU_SIZE: u32 = 16;
 
 const COST_INVALID_REQUEST: Rep = Rep::CostMajor("Peer sent unparsable request");
 
-/// PoV size limit in bytes for which prefer fetching from backers.
-const SMALL_POV_LIMIT: usize = 128 * 1024;
+/// PoV size limit in bytes for which prefer fetching from backers. (conservative, Polkadot for now)
+pub(crate) const CONSERVATIVE_FETCH_CHUNKS_THRESHOLD: usize = 1 * 1024 * 1024;
+/// PoV size limit in bytes for which prefer fetching from backers. (Kusama and all testnets)
+pub const FETCH_CHUNKS_THRESHOLD: usize = 4 * 1024 * 1024;
 
 #[derive(Clone, PartialEq)]
 /// The strategy we use to recover the PoV.
 pub enum RecoveryStrategyKind {
-	/// We always try the backing group first, then fallback to validator chunks.
-	BackersFirstAlways,
 	/// We try the backing group first if PoV size is lower than specified, then fallback to
 	/// validator chunks.
 	BackersFirstIfSizeLower(usize),
+	/// We try the backing group first if PoV size is lower than specified, then fallback to
+	/// systematic chunks. Regular chunk recovery as a last resort.
+	BackersFirstIfSizeLowerThenSystematicChunks(usize),
+
+	/// The following variants are only helpful for integration tests.
+	///
+	/// We always try the backing group first, then fallback to validator chunks.
+	#[allow(dead_code)]
+	BackersFirstAlways,
 	/// We always recover using validator chunks.
+	#[allow(dead_code)]
 	ChunksAlways,
+	/// First try the backing group. Then systematic chunks.
+	#[allow(dead_code)]
+	BackersThenSystematicChunks,
+	/// Always recover using systematic chunks, fall back to regular chunks.
+	#[allow(dead_code)]
+	SystematicChunks,
 }
 
 /// The Availability Recovery Subsystem.
@@ -107,11 +135,15 @@ pub struct AvailabilityRecoverySubsystem {
 	metrics: Metrics,
 	/// The type of check to perform after available data was recovered.
 	post_recovery_check: PostRecoveryCheck,
+	/// Full protocol name for ChunkFetchingV1.
+	req_v1_protocol_name: ProtocolName,
+	/// Full protocol name for ChunkFetchingV2.
+	req_v2_protocol_name: ProtocolName,
 }
 
 #[derive(Clone, PartialEq, Debug)]
 /// The type of check to perform after available data was recovered.
-pub enum PostRecoveryCheck {
+enum PostRecoveryCheck {
 	/// Reencode the data and check erasure root. For validators.
 	Reencode,
 	/// Only check the pov hash. For collators only.
@@ -119,56 +151,18 @@ pub enum PostRecoveryCheck {
 }
 
 /// Expensive erasure coding computations that we want to run on a blocking thread.
-pub enum ErasureTask {
+enum ErasureTask {
 	/// Reconstructs `AvailableData` from chunks given `n_validators`.
 	Reconstruct(
 		usize,
-		HashMap<ValidatorIndex, ErasureChunk>,
-		oneshot::Sender<Result<AvailableData, ErasureEncodingError>>,
+		BTreeMap<ChunkIndex, Vec<u8>>,
+		oneshot::Sender<std::result::Result<AvailableData, ErasureEncodingError>>,
 	),
 	/// Re-encode `AvailableData` into erasure chunks in order to verify the provided root hash of
 	/// the Merkle tree.
 	Reencode(usize, Hash, AvailableData, oneshot::Sender<Option<AvailableData>>),
 }
 
-const fn is_unavailable(
-	received_chunks: usize,
-	requesting_chunks: usize,
-	unrequested_validators: usize,
-	threshold: usize,
-) -> bool {
-	received_chunks + requesting_chunks + unrequested_validators < threshold
-}
-
-/// Check validity of a chunk.
-fn is_chunk_valid(params: &RecoveryParams, chunk: &ErasureChunk) -> bool {
-	let anticipated_hash =
-		match branch_hash(&params.erasure_root, chunk.proof(), chunk.index.0 as usize) {
-			Ok(hash) => hash,
-			Err(e) => {
-				gum::debug!(
-					target: LOG_TARGET,
-					candidate_hash = ?params.candidate_hash,
-					validator_index = ?chunk.index,
-					error = ?e,
-					"Invalid Merkle proof",
-				);
-				return false
-			},
-		};
-	let erasure_chunk_hash = BlakeTwo256::hash(&chunk.chunk);
-	if anticipated_hash != erasure_chunk_hash {
-		gum::debug!(
-			target: LOG_TARGET,
-			candidate_hash = ?params.candidate_hash,
-			validator_index = ?chunk.index,
-			"Merkle proof mismatch"
-		);
-		return false
-	}
-	true
-}
-
 /// Re-encode the data into erasure chunks in order to verify
 /// the root hash of the provided Merkle tree, which is built
 /// on-top of the encoded chunks.
@@ -212,12 +206,12 @@ fn reconstructed_data_matches_root(
 /// Accumulate all awaiting sides for some particular `AvailableData`.
 struct RecoveryHandle {
 	candidate_hash: CandidateHash,
-	remote: RemoteHandle<Result<AvailableData, RecoveryError>>,
-	awaiting: Vec<oneshot::Sender<Result<AvailableData, RecoveryError>>>,
+	remote: RemoteHandle<RecoveryResult>,
+	awaiting: Vec<oneshot::Sender<RecoveryResult>>,
 }
 
 impl Future for RecoveryHandle {
-	type Output = Option<(CandidateHash, Result<AvailableData, RecoveryError>)>;
+	type Output = Option<(CandidateHash, RecoveryResult)>;
 
 	fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
 		let mut indices_to_remove = Vec::new();
@@ -271,7 +265,7 @@ enum CachedRecovery {
 
 impl CachedRecovery {
 	/// Convert back to	`Result` to deliver responses.
-	fn into_result(self) -> Result<AvailableData, RecoveryError> {
+	fn into_result(self) -> RecoveryResult {
 		match self {
 			Self::Valid(d) => Ok(d),
 			Self::Invalid => Err(RecoveryError::Invalid),
@@ -279,9 +273,9 @@ impl CachedRecovery {
 	}
 }
 
-impl TryFrom<Result<AvailableData, RecoveryError>> for CachedRecovery {
+impl TryFrom<RecoveryResult> for CachedRecovery {
 	type Error = ();
-	fn try_from(o: Result<AvailableData, RecoveryError>) -> Result<CachedRecovery, Self::Error> {
+	fn try_from(o: RecoveryResult) -> std::result::Result<CachedRecovery, Self::Error> {
 		match o {
 			Ok(d) => Ok(Self::Valid(d)),
 			Err(RecoveryError::Invalid) => Ok(Self::Invalid),
@@ -303,6 +297,9 @@ struct State {
 
 	/// An LRU cache of recently recovered data.
 	availability_lru: LruMap<CandidateHash, CachedRecovery>,
+
+	/// Cached runtime info.
+	runtime_info: RuntimeInfo,
 }
 
 impl Default for State {
@@ -311,6 +308,7 @@ impl Default for State {
 			ongoing_recoveries: FuturesUnordered::new(),
 			live_block: (0, Hash::default()),
 			availability_lru: LruMap::new(ByLength::new(LRU_SIZE)),
+			runtime_info: RuntimeInfo::new(None),
 		}
 	}
 }
@@ -327,9 +325,10 @@ impl<Context> AvailabilityRecoverySubsystem {
 }
 
 /// Handles a signal from the overseer.
-async fn handle_signal(state: &mut State, signal: OverseerSignal) -> SubsystemResult<bool> {
+/// Returns true if subsystem receives a deadly signal.
+async fn handle_signal(state: &mut State, signal: OverseerSignal) -> bool {
 	match signal {
-		OverseerSignal::Conclude => Ok(true),
+		OverseerSignal::Conclude => true,
 		OverseerSignal::ActiveLeaves(ActiveLeavesUpdate { activated, .. }) => {
 			// if activated is non-empty, set state.live_block to the highest block in `activated`
 			if let Some(activated) = activated {
@@ -338,9 +337,9 @@ async fn handle_signal(state: &mut State, signal: OverseerSignal) -> SubsystemRe
 				}
 			}
 
-			Ok(false)
+			false
 		},
-		OverseerSignal::BlockFinalized(_, _) => Ok(false),
+		OverseerSignal::BlockFinalized(_, _) => false,
 	}
 }
 
@@ -349,27 +348,11 @@ async fn handle_signal(state: &mut State, signal: OverseerSignal) -> SubsystemRe
 async fn launch_recovery_task<Context>(
 	state: &mut State,
 	ctx: &mut Context,
-	session_info: SessionInfo,
-	receipt: CandidateReceipt,
-	response_sender: oneshot::Sender<Result<AvailableData, RecoveryError>>,
-	metrics: &Metrics,
+	response_sender: oneshot::Sender<RecoveryResult>,
 	recovery_strategies: VecDeque<Box<dyn RecoveryStrategy<<Context as SubsystemContext>::Sender>>>,
-	bypass_availability_store: bool,
-	post_recovery_check: PostRecoveryCheck,
-) -> error::Result<()> {
-	let candidate_hash = receipt.hash();
-	let params = RecoveryParams {
-		validator_authority_keys: session_info.discovery_keys.clone(),
-		n_validators: session_info.validators.len(),
-		threshold: recovery_threshold(session_info.validators.len())?,
-		candidate_hash,
-		erasure_root: receipt.descriptor.erasure_root,
-		metrics: metrics.clone(),
-		bypass_availability_store,
-		post_recovery_check,
-		pov_hash: receipt.descriptor.pov_hash,
-	};
-
+	params: RecoveryParams,
+) -> Result<()> {
+	let candidate_hash = params.candidate_hash;
 	let recovery_task = RecoveryTask::new(ctx.sender().clone(), params, recovery_strategies);
 
 	let (remote, remote_handle) = recovery_task.run().remote_handle();
@@ -380,15 +363,8 @@ async fn launch_recovery_task<Context>(
 		awaiting: vec![response_sender],
 	});
 
-	if let Err(e) = ctx.spawn("recovery-task", Box::pin(remote)) {
-		gum::warn!(
-			target: LOG_TARGET,
-			err = ?e,
-			"Failed to spawn a recovery task",
-		);
-	}
-
-	Ok(())
+	ctx.spawn("recovery-task", Box::pin(remote))
+		.map_err(|err| Error::SpawnTask(err))
 }
 
 /// Handles an availability recovery request.
@@ -399,13 +375,16 @@ async fn handle_recover<Context>(
 	receipt: CandidateReceipt,
 	session_index: SessionIndex,
 	backing_group: Option<GroupIndex>,
-	response_sender: oneshot::Sender<Result<AvailableData, RecoveryError>>,
+	response_sender: oneshot::Sender<RecoveryResult>,
 	metrics: &Metrics,
 	erasure_task_tx: futures::channel::mpsc::Sender<ErasureTask>,
 	recovery_strategy_kind: RecoveryStrategyKind,
 	bypass_availability_store: bool,
 	post_recovery_check: PostRecoveryCheck,
-) -> error::Result<()> {
+	maybe_core_index: Option<CoreIndex>,
+	req_v1_protocol_name: ProtocolName,
+	req_v2_protocol_name: ProtocolName,
+) -> Result<()> {
 	let candidate_hash = receipt.hash();
 
 	let span = jaeger::Span::new(candidate_hash, "availability-recovery")
@@ -414,14 +393,7 @@ async fn handle_recover<Context>(
 	if let Some(result) =
 		state.availability_lru.get(&candidate_hash).cloned().map(|v| v.into_result())
 	{
-		if let Err(e) = response_sender.send(result) {
-			gum::warn!(
-				target: LOG_TARGET,
-				err = ?e,
-				"Error responding with an availability recovery result",
-			);
-		}
-		return Ok(())
+		return response_sender.send(result).map_err(|_| Error::CanceledResponseSender)
 	}
 
 	if let Some(i) =
@@ -432,100 +404,182 @@ async fn handle_recover<Context>(
 	}
 
 	let _span = span.child("not-cached");
-	let session_info = request_session_info(state.live_block.1, session_index, ctx.sender())
-		.await
-		.await
-		.map_err(error::Error::CanceledSessionInfo)??;
+	let session_info_res = state
+		.runtime_info
+		.get_session_info_by_index(ctx.sender(), state.live_block.1, session_index)
+		.await;
 
 	let _span = span.child("session-info-ctx-received");
-	match session_info {
-		Some(session_info) => {
+	match session_info_res {
+		Ok(ExtendedSessionInfo { session_info, node_features, .. }) => {
+			let mut backer_group = None;
+			let n_validators = session_info.validators.len();
+			let systematic_threshold = systematic_recovery_threshold(n_validators)?;
 			let mut recovery_strategies: VecDeque<
 				Box<dyn RecoveryStrategy<<Context as SubsystemContext>::Sender>>,
-			> = VecDeque::with_capacity(2);
+			> = VecDeque::with_capacity(3);
 
 			if let Some(backing_group) = backing_group {
 				if let Some(backing_validators) = session_info.validator_groups.get(backing_group) {
 					let mut small_pov_size = true;
 
-					if let RecoveryStrategyKind::BackersFirstIfSizeLower(small_pov_limit) =
-						recovery_strategy_kind
-					{
-						// Get our own chunk size to get an estimate of the PoV size.
-						let chunk_size: Result<Option<usize>, error::Error> =
-							query_chunk_size(ctx, candidate_hash).await;
-						if let Ok(Some(chunk_size)) = chunk_size {
-							let pov_size_estimate =
-								chunk_size.saturating_mul(session_info.validators.len()) / 3;
-							small_pov_size = pov_size_estimate < small_pov_limit;
-
-							gum::trace!(
-								target: LOG_TARGET,
-								?candidate_hash,
-								pov_size_estimate,
-								small_pov_limit,
-								enabled = small_pov_size,
-								"Prefer fetch from backing group",
-							);
-						} else {
-							// we have a POV limit but were not able to query the chunk size, so
-							// don't use the backing group.
-							small_pov_size = false;
-						}
+					match recovery_strategy_kind {
+						RecoveryStrategyKind::BackersFirstIfSizeLower(fetch_chunks_threshold) |
+						RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks(
+							fetch_chunks_threshold,
+						) => {
+							// Get our own chunk size to get an estimate of the PoV size.
+							let chunk_size: Result<Option<usize>> =
+								query_chunk_size(ctx, candidate_hash).await;
+							if let Ok(Some(chunk_size)) = chunk_size {
+								let pov_size_estimate = chunk_size * systematic_threshold;
+								small_pov_size = pov_size_estimate < fetch_chunks_threshold;
+
+								if small_pov_size {
+									gum::trace!(
+										target: LOG_TARGET,
+										?candidate_hash,
+										pov_size_estimate,
+										fetch_chunks_threshold,
+										"Prefer fetch from backing group",
+									);
+								}
+							} else {
+								// we have a POV limit but were not able to query the chunk size, so
+								// don't use the backing group.
+								small_pov_size = false;
+							}
+						},
+						_ => {},
 					};
 
 					match (&recovery_strategy_kind, small_pov_size) {
 						(RecoveryStrategyKind::BackersFirstAlways, _) |
-						(RecoveryStrategyKind::BackersFirstIfSizeLower(_), true) => recovery_strategies.push_back(
-							Box::new(FetchFull::new(FetchFullParams {
-								validators: backing_validators.to_vec(),
-								erasure_task_tx: erasure_task_tx.clone(),
-							})),
-						),
+						(RecoveryStrategyKind::BackersFirstIfSizeLower(_), true) |
+						(
+							RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks(_),
+							true,
+						) |
+						(RecoveryStrategyKind::BackersThenSystematicChunks, _) =>
+							recovery_strategies.push_back(Box::new(FetchFull::new(
+								FetchFullParams { validators: backing_validators.to_vec() },
+							))),
 						_ => {},
 					};
+
+					backer_group = Some(backing_validators);
+				}
+			}
+
+			let chunk_mapping_enabled = if let Some(&true) = node_features
+				.get(usize::from(node_features::FeatureIndex::AvailabilityChunkMapping as u8))
+				.as_deref()
+			{
+				true
+			} else {
+				false
+			};
+
+			// We can only attempt systematic recovery if we received the core index of the
+			// candidate and chunk mapping is enabled.
+			if let Some(core_index) = maybe_core_index {
+				if matches!(
+					recovery_strategy_kind,
+					RecoveryStrategyKind::BackersThenSystematicChunks |
+						RecoveryStrategyKind::SystematicChunks |
+						RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks(_)
+				) && chunk_mapping_enabled
+				{
+					let chunk_indices =
+						availability_chunk_indices(Some(node_features), n_validators, core_index)?;
+
+					let chunk_indices: VecDeque<_> = chunk_indices
+						.iter()
+						.enumerate()
+						.map(|(v_index, c_index)| {
+							(
+								*c_index,
+								ValidatorIndex(
+									u32::try_from(v_index)
+										.expect("validator count should not exceed u32"),
+								),
+							)
+						})
+						.collect();
+
+					// Only get the validators according to the threshold.
+					let validators = chunk_indices
+						.clone()
+						.into_iter()
+						.filter(|(c_index, _)| {
+							usize::try_from(c_index.0)
+								.expect("usize is at least u32 bytes on all modern targets.") <
+								systematic_threshold
+						})
+						.collect();
+
+					recovery_strategies.push_back(Box::new(FetchSystematicChunks::new(
+						FetchSystematicChunksParams {
+							validators,
+							backers: backer_group.map(|v| v.to_vec()).unwrap_or_else(|| vec![]),
+						},
+					)));
 				}
 			}
 
 			recovery_strategies.push_back(Box::new(FetchChunks::new(FetchChunksParams {
 				n_validators: session_info.validators.len(),
-				erasure_task_tx,
 			})));
 
+			let session_info = session_info.clone();
+
+			let n_validators = session_info.validators.len();
+
 			launch_recovery_task(
 				state,
 				ctx,
-				session_info,
-				receipt,
 				response_sender,
-				metrics,
 				recovery_strategies,
-				bypass_availability_store,
-				post_recovery_check,
+				RecoveryParams {
+					validator_authority_keys: session_info.discovery_keys.clone(),
+					n_validators,
+					threshold: recovery_threshold(n_validators)?,
+					systematic_threshold,
+					candidate_hash,
+					erasure_root: receipt.descriptor.erasure_root,
+					metrics: metrics.clone(),
+					bypass_availability_store,
+					post_recovery_check,
+					pov_hash: receipt.descriptor.pov_hash,
+					req_v1_protocol_name,
+					req_v2_protocol_name,
+					chunk_mapping_enabled,
+					erasure_task_tx,
+				},
 			)
 			.await
 		},
-		None => {
-			gum::warn!(target: LOG_TARGET, "SessionInfo is `None` at {:?}", state.live_block);
+		Err(_) => {
 			response_sender
 				.send(Err(RecoveryError::Unavailable))
-				.map_err(|_| error::Error::CanceledResponseSender)?;
-			Ok(())
+				.map_err(|_| Error::CanceledResponseSender)?;
+
+			Err(Error::SessionInfoUnavailable(state.live_block.1))
 		},
 	}
 }
 
-/// Queries a chunk from av-store.
+/// Queries the full `AvailableData` from av-store.
 #[overseer::contextbounds(AvailabilityRecovery, prefix = self::overseer)]
 async fn query_full_data<Context>(
 	ctx: &mut Context,
 	candidate_hash: CandidateHash,
-) -> error::Result<Option<AvailableData>> {
+) -> Result<Option<AvailableData>> {
 	let (tx, rx) = oneshot::channel();
 	ctx.send_message(AvailabilityStoreMessage::QueryAvailableData(candidate_hash, tx))
 		.await;
 
-	rx.await.map_err(error::Error::CanceledQueryFullData)
+	rx.await.map_err(Error::CanceledQueryFullData)
 }
 
 /// Queries a chunk from av-store.
@@ -533,12 +587,12 @@ async fn query_full_data<Context>(
 async fn query_chunk_size<Context>(
 	ctx: &mut Context,
 	candidate_hash: CandidateHash,
-) -> error::Result<Option<usize>> {
+) -> Result<Option<usize>> {
 	let (tx, rx) = oneshot::channel();
 	ctx.send_message(AvailabilityStoreMessage::QueryChunkSize(candidate_hash, tx))
 		.await;
 
-	rx.await.map_err(error::Error::CanceledQueryFullData)
+	rx.await.map_err(Error::CanceledQueryFullData)
 }
 
 #[overseer::contextbounds(AvailabilityRecovery, prefix = self::overseer)]
@@ -547,64 +601,80 @@ impl AvailabilityRecoverySubsystem {
 	/// which never requests the `AvailabilityStoreSubsystem` subsystem and only checks the POV hash
 	/// instead of reencoding the available data.
 	pub fn for_collator(
+		fetch_chunks_threshold: Option<usize>,
 		req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+		req_protocol_names: &ReqProtocolNames,
 		metrics: Metrics,
 	) -> Self {
 		Self {
-			recovery_strategy_kind: RecoveryStrategyKind::BackersFirstIfSizeLower(SMALL_POV_LIMIT),
+			recovery_strategy_kind: RecoveryStrategyKind::BackersFirstIfSizeLower(
+				fetch_chunks_threshold.unwrap_or(CONSERVATIVE_FETCH_CHUNKS_THRESHOLD),
+			),
 			bypass_availability_store: true,
 			post_recovery_check: PostRecoveryCheck::PovHash,
 			req_receiver,
 			metrics,
+			req_v1_protocol_name: req_protocol_names
+				.get_name(request_v1::ChunkFetchingRequest::PROTOCOL),
+			req_v2_protocol_name: req_protocol_names
+				.get_name(request_v2::ChunkFetchingRequest::PROTOCOL),
 		}
 	}
 
-	/// Create a new instance of `AvailabilityRecoverySubsystem` which starts with a fast path to
-	/// request data from backers.
-	pub fn with_fast_path(
+	/// Create an optimised new instance of `AvailabilityRecoverySubsystem` suitable for validator
+	/// nodes, which:
+	/// - for small POVs (over the `fetch_chunks_threshold` or the
+	///   `CONSERVATIVE_FETCH_CHUNKS_THRESHOLD`), it attempts full recovery from backers, if backing
+	///   group supplied.
+	/// - for large POVs, attempts systematic recovery, if core_index supplied and
+	///   AvailabilityChunkMapping node feature is enabled.
+	/// - as a last resort, attempt regular chunk recovery from all validators.
+	pub fn for_validator(
+		fetch_chunks_threshold: Option<usize>,
 		req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+		req_protocol_names: &ReqProtocolNames,
 		metrics: Metrics,
 	) -> Self {
 		Self {
-			recovery_strategy_kind: RecoveryStrategyKind::BackersFirstAlways,
+			recovery_strategy_kind:
+				RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks(
+					fetch_chunks_threshold.unwrap_or(CONSERVATIVE_FETCH_CHUNKS_THRESHOLD),
+				),
 			bypass_availability_store: false,
 			post_recovery_check: PostRecoveryCheck::Reencode,
 			req_receiver,
 			metrics,
+			req_v1_protocol_name: req_protocol_names
+				.get_name(request_v1::ChunkFetchingRequest::PROTOCOL),
+			req_v2_protocol_name: req_protocol_names
+				.get_name(request_v2::ChunkFetchingRequest::PROTOCOL),
 		}
 	}
 
-	/// Create a new instance of `AvailabilityRecoverySubsystem` which requests only chunks
-	pub fn with_chunks_only(
+	/// Customise the recovery strategy kind
+	/// Currently only useful for tests.
+	#[cfg(any(test, feature = "subsystem-benchmarks"))]
+	pub fn with_recovery_strategy_kind(
 		req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+		req_protocol_names: &ReqProtocolNames,
 		metrics: Metrics,
+		recovery_strategy_kind: RecoveryStrategyKind,
 	) -> Self {
 		Self {
-			recovery_strategy_kind: RecoveryStrategyKind::ChunksAlways,
-			bypass_availability_store: false,
-			post_recovery_check: PostRecoveryCheck::Reencode,
-			req_receiver,
-			metrics,
-		}
-	}
-
-	/// Create a new instance of `AvailabilityRecoverySubsystem` which requests chunks if PoV is
-	/// above a threshold.
-	pub fn with_chunks_if_pov_large(
-		req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
-		metrics: Metrics,
-	) -> Self {
-		Self {
-			recovery_strategy_kind: RecoveryStrategyKind::BackersFirstIfSizeLower(SMALL_POV_LIMIT),
+			recovery_strategy_kind,
 			bypass_availability_store: false,
 			post_recovery_check: PostRecoveryCheck::Reencode,
 			req_receiver,
 			metrics,
+			req_v1_protocol_name: req_protocol_names
+				.get_name(request_v1::ChunkFetchingRequest::PROTOCOL),
+			req_v2_protocol_name: req_protocol_names
+				.get_name(request_v2::ChunkFetchingRequest::PROTOCOL),
 		}
 	}
 
 	/// Starts the inner subsystem loop.
-	pub async fn run<Context>(self, mut ctx: Context) -> SubsystemResult<()> {
+	pub async fn run<Context>(self, mut ctx: Context) -> std::result::Result<(), FatalError> {
 		let mut state = State::default();
 		let Self {
 			mut req_receiver,
@@ -612,6 +682,8 @@ impl AvailabilityRecoverySubsystem {
 			recovery_strategy_kind,
 			bypass_availability_store,
 			post_recovery_check,
+			req_v1_protocol_name,
+			req_v2_protocol_name,
 		} = self;
 
 		let (erasure_task_tx, erasure_task_rx) = futures::channel::mpsc::channel(16);
@@ -647,53 +719,44 @@ impl AvailabilityRecoverySubsystem {
 		loop {
 			let recv_req = req_receiver.recv(|| vec![COST_INVALID_REQUEST]).fuse();
 			pin_mut!(recv_req);
-			futures::select! {
+			let res = futures::select! {
 				erasure_task = erasure_task_rx.next() => {
 					match erasure_task {
 						Some(task) => {
-							let send_result = to_pool
+							to_pool
 								.next()
 								.expect("Pool size is `NonZeroUsize`; qed")
 								.send(task)
 								.await
-								.map_err(|_| RecoveryError::ChannelClosed);
-
-							if let Err(err) = send_result {
-								gum::warn!(
-									target: LOG_TARGET,
-									?err,
-									"Failed to send erasure coding task",
-								);
-							}
+								.map_err(|_| RecoveryError::ChannelClosed)
 						},
 						None => {
-							gum::debug!(
-								target: LOG_TARGET,
-								"Erasure task channel closed",
-							);
-
-							return Err(SubsystemError::with_origin("availability-recovery", RecoveryError::ChannelClosed))
+							Err(RecoveryError::ChannelClosed)
 						}
-					}
+					}.map_err(Into::into)
 				}
-				v = ctx.recv().fuse() => {
-					match v? {
-						FromOrchestra::Signal(signal) => if handle_signal(
-							&mut state,
-							signal,
-						).await? {
-							gum::debug!(target: LOG_TARGET, "subsystem concluded");
-							return Ok(());
-						}
-						FromOrchestra::Communication { msg } => {
-							match msg {
-								AvailabilityRecoveryMessage::RecoverAvailableData(
-									receipt,
-									session_index,
-									maybe_backing_group,
-									response_sender,
-								) => {
-									if let Err(e) = handle_recover(
+				signal = ctx.recv().fuse() => {
+					match signal {
+						Ok(signal) => {
+							match signal {
+								FromOrchestra::Signal(signal) => if handle_signal(
+									&mut state,
+									signal,
+								).await {
+									gum::debug!(target: LOG_TARGET, "subsystem concluded");
+									return Ok(());
+								} else {
+									Ok(())
+								},
+								FromOrchestra::Communication {
+									msg: AvailabilityRecoveryMessage::RecoverAvailableData(
+										receipt,
+										session_index,
+										maybe_backing_group,
+										maybe_core_index,
+										response_sender,
+									)
+								} => handle_recover(
 										&mut state,
 										&mut ctx,
 										receipt,
@@ -704,21 +767,18 @@ impl AvailabilityRecoverySubsystem {
 										erasure_task_tx.clone(),
 										recovery_strategy_kind.clone(),
 										bypass_availability_store,
-										post_recovery_check.clone()
-									).await {
-										gum::warn!(
-											target: LOG_TARGET,
-											err = ?e,
-											"Error handling a recovery request",
-										);
-									}
-								}
+										post_recovery_check.clone(),
+										maybe_core_index,
+										req_v1_protocol_name.clone(),
+										req_v2_protocol_name.clone(),
+									).await
 							}
-						}
+						},
+						Err(e) => Err(Error::SubsystemReceive(e))
 					}
 				}
 				in_req = recv_req => {
-					match in_req.into_nested().map_err(|fatal| SubsystemError::with_origin("availability-recovery", fatal))? {
+					match in_req {
 						Ok(req) => {
 							if bypass_availability_store {
 								gum::debug!(
@@ -726,40 +786,42 @@ impl AvailabilityRecoverySubsystem {
 									"Skipping request to availability-store.",
 								);
 								let _ = req.send_response(None.into());
-								continue
-							}
-							match query_full_data(&mut ctx, req.payload.candidate_hash).await {
-								Ok(res) => {
-									let _ = req.send_response(res.into());
-								}
-								Err(e) => {
-									gum::debug!(
-										target: LOG_TARGET,
-										err = ?e,
-										"Failed to query available data.",
-									);
-
-									let _ = req.send_response(None.into());
+								Ok(())
+							} else {
+								match query_full_data(&mut ctx, req.payload.candidate_hash).await {
+									Ok(res) => {
+										let _ = req.send_response(res.into());
+										Ok(())
+									}
+									Err(e) => {
+										let _ = req.send_response(None.into());
+										Err(e)
+									}
 								}
 							}
 						}
-						Err(jfyi) => {
-							gum::debug!(
-								target: LOG_TARGET,
-								error = ?jfyi,
-								"Decoding incoming request failed"
-							);
-							continue
-						}
+						Err(e) => Err(Error::IncomingRequest(e))
 					}
 				}
 				output = state.ongoing_recoveries.select_next_some() => {
+					let mut res = Ok(());
 					if let Some((candidate_hash, result)) = output {
+						if let Err(ref e) = result {
+							res = Err(Error::Recovery(e.clone()));
+						}
+
 						if let Ok(recovery) = CachedRecovery::try_from(result) {
 							state.availability_lru.insert(candidate_hash, recovery);
 						}
 					}
+
+					res
 				}
+			};
+
+			// Only bubble up fatal errors, but log all of them.
+			if let Err(e) = res {
+				log_error(Err(e))?;
 			}
 		}
 	}
@@ -827,7 +889,13 @@ async fn erasure_task_thread(
 			Some(ErasureTask::Reconstruct(n_validators, chunks, sender)) => {
 				let _ = sender.send(polkadot_erasure_coding::reconstruct_v1(
 					n_validators,
-					chunks.values().map(|c| (&c.chunk[..], c.index.0 as usize)),
+					chunks.iter().map(|(c_index, chunk)| {
+						(
+							&chunk[..],
+							usize::try_from(c_index.0)
+								.expect("usize is at least u32 bytes on all modern targets."),
+						)
+					}),
 				));
 			},
 			Some(ErasureTask::Reencode(n_validators, root, available_data, sender)) => {
diff --git a/polkadot/node/network/availability-recovery/src/metrics.rs b/polkadot/node/network/availability-recovery/src/metrics.rs
index 9f4cddc57e43a93089fbb08ec4a18dfd77ffea8d..4e269df55027b69fbff7604ac85d980f4fd36c6f 100644
--- a/polkadot/node/network/availability-recovery/src/metrics.rs
+++ b/polkadot/node/network/availability-recovery/src/metrics.rs
@@ -14,9 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
+use polkadot_node_subsystem::prometheus::HistogramVec;
 use polkadot_node_subsystem_util::metrics::{
 	self,
-	prometheus::{self, Counter, CounterVec, Histogram, Opts, PrometheusError, Registry, U64},
+	prometheus::{
+		self, prometheus::HistogramTimer, Counter, CounterVec, Histogram, Opts, PrometheusError,
+		Registry, U64,
+	},
 };
 
 /// Availability Distribution metrics.
@@ -28,26 +32,61 @@ struct MetricsInner {
 	/// Number of sent chunk requests.
 	///
 	/// Gets incremented on each sent chunk requests.
-	chunk_requests_issued: Counter<U64>,
+	///
+	/// Split by chunk type:
+	/// - `regular_chunks`
+	/// - `systematic_chunks`
+	chunk_requests_issued: CounterVec<U64>,
+
 	/// Total number of bytes recovered
 	///
 	/// Gets incremented on each successful recovery
 	recovered_bytes_total: Counter<U64>,
+
 	/// A counter for finished chunk requests.
 	///
-	/// Split by result:
+	/// Split by the chunk type (`regular_chunks` or `systematic_chunks`)
+	///
+	/// Also split by result:
 	/// - `no_such_chunk` ... peer did not have the requested chunk
 	/// - `timeout` ... request timed out.
-	/// - `network_error` ... Some networking issue except timeout
+	/// - `error` ... Some networking issue except timeout
 	/// - `invalid` ... Chunk was received, but not valid.
 	/// - `success`
 	chunk_requests_finished: CounterVec<U64>,
 
+	/// A counter for successful chunk requests, split by the network protocol version.
+	chunk_request_protocols: CounterVec<U64>,
+
+	/// Number of sent available data requests.
+	full_data_requests_issued: Counter<U64>,
+
+	/// Counter for finished available data requests.
+	///
+	/// Split by the result type:
+	///
+	/// - `no_such_data` ... peer did not have the requested data
+	/// - `timeout` ... request timed out.
+	/// - `error` ... Some networking issue except timeout
+	/// - `invalid` ... data was received, but not valid.
+	/// - `success`
+	full_data_requests_finished: CounterVec<U64>,
+
 	/// The duration of request to response.
-	time_chunk_request: Histogram,
+	///
+	/// Split by chunk type (`regular_chunks` or `systematic_chunks`).
+	time_chunk_request: HistogramVec,
 
 	/// The duration between the pure recovery and verification.
-	time_erasure_recovery: Histogram,
+	///
+	/// Split by recovery type (`regular_chunks`, `systematic_chunks` or `full_from_backers`).
+	time_erasure_recovery: HistogramVec,
+
+	/// How much time it takes to reconstruct the available data from chunks.
+	///
+	/// Split by chunk type (`regular_chunks` or `systematic_chunks`), as the algorithms are
+	/// different.
+	time_erasure_reconstruct: HistogramVec,
 
 	/// How much time it takes to re-encode the data into erasure chunks in order to verify
 	/// the root hash of the provided Merkle tree. See `reconstructed_data_matches_root`.
@@ -58,6 +97,10 @@ struct MetricsInner {
 	time_full_recovery: Histogram,
 
 	/// Number of full recoveries that have been finished one way or the other.
+	///
+	/// Split by recovery `strategy_type` (`full_from_backers, systematic_chunks, regular_chunks,
+	/// all`). `all` is used for failed recoveries that tried all available strategies.
+	/// Also split by `result` type.
 	full_recoveries_finished: CounterVec<U64>,
 
 	/// Number of full recoveries that have been started on this subsystem.
@@ -73,87 +116,175 @@ impl Metrics {
 		Metrics(None)
 	}
 
-	/// Increment counter on fetched labels.
-	pub fn on_chunk_request_issued(&self) {
+	/// Increment counter for chunk requests.
+	pub fn on_chunk_request_issued(&self, chunk_type: &str) {
 		if let Some(metrics) = &self.0 {
-			metrics.chunk_requests_issued.inc()
+			metrics.chunk_requests_issued.with_label_values(&[chunk_type]).inc()
+		}
+	}
+
+	/// Increment counter for full data requests.
+	pub fn on_full_request_issued(&self) {
+		if let Some(metrics) = &self.0 {
+			metrics.full_data_requests_issued.inc()
 		}
 	}
 
 	/// A chunk request timed out.
-	pub fn on_chunk_request_timeout(&self) {
+	pub fn on_chunk_request_timeout(&self, chunk_type: &str) {
+		if let Some(metrics) = &self.0 {
+			metrics
+				.chunk_requests_finished
+				.with_label_values(&[chunk_type, "timeout"])
+				.inc()
+		}
+	}
+
+	/// A full data request timed out.
+	pub fn on_full_request_timeout(&self) {
 		if let Some(metrics) = &self.0 {
-			metrics.chunk_requests_finished.with_label_values(&["timeout"]).inc()
+			metrics.full_data_requests_finished.with_label_values(&["timeout"]).inc()
 		}
 	}
 
 	/// A chunk request failed because validator did not have its chunk.
-	pub fn on_chunk_request_no_such_chunk(&self) {
+	pub fn on_chunk_request_no_such_chunk(&self, chunk_type: &str) {
+		if let Some(metrics) = &self.0 {
+			metrics
+				.chunk_requests_finished
+				.with_label_values(&[chunk_type, "no_such_chunk"])
+				.inc()
+		}
+	}
+
+	/// A full data request failed because the validator did not have it.
+	pub fn on_full_request_no_such_data(&self) {
 		if let Some(metrics) = &self.0 {
-			metrics.chunk_requests_finished.with_label_values(&["no_such_chunk"]).inc()
+			metrics.full_data_requests_finished.with_label_values(&["no_such_data"]).inc()
 		}
 	}
 
 	/// A chunk request failed for some non timeout related network error.
-	pub fn on_chunk_request_error(&self) {
+	pub fn on_chunk_request_error(&self, chunk_type: &str) {
 		if let Some(metrics) = &self.0 {
-			metrics.chunk_requests_finished.with_label_values(&["error"]).inc()
+			metrics.chunk_requests_finished.with_label_values(&[chunk_type, "error"]).inc()
+		}
+	}
+
+	/// A full data request failed for some non timeout related network error.
+	pub fn on_full_request_error(&self) {
+		if let Some(metrics) = &self.0 {
+			metrics.full_data_requests_finished.with_label_values(&["error"]).inc()
 		}
 	}
 
 	/// A chunk request succeeded, but was not valid.
-	pub fn on_chunk_request_invalid(&self) {
+	pub fn on_chunk_request_invalid(&self, chunk_type: &str) {
 		if let Some(metrics) = &self.0 {
-			metrics.chunk_requests_finished.with_label_values(&["invalid"]).inc()
+			metrics
+				.chunk_requests_finished
+				.with_label_values(&[chunk_type, "invalid"])
+				.inc()
+		}
+	}
+
+	/// A full data request succeeded, but was not valid.
+	pub fn on_full_request_invalid(&self) {
+		if let Some(metrics) = &self.0 {
+			metrics.full_data_requests_finished.with_label_values(&["invalid"]).inc()
 		}
 	}
 
 	/// A chunk request succeeded.
-	pub fn on_chunk_request_succeeded(&self) {
+	pub fn on_chunk_request_succeeded(&self, chunk_type: &str) {
 		if let Some(metrics) = &self.0 {
-			metrics.chunk_requests_finished.with_label_values(&["success"]).inc()
+			metrics
+				.chunk_requests_finished
+				.with_label_values(&[chunk_type, "success"])
+				.inc()
+		}
+	}
+
+	/// A chunk response was received on the v1 protocol.
+	pub fn on_chunk_response_v1(&self) {
+		if let Some(metrics) = &self.0 {
+			metrics.chunk_request_protocols.with_label_values(&["v1"]).inc()
+		}
+	}
+
+	/// A chunk response was received on the v2 protocol.
+	pub fn on_chunk_response_v2(&self) {
+		if let Some(metrics) = &self.0 {
+			metrics.chunk_request_protocols.with_label_values(&["v2"]).inc()
+		}
+	}
+
+	/// A full data request succeeded.
+	pub fn on_full_request_succeeded(&self) {
+		if let Some(metrics) = &self.0 {
+			metrics.full_data_requests_finished.with_label_values(&["success"]).inc()
 		}
 	}
 
 	/// Get a timer to time request/response duration.
-	pub fn time_chunk_request(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
-		self.0.as_ref().map(|metrics| metrics.time_chunk_request.start_timer())
+	pub fn time_chunk_request(&self, chunk_type: &str) -> Option<HistogramTimer> {
+		self.0.as_ref().map(|metrics| {
+			metrics.time_chunk_request.with_label_values(&[chunk_type]).start_timer()
+		})
 	}
 
 	/// Get a timer to time erasure code recover.
-	pub fn time_erasure_recovery(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
-		self.0.as_ref().map(|metrics| metrics.time_erasure_recovery.start_timer())
+	pub fn time_erasure_recovery(&self, chunk_type: &str) -> Option<HistogramTimer> {
+		self.0.as_ref().map(|metrics| {
+			metrics.time_erasure_recovery.with_label_values(&[chunk_type]).start_timer()
+		})
+	}
+
+	/// Get a timer for available data reconstruction.
+	pub fn time_erasure_reconstruct(&self, chunk_type: &str) -> Option<HistogramTimer> {
+		self.0.as_ref().map(|metrics| {
+			metrics.time_erasure_reconstruct.with_label_values(&[chunk_type]).start_timer()
+		})
 	}
 
 	/// Get a timer to time chunk encoding.
-	pub fn time_reencode_chunks(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
+	pub fn time_reencode_chunks(&self) -> Option<HistogramTimer> {
 		self.0.as_ref().map(|metrics| metrics.time_reencode_chunks.start_timer())
 	}
 
 	/// Get a timer to measure the time of the complete recovery process.
-	pub fn time_full_recovery(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
+	pub fn time_full_recovery(&self) -> Option<HistogramTimer> {
 		self.0.as_ref().map(|metrics| metrics.time_full_recovery.start_timer())
 	}
 
 	/// A full recovery succeeded.
-	pub fn on_recovery_succeeded(&self, bytes: usize) {
+	pub fn on_recovery_succeeded(&self, strategy_type: &str, bytes: usize) {
 		if let Some(metrics) = &self.0 {
-			metrics.full_recoveries_finished.with_label_values(&["success"]).inc();
+			metrics
+				.full_recoveries_finished
+				.with_label_values(&["success", strategy_type])
+				.inc();
 			metrics.recovered_bytes_total.inc_by(bytes as u64)
 		}
 	}
 
 	/// A full recovery failed (data not available).
-	pub fn on_recovery_failed(&self) {
+	pub fn on_recovery_failed(&self, strategy_type: &str) {
 		if let Some(metrics) = &self.0 {
-			metrics.full_recoveries_finished.with_label_values(&["failure"]).inc()
+			metrics
+				.full_recoveries_finished
+				.with_label_values(&["failure", strategy_type])
+				.inc()
 		}
 	}
 
 	/// A full recovery failed (data was recovered, but invalid).
-	pub fn on_recovery_invalid(&self) {
+	pub fn on_recovery_invalid(&self, strategy_type: &str) {
 		if let Some(metrics) = &self.0 {
-			metrics.full_recoveries_finished.with_label_values(&["invalid"]).inc()
+			metrics
+				.full_recoveries_finished
+				.with_label_values(&["invalid", strategy_type])
+				.inc()
 		}
 	}
 
@@ -169,9 +300,17 @@ impl metrics::Metrics for Metrics {
 	fn try_register(registry: &Registry) -> Result<Self, PrometheusError> {
 		let metrics = MetricsInner {
 			chunk_requests_issued: prometheus::register(
+				CounterVec::new(
+					Opts::new("polkadot_parachain_availability_recovery_chunk_requests_issued",
+					"Total number of issued chunk requests."),
+					&["type"]
+				)?,
+				registry,
+			)?,
+			full_data_requests_issued: prometheus::register(
 				Counter::new(
-					"polkadot_parachain_availability_recovery_chunk_requests_issued",
-					"Total number of issued chunk requests.",
+					"polkadot_parachain_availability_recovery_full_data_requests_issued",
+					"Total number of issued full data requests.",
 				)?,
 				registry,
 			)?,
@@ -188,22 +327,49 @@ impl metrics::Metrics for Metrics {
 						"polkadot_parachain_availability_recovery_chunk_requests_finished",
 						"Total number of chunk requests finished.",
 					),
+					&["result", "type"],
+				)?,
+				registry,
+			)?,
+			chunk_request_protocols: prometheus::register(
+				CounterVec::new(
+					Opts::new(
+						"polkadot_parachain_availability_recovery_chunk_request_protocols",
+						"Total number of successful chunk requests, mapped by the protocol version (v1 or v2).",
+					),
+					&["protocol"],
+				)?,
+				registry,
+			)?,
+			full_data_requests_finished: prometheus::register(
+				CounterVec::new(
+					Opts::new(
+						"polkadot_parachain_availability_recovery_full_data_requests_finished",
+						"Total number of full data requests finished.",
+					),
 					&["result"],
 				)?,
 				registry,
 			)?,
 			time_chunk_request: prometheus::register(
-				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+				prometheus::HistogramVec::new(prometheus::HistogramOpts::new(
 					"polkadot_parachain_availability_recovery_time_chunk_request",
 					"Time spent waiting for a response to a chunk request",
-				))?,
+				), &["type"])?,
 				registry,
 			)?,
 			time_erasure_recovery: prometheus::register(
-				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+				prometheus::HistogramVec::new(prometheus::HistogramOpts::new(
 					"polkadot_parachain_availability_recovery_time_erasure_recovery",
 					"Time spent to recover the erasure code and verify the merkle root by re-encoding as erasure chunks",
-				))?,
+				), &["type"])?,
+				registry,
+			)?,
+			time_erasure_reconstruct: prometheus::register(
+				prometheus::HistogramVec::new(prometheus::HistogramOpts::new(
+					"polkadot_parachain_availability_recovery_time_erasure_reconstruct",
+					"Time spent to reconstruct the data from chunks",
+				), &["type"])?,
 				registry,
 			)?,
 			time_reencode_chunks: prometheus::register(
@@ -226,7 +392,7 @@ impl metrics::Metrics for Metrics {
 						"polkadot_parachain_availability_recovery_recoveries_finished",
 						"Total number of recoveries that finished.",
 					),
-					&["result"],
+					&["result", "strategy_type"],
 				)?,
 				registry,
 			)?,
diff --git a/polkadot/node/network/availability-recovery/src/task.rs b/polkadot/node/network/availability-recovery/src/task.rs
deleted file mode 100644
index c300c221da5c6da8f40e8a6db3dede59ba207a58..0000000000000000000000000000000000000000
--- a/polkadot/node/network/availability-recovery/src/task.rs
+++ /dev/null
@@ -1,861 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Polkadot.
-
-// Polkadot is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Polkadot is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
-
-//! Recovery task and associated strategies.
-
-#![warn(missing_docs)]
-
-use crate::{
-	futures_undead::FuturesUndead, is_chunk_valid, is_unavailable, metrics::Metrics, ErasureTask,
-	PostRecoveryCheck, LOG_TARGET,
-};
-use futures::{channel::oneshot, SinkExt};
-use parity_scale_codec::Encode;
-#[cfg(not(test))]
-use polkadot_node_network_protocol::request_response::CHUNK_REQUEST_TIMEOUT;
-use polkadot_node_network_protocol::request_response::{
-	self as req_res, outgoing::RequestError, OutgoingRequest, Recipient, Requests,
-};
-use polkadot_node_primitives::{AvailableData, ErasureChunk};
-use polkadot_node_subsystem::{
-	messages::{AvailabilityStoreMessage, NetworkBridgeTxMessage},
-	overseer, RecoveryError,
-};
-use polkadot_primitives::{AuthorityDiscoveryId, CandidateHash, Hash, ValidatorIndex};
-use rand::seq::SliceRandom;
-use sc_network::{IfDisconnected, OutboundFailure, RequestFailure};
-use std::{
-	collections::{HashMap, VecDeque},
-	time::Duration,
-};
-
-// How many parallel recovery tasks should be running at once.
-const N_PARALLEL: usize = 50;
-
-/// Time after which we consider a request to have failed
-///
-/// and we should try more peers. Note in theory the request times out at the network level,
-/// measurements have shown, that in practice requests might actually take longer to fail in
-/// certain occasions. (The very least, authority discovery is not part of the timeout.)
-///
-/// For the time being this value is the same as the timeout on the networking layer, but as this
-/// timeout is more soft than the networking one, it might make sense to pick different values as
-/// well.
-#[cfg(not(test))]
-const TIMEOUT_START_NEW_REQUESTS: Duration = CHUNK_REQUEST_TIMEOUT;
-#[cfg(test)]
-const TIMEOUT_START_NEW_REQUESTS: Duration = Duration::from_millis(100);
-
-#[async_trait::async_trait]
-/// Common trait for runnable recovery strategies.
-pub trait RecoveryStrategy<Sender: overseer::AvailabilityRecoverySenderTrait>: Send {
-	/// Main entry point of the strategy.
-	async fn run(
-		&mut self,
-		state: &mut State,
-		sender: &mut Sender,
-		common_params: &RecoveryParams,
-	) -> Result<AvailableData, RecoveryError>;
-
-	/// Return the name of the strategy for logging purposes.
-	fn display_name(&self) -> &'static str;
-}
-
-/// Recovery parameters common to all strategies in a `RecoveryTask`.
-pub struct RecoveryParams {
-	/// Discovery ids of `validators`.
-	pub validator_authority_keys: Vec<AuthorityDiscoveryId>,
-
-	/// Number of validators.
-	pub n_validators: usize,
-
-	/// The number of chunks needed.
-	pub threshold: usize,
-
-	/// A hash of the relevant candidate.
-	pub candidate_hash: CandidateHash,
-
-	/// The root of the erasure encoding of the candidate.
-	pub erasure_root: Hash,
-
-	/// Metrics to report.
-	pub metrics: Metrics,
-
-	/// Do not request data from availability-store. Useful for collators.
-	pub bypass_availability_store: bool,
-
-	/// The type of check to perform after available data was recovered.
-	pub post_recovery_check: PostRecoveryCheck,
-
-	/// The blake2-256 hash of the PoV.
-	pub pov_hash: Hash,
-}
-
-/// Intermediate/common data that must be passed between `RecoveryStrategy`s belonging to the
-/// same `RecoveryTask`.
-pub struct State {
-	/// Chunks received so far.
-	received_chunks: HashMap<ValidatorIndex, ErasureChunk>,
-}
-
-impl State {
-	fn new() -> Self {
-		Self { received_chunks: HashMap::new() }
-	}
-
-	fn insert_chunk(&mut self, validator: ValidatorIndex, chunk: ErasureChunk) {
-		self.received_chunks.insert(validator, chunk);
-	}
-
-	fn chunk_count(&self) -> usize {
-		self.received_chunks.len()
-	}
-
-	/// Retrieve the local chunks held in the av-store (either 0 or 1).
-	async fn populate_from_av_store<Sender: overseer::AvailabilityRecoverySenderTrait>(
-		&mut self,
-		params: &RecoveryParams,
-		sender: &mut Sender,
-	) -> Vec<ValidatorIndex> {
-		let (tx, rx) = oneshot::channel();
-		sender
-			.send_message(AvailabilityStoreMessage::QueryAllChunks(params.candidate_hash, tx))
-			.await;
-
-		match rx.await {
-			Ok(chunks) => {
-				// This should either be length 1 or 0. If we had the whole data,
-				// we wouldn't have reached this stage.
-				let chunk_indices: Vec<_> = chunks.iter().map(|c| c.index).collect();
-
-				for chunk in chunks {
-					if is_chunk_valid(params, &chunk) {
-						gum::trace!(
-							target: LOG_TARGET,
-							candidate_hash = ?params.candidate_hash,
-							validator_index = ?chunk.index,
-							"Found valid chunk on disk"
-						);
-						self.insert_chunk(chunk.index, chunk);
-					} else {
-						gum::error!(
-							target: LOG_TARGET,
-							"Loaded invalid chunk from disk! Disk/Db corruption _very_ likely - please fix ASAP!"
-						);
-					};
-				}
-
-				chunk_indices
-			},
-			Err(oneshot::Canceled) => {
-				gum::warn!(
-					target: LOG_TARGET,
-					candidate_hash = ?params.candidate_hash,
-					"Failed to reach the availability store"
-				);
-
-				vec![]
-			},
-		}
-	}
-
-	/// Launch chunk requests in parallel, according to the parameters.
-	async fn launch_parallel_chunk_requests<Sender>(
-		&mut self,
-		params: &RecoveryParams,
-		sender: &mut Sender,
-		desired_requests_count: usize,
-		validators: &mut VecDeque<ValidatorIndex>,
-		requesting_chunks: &mut FuturesUndead<
-			Result<Option<ErasureChunk>, (ValidatorIndex, RequestError)>,
-		>,
-	) where
-		Sender: overseer::AvailabilityRecoverySenderTrait,
-	{
-		let candidate_hash = &params.candidate_hash;
-		let already_requesting_count = requesting_chunks.len();
-
-		let mut requests = Vec::with_capacity(desired_requests_count - already_requesting_count);
-
-		while requesting_chunks.len() < desired_requests_count {
-			if let Some(validator_index) = validators.pop_back() {
-				let validator = params.validator_authority_keys[validator_index.0 as usize].clone();
-				gum::trace!(
-					target: LOG_TARGET,
-					?validator,
-					?validator_index,
-					?candidate_hash,
-					"Requesting chunk",
-				);
-
-				// Request data.
-				let raw_request = req_res::v1::ChunkFetchingRequest {
-					candidate_hash: params.candidate_hash,
-					index: validator_index,
-				};
-
-				let (req, res) = OutgoingRequest::new(Recipient::Authority(validator), raw_request);
-				requests.push(Requests::ChunkFetchingV1(req));
-
-				params.metrics.on_chunk_request_issued();
-				let timer = params.metrics.time_chunk_request();
-
-				requesting_chunks.push(Box::pin(async move {
-					let _timer = timer;
-					match res.await {
-						Ok(req_res::v1::ChunkFetchingResponse::Chunk(chunk)) =>
-							Ok(Some(chunk.recombine_into_chunk(&raw_request))),
-						Ok(req_res::v1::ChunkFetchingResponse::NoSuchChunk) => Ok(None),
-						Err(e) => Err((validator_index, e)),
-					}
-				}));
-			} else {
-				break
-			}
-		}
-
-		sender
-			.send_message(NetworkBridgeTxMessage::SendRequests(
-				requests,
-				IfDisconnected::TryConnect,
-			))
-			.await;
-	}
-
-	/// Wait for a sufficient amount of chunks to reconstruct according to the provided `params`.
-	async fn wait_for_chunks(
-		&mut self,
-		params: &RecoveryParams,
-		validators: &mut VecDeque<ValidatorIndex>,
-		requesting_chunks: &mut FuturesUndead<
-			Result<Option<ErasureChunk>, (ValidatorIndex, RequestError)>,
-		>,
-		can_conclude: impl Fn(usize, usize, usize, &RecoveryParams, usize) -> bool,
-	) -> (usize, usize) {
-		let metrics = &params.metrics;
-
-		let mut total_received_responses = 0;
-		let mut error_count = 0;
-
-		// Wait for all current requests to conclude or time-out, or until we reach enough chunks.
-		// We also declare requests undead, once `TIMEOUT_START_NEW_REQUESTS` is reached and will
-		// return in that case for `launch_parallel_requests` to fill up slots again.
-		while let Some(request_result) =
-			requesting_chunks.next_with_timeout(TIMEOUT_START_NEW_REQUESTS).await
-		{
-			total_received_responses += 1;
-
-			match request_result {
-				Ok(Some(chunk)) =>
-					if is_chunk_valid(params, &chunk) {
-						metrics.on_chunk_request_succeeded();
-						gum::trace!(
-							target: LOG_TARGET,
-							candidate_hash = ?params.candidate_hash,
-							validator_index = ?chunk.index,
-							"Received valid chunk",
-						);
-						self.insert_chunk(chunk.index, chunk);
-					} else {
-						metrics.on_chunk_request_invalid();
-						error_count += 1;
-					},
-				Ok(None) => {
-					metrics.on_chunk_request_no_such_chunk();
-					error_count += 1;
-				},
-				Err((validator_index, e)) => {
-					error_count += 1;
-
-					gum::trace!(
-						target: LOG_TARGET,
-						candidate_hash= ?params.candidate_hash,
-						err = ?e,
-						?validator_index,
-						"Failure requesting chunk",
-					);
-
-					match e {
-						RequestError::InvalidResponse(_) => {
-							metrics.on_chunk_request_invalid();
-
-							gum::debug!(
-								target: LOG_TARGET,
-								candidate_hash = ?params.candidate_hash,
-								err = ?e,
-								?validator_index,
-								"Chunk fetching response was invalid",
-							);
-						},
-						RequestError::NetworkError(err) => {
-							// No debug logs on general network errors - that became very spammy
-							// occasionally.
-							if let RequestFailure::Network(OutboundFailure::Timeout) = err {
-								metrics.on_chunk_request_timeout();
-							} else {
-								metrics.on_chunk_request_error();
-							}
-
-							validators.push_front(validator_index);
-						},
-						RequestError::Canceled(_) => {
-							metrics.on_chunk_request_error();
-
-							validators.push_front(validator_index);
-						},
-					}
-				},
-			}
-
-			// Stop waiting for requests when we either can already recover the data
-			// or have gotten firm 'No' responses from enough validators.
-			if can_conclude(
-				validators.len(),
-				requesting_chunks.total_len(),
-				self.chunk_count(),
-				params,
-				error_count,
-			) {
-				gum::debug!(
-					target: LOG_TARGET,
-					candidate_hash = ?params.candidate_hash,
-					received_chunks_count = ?self.chunk_count(),
-					requested_chunks_count = ?requesting_chunks.len(),
-					threshold = ?params.threshold,
-					"Can conclude availability for a candidate",
-				);
-				break
-			}
-		}
-
-		(total_received_responses, error_count)
-	}
-}
-
-/// A stateful reconstruction of availability data in reference to
-/// a candidate hash.
-pub struct RecoveryTask<Sender: overseer::AvailabilityRecoverySenderTrait> {
-	sender: Sender,
-	params: RecoveryParams,
-	strategies: VecDeque<Box<dyn RecoveryStrategy<Sender>>>,
-	state: State,
-}
-
-impl<Sender> RecoveryTask<Sender>
-where
-	Sender: overseer::AvailabilityRecoverySenderTrait,
-{
-	/// Instantiate a new recovery task.
-	pub fn new(
-		sender: Sender,
-		params: RecoveryParams,
-		strategies: VecDeque<Box<dyn RecoveryStrategy<Sender>>>,
-	) -> Self {
-		Self { sender, params, strategies, state: State::new() }
-	}
-
-	async fn in_availability_store(&mut self) -> Option<AvailableData> {
-		if !self.params.bypass_availability_store {
-			let (tx, rx) = oneshot::channel();
-			self.sender
-				.send_message(AvailabilityStoreMessage::QueryAvailableData(
-					self.params.candidate_hash,
-					tx,
-				))
-				.await;
-
-			match rx.await {
-				Ok(Some(data)) => return Some(data),
-				Ok(None) => {},
-				Err(oneshot::Canceled) => {
-					gum::warn!(
-						target: LOG_TARGET,
-						candidate_hash = ?self.params.candidate_hash,
-						"Failed to reach the availability store",
-					)
-				},
-			}
-		}
-
-		None
-	}
-
-	/// Run this recovery task to completion. It will loop through the configured strategies
-	/// in-order and return whenever the first one recovers the full `AvailableData`.
-	pub async fn run(mut self) -> Result<AvailableData, RecoveryError> {
-		if let Some(data) = self.in_availability_store().await {
-			return Ok(data)
-		}
-
-		self.params.metrics.on_recovery_started();
-
-		let _timer = self.params.metrics.time_full_recovery();
-
-		while let Some(mut current_strategy) = self.strategies.pop_front() {
-			gum::debug!(
-				target: LOG_TARGET,
-				candidate_hash = ?self.params.candidate_hash,
-				"Starting `{}` strategy",
-				current_strategy.display_name(),
-			);
-
-			let res = current_strategy.run(&mut self.state, &mut self.sender, &self.params).await;
-
-			match res {
-				Err(RecoveryError::Unavailable) =>
-					if self.strategies.front().is_some() {
-						gum::debug!(
-							target: LOG_TARGET,
-							candidate_hash = ?self.params.candidate_hash,
-							"Recovery strategy `{}` did not conclude. Trying the next one.",
-							current_strategy.display_name(),
-						);
-						continue
-					},
-				Err(err) => {
-					match &err {
-						RecoveryError::Invalid => self.params.metrics.on_recovery_invalid(),
-						_ => self.params.metrics.on_recovery_failed(),
-					}
-					return Err(err)
-				},
-				Ok(data) => {
-					self.params.metrics.on_recovery_succeeded(data.encoded_size());
-					return Ok(data)
-				},
-			}
-		}
-
-		// We have no other strategies to try.
-		gum::warn!(
-			target: LOG_TARGET,
-			candidate_hash = ?self.params.candidate_hash,
-			"Recovery of available data failed.",
-		);
-		self.params.metrics.on_recovery_failed();
-
-		Err(RecoveryError::Unavailable)
-	}
-}
-
-/// `RecoveryStrategy` that sequentially tries to fetch the full `AvailableData` from
-/// already-connected validators in the configured validator set.
-pub struct FetchFull {
-	params: FetchFullParams,
-}
-
-pub struct FetchFullParams {
-	/// Validators that will be used for fetching the data.
-	pub validators: Vec<ValidatorIndex>,
-	/// Channel to the erasure task handler.
-	pub erasure_task_tx: futures::channel::mpsc::Sender<ErasureTask>,
-}
-
-impl FetchFull {
-	/// Create a new `FetchFull` recovery strategy.
-	pub fn new(mut params: FetchFullParams) -> Self {
-		params.validators.shuffle(&mut rand::thread_rng());
-		Self { params }
-	}
-}
-
-#[async_trait::async_trait]
-impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender> for FetchFull {
-	fn display_name(&self) -> &'static str {
-		"Full recovery from backers"
-	}
-
-	async fn run(
-		&mut self,
-		_: &mut State,
-		sender: &mut Sender,
-		common_params: &RecoveryParams,
-	) -> Result<AvailableData, RecoveryError> {
-		loop {
-			// Pop the next validator, and proceed to next fetch_chunks_task if we're out.
-			let validator_index =
-				self.params.validators.pop().ok_or_else(|| RecoveryError::Unavailable)?;
-
-			// Request data.
-			let (req, response) = OutgoingRequest::new(
-				Recipient::Authority(
-					common_params.validator_authority_keys[validator_index.0 as usize].clone(),
-				),
-				req_res::v1::AvailableDataFetchingRequest {
-					candidate_hash: common_params.candidate_hash,
-				},
-			);
-
-			sender
-				.send_message(NetworkBridgeTxMessage::SendRequests(
-					vec![Requests::AvailableDataFetchingV1(req)],
-					IfDisconnected::ImmediateError,
-				))
-				.await;
-
-			match response.await {
-				Ok(req_res::v1::AvailableDataFetchingResponse::AvailableData(data)) => {
-					let maybe_data = match common_params.post_recovery_check {
-						PostRecoveryCheck::Reencode => {
-							let (reencode_tx, reencode_rx) = oneshot::channel();
-							self.params
-								.erasure_task_tx
-								.send(ErasureTask::Reencode(
-									common_params.n_validators,
-									common_params.erasure_root,
-									data,
-									reencode_tx,
-								))
-								.await
-								.map_err(|_| RecoveryError::ChannelClosed)?;
-
-							reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)?
-						},
-						PostRecoveryCheck::PovHash =>
-							(data.pov.hash() == common_params.pov_hash).then_some(data),
-					};
-
-					match maybe_data {
-						Some(data) => {
-							gum::trace!(
-								target: LOG_TARGET,
-								candidate_hash = ?common_params.candidate_hash,
-								"Received full data",
-							);
-
-							return Ok(data)
-						},
-						None => {
-							gum::debug!(
-								target: LOG_TARGET,
-								candidate_hash = ?common_params.candidate_hash,
-								?validator_index,
-								"Invalid data response",
-							);
-
-							// it doesn't help to report the peer with req/res.
-							// we'll try the next backer.
-						},
-					};
-				},
-				Ok(req_res::v1::AvailableDataFetchingResponse::NoSuchData) => {},
-				Err(e) => gum::debug!(
-					target: LOG_TARGET,
-					candidate_hash = ?common_params.candidate_hash,
-					?validator_index,
-					err = ?e,
-					"Error fetching full available data."
-				),
-			}
-		}
-	}
-}
-
-/// `RecoveryStrategy` that requests chunks from validators, in parallel.
-pub struct FetchChunks {
-	/// How many requests have been unsuccessful so far.
-	error_count: usize,
-	/// Total number of responses that have been received, including failed ones.
-	total_received_responses: usize,
-	/// Collection of in-flight requests.
-	requesting_chunks: FuturesUndead<Result<Option<ErasureChunk>, (ValidatorIndex, RequestError)>>,
-	/// A random shuffling of the validators which indicates the order in which we connect to the
-	/// validators and request the chunk from them.
-	validators: VecDeque<ValidatorIndex>,
-	/// Channel to the erasure task handler.
-	erasure_task_tx: futures::channel::mpsc::Sender<ErasureTask>,
-}
-
-/// Parameters specific to the `FetchChunks` strategy.
-pub struct FetchChunksParams {
-	/// Total number of validators.
-	pub n_validators: usize,
-	/// Channel to the erasure task handler.
-	pub erasure_task_tx: futures::channel::mpsc::Sender<ErasureTask>,
-}
-
-impl FetchChunks {
-	/// Instantiate a new strategy.
-	pub fn new(params: FetchChunksParams) -> Self {
-		let mut shuffling: Vec<_> = (0..params.n_validators)
-			.map(|i| ValidatorIndex(i.try_into().expect("number of validators must fit in a u32")))
-			.collect();
-		shuffling.shuffle(&mut rand::thread_rng());
-
-		Self {
-			error_count: 0,
-			total_received_responses: 0,
-			requesting_chunks: FuturesUndead::new(),
-			validators: shuffling.into(),
-			erasure_task_tx: params.erasure_task_tx,
-		}
-	}
-
-	fn is_unavailable(
-		unrequested_validators: usize,
-		in_flight_requests: usize,
-		chunk_count: usize,
-		threshold: usize,
-	) -> bool {
-		is_unavailable(chunk_count, in_flight_requests, unrequested_validators, threshold)
-	}
-
-	/// Desired number of parallel requests.
-	///
-	/// For the given threshold (total required number of chunks) get the desired number of
-	/// requests we want to have running in parallel at this time.
-	fn get_desired_request_count(&self, chunk_count: usize, threshold: usize) -> usize {
-		// Upper bound for parallel requests.
-		// We want to limit this, so requests can be processed within the timeout and we limit the
-		// following feedback loop:
-		// 1. Requests fail due to timeout
-		// 2. We request more chunks to make up for it
-		// 3. Bandwidth is spread out even more, so we get even more timeouts
-		// 4. We request more chunks to make up for it ...
-		let max_requests_boundary = std::cmp::min(N_PARALLEL, threshold);
-		// How many chunks are still needed?
-		let remaining_chunks = threshold.saturating_sub(chunk_count);
-		// What is the current error rate, so we can make up for it?
-		let inv_error_rate =
-			self.total_received_responses.checked_div(self.error_count).unwrap_or(0);
-		// Actual number of requests we want to have in flight in parallel:
-		std::cmp::min(
-			max_requests_boundary,
-			remaining_chunks + remaining_chunks.checked_div(inv_error_rate).unwrap_or(0),
-		)
-	}
-
-	async fn attempt_recovery(
-		&mut self,
-		state: &mut State,
-		common_params: &RecoveryParams,
-	) -> Result<AvailableData, RecoveryError> {
-		let recovery_duration = common_params.metrics.time_erasure_recovery();
-
-		// Send request to reconstruct available data from chunks.
-		let (avilable_data_tx, available_data_rx) = oneshot::channel();
-		self.erasure_task_tx
-			.send(ErasureTask::Reconstruct(
-				common_params.n_validators,
-				// Safe to leave an empty vec in place, as we're stopping the recovery process if
-				// this reconstruct fails.
-				std::mem::take(&mut state.received_chunks),
-				avilable_data_tx,
-			))
-			.await
-			.map_err(|_| RecoveryError::ChannelClosed)?;
-
-		let available_data_response =
-			available_data_rx.await.map_err(|_| RecoveryError::ChannelClosed)?;
-
-		match available_data_response {
-			Ok(data) => {
-				let maybe_data = match common_params.post_recovery_check {
-					PostRecoveryCheck::Reencode => {
-						// Send request to re-encode the chunks and check merkle root.
-						let (reencode_tx, reencode_rx) = oneshot::channel();
-						self.erasure_task_tx
-							.send(ErasureTask::Reencode(
-								common_params.n_validators,
-								common_params.erasure_root,
-								data,
-								reencode_tx,
-							))
-							.await
-							.map_err(|_| RecoveryError::ChannelClosed)?;
-
-						reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)?.or_else(|| {
-							gum::trace!(
-								target: LOG_TARGET,
-								candidate_hash = ?common_params.candidate_hash,
-								erasure_root = ?common_params.erasure_root,
-								"Data recovery error - root mismatch",
-							);
-							None
-						})
-					},
-					PostRecoveryCheck::PovHash =>
-						(data.pov.hash() == common_params.pov_hash).then_some(data).or_else(|| {
-							gum::trace!(
-								target: LOG_TARGET,
-								candidate_hash = ?common_params.candidate_hash,
-								pov_hash = ?common_params.pov_hash,
-								"Data recovery error - PoV hash mismatch",
-							);
-							None
-						}),
-				};
-
-				if let Some(data) = maybe_data {
-					gum::trace!(
-						target: LOG_TARGET,
-						candidate_hash = ?common_params.candidate_hash,
-						erasure_root = ?common_params.erasure_root,
-						"Data recovery from chunks complete",
-					);
-
-					Ok(data)
-				} else {
-					recovery_duration.map(|rd| rd.stop_and_discard());
-
-					Err(RecoveryError::Invalid)
-				}
-			},
-			Err(err) => {
-				recovery_duration.map(|rd| rd.stop_and_discard());
-				gum::trace!(
-					target: LOG_TARGET,
-					candidate_hash = ?common_params.candidate_hash,
-					erasure_root = ?common_params.erasure_root,
-					?err,
-					"Data recovery error ",
-				);
-
-				Err(RecoveryError::Invalid)
-			},
-		}
-	}
-}
-
-#[async_trait::async_trait]
-impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender> for FetchChunks {
-	fn display_name(&self) -> &'static str {
-		"Fetch chunks"
-	}
-
-	async fn run(
-		&mut self,
-		state: &mut State,
-		sender: &mut Sender,
-		common_params: &RecoveryParams,
-	) -> Result<AvailableData, RecoveryError> {
-		// First query the store for any chunks we've got.
-		if !common_params.bypass_availability_store {
-			let local_chunk_indices = state.populate_from_av_store(common_params, sender).await;
-			self.validators.retain(|i| !local_chunk_indices.contains(i));
-		}
-
-		// No need to query the validators that have the chunks we already received.
-		self.validators.retain(|i| !state.received_chunks.contains_key(i));
-
-		loop {
-			// If received_chunks has more than threshold entries, attempt to recover the data.
-			// If that fails, or a re-encoding of it doesn't match the expected erasure root,
-			// return Err(RecoveryError::Invalid).
-			// Do this before requesting any chunks because we may have enough of them coming from
-			// past RecoveryStrategies.
-			if state.chunk_count() >= common_params.threshold {
-				return self.attempt_recovery(state, common_params).await
-			}
-
-			if Self::is_unavailable(
-				self.validators.len(),
-				self.requesting_chunks.total_len(),
-				state.chunk_count(),
-				common_params.threshold,
-			) {
-				gum::debug!(
-					target: LOG_TARGET,
-					candidate_hash = ?common_params.candidate_hash,
-					erasure_root = ?common_params.erasure_root,
-					received = %state.chunk_count(),
-					requesting = %self.requesting_chunks.len(),
-					total_requesting = %self.requesting_chunks.total_len(),
-					n_validators = %common_params.n_validators,
-					"Data recovery from chunks is not possible",
-				);
-
-				return Err(RecoveryError::Unavailable)
-			}
-
-			let desired_requests_count =
-				self.get_desired_request_count(state.chunk_count(), common_params.threshold);
-			let already_requesting_count = self.requesting_chunks.len();
-			gum::debug!(
-				target: LOG_TARGET,
-				?common_params.candidate_hash,
-				?desired_requests_count,
-				error_count= ?self.error_count,
-				total_received = ?self.total_received_responses,
-				threshold = ?common_params.threshold,
-				?already_requesting_count,
-				"Requesting availability chunks for a candidate",
-			);
-			state
-				.launch_parallel_chunk_requests(
-					common_params,
-					sender,
-					desired_requests_count,
-					&mut self.validators,
-					&mut self.requesting_chunks,
-				)
-				.await;
-
-			let (total_responses, error_count) = state
-				.wait_for_chunks(
-					common_params,
-					&mut self.validators,
-					&mut self.requesting_chunks,
-					|unrequested_validators, reqs, chunk_count, params, _error_count| {
-						chunk_count >= params.threshold ||
-							Self::is_unavailable(
-								unrequested_validators,
-								reqs,
-								chunk_count,
-								params.threshold,
-							)
-					},
-				)
-				.await;
-
-			self.total_received_responses += total_responses;
-			self.error_count += error_count;
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use polkadot_erasure_coding::recovery_threshold;
-
-	#[test]
-	fn parallel_request_calculation_works_as_expected() {
-		let num_validators = 100;
-		let threshold = recovery_threshold(num_validators).unwrap();
-		let (erasure_task_tx, _erasure_task_rx) = futures::channel::mpsc::channel(16);
-
-		let mut fetch_chunks_task =
-			FetchChunks::new(FetchChunksParams { n_validators: 100, erasure_task_tx });
-		assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold);
-		fetch_chunks_task.error_count = 1;
-		fetch_chunks_task.total_received_responses = 1;
-		// We saturate at threshold (34):
-		assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold);
-
-		fetch_chunks_task.total_received_responses = 2;
-		// With given error rate - still saturating:
-		assert_eq!(fetch_chunks_task.get_desired_request_count(1, threshold), threshold);
-		fetch_chunks_task.total_received_responses += 8;
-		// error rate: 1/10
-		// remaining chunks needed: threshold (34) - 9
-		// expected: 24 * (1+ 1/10) = (next greater integer) = 27
-		assert_eq!(fetch_chunks_task.get_desired_request_count(9, threshold), 27);
-		fetch_chunks_task.error_count = 0;
-		// With error count zero - we should fetch exactly as needed:
-		assert_eq!(fetch_chunks_task.get_desired_request_count(10, threshold), threshold - 10);
-	}
-}
diff --git a/polkadot/node/network/availability-recovery/src/task/mod.rs b/polkadot/node/network/availability-recovery/src/task/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0a8b52411afee5cd5f63d0f3ec90497af34601e2
--- /dev/null
+++ b/polkadot/node/network/availability-recovery/src/task/mod.rs
@@ -0,0 +1,197 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Main recovery task logic. Runs recovery strategies.
+
+#![warn(missing_docs)]
+
+mod strategy;
+
+pub use self::strategy::{
+	FetchChunks, FetchChunksParams, FetchFull, FetchFullParams, FetchSystematicChunks,
+	FetchSystematicChunksParams, RecoveryStrategy, State,
+};
+
+#[cfg(test)]
+pub use self::strategy::{REGULAR_CHUNKS_REQ_RETRY_LIMIT, SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT};
+
+use crate::{metrics::Metrics, ErasureTask, PostRecoveryCheck, LOG_TARGET};
+
+use codec::Encode;
+use polkadot_node_primitives::AvailableData;
+use polkadot_node_subsystem::{messages::AvailabilityStoreMessage, overseer, RecoveryError};
+use polkadot_primitives::{AuthorityDiscoveryId, CandidateHash, Hash};
+use sc_network::ProtocolName;
+
+use futures::channel::{mpsc, oneshot};
+use std::collections::VecDeque;
+
+/// Recovery parameters common to all strategies in a `RecoveryTask`.
+#[derive(Clone)]
+pub struct RecoveryParams {
+	/// Discovery ids of `validators`.
+	pub validator_authority_keys: Vec<AuthorityDiscoveryId>,
+
+	/// Number of validators.
+	pub n_validators: usize,
+
+	/// The number of regular chunks needed.
+	pub threshold: usize,
+
+	/// The number of systematic chunks needed.
+	pub systematic_threshold: usize,
+
+	/// A hash of the relevant candidate.
+	pub candidate_hash: CandidateHash,
+
+	/// The root of the erasure encoding of the candidate.
+	pub erasure_root: Hash,
+
+	/// Metrics to report.
+	pub metrics: Metrics,
+
+	/// Do not request data from availability-store. Useful for collators.
+	pub bypass_availability_store: bool,
+
+	/// The type of check to perform after available data was recovered.
+	pub post_recovery_check: PostRecoveryCheck,
+
+	/// The blake2-256 hash of the PoV.
+	pub pov_hash: Hash,
+
+	/// Protocol name for ChunkFetchingV1.
+	pub req_v1_protocol_name: ProtocolName,
+
+	/// Protocol name for ChunkFetchingV2.
+	pub req_v2_protocol_name: ProtocolName,
+
+	/// Whether or not chunk mapping is enabled.
+	pub chunk_mapping_enabled: bool,
+
+	/// Channel to the erasure task handler.
+	pub erasure_task_tx: mpsc::Sender<ErasureTask>,
+}
+
+/// A stateful reconstruction of availability data in reference to
+/// a candidate hash.
+pub struct RecoveryTask<Sender: overseer::AvailabilityRecoverySenderTrait> {
+	sender: Sender,
+	params: RecoveryParams,
+	strategies: VecDeque<Box<dyn RecoveryStrategy<Sender>>>,
+	state: State,
+}
+
+impl<Sender> RecoveryTask<Sender>
+where
+	Sender: overseer::AvailabilityRecoverySenderTrait,
+{
+	/// Instantiate a new recovery task.
+	pub fn new(
+		sender: Sender,
+		params: RecoveryParams,
+		strategies: VecDeque<Box<dyn RecoveryStrategy<Sender>>>,
+	) -> Self {
+		Self { sender, params, strategies, state: State::new() }
+	}
+
+	async fn in_availability_store(&mut self) -> Option<AvailableData> {
+		if !self.params.bypass_availability_store {
+			let (tx, rx) = oneshot::channel();
+			self.sender
+				.send_message(AvailabilityStoreMessage::QueryAvailableData(
+					self.params.candidate_hash,
+					tx,
+				))
+				.await;
+
+			match rx.await {
+				Ok(Some(data)) => return Some(data),
+				Ok(None) => {},
+				Err(oneshot::Canceled) => {
+					gum::warn!(
+						target: LOG_TARGET,
+						candidate_hash = ?self.params.candidate_hash,
+						"Failed to reach the availability store",
+					)
+				},
+			}
+		}
+
+		None
+	}
+
+	/// Run this recovery task to completion. It will loop through the configured strategies
+	/// in-order and return whenever the first one recovers the full `AvailableData`.
+	pub async fn run(mut self) -> Result<AvailableData, RecoveryError> {
+		if let Some(data) = self.in_availability_store().await {
+			return Ok(data)
+		}
+
+		self.params.metrics.on_recovery_started();
+
+		let _timer = self.params.metrics.time_full_recovery();
+
+		while let Some(current_strategy) = self.strategies.pop_front() {
+			let display_name = current_strategy.display_name();
+			let strategy_type = current_strategy.strategy_type();
+
+			gum::debug!(
+				target: LOG_TARGET,
+				candidate_hash = ?self.params.candidate_hash,
+				"Starting `{}` strategy",
+				display_name
+			);
+
+			let res = current_strategy.run(&mut self.state, &mut self.sender, &self.params).await;
+
+			match res {
+				Err(RecoveryError::Unavailable) =>
+					if self.strategies.front().is_some() {
+						gum::debug!(
+							target: LOG_TARGET,
+							candidate_hash = ?self.params.candidate_hash,
+							"Recovery strategy `{}` did not conclude. Trying the next one.",
+							display_name
+						);
+						continue
+					},
+				Err(err) => {
+					match &err {
+						RecoveryError::Invalid =>
+							self.params.metrics.on_recovery_invalid(strategy_type),
+						_ => self.params.metrics.on_recovery_failed(strategy_type),
+					}
+					return Err(err)
+				},
+				Ok(data) => {
+					self.params.metrics.on_recovery_succeeded(strategy_type, data.encoded_size());
+					return Ok(data)
+				},
+			}
+		}
+
+		// We have no other strategies to try.
+		gum::warn!(
+			target: LOG_TARGET,
+			candidate_hash = ?self.params.candidate_hash,
+			"Recovery of available data failed.",
+		);
+
+		self.params.metrics.on_recovery_failed("all");
+
+		Err(RecoveryError::Unavailable)
+	}
+}
diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/chunks.rs b/polkadot/node/network/availability-recovery/src/task/strategy/chunks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b6376a5b543ed75d511571ec48d2fee8cac6a7d4
--- /dev/null
+++ b/polkadot/node/network/availability-recovery/src/task/strategy/chunks.rs
@@ -0,0 +1,335 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+	futures_undead::FuturesUndead,
+	task::{
+		strategy::{
+			do_post_recovery_check, is_unavailable, OngoingRequests, N_PARALLEL,
+			REGULAR_CHUNKS_REQ_RETRY_LIMIT,
+		},
+		RecoveryParams, State,
+	},
+	ErasureTask, RecoveryStrategy, LOG_TARGET,
+};
+
+use polkadot_node_primitives::AvailableData;
+use polkadot_node_subsystem::{overseer, RecoveryError};
+use polkadot_primitives::ValidatorIndex;
+
+use futures::{channel::oneshot, SinkExt};
+use rand::seq::SliceRandom;
+use std::collections::VecDeque;
+
+/// Parameters specific to the `FetchChunks` strategy.
+pub struct FetchChunksParams {
+	pub n_validators: usize,
+}
+
+/// `RecoveryStrategy` that requests chunks from validators, in parallel.
+pub struct FetchChunks {
+	/// How many requests have been unsuccessful so far.
+	error_count: usize,
+	/// Total number of responses that have been received, including failed ones.
+	total_received_responses: usize,
+	/// A shuffled array of validator indices.
+	validators: VecDeque<ValidatorIndex>,
+	/// Collection of in-flight requests.
+	requesting_chunks: OngoingRequests,
+}
+
+impl FetchChunks {
+	/// Instantiate a new strategy.
+	pub fn new(params: FetchChunksParams) -> Self {
+		// Shuffle the validators to make sure that we don't request chunks from the same
+		// validators over and over.
+		let mut validators: VecDeque<ValidatorIndex> =
+			(0..params.n_validators).map(|i| ValidatorIndex(i as u32)).collect();
+		validators.make_contiguous().shuffle(&mut rand::thread_rng());
+
+		Self {
+			error_count: 0,
+			total_received_responses: 0,
+			validators,
+			requesting_chunks: FuturesUndead::new(),
+		}
+	}
+
+	fn is_unavailable(
+		unrequested_validators: usize,
+		in_flight_requests: usize,
+		chunk_count: usize,
+		threshold: usize,
+	) -> bool {
+		is_unavailable(chunk_count, in_flight_requests, unrequested_validators, threshold)
+	}
+
+	/// Desired number of parallel requests.
+	///
+	/// For the given threshold (total required number of chunks) get the desired number of
+	/// requests we want to have running in parallel at this time.
+	fn get_desired_request_count(&self, chunk_count: usize, threshold: usize) -> usize {
+		// Upper bound for parallel requests.
+		// We want to limit this, so requests can be processed within the timeout and we limit the
+		// following feedback loop:
+		// 1. Requests fail due to timeout
+		// 2. We request more chunks to make up for it
+		// 3. Bandwidth is spread out even more, so we get even more timeouts
+		// 4. We request more chunks to make up for it ...
+		let max_requests_boundary = std::cmp::min(N_PARALLEL, threshold);
+		// How many chunks are still needed?
+		let remaining_chunks = threshold.saturating_sub(chunk_count);
+		// What is the current error rate, so we can make up for it?
+		let inv_error_rate =
+			self.total_received_responses.checked_div(self.error_count).unwrap_or(0);
+		// Actual number of requests we want to have in flight in parallel:
+		std::cmp::min(
+			max_requests_boundary,
+			remaining_chunks + remaining_chunks.checked_div(inv_error_rate).unwrap_or(0),
+		)
+	}
+
+	async fn attempt_recovery<Sender: overseer::AvailabilityRecoverySenderTrait>(
+		&mut self,
+		state: &mut State,
+		common_params: &RecoveryParams,
+	) -> Result<AvailableData, RecoveryError> {
+		let recovery_duration = common_params
+			.metrics
+			.time_erasure_recovery(RecoveryStrategy::<Sender>::strategy_type(self));
+
+		// Send request to reconstruct available data from chunks.
+		let (avilable_data_tx, available_data_rx) = oneshot::channel();
+
+		let mut erasure_task_tx = common_params.erasure_task_tx.clone();
+		erasure_task_tx
+			.send(ErasureTask::Reconstruct(
+				common_params.n_validators,
+				// Safe to leave an empty vec in place, as we're stopping the recovery process if
+				// this reconstruct fails.
+				std::mem::take(&mut state.received_chunks)
+					.into_iter()
+					.map(|(c_index, chunk)| (c_index, chunk.chunk))
+					.collect(),
+				avilable_data_tx,
+			))
+			.await
+			.map_err(|_| RecoveryError::ChannelClosed)?;
+
+		let available_data_response =
+			available_data_rx.await.map_err(|_| RecoveryError::ChannelClosed)?;
+
+		match available_data_response {
+			// Attempt post-recovery check.
+			Ok(data) => do_post_recovery_check(common_params, data)
+				.await
+				.map_err(|e| {
+					recovery_duration.map(|rd| rd.stop_and_discard());
+					e
+				})
+				.map(|data| {
+					gum::trace!(
+						target: LOG_TARGET,
+						candidate_hash = ?common_params.candidate_hash,
+						erasure_root = ?common_params.erasure_root,
+						"Data recovery from chunks complete",
+					);
+					data
+				}),
+			Err(err) => {
+				recovery_duration.map(|rd| rd.stop_and_discard());
+				gum::debug!(
+					target: LOG_TARGET,
+					candidate_hash = ?common_params.candidate_hash,
+					erasure_root = ?common_params.erasure_root,
+					?err,
+					"Data recovery error",
+				);
+
+				Err(RecoveryError::Invalid)
+			},
+		}
+	}
+}
+
+#[async_trait::async_trait]
+impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender> for FetchChunks {
+	fn display_name(&self) -> &'static str {
+		"Fetch chunks"
+	}
+
+	fn strategy_type(&self) -> &'static str {
+		"regular_chunks"
+	}
+
+	async fn run(
+		mut self: Box<Self>,
+		state: &mut State,
+		sender: &mut Sender,
+		common_params: &RecoveryParams,
+	) -> Result<AvailableData, RecoveryError> {
+		// First query the store for any chunks we've got.
+		if !common_params.bypass_availability_store {
+			let local_chunk_indices = state.populate_from_av_store(common_params, sender).await;
+			self.validators.retain(|validator_index| {
+				!local_chunk_indices.iter().any(|(v_index, _)| v_index == validator_index)
+			});
+		}
+
+		// No need to query the validators that have the chunks we already received or that we know
+		// don't have the data from previous strategies.
+		self.validators.retain(|v_index| {
+			!state.received_chunks.values().any(|c| v_index == &c.validator_index) &&
+				state.can_retry_request(
+					&(common_params.validator_authority_keys[v_index.0 as usize].clone(), *v_index),
+					REGULAR_CHUNKS_REQ_RETRY_LIMIT,
+				)
+		});
+
+		// Safe to `take` here, as we're consuming `self` anyway and we're not using the
+		// `validators` field in other methods.
+		let mut validators_queue: VecDeque<_> = std::mem::take(&mut self.validators)
+			.into_iter()
+			.map(|validator_index| {
+				(
+					common_params.validator_authority_keys[validator_index.0 as usize].clone(),
+					validator_index,
+				)
+			})
+			.collect();
+
+		loop {
+			// If received_chunks has more than threshold entries, attempt to recover the data.
+			// If that fails, or a re-encoding of it doesn't match the expected erasure root,
+			// return Err(RecoveryError::Invalid).
+			// Do this before requesting any chunks because we may have enough of them coming from
+			// past RecoveryStrategies.
+			if state.chunk_count() >= common_params.threshold {
+				return self.attempt_recovery::<Sender>(state, common_params).await
+			}
+
+			if Self::is_unavailable(
+				validators_queue.len(),
+				self.requesting_chunks.total_len(),
+				state.chunk_count(),
+				common_params.threshold,
+			) {
+				gum::debug!(
+					target: LOG_TARGET,
+					candidate_hash = ?common_params.candidate_hash,
+					erasure_root = ?common_params.erasure_root,
+					received = %state.chunk_count(),
+					requesting = %self.requesting_chunks.len(),
+					total_requesting = %self.requesting_chunks.total_len(),
+					n_validators = %common_params.n_validators,
+					"Data recovery from chunks is not possible",
+				);
+
+				return Err(RecoveryError::Unavailable)
+			}
+
+			let desired_requests_count =
+				self.get_desired_request_count(state.chunk_count(), common_params.threshold);
+			let already_requesting_count = self.requesting_chunks.len();
+			gum::debug!(
+				target: LOG_TARGET,
+				?common_params.candidate_hash,
+				?desired_requests_count,
+				error_count= ?self.error_count,
+				total_received = ?self.total_received_responses,
+				threshold = ?common_params.threshold,
+				?already_requesting_count,
+				"Requesting availability chunks for a candidate",
+			);
+
+			let strategy_type = RecoveryStrategy::<Sender>::strategy_type(&*self);
+
+			state
+				.launch_parallel_chunk_requests(
+					strategy_type,
+					common_params,
+					sender,
+					desired_requests_count,
+					&mut validators_queue,
+					&mut self.requesting_chunks,
+				)
+				.await;
+
+			let (total_responses, error_count) = state
+				.wait_for_chunks(
+					strategy_type,
+					common_params,
+					REGULAR_CHUNKS_REQ_RETRY_LIMIT,
+					&mut validators_queue,
+					&mut self.requesting_chunks,
+					&mut vec![],
+					|unrequested_validators,
+					 in_flight_reqs,
+					 chunk_count,
+					 _systematic_chunk_count| {
+						chunk_count >= common_params.threshold ||
+							Self::is_unavailable(
+								unrequested_validators,
+								in_flight_reqs,
+								chunk_count,
+								common_params.threshold,
+							)
+					},
+				)
+				.await;
+
+			self.total_received_responses += total_responses;
+			self.error_count += error_count;
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use polkadot_erasure_coding::recovery_threshold;
+
+	#[test]
+	fn test_get_desired_request_count() {
+		let n_validators = 100;
+		let threshold = recovery_threshold(n_validators).unwrap();
+
+		let mut fetch_chunks_task = FetchChunks::new(FetchChunksParams { n_validators });
+		assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold);
+		fetch_chunks_task.error_count = 1;
+		fetch_chunks_task.total_received_responses = 1;
+		// We saturate at threshold (34):
+		assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold);
+
+		// We saturate at the parallel limit.
+		assert_eq!(fetch_chunks_task.get_desired_request_count(0, N_PARALLEL + 2), N_PARALLEL);
+
+		fetch_chunks_task.total_received_responses = 2;
+		// With given error rate - still saturating:
+		assert_eq!(fetch_chunks_task.get_desired_request_count(1, threshold), threshold);
+		fetch_chunks_task.total_received_responses = 10;
+		// error rate: 1/10
+		// remaining chunks needed: threshold (34) - 9
+		// expected: 24 * (1+ 1/10) = (next greater integer) = 27
+		assert_eq!(fetch_chunks_task.get_desired_request_count(9, threshold), 27);
+		// We saturate at the parallel limit.
+		assert_eq!(fetch_chunks_task.get_desired_request_count(9, N_PARALLEL + 9), N_PARALLEL);
+
+		fetch_chunks_task.error_count = 0;
+		// With error count zero - we should fetch exactly as needed:
+		assert_eq!(fetch_chunks_task.get_desired_request_count(10, threshold), threshold - 10);
+	}
+}
diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/full.rs b/polkadot/node/network/availability-recovery/src/task/strategy/full.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1d7fbe8ea3c8da42ab3227750852c02d328b6dd8
--- /dev/null
+++ b/polkadot/node/network/availability-recovery/src/task/strategy/full.rs
@@ -0,0 +1,174 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+	task::{RecoveryParams, RecoveryStrategy, State},
+	ErasureTask, PostRecoveryCheck, LOG_TARGET,
+};
+
+use polkadot_node_network_protocol::request_response::{
+	self as req_res, outgoing::RequestError, OutgoingRequest, Recipient, Requests,
+};
+use polkadot_node_primitives::AvailableData;
+use polkadot_node_subsystem::{messages::NetworkBridgeTxMessage, overseer, RecoveryError};
+use polkadot_primitives::ValidatorIndex;
+use sc_network::{IfDisconnected, OutboundFailure, RequestFailure};
+
+use futures::{channel::oneshot, SinkExt};
+use rand::seq::SliceRandom;
+
+/// Parameters specific to the `FetchFull` strategy.
+pub struct FetchFullParams {
+	/// Validators that will be used for fetching the data.
+	pub validators: Vec<ValidatorIndex>,
+}
+
+/// `RecoveryStrategy` that sequentially tries to fetch the full `AvailableData` from
+/// already-connected validators in the configured validator set.
+pub struct FetchFull {
+	params: FetchFullParams,
+}
+
+impl FetchFull {
+	/// Create a new `FetchFull` recovery strategy.
+	pub fn new(mut params: FetchFullParams) -> Self {
+		params.validators.shuffle(&mut rand::thread_rng());
+		Self { params }
+	}
+}
+
+#[async_trait::async_trait]
+impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender> for FetchFull {
+	fn display_name(&self) -> &'static str {
+		"Full recovery from backers"
+	}
+
+	fn strategy_type(&self) -> &'static str {
+		"full_from_backers"
+	}
+
+	async fn run(
+		mut self: Box<Self>,
+		_: &mut State,
+		sender: &mut Sender,
+		common_params: &RecoveryParams,
+	) -> Result<AvailableData, RecoveryError> {
+		let strategy_type = RecoveryStrategy::<Sender>::strategy_type(&*self);
+
+		loop {
+			// Pop the next validator.
+			let validator_index =
+				self.params.validators.pop().ok_or_else(|| RecoveryError::Unavailable)?;
+
+			// Request data.
+			let (req, response) = OutgoingRequest::new(
+				Recipient::Authority(
+					common_params.validator_authority_keys[validator_index.0 as usize].clone(),
+				),
+				req_res::v1::AvailableDataFetchingRequest {
+					candidate_hash: common_params.candidate_hash,
+				},
+			);
+
+			sender
+				.send_message(NetworkBridgeTxMessage::SendRequests(
+					vec![Requests::AvailableDataFetchingV1(req)],
+					IfDisconnected::ImmediateError,
+				))
+				.await;
+
+			common_params.metrics.on_full_request_issued();
+
+			match response.await {
+				Ok(req_res::v1::AvailableDataFetchingResponse::AvailableData(data)) => {
+					let recovery_duration =
+						common_params.metrics.time_erasure_recovery(strategy_type);
+					let maybe_data = match common_params.post_recovery_check {
+						PostRecoveryCheck::Reencode => {
+							let (reencode_tx, reencode_rx) = oneshot::channel();
+							let mut erasure_task_tx = common_params.erasure_task_tx.clone();
+
+							erasure_task_tx
+								.send(ErasureTask::Reencode(
+									common_params.n_validators,
+									common_params.erasure_root,
+									data,
+									reencode_tx,
+								))
+								.await
+								.map_err(|_| RecoveryError::ChannelClosed)?;
+
+							reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)?
+						},
+						PostRecoveryCheck::PovHash =>
+							(data.pov.hash() == common_params.pov_hash).then_some(data),
+					};
+
+					match maybe_data {
+						Some(data) => {
+							gum::trace!(
+								target: LOG_TARGET,
+								candidate_hash = ?common_params.candidate_hash,
+								"Received full data",
+							);
+
+							common_params.metrics.on_full_request_succeeded();
+							return Ok(data)
+						},
+						None => {
+							common_params.metrics.on_full_request_invalid();
+							recovery_duration.map(|rd| rd.stop_and_discard());
+
+							gum::debug!(
+								target: LOG_TARGET,
+								candidate_hash = ?common_params.candidate_hash,
+								?validator_index,
+								"Invalid data response",
+							);
+
+							// it doesn't help to report the peer with req/res.
+							// we'll try the next backer.
+						},
+					}
+				},
+				Ok(req_res::v1::AvailableDataFetchingResponse::NoSuchData) => {
+					common_params.metrics.on_full_request_no_such_data();
+				},
+				Err(e) => {
+					match &e {
+						RequestError::Canceled(_) => common_params.metrics.on_full_request_error(),
+						RequestError::InvalidResponse(_) =>
+							common_params.metrics.on_full_request_invalid(),
+						RequestError::NetworkError(req_failure) => {
+							if let RequestFailure::Network(OutboundFailure::Timeout) = req_failure {
+								common_params.metrics.on_full_request_timeout();
+							} else {
+								common_params.metrics.on_full_request_error();
+							}
+						},
+					};
+					gum::debug!(
+						target: LOG_TARGET,
+						candidate_hash = ?common_params.candidate_hash,
+						?validator_index,
+						err = ?e,
+						"Error fetching full available data."
+					);
+				},
+			}
+		}
+	}
+}
diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/mod.rs b/polkadot/node/network/availability-recovery/src/task/strategy/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1403277c8a95bff3c98115f58197fd0373047c71
--- /dev/null
+++ b/polkadot/node/network/availability-recovery/src/task/strategy/mod.rs
@@ -0,0 +1,1558 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Recovery strategies.
+
+mod chunks;
+mod full;
+mod systematic;
+
+pub use self::{
+	chunks::{FetchChunks, FetchChunksParams},
+	full::{FetchFull, FetchFullParams},
+	systematic::{FetchSystematicChunks, FetchSystematicChunksParams},
+};
+use crate::{
+	futures_undead::FuturesUndead, ErasureTask, PostRecoveryCheck, RecoveryParams, LOG_TARGET,
+};
+
+use codec::Decode;
+use futures::{channel::oneshot, SinkExt};
+use polkadot_erasure_coding::branch_hash;
+#[cfg(not(test))]
+use polkadot_node_network_protocol::request_response::CHUNK_REQUEST_TIMEOUT;
+use polkadot_node_network_protocol::request_response::{
+	self as req_res, outgoing::RequestError, OutgoingRequest, Recipient, Requests,
+};
+use polkadot_node_primitives::{AvailableData, ErasureChunk};
+use polkadot_node_subsystem::{
+	messages::{AvailabilityStoreMessage, NetworkBridgeTxMessage},
+	overseer, RecoveryError,
+};
+use polkadot_primitives::{AuthorityDiscoveryId, BlakeTwo256, ChunkIndex, HashT, ValidatorIndex};
+use sc_network::{IfDisconnected, OutboundFailure, ProtocolName, RequestFailure};
+use std::{
+	collections::{BTreeMap, HashMap, VecDeque},
+	time::Duration,
+};
+
+// How many parallel chunk fetching requests should be running at once.
+const N_PARALLEL: usize = 50;
+
+/// Time after which we consider a request to have failed
+///
+/// and we should try more peers. Note in theory the request times out at the network level,
+/// measurements have shown, that in practice requests might actually take longer to fail in
+/// certain occasions. (The very least, authority discovery is not part of the timeout.)
+///
+/// For the time being this value is the same as the timeout on the networking layer, but as this
+/// timeout is more soft than the networking one, it might make sense to pick different values as
+/// well.
+#[cfg(not(test))]
+const TIMEOUT_START_NEW_REQUESTS: Duration = CHUNK_REQUEST_TIMEOUT;
+#[cfg(test)]
+const TIMEOUT_START_NEW_REQUESTS: Duration = Duration::from_millis(100);
+
+/// The maximum number of times systematic chunk recovery will try making a request for a given
+/// (validator,chunk) pair, if the error was not fatal. Added so that we don't get stuck in an
+/// infinite retry loop.
+pub const SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT: u32 = 2;
+/// The maximum number of times regular chunk recovery will try making a request for a given
+/// (validator,chunk) pair, if the error was not fatal. Added so that we don't get stuck in an
+/// infinite retry loop.
+pub const REGULAR_CHUNKS_REQ_RETRY_LIMIT: u32 = 5;
+
+// Helpful type alias for tracking ongoing chunk requests.
+type OngoingRequests = FuturesUndead<(
+	AuthorityDiscoveryId,
+	ValidatorIndex,
+	Result<(Option<ErasureChunk>, ProtocolName), RequestError>,
+)>;
+
+const fn is_unavailable(
+	received_chunks: usize,
+	requesting_chunks: usize,
+	unrequested_validators: usize,
+	threshold: usize,
+) -> bool {
+	received_chunks + requesting_chunks + unrequested_validators < threshold
+}
+
+/// Check validity of a chunk.
+fn is_chunk_valid(params: &RecoveryParams, chunk: &ErasureChunk) -> bool {
+	let anticipated_hash =
+		match branch_hash(&params.erasure_root, chunk.proof(), chunk.index.0 as usize) {
+			Ok(hash) => hash,
+			Err(e) => {
+				gum::debug!(
+					target: LOG_TARGET,
+					candidate_hash = ?params.candidate_hash,
+					chunk_index = ?chunk.index,
+					error = ?e,
+					"Invalid Merkle proof",
+				);
+				return false
+			},
+		};
+	let erasure_chunk_hash = BlakeTwo256::hash(&chunk.chunk);
+	if anticipated_hash != erasure_chunk_hash {
+		gum::debug!(
+			target: LOG_TARGET,
+			candidate_hash = ?params.candidate_hash,
+			chunk_index = ?chunk.index,
+			"Merkle proof mismatch"
+		);
+		return false
+	}
+	true
+}
+
+/// Perform the validity checks after recovery.
+async fn do_post_recovery_check(
+	params: &RecoveryParams,
+	data: AvailableData,
+) -> Result<AvailableData, RecoveryError> {
+	let mut erasure_task_tx = params.erasure_task_tx.clone();
+	match params.post_recovery_check {
+		PostRecoveryCheck::Reencode => {
+			// Send request to re-encode the chunks and check merkle root.
+			let (reencode_tx, reencode_rx) = oneshot::channel();
+			erasure_task_tx
+				.send(ErasureTask::Reencode(
+					params.n_validators,
+					params.erasure_root,
+					data,
+					reencode_tx,
+				))
+				.await
+				.map_err(|_| RecoveryError::ChannelClosed)?;
+
+			reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)?.ok_or_else(|| {
+				gum::trace!(
+					target: LOG_TARGET,
+					candidate_hash = ?params.candidate_hash,
+					erasure_root = ?params.erasure_root,
+					"Data recovery error - root mismatch",
+				);
+				RecoveryError::Invalid
+			})
+		},
+		PostRecoveryCheck::PovHash => {
+			let pov = data.pov.clone();
+			(pov.hash() == params.pov_hash).then_some(data).ok_or_else(|| {
+				gum::trace!(
+					target: LOG_TARGET,
+					candidate_hash = ?params.candidate_hash,
+					expected_pov_hash = ?params.pov_hash,
+					actual_pov_hash = ?pov.hash(),
+					"Data recovery error - PoV hash mismatch",
+				);
+				RecoveryError::Invalid
+			})
+		},
+	}
+}
+
+#[async_trait::async_trait]
+/// Common trait for runnable recovery strategies.
+pub trait RecoveryStrategy<Sender: overseer::AvailabilityRecoverySenderTrait>: Send {
+	/// Main entry point of the strategy.
+	async fn run(
+		mut self: Box<Self>,
+		state: &mut State,
+		sender: &mut Sender,
+		common_params: &RecoveryParams,
+	) -> Result<AvailableData, RecoveryError>;
+
+	/// Return the name of the strategy for logging purposes.
+	fn display_name(&self) -> &'static str;
+
+	/// Return the strategy type for use as a metric label.
+	fn strategy_type(&self) -> &'static str;
+}
+
+/// Utility type used for recording the result of requesting a chunk from a validator.
+enum ErrorRecord {
+	NonFatal(u32),
+	Fatal,
+}
+
+/// Helper struct used for the `received_chunks` mapping.
+/// Compared to `ErasureChunk`, it doesn't need to hold the `ChunkIndex` (because it's the key used
+/// for the map) and proof, but needs to hold the `ValidatorIndex` instead.
+struct Chunk {
+	/// The erasure-encoded chunk of data belonging to the candidate block.
+	chunk: Vec<u8>,
+	/// The validator index that corresponds to this chunk. Not always the same as the chunk index.
+	validator_index: ValidatorIndex,
+}
+
+/// Intermediate/common data that must be passed between `RecoveryStrategy`s belonging to the
+/// same `RecoveryTask`.
+pub struct State {
+	/// Chunks received so far.
+	/// This MUST be a `BTreeMap` in order for systematic recovery to work (the algorithm assumes
+	/// that chunks are ordered by their index). If we ever switch this to some non-ordered
+	/// collection, we need to add a sort step to the systematic recovery.
+	received_chunks: BTreeMap<ChunkIndex, Chunk>,
+
+	/// A record of errors returned when requesting a chunk from a validator.
+	recorded_errors: HashMap<(AuthorityDiscoveryId, ValidatorIndex), ErrorRecord>,
+}
+
+impl State {
+	pub fn new() -> Self {
+		Self { received_chunks: BTreeMap::new(), recorded_errors: HashMap::new() }
+	}
+
+	fn insert_chunk(&mut self, chunk_index: ChunkIndex, chunk: Chunk) {
+		self.received_chunks.insert(chunk_index, chunk);
+	}
+
+	fn chunk_count(&self) -> usize {
+		self.received_chunks.len()
+	}
+
+	fn systematic_chunk_count(&self, systematic_threshold: usize) -> usize {
+		self.received_chunks
+			.range(ChunkIndex(0)..ChunkIndex(systematic_threshold as u32))
+			.count()
+	}
+
+	fn record_error_fatal(
+		&mut self,
+		authority_id: AuthorityDiscoveryId,
+		validator_index: ValidatorIndex,
+	) {
+		self.recorded_errors.insert((authority_id, validator_index), ErrorRecord::Fatal);
+	}
+
+	fn record_error_non_fatal(
+		&mut self,
+		authority_id: AuthorityDiscoveryId,
+		validator_index: ValidatorIndex,
+	) {
+		self.recorded_errors
+			.entry((authority_id, validator_index))
+			.and_modify(|record| {
+				if let ErrorRecord::NonFatal(ref mut count) = record {
+					*count = count.saturating_add(1);
+				}
+			})
+			.or_insert(ErrorRecord::NonFatal(1));
+	}
+
+	fn can_retry_request(
+		&self,
+		key: &(AuthorityDiscoveryId, ValidatorIndex),
+		retry_threshold: u32,
+	) -> bool {
+		match self.recorded_errors.get(key) {
+			None => true,
+			Some(entry) => match entry {
+				ErrorRecord::Fatal => false,
+				ErrorRecord::NonFatal(count) if *count < retry_threshold => true,
+				ErrorRecord::NonFatal(_) => false,
+			},
+		}
+	}
+
+	/// Retrieve the local chunks held in the av-store (should be either 0 or 1).
+	async fn populate_from_av_store<Sender: overseer::AvailabilityRecoverySenderTrait>(
+		&mut self,
+		params: &RecoveryParams,
+		sender: &mut Sender,
+	) -> Vec<(ValidatorIndex, ChunkIndex)> {
+		let (tx, rx) = oneshot::channel();
+		sender
+			.send_message(AvailabilityStoreMessage::QueryAllChunks(params.candidate_hash, tx))
+			.await;
+
+		match rx.await {
+			Ok(chunks) => {
+				// This should either be length 1 or 0. If we had the whole data,
+				// we wouldn't have reached this stage.
+				let chunk_indices: Vec<_> = chunks
+					.iter()
+					.map(|(validator_index, chunk)| (*validator_index, chunk.index))
+					.collect();
+
+				for (validator_index, chunk) in chunks {
+					if is_chunk_valid(params, &chunk) {
+						gum::trace!(
+							target: LOG_TARGET,
+							candidate_hash = ?params.candidate_hash,
+							chunk_index = ?chunk.index,
+							"Found valid chunk on disk"
+						);
+						self.insert_chunk(
+							chunk.index,
+							Chunk { chunk: chunk.chunk, validator_index },
+						);
+					} else {
+						gum::error!(
+							target: LOG_TARGET,
+							"Loaded invalid chunk from disk! Disk/Db corruption _very_ likely - please fix ASAP!"
+						);
+					};
+				}
+
+				chunk_indices
+			},
+			Err(oneshot::Canceled) => {
+				gum::warn!(
+					target: LOG_TARGET,
+					candidate_hash = ?params.candidate_hash,
+					"Failed to reach the availability store"
+				);
+
+				vec![]
+			},
+		}
+	}
+
+	/// Launch chunk requests in parallel, according to the parameters.
+	async fn launch_parallel_chunk_requests<Sender>(
+		&mut self,
+		strategy_type: &str,
+		params: &RecoveryParams,
+		sender: &mut Sender,
+		desired_requests_count: usize,
+		validators: &mut VecDeque<(AuthorityDiscoveryId, ValidatorIndex)>,
+		requesting_chunks: &mut OngoingRequests,
+	) where
+		Sender: overseer::AvailabilityRecoverySenderTrait,
+	{
+		let candidate_hash = params.candidate_hash;
+		let already_requesting_count = requesting_chunks.len();
+
+		let to_launch = desired_requests_count - already_requesting_count;
+		let mut requests = Vec::with_capacity(to_launch);
+
+		gum::trace!(
+			target: LOG_TARGET,
+			?candidate_hash,
+			"Attempting to launch {} requests",
+			to_launch
+		);
+
+		while requesting_chunks.len() < desired_requests_count {
+			if let Some((authority_id, validator_index)) = validators.pop_back() {
+				gum::trace!(
+					target: LOG_TARGET,
+					?authority_id,
+					?validator_index,
+					?candidate_hash,
+					"Requesting chunk",
+				);
+
+				// Request data.
+				let raw_request_v2 =
+					req_res::v2::ChunkFetchingRequest { candidate_hash, index: validator_index };
+				let raw_request_v1 = req_res::v1::ChunkFetchingRequest::from(raw_request_v2);
+
+				let (req, res) = OutgoingRequest::new_with_fallback(
+					Recipient::Authority(authority_id.clone()),
+					raw_request_v2,
+					raw_request_v1,
+				);
+				requests.push(Requests::ChunkFetching(req));
+
+				params.metrics.on_chunk_request_issued(strategy_type);
+				let timer = params.metrics.time_chunk_request(strategy_type);
+				let v1_protocol_name = params.req_v1_protocol_name.clone();
+				let v2_protocol_name = params.req_v2_protocol_name.clone();
+
+				let chunk_mapping_enabled = params.chunk_mapping_enabled;
+				let authority_id_clone = authority_id.clone();
+
+				requesting_chunks.push(Box::pin(async move {
+					let _timer = timer;
+					let res = match res.await {
+						Ok((bytes, protocol)) =>
+							if v2_protocol_name == protocol {
+								match req_res::v2::ChunkFetchingResponse::decode(&mut &bytes[..]) {
+									Ok(req_res::v2::ChunkFetchingResponse::Chunk(chunk)) =>
+										Ok((Some(chunk.into()), protocol)),
+									Ok(req_res::v2::ChunkFetchingResponse::NoSuchChunk) =>
+										Ok((None, protocol)),
+									Err(e) => Err(RequestError::InvalidResponse(e)),
+								}
+							} else if v1_protocol_name == protocol {
+								// V1 protocol version must not be used when chunk mapping node
+								// feature is enabled, because we can't know the real index of the
+								// returned chunk.
+								// This case should never be reached as long as the
+								// `AvailabilityChunkMapping` feature is only enabled after the
+								// v1 version is removed. Still, log this.
+								if chunk_mapping_enabled {
+									gum::info!(
+										target: LOG_TARGET,
+										?candidate_hash,
+										authority_id = ?authority_id_clone,
+										"Another validator is responding on /req_chunk/1 protocol while the availability chunk \
+										mapping feature is enabled in the runtime. All validators must switch to /req_chunk/2."
+									);
+								}
+
+								match req_res::v1::ChunkFetchingResponse::decode(&mut &bytes[..]) {
+									Ok(req_res::v1::ChunkFetchingResponse::Chunk(chunk)) => Ok((
+										Some(chunk.recombine_into_chunk(&raw_request_v1)),
+										protocol,
+									)),
+									Ok(req_res::v1::ChunkFetchingResponse::NoSuchChunk) =>
+										Ok((None, protocol)),
+									Err(e) => Err(RequestError::InvalidResponse(e)),
+								}
+							} else {
+								Err(RequestError::NetworkError(RequestFailure::UnknownProtocol))
+							},
+
+						Err(e) => Err(e),
+					};
+
+					(authority_id, validator_index, res)
+				}));
+			} else {
+				break
+			}
+		}
+
+		if requests.len() != 0 {
+			sender
+				.send_message(NetworkBridgeTxMessage::SendRequests(
+					requests,
+					IfDisconnected::TryConnect,
+				))
+				.await;
+		}
+	}
+
+	/// Wait for a sufficient amount of chunks to reconstruct according to the provided `params`.
+	async fn wait_for_chunks(
+		&mut self,
+		strategy_type: &str,
+		params: &RecoveryParams,
+		retry_threshold: u32,
+		validators: &mut VecDeque<(AuthorityDiscoveryId, ValidatorIndex)>,
+		requesting_chunks: &mut OngoingRequests,
+		// If supplied, these validators will be used as a backup for requesting chunks. They
+		// should hold all chunks. Each of them will only be used to query one chunk.
+		backup_validators: &mut Vec<AuthorityDiscoveryId>,
+		// Function that returns `true` when this strategy can conclude. Either if we got enough
+		// chunks or if it's impossible.
+		mut can_conclude: impl FnMut(
+			// Number of validators left in the queue
+			usize,
+			// Number of in flight requests
+			usize,
+			// Number of valid chunks received so far
+			usize,
+			// Number of valid systematic chunks received so far
+			usize,
+		) -> bool,
+	) -> (usize, usize) {
+		let metrics = &params.metrics;
+
+		let mut total_received_responses = 0;
+		let mut error_count = 0;
+
+		// Wait for all current requests to conclude or time-out, or until we reach enough chunks.
+		// We also declare requests undead, once `TIMEOUT_START_NEW_REQUESTS` is reached and will
+		// return in that case for `launch_parallel_requests` to fill up slots again.
+		while let Some(res) = requesting_chunks.next_with_timeout(TIMEOUT_START_NEW_REQUESTS).await
+		{
+			total_received_responses += 1;
+
+			let (authority_id, validator_index, request_result) = res;
+
+			let mut is_error = false;
+
+			match request_result {
+				Ok((maybe_chunk, protocol)) => {
+					match protocol {
+						name if name == params.req_v1_protocol_name =>
+							params.metrics.on_chunk_response_v1(),
+						name if name == params.req_v2_protocol_name =>
+							params.metrics.on_chunk_response_v2(),
+						_ => {},
+					}
+
+					match maybe_chunk {
+						Some(chunk) =>
+							if is_chunk_valid(params, &chunk) {
+								metrics.on_chunk_request_succeeded(strategy_type);
+								gum::trace!(
+									target: LOG_TARGET,
+									candidate_hash = ?params.candidate_hash,
+									?authority_id,
+									?validator_index,
+									"Received valid chunk",
+								);
+								self.insert_chunk(
+									chunk.index,
+									Chunk { chunk: chunk.chunk, validator_index },
+								);
+							} else {
+								metrics.on_chunk_request_invalid(strategy_type);
+								error_count += 1;
+								// Record that we got an invalid chunk so that subsequent strategies
+								// don't try requesting this again.
+								self.record_error_fatal(authority_id.clone(), validator_index);
+								is_error = true;
+							},
+						None => {
+							metrics.on_chunk_request_no_such_chunk(strategy_type);
+							gum::trace!(
+								target: LOG_TARGET,
+								candidate_hash = ?params.candidate_hash,
+								?authority_id,
+								?validator_index,
+								"Validator did not have the chunk",
+							);
+							error_count += 1;
+							// Record that the validator did not have this chunk so that subsequent
+							// strategies don't try requesting this again.
+							self.record_error_fatal(authority_id.clone(), validator_index);
+							is_error = true;
+						},
+					}
+				},
+				Err(err) => {
+					error_count += 1;
+
+					gum::trace!(
+						target: LOG_TARGET,
+						candidate_hash= ?params.candidate_hash,
+						?err,
+						?authority_id,
+						?validator_index,
+						"Failure requesting chunk",
+					);
+
+					is_error = true;
+
+					match err {
+						RequestError::InvalidResponse(_) => {
+							metrics.on_chunk_request_invalid(strategy_type);
+
+							gum::debug!(
+								target: LOG_TARGET,
+								candidate_hash = ?params.candidate_hash,
+								?err,
+								?authority_id,
+								?validator_index,
+								"Chunk fetching response was invalid",
+							);
+
+							// Record that we got an invalid chunk so that this or
+							// subsequent strategies don't try requesting this again.
+							self.record_error_fatal(authority_id.clone(), validator_index);
+						},
+						RequestError::NetworkError(err) => {
+							// No debug logs on general network errors - that became very
+							// spammy occasionally.
+							if let RequestFailure::Network(OutboundFailure::Timeout) = err {
+								metrics.on_chunk_request_timeout(strategy_type);
+							} else {
+								metrics.on_chunk_request_error(strategy_type);
+							}
+
+							// Record that we got a non-fatal error so that this or
+							// subsequent strategies will retry requesting this only a
+							// limited number of times.
+							self.record_error_non_fatal(authority_id.clone(), validator_index);
+						},
+						RequestError::Canceled(_) => {
+							metrics.on_chunk_request_error(strategy_type);
+
+							// Record that we got a non-fatal error so that this or
+							// subsequent strategies will retry requesting this only a
+							// limited number of times.
+							self.record_error_non_fatal(authority_id.clone(), validator_index);
+						},
+					}
+				},
+			}
+
+			if is_error {
+				// First, see if we can retry the request.
+				if self.can_retry_request(&(authority_id.clone(), validator_index), retry_threshold)
+				{
+					validators.push_front((authority_id, validator_index));
+				} else {
+					// Otherwise, try requesting from a backer as a backup, if we've not already
+					// requested the same chunk from it.
+
+					let position = backup_validators.iter().position(|v| {
+						!self.recorded_errors.contains_key(&(v.clone(), validator_index))
+					});
+					if let Some(position) = position {
+						// Use swap_remove because it's faster and we don't care about order here.
+						let backer = backup_validators.swap_remove(position);
+						validators.push_front((backer, validator_index));
+					}
+				}
+			}
+
+			if can_conclude(
+				validators.len(),
+				requesting_chunks.total_len(),
+				self.chunk_count(),
+				self.systematic_chunk_count(params.systematic_threshold),
+			) {
+				gum::debug!(
+					target: LOG_TARGET,
+					validators_len = validators.len(),
+					candidate_hash = ?params.candidate_hash,
+					received_chunks_count = ?self.chunk_count(),
+					requested_chunks_count = ?requesting_chunks.len(),
+					threshold = ?params.threshold,
+					"Can conclude availability recovery strategy",
+				);
+				break
+			}
+		}
+
+		(total_received_responses, error_count)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{tests::*, Metrics, RecoveryStrategy, RecoveryTask};
+	use assert_matches::assert_matches;
+	use codec::Error as DecodingError;
+	use futures::{
+		channel::mpsc::{self, UnboundedReceiver},
+		executor, future, Future, FutureExt, StreamExt,
+	};
+	use polkadot_erasure_coding::{recovery_threshold, systematic_recovery_threshold};
+	use polkadot_node_network_protocol::request_response::Protocol;
+	use polkadot_node_primitives::{BlockData, PoV};
+	use polkadot_node_subsystem::{AllMessages, TimeoutExt};
+	use polkadot_node_subsystem_test_helpers::{
+		derive_erasure_chunks_with_proofs_and_root, sender_receiver, TestSubsystemSender,
+	};
+	use polkadot_primitives::{CandidateHash, HeadData, PersistedValidationData};
+	use polkadot_primitives_test_helpers::dummy_hash;
+	use sp_keyring::Sr25519Keyring;
+	use std::sync::Arc;
+
+	const TIMEOUT: Duration = Duration::from_secs(1);
+
+	impl Default for RecoveryParams {
+		fn default() -> Self {
+			let validators = vec![
+				Sr25519Keyring::Ferdie,
+				Sr25519Keyring::Alice.into(),
+				Sr25519Keyring::Bob.into(),
+				Sr25519Keyring::Charlie,
+				Sr25519Keyring::Dave,
+				Sr25519Keyring::One,
+				Sr25519Keyring::Two,
+			];
+			let (erasure_task_tx, _erasure_task_rx) = mpsc::channel(10);
+
+			Self {
+				validator_authority_keys: validator_authority_id(&validators),
+				n_validators: validators.len(),
+				threshold: recovery_threshold(validators.len()).unwrap(),
+				systematic_threshold: systematic_recovery_threshold(validators.len()).unwrap(),
+				candidate_hash: CandidateHash(dummy_hash()),
+				erasure_root: dummy_hash(),
+				metrics: Metrics::new_dummy(),
+				bypass_availability_store: false,
+				post_recovery_check: PostRecoveryCheck::Reencode,
+				pov_hash: dummy_hash(),
+				req_v1_protocol_name: "/req_chunk/1".into(),
+				req_v2_protocol_name: "/req_chunk/2".into(),
+				chunk_mapping_enabled: true,
+				erasure_task_tx,
+			}
+		}
+	}
+
+	impl RecoveryParams {
+		fn create_chunks(&mut self) -> Vec<ErasureChunk> {
+			let available_data = dummy_available_data();
+			let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root(
+				self.n_validators,
+				&available_data,
+				|_, _| {},
+			);
+
+			self.erasure_root = erasure_root;
+			self.pov_hash = available_data.pov.hash();
+
+			chunks
+		}
+	}
+
+	fn dummy_available_data() -> AvailableData {
+		let validation_data = PersistedValidationData {
+			parent_head: HeadData(vec![7, 8, 9]),
+			relay_parent_number: Default::default(),
+			max_pov_size: 1024,
+			relay_parent_storage_root: Default::default(),
+		};
+
+		AvailableData {
+			validation_data,
+			pov: Arc::new(PoV { block_data: BlockData(vec![42; 64]) }),
+		}
+	}
+
+	fn test_harness<RecvFut: Future<Output = ()>, TestFut: Future<Output = ()>>(
+		receiver_future: impl FnOnce(UnboundedReceiver<AllMessages>) -> RecvFut,
+		test: impl FnOnce(TestSubsystemSender) -> TestFut,
+	) {
+		let (sender, receiver) = sender_receiver();
+
+		let test_fut = test(sender);
+		let receiver_future = receiver_future(receiver);
+
+		futures::pin_mut!(test_fut);
+		futures::pin_mut!(receiver_future);
+
+		executor::block_on(future::join(test_fut, receiver_future)).1
+	}
+
+	#[test]
+	fn test_recorded_errors() {
+		let retry_threshold = 2;
+		let mut state = State::new();
+
+		let alice = Sr25519Keyring::Alice.public();
+		let bob = Sr25519Keyring::Bob.public();
+		let eve = Sr25519Keyring::Eve.public();
+
+		assert!(state.can_retry_request(&(alice.into(), 0.into()), retry_threshold));
+		assert!(state.can_retry_request(&(alice.into(), 0.into()), 0));
+		state.record_error_non_fatal(alice.into(), 0.into());
+		assert!(state.can_retry_request(&(alice.into(), 0.into()), retry_threshold));
+		state.record_error_non_fatal(alice.into(), 0.into());
+		assert!(!state.can_retry_request(&(alice.into(), 0.into()), retry_threshold));
+		state.record_error_non_fatal(alice.into(), 0.into());
+		assert!(!state.can_retry_request(&(alice.into(), 0.into()), retry_threshold));
+
+		assert!(state.can_retry_request(&(alice.into(), 0.into()), 5));
+
+		state.record_error_fatal(bob.into(), 1.into());
+		assert!(!state.can_retry_request(&(bob.into(), 1.into()), retry_threshold));
+		state.record_error_non_fatal(bob.into(), 1.into());
+		assert!(!state.can_retry_request(&(bob.into(), 1.into()), retry_threshold));
+
+		assert!(state.can_retry_request(&(eve.into(), 4.into()), 0));
+		assert!(state.can_retry_request(&(eve.into(), 4.into()), retry_threshold));
+	}
+
+	#[test]
+	fn test_populate_from_av_store() {
+		let params = RecoveryParams::default();
+
+		// Failed to reach the av store
+		{
+			let params = params.clone();
+			let candidate_hash = params.candidate_hash;
+			let mut state = State::new();
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					assert_matches!(
+					receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(),
+					AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAllChunks(hash, tx)) => {
+						assert_eq!(hash, candidate_hash);
+						drop(tx);
+					});
+				},
+				|mut sender| async move {
+					let local_chunk_indices =
+						state.populate_from_av_store(&params, &mut sender).await;
+
+					assert_eq!(state.chunk_count(), 0);
+					assert_eq!(local_chunk_indices.len(), 0);
+				},
+			);
+		}
+
+		// Found invalid chunk
+		{
+			let mut params = params.clone();
+			let candidate_hash = params.candidate_hash;
+			let mut state = State::new();
+			let chunks = params.create_chunks();
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					assert_matches!(
+					receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(),
+					AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAllChunks(hash, tx)) => {
+						assert_eq!(hash, candidate_hash);
+						let mut chunk = chunks[0].clone();
+						chunk.index = 3.into();
+						tx.send(vec![(2.into(), chunk)]).unwrap();
+					});
+				},
+				|mut sender| async move {
+					let local_chunk_indices =
+						state.populate_from_av_store(&params, &mut sender).await;
+
+					assert_eq!(state.chunk_count(), 0);
+					assert_eq!(local_chunk_indices.len(), 1);
+				},
+			);
+		}
+
+		// Found valid chunk
+		{
+			let mut params = params.clone();
+			let candidate_hash = params.candidate_hash;
+			let mut state = State::new();
+			let chunks = params.create_chunks();
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					assert_matches!(
+					receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(),
+					AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAllChunks(hash, tx)) => {
+						assert_eq!(hash, candidate_hash);
+						tx.send(vec![(4.into(), chunks[1].clone())]).unwrap();
+					});
+				},
+				|mut sender| async move {
+					let local_chunk_indices =
+						state.populate_from_av_store(&params, &mut sender).await;
+
+					assert_eq!(state.chunk_count(), 1);
+					assert_eq!(local_chunk_indices.len(), 1);
+				},
+			);
+		}
+	}
+
+	#[test]
+	fn test_launch_parallel_chunk_requests() {
+		let params = RecoveryParams::default();
+		let alice: AuthorityDiscoveryId = Sr25519Keyring::Alice.public().into();
+		let bob: AuthorityDiscoveryId = Sr25519Keyring::Bob.public().into();
+		let eve: AuthorityDiscoveryId = Sr25519Keyring::Eve.public().into();
+
+		// No validators to request from.
+		{
+			let params = params.clone();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			let mut validators = VecDeque::new();
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|mut sender| async move {
+					state
+						.launch_parallel_chunk_requests(
+							"regular",
+							&params,
+							&mut sender,
+							3,
+							&mut validators,
+							&mut ongoing_reqs,
+						)
+						.await;
+
+					assert_eq!(ongoing_reqs.total_len(), 0);
+				},
+			);
+		}
+
+		// Has validators but no need to request more.
+		{
+			let params = params.clone();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			let mut validators = VecDeque::new();
+			validators.push_back((alice.clone(), ValidatorIndex(1)));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|mut sender| async move {
+					state
+						.launch_parallel_chunk_requests(
+							"regular",
+							&params,
+							&mut sender,
+							0,
+							&mut validators,
+							&mut ongoing_reqs,
+						)
+						.await;
+
+					assert_eq!(ongoing_reqs.total_len(), 0);
+				},
+			);
+		}
+
+		// Has validators but no need to request more.
+		{
+			let params = params.clone();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			ongoing_reqs.push(async { todo!() }.boxed());
+			ongoing_reqs.soft_cancel();
+			let mut validators = VecDeque::new();
+			validators.push_back((alice.clone(), ValidatorIndex(1)));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|mut sender| async move {
+					state
+						.launch_parallel_chunk_requests(
+							"regular",
+							&params,
+							&mut sender,
+							0,
+							&mut validators,
+							&mut ongoing_reqs,
+						)
+						.await;
+
+					assert_eq!(ongoing_reqs.total_len(), 1);
+					assert_eq!(ongoing_reqs.len(), 0);
+				},
+			);
+		}
+
+		// Needs to request more.
+		{
+			let params = params.clone();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			ongoing_reqs.push(async { todo!() }.boxed());
+			ongoing_reqs.soft_cancel();
+			ongoing_reqs.push(async { todo!() }.boxed());
+			let mut validators = VecDeque::new();
+			validators.push_back((alice.clone(), 0.into()));
+			validators.push_back((bob, 1.into()));
+			validators.push_back((eve, 2.into()));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					assert_matches!(
+						receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(),
+						AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendRequests(requests, _)) if requests.len()
+== 3 					);
+				},
+				|mut sender| async move {
+					state
+						.launch_parallel_chunk_requests(
+							"regular",
+							&params,
+							&mut sender,
+							10,
+							&mut validators,
+							&mut ongoing_reqs,
+						)
+						.await;
+
+					assert_eq!(ongoing_reqs.total_len(), 5);
+					assert_eq!(ongoing_reqs.len(), 4);
+				},
+			);
+		}
+
+		// Check network protocol versioning.
+		{
+			let params = params.clone();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			let mut validators = VecDeque::new();
+			validators.push_back((alice, 0.into()));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					match receiver.next().timeout(TIMEOUT).await.unwrap().unwrap() {
+						AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendRequests(
+							mut requests,
+							_,
+						)) => {
+							assert_eq!(requests.len(), 1);
+							// By default, we should use the new protocol version with a fallback on
+							// the older one.
+							let (protocol, request) = requests.remove(0).encode_request();
+							assert_eq!(protocol, Protocol::ChunkFetchingV2);
+							assert_eq!(
+								request.fallback_request.unwrap().1,
+								Protocol::ChunkFetchingV1
+							);
+						},
+						_ => unreachable!(),
+					}
+				},
+				|mut sender| async move {
+					state
+						.launch_parallel_chunk_requests(
+							"regular",
+							&params,
+							&mut sender,
+							10,
+							&mut validators,
+							&mut ongoing_reqs,
+						)
+						.await;
+
+					assert_eq!(ongoing_reqs.total_len(), 1);
+					assert_eq!(ongoing_reqs.len(), 1);
+				},
+			);
+		}
+	}
+
+	#[test]
+	fn test_wait_for_chunks() {
+		let params = RecoveryParams::default();
+		let retry_threshold = 2;
+
+		// No ongoing requests.
+		{
+			let params = params.clone();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			let mut validators = VecDeque::new();
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|_| async move {
+					let (total_responses, error_count) = state
+						.wait_for_chunks(
+							"regular",
+							&params,
+							retry_threshold,
+							&mut validators,
+							&mut ongoing_reqs,
+							&mut vec![],
+							|_, _, _, _| false,
+						)
+						.await;
+					assert_eq!(total_responses, 0);
+					assert_eq!(error_count, 0);
+					assert_eq!(state.chunk_count(), 0);
+				},
+			);
+		}
+
+		// Complex scenario.
+		{
+			let mut params = params.clone();
+			let chunks = params.create_chunks();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[0].clone(),
+					0.into(),
+					Ok((Some(chunks[0].clone()), "".into())),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.soft_cancel();
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[1].clone(),
+					1.into(),
+					Ok((Some(chunks[1].clone()), "".into())),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[2].clone(),
+					2.into(),
+					Ok((None, "".into())),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[3].clone(),
+					3.into(),
+					Err(RequestError::from(DecodingError::from("err"))),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[4].clone(),
+					4.into(),
+					Err(RequestError::NetworkError(RequestFailure::NotConnected)),
+				))
+				.boxed(),
+			);
+
+			let mut validators: VecDeque<_> = (5..params.n_validators as u32)
+				.map(|i| (params.validator_authority_keys[i as usize].clone(), i.into()))
+				.collect();
+			validators.push_back((
+				Sr25519Keyring::AliceStash.public().into(),
+				ValidatorIndex(params.n_validators as u32),
+			));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|_| async move {
+					let (total_responses, error_count) = state
+						.wait_for_chunks(
+							"regular",
+							&params,
+							retry_threshold,
+							&mut validators,
+							&mut ongoing_reqs,
+							&mut vec![],
+							|_, _, _, _| false,
+						)
+						.await;
+					assert_eq!(total_responses, 5);
+					assert_eq!(error_count, 3);
+					assert_eq!(state.chunk_count(), 2);
+
+					let mut expected_validators: VecDeque<_> = (4..params.n_validators as u32)
+						.map(|i| (params.validator_authority_keys[i as usize].clone(), i.into()))
+						.collect();
+					expected_validators.push_back((
+						Sr25519Keyring::AliceStash.public().into(),
+						ValidatorIndex(params.n_validators as u32),
+					));
+
+					assert_eq!(validators, expected_validators);
+
+					// This time we'll go over the recoverable error threshold.
+					ongoing_reqs.push(
+						future::ready((
+							params.validator_authority_keys[4].clone(),
+							4.into(),
+							Err(RequestError::NetworkError(RequestFailure::NotConnected)),
+						))
+						.boxed(),
+					);
+
+					let (total_responses, error_count) = state
+						.wait_for_chunks(
+							"regular",
+							&params,
+							retry_threshold,
+							&mut validators,
+							&mut ongoing_reqs,
+							&mut vec![],
+							|_, _, _, _| false,
+						)
+						.await;
+					assert_eq!(total_responses, 1);
+					assert_eq!(error_count, 1);
+					assert_eq!(state.chunk_count(), 2);
+
+					validators.pop_front();
+					let mut expected_validators: VecDeque<_> = (5..params.n_validators as u32)
+						.map(|i| (params.validator_authority_keys[i as usize].clone(), i.into()))
+						.collect();
+					expected_validators.push_back((
+						Sr25519Keyring::AliceStash.public().into(),
+						ValidatorIndex(params.n_validators as u32),
+					));
+
+					assert_eq!(validators, expected_validators);
+
+					// Check that can_conclude returning true terminates the loop.
+					let (total_responses, error_count) = state
+						.wait_for_chunks(
+							"regular",
+							&params,
+							retry_threshold,
+							&mut validators,
+							&mut ongoing_reqs,
+							&mut vec![],
+							|_, _, _, _| true,
+						)
+						.await;
+					assert_eq!(total_responses, 0);
+					assert_eq!(error_count, 0);
+					assert_eq!(state.chunk_count(), 2);
+
+					assert_eq!(validators, expected_validators);
+				},
+			);
+		}
+
+		// Complex scenario with backups in the backing group.
+		{
+			let mut params = params.clone();
+			let chunks = params.create_chunks();
+			let mut state = State::new();
+			let mut ongoing_reqs = OngoingRequests::new();
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[0].clone(),
+					0.into(),
+					Ok((Some(chunks[0].clone()), "".into())),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.soft_cancel();
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[1].clone(),
+					1.into(),
+					Ok((Some(chunks[1].clone()), "".into())),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[2].clone(),
+					2.into(),
+					Ok((None, "".into())),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[3].clone(),
+					3.into(),
+					Err(RequestError::from(DecodingError::from("err"))),
+				))
+				.boxed(),
+			);
+			ongoing_reqs.push(
+				future::ready((
+					params.validator_authority_keys[4].clone(),
+					4.into(),
+					Err(RequestError::NetworkError(RequestFailure::NotConnected)),
+				))
+				.boxed(),
+			);
+
+			let mut validators: VecDeque<_> = (5..params.n_validators as u32)
+				.map(|i| (params.validator_authority_keys[i as usize].clone(), i.into()))
+				.collect();
+			validators.push_back((
+				Sr25519Keyring::Eve.public().into(),
+				ValidatorIndex(params.n_validators as u32),
+			));
+
+			let mut backup_backers = vec![
+				params.validator_authority_keys[2].clone(),
+				params.validator_authority_keys[0].clone(),
+				params.validator_authority_keys[4].clone(),
+				params.validator_authority_keys[3].clone(),
+				Sr25519Keyring::AliceStash.public().into(),
+				Sr25519Keyring::BobStash.public().into(),
+			];
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|_| async move {
+					let (total_responses, error_count) = state
+						.wait_for_chunks(
+							"regular",
+							&params,
+							retry_threshold,
+							&mut validators,
+							&mut ongoing_reqs,
+							&mut backup_backers,
+							|_, _, _, _| false,
+						)
+						.await;
+					assert_eq!(total_responses, 5);
+					assert_eq!(error_count, 3);
+					assert_eq!(state.chunk_count(), 2);
+
+					let mut expected_validators: VecDeque<_> = (5..params.n_validators as u32)
+						.map(|i| (params.validator_authority_keys[i as usize].clone(), i.into()))
+						.collect();
+					expected_validators.push_back((
+						Sr25519Keyring::Eve.public().into(),
+						ValidatorIndex(params.n_validators as u32),
+					));
+					// We picked a backer as a backup for chunks 2 and 3.
+					expected_validators
+						.push_front((params.validator_authority_keys[0].clone(), 2.into()));
+					expected_validators
+						.push_front((params.validator_authority_keys[2].clone(), 3.into()));
+					expected_validators
+						.push_front((params.validator_authority_keys[4].clone(), 4.into()));
+
+					assert_eq!(validators, expected_validators);
+
+					// This time we'll go over the recoverable error threshold for chunk 4.
+					ongoing_reqs.push(
+						future::ready((
+							params.validator_authority_keys[4].clone(),
+							4.into(),
+							Err(RequestError::NetworkError(RequestFailure::NotConnected)),
+						))
+						.boxed(),
+					);
+
+					validators.pop_front();
+
+					let (total_responses, error_count) = state
+						.wait_for_chunks(
+							"regular",
+							&params,
+							retry_threshold,
+							&mut validators,
+							&mut ongoing_reqs,
+							&mut backup_backers,
+							|_, _, _, _| false,
+						)
+						.await;
+					assert_eq!(total_responses, 1);
+					assert_eq!(error_count, 1);
+					assert_eq!(state.chunk_count(), 2);
+
+					expected_validators.pop_front();
+					expected_validators
+						.push_front((Sr25519Keyring::AliceStash.public().into(), 4.into()));
+
+					assert_eq!(validators, expected_validators);
+				},
+			);
+		}
+	}
+
+	#[test]
+	fn test_recovery_strategy_run() {
+		let params = RecoveryParams::default();
+
+		struct GoodStrategy;
+		#[async_trait::async_trait]
+		impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender> for GoodStrategy {
+			fn display_name(&self) -> &'static str {
+				"GoodStrategy"
+			}
+
+			fn strategy_type(&self) -> &'static str {
+				"good_strategy"
+			}
+
+			async fn run(
+				mut self: Box<Self>,
+				_state: &mut State,
+				_sender: &mut Sender,
+				_common_params: &RecoveryParams,
+			) -> Result<AvailableData, RecoveryError> {
+				Ok(dummy_available_data())
+			}
+		}
+
+		struct UnavailableStrategy;
+		#[async_trait::async_trait]
+		impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender>
+			for UnavailableStrategy
+		{
+			fn display_name(&self) -> &'static str {
+				"UnavailableStrategy"
+			}
+
+			fn strategy_type(&self) -> &'static str {
+				"unavailable_strategy"
+			}
+
+			async fn run(
+				mut self: Box<Self>,
+				_state: &mut State,
+				_sender: &mut Sender,
+				_common_params: &RecoveryParams,
+			) -> Result<AvailableData, RecoveryError> {
+				Err(RecoveryError::Unavailable)
+			}
+		}
+
+		struct InvalidStrategy;
+		#[async_trait::async_trait]
+		impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender>
+			for InvalidStrategy
+		{
+			fn display_name(&self) -> &'static str {
+				"InvalidStrategy"
+			}
+
+			fn strategy_type(&self) -> &'static str {
+				"invalid_strategy"
+			}
+
+			async fn run(
+				mut self: Box<Self>,
+				_state: &mut State,
+				_sender: &mut Sender,
+				_common_params: &RecoveryParams,
+			) -> Result<AvailableData, RecoveryError> {
+				Err(RecoveryError::Invalid)
+			}
+		}
+
+		// No recovery strategies.
+		{
+			let mut params = params.clone();
+			let strategies = VecDeque::new();
+			params.bypass_availability_store = true;
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|sender| async move {
+					let task = RecoveryTask::new(sender, params, strategies);
+
+					assert_eq!(task.run().await.unwrap_err(), RecoveryError::Unavailable);
+				},
+			);
+		}
+
+		// If we have the data in av-store, returns early.
+		{
+			let params = params.clone();
+			let strategies = VecDeque::new();
+			let candidate_hash = params.candidate_hash;
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					assert_matches!(
+					receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(),
+					AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAvailableData(hash, tx)) => {
+						assert_eq!(hash, candidate_hash);
+						tx.send(Some(dummy_available_data())).unwrap();
+					});
+				},
+				|sender| async move {
+					let task = RecoveryTask::new(sender, params, strategies);
+
+					assert_eq!(task.run().await.unwrap(), dummy_available_data());
+				},
+			);
+		}
+
+		// Strategy returning `RecoveryError::Invalid`` will short-circuit the entire task.
+		{
+			let mut params = params.clone();
+			params.bypass_availability_store = true;
+			let mut strategies: VecDeque<Box<dyn RecoveryStrategy<TestSubsystemSender>>> =
+				VecDeque::new();
+			strategies.push_back(Box::new(InvalidStrategy));
+			strategies.push_back(Box::new(GoodStrategy));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					// Shouldn't send any requests.
+					assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none());
+				},
+				|sender| async move {
+					let task = RecoveryTask::new(sender, params, strategies);
+
+					assert_eq!(task.run().await.unwrap_err(), RecoveryError::Invalid);
+				},
+			);
+		}
+
+		// Strategy returning `Unavailable` will fall back to the next one.
+		{
+			let params = params.clone();
+			let candidate_hash = params.candidate_hash;
+			let mut strategies: VecDeque<Box<dyn RecoveryStrategy<TestSubsystemSender>>> =
+				VecDeque::new();
+			strategies.push_back(Box::new(UnavailableStrategy));
+			strategies.push_back(Box::new(GoodStrategy));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					assert_matches!(
+						receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(),
+						AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAvailableData(hash, tx)) => {
+							assert_eq!(hash, candidate_hash);
+							tx.send(Some(dummy_available_data())).unwrap();
+					});
+				},
+				|sender| async move {
+					let task = RecoveryTask::new(sender, params, strategies);
+
+					assert_eq!(task.run().await.unwrap(), dummy_available_data());
+				},
+			);
+		}
+
+		// More complex scenario.
+		{
+			let params = params.clone();
+			let candidate_hash = params.candidate_hash;
+			let mut strategies: VecDeque<Box<dyn RecoveryStrategy<TestSubsystemSender>>> =
+				VecDeque::new();
+			strategies.push_back(Box::new(UnavailableStrategy));
+			strategies.push_back(Box::new(UnavailableStrategy));
+			strategies.push_back(Box::new(GoodStrategy));
+			strategies.push_back(Box::new(InvalidStrategy));
+
+			test_harness(
+				|mut receiver: UnboundedReceiver<AllMessages>| async move {
+					assert_matches!(
+						receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(),
+						AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAvailableData(hash, tx)) => {
+							assert_eq!(hash, candidate_hash);
+							tx.send(Some(dummy_available_data())).unwrap();
+					});
+				},
+				|sender| async move {
+					let task = RecoveryTask::new(sender, params, strategies);
+
+					assert_eq!(task.run().await.unwrap(), dummy_available_data());
+				},
+			);
+		}
+	}
+
+	#[test]
+	fn test_is_unavailable() {
+		assert_eq!(is_unavailable(0, 0, 0, 0), false);
+		assert_eq!(is_unavailable(2, 2, 2, 0), false);
+		// Already reached the threshold.
+		assert_eq!(is_unavailable(3, 0, 10, 3), false);
+		assert_eq!(is_unavailable(3, 2, 0, 3), false);
+		assert_eq!(is_unavailable(3, 2, 10, 3), false);
+		// It's still possible to reach the threshold
+		assert_eq!(is_unavailable(0, 0, 10, 3), false);
+		assert_eq!(is_unavailable(0, 0, 3, 3), false);
+		assert_eq!(is_unavailable(1, 1, 1, 3), false);
+		// Not possible to reach the threshold
+		assert_eq!(is_unavailable(0, 0, 0, 3), true);
+		assert_eq!(is_unavailable(2, 3, 2, 10), true);
+	}
+}
diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/systematic.rs b/polkadot/node/network/availability-recovery/src/task/strategy/systematic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..677bc2d1375aa75900123c39f1fbe59c8902ea69
--- /dev/null
+++ b/polkadot/node/network/availability-recovery/src/task/strategy/systematic.rs
@@ -0,0 +1,343 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+	futures_undead::FuturesUndead,
+	task::{
+		strategy::{
+			do_post_recovery_check, is_unavailable, OngoingRequests, N_PARALLEL,
+			SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT,
+		},
+		RecoveryParams, RecoveryStrategy, State,
+	},
+	LOG_TARGET,
+};
+
+use polkadot_node_primitives::AvailableData;
+use polkadot_node_subsystem::{overseer, RecoveryError};
+use polkadot_primitives::{ChunkIndex, ValidatorIndex};
+
+use std::collections::VecDeque;
+
+/// Parameters needed for fetching systematic chunks.
+pub struct FetchSystematicChunksParams {
+	/// Validators that hold the systematic chunks.
+	pub validators: Vec<(ChunkIndex, ValidatorIndex)>,
+	/// Validators in the backing group, to be used as a backup for requesting systematic chunks.
+	pub backers: Vec<ValidatorIndex>,
+}
+
+/// `RecoveryStrategy` that attempts to recover the systematic chunks from the validators that
+/// hold them, in order to bypass the erasure code reconstruction step, which is costly.
+pub struct FetchSystematicChunks {
+	/// Systematic recovery threshold.
+	threshold: usize,
+	/// Validators that hold the systematic chunks.
+	validators: Vec<(ChunkIndex, ValidatorIndex)>,
+	/// Backers to be used as a backup.
+	backers: Vec<ValidatorIndex>,
+	/// Collection of in-flight requests.
+	requesting_chunks: OngoingRequests,
+}
+
+impl FetchSystematicChunks {
+	/// Instantiate a new systematic chunks strategy.
+	pub fn new(params: FetchSystematicChunksParams) -> Self {
+		Self {
+			threshold: params.validators.len(),
+			validators: params.validators,
+			backers: params.backers,
+			requesting_chunks: FuturesUndead::new(),
+		}
+	}
+
+	fn is_unavailable(
+		unrequested_validators: usize,
+		in_flight_requests: usize,
+		systematic_chunk_count: usize,
+		threshold: usize,
+	) -> bool {
+		is_unavailable(
+			systematic_chunk_count,
+			in_flight_requests,
+			unrequested_validators,
+			threshold,
+		)
+	}
+
+	/// Desired number of parallel requests.
+	///
+	/// For the given threshold (total required number of chunks) get the desired number of
+	/// requests we want to have running in parallel at this time.
+	fn get_desired_request_count(&self, chunk_count: usize, threshold: usize) -> usize {
+		// Upper bound for parallel requests.
+		let max_requests_boundary = std::cmp::min(N_PARALLEL, threshold);
+		// How many chunks are still needed?
+		let remaining_chunks = threshold.saturating_sub(chunk_count);
+		// Actual number of requests we want to have in flight in parallel:
+		// We don't have to make up for any error rate, as an error fetching a systematic chunk
+		// results in failure of the entire strategy.
+		std::cmp::min(max_requests_boundary, remaining_chunks)
+	}
+
+	async fn attempt_systematic_recovery<Sender: overseer::AvailabilityRecoverySenderTrait>(
+		&mut self,
+		state: &mut State,
+		common_params: &RecoveryParams,
+	) -> Result<AvailableData, RecoveryError> {
+		let strategy_type = RecoveryStrategy::<Sender>::strategy_type(self);
+		let recovery_duration = common_params.metrics.time_erasure_recovery(strategy_type);
+		let reconstruct_duration = common_params.metrics.time_erasure_reconstruct(strategy_type);
+		let chunks = state
+			.received_chunks
+			.range(
+				ChunkIndex(0)..
+					ChunkIndex(
+						u32::try_from(self.threshold)
+							.expect("validator count should not exceed u32"),
+					),
+			)
+			.map(|(_, chunk)| chunk.chunk.clone())
+			.collect::<Vec<_>>();
+
+		let available_data = polkadot_erasure_coding::reconstruct_from_systematic_v1(
+			common_params.n_validators,
+			chunks,
+		);
+
+		match available_data {
+			Ok(data) => {
+				drop(reconstruct_duration);
+
+				// Attempt post-recovery check.
+				do_post_recovery_check(common_params, data)
+					.await
+					.map_err(|e| {
+						recovery_duration.map(|rd| rd.stop_and_discard());
+						e
+					})
+					.map(|data| {
+						gum::trace!(
+							target: LOG_TARGET,
+							candidate_hash = ?common_params.candidate_hash,
+							erasure_root = ?common_params.erasure_root,
+							"Data recovery from systematic chunks complete",
+						);
+						data
+					})
+			},
+			Err(err) => {
+				reconstruct_duration.map(|rd| rd.stop_and_discard());
+				recovery_duration.map(|rd| rd.stop_and_discard());
+
+				gum::debug!(
+					target: LOG_TARGET,
+					candidate_hash = ?common_params.candidate_hash,
+					erasure_root = ?common_params.erasure_root,
+					?err,
+					"Systematic data recovery error",
+				);
+
+				Err(RecoveryError::Invalid)
+			},
+		}
+	}
+}
+
+#[async_trait::async_trait]
+impl<Sender: overseer::AvailabilityRecoverySenderTrait> RecoveryStrategy<Sender>
+	for FetchSystematicChunks
+{
+	fn display_name(&self) -> &'static str {
+		"Fetch systematic chunks"
+	}
+
+	fn strategy_type(&self) -> &'static str {
+		"systematic_chunks"
+	}
+
+	async fn run(
+		mut self: Box<Self>,
+		state: &mut State,
+		sender: &mut Sender,
+		common_params: &RecoveryParams,
+	) -> Result<AvailableData, RecoveryError> {
+		// First query the store for any chunks we've got.
+		if !common_params.bypass_availability_store {
+			let local_chunk_indices = state.populate_from_av_store(common_params, sender).await;
+
+			for (_, our_c_index) in &local_chunk_indices {
+				// If we are among the systematic validators but hold an invalid chunk, we cannot
+				// perform the systematic recovery. Fall through to the next strategy.
+				if self.validators.iter().any(|(c_index, _)| c_index == our_c_index) &&
+					!state.received_chunks.contains_key(our_c_index)
+				{
+					gum::debug!(
+						target: LOG_TARGET,
+						candidate_hash = ?common_params.candidate_hash,
+						erasure_root = ?common_params.erasure_root,
+						requesting = %self.requesting_chunks.len(),
+						total_requesting = %self.requesting_chunks.total_len(),
+						n_validators = %common_params.n_validators,
+						chunk_index = ?our_c_index,
+						"Systematic chunk recovery is not possible. We are among the systematic validators but hold an invalid chunk",
+					);
+					return Err(RecoveryError::Unavailable)
+				}
+			}
+		}
+
+		// No need to query the validators that have the chunks we already received or that we know
+		// don't have the data from previous strategies.
+		self.validators.retain(|(c_index, v_index)| {
+			!state.received_chunks.contains_key(c_index) &&
+				state.can_retry_request(
+					&(common_params.validator_authority_keys[v_index.0 as usize].clone(), *v_index),
+					SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT,
+				)
+		});
+
+		let mut systematic_chunk_count = state
+			.received_chunks
+			.range(ChunkIndex(0)..ChunkIndex(self.threshold as u32))
+			.count();
+
+		// Safe to `take` here, as we're consuming `self` anyway and we're not using the
+		// `validators` or `backers` fields in other methods.
+		let mut validators_queue: VecDeque<_> = std::mem::take(&mut self.validators)
+			.into_iter()
+			.map(|(_, validator_index)| {
+				(
+					common_params.validator_authority_keys[validator_index.0 as usize].clone(),
+					validator_index,
+				)
+			})
+			.collect();
+		let mut backers: Vec<_> = std::mem::take(&mut self.backers)
+			.into_iter()
+			.map(|validator_index| {
+				common_params.validator_authority_keys[validator_index.0 as usize].clone()
+			})
+			.collect();
+
+		loop {
+			// If received_chunks has `systematic_chunk_threshold` entries, attempt to recover the
+			// data.
+			if systematic_chunk_count >= self.threshold {
+				return self.attempt_systematic_recovery::<Sender>(state, common_params).await
+			}
+
+			if Self::is_unavailable(
+				validators_queue.len(),
+				self.requesting_chunks.total_len(),
+				systematic_chunk_count,
+				self.threshold,
+			) {
+				gum::debug!(
+					target: LOG_TARGET,
+					candidate_hash = ?common_params.candidate_hash,
+					erasure_root = ?common_params.erasure_root,
+					%systematic_chunk_count,
+					requesting = %self.requesting_chunks.len(),
+					total_requesting = %self.requesting_chunks.total_len(),
+					n_validators = %common_params.n_validators,
+					systematic_threshold = ?self.threshold,
+					"Data recovery from systematic chunks is not possible",
+				);
+
+				return Err(RecoveryError::Unavailable)
+			}
+
+			let desired_requests_count =
+				self.get_desired_request_count(systematic_chunk_count, self.threshold);
+			let already_requesting_count = self.requesting_chunks.len();
+			gum::debug!(
+				target: LOG_TARGET,
+				?common_params.candidate_hash,
+				?desired_requests_count,
+				total_received = ?systematic_chunk_count,
+				systematic_threshold = ?self.threshold,
+				?already_requesting_count,
+				"Requesting systematic availability chunks for a candidate",
+			);
+
+			let strategy_type = RecoveryStrategy::<Sender>::strategy_type(&*self);
+
+			state
+				.launch_parallel_chunk_requests(
+					strategy_type,
+					common_params,
+					sender,
+					desired_requests_count,
+					&mut validators_queue,
+					&mut self.requesting_chunks,
+				)
+				.await;
+
+			let _ = state
+				.wait_for_chunks(
+					strategy_type,
+					common_params,
+					SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT,
+					&mut validators_queue,
+					&mut self.requesting_chunks,
+					&mut backers,
+					|unrequested_validators,
+					 in_flight_reqs,
+					 // Don't use this chunk count, as it may contain non-systematic chunks.
+					 _chunk_count,
+					 new_systematic_chunk_count| {
+						systematic_chunk_count = new_systematic_chunk_count;
+
+						let is_unavailable = Self::is_unavailable(
+							unrequested_validators,
+							in_flight_reqs,
+							systematic_chunk_count,
+							self.threshold,
+						);
+
+						systematic_chunk_count >= self.threshold || is_unavailable
+					},
+				)
+				.await;
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use polkadot_erasure_coding::systematic_recovery_threshold;
+
+	#[test]
+	fn test_get_desired_request_count() {
+		let num_validators = 100;
+		let threshold = systematic_recovery_threshold(num_validators).unwrap();
+
+		let systematic_chunks_task = FetchSystematicChunks::new(FetchSystematicChunksParams {
+			validators: vec![(1.into(), 1.into()); num_validators],
+			backers: vec![],
+		});
+		assert_eq!(systematic_chunks_task.get_desired_request_count(0, threshold), threshold);
+		assert_eq!(systematic_chunks_task.get_desired_request_count(5, threshold), threshold - 5);
+		assert_eq!(
+			systematic_chunks_task.get_desired_request_count(num_validators * 2, threshold),
+			0
+		);
+		assert_eq!(systematic_chunks_task.get_desired_request_count(0, N_PARALLEL * 2), N_PARALLEL);
+		assert_eq!(systematic_chunks_task.get_desired_request_count(N_PARALLEL, N_PARALLEL + 2), 2);
+	}
+}
diff --git a/polkadot/node/network/availability-recovery/src/tests.rs b/polkadot/node/network/availability-recovery/src/tests.rs
index 909f6a25f46b1eca3074095b6f54f0415d62c562..4fd9ede40ff658631142df4829aab43e55c9f105 100644
--- a/polkadot/node/network/availability-recovery/src/tests.rs
+++ b/polkadot/node/network/availability-recovery/src/tests.rs
@@ -14,38 +14,133 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::{sync::Arc, time::Duration};
+use crate::task::{REGULAR_CHUNKS_REQ_RETRY_LIMIT, SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT};
+
+use super::*;
+use std::{result::Result, sync::Arc, time::Duration};
 
 use assert_matches::assert_matches;
 use futures::{executor, future};
 use futures_timer::Delay;
+use rstest::rstest;
 
-use parity_scale_codec::Encode;
+use codec::Encode;
 use polkadot_node_network_protocol::request_response::{
-	self as req_res, v1::AvailableDataFetchingRequest, IncomingRequest, Protocol, Recipient,
-	ReqProtocolNames, Requests,
+	self as req_res,
+	v1::{AvailableDataFetchingRequest, ChunkResponse},
+	IncomingRequest, Protocol, Recipient, ReqProtocolNames, Requests,
 };
-use polkadot_node_subsystem_test_helpers::derive_erasure_chunks_with_proofs_and_root;
-
-use super::*;
 
-use sc_network::{IfDisconnected, OutboundFailure, ProtocolName, RequestFailure};
-
-use polkadot_node_primitives::{BlockData, PoV, Proof};
+use polkadot_node_primitives::{BlockData, ErasureChunk, PoV, Proof};
 use polkadot_node_subsystem::messages::{
 	AllMessages, NetworkBridgeTxMessage, RuntimeApiMessage, RuntimeApiRequest,
 };
 use polkadot_node_subsystem_test_helpers::{
-	make_subsystem_context, mock::new_leaf, TestSubsystemContextHandle,
+	derive_erasure_chunks_with_proofs_and_root, make_subsystem_context, mock::new_leaf,
+	TestSubsystemContextHandle,
 };
 use polkadot_node_subsystem_util::TimeoutExt;
 use polkadot_primitives::{
-	AuthorityDiscoveryId, Block, Hash, HeadData, IndexedVec, PersistedValidationData, ValidatorId,
+	node_features, AuthorityDiscoveryId, Block, ExecutorParams, Hash, HeadData, IndexedVec,
+	NodeFeatures, PersistedValidationData, SessionInfo, ValidatorId,
 };
 use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash};
+use sc_network::{IfDisconnected, OutboundFailure, ProtocolName, RequestFailure};
+use sp_keyring::Sr25519Keyring;
 
 type VirtualOverseer = TestSubsystemContextHandle<AvailabilityRecoveryMessage>;
 
+// Implement some helper constructors for the AvailabilityRecoverySubsystem
+
+/// Create a new instance of `AvailabilityRecoverySubsystem` which starts with a fast path to
+/// request data from backers.
+fn with_fast_path(
+	req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+	req_protocol_names: &ReqProtocolNames,
+	metrics: Metrics,
+) -> AvailabilityRecoverySubsystem {
+	AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
+		req_receiver,
+		req_protocol_names,
+		metrics,
+		RecoveryStrategyKind::BackersFirstAlways,
+	)
+}
+
+/// Create a new instance of `AvailabilityRecoverySubsystem` which requests only chunks
+fn with_chunks_only(
+	req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+	req_protocol_names: &ReqProtocolNames,
+	metrics: Metrics,
+) -> AvailabilityRecoverySubsystem {
+	AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
+		req_receiver,
+		req_protocol_names,
+		metrics,
+		RecoveryStrategyKind::ChunksAlways,
+	)
+}
+
+/// Create a new instance of `AvailabilityRecoverySubsystem` which requests chunks if PoV is
+/// above a threshold.
+fn with_chunks_if_pov_large(
+	req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+	req_protocol_names: &ReqProtocolNames,
+	metrics: Metrics,
+) -> AvailabilityRecoverySubsystem {
+	AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
+		req_receiver,
+		req_protocol_names,
+		metrics,
+		RecoveryStrategyKind::BackersFirstIfSizeLower(FETCH_CHUNKS_THRESHOLD),
+	)
+}
+
+/// Create a new instance of `AvailabilityRecoverySubsystem` which requests systematic chunks if
+/// PoV is above a threshold.
+fn with_systematic_chunks_if_pov_large(
+	req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+	req_protocol_names: &ReqProtocolNames,
+	metrics: Metrics,
+) -> AvailabilityRecoverySubsystem {
+	AvailabilityRecoverySubsystem::for_validator(
+		Some(FETCH_CHUNKS_THRESHOLD),
+		req_receiver,
+		req_protocol_names,
+		metrics,
+	)
+}
+
+/// Create a new instance of `AvailabilityRecoverySubsystem` which first requests full data
+/// from backers, with a fallback to recover from systematic chunks.
+fn with_fast_path_then_systematic_chunks(
+	req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+	req_protocol_names: &ReqProtocolNames,
+	metrics: Metrics,
+) -> AvailabilityRecoverySubsystem {
+	AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
+		req_receiver,
+		req_protocol_names,
+		metrics,
+		RecoveryStrategyKind::BackersThenSystematicChunks,
+	)
+}
+
+/// Create a new instance of `AvailabilityRecoverySubsystem` which first attempts to request
+/// systematic chunks, with a fallback to requesting regular chunks.
+fn with_systematic_chunks(
+	req_receiver: IncomingRequestReceiver<request_v1::AvailableDataFetchingRequest>,
+	req_protocol_names: &ReqProtocolNames,
+	metrics: Metrics,
+) -> AvailabilityRecoverySubsystem {
+	AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
+		req_receiver,
+		req_protocol_names,
+		metrics,
+		RecoveryStrategyKind::SystematicChunks,
+	)
+}
+
 // Deterministic genesis hash for protocol names
 const GENESIS_HASH: Hash = Hash::repeat_byte(0xff);
 
@@ -61,14 +156,11 @@ fn request_receiver(
 	receiver.0
 }
 
-fn test_harness<T: Future<Output = VirtualOverseer>>(
+fn test_harness<Fut: Future<Output = VirtualOverseer>>(
 	subsystem: AvailabilityRecoverySubsystem,
-	test: impl FnOnce(VirtualOverseer) -> T,
+	test: impl FnOnce(VirtualOverseer) -> Fut,
 ) {
-	let _ = env_logger::builder()
-		.is_test(true)
-		.filter(Some("polkadot_availability_recovery"), log::LevelFilter::Trace)
-		.try_init();
+	sp_tracing::init_for_tests();
 
 	let pool = sp_core::testing::TaskExecutor::new();
 
@@ -138,8 +230,6 @@ async fn overseer_recv(
 	msg
 }
 
-use sp_keyring::Sr25519Keyring;
-
 #[derive(Debug)]
 enum Has {
 	No,
@@ -163,27 +253,127 @@ struct TestState {
 	validators: Vec<Sr25519Keyring>,
 	validator_public: IndexedVec<ValidatorIndex, ValidatorId>,
 	validator_authority_id: Vec<AuthorityDiscoveryId>,
+	validator_groups: IndexedVec<GroupIndex, Vec<ValidatorIndex>>,
 	current: Hash,
 	candidate: CandidateReceipt,
 	session_index: SessionIndex,
+	core_index: CoreIndex,
+	node_features: NodeFeatures,
 
 	persisted_validation_data: PersistedValidationData,
 
 	available_data: AvailableData,
-	chunks: Vec<ErasureChunk>,
-	invalid_chunks: Vec<ErasureChunk>,
+	chunks: IndexedVec<ValidatorIndex, ErasureChunk>,
+	invalid_chunks: IndexedVec<ValidatorIndex, ErasureChunk>,
 }
 
 impl TestState {
+	fn new(node_features: NodeFeatures) -> Self {
+		let validators = vec![
+			Sr25519Keyring::Ferdie, // <- this node, role: validator
+			Sr25519Keyring::Alice,
+			Sr25519Keyring::Bob,
+			Sr25519Keyring::Charlie,
+			Sr25519Keyring::Dave,
+			Sr25519Keyring::One,
+			Sr25519Keyring::Two,
+		];
+
+		let validator_public = validator_pubkeys(&validators);
+		let validator_authority_id = validator_authority_id(&validators);
+		let validator_groups = vec![
+			vec![1.into(), 0.into(), 3.into(), 4.into()],
+			vec![5.into(), 6.into()],
+			vec![2.into()],
+		];
+
+		let current = Hash::repeat_byte(1);
+
+		let mut candidate = dummy_candidate_receipt(dummy_hash());
+
+		let session_index = 10;
+
+		let persisted_validation_data = PersistedValidationData {
+			parent_head: HeadData(vec![7, 8, 9]),
+			relay_parent_number: Default::default(),
+			max_pov_size: 1024,
+			relay_parent_storage_root: Default::default(),
+		};
+
+		let pov = PoV { block_data: BlockData(vec![42; 64]) };
+
+		let available_data = AvailableData {
+			validation_data: persisted_validation_data.clone(),
+			pov: Arc::new(pov),
+		};
+
+		let core_index = CoreIndex(2);
+
+		let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root(
+			validators.len(),
+			&available_data,
+			|_, _| {},
+		);
+		let chunks = map_chunks(chunks, &node_features, validators.len(), core_index);
+
+		// Mess around:
+		let invalid_chunks = chunks
+			.iter()
+			.cloned()
+			.map(|mut chunk| {
+				if chunk.chunk.len() >= 2 && chunk.chunk[0] != chunk.chunk[1] {
+					chunk.chunk[0] = chunk.chunk[1];
+				} else if chunk.chunk.len() >= 1 {
+					chunk.chunk[0] = !chunk.chunk[0];
+				} else {
+					chunk.proof = Proof::dummy_proof();
+				}
+				chunk
+			})
+			.collect();
+		debug_assert_ne!(chunks, invalid_chunks);
+
+		candidate.descriptor.erasure_root = erasure_root;
+		candidate.descriptor.relay_parent = Hash::repeat_byte(10);
+		candidate.descriptor.pov_hash = Hash::repeat_byte(3);
+
+		Self {
+			validators,
+			validator_public,
+			validator_authority_id,
+			validator_groups: IndexedVec::<GroupIndex, Vec<ValidatorIndex>>::try_from(
+				validator_groups,
+			)
+			.unwrap(),
+			current,
+			candidate,
+			session_index,
+			core_index,
+			node_features,
+			persisted_validation_data,
+			available_data,
+			chunks,
+			invalid_chunks,
+		}
+	}
+
+	fn with_empty_node_features() -> Self {
+		Self::new(NodeFeatures::EMPTY)
+	}
+
 	fn threshold(&self) -> usize {
 		recovery_threshold(self.validators.len()).unwrap()
 	}
 
+	fn systematic_threshold(&self) -> usize {
+		systematic_recovery_threshold(self.validators.len()).unwrap()
+	}
+
 	fn impossibility_threshold(&self) -> usize {
 		self.validators.len() - self.threshold() + 1
 	}
 
-	async fn test_runtime_api(&self, virtual_overseer: &mut VirtualOverseer) {
+	async fn test_runtime_api_session_info(&self, virtual_overseer: &mut VirtualOverseer) {
 		assert_matches!(
 			overseer_recv(virtual_overseer).await,
 			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
@@ -199,8 +389,7 @@ impl TestState {
 				tx.send(Ok(Some(SessionInfo {
 					validators: self.validator_public.clone(),
 					discovery_keys: self.validator_authority_id.clone(),
-					// all validators in the same group.
-					validator_groups: IndexedVec::<GroupIndex,Vec<ValidatorIndex>>::from(vec![(0..self.validators.len()).map(|i| ValidatorIndex(i as _)).collect()]),
+					validator_groups: self.validator_groups.clone(),
 					assignment_keys: vec![],
 					n_cores: 0,
 					zeroth_delay_tranche_width: 0,
@@ -214,6 +403,38 @@ impl TestState {
 				}))).unwrap();
 			}
 		);
+		assert_matches!(
+			overseer_recv(virtual_overseer).await,
+			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+				relay_parent,
+				RuntimeApiRequest::SessionExecutorParams(
+					session_index,
+					tx,
+				)
+			)) => {
+				assert_eq!(relay_parent, self.current);
+				assert_eq!(session_index, self.session_index);
+
+				tx.send(Ok(Some(ExecutorParams::new()))).unwrap();
+			}
+		);
+	}
+
+	async fn test_runtime_api_node_features(&self, virtual_overseer: &mut VirtualOverseer) {
+		assert_matches!(
+			overseer_recv(virtual_overseer).await,
+			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+				_relay_parent,
+				RuntimeApiRequest::NodeFeatures(
+					_,
+					tx,
+				)
+			)) => {
+				tx.send(Ok(
+					self.node_features.clone()
+				)).unwrap();
+			}
+		);
 	}
 
 	async fn respond_to_available_data_query(
@@ -239,16 +460,19 @@ impl TestState {
 	async fn respond_to_query_all_request(
 		&self,
 		virtual_overseer: &mut VirtualOverseer,
-		send_chunk: impl Fn(usize) -> bool,
+		send_chunk: impl Fn(ValidatorIndex) -> bool,
 	) {
 		assert_matches!(
 			overseer_recv(virtual_overseer).await,
 			AllMessages::AvailabilityStore(
 				AvailabilityStoreMessage::QueryAllChunks(_, tx)
 			) => {
-				let v = self.chunks.iter()
-					.filter(|c| send_chunk(c.index.0 as usize))
-					.cloned()
+				let v = self.chunks.iter().enumerate()
+					.filter_map(|(val_idx, c)| if send_chunk(ValidatorIndex(val_idx as u32)) {
+						Some((ValidatorIndex(val_idx as u32), c.clone()))
+					} else {
+						None
+					})
 					.collect();
 
 				let _ = tx.send(v);
@@ -259,16 +483,19 @@ impl TestState {
 	async fn respond_to_query_all_request_invalid(
 		&self,
 		virtual_overseer: &mut VirtualOverseer,
-		send_chunk: impl Fn(usize) -> bool,
+		send_chunk: impl Fn(ValidatorIndex) -> bool,
 	) {
 		assert_matches!(
 			overseer_recv(virtual_overseer).await,
 			AllMessages::AvailabilityStore(
 				AvailabilityStoreMessage::QueryAllChunks(_, tx)
 			) => {
-				let v = self.invalid_chunks.iter()
-					.filter(|c| send_chunk(c.index.0 as usize))
-					.cloned()
+				let v = self.invalid_chunks.iter().enumerate()
+					.filter_map(|(val_idx, c)| if send_chunk(ValidatorIndex(val_idx as u32)) {
+						Some((ValidatorIndex(val_idx as u32), c.clone()))
+					} else {
+						None
+					})
 					.collect();
 
 				let _ = tx.send(v);
@@ -276,14 +503,16 @@ impl TestState {
 		)
 	}
 
-	async fn test_chunk_requests(
+	async fn test_chunk_requests_inner(
 		&self,
 		req_protocol_names: &ReqProtocolNames,
 		candidate_hash: CandidateHash,
 		virtual_overseer: &mut VirtualOverseer,
 		n: usize,
-		who_has: impl Fn(usize) -> Has,
-	) -> Vec<oneshot::Sender<std::result::Result<(Vec<u8>, ProtocolName), RequestFailure>>> {
+		mut who_has: impl FnMut(ValidatorIndex) -> Has,
+		systematic_recovery: bool,
+		protocol: Protocol,
+	) -> Vec<oneshot::Sender<Result<(Vec<u8>, ProtocolName), RequestFailure>>> {
 		// arbitrary order.
 		let mut i = 0;
 		let mut senders = Vec::new();
@@ -301,13 +530,19 @@ impl TestState {
 						i += 1;
 						assert_matches!(
 							req,
-							Requests::ChunkFetchingV1(req) => {
+							Requests::ChunkFetching(req) => {
 								assert_eq!(req.payload.candidate_hash, candidate_hash);
 
-								let validator_index = req.payload.index.0 as usize;
+								let validator_index = req.payload.index;
+								let chunk = self.chunks.get(validator_index).unwrap().clone();
+
+								if systematic_recovery {
+									assert!(chunk.index.0 as usize <= self.systematic_threshold(), "requested non-systematic chunk");
+								}
+
 								let available_data = match who_has(validator_index) {
 									Has::No => Ok(None),
-									Has::Yes => Ok(Some(self.chunks[validator_index].clone().into())),
+									Has::Yes => Ok(Some(chunk)),
 									Has::NetworkError(e) => Err(e),
 									Has::DoesNotReturn => {
 										senders.push(req.pending_response);
@@ -315,11 +550,29 @@ impl TestState {
 									}
 								};
 
-								let _ = req.pending_response.send(
+								req.pending_response.send(
 									available_data.map(|r|
-										(req_res::v1::ChunkFetchingResponse::from(r).encode(), req_protocol_names.get_name(Protocol::ChunkFetchingV1))
+										(
+											match protocol {
+												Protocol::ChunkFetchingV1 =>
+													match r {
+														None => req_res::v1::ChunkFetchingResponse::NoSuchChunk,
+														Some(c) => req_res::v1::ChunkFetchingResponse::Chunk(
+															ChunkResponse {
+																chunk: c.chunk,
+																proof: c.proof
+															}
+														)
+													}.encode(),
+												Protocol::ChunkFetchingV2 =>
+													req_res::v2::ChunkFetchingResponse::from(r).encode(),
+
+												_ => unreachable!()
+											},
+											req_protocol_names.get_name(protocol)
+										)
 									)
-								);
+								).unwrap();
 							}
 						)
 					}
@@ -329,16 +582,61 @@ impl TestState {
 		senders
 	}
 
+	async fn test_chunk_requests(
+		&self,
+		req_protocol_names: &ReqProtocolNames,
+		candidate_hash: CandidateHash,
+		virtual_overseer: &mut VirtualOverseer,
+		n: usize,
+		who_has: impl FnMut(ValidatorIndex) -> Has,
+		systematic_recovery: bool,
+	) -> Vec<oneshot::Sender<Result<(Vec<u8>, ProtocolName), RequestFailure>>> {
+		self.test_chunk_requests_inner(
+			req_protocol_names,
+			candidate_hash,
+			virtual_overseer,
+			n,
+			who_has,
+			systematic_recovery,
+			Protocol::ChunkFetchingV2,
+		)
+		.await
+	}
+
+	// Use legacy network protocol version.
+	async fn test_chunk_requests_v1(
+		&self,
+		req_protocol_names: &ReqProtocolNames,
+		candidate_hash: CandidateHash,
+		virtual_overseer: &mut VirtualOverseer,
+		n: usize,
+		who_has: impl FnMut(ValidatorIndex) -> Has,
+		systematic_recovery: bool,
+	) -> Vec<oneshot::Sender<Result<(Vec<u8>, ProtocolName), RequestFailure>>> {
+		self.test_chunk_requests_inner(
+			req_protocol_names,
+			candidate_hash,
+			virtual_overseer,
+			n,
+			who_has,
+			systematic_recovery,
+			Protocol::ChunkFetchingV1,
+		)
+		.await
+	}
+
 	async fn test_full_data_requests(
 		&self,
 		req_protocol_names: &ReqProtocolNames,
 		candidate_hash: CandidateHash,
 		virtual_overseer: &mut VirtualOverseer,
 		who_has: impl Fn(usize) -> Has,
-	) -> Vec<oneshot::Sender<std::result::Result<(Vec<u8>, ProtocolName), RequestFailure>>> {
+		group_index: GroupIndex,
+	) -> Vec<oneshot::Sender<Result<(Vec<u8>, ProtocolName), RequestFailure>>> {
 		let mut senders = Vec::new();
-		for _ in 0..self.validators.len() {
-			// Receive a request for a chunk.
+		let expected_validators = self.validator_groups.get(group_index).unwrap();
+		for _ in 0..expected_validators.len() {
+			// Receive a request for the full `AvailableData`.
 			assert_matches!(
 				overseer_recv(virtual_overseer).await,
 				AllMessages::NetworkBridgeTx(
@@ -357,6 +655,7 @@ impl TestState {
 								.iter()
 								.position(|a| Recipient::Authority(a.clone()) == req.peer)
 								.unwrap();
+							assert!(expected_validators.contains(&ValidatorIndex(validator_index as u32)));
 
 							let available_data = match who_has(validator_index) {
 								Has::No => Ok(None),
@@ -387,95 +686,67 @@ impl TestState {
 	}
 }
 
+impl Default for TestState {
+	fn default() -> Self {
+		// Enable the chunk mapping node feature.
+		let mut node_features = NodeFeatures::new();
+		node_features
+			.resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false);
+		node_features
+			.set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true);
+
+		Self::new(node_features)
+	}
+}
+
 fn validator_pubkeys(val_ids: &[Sr25519Keyring]) -> IndexedVec<ValidatorIndex, ValidatorId> {
 	val_ids.iter().map(|v| v.public().into()).collect()
 }
 
-fn validator_authority_id(val_ids: &[Sr25519Keyring]) -> Vec<AuthorityDiscoveryId> {
+pub fn validator_authority_id(val_ids: &[Sr25519Keyring]) -> Vec<AuthorityDiscoveryId> {
 	val_ids.iter().map(|v| v.public().into()).collect()
 }
 
-impl Default for TestState {
-	fn default() -> Self {
-		let validators = vec![
-			Sr25519Keyring::Ferdie, // <- this node, role: validator
-			Sr25519Keyring::Alice,
-			Sr25519Keyring::Bob,
-			Sr25519Keyring::Charlie,
-			Sr25519Keyring::Dave,
-		];
-
-		let validator_public = validator_pubkeys(&validators);
-		let validator_authority_id = validator_authority_id(&validators);
-
-		let current = Hash::repeat_byte(1);
-
-		let mut candidate = dummy_candidate_receipt(dummy_hash());
-
-		let session_index = 10;
-
-		let persisted_validation_data = PersistedValidationData {
-			parent_head: HeadData(vec![7, 8, 9]),
-			relay_parent_number: Default::default(),
-			max_pov_size: 1024,
-			relay_parent_storage_root: Default::default(),
-		};
-
-		let pov = PoV { block_data: BlockData(vec![42; 64]) };
-
-		let available_data = AvailableData {
-			validation_data: persisted_validation_data.clone(),
-			pov: Arc::new(pov),
-		};
-
-		let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root(
-			validators.len(),
-			&available_data,
-			|_, _| {},
-		);
-		// Mess around:
-		let invalid_chunks = chunks
-			.iter()
-			.cloned()
-			.map(|mut chunk| {
-				if chunk.chunk.len() >= 2 && chunk.chunk[0] != chunk.chunk[1] {
-					chunk.chunk[0] = chunk.chunk[1];
-				} else if chunk.chunk.len() >= 1 {
-					chunk.chunk[0] = !chunk.chunk[0];
-				} else {
-					chunk.proof = Proof::dummy_proof();
-				}
-				chunk
-			})
-			.collect();
-		debug_assert_ne!(chunks, invalid_chunks);
-
-		candidate.descriptor.erasure_root = erasure_root;
-		candidate.descriptor.relay_parent = Hash::repeat_byte(10);
-
-		Self {
-			validators,
-			validator_public,
-			validator_authority_id,
-			current,
-			candidate,
-			session_index,
-			persisted_validation_data,
-			available_data,
-			chunks,
-			invalid_chunks,
-		}
-	}
+/// Map the chunks to the validators according to the availability chunk mapping algorithm.
+fn map_chunks(
+	chunks: Vec<ErasureChunk>,
+	node_features: &NodeFeatures,
+	n_validators: usize,
+	core_index: CoreIndex,
+) -> IndexedVec<ValidatorIndex, ErasureChunk> {
+	let chunk_indices =
+		availability_chunk_indices(Some(node_features), n_validators, core_index).unwrap();
+
+	(0..n_validators)
+		.map(|val_idx| chunks[chunk_indices[val_idx].0 as usize].clone())
+		.collect::<Vec<_>>()
+		.into()
 }
 
-#[test]
-fn availability_is_recovered_from_chunks_if_no_group_provided() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn availability_is_recovered_from_chunks_if_no_group_provided(#[case] systematic_recovery: bool) {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_fast_path(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let (subsystem, threshold) = match systematic_recovery {
+		true => (
+			with_fast_path_then_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		false => (
+			with_fast_path(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -495,12 +766,15 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
@@ -512,8 +786,9 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() {
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.threshold(),
+				threshold,
 				|_| Has::Yes,
+				systematic_recovery,
 			)
 			.await;
 
@@ -533,16 +808,31 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() {
 				new_candidate.clone(),
 				test_state.session_index,
 				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
-
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
 		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
 
+		if systematic_recovery {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					new_candidate.hash(),
+					&mut virtual_overseer,
+					threshold,
+					|_| Has::No,
+					systematic_recovery,
+				)
+				.await;
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
+
+		// Even if the recovery is systematic, we'll always fall back to regular recovery, so keep
+		// this around.
 		test_state
 			.test_chunk_requests(
 				&req_protocol_names,
@@ -550,6 +840,7 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() {
 				&mut virtual_overseer,
 				test_state.impossibility_threshold(),
 				|_| Has::No,
+				false,
 			)
 			.await;
 
@@ -559,16 +850,34 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() {
 	});
 }
 
-#[test]
-fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunks_only() {
-	let test_state = TestState::default();
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunks_only(
+	#[case] systematic_recovery: bool,
+) {
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
-
-	test_harness(subsystem, |mut virtual_overseer| async move {
+	let test_state = TestState::default();
+	let (subsystem, threshold) = match systematic_recovery {
+		true => (
+			with_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		false => (
+			with_chunks_only(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+	};
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
 			&mut virtual_overseer,
 			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
@@ -586,12 +895,15 @@ fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunk
 				test_state.candidate.clone(),
 				test_state.session_index,
 				Some(GroupIndex(0)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
@@ -603,8 +915,9 @@ fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunk
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.threshold(),
+				threshold,
 				|_| Has::Yes,
+				systematic_recovery,
 			)
 			.await;
 
@@ -623,41 +936,80 @@ fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunk
 			AvailabilityRecoveryMessage::RecoverAvailableData(
 				new_candidate.clone(),
 				test_state.session_index,
-				None,
+				Some(GroupIndex(1)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
-
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
 		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
 
-		test_state
-			.test_chunk_requests(
-				&req_protocol_names,
-				new_candidate.hash(),
-				&mut virtual_overseer,
-				test_state.impossibility_threshold(),
-				|_| Has::No,
-			)
-			.await;
+		if systematic_recovery {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					new_candidate.hash(),
+					&mut virtual_overseer,
+					threshold * SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT as usize,
+					|_| Has::No,
+					systematic_recovery,
+				)
+				.await;
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+			// Even if the recovery is systematic, we'll always fall back to regular recovery, so
+			// keep this around.
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					new_candidate.hash(),
+					&mut virtual_overseer,
+					test_state.impossibility_threshold() - threshold,
+					|_| Has::No,
+					false,
+				)
+				.await;
+
+			// A request times out with `Unavailable` error.
+			assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
+		} else {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					new_candidate.hash(),
+					&mut virtual_overseer,
+					test_state.impossibility_threshold(),
+					|_| Has::No,
+					false,
+				)
+				.await;
 
-		// A request times out with `Unavailable` error.
-		assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
+			// A request times out with `Unavailable` error.
+			assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
+		}
 		virtual_overseer
 	});
 }
 
-#[test]
-fn bad_merkle_path_leads_to_recovery_error() {
-	let mut test_state = TestState::default();
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn bad_merkle_path_leads_to_recovery_error(#[case] systematic_recovery: bool) {
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_fast_path(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let mut test_state = TestState::default();
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -677,25 +1029,40 @@ fn bad_merkle_path_leads_to_recovery_error() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
 		// Create some faulty chunks.
-		test_state.chunks[0].chunk = vec![0; 32];
-		test_state.chunks[1].chunk = vec![1; 32];
-		test_state.chunks[2].chunk = vec![2; 32];
-		test_state.chunks[3].chunk = vec![3; 32];
-		test_state.chunks[4].chunk = vec![4; 32];
+		for chunk in test_state.chunks.iter_mut() {
+			chunk.chunk = vec![0; 32];
+		}
 
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
 		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
 
+		if systematic_recovery {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					candidate_hash,
+					&mut virtual_overseer,
+					test_state.systematic_threshold(),
+					|_| Has::No,
+					systematic_recovery,
+				)
+				.await;
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
+
 		test_state
 			.test_chunk_requests(
 				&req_protocol_names,
@@ -703,6 +1070,7 @@ fn bad_merkle_path_leads_to_recovery_error() {
 				&mut virtual_overseer,
 				test_state.impossibility_threshold(),
 				|_| Has::Yes,
+				false,
 			)
 			.await;
 
@@ -712,14 +1080,24 @@ fn bad_merkle_path_leads_to_recovery_error() {
 	});
 }
 
-#[test]
-fn wrong_chunk_index_leads_to_recovery_error() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn wrong_chunk_index_leads_to_recovery_error(#[case] systematic_recovery: bool) {
 	let mut test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_fast_path(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -739,32 +1117,55 @@ fn wrong_chunk_index_leads_to_recovery_error() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
 
-		let candidate_hash = test_state.candidate.hash();
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
-		// These chunks should fail the index check as they don't have the correct index for
-		// validator.
-		test_state.chunks[1] = test_state.chunks[0].clone();
-		test_state.chunks[2] = test_state.chunks[0].clone();
-		test_state.chunks[3] = test_state.chunks[0].clone();
-		test_state.chunks[4] = test_state.chunks[0].clone();
+		let candidate_hash = test_state.candidate.hash();
 
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
 		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
 
+		// Chunks should fail the index check as they don't have the correct index.
+
+		// *(test_state.chunks.get_mut(0.into()).unwrap()) =
+		// 	test_state.chunks.get(1.into()).unwrap().clone();
+		let first_chunk = test_state.chunks.get(0.into()).unwrap().clone();
+		for c_index in 1..test_state.chunks.len() {
+			*(test_state.chunks.get_mut(ValidatorIndex(c_index as u32)).unwrap()) =
+				first_chunk.clone();
+		}
+
+		if systematic_recovery {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					candidate_hash,
+					&mut virtual_overseer,
+					test_state.systematic_threshold(),
+					|_| Has::Yes,
+					// We set this to false, as we know we will be requesting the wrong indices.
+					false,
+				)
+				.await;
+
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
+
 		test_state
 			.test_chunk_requests(
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.impossibility_threshold(),
-				|_| Has::No,
+				test_state.chunks.len() - 1,
+				|_| Has::Yes,
+				false,
 			)
 			.await;
 
@@ -774,14 +1175,30 @@ fn wrong_chunk_index_leads_to_recovery_error() {
 	});
 }
 
-#[test]
-fn invalid_erasure_coding_leads_to_invalid_error() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn invalid_erasure_coding_leads_to_invalid_error(#[case] systematic_recovery: bool) {
 	let mut test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_fast_path(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let (subsystem, threshold) = match systematic_recovery {
+		true => (
+			with_fast_path_then_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		false => (
+			with_fast_path(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		let pov = PoV { block_data: BlockData(vec![69; 64]) };
@@ -795,7 +1212,12 @@ fn invalid_erasure_coding_leads_to_invalid_error() {
 			|i, chunk| *chunk = vec![i as u8; 32],
 		);
 
-		test_state.chunks = bad_chunks;
+		test_state.chunks = map_chunks(
+			bad_chunks,
+			&test_state.node_features,
+			test_state.validators.len(),
+			test_state.core_index,
+		);
 		test_state.candidate.descriptor.erasure_root = bad_erasure_root;
 
 		let candidate_hash = test_state.candidate.hash();
@@ -817,12 +1239,15 @@ fn invalid_erasure_coding_leads_to_invalid_error() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
 		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
@@ -832,8 +1257,9 @@ fn invalid_erasure_coding_leads_to_invalid_error() {
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.threshold(),
+				threshold,
 				|_| Has::Yes,
+				systematic_recovery,
 			)
 			.await;
 
@@ -843,12 +1269,74 @@ fn invalid_erasure_coding_leads_to_invalid_error() {
 	});
 }
 
+#[test]
+fn invalid_pov_hash_leads_to_invalid_error() {
+	let mut test_state = TestState::default();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let subsystem = AvailabilityRecoverySubsystem::for_collator(
+		None,
+		request_receiver(&req_protocol_names),
+		&req_protocol_names,
+		Metrics::new_dummy(),
+	);
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		let pov = PoV { block_data: BlockData(vec![69; 64]) };
+
+		test_state.candidate.descriptor.pov_hash = pov.hash();
+
+		let candidate_hash = test_state.candidate.hash();
+
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+
+		test_state
+			.test_chunk_requests(
+				&req_protocol_names,
+				candidate_hash,
+				&mut virtual_overseer,
+				test_state.threshold(),
+				|_| Has::Yes,
+				false,
+			)
+			.await;
+
+		assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Invalid);
+		virtual_overseer
+	});
+}
+
 #[test]
 fn fast_path_backing_group_recovers() {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_fast_path(
+	let subsystem = with_fast_path(
 		request_receiver(&req_protocol_names),
+		&req_protocol_names,
 		Metrics::new_dummy(),
 	);
 
@@ -870,12 +1358,14 @@ fn fast_path_backing_group_recovers() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				Some(GroupIndex(0)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
@@ -892,6 +1382,7 @@ fn fast_path_backing_group_recovers() {
 				candidate_hash,
 				&mut virtual_overseer,
 				who_has,
+				GroupIndex(0),
 			)
 			.await;
 
@@ -901,14 +1392,47 @@ fn fast_path_backing_group_recovers() {
 	});
 }
 
-#[test]
-fn recovers_from_only_chunks_if_pov_large() {
-	let test_state = TestState::default();
+#[rstest]
+#[case(true, false)]
+#[case(false, true)]
+#[case(false, false)]
+fn recovers_from_only_chunks_if_pov_large(
+	#[case] systematic_recovery: bool,
+	#[case] for_collator: bool,
+) {
+	let mut test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_if_pov_large(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let (subsystem, threshold) = match (systematic_recovery, for_collator) {
+		(true, false) => (
+			with_systematic_chunks_if_pov_large(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		(false, false) => (
+			with_chunks_if_pov_large(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+		(false, true) => {
+			test_state.candidate.descriptor.pov_hash = test_state.available_data.pov.hash();
+			(
+				AvailabilityRecoverySubsystem::for_collator(
+					None,
+					request_receiver(&req_protocol_names),
+					&req_protocol_names,
+					Metrics::new_dummy(),
+				),
+				test_state.threshold(),
+			)
+		},
+		(_, _) => unreachable!(),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -928,12 +1452,15 @@ fn recovers_from_only_chunks_if_pov_large() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				Some(GroupIndex(0)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
@@ -942,20 +1469,23 @@ fn recovers_from_only_chunks_if_pov_large() {
 			AllMessages::AvailabilityStore(
 				AvailabilityStoreMessage::QueryChunkSize(_, tx)
 			) => {
-				let _ = tx.send(Some(1000000));
+				let _ = tx.send(Some(crate::FETCH_CHUNKS_THRESHOLD + 1));
 			}
 		);
 
-		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
-		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		if !for_collator {
+			test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
 
 		test_state
 			.test_chunk_requests(
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.threshold(),
+				threshold,
 				|_| Has::Yes,
+				systematic_recovery,
 			)
 			.await;
 
@@ -974,35 +1504,64 @@ fn recovers_from_only_chunks_if_pov_large() {
 			AvailabilityRecoveryMessage::RecoverAvailableData(
 				new_candidate.clone(),
 				test_state.session_index,
-				Some(GroupIndex(0)),
+				Some(GroupIndex(1)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
-
 		assert_matches!(
 			overseer_recv(&mut virtual_overseer).await,
 			AllMessages::AvailabilityStore(
 				AvailabilityStoreMessage::QueryChunkSize(_, tx)
 			) => {
-				let _ = tx.send(Some(1000000));
+				let _ = tx.send(Some(crate::FETCH_CHUNKS_THRESHOLD + 1));
 			}
 		);
 
-		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
-		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		if !for_collator {
+			test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
 
-		test_state
-			.test_chunk_requests(
-				&req_protocol_names,
-				new_candidate.hash(),
-				&mut virtual_overseer,
-				test_state.impossibility_threshold(),
-				|_| Has::No,
-			)
-			.await;
+		if systematic_recovery {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					new_candidate.hash(),
+					&mut virtual_overseer,
+					test_state.systematic_threshold() * SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT as usize,
+					|_| Has::No,
+					systematic_recovery,
+				)
+				.await;
+			if !for_collator {
+				test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+			}
+			// Even if the recovery is systematic, we'll always fall back to regular recovery.
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					new_candidate.hash(),
+					&mut virtual_overseer,
+					test_state.impossibility_threshold() - threshold,
+					|_| Has::No,
+					false,
+				)
+				.await;
+		} else {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					new_candidate.hash(),
+					&mut virtual_overseer,
+					test_state.impossibility_threshold(),
+					|_| Has::No,
+					false,
+				)
+				.await;
+		}
 
 		// A request times out with `Unavailable` error.
 		assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
@@ -1010,14 +1569,40 @@ fn recovers_from_only_chunks_if_pov_large() {
 	});
 }
 
-#[test]
-fn fast_path_backing_group_recovers_if_pov_small() {
-	let test_state = TestState::default();
+#[rstest]
+#[case(true, false)]
+#[case(false, true)]
+#[case(false, false)]
+fn fast_path_backing_group_recovers_if_pov_small(
+	#[case] systematic_recovery: bool,
+	#[case] for_collator: bool,
+) {
+	let mut test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_if_pov_large(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+
+	let subsystem = match (systematic_recovery, for_collator) {
+		(true, false) => with_systematic_chunks_if_pov_large(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+
+		(false, false) => with_chunks_if_pov_large(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		(false, true) => {
+			test_state.candidate.descriptor.pov_hash = test_state.available_data.pov.hash();
+			AvailabilityRecoverySubsystem::for_collator(
+				None,
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			)
+		},
+		(_, _) => unreachable!(),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -1037,12 +1622,15 @@ fn fast_path_backing_group_recovers_if_pov_small() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				Some(GroupIndex(0)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
@@ -1060,7 +1648,9 @@ fn fast_path_backing_group_recovers_if_pov_small() {
 			}
 		);
 
-		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		if !for_collator {
+			test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		}
 
 		test_state
 			.test_full_data_requests(
@@ -1068,6 +1658,7 @@ fn fast_path_backing_group_recovers_if_pov_small() {
 				candidate_hash,
 				&mut virtual_overseer,
 				who_has,
+				GroupIndex(0),
 			)
 			.await;
 
@@ -1077,14 +1668,31 @@ fn fast_path_backing_group_recovers_if_pov_small() {
 	});
 }
 
-#[test]
-fn no_answers_in_fast_path_causes_chunk_requests() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn no_answers_in_fast_path_causes_chunk_requests(#[case] systematic_recovery: bool) {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_fast_path(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+
+	let (subsystem, threshold) = match systematic_recovery {
+		true => (
+			with_fast_path_then_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		false => (
+			with_fast_path(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -1104,12 +1712,15 @@ fn no_answers_in_fast_path_causes_chunk_requests() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				Some(GroupIndex(0)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
@@ -1127,6 +1738,7 @@ fn no_answers_in_fast_path_causes_chunk_requests() {
 				candidate_hash,
 				&mut virtual_overseer,
 				who_has,
+				GroupIndex(0),
 			)
 			.await;
 
@@ -1137,8 +1749,9 @@ fn no_answers_in_fast_path_causes_chunk_requests() {
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.threshold(),
+				threshold,
 				|_| Has::Yes,
+				systematic_recovery,
 			)
 			.await;
 
@@ -1148,14 +1761,25 @@ fn no_answers_in_fast_path_causes_chunk_requests() {
 	});
 }
 
-#[test]
-fn task_canceled_when_receivers_dropped() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn task_canceled_when_receivers_dropped(#[case] systematic_recovery: bool) {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -1175,12 +1799,15 @@ fn task_canceled_when_receivers_dropped() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		for _ in 0..test_state.validators.len() {
 			match virtual_overseer.recv().timeout(TIMEOUT).await {
@@ -1193,14 +1820,24 @@ fn task_canceled_when_receivers_dropped() {
 	});
 }
 
-#[test]
-fn chunks_retry_until_all_nodes_respond() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn chunks_retry_until_all_nodes_respond(#[case] systematic_recovery: bool) {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -1219,30 +1856,51 @@ fn chunks_retry_until_all_nodes_respond() {
 			AvailabilityRecoveryMessage::RecoverAvailableData(
 				test_state.candidate.clone(),
 				test_state.session_index,
-				Some(GroupIndex(0)),
+				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
 		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
 
+		if systematic_recovery {
+			for _ in 0..SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT {
+				test_state
+					.test_chunk_requests(
+						&req_protocol_names,
+						candidate_hash,
+						&mut virtual_overseer,
+						test_state.systematic_threshold(),
+						|_| Has::timeout(),
+						true,
+					)
+					.await;
+			}
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
+
 		test_state
 			.test_chunk_requests(
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.validators.len() - test_state.threshold(),
+				test_state.impossibility_threshold(),
 				|_| Has::timeout(),
+				false,
 			)
 			.await;
 
-		// we get to go another round!
+		// We get to go another round! Actually, we get to go `REGULAR_CHUNKS_REQ_RETRY_LIMIT`
+		// number of times.
 		test_state
 			.test_chunk_requests(
 				&req_protocol_names,
@@ -1250,21 +1908,23 @@ fn chunks_retry_until_all_nodes_respond() {
 				&mut virtual_overseer,
 				test_state.impossibility_threshold(),
 				|_| Has::No,
+				false,
 			)
 			.await;
 
-		// Recovered data should match the original one.
+		// Recovery is impossible.
 		assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
 		virtual_overseer
 	});
 }
 
 #[test]
-fn not_returning_requests_wont_stall_retrieval() {
+fn network_bridge_not_returning_responses_wont_stall_retrieval() {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
+	let subsystem = with_chunks_only(
 		request_receiver(&req_protocol_names),
+		&req_protocol_names,
 		Metrics::new_dummy(),
 	);
 
@@ -1286,12 +1946,15 @@ fn not_returning_requests_wont_stall_retrieval() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				Some(GroupIndex(0)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
@@ -1309,6 +1972,7 @@ fn not_returning_requests_wont_stall_retrieval() {
 				&mut virtual_overseer,
 				not_returning_count,
 				|_| Has::DoesNotReturn,
+				false,
 			)
 			.await;
 
@@ -1320,6 +1984,7 @@ fn not_returning_requests_wont_stall_retrieval() {
 				// Should start over:
 				test_state.validators.len() + 3,
 				|_| Has::timeout(),
+				false,
 			)
 			.await;
 
@@ -1331,6 +1996,7 @@ fn not_returning_requests_wont_stall_retrieval() {
 				&mut virtual_overseer,
 				test_state.threshold(),
 				|_| Has::Yes,
+				false,
 			)
 			.await;
 
@@ -1340,14 +2006,24 @@ fn not_returning_requests_wont_stall_retrieval() {
 	});
 }
 
-#[test]
-fn all_not_returning_requests_still_recovers_on_return() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn all_not_returning_requests_still_recovers_on_return(#[case] systematic_recovery: bool) {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -1366,46 +2042,64 @@ fn all_not_returning_requests_still_recovers_on_return() {
 			AvailabilityRecoveryMessage::RecoverAvailableData(
 				test_state.candidate.clone(),
 				test_state.session_index,
-				Some(GroupIndex(0)),
+				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
 		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		let n = if systematic_recovery {
+			test_state.systematic_threshold()
+		} else {
+			test_state.validators.len()
+		};
 
 		let senders = test_state
 			.test_chunk_requests(
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.validators.len(),
+				n,
 				|_| Has::DoesNotReturn,
+				systematic_recovery,
 			)
 			.await;
 
 		future::join(
 			async {
 				Delay::new(Duration::from_millis(10)).await;
-				// Now retrieval should be able to recover.
+				// Now retrieval should be able progress.
 				std::mem::drop(senders);
 			},
-			test_state.test_chunk_requests(
-				&req_protocol_names,
-				candidate_hash,
-				&mut virtual_overseer,
-				// Should start over:
-				test_state.validators.len() + 3,
-				|_| Has::timeout(),
-			),
+			async {
+				test_state
+					.test_chunk_requests(
+						&req_protocol_names,
+						candidate_hash,
+						&mut virtual_overseer,
+						// Should start over:
+						n,
+						|_| Has::timeout(),
+						systematic_recovery,
+					)
+					.await
+			},
 		)
 		.await;
 
+		if systematic_recovery {
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
+
 		// we get to go another round!
 		test_state
 			.test_chunk_requests(
@@ -1414,6 +2108,7 @@ fn all_not_returning_requests_still_recovers_on_return() {
 				&mut virtual_overseer,
 				test_state.threshold(),
 				|_| Has::Yes,
+				false,
 			)
 			.await;
 
@@ -1423,14 +2118,24 @@ fn all_not_returning_requests_still_recovers_on_return() {
 	});
 }
 
-#[test]
-fn returns_early_if_we_have_the_data() {
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn returns_early_if_we_have_the_data(#[case] systematic_recovery: bool) {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
-		request_receiver(&req_protocol_names),
-		Metrics::new_dummy(),
-	);
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
 
 	test_harness(subsystem, |mut virtual_overseer| async move {
 		overseer_signal(
@@ -1450,12 +2155,15 @@ fn returns_early_if_we_have_the_data() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				None,
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 		test_state.respond_to_available_data_query(&mut virtual_overseer, true).await;
 
 		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
@@ -1464,11 +2172,12 @@ fn returns_early_if_we_have_the_data() {
 }
 
 #[test]
-fn does_not_query_local_validator() {
+fn returns_early_if_present_in_the_subsystem_cache() {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
+	let subsystem = with_fast_path(
 		request_receiver(&req_protocol_names),
+		&req_protocol_names,
 		Metrics::new_dummy(),
 	);
 
@@ -1489,50 +2198,812 @@ fn does_not_query_local_validator() {
 			AvailabilityRecoveryMessage::RecoverAvailableData(
 				test_state.candidate.clone(),
 				test_state.session_index,
-				None,
+				Some(GroupIndex(0)),
+				Some(test_state.core_index),
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
-		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
-		test_state.respond_to_query_all_request(&mut virtual_overseer, |i| i == 0).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
 
 		let candidate_hash = test_state.candidate.hash();
 
+		let who_has = |i| match i {
+			3 => Has::Yes,
+			_ => Has::No,
+		};
+
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+
 		test_state
-			.test_chunk_requests(
+			.test_full_data_requests(
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.validators.len(),
-				|i| if i == 0 { panic!("requested from local validator") } else { Has::timeout() },
+				who_has,
+				GroupIndex(0),
 			)
 			.await;
 
-		// second round, make sure it uses the local chunk.
-		test_state
-			.test_chunk_requests(
-				&req_protocol_names,
+		// Recovered data should match the original one.
+		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+
+		// A second recovery for the same candidate will return early as it'll be present in the
+		// cache.
+		let (tx, rx) = oneshot::channel();
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				Some(GroupIndex(0)),
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+
+		virtual_overseer
+	});
+}
+
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn does_not_query_local_validator(#[case] systematic_recovery: bool) {
+	let test_state = TestState::default();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let (subsystem, threshold) = match systematic_recovery {
+		true => (
+			with_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		false => (
+			with_chunks_only(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+	};
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state
+			.respond_to_query_all_request(&mut virtual_overseer, |i| i.0 == 0)
+			.await;
+
+		let candidate_hash = test_state.candidate.hash();
+
+		// second round, make sure it uses the local chunk.
+		test_state
+			.test_chunk_requests(
+				&req_protocol_names,
+				candidate_hash,
+				&mut virtual_overseer,
+				threshold - 1,
+				|i| if i.0 == 0 { panic!("requested from local validator") } else { Has::Yes },
+				systematic_recovery,
+			)
+			.await;
+
+		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+		virtual_overseer
+	});
+}
+
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn invalid_local_chunk(#[case] systematic_recovery: bool) {
+	let test_state = TestState::default();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+
+		let validator_index_for_first_chunk = test_state
+			.chunks
+			.iter()
+			.enumerate()
+			.find_map(|(val_idx, chunk)| if chunk.index.0 == 0 { Some(val_idx) } else { None })
+			.unwrap() as u32;
+
+		test_state
+			.respond_to_query_all_request_invalid(&mut virtual_overseer, |i| {
+				i.0 == validator_index_for_first_chunk
+			})
+			.await;
+
+		let candidate_hash = test_state.candidate.hash();
+
+		// If systematic recovery detects invalid local chunk, it'll directly go to regular
+		// recovery, if we were the one holding an invalid chunk.
+		if systematic_recovery {
+			test_state
+				.respond_to_query_all_request_invalid(&mut virtual_overseer, |i| {
+					i.0 == validator_index_for_first_chunk
+				})
+				.await;
+		}
+
+		test_state
+			.test_chunk_requests(
+				&req_protocol_names,
+				candidate_hash,
+				&mut virtual_overseer,
+				test_state.threshold(),
+				|i| {
+					if i.0 == validator_index_for_first_chunk {
+						panic!("requested from local validator")
+					} else {
+						Has::Yes
+					}
+				},
+				false,
+			)
+			.await;
+
+		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+		virtual_overseer
+	});
+}
+
+#[test]
+fn systematic_chunks_are_not_requested_again_in_regular_recovery() {
+	// Run this test multiple times, as the order in which requests are made is random and we want
+	// to make sure that we catch regressions.
+	for _ in 0..TestState::default().chunks.len() {
+		let test_state = TestState::default();
+		let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+		let subsystem = with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		);
+
+		test_harness(subsystem, |mut virtual_overseer| async move {
+			overseer_signal(
+				&mut virtual_overseer,
+				OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+					test_state.current,
+					1,
+				))),
+			)
+			.await;
+
+			let (tx, rx) = oneshot::channel();
+
+			overseer_send(
+				&mut virtual_overseer,
+				AvailabilityRecoveryMessage::RecoverAvailableData(
+					test_state.candidate.clone(),
+					test_state.session_index,
+					None,
+					Some(test_state.core_index),
+					tx,
+				),
+			)
+			.await;
+
+			test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+			test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+			test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+			let validator_index_for_first_chunk = test_state
+				.chunks
+				.iter()
+				.enumerate()
+				.find_map(|(val_idx, chunk)| if chunk.index.0 == 0 { Some(val_idx) } else { None })
+				.unwrap() as u32;
+
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					test_state.candidate.hash(),
+					&mut virtual_overseer,
+					test_state.systematic_threshold(),
+					|i| if i.0 == validator_index_for_first_chunk { Has::No } else { Has::Yes },
+					true,
+				)
+				.await;
+
+			// Falls back to regular recovery, since one validator returned a fatal error.
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					test_state.candidate.hash(),
+					&mut virtual_overseer,
+					1,
+					|i| {
+						if (test_state.chunks.get(i).unwrap().index.0 as usize) <
+							test_state.systematic_threshold()
+						{
+							panic!("Already requested")
+						} else {
+							Has::Yes
+						}
+					},
+					false,
+				)
+				.await;
+
+			assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+			virtual_overseer
+		});
+	}
+}
+
+#[rstest]
+#[case(true, true)]
+#[case(true, false)]
+#[case(false, true)]
+#[case(false, false)]
+fn chunk_indices_are_mapped_to_different_validators(
+	#[case] systematic_recovery: bool,
+	#[case] mapping_enabled: bool,
+) {
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let test_state = match mapping_enabled {
+		true => TestState::default(),
+		false => TestState::with_empty_node_features(),
+	};
+	let subsystem = match systematic_recovery {
+		true => with_systematic_chunks(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+		false => with_chunks_only(
+			request_receiver(&req_protocol_names),
+			&req_protocol_names,
+			Metrics::new_dummy(),
+		),
+	};
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, _rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+		let mut chunk_indices: Vec<(u32, u32)> = vec![];
+
+		assert_matches!(
+			overseer_recv(&mut virtual_overseer).await,
+			AllMessages::NetworkBridgeTx(
+				NetworkBridgeTxMessage::SendRequests(
+					requests,
+					_if_disconnected,
+				)
+			) => {
+				for req in requests {
+					assert_matches!(
+						req,
+						Requests::ChunkFetching(req) => {
+							assert_eq!(req.payload.candidate_hash, test_state.candidate.hash());
+
+							let validator_index = req.payload.index;
+							let chunk_index = test_state.chunks.get(validator_index).unwrap().index;
+
+							if systematic_recovery && mapping_enabled {
+								assert!((chunk_index.0 as usize) <= test_state.systematic_threshold(), "requested non-systematic chunk");
+							}
+
+							chunk_indices.push((chunk_index.0, validator_index.0));
+						}
+					)
+				}
+			}
+		);
+
+		if mapping_enabled {
+			assert!(!chunk_indices.iter().any(|(c_index, v_index)| c_index == v_index));
+		} else {
+			assert!(chunk_indices.iter().all(|(c_index, v_index)| c_index == v_index));
+		}
+
+		virtual_overseer
+	});
+}
+
+#[rstest]
+#[case(true, false)]
+#[case(false, true)]
+#[case(false, false)]
+fn number_of_request_retries_is_bounded(
+	#[case] systematic_recovery: bool,
+	#[case] should_fail: bool,
+) {
+	let mut test_state = TestState::default();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	// We need the number of validators to be evenly divisible by the threshold for this test to be
+	// easier to write.
+	let n_validators = 6;
+	test_state.validators.truncate(n_validators);
+	test_state.validator_authority_id.truncate(n_validators);
+	let mut temp = test_state.validator_public.to_vec();
+	temp.truncate(n_validators);
+	test_state.validator_public = temp.into();
+
+	let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root(
+		n_validators,
+		&test_state.available_data,
+		|_, _| {},
+	);
+	test_state.chunks =
+		map_chunks(chunks, &test_state.node_features, n_validators, test_state.core_index);
+	test_state.candidate.descriptor.erasure_root = erasure_root;
+
+	let (subsystem, retry_limit) = match systematic_recovery {
+		false => (
+			with_chunks_only(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			REGULAR_CHUNKS_REQ_RETRY_LIMIT,
+		),
+		true => (
+			with_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT,
+		),
+	};
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+		let validator_count_per_iteration = if systematic_recovery {
+			test_state.systematic_threshold()
+		} else {
+			test_state.chunks.len()
+		};
+
+		// Network errors are considered non-fatal but should be retried a limited number of times.
+		for _ in 1..retry_limit {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					test_state.candidate.hash(),
+					&mut virtual_overseer,
+					validator_count_per_iteration,
+					|_| Has::timeout(),
+					systematic_recovery,
+				)
+				.await;
+		}
+
+		if should_fail {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					test_state.candidate.hash(),
+					&mut virtual_overseer,
+					validator_count_per_iteration,
+					|_| Has::timeout(),
+					systematic_recovery,
+				)
+				.await;
+
+			assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
+		} else {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					test_state.candidate.hash(),
+					&mut virtual_overseer,
+					test_state.threshold(),
+					|_| Has::Yes,
+					systematic_recovery,
+				)
+				.await;
+
+			assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+		}
+
+		virtual_overseer
+	});
+}
+
+#[test]
+fn systematic_recovery_retries_from_backers() {
+	let test_state = TestState::default();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let subsystem = with_systematic_chunks(
+		request_receiver(&req_protocol_names),
+		&req_protocol_names,
+		Metrics::new_dummy(),
+	);
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+		let group_index = GroupIndex(2);
+		let group_size = test_state.validator_groups.get(group_index).unwrap().len();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				Some(group_index),
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+		let mut cnt = 0;
+
+		test_state
+			.test_chunk_requests(
+				&req_protocol_names,
+				test_state.candidate.hash(),
+				&mut virtual_overseer,
+				test_state.systematic_threshold(),
+				|_| {
+					let res = if cnt < group_size { Has::timeout() } else { Has::Yes };
+					cnt += 1;
+					res
+				},
+				true,
+			)
+			.await;
+
+		// Exhaust retries.
+		for _ in 0..(SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT - 1) {
+			test_state
+				.test_chunk_requests(
+					&req_protocol_names,
+					test_state.candidate.hash(),
+					&mut virtual_overseer,
+					group_size,
+					|_| Has::No,
+					true,
+				)
+				.await;
+		}
+
+		// Now, final chance is to try from a backer.
+		test_state
+			.test_chunk_requests(
+				&req_protocol_names,
+				test_state.candidate.hash(),
+				&mut virtual_overseer,
+				group_size,
+				|_| Has::Yes,
+				true,
+			)
+			.await;
+
+		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+		virtual_overseer
+	});
+}
+
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn test_legacy_network_protocol_with_mapping_disabled(#[case] systematic_recovery: bool) {
+	// In this case, when the mapping is disabled, recovery will work with both v2 and v1 requests,
+	// under the assumption that ValidatorIndex is always equal to ChunkIndex. However, systematic
+	// recovery will not be possible, it will fall back to regular recovery.
+	let test_state = TestState::with_empty_node_features();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let (subsystem, threshold) = match systematic_recovery {
+		true => (
+			with_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		false => (
+			with_fast_path(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+	};
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+
+		let candidate_hash = test_state.candidate.hash();
+
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+		test_state
+			.test_chunk_requests_v1(
+				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.threshold() - 1,
-				|i| if i == 0 { panic!("requested from local validator") } else { Has::Yes },
+				threshold,
+				|_| Has::Yes,
+				false,
 			)
 			.await;
 
+		// Recovered data should match the original one.
 		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
 		virtual_overseer
 	});
 }
 
+#[rstest]
+#[case(true)]
+#[case(false)]
+fn test_legacy_network_protocol_with_mapping_enabled(#[case] systematic_recovery: bool) {
+	// In this case, when the mapping is enabled, we MUST only use v2. Recovery should fail for v1.
+	let test_state = TestState::default();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let (subsystem, threshold) = match systematic_recovery {
+		true => (
+			with_systematic_chunks(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.systematic_threshold(),
+		),
+		false => (
+			with_fast_path(
+				request_receiver(&req_protocol_names),
+				&req_protocol_names,
+				Metrics::new_dummy(),
+			),
+			test_state.threshold(),
+		),
+	};
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+
+		let candidate_hash = test_state.candidate.hash();
+
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+		if systematic_recovery {
+			test_state
+				.test_chunk_requests_v1(
+					&req_protocol_names,
+					candidate_hash,
+					&mut virtual_overseer,
+					threshold,
+					|_| Has::Yes,
+					systematic_recovery,
+				)
+				.await;
+
+			// Systematic recovery failed, trying regular recovery.
+			test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+		}
+
+		test_state
+			.test_chunk_requests_v1(
+				&req_protocol_names,
+				candidate_hash,
+				&mut virtual_overseer,
+				test_state.validators.len() - test_state.threshold(),
+				|_| Has::Yes,
+				false,
+			)
+			.await;
+
+		assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
+		virtual_overseer
+	});
+}
+
 #[test]
-fn invalid_local_chunk_is_ignored() {
+fn test_systematic_recovery_skipped_if_no_core_index() {
 	let test_state = TestState::default();
 	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
-	let subsystem = AvailabilityRecoverySubsystem::with_chunks_only(
+	let subsystem = with_systematic_chunks(
 		request_receiver(&req_protocol_names),
+		&req_protocol_names,
 		Metrics::new_dummy(),
 	);
 
@@ -1554,30 +3025,99 @@ fn invalid_local_chunk_is_ignored() {
 				test_state.candidate.clone(),
 				test_state.session_index,
 				None,
+				None,
 				tx,
 			),
 		)
 		.await;
 
-		test_state.test_runtime_api(&mut virtual_overseer).await;
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+
+		let candidate_hash = test_state.candidate.hash();
+
 		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+		// Systematic recovery not possible without core index, falling back to regular recovery.
 		test_state
-			.respond_to_query_all_request_invalid(&mut virtual_overseer, |i| i == 0)
+			.test_chunk_requests(
+				&req_protocol_names,
+				candidate_hash,
+				&mut virtual_overseer,
+				test_state.validators.len() - test_state.threshold(),
+				|_| Has::No,
+				false,
+			)
 			.await;
 
+		// Make it fail, in order to assert that indeed regular recovery was attempted. If it were
+		// systematic recovery, we would have had one more attempt for regular reconstruction.
+		assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
+		virtual_overseer
+	});
+}
+
+#[test]
+fn test_systematic_recovery_skipped_if_mapping_disabled() {
+	let test_state = TestState::with_empty_node_features();
+	let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None);
+	let subsystem = AvailabilityRecoverySubsystem::for_validator(
+		None,
+		request_receiver(&req_protocol_names),
+		&req_protocol_names,
+		Metrics::new_dummy(),
+	);
+
+	test_harness(subsystem, |mut virtual_overseer| async move {
+		overseer_signal(
+			&mut virtual_overseer,
+			OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf(
+				test_state.current,
+				1,
+			))),
+		)
+		.await;
+
+		let (tx, rx) = oneshot::channel();
+
+		overseer_send(
+			&mut virtual_overseer,
+			AvailabilityRecoveryMessage::RecoverAvailableData(
+				test_state.candidate.clone(),
+				test_state.session_index,
+				None,
+				Some(test_state.core_index),
+				tx,
+			),
+		)
+		.await;
+
+		test_state.test_runtime_api_session_info(&mut virtual_overseer).await;
+
+		test_state.test_runtime_api_node_features(&mut virtual_overseer).await;
+
 		let candidate_hash = test_state.candidate.hash();
 
+		test_state.respond_to_available_data_query(&mut virtual_overseer, false).await;
+		test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await;
+
+		// Systematic recovery not possible without core index, falling back to regular recovery.
 		test_state
 			.test_chunk_requests(
 				&req_protocol_names,
 				candidate_hash,
 				&mut virtual_overseer,
-				test_state.threshold() - 1,
-				|i| if i == 0 { panic!("requested from local validator") } else { Has::Yes },
+				test_state.validators.len() - test_state.threshold(),
+				|_| Has::No,
+				false,
 			)
 			.await;
 
-		assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data);
+		// Make it fail, in order to assert that indeed regular recovery was attempted. If it were
+		// systematic recovery, we would have had one more attempt for regular reconstruction.
+		assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable);
 		virtual_overseer
 	});
 }
diff --git a/polkadot/node/network/bridge/Cargo.toml b/polkadot/node/network/bridge/Cargo.toml
index b609fb1e071957868c4bff91e02ca5d110aae9ee..cd4e00ee1e4c596ed8c9798fd0009c95f6950a93 100644
--- a/polkadot/node/network/bridge/Cargo.toml
+++ b/polkadot/node/network/bridge/Cargo.toml
@@ -15,7 +15,7 @@ async-trait = "0.1.79"
 futures = "0.3.30"
 gum = { package = "tracing-gum", path = "../../gum" }
 polkadot-primitives = { path = "../../../primitives" }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sc-network = { path = "../../../../substrate/client/network" }
 sp-consensus = { path = "../../../../substrate/primitives/consensus/common" }
 polkadot-node-metrics = { path = "../../metrics" }
diff --git a/polkadot/node/network/bridge/src/lib.rs b/polkadot/node/network/bridge/src/lib.rs
index 0305aaa067ccd5dbeb571ee3c9531417ac32818b..0db18bc219a9f00bbb57662e2d051c8405d4cf3a 100644
--- a/polkadot/node/network/bridge/src/lib.rs
+++ b/polkadot/node/network/bridge/src/lib.rs
@@ -21,8 +21,8 @@
 #![deny(unused_crate_dependencies)]
 #![warn(missing_docs)]
 
+use codec::{Decode, Encode};
 use futures::prelude::*;
-use parity_scale_codec::{Decode, Encode};
 use parking_lot::Mutex;
 
 use sp_consensus::SyncOracle;
diff --git a/polkadot/node/network/bridge/src/network.rs b/polkadot/node/network/bridge/src/network.rs
index 17d6676b8430d8252cf5a8816a8117a80d0411df..b31359f48a56fa01aea1e34bd23f0098d0744739 100644
--- a/polkadot/node/network/bridge/src/network.rs
+++ b/polkadot/node/network/bridge/src/network.rs
@@ -22,7 +22,7 @@ use std::{
 use async_trait::async_trait;
 use parking_lot::Mutex;
 
-use parity_scale_codec::Encode;
+use codec::Encode;
 
 use sc_network::{
 	config::parse_addr, multiaddr::Multiaddr, service::traits::NetworkService, types::ProtocolName,
diff --git a/polkadot/node/network/bridge/src/rx/mod.rs b/polkadot/node/network/bridge/src/rx/mod.rs
index 0a4497fc4b5a22639e516598a15557f08227c969..84e935366d0cb7734d5b0aec102032aa0c85edec 100644
--- a/polkadot/node/network/bridge/src/rx/mod.rs
+++ b/polkadot/node/network/bridge/src/rx/mod.rs
@@ -20,8 +20,8 @@ use super::*;
 
 use always_assert::never;
 use bytes::Bytes;
+use codec::{Decode, DecodeAll};
 use net_protocol::filter_by_peer_version;
-use parity_scale_codec::{Decode, DecodeAll};
 use parking_lot::Mutex;
 
 use sc_network::{
diff --git a/polkadot/node/network/bridge/src/tx/mod.rs b/polkadot/node/network/bridge/src/tx/mod.rs
index d5be6f01c33737a2b09bd39f40640d29c99ca94c..7b6dea748572ba1c24633b047227b92a9890c12c 100644
--- a/polkadot/node/network/bridge/src/tx/mod.rs
+++ b/polkadot/node/network/bridge/src/tx/mod.rs
@@ -301,7 +301,15 @@ where
 
 			for req in reqs {
 				match req {
-					Requests::ChunkFetchingV1(_) => metrics.on_message("chunk_fetching_v1"),
+					Requests::ChunkFetching(ref req) => {
+						// This is not the actual request that will succeed, as we don't know yet
+						// what that will be. It's only the primary request we tried.
+						if req.fallback_request.is_some() {
+							metrics.on_message("chunk_fetching_v2")
+						} else {
+							metrics.on_message("chunk_fetching_v1")
+						}
+					},
 					Requests::AvailableDataFetchingV1(_) =>
 						metrics.on_message("available_data_fetching_v1"),
 					Requests::CollationFetchingV1(_) => metrics.on_message("collation_fetching_v1"),
diff --git a/polkadot/node/network/bridge/src/tx/tests.rs b/polkadot/node/network/bridge/src/tx/tests.rs
index c3cf0f322f681b5cf2bca5c7a8bbadd53553a90d..9265358196dbf96d485af6b363ed089cf8efe321 100644
--- a/polkadot/node/network/bridge/src/tx/tests.rs
+++ b/polkadot/node/network/bridge/src/tx/tests.rs
@@ -26,7 +26,7 @@ use sc_network::{
 	IfDisconnected, ObservedRole as SubstrateObservedRole, ProtocolName, ReputationChange, Roles,
 };
 
-use parity_scale_codec::DecodeAll;
+use codec::DecodeAll;
 use polkadot_node_network_protocol::{
 	peer_set::{PeerSetProtocolNames, ValidationVersion},
 	request_response::{outgoing::Requests, ReqProtocolNames},
diff --git a/polkadot/node/network/bridge/src/validator_discovery.rs b/polkadot/node/network/bridge/src/validator_discovery.rs
index b11af8a8a089c4aa64b26312562636b039068a78..f0ef038d5eb40708165f41dcdc5310b5dd44c951 100644
--- a/polkadot/node/network/bridge/src/validator_discovery.rs
+++ b/polkadot/node/network/bridge/src/validator_discovery.rs
@@ -88,16 +88,6 @@ impl<N: Network, AD: AuthorityDiscovery> Service<N, AD> {
 		{
 			gum::warn!(target: LOG_TARGET, err = ?e, "AuthorityDiscoveryService returned an invalid multiaddress");
 		}
-		// the addresses are known to be valid
-		//
-		// for peer-set management, the main protocol name should be used regardless of
-		// the negotiated version.
-		let _ = network_service
-			.remove_from_peers_set(
-				self.peerset_protocol_names.get_main_name(peer_set),
-				peers_to_remove,
-			)
-			.await;
 
 		network_service
 	}
diff --git a/polkadot/node/network/collator-protocol/Cargo.toml b/polkadot/node/network/collator-protocol/Cargo.toml
index c02999a59b5a976748a7afe641b069851f6eb3c8..a56c1c7dfe9865dd82b78dda40a5e3aec228daf3 100644
--- a/polkadot/node/network/collator-protocol/Cargo.toml
+++ b/polkadot/node/network/collator-protocol/Cargo.toml
@@ -38,11 +38,10 @@ sp-core = { path = "../../../../substrate/primitives/core", features = ["std"] }
 sp-keyring = { path = "../../../../substrate/primitives/keyring" }
 sc-keystore = { path = "../../../../substrate/client/keystore" }
 sc-network = { path = "../../../../substrate/client/network" }
-parity-scale-codec = { version = "3.6.12", features = ["std"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["std"] }
 
 polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" }
 polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
 
 [features]
 default = []
-elastic-scaling-experimental = []
diff --git a/polkadot/node/network/collator-protocol/src/collator_side/mod.rs b/polkadot/node/network/collator-protocol/src/collator_side/mod.rs
index f227e3855fa0a72b268a5be9b6e33d8712111dc1..5c201542eb560641c39c19cece9cc23fe076c90a 100644
--- a/polkadot/node/network/collator-protocol/src/collator_side/mod.rs
+++ b/polkadot/node/network/collator-protocol/src/collator_side/mod.rs
@@ -51,6 +51,7 @@ use polkadot_node_subsystem_util::{
 		get_availability_cores, get_group_rotation_info, prospective_parachains_mode,
 		ProspectiveParachainsMode, RuntimeInfo,
 	},
+	vstaging::fetch_claim_queue,
 	TimeoutExt,
 };
 use polkadot_primitives::{
@@ -264,7 +265,9 @@ struct State {
 	/// never included in the fragment chains of active leaves which do. In
 	/// particular, this means that if a given relay parent belongs to implicit
 	/// ancestry of some active leaf, then it does support prospective parachains.
-	implicit_view: ImplicitView,
+	///
+	/// It's `None` if the collator is not yet collating for a paraid.
+	implicit_view: Option<ImplicitView>,
 
 	/// All active leaves observed by us, including both that do and do not
 	/// support prospective parachains. This mapping works as a replacement for
@@ -334,7 +337,7 @@ impl State {
 			metrics,
 			collating_on: Default::default(),
 			peer_data: Default::default(),
-			implicit_view: Default::default(),
+			implicit_view: None,
 			active_leaves: Default::default(),
 			per_relay_parent: Default::default(),
 			span_per_relay_parent: Default::default(),
@@ -539,11 +542,12 @@ async fn distribute_collation<Context>(
 			.filter(|(_, PeerData { view: v, .. })| match relay_parent_mode {
 				ProspectiveParachainsMode::Disabled => v.contains(&candidate_relay_parent),
 				ProspectiveParachainsMode::Enabled { .. } => v.iter().any(|block_hash| {
-					state
-						.implicit_view
-						.known_allowed_relay_parents_under(block_hash, Some(id))
-						.unwrap_or_default()
-						.contains(&candidate_relay_parent)
+					state.implicit_view.as_ref().map(|implicit_view| {
+						implicit_view
+							.known_allowed_relay_parents_under(block_hash, Some(id))
+							.unwrap_or_default()
+							.contains(&candidate_relay_parent)
+					}) == Some(true)
 				}),
 			});
 
@@ -576,22 +580,27 @@ async fn determine_cores(
 	let cores = get_availability_cores(sender, relay_parent).await?;
 	let n_cores = cores.len();
 	let mut assigned_cores = Vec::new();
+	let maybe_claim_queue = fetch_claim_queue(sender, relay_parent).await?;
 
 	for (idx, core) in cores.iter().enumerate() {
-		let core_para_id = match core {
-			CoreState::Scheduled(scheduled) => Some(scheduled.para_id),
-			CoreState::Occupied(occupied) =>
-				if relay_parent_mode.is_enabled() {
-					// With async backing we don't care about the core state,
-					// it is only needed for figuring our validators group.
-					Some(occupied.candidate_descriptor.para_id)
-				} else {
-					None
-				},
-			CoreState::Free => None,
+		let core_is_scheduled = match maybe_claim_queue {
+			Some(ref claim_queue) => {
+				// Runtime supports claim queue - use it.
+				claim_queue
+					.iter_claims_for_core(&CoreIndex(idx as u32))
+					.any(|para| para == &para_id)
+			},
+			None => match core {
+				CoreState::Scheduled(scheduled) if scheduled.para_id == para_id => true,
+				CoreState::Occupied(occupied) if relay_parent_mode.is_enabled() =>
+				// With async backing we don't care about the core state,
+				// it is only needed for figuring our validators group.
+					occupied.next_up_on_available.as_ref().map(|c| c.para_id) == Some(para_id),
+				_ => false,
+			},
 		};
 
-		if core_para_id == Some(para_id) {
+		if core_is_scheduled {
 			assigned_cores.push(CoreIndex::from(idx as u32));
 		}
 	}
@@ -830,6 +839,7 @@ async fn process_msg<Context>(
 	match msg {
 		CollateOn(id) => {
 			state.collating_on = Some(id);
+			state.implicit_view = Some(ImplicitView::new(Some(id)));
 		},
 		DistributeCollation {
 			candidate_receipt,
@@ -920,7 +930,6 @@ async fn send_collation(
 	let peer_id = request.peer_id();
 	let candidate_hash = receipt.hash();
 
-	#[cfg(feature = "elastic-scaling-experimental")]
 	let result = match parent_head_data {
 		ParentHeadData::WithData { head_data, .. } =>
 			Ok(request_v2::CollationFetchingResponse::CollationWithParentHeadData {
@@ -931,13 +940,6 @@ async fn send_collation(
 		ParentHeadData::OnlyHash(_) =>
 			Ok(request_v1::CollationFetchingResponse::Collation(receipt, pov)),
 	};
-	#[cfg(not(feature = "elastic-scaling-experimental"))]
-	let result = {
-		// suppress unused warning
-		let _parent_head_data = parent_head_data;
-
-		Ok(request_v1::CollationFetchingResponse::Collation(receipt, pov))
-	};
 
 	let response =
 		OutgoingResponse { result, reputation_changes: Vec::new(), sent_feedback: Some(tx) };
@@ -1215,7 +1217,10 @@ async fn handle_peer_view_change<Context>(
 			Some(ProspectiveParachainsMode::Disabled) => std::slice::from_ref(&added),
 			Some(ProspectiveParachainsMode::Enabled { .. }) => state
 				.implicit_view
-				.known_allowed_relay_parents_under(&added, state.collating_on)
+				.as_ref()
+				.and_then(|implicit_view| {
+					implicit_view.known_allowed_relay_parents_under(&added, state.collating_on)
+				})
 				.unwrap_or_default(),
 			None => {
 				gum::trace!(
@@ -1353,21 +1358,22 @@ where
 		state.per_relay_parent.insert(*leaf, PerRelayParent::new(mode));
 
 		if mode.is_enabled() {
-			state
-				.implicit_view
-				.activate_leaf(sender, *leaf)
-				.await
-				.map_err(Error::ImplicitViewFetchError)?;
+			if let Some(ref mut implicit_view) = state.implicit_view {
+				implicit_view
+					.activate_leaf(sender, *leaf)
+					.await
+					.map_err(Error::ImplicitViewFetchError)?;
 
-			let allowed_ancestry = state
-				.implicit_view
-				.known_allowed_relay_parents_under(leaf, state.collating_on)
-				.unwrap_or_default();
-			for block_hash in allowed_ancestry {
-				state
-					.per_relay_parent
-					.entry(*block_hash)
-					.or_insert_with(|| PerRelayParent::new(mode));
+				let allowed_ancestry = implicit_view
+					.known_allowed_relay_parents_under(leaf, state.collating_on)
+					.unwrap_or_default();
+
+				for block_hash in allowed_ancestry {
+					state
+						.per_relay_parent
+						.entry(*block_hash)
+						.or_insert_with(|| PerRelayParent::new(mode));
+				}
 			}
 		}
 	}
@@ -1378,7 +1384,11 @@ where
 		// of implicit ancestry. Only update the state after the hash is actually
 		// pruned from the block info storage.
 		let pruned = if mode.is_enabled() {
-			state.implicit_view.deactivate_leaf(*leaf)
+			state
+				.implicit_view
+				.as_mut()
+				.map(|view| view.deactivate_leaf(*leaf))
+				.unwrap_or_default()
 		} else {
 			vec![*leaf]
 		};
diff --git a/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs b/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs
index 689e03ce4737bcdd39d0651009f212e3cb364eea..13601ca7a0056508f06fdd3f2ed717ee4d2ea4b4 100644
--- a/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs
+++ b/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs
@@ -16,13 +16,17 @@
 
 use super::*;
 
-use std::{collections::HashSet, sync::Arc, time::Duration};
+use std::{
+	collections::{BTreeMap, HashSet, VecDeque},
+	sync::Arc,
+	time::Duration,
+};
 
 use assert_matches::assert_matches;
 use futures::{executor, future, Future};
 use futures_timer::Delay;
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 use sc_network::config::IncomingRequest as RawIncomingRequest;
 use sp_core::crypto::Pair;
@@ -66,7 +70,7 @@ struct TestState {
 	group_rotation_info: GroupRotationInfo,
 	validator_peer_id: Vec<PeerId>,
 	relay_parent: Hash,
-	availability_cores: Vec<CoreState>,
+	claim_queue: BTreeMap<CoreIndex, VecDeque<ParaId>>,
 	local_peer_id: PeerId,
 	collator_pair: CollatorPair,
 	session_index: SessionIndex,
@@ -105,8 +109,9 @@ impl Default for TestState {
 		let group_rotation_info =
 			GroupRotationInfo { session_start_block: 0, group_rotation_frequency: 100, now: 1 };
 
-		let availability_cores =
-			vec![CoreState::Scheduled(ScheduledCore { para_id, collator: None }), CoreState::Free];
+		let mut claim_queue = BTreeMap::new();
+		claim_queue.insert(CoreIndex(0), [para_id].into_iter().collect());
+		claim_queue.insert(CoreIndex(1), VecDeque::new());
 
 		let relay_parent = Hash::random();
 
@@ -133,7 +138,7 @@ impl Default for TestState {
 			group_rotation_info,
 			validator_peer_id,
 			relay_parent,
-			availability_cores,
+			claim_queue,
 			local_peer_id,
 			collator_pair,
 			session_index: 1,
@@ -144,21 +149,17 @@ impl Default for TestState {
 impl TestState {
 	/// Adds a few more scheduled cores to the state for the same para id
 	/// compared to the default.
-	#[cfg(feature = "elastic-scaling-experimental")]
 	pub fn with_elastic_scaling() -> Self {
 		let mut state = Self::default();
 		let para_id = state.para_id;
-		state
-			.availability_cores
-			.push(CoreState::Scheduled(ScheduledCore { para_id, collator: None }));
-		state
-			.availability_cores
-			.push(CoreState::Scheduled(ScheduledCore { para_id, collator: None }));
+
+		state.claim_queue.insert(CoreIndex(2), [para_id].into_iter().collect());
+		state.claim_queue.insert(CoreIndex(3), [para_id].into_iter().collect());
 		state
 	}
 
 	fn current_group_validator_indices(&self) -> &[ValidatorIndex] {
-		let core_num = self.availability_cores.len();
+		let core_num = self.claim_queue.len();
 		let GroupIndex(group_idx) = self.group_rotation_info.group_for_core(CoreIndex(0), core_num);
 		&self.session_info.validator_groups.get(GroupIndex::from(group_idx)).unwrap()
 	}
@@ -223,7 +224,8 @@ impl TestState {
 	}
 }
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<CollatorProtocolMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<CollatorProtocolMessage>;
 
 struct TestHarness {
 	virtual_overseer: VirtualOverseer,
@@ -245,7 +247,8 @@ fn test_harness<T: Future<Output = TestHarness>>(
 
 	let pool = sp_core::testing::TaskExecutor::new();
 
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let genesis_hash = Hash::repeat_byte(0xff);
 	let req_protocol_names = ReqProtocolNames::new(&genesis_hash, None);
@@ -394,7 +397,36 @@ async fn distribute_collation_with_receipt(
 			RuntimeApiRequest::AvailabilityCores(tx)
 		)) => {
 			assert_eq!(relay_parent, _relay_parent);
-			tx.send(Ok(test_state.availability_cores.clone())).unwrap();
+			tx.send(Ok(test_state.claim_queue.values().map(|paras|
+				if let Some(para) = paras.front() {
+					CoreState::Scheduled(ScheduledCore { para_id: *para, collator: None })
+				} else {
+					CoreState::Free
+				}
+			).collect())).unwrap();
+		}
+	);
+
+	assert_matches!(
+		overseer_recv(virtual_overseer).await,
+		AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+			_relay_parent,
+			RuntimeApiRequest::Version(tx)
+		)) => {
+			assert_eq!(relay_parent, _relay_parent);
+			tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap();
+		}
+	);
+
+	// obtain the claim queue schedule.
+	assert_matches!(
+		overseer_recv(virtual_overseer).await,
+		AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+			_relay_parent,
+			RuntimeApiRequest::ClaimQueue(tx)
+		)) => {
+			assert_eq!(relay_parent, _relay_parent);
+			tx.send(Ok(test_state.claim_queue.clone())).unwrap();
 		}
 	);
 
diff --git a/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs b/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs
index 707053545630a0a11603ccda030200eed7b5cfe2..ea8fdb0e04fbe0ba29303b62ae1d45c63d43cdf4 100644
--- a/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs
+++ b/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs
@@ -18,8 +18,8 @@
 
 use super::*;
 
-use polkadot_node_subsystem::messages::{ChainApiMessage, ProspectiveParachainsMessage};
-use polkadot_primitives::{AsyncBackingParams, Header, OccupiedCore};
+use polkadot_node_subsystem::messages::ChainApiMessage;
+use polkadot_primitives::{AsyncBackingParams, Header};
 
 const ASYNC_BACKING_PARAMETERS: AsyncBackingParams =
 	AsyncBackingParams { max_candidate_depth: 4, allowed_ancestry_len: 3 };
@@ -31,7 +31,6 @@ fn get_parent_hash(hash: Hash) -> Hash {
 /// Handle a view update.
 async fn update_view(
 	virtual_overseer: &mut VirtualOverseer,
-	test_state: &TestState,
 	new_view: Vec<(Hash, u32)>, // Hash and block number.
 	activated: u8,              // How many new heads does this update contain?
 ) {
@@ -61,21 +60,88 @@ async fn update_view(
 
 		let min_number = leaf_number.saturating_sub(ASYNC_BACKING_PARAMETERS.allowed_ancestry_len);
 
-		assert_matches!(
-			overseer_recv(virtual_overseer).await,
-			AllMessages::ProspectiveParachains(
-				ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx),
-			) if parent == leaf_hash => {
-				tx.send(vec![(test_state.para_id, min_number)]).unwrap();
-			}
-		);
-
 		let ancestry_len = leaf_number + 1 - min_number;
 		let ancestry_hashes = std::iter::successors(Some(leaf_hash), |h| Some(get_parent_hash(*h)))
 			.take(ancestry_len as usize);
 		let ancestry_numbers = (min_number..=leaf_number).rev();
 		let mut ancestry_iter = ancestry_hashes.clone().zip(ancestry_numbers).peekable();
 
+		if let Some((hash, number)) = ancestry_iter.next() {
+			assert_matches!(
+				overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(),
+				AllMessages::ChainApi(ChainApiMessage::BlockHeader(.., tx)) => {
+					let header = Header {
+						parent_hash: get_parent_hash(hash),
+						number,
+						state_root: Hash::zero(),
+						extrinsics_root: Hash::zero(),
+						digest: Default::default(),
+					};
+
+					tx.send(Ok(Some(header))).unwrap();
+				}
+			);
+
+			assert_matches!(
+				overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(),
+				AllMessages::RuntimeApi(
+					RuntimeApiMessage::Request(
+						..,
+						RuntimeApiRequest::AsyncBackingParams(
+							tx
+						)
+					)
+				) => {
+					tx.send(Ok(ASYNC_BACKING_PARAMETERS)).unwrap();
+				}
+			);
+
+			assert_matches!(
+				overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(),
+				AllMessages::RuntimeApi(
+					RuntimeApiMessage::Request(
+						..,
+						RuntimeApiRequest::SessionIndexForChild(
+							tx
+						)
+					)
+				) => {
+					tx.send(Ok(1)).unwrap();
+				}
+			);
+
+			assert_matches!(
+				overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(),
+				AllMessages::ChainApi(
+					ChainApiMessage::Ancestors {
+						k,
+						response_channel: tx,
+						..
+					}
+				) => {
+					assert_eq!(k, ASYNC_BACKING_PARAMETERS.allowed_ancestry_len as usize);
+
+					tx.send(Ok(ancestry_hashes.clone().skip(1).into_iter().collect())).unwrap();
+				}
+			);
+		}
+
+		for _ in ancestry_iter.clone() {
+			assert_matches!(
+				overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(),
+				AllMessages::RuntimeApi(
+					RuntimeApiMessage::Request(
+						..,
+						RuntimeApiRequest::SessionIndexForChild(
+							tx
+						)
+					)
+				) => {
+					tx.send(Ok(1)).unwrap();
+				}
+			);
+		}
+
 		while let Some((hash, number)) = ancestry_iter.next() {
 			// May be `None` for the last element.
 			let parent_hash =
@@ -195,7 +261,7 @@ fn distribute_collation_from_implicit_view() {
 			overseer_send(virtual_overseer, CollatorProtocolMessage::CollateOn(test_state.para_id))
 				.await;
 			// Activated leaf is `b`, but the collation will be based on `c`.
-			update_view(virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await;
+			update_view(virtual_overseer, vec![(head_b, head_b_num)], 1).await;
 
 			let validator_peer_ids = test_state.current_group_validator_peer_ids();
 			for (val, peer) in test_state
@@ -258,7 +324,7 @@ fn distribute_collation_from_implicit_view() {
 
 			// Head `c` goes out of view.
 			// Build a different candidate for this relay parent and attempt to distribute it.
-			update_view(virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await;
+			update_view(virtual_overseer, vec![(head_a, head_a_num)], 1).await;
 
 			let pov = PoV { block_data: BlockData(vec![4, 5, 6]) };
 			let parent_head_data_hash = Hash::repeat_byte(0xBB);
@@ -318,7 +384,7 @@ fn distribute_collation_up_to_limit() {
 			overseer_send(virtual_overseer, CollatorProtocolMessage::CollateOn(test_state.para_id))
 				.await;
 			// Activated leaf is `a`, but the collation will be based on `b`.
-			update_view(virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await;
+			update_view(virtual_overseer, vec![(head_a, head_a_num)], 1).await;
 
 			for i in 0..(ASYNC_BACKING_PARAMETERS.max_candidate_depth + 1) {
 				let pov = PoV { block_data: BlockData(vec![i as u8]) };
@@ -377,7 +443,6 @@ fn distribute_collation_up_to_limit() {
 /// Tests that collator send the parent head data in
 /// case the para is assigned to multiple cores (elastic scaling).
 #[test]
-#[cfg(feature = "elastic-scaling-experimental")]
 fn send_parent_head_data_for_elastic_scaling() {
 	let test_state = TestState::with_elastic_scaling();
 
@@ -402,7 +467,7 @@ fn send_parent_head_data_for_elastic_scaling() {
 				CollatorProtocolMessage::CollateOn(test_state.para_id),
 			)
 			.await;
-			update_view(&mut virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await;
+			update_view(&mut virtual_overseer, vec![(head_b, head_b_num)], 1).await;
 
 			let pov_data = PoV { block_data: BlockData(vec![1 as u8]) };
 			let candidate = TestCandidateBuilder {
@@ -517,8 +582,8 @@ fn advertise_and_send_collation_by_hash() {
 				CollatorProtocolMessage::CollateOn(test_state.para_id),
 			)
 			.await;
-			update_view(&mut virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await;
-			update_view(&mut virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await;
+			update_view(&mut virtual_overseer, vec![(head_b, head_b_num)], 1).await;
+			update_view(&mut virtual_overseer, vec![(head_a, head_a_num)], 1).await;
 
 			let candidates: Vec<_> = (0..2)
 				.map(|i| {
@@ -600,90 +665,3 @@ fn advertise_and_send_collation_by_hash() {
 		},
 	)
 }
-
-/// Tests that collator distributes collation built on top of occupied core.
-#[test]
-fn advertise_core_occupied() {
-	let mut test_state = TestState::default();
-	let candidate =
-		TestCandidateBuilder { para_id: test_state.para_id, ..Default::default() }.build();
-	test_state.availability_cores[0] = CoreState::Occupied(OccupiedCore {
-		next_up_on_available: None,
-		occupied_since: 0,
-		time_out_at: 0,
-		next_up_on_time_out: None,
-		availability: BitVec::default(),
-		group_responsible: GroupIndex(0),
-		candidate_hash: candidate.hash(),
-		candidate_descriptor: candidate.descriptor,
-	});
-
-	let local_peer_id = test_state.local_peer_id;
-	let collator_pair = test_state.collator_pair.clone();
-
-	test_harness(
-		local_peer_id,
-		collator_pair,
-		ReputationAggregator::new(|_| true),
-		|mut test_harness| async move {
-			let virtual_overseer = &mut test_harness.virtual_overseer;
-
-			let head_a = Hash::from_low_u64_be(128);
-			let head_a_num: u32 = 64;
-
-			// Grandparent of head `a`.
-			let head_b = Hash::from_low_u64_be(130);
-
-			// Set collating para id.
-			overseer_send(virtual_overseer, CollatorProtocolMessage::CollateOn(test_state.para_id))
-				.await;
-			// Activated leaf is `a`, but the collation will be based on `b`.
-			update_view(virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await;
-
-			let pov = PoV { block_data: BlockData(vec![1, 2, 3]) };
-			let candidate = TestCandidateBuilder {
-				para_id: test_state.para_id,
-				relay_parent: head_b,
-				pov_hash: pov.hash(),
-				..Default::default()
-			}
-			.build();
-			let candidate_hash = candidate.hash();
-			distribute_collation_with_receipt(
-				virtual_overseer,
-				&test_state,
-				head_b,
-				true,
-				candidate,
-				pov,
-				Hash::zero(),
-			)
-			.await;
-
-			let validators = test_state.current_group_validator_authority_ids();
-			let peer_ids = test_state.current_group_validator_peer_ids();
-
-			connect_peer(
-				virtual_overseer,
-				peer_ids[0],
-				CollationVersion::V2,
-				Some(validators[0].clone()),
-			)
-			.await;
-			expect_declare_msg_v2(virtual_overseer, &test_state, &peer_ids[0]).await;
-			// Peer is aware of the leaf.
-			send_peer_view_change(virtual_overseer, &peer_ids[0], vec![head_a]).await;
-
-			// Collation is advertised.
-			expect_advertise_collation_msg(
-				virtual_overseer,
-				&peer_ids[0],
-				head_b,
-				Some(vec![candidate_hash]),
-			)
-			.await;
-
-			test_harness
-		},
-	)
-}
diff --git a/polkadot/node/network/collator-protocol/src/validator_side/collation.rs b/polkadot/node/network/collator-protocol/src/validator_side/collation.rs
index 001df1fb3da9b24a3c1acffc049cc7433903aea8..96ffe9f13db3562429eb68cdfdc05da801c33863 100644
--- a/polkadot/node/network/collator-protocol/src/validator_side/collation.rs
+++ b/polkadot/node/network/collator-protocol/src/validator_side/collation.rs
@@ -270,7 +270,7 @@ impl Collations {
 			// We don't need to fetch any other collation when we already have seconded one.
 			CollationStatus::Seconded => None,
 			CollationStatus::Waiting =>
-				if !self.is_seconded_limit_reached(relay_parent_mode) {
+				if self.is_seconded_limit_reached(relay_parent_mode) {
 					None
 				} else {
 					self.waiting_queue.pop_front()
@@ -280,7 +280,7 @@ impl Collations {
 		}
 	}
 
-	/// Checks the limit of seconded candidates for a given para.
+	/// Checks the limit of seconded candidates.
 	pub(super) fn is_seconded_limit_reached(
 		&self,
 		relay_parent_mode: ProspectiveParachainsMode,
@@ -293,7 +293,7 @@ impl Collations {
 			} else {
 				1
 			};
-		self.seconded_count < seconded_limit
+		self.seconded_count >= seconded_limit
 	}
 }
 
diff --git a/polkadot/node/network/collator-protocol/src/validator_side/mod.rs b/polkadot/node/network/collator-protocol/src/validator_side/mod.rs
index 9f037a983e51c33cb734ee65fc496541d1082bf2..f5c9726f3f6a509a4966720f5e2011d173a9d318 100644
--- a/polkadot/node/network/collator-protocol/src/validator_side/mod.rs
+++ b/polkadot/node/network/collator-protocol/src/validator_side/mod.rs
@@ -19,7 +19,7 @@ use futures::{
 };
 use futures_timer::Delay;
 use std::{
-	collections::{hash_map::Entry, HashMap, HashSet},
+	collections::{hash_map::Entry, HashMap, HashSet, VecDeque},
 	future::Future,
 	time::{Duration, Instant},
 };
@@ -51,6 +51,7 @@ use polkadot_node_subsystem_util::{
 	backing_implicit_view::View as ImplicitView,
 	reputation::{ReputationAggregator, REPUTATION_CHANGE_INTERVAL},
 	runtime::{prospective_parachains_mode, ProspectiveParachainsMode},
+	vstaging::fetch_claim_queue,
 };
 use polkadot_primitives::{
 	CandidateHash, CollatorId, CoreState, Hash, HeadData, Id as ParaId, OccupiedCoreAssumption,
@@ -362,8 +363,8 @@ impl PeerData {
 
 #[derive(Debug)]
 struct GroupAssignments {
-	/// Current assignment.
-	current: Option<ParaId>,
+	/// Current assignments.
+	current: Vec<ParaId>,
 }
 
 struct PerRelayParent {
@@ -376,7 +377,7 @@ impl PerRelayParent {
 	fn new(mode: ProspectiveParachainsMode) -> Self {
 		Self {
 			prospective_parachains_mode: mode,
-			assignment: GroupAssignments { current: None },
+			assignment: GroupAssignments { current: vec![] },
 			collations: Collations::default(),
 		}
 	}
@@ -491,34 +492,34 @@ where
 		.await
 		.map_err(Error::CancelledAvailabilityCores)??;
 
-	let para_now = match polkadot_node_subsystem_util::signing_key_and_index(&validators, keystore)
-		.and_then(|(_, index)| polkadot_node_subsystem_util::find_validator_group(&groups, index))
-	{
-		Some(group) => {
-			let core_now = rotation_info.core_for_group(group, cores.len());
-
-			cores.get(core_now.0 as usize).and_then(|c| match c {
-				CoreState::Occupied(core) if relay_parent_mode.is_enabled() => Some(core.para_id()),
-				CoreState::Scheduled(core) => Some(core.para_id),
-				CoreState::Occupied(_) | CoreState::Free => None,
-			})
-		},
-		None => {
-			gum::trace!(target: LOG_TARGET, ?relay_parent, "Not a validator");
-
-			return Ok(())
-		},
+	let core_now = if let Some(group) =
+		polkadot_node_subsystem_util::signing_key_and_index(&validators, keystore).and_then(
+			|(_, index)| polkadot_node_subsystem_util::find_validator_group(&groups, index),
+		) {
+		rotation_info.core_for_group(group, cores.len())
+	} else {
+		gum::trace!(target: LOG_TARGET, ?relay_parent, "Not a validator");
+		return Ok(())
 	};
 
-	// This code won't work well, if at all for on-demand parachains. For on-demand we'll
-	// have to be aware of which core the on-demand claim is going to be multiplexed
-	// onto. The on-demand claim will also have a known collator, and we should always
-	// allow an incoming connection from that collator. If not even connecting to them
-	// directly.
-	//
-	// However, this'll work fine for parachains, as each parachain gets a dedicated
-	// core.
-	if let Some(para_id) = para_now.as_ref() {
+	let paras_now = match fetch_claim_queue(sender, relay_parent).await.map_err(Error::Runtime)? {
+		// Runtime supports claim queue - use it
+		//
+		// `relay_parent_mode` is not examined here because if the runtime supports claim queue
+		// then it supports async backing params too (`ASYNC_BACKING_STATE_RUNTIME_REQUIREMENT`
+		// < `CLAIM_QUEUE_RUNTIME_REQUIREMENT`).
+		Some(mut claim_queue) => claim_queue.0.remove(&core_now),
+		// Claim queue is not supported by the runtime - use availability cores instead.
+		None => cores.get(core_now.0 as usize).and_then(|c| match c {
+			CoreState::Occupied(core) if relay_parent_mode.is_enabled() =>
+				core.next_up_on_available.as_ref().map(|c| [c.para_id].into_iter().collect()),
+			CoreState::Scheduled(core) => Some([core.para_id].into_iter().collect()),
+			CoreState::Occupied(_) | CoreState::Free => None,
+		}),
+	}
+	.unwrap_or_else(|| VecDeque::new());
+
+	for para_id in paras_now.iter() {
 		let entry = current_assignments.entry(*para_id).or_default();
 		*entry += 1;
 		if *entry == 1 {
@@ -531,7 +532,7 @@ where
 		}
 	}
 
-	*group_assignment = GroupAssignments { current: para_now };
+	*group_assignment = GroupAssignments { current: paras_now.into_iter().collect() };
 
 	Ok(())
 }
@@ -542,7 +543,7 @@ fn remove_outgoing(
 ) {
 	let GroupAssignments { current, .. } = per_relay_parent.assignment;
 
-	if let Some(cur) = current {
+	for cur in current {
 		if let Entry::Occupied(mut occupied) = current_assignments.entry(cur) {
 			*occupied.get_mut() -= 1;
 			if *occupied.get() == 0 {
@@ -857,7 +858,8 @@ async fn process_incoming_peer_message<Context>(
 					peer_id = ?origin,
 					?collator_id,
 					?para_id,
-					"Declared as collator for unneeded para",
+					"Declared as collator for unneeded para. Current assignments: {:?}",
+					&state.current_assignments
 				);
 
 				modify_reputation(
@@ -1089,7 +1091,7 @@ where
 		peer_data.collating_para().ok_or(AdvertisementError::UndeclaredCollator)?;
 
 	// Check if this is assigned to us.
-	if assignment.current.map_or(true, |id| id != collator_para_id) {
+	if !assignment.current.contains(&collator_para_id) {
 		return Err(AdvertisementError::InvalidAssignment)
 	}
 
@@ -1105,7 +1107,7 @@ where
 		)
 		.map_err(AdvertisementError::Invalid)?;
 
-	if !per_relay_parent.collations.is_seconded_limit_reached(relay_parent_mode) {
+	if per_relay_parent.collations.is_seconded_limit_reached(relay_parent_mode) {
 		return Err(AdvertisementError::SecondedLimitReached)
 	}
 
@@ -1197,7 +1199,7 @@ where
 		});
 
 	let collations = &mut per_relay_parent.collations;
-	if !collations.is_seconded_limit_reached(relay_parent_mode) {
+	if collations.is_seconded_limit_reached(relay_parent_mode) {
 		gum::trace!(
 			target: LOG_TARGET,
 			peer_id = ?peer_id,
diff --git a/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs b/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs
index 1ba6389212cc5beffdd6cb94a0fed194dd1cb048..44e25efd4dfcd30536fca2dc766dc1f18b1851b4 100644
--- a/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs
+++ b/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs
@@ -21,7 +21,12 @@ use sc_network::ProtocolName;
 use sp_core::{crypto::Pair, Encode};
 use sp_keyring::Sr25519Keyring;
 use sp_keystore::Keystore;
-use std::{iter, sync::Arc, time::Duration};
+use std::{
+	collections::{BTreeMap, VecDeque},
+	iter,
+	sync::Arc,
+	time::Duration,
+};
 
 use polkadot_node_network_protocol::{
 	our_view,
@@ -37,7 +42,7 @@ use polkadot_node_subsystem::{
 use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_node_subsystem_util::{reputation::add_reputation, TimeoutExt};
 use polkadot_primitives::{
-	CandidateReceipt, CollatorPair, CoreState, GroupIndex, GroupRotationInfo, HeadData,
+	CandidateReceipt, CollatorPair, CoreIndex, CoreState, GroupIndex, GroupRotationInfo, HeadData,
 	OccupiedCore, PersistedValidationData, ScheduledCore, ValidatorId, ValidatorIndex,
 };
 use polkadot_primitives_test_helpers::{
@@ -71,6 +76,7 @@ struct TestState {
 	validator_groups: Vec<Vec<ValidatorIndex>>,
 	group_rotation_info: GroupRotationInfo,
 	cores: Vec<CoreState>,
+	claim_queue: BTreeMap<CoreIndex, VecDeque<ParaId>>,
 }
 
 impl Default for TestState {
@@ -104,7 +110,7 @@ impl Default for TestState {
 			CoreState::Scheduled(ScheduledCore { para_id: chain_ids[0], collator: None }),
 			CoreState::Free,
 			CoreState::Occupied(OccupiedCore {
-				next_up_on_available: None,
+				next_up_on_available: Some(ScheduledCore { para_id: chain_ids[1], collator: None }),
 				occupied_since: 0,
 				time_out_at: 1,
 				next_up_on_time_out: None,
@@ -120,6 +126,11 @@ impl Default for TestState {
 			}),
 		];
 
+		let mut claim_queue = BTreeMap::new();
+		claim_queue.insert(CoreIndex(0), [chain_ids[0]].into_iter().collect());
+		claim_queue.insert(CoreIndex(1), VecDeque::new());
+		claim_queue.insert(CoreIndex(2), [chain_ids[1]].into_iter().collect());
+
 		Self {
 			chain_ids,
 			relay_parent,
@@ -128,11 +139,13 @@ impl Default for TestState {
 			validator_groups,
 			group_rotation_info,
 			cores,
+			claim_queue,
 		}
 	}
 }
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<CollatorProtocolMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<CollatorProtocolMessage>;
 
 struct TestHarness {
 	virtual_overseer: VirtualOverseer,
@@ -151,7 +164,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 
 	let pool = sp_core::testing::TaskExecutor::new();
 
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let keystore = Arc::new(sc_keystore::LocalKeystore::in_memory());
 	Keystore::sr25519_generate_new(
@@ -262,6 +276,26 @@ async fn respond_to_core_info_queries(
 			let _ = tx.send(Ok(test_state.cores.clone()));
 		}
 	);
+
+	assert_matches!(
+		overseer_recv(virtual_overseer).await,
+		AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+			_,
+			RuntimeApiRequest::Version(tx),
+		)) => {
+			let _ = tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT));
+		}
+	);
+
+	assert_matches!(
+		overseer_recv(virtual_overseer).await,
+		AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+			_,
+			RuntimeApiRequest::ClaimQueue(tx),
+		)) => {
+			let _ = tx.send(Ok(test_state.claim_queue.clone()));
+		}
+	);
 }
 
 /// Assert that the next message is a `CandidateBacking(Second())`.
diff --git a/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs b/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs
index 785690121dadd1858a4985459b515739842a1421..472731b506ab1c5d59a756a9e80b47016bcceb6c 100644
--- a/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs
+++ b/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs
@@ -72,6 +72,26 @@ async fn assert_assign_incoming(
 			tx.send(Ok(test_state.cores.clone())).unwrap();
 		}
 	);
+
+	assert_matches!(
+		overseer_recv(virtual_overseer).await,
+		AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+			parent,
+			RuntimeApiRequest::Version(tx),
+		)) if parent == hash => {
+			let _ = tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT));
+		}
+	);
+
+	assert_matches!(
+		overseer_recv(virtual_overseer).await,
+		AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+			parent,
+			RuntimeApiRequest::ClaimQueue(tx),
+		)) if parent == hash => {
+			let _ = tx.send(Ok(test_state.claim_queue.clone()));
+		}
+	);
 }
 
 /// Handle a view update.
@@ -116,15 +136,6 @@ pub(super) async fn update_view(
 
 		let min_number = leaf_number.saturating_sub(ASYNC_BACKING_PARAMETERS.allowed_ancestry_len);
 
-		assert_matches!(
-			overseer_recv(virtual_overseer).await,
-			AllMessages::ProspectiveParachains(
-				ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx),
-			) if parent == leaf_hash => {
-				tx.send(test_state.chain_ids.iter().map(|para_id| (*para_id, min_number)).collect()).unwrap();
-			}
-		);
-
 		let ancestry_len = leaf_number + 1 - min_number;
 		let ancestry_hashes = std::iter::successors(Some(leaf_hash), |h| Some(get_parent_hash(*h)))
 			.take(ancestry_len as usize);
@@ -166,6 +177,17 @@ pub(super) async fn update_view(
 					}
 				);
 
+				if requested_len == 0 {
+					assert_matches!(
+						overseer_recv(virtual_overseer).await,
+						AllMessages::ProspectiveParachains(
+							ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx),
+						) if parent == leaf_hash => {
+							tx.send(test_state.chain_ids.iter().map(|para_id| (*para_id, min_number)).collect()).unwrap();
+						}
+					);
+				}
+
 				requested_len += 1;
 			}
 		}
diff --git a/polkadot/node/network/dispute-distribution/Cargo.toml b/polkadot/node/network/dispute-distribution/Cargo.toml
index dff285590d97cd4f47a00a6141b5c8a07315e35e..08713209bb740737df26e36d2f4df7933914406b 100644
--- a/polkadot/node/network/dispute-distribution/Cargo.toml
+++ b/polkadot/node/network/dispute-distribution/Cargo.toml
@@ -14,7 +14,7 @@ futures = "0.3.30"
 futures-timer = "3.0.2"
 gum = { package = "tracing-gum", path = "../../gum" }
 derive_more = "0.99.17"
-parity-scale-codec = { version = "3.6.12", features = ["std"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["std"] }
 polkadot-primitives = { path = "../../../primitives" }
 polkadot-erasure-coding = { path = "../../../erasure-coding" }
 polkadot-node-subsystem = { path = "../../subsystem" }
diff --git a/polkadot/node/network/dispute-distribution/src/tests/mod.rs b/polkadot/node/network/dispute-distribution/src/tests/mod.rs
index 1d0d667f5ccf4a156316110f1493ac180615b877..60820e62ca2d6dbab4d8ba5defe037e12ed1a463 100644
--- a/polkadot/node/network/dispute-distribution/src/tests/mod.rs
+++ b/polkadot/node/network/dispute-distribution/src/tests/mod.rs
@@ -24,13 +24,13 @@ use std::{
 };
 
 use assert_matches::assert_matches;
+use codec::{Decode, Encode};
 use futures::{
 	channel::oneshot,
 	future::{poll_fn, ready},
 	pin_mut, Future,
 };
 use futures_timer::Delay;
-use parity_scale_codec::{Decode, Encode};
 
 use sc_network::{config::RequestResponseConfig, ProtocolName};
 
diff --git a/polkadot/node/network/gossip-support/src/tests.rs b/polkadot/node/network/gossip-support/src/tests.rs
index cce78df38f308e34e1c663ab2c27850c818e26f8..42197d00e6f3de0f598c8d92bc076bfb225fba9a 100644
--- a/polkadot/node/network/gossip-support/src/tests.rs
+++ b/polkadot/node/network/gossip-support/src/tests.rs
@@ -90,7 +90,8 @@ lazy_static! {
 	];
 }
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<GossipSupportMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<GossipSupportMessage>;
 
 #[derive(Debug, Clone)]
 struct MockAuthorityDiscovery {
@@ -200,7 +201,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>, AD: AuthorityDiscovery>(
 	test_fn: impl FnOnce(VirtualOverseer) -> T,
 ) -> GossipSupport<AD> {
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 
 	let subsystem = subsystem.run(context);
 
diff --git a/polkadot/node/network/protocol/Cargo.toml b/polkadot/node/network/protocol/Cargo.toml
index c5015b8c64504b2712c9713463ab78af2f265948..83145ce4013022b5567d45434c989bba732382c7 100644
--- a/polkadot/node/network/protocol/Cargo.toml
+++ b/polkadot/node/network/protocol/Cargo.toml
@@ -16,7 +16,7 @@ hex = "0.4.3"
 polkadot-primitives = { path = "../../../primitives" }
 polkadot-node-primitives = { path = "../../primitives" }
 polkadot-node-jaeger = { path = "../../jaeger" }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sc-network = { path = "../../../../substrate/client/network" }
 sc-network-types = { path = "../../../../substrate/client/network/types" }
 sc-authority-discovery = { path = "../../../../substrate/client/authority-discovery" }
diff --git a/polkadot/node/network/protocol/src/lib.rs b/polkadot/node/network/protocol/src/lib.rs
index c38838b1ef9845eb85c929066eb7de108374fa0d..ca0f8a4e48493691d7c1cb43579e9420c8a88274 100644
--- a/polkadot/node/network/protocol/src/lib.rs
+++ b/polkadot/node/network/protocol/src/lib.rs
@@ -19,7 +19,7 @@
 #![deny(unused_crate_dependencies)]
 #![warn(missing_docs)]
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_primitives::{BlockNumber, Hash};
 use std::{collections::HashMap, fmt};
 
@@ -462,7 +462,7 @@ impl_versioned_try_from!(
 
 /// v1 notification protocol types.
 pub mod v1 {
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 
 	use polkadot_primitives::{
 		CandidateHash, CandidateIndex, CollatorId, CollatorSignature, CompactStatement, Hash,
@@ -621,7 +621,7 @@ pub mod v1 {
 /// v2 network protocol types.
 pub mod v2 {
 	use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec};
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 
 	use polkadot_primitives::{
 		CandidateHash, CandidateIndex, CollatorId, CollatorSignature, GroupIndex, Hash,
@@ -875,7 +875,7 @@ pub mod v2 {
 /// Purpose is for changing ApprovalDistributionMessage to
 /// include more than one assignment and approval in a message.
 pub mod v3 {
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 
 	use polkadot_node_primitives::approval::v2::{
 		CandidateBitfield, IndirectAssignmentCertV2, IndirectSignedApprovalVoteV2,
diff --git a/polkadot/node/network/protocol/src/request_response/incoming/error.rs b/polkadot/node/network/protocol/src/request_response/incoming/error.rs
index 7de9d919058ab05d3c91832c7d9829173d948e43..d3aa0b7275c13501f62fb0ca3be2c364e79d1883 100644
--- a/polkadot/node/network/protocol/src/request_response/incoming/error.rs
+++ b/polkadot/node/network/protocol/src/request_response/incoming/error.rs
@@ -18,7 +18,7 @@
 
 use sc_network_types::PeerId;
 
-use parity_scale_codec::Error as DecodingError;
+use codec::Error as DecodingError;
 
 #[allow(missing_docs)]
 #[fatality::fatality(splitable)]
diff --git a/polkadot/node/network/protocol/src/request_response/incoming/mod.rs b/polkadot/node/network/protocol/src/request_response/incoming/mod.rs
index e85390729ee3f99f4a74b4cf2b90ac225c819fc6..9577c690ebdc8c9b64fa66426af178c63e58cc34 100644
--- a/polkadot/node/network/protocol/src/request_response/incoming/mod.rs
+++ b/polkadot/node/network/protocol/src/request_response/incoming/mod.rs
@@ -18,7 +18,7 @@ use std::marker::PhantomData;
 
 use futures::{channel::oneshot, StreamExt};
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 use sc_network::{config as netconfig, NetworkBackend};
 use sc_network_types::PeerId;
diff --git a/polkadot/node/network/protocol/src/request_response/mod.rs b/polkadot/node/network/protocol/src/request_response/mod.rs
index cab02bb88a00b429a80ce25e342fd38e25b3f3d5..fe06593bd7a0f58202471483cc06980ee35a2926 100644
--- a/polkadot/node/network/protocol/src/request_response/mod.rs
+++ b/polkadot/node/network/protocol/src/request_response/mod.rs
@@ -98,6 +98,10 @@ pub enum Protocol {
 	/// Protocol for requesting candidates with attestations in statement distribution
 	/// when async backing is enabled.
 	AttestedCandidateV2,
+
+	/// Protocol for chunk fetching version 2, used by availability distribution and availability
+	/// recovery.
+	ChunkFetchingV2,
 }
 
 /// Minimum bandwidth we expect for validators - 500Mbit/s is the recommendation, so approximately
@@ -209,7 +213,7 @@ impl Protocol {
 		let name = req_protocol_names.get_name(self);
 		let legacy_names = self.get_legacy_name().into_iter().map(Into::into).collect();
 		match self {
-			Protocol::ChunkFetchingV1 => N::request_response_config(
+			Protocol::ChunkFetchingV1 | Protocol::ChunkFetchingV2 => N::request_response_config(
 				name,
 				legacy_names,
 				1_000,
@@ -292,7 +296,7 @@ impl Protocol {
 			// times (due to network delays), 100 seems big enough to accommodate for "bursts",
 			// assuming we can service requests relatively quickly, which would need to be measured
 			// as well.
-			Protocol::ChunkFetchingV1 => 100,
+			Protocol::ChunkFetchingV1 | Protocol::ChunkFetchingV2 => 100,
 			// 10 seems reasonable, considering group sizes of max 10 validators.
 			Protocol::CollationFetchingV1 | Protocol::CollationFetchingV2 => 10,
 			// 10 seems reasonable, considering group sizes of max 10 validators.
@@ -362,6 +366,7 @@ impl Protocol {
 			// Introduced after legacy names became legacy.
 			Protocol::AttestedCandidateV2 => None,
 			Protocol::CollationFetchingV2 => None,
+			Protocol::ChunkFetchingV2 => None,
 		}
 	}
 }
@@ -412,6 +417,7 @@ impl ReqProtocolNames {
 		};
 
 		let short_name = match protocol {
+			// V1:
 			Protocol::ChunkFetchingV1 => "/req_chunk/1",
 			Protocol::CollationFetchingV1 => "/req_collation/1",
 			Protocol::PoVFetchingV1 => "/req_pov/1",
@@ -419,8 +425,10 @@ impl ReqProtocolNames {
 			Protocol::StatementFetchingV1 => "/req_statement/1",
 			Protocol::DisputeSendingV1 => "/send_dispute/1",
 
+			// V2:
 			Protocol::CollationFetchingV2 => "/req_collation/2",
 			Protocol::AttestedCandidateV2 => "/req_attested_candidate/2",
+			Protocol::ChunkFetchingV2 => "/req_chunk/2",
 		};
 
 		format!("{}{}", prefix, short_name).into()
diff --git a/polkadot/node/network/protocol/src/request_response/outgoing.rs b/polkadot/node/network/protocol/src/request_response/outgoing.rs
index 96ef4a6ab25dcc13949e6b3dfbc0e8c6856393f5..27f0f34bf8d4ac43080077a964243f8085c1a12b 100644
--- a/polkadot/node/network/protocol/src/request_response/outgoing.rs
+++ b/polkadot/node/network/protocol/src/request_response/outgoing.rs
@@ -16,8 +16,8 @@
 
 use futures::{channel::oneshot, prelude::Future, FutureExt};
 
+use codec::{Decode, Encode, Error as DecodingError};
 use network::ProtocolName;
-use parity_scale_codec::{Decode, Encode, Error as DecodingError};
 
 use sc_network as network;
 use sc_network_types::PeerId;
@@ -30,7 +30,7 @@ use super::{v1, v2, IsRequest, Protocol};
 #[derive(Debug)]
 pub enum Requests {
 	/// Request an availability chunk from a node.
-	ChunkFetchingV1(OutgoingRequest<v1::ChunkFetchingRequest>),
+	ChunkFetching(OutgoingRequest<v2::ChunkFetchingRequest, v1::ChunkFetchingRequest>),
 	/// Fetch a collation from a collator which previously announced it.
 	CollationFetchingV1(OutgoingRequest<v1::CollationFetchingRequest>),
 	/// Fetch a PoV from a validator which previously sent out a seconded statement.
@@ -59,7 +59,7 @@ impl Requests {
 	/// contained in the `enum`.
 	pub fn encode_request(self) -> (Protocol, OutgoingRequest<Vec<u8>>) {
 		match self {
-			Self::ChunkFetchingV1(r) => r.encode_request(),
+			Self::ChunkFetching(r) => r.encode_request(),
 			Self::CollationFetchingV1(r) => r.encode_request(),
 			Self::CollationFetchingV2(r) => r.encode_request(),
 			Self::PoVFetchingV1(r) => r.encode_request(),
@@ -164,24 +164,20 @@ where
 	///
 	/// Returns a raw `Vec<u8>` response over the channel. Use the associated `ProtocolName` to know
 	/// which request was the successful one and appropriately decode the response.
-	// WARNING: This is commented for now because it's not used yet.
-	// If you need it, make sure to test it. You may need to enable the V1 substream upgrade
-	// protocol, unless libp2p was in the meantime updated to a version that fixes the problem
-	// described in https://github.com/libp2p/rust-libp2p/issues/5074
-	// pub fn new_with_fallback(
-	// 	peer: Recipient,
-	// 	payload: Req,
-	// 	fallback_request: FallbackReq,
-	// ) -> (Self, impl Future<Output = OutgoingResult<(Vec<u8>, ProtocolName)>>) {
-	// 	let (tx, rx) = oneshot::channel();
-	// 	let r = Self {
-	// 		peer,
-	// 		payload,
-	// 		pending_response: tx,
-	// 		fallback_request: Some((fallback_request, FallbackReq::PROTOCOL)),
-	// 	};
-	// 	(r, async { Ok(rx.await??) })
-	// }
+	pub fn new_with_fallback(
+		peer: Recipient,
+		payload: Req,
+		fallback_request: FallbackReq,
+	) -> (Self, impl Future<Output = OutgoingResult<(Vec<u8>, ProtocolName)>>) {
+		let (tx, rx) = oneshot::channel();
+		let r = Self {
+			peer,
+			payload,
+			pending_response: tx,
+			fallback_request: Some((fallback_request, FallbackReq::PROTOCOL)),
+		};
+		(r, async { Ok(rx.await??) })
+	}
 
 	/// Encode a request into a `Vec<u8>`.
 	///
diff --git a/polkadot/node/network/protocol/src/request_response/v1.rs b/polkadot/node/network/protocol/src/request_response/v1.rs
index 60eecb69f738912ddb0240c890e2283db7f91a72..80721f1884afd04e7abd0634dc62b3357b2307b4 100644
--- a/polkadot/node/network/protocol/src/request_response/v1.rs
+++ b/polkadot/node/network/protocol/src/request_response/v1.rs
@@ -16,7 +16,7 @@
 
 //! Requests and responses as sent over the wire for the individual protocols.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 use polkadot_node_primitives::{
 	AvailableData, DisputeMessage, ErasureChunk, PoV, Proof, UncheckedDisputeMessage,
@@ -33,7 +33,8 @@ use super::{IsRequest, Protocol};
 pub struct ChunkFetchingRequest {
 	/// Hash of candidate we want a chunk for.
 	pub candidate_hash: CandidateHash,
-	/// The index of the chunk to fetch.
+	/// The validator index we are requesting from. This must be identical to the index of the
+	/// chunk we'll receive. For v2, this may not be the case.
 	pub index: ValidatorIndex,
 }
 
@@ -57,6 +58,15 @@ impl From<Option<ChunkResponse>> for ChunkFetchingResponse {
 	}
 }
 
+impl From<ChunkFetchingResponse> for Option<ChunkResponse> {
+	fn from(x: ChunkFetchingResponse) -> Self {
+		match x {
+			ChunkFetchingResponse::Chunk(c) => Some(c),
+			ChunkFetchingResponse::NoSuchChunk => None,
+		}
+	}
+}
+
 /// Skimmed down variant of `ErasureChunk`.
 ///
 /// Instead of transmitting a full `ErasureChunk` we transmit `ChunkResponse` in
@@ -80,7 +90,7 @@ impl From<ErasureChunk> for ChunkResponse {
 impl ChunkResponse {
 	/// Re-build an `ErasureChunk` from response and request.
 	pub fn recombine_into_chunk(self, req: &ChunkFetchingRequest) -> ErasureChunk {
-		ErasureChunk { chunk: self.chunk, proof: self.proof, index: req.index }
+		ErasureChunk { chunk: self.chunk, proof: self.proof, index: req.index.into() }
 	}
 }
 
diff --git a/polkadot/node/network/protocol/src/request_response/v2.rs b/polkadot/node/network/protocol/src/request_response/v2.rs
index 6b90c579237fbff95496035f461c5cc4c5202984..ae65b39cd406e9f337a1e7d6a1d04468249c22c8 100644
--- a/polkadot/node/network/protocol/src/request_response/v2.rs
+++ b/polkadot/node/network/protocol/src/request_response/v2.rs
@@ -16,14 +16,15 @@
 
 //! Requests and responses as sent over the wire for the individual protocols.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
+use polkadot_node_primitives::ErasureChunk;
 use polkadot_primitives::{
 	CandidateHash, CommittedCandidateReceipt, Hash, Id as ParaId, PersistedValidationData,
-	UncheckedSignedStatement,
+	UncheckedSignedStatement, ValidatorIndex,
 };
 
-use super::{IsRequest, Protocol};
+use super::{v1, IsRequest, Protocol};
 use crate::v2::StatementFilter;
 
 /// Request a candidate with statements.
@@ -78,3 +79,60 @@ impl IsRequest for CollationFetchingRequest {
 	type Response = CollationFetchingResponse;
 	const PROTOCOL: Protocol = Protocol::CollationFetchingV2;
 }
+
+/// Request an availability chunk.
+#[derive(Debug, Copy, Clone, Encode, Decode)]
+pub struct ChunkFetchingRequest {
+	/// Hash of candidate we want a chunk for.
+	pub candidate_hash: CandidateHash,
+	/// The validator index we are requesting from. This may not be identical to the index of the
+	/// chunk we'll receive. It's up to the caller to decide whether they need to validate they got
+	/// the chunk they were expecting.
+	pub index: ValidatorIndex,
+}
+
+/// Receive a requested erasure chunk.
+#[derive(Debug, Clone, Encode, Decode)]
+pub enum ChunkFetchingResponse {
+	/// The requested chunk data.
+	#[codec(index = 0)]
+	Chunk(ErasureChunk),
+	/// Node was not in possession of the requested chunk.
+	#[codec(index = 1)]
+	NoSuchChunk,
+}
+
+impl From<Option<ErasureChunk>> for ChunkFetchingResponse {
+	fn from(x: Option<ErasureChunk>) -> Self {
+		match x {
+			Some(c) => ChunkFetchingResponse::Chunk(c),
+			None => ChunkFetchingResponse::NoSuchChunk,
+		}
+	}
+}
+
+impl From<ChunkFetchingResponse> for Option<ErasureChunk> {
+	fn from(x: ChunkFetchingResponse) -> Self {
+		match x {
+			ChunkFetchingResponse::Chunk(c) => Some(c),
+			ChunkFetchingResponse::NoSuchChunk => None,
+		}
+	}
+}
+
+impl From<v1::ChunkFetchingRequest> for ChunkFetchingRequest {
+	fn from(v1::ChunkFetchingRequest { candidate_hash, index }: v1::ChunkFetchingRequest) -> Self {
+		Self { candidate_hash, index }
+	}
+}
+
+impl From<ChunkFetchingRequest> for v1::ChunkFetchingRequest {
+	fn from(ChunkFetchingRequest { candidate_hash, index }: ChunkFetchingRequest) -> Self {
+		Self { candidate_hash, index }
+	}
+}
+
+impl IsRequest for ChunkFetchingRequest {
+	type Response = ChunkFetchingResponse;
+	const PROTOCOL: Protocol = Protocol::ChunkFetchingV2;
+}
diff --git a/polkadot/node/network/statement-distribution/Cargo.toml b/polkadot/node/network/statement-distribution/Cargo.toml
index 1fe761bd0e3bb4e52d505aae234c750e28ffd1e6..b044acd1a86d372019cd93b1c628601ae43a465d 100644
--- a/polkadot/node/network/statement-distribution/Cargo.toml
+++ b/polkadot/node/network/statement-distribution/Cargo.toml
@@ -22,7 +22,7 @@ polkadot-node-subsystem-util = { path = "../../subsystem-util" }
 polkadot-node-network-protocol = { path = "../protocol" }
 arrayvec = "0.7.4"
 indexmap = "2.0.0"
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 thiserror = { workspace = true }
 fatality = "0.1.1"
 bitvec = "1"
@@ -42,3 +42,13 @@ sc-network = { path = "../../../../substrate/client/network" }
 futures-timer = "3.0.2"
 polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" }
 rand_chacha = "0.3"
+polkadot-subsystem-bench = { path = "../../subsystem-bench" }
+
+[[bench]]
+name = "statement-distribution-regression-bench"
+path = "benches/statement-distribution-regression-bench.rs"
+harness = false
+required-features = ["subsystem-benchmarks"]
+
+[features]
+subsystem-benchmarks = []
diff --git a/polkadot/node/network/statement-distribution/benches/statement-distribution-regression-bench.rs b/polkadot/node/network/statement-distribution/benches/statement-distribution-regression-bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9cbe385e3f42ee5be7dc0e5cda44bdbc92930828
--- /dev/null
+++ b/polkadot/node/network/statement-distribution/benches/statement-distribution-regression-bench.rs
@@ -0,0 +1,74 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! statement-distribution regression tests
+//!
+//! Statement distribution benchmark based on Kusama parameters and scale.
+
+use polkadot_subsystem_bench::{
+	configuration::TestConfiguration,
+	statement::{benchmark_statement_distribution, prepare_test, TestState},
+	usage::BenchmarkUsage,
+	utils::save_to_file,
+};
+use std::io::Write;
+
+const BENCH_COUNT: usize = 50;
+
+fn main() -> Result<(), String> {
+	let mut messages = vec![];
+	let mut config = TestConfiguration::default();
+	config.n_cores = 100;
+	config.n_validators = 500;
+	config.num_blocks = 10;
+	config.connectivity = 100;
+	config.generate_pov_sizes();
+	let state = TestState::new(&config);
+
+	println!("Benchmarking...");
+	let usages: Vec<BenchmarkUsage> = (0..BENCH_COUNT)
+		.map(|n| {
+			print!("\r[{}{}]", "#".repeat(n), "_".repeat(BENCH_COUNT - n));
+			std::io::stdout().flush().unwrap();
+			let (mut env, _cfgs) = prepare_test(&state, false);
+			env.runtime().block_on(benchmark_statement_distribution(&mut env, &state))
+		})
+		.collect();
+	println!("\rDone!{}", " ".repeat(BENCH_COUNT));
+
+	let average_usage = BenchmarkUsage::average(&usages);
+	save_to_file(
+		"charts/statement-distribution-regression-bench.json",
+		average_usage.to_chart_json().map_err(|e| e.to_string())?,
+	)
+	.map_err(|e| e.to_string())?;
+	println!("{}", average_usage);
+
+	// We expect no variance for received and sent
+	// but use 0.001 because we operate with floats
+	messages.extend(average_usage.check_network_usage(&[
+		("Received from peers", 106.4000, 0.001),
+		("Sent to peers", 127.9100, 0.001),
+	]));
+	messages.extend(average_usage.check_cpu_usage(&[("statement-distribution", 0.0390, 0.1)]));
+
+	if messages.is_empty() {
+		Ok(())
+	} else {
+		eprintln!("{}", messages.join("\n"));
+		Err("Regressions found".to_string())
+	}
+}
diff --git a/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs b/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs
index e22883f8937606475efc01225fcd6f98e4ee0f08..264333435a00ed074e0b1b47b96a51ae2e3e4441 100644
--- a/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs
+++ b/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs
@@ -14,8 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
+use codec::Encode;
 use net_protocol::{filter_by_peer_version, peer_set::ProtocolVersion};
-use parity_scale_codec::Encode;
 
 use polkadot_node_network_protocol::{
 	self as net_protocol,
diff --git a/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs b/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs
index d4c5f95034ae8061b81f8019c86fcd44b0530cf5..8e6fcbaebbf1404f123321e2fe7ff3e90d8cf43a 100644
--- a/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs
+++ b/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs
@@ -20,9 +20,9 @@ use super::*;
 use crate::{metrics::Metrics, *};
 
 use assert_matches::assert_matches;
+use codec::{Decode, Encode};
 use futures::executor;
 use futures_timer::Delay;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_node_network_protocol::{
 	grid_topology::{SessionGridTopology, TopologyPeerInfo},
 	peer_set::ValidationVersion,
diff --git a/polkadot/node/network/statement-distribution/src/lib.rs b/polkadot/node/network/statement-distribution/src/lib.rs
index 4ca199c3378bfc80eeee9c5f2985b1ad570e5736..4d56c795f13b29949a7a3b3e7f9bfc85e89ab274 100644
--- a/polkadot/node/network/statement-distribution/src/lib.rs
+++ b/polkadot/node/network/statement-distribution/src/lib.rs
@@ -19,7 +19,6 @@
 //! This is responsible for distributing signed statements about candidate
 //! validity among validators.
 
-#![deny(unused_crate_dependencies)]
 #![warn(missing_docs)]
 
 use error::{log_error, FatalResult};
diff --git a/polkadot/node/network/statement-distribution/src/v2/cluster.rs b/polkadot/node/network/statement-distribution/src/v2/cluster.rs
index c3f45314b2464e1125a797686c51827e022b0403..26d7a68eb2a74256c8fd73cc684bde80995db291 100644
--- a/polkadot/node/network/statement-distribution/src/v2/cluster.rs
+++ b/polkadot/node/network/statement-distribution/src/v2/cluster.rs
@@ -60,13 +60,6 @@ use polkadot_primitives::{CandidateHash, CompactStatement, Hash, ValidatorIndex}
 use crate::LOG_TARGET;
 use std::collections::{HashMap, HashSet};
 
-#[derive(Hash, PartialEq, Eq)]
-struct ValidStatementManifest {
-	remote: ValidatorIndex,
-	originator: ValidatorIndex,
-	candidate_hash: CandidateHash,
-}
-
 // A piece of knowledge about a candidate
 #[derive(Hash, Clone, PartialEq, Eq)]
 enum Knowledge {
@@ -436,7 +429,9 @@ impl ClusterTracker {
 
 	pub fn warn_if_too_many_pending_statements(&self, parent_hash: Hash) {
 		if self.pending.iter().filter(|pending| !pending.1.is_empty()).count() >=
-			self.validators.len()
+			self.validators.len() &&
+			// No reason to warn if we are the only node in the cluster.
+			self.validators.len() > 1
 		{
 			gum::warn!(
 				target: LOG_TARGET,
diff --git a/polkadot/node/network/statement-distribution/src/v2/mod.rs b/polkadot/node/network/statement-distribution/src/v2/mod.rs
index 961ec45bdada037885fb5ea43858e4e1522fac2c..2bb9c82c6a6fa00a84b5274a12f7e79398ca89f3 100644
--- a/polkadot/node/network/statement-distribution/src/v2/mod.rs
+++ b/polkadot/node/network/statement-distribution/src/v2/mod.rs
@@ -68,7 +68,7 @@ use futures::{
 use std::{
 	collections::{
 		hash_map::{Entry, HashMap},
-		BTreeSet, HashSet,
+		HashSet,
 	},
 	time::{Duration, Instant},
 };
@@ -156,6 +156,7 @@ struct PerRelayParentState {
 	seconding_limit: usize,
 	session: SessionIndex,
 	groups_per_para: HashMap<ParaId, Vec<GroupIndex>>,
+	disabled_validators: HashSet<ValidatorIndex>,
 }
 
 impl PerRelayParentState {
@@ -166,6 +167,17 @@ impl PerRelayParentState {
 	fn active_validator_state_mut(&mut self) -> Option<&mut ActiveValidatorState> {
 		self.local_validator.as_mut().and_then(|local| local.active.as_mut())
 	}
+
+	/// Returns `true` if the given validator is disabled in the context of the relay parent.
+	pub fn is_disabled(&self, validator_index: &ValidatorIndex) -> bool {
+		self.disabled_validators.contains(validator_index)
+	}
+
+	/// A convenience function to generate a disabled bitmask for the given backing group.
+	/// The output bits are set to `true` for validators that are disabled.
+	pub fn disabled_bitmask(&self, group: &[ValidatorIndex]) -> BitVec<u8, Lsb0> {
+		BitVec::from_iter(group.iter().map(|v| self.is_disabled(v)))
+	}
 }
 
 // per-relay-parent local validator state.
@@ -183,8 +195,8 @@ struct ActiveValidatorState {
 	index: ValidatorIndex,
 	// our validator group
 	group: GroupIndex,
-	// the assignment of our validator group, if any.
-	assignment: Option<ParaId>,
+	// the assignments of our validator group, if any.
+	assignments: Vec<ParaId>,
 	// the 'direct-in-group' communication at this relay-parent.
 	cluster_tracker: ClusterTracker,
 }
@@ -206,8 +218,6 @@ struct PerSessionState {
 	// getting the topology from the gossip-support subsystem
 	grid_view: Option<grid::SessionTopologyView>,
 	local_validator: Option<LocalValidatorIndex>,
-	// We store the latest state here based on union of leaves.
-	disabled_validators: BTreeSet<ValidatorIndex>,
 }
 
 impl PerSessionState {
@@ -224,16 +234,7 @@ impl PerSessionState {
 		)
 		.map(|(_, index)| LocalValidatorIndex::Active(index));
 
-		let disabled_validators = BTreeSet::new();
-
-		PerSessionState {
-			session_info,
-			groups,
-			authority_lookup,
-			grid_view: None,
-			local_validator,
-			disabled_validators,
-		}
+		PerSessionState { session_info, groups, authority_lookup, grid_view: None, local_validator }
 	}
 
 	fn supply_topology(
@@ -269,33 +270,6 @@ impl PerSessionState {
 	fn is_not_validator(&self) -> bool {
 		self.grid_view.is_some() && self.local_validator.is_none()
 	}
-
-	/// A convenience function to generate a disabled bitmask for the given backing group.
-	/// The output bits are set to `true` for validators that are disabled.
-	/// Returns `None` if the group index is out of bounds.
-	pub fn disabled_bitmask(&self, group: GroupIndex) -> Option<BitVec<u8, Lsb0>> {
-		let group = self.groups.get(group)?;
-		let mask = BitVec::from_iter(group.iter().map(|v| self.is_disabled(v)));
-		Some(mask)
-	}
-
-	/// Returns `true` if the given validator is disabled in the current session.
-	pub fn is_disabled(&self, validator_index: &ValidatorIndex) -> bool {
-		self.disabled_validators.contains(validator_index)
-	}
-
-	/// Extend the list of disabled validators.
-	pub fn extend_disabled_validators(
-		&mut self,
-		disabled: impl IntoIterator<Item = ValidatorIndex>,
-	) {
-		self.disabled_validators.extend(disabled);
-	}
-
-	/// Clear the list of disabled validators.
-	pub fn clear_disabled_validators(&mut self) {
-		self.disabled_validators.clear();
-	}
 }
 
 pub(crate) struct State {
@@ -582,19 +556,16 @@ pub(crate) async fn handle_active_leaves_update<Context>(
 	let new_relay_parents =
 		state.implicit_view.all_allowed_relay_parents().cloned().collect::<Vec<_>>();
 
-	// We clear the list of disabled validators to reset it properly based on union of leaves.
-	let mut cleared_disabled_validators: BTreeSet<SessionIndex> = BTreeSet::new();
-
 	for new_relay_parent in new_relay_parents.iter().cloned() {
-		// Even if we processed this relay parent before, we need to fetch the list of disabled
-		// validators based on union of active leaves.
-		let disabled_validators =
+		let disabled_validators: HashSet<_> =
 			polkadot_node_subsystem_util::vstaging::get_disabled_validators_with_fallback(
 				ctx.sender(),
 				new_relay_parent,
 			)
 			.await
-			.map_err(JfyiError::FetchDisabledValidators)?;
+			.map_err(JfyiError::FetchDisabledValidators)?
+			.into_iter()
+			.collect();
 
 		let session_index = polkadot_node_subsystem_util::request_session_index_for_child(
 			new_relay_parent,
@@ -644,10 +615,6 @@ pub(crate) async fn handle_active_leaves_update<Context>(
 			.get_mut(&session_index)
 			.expect("either existed or just inserted; qed");
 
-		if cleared_disabled_validators.insert(session_index) {
-			per_session.clear_disabled_validators();
-		}
-
 		if !disabled_validators.is_empty() {
 			gum::debug!(
 				target: LOG_TARGET,
@@ -656,8 +623,6 @@ pub(crate) async fn handle_active_leaves_update<Context>(
 				?disabled_validators,
 				"Disabled validators detected"
 			);
-
-			per_session.extend_disabled_validators(disabled_validators);
 		}
 
 		if state.per_relay_parent.contains_key(&new_relay_parent) {
@@ -723,6 +688,7 @@ pub(crate) async fn handle_active_leaves_update<Context>(
 				seconding_limit,
 				session: session_index,
 				groups_per_para,
+				disabled_validators,
 			},
 		);
 	}
@@ -774,8 +740,8 @@ fn find_active_validator_state(
 	let our_group = groups.by_validator_index(validator_index)?;
 
 	let core_index = group_rotation_info.core_for_group(our_group, availability_cores.len());
-	let para_assigned_to_core = if let Some(claim_queue) = maybe_claim_queue {
-		claim_queue.get_claim_for(core_index, 0)
+	let paras_assigned_to_core = if let Some(claim_queue) = maybe_claim_queue {
+		claim_queue.iter_claims_for_core(&core_index).copied().collect()
 	} else {
 		availability_cores
 			.get(core_index.0 as usize)
@@ -787,6 +753,8 @@ fn find_active_validator_state(
 					.map(|scheduled_core| scheduled_core.para_id),
 				CoreState::Free | CoreState::Occupied(_) => None,
 			})
+			.into_iter()
+			.collect()
 	};
 	let group_validators = groups.get(our_group)?.to_owned();
 
@@ -794,7 +762,7 @@ fn find_active_validator_state(
 		active: Some(ActiveValidatorState {
 			index: validator_index,
 			group: our_group,
-			assignment: para_assigned_to_core,
+			assignments: paras_assigned_to_core,
 			cluster_tracker: ClusterTracker::new(group_validators, seconding_limit)
 				.expect("group is non-empty because we are in it; qed"),
 		}),
@@ -1196,10 +1164,10 @@ pub(crate) async fn share_local_statement<Context>(
 		None => return Ok(()),
 	};
 
-	let (local_index, local_assignment, local_group) =
+	let (local_index, local_assignments, local_group) =
 		match per_relay_parent.active_validator_state() {
 			None => return Err(JfyiError::InvalidShare),
-			Some(l) => (l.index, l.assignment, l.group),
+			Some(l) => (l.index, &l.assignments, l.group),
 		};
 
 	// Two possibilities: either the statement is `Seconded` or we already
@@ -1237,7 +1205,7 @@ pub(crate) async fn share_local_statement<Context>(
 		return Err(JfyiError::InvalidShare)
 	}
 
-	if local_assignment != Some(expected_para) || relay_parent != expected_relay_parent {
+	if !local_assignments.contains(&expected_para) || relay_parent != expected_relay_parent {
 		return Err(JfyiError::InvalidShare)
 	}
 
@@ -1581,6 +1549,17 @@ async fn handle_incoming_statement<Context>(
 	};
 	let session_info = &per_session.session_info;
 
+	if per_relay_parent.is_disabled(&statement.unchecked_validator_index()) {
+		gum::debug!(
+			target: LOG_TARGET,
+			?relay_parent,
+			validator_index = ?statement.unchecked_validator_index(),
+			"Ignoring a statement from disabled validator."
+		);
+		modify_reputation(reputation, ctx.sender(), peer, COST_DISABLED_VALIDATOR).await;
+		return
+	}
+
 	let local_validator = match per_relay_parent.local_validator.as_mut() {
 		None => {
 			// we shouldn't be receiving statements unless we're a validator
@@ -1614,17 +1593,6 @@ async fn handle_incoming_statement<Context>(
 			},
 		};
 
-	if per_session.is_disabled(&statement.unchecked_validator_index()) {
-		gum::debug!(
-			target: LOG_TARGET,
-			?relay_parent,
-			validator_index = ?statement.unchecked_validator_index(),
-			"Ignoring a statement from disabled validator."
-		);
-		modify_reputation(reputation, ctx.sender(), peer, COST_DISABLED_VALIDATOR).await;
-		return
-	}
-
 	let (active, cluster_sender_index) = {
 		// This block of code only returns `Some` when both the originator and
 		// the sending peer are in the cluster.
@@ -2178,12 +2146,11 @@ async fn determine_groups_per_para(
 	let n_cores = availability_cores.len();
 
 	// Determine the core indices occupied by each para at the current relay parent. To support
-	// on-demand parachains we also consider the core indices at next block if core has a candidate
-	// pending availability.
-	let para_core_indices: Vec<_> = if let Some(claim_queue) = maybe_claim_queue {
+	// on-demand parachains we also consider the core indices at next blocks.
+	let schedule: HashMap<CoreIndex, Vec<ParaId>> = if let Some(claim_queue) = maybe_claim_queue {
 		claim_queue
-			.iter_claims_at_depth(0)
-			.map(|(core_index, para)| (para, core_index))
+			.iter_all_claims()
+			.map(|(core_index, paras)| (*core_index, paras.iter().copied().collect()))
 			.collect()
 	} else {
 		availability_cores
@@ -2191,12 +2158,12 @@ async fn determine_groups_per_para(
 			.enumerate()
 			.filter_map(|(index, core)| match core {
 				CoreState::Scheduled(scheduled_core) =>
-					Some((scheduled_core.para_id, CoreIndex(index as u32))),
+					Some((CoreIndex(index as u32), vec![scheduled_core.para_id])),
 				CoreState::Occupied(occupied_core) =>
 					if max_candidate_depth >= 1 {
-						occupied_core
-							.next_up_on_available
-							.map(|scheduled_core| (scheduled_core.para_id, CoreIndex(index as u32)))
+						occupied_core.next_up_on_available.map(|scheduled_core| {
+							(CoreIndex(index as u32), vec![scheduled_core.para_id])
+						})
 					} else {
 						None
 					},
@@ -2207,9 +2174,12 @@ async fn determine_groups_per_para(
 
 	let mut groups_per_para = HashMap::new();
 	// Map from `CoreIndex` to `GroupIndex` and collect as `HashMap`.
-	for (para, core_index) in para_core_indices {
+	for (core_index, paras) in schedule {
 		let group_index = group_rotation_info.group_for_core(core_index, n_cores);
-		groups_per_para.entry(para).or_insert_with(Vec::new).push(group_index)
+
+		for para in paras {
+			groups_per_para.entry(para).or_insert_with(Vec::new).push(group_index);
+		}
 	}
 
 	groups_per_para
@@ -2379,21 +2349,18 @@ async fn handle_incoming_manifest_common<'a, Context>(
 		Some(s) => s,
 	};
 
-	let local_validator = match relay_parent_state.local_validator.as_mut() {
-		None => {
-			if per_session.is_not_validator() {
-				modify_reputation(
-					reputation,
-					ctx.sender(),
-					peer,
-					COST_UNEXPECTED_MANIFEST_MISSING_KNOWLEDGE,
-				)
-				.await;
-			}
-			return None
-		},
-		Some(x) => x,
-	};
+	if relay_parent_state.local_validator.is_none() {
+		if per_session.is_not_validator() {
+			modify_reputation(
+				reputation,
+				ctx.sender(),
+				peer,
+				COST_UNEXPECTED_MANIFEST_MISSING_KNOWLEDGE,
+			)
+			.await;
+		}
+		return None
+	}
 
 	let Some(expected_groups) = relay_parent_state.groups_per_para.get(&para_id) else {
 		modify_reputation(reputation, ctx.sender(), peer, COST_MALFORMED_MANIFEST).await;
@@ -2436,10 +2403,13 @@ async fn handle_incoming_manifest_common<'a, Context>(
 	let claimed_parent_hash = manifest_summary.claimed_parent_hash;
 
 	// Ignore votes from disabled validators when counting towards the threshold.
-	let disabled_mask = per_session.disabled_bitmask(group_index).unwrap_or_default();
+	let group = per_session.groups.get(group_index).unwrap_or(&[]);
+	let disabled_mask = relay_parent_state.disabled_bitmask(group);
 	manifest_summary.statement_knowledge.mask_seconded(&disabled_mask);
 	manifest_summary.statement_knowledge.mask_valid(&disabled_mask);
 
+	let local_validator = relay_parent_state.local_validator.as_mut().expect("checked above; qed");
+
 	let acknowledge = match local_validator.grid_tracker.import_manifest(
 		grid_topology,
 		&per_session.groups,
@@ -3018,9 +2988,7 @@ pub(crate) async fn dispatch_requests<Context>(ctx: &mut Context, state: &mut St
 		}
 
 		// Add disabled validators to the unwanted mask.
-		let disabled_mask = per_session
-			.disabled_bitmask(group_index)
-			.expect("group existence checked above; qed");
+		let disabled_mask = relay_parent_state.disabled_bitmask(group);
 		unwanted_mask.seconded_in_group |= &disabled_mask;
 		unwanted_mask.validated_in_group |= &disabled_mask;
 
@@ -3111,9 +3079,7 @@ pub(crate) async fn handle_response<Context>(
 			Some(g) => g,
 		};
 
-		let disabled_mask = per_session
-			.disabled_bitmask(group_index)
-			.expect("group_index checked above; qed");
+		let disabled_mask = relay_parent_state.disabled_bitmask(group);
 
 		let res = response.validate_response(
 			&mut state.request_manager,
@@ -3258,7 +3224,7 @@ pub(crate) fn answer_request(state: &mut State, message: ResponderMessage) {
 		Some(s) => s,
 	};
 
-	let local_validator = match relay_parent_state.local_validator.as_mut() {
+	let local_validator = match relay_parent_state.local_validator.as_ref() {
 		None => return,
 		Some(s) => s,
 	};
@@ -3332,16 +3298,15 @@ pub(crate) fn answer_request(state: &mut State, message: ResponderMessage) {
 
 	// Transform mask with 'OR' semantics into one with 'AND' semantics for the API used
 	// below.
-	let mut and_mask = StatementFilter {
+	let and_mask = StatementFilter {
 		seconded_in_group: !mask.seconded_in_group.clone(),
 		validated_in_group: !mask.validated_in_group.clone(),
 	};
 
-	// Ignore disabled validators from the latest state when sending the response.
-	let disabled_mask =
-		per_session.disabled_bitmask(group_index).expect("group existence checked; qed");
-	and_mask.mask_seconded(&disabled_mask);
-	and_mask.mask_valid(&disabled_mask);
+	let local_validator = match relay_parent_state.local_validator.as_mut() {
+		None => return,
+		Some(s) => s,
+	};
 
 	let mut sent_filter = StatementFilter::blank(group_size);
 	let statements: Vec<_> = relay_parent_state
diff --git a/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs b/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs
index d32e2323ba346b3001677b7951d4257e6a18752e..119dc832d13a197c7e76c95c898c5f49e21b299f 100644
--- a/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs
+++ b/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs
@@ -44,8 +44,8 @@ use sp_authority_discovery::AuthorityPair as AuthorityDiscoveryPair;
 use sp_keyring::Sr25519Keyring;
 
 use assert_matches::assert_matches;
+use codec::Encode;
 use futures::Future;
-use parity_scale_codec::Encode;
 use rand::{Rng, SeedableRng};
 use test_helpers::mock::new_leaf;
 
@@ -55,7 +55,8 @@ mod cluster;
 mod grid;
 mod requests;
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<StatementDistributionMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<StatementDistributionMessage>;
 
 const DEFAULT_ASYNC_BACKING_PARAMETERS: AsyncBackingParams =
 	AsyncBackingParams { max_candidate_depth: 4, allowed_ancestry_len: 3 };
@@ -371,7 +372,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 
 	let test_state = TestState::from_config(config, req_cfg.inbound_queue.unwrap(), &mut rng);
 
-	let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone());
+	let (context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone());
 	let subsystem = async move {
 		let subsystem = crate::StatementDistributionSubsystem {
 			keystore,
@@ -422,7 +424,7 @@ struct TestLeaf {
 	parent_hash: Hash,
 	session: SessionIndex,
 	availability_cores: Vec<CoreState>,
-	disabled_validators: Vec<ValidatorIndex>,
+	pub disabled_validators: Vec<ValidatorIndex>,
 	para_data: Vec<(ParaId, PerParaData)>,
 	minimum_backing_votes: u32,
 }
@@ -586,19 +588,6 @@ async fn handle_leaf_activation(
 		}
 	);
 
-	let mrp_response: Vec<(ParaId, BlockNumber)> = para_data
-		.iter()
-		.map(|(para_id, data)| (*para_id, data.min_relay_parent))
-		.collect();
-	assert_matches!(
-		virtual_overseer.recv().await,
-		AllMessages::ProspectiveParachains(
-			ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx)
-		) if parent == *hash => {
-			tx.send(mrp_response).unwrap();
-		}
-	);
-
 	let header = Header {
 		parent_hash: *parent_hash,
 		number: *number,
@@ -615,6 +604,19 @@ async fn handle_leaf_activation(
 		}
 	);
 
+	let mrp_response: Vec<(ParaId, BlockNumber)> = para_data
+		.iter()
+		.map(|(para_id, data)| (*para_id, data.min_relay_parent))
+		.collect();
+	assert_matches!(
+		virtual_overseer.recv().await,
+		AllMessages::ProspectiveParachains(
+			ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx)
+		) if parent == *hash => {
+			tx.send(mrp_response).unwrap();
+		}
+	);
+
 	loop {
 		match virtual_overseer.recv().await {
 			AllMessages::RuntimeApi(RuntimeApiMessage::Request(
diff --git a/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs b/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs
index 38d7a10b86527c153f4a369beb8bbe86da05d582..dcb90bacdcde2cfcff065396cb353b95fa504e7c 100644
--- a/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs
+++ b/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs
@@ -17,14 +17,13 @@
 use super::*;
 
 use bitvec::order::Lsb0;
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_node_network_protocol::{
 	request_response::v2 as request_v2, v2::BackedCandidateManifest,
 };
 use polkadot_primitives_test_helpers::make_candidate;
-use sc_network::{
-	config::{IncomingRequest as RawIncomingRequest, OutgoingResponse as RawOutgoingResponse},
-	ProtocolName,
+use sc_network::config::{
+	IncomingRequest as RawIncomingRequest, OutgoingResponse as RawOutgoingResponse,
 };
 
 #[test]
@@ -1222,392 +1221,8 @@ fn disabled_validators_added_to_unwanted_mask() {
 	});
 }
 
-// We send a request to a peer and after receiving the response
-// we learn about a validator being disabled. We should filter out
-// the statement from the disabled validator when receiving it.
 #[test]
-fn when_validator_disabled_after_sending_the_request() {
-	let group_size = 3;
-	let config = TestConfig {
-		validator_count: 20,
-		group_size,
-		local_validator: LocalRole::Validator,
-		async_backing_params: None,
-	};
-
-	let relay_parent = Hash::repeat_byte(1);
-	let another_relay_parent = Hash::repeat_byte(2);
-	let peer_disabled_later = PeerId::random();
-	let peer_b = PeerId::random();
-
-	test_harness(config, |state, mut overseer| async move {
-		let local_validator = state.local.clone().unwrap();
-		let local_group_index = local_validator.group_index.unwrap();
-		let local_para = ParaId::from(local_group_index.0);
-		let other_group_validators = state.group_validators(local_group_index, true);
-		let index_disabled = other_group_validators[0];
-		let index_b = other_group_validators[1];
-
-		let test_leaf = state.make_dummy_leaf_with_disabled_validators(relay_parent, vec![]);
-		let test_leaf_disabled = state
-			.make_dummy_leaf_with_disabled_validators(another_relay_parent, vec![index_disabled]);
-
-		let (candidate, pvd) = make_candidate(
-			relay_parent,
-			1,
-			local_para,
-			test_leaf.para_data(local_para).head_data.clone(),
-			vec![4, 5, 6].into(),
-			Hash::repeat_byte(42).into(),
-		);
-		let candidate_hash = candidate.hash();
-
-		// peer A is in group, has relay parent in view and disabled later.
-		// peer B is in group, has relay parent in view.
-		{
-			connect_peer(
-				&mut overseer,
-				peer_disabled_later.clone(),
-				Some(vec![state.discovery_id(index_disabled)].into_iter().collect()),
-			)
-			.await;
-			connect_peer(
-				&mut overseer,
-				peer_b.clone(),
-				Some(vec![state.discovery_id(index_b)].into_iter().collect()),
-			)
-			.await;
-			send_peer_view_change(&mut overseer, peer_disabled_later.clone(), view![relay_parent])
-				.await;
-			send_peer_view_change(&mut overseer, peer_b.clone(), view![relay_parent]).await;
-		}
-
-		activate_leaf(&mut overseer, &test_leaf, &state, true, vec![]).await;
-
-		let seconded_disabled = state
-			.sign_statement(
-				index_disabled,
-				CompactStatement::Seconded(candidate_hash),
-				&SigningContext { parent_hash: relay_parent, session_index: 1 },
-			)
-			.as_unchecked()
-			.clone();
-
-		let seconded_b = state
-			.sign_statement(
-				index_b,
-				CompactStatement::Seconded(candidate_hash),
-				&SigningContext { parent_hash: relay_parent, session_index: 1 },
-			)
-			.as_unchecked()
-			.clone();
-		{
-			send_peer_message(
-				&mut overseer,
-				peer_b.clone(),
-				protocol_v2::StatementDistributionMessage::Statement(
-					relay_parent,
-					seconded_b.clone(),
-				),
-			)
-			.await;
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
-					if p == peer_b && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { }
-			);
-		}
-
-		// Send a request to peer and activate leaf when a validator is disabled;
-		// mock the response with a statement from disabled validator.
-		{
-			let statements = vec![seconded_disabled];
-			let mask = StatementFilter::blank(group_size);
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendRequests(mut requests, IfDisconnected::ImmediateError)) => {
-					assert_eq!(requests.len(), 1);
-					assert_matches!(
-						requests.pop().unwrap(),
-						Requests::AttestedCandidateV2(outgoing) => {
-							assert_eq!(outgoing.peer, Recipient::Peer(peer_b));
-							assert_eq!(outgoing.payload.candidate_hash, candidate_hash);
-							assert_eq!(outgoing.payload.mask, mask);
-
-							activate_leaf(&mut overseer, &test_leaf_disabled, &state, false, vec![]).await;
-
-							let res = AttestedCandidateResponse {
-								candidate_receipt: candidate,
-								persisted_validation_data: pvd,
-								statements,
-							};
-							outgoing.pending_response.send(Ok((res.encode(), ProtocolName::from("")))).unwrap();
-						}
-					);
-				}
-			);
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
-					if p == peer_b && r == BENEFIT_VALID_RESPONSE.into() => { }
-			);
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages:: NetworkBridgeTx(
-					NetworkBridgeTxMessage::SendValidationMessage(
-						peers,
-						Versioned::V2(
-							protocol_v2::ValidationProtocol::StatementDistribution(
-								protocol_v2::StatementDistributionMessage::Statement(hash, statement),
-							),
-						),
-					)
-				) => {
-					assert_eq!(peers, vec![peer_disabled_later]);
-					assert_eq!(hash, relay_parent);
-					assert_eq!(statement, seconded_b);
-				}
-			);
-			answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await;
-		}
-
-		overseer
-	});
-}
-
-#[test]
-fn no_response_for_grid_request_not_meeting_quorum() {
-	let validator_count = 6;
-	let group_size = 3;
-	let config = TestConfig {
-		validator_count,
-		group_size,
-		local_validator: LocalRole::Validator,
-		async_backing_params: None,
-	};
-
-	let relay_parent = Hash::repeat_byte(1);
-	let peer_a = PeerId::random();
-	let peer_b = PeerId::random();
-	let peer_c = PeerId::random();
-
-	test_harness(config, |mut state, mut overseer| async move {
-		let local_validator = state.local.clone().unwrap();
-		let local_group_index = local_validator.group_index.unwrap();
-		let local_para = ParaId::from(local_group_index.0);
-
-		let test_leaf = state.make_dummy_leaf_with_min_backing_votes(relay_parent, 2);
-
-		let (candidate, pvd) = make_candidate(
-			relay_parent,
-			1,
-			local_para,
-			test_leaf.para_data(local_para).head_data.clone(),
-			vec![4, 5, 6].into(),
-			Hash::repeat_byte(42).into(),
-		);
-		let candidate_hash = candidate.hash();
-
-		let other_group_validators = state.group_validators(local_group_index, true);
-		let target_group_validators =
-			state.group_validators((local_group_index.0 + 1).into(), true);
-		let v_a = other_group_validators[0];
-		let v_b = other_group_validators[1];
-		let v_c = target_group_validators[0];
-
-		// peer A is in group, has relay parent in view.
-		// peer B is in group, has no relay parent in view.
-		// peer C is not in group, has relay parent in view.
-		{
-			connect_peer(
-				&mut overseer,
-				peer_a.clone(),
-				Some(vec![state.discovery_id(v_a)].into_iter().collect()),
-			)
-			.await;
-
-			connect_peer(
-				&mut overseer,
-				peer_b.clone(),
-				Some(vec![state.discovery_id(v_b)].into_iter().collect()),
-			)
-			.await;
-
-			connect_peer(
-				&mut overseer,
-				peer_c.clone(),
-				Some(vec![state.discovery_id(v_c)].into_iter().collect()),
-			)
-			.await;
-
-			send_peer_view_change(&mut overseer, peer_a.clone(), view![relay_parent]).await;
-			send_peer_view_change(&mut overseer, peer_c.clone(), view![relay_parent]).await;
-		}
-
-		activate_leaf(&mut overseer, &test_leaf, &state, true, vec![]).await;
-
-		// Send gossip topology.
-		send_new_topology(&mut overseer, state.make_dummy_topology()).await;
-
-		// Confirm the candidate locally so that we don't send out requests.
-		{
-			let statement = state
-				.sign_full_statement(
-					local_validator.validator_index,
-					Statement::Seconded(candidate.clone()),
-					&SigningContext { parent_hash: relay_parent, session_index: 1 },
-					pvd.clone(),
-				)
-				.clone();
-
-			overseer
-				.send(FromOrchestra::Communication {
-					msg: StatementDistributionMessage::Share(relay_parent, statement),
-				})
-				.await;
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a]
-			);
-
-			answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await;
-		}
-
-		// Send enough statements to make candidate backable, make sure announcements are sent.
-
-		// Send statement from peer A.
-		{
-			let statement = state
-				.sign_statement(
-					v_a,
-					CompactStatement::Seconded(candidate_hash),
-					&SigningContext { parent_hash: relay_parent, session_index: 1 },
-				)
-				.as_unchecked()
-				.clone();
-
-			send_peer_message(
-				&mut overseer,
-				peer_a.clone(),
-				protocol_v2::StatementDistributionMessage::Statement(relay_parent, statement),
-			)
-			.await;
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
-					if p == peer_a && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { }
-			);
-		}
-
-		// Send statement from peer B.
-		let statement_b = state
-			.sign_statement(
-				v_b,
-				CompactStatement::Seconded(candidate_hash),
-				&SigningContext { parent_hash: relay_parent, session_index: 1 },
-			)
-			.as_unchecked()
-			.clone();
-		{
-			send_peer_message(
-				&mut overseer,
-				peer_b.clone(),
-				protocol_v2::StatementDistributionMessage::Statement(
-					relay_parent,
-					statement_b.clone(),
-				),
-			)
-			.await;
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
-					if p == peer_b && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { }
-			);
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a]
-			);
-		}
-
-		// Send Backed notification.
-		{
-			overseer
-				.send(FromOrchestra::Communication {
-					msg: StatementDistributionMessage::Backed(candidate_hash),
-				})
-				.await;
-
-			assert_matches!(
-				overseer.recv().await,
-				AllMessages:: NetworkBridgeTx(
-					NetworkBridgeTxMessage::SendValidationMessage(
-						peers,
-						Versioned::V2(
-							protocol_v2::ValidationProtocol::StatementDistribution(
-								protocol_v2::StatementDistributionMessage::BackedCandidateManifest(manifest),
-							),
-						),
-					)
-				) => {
-					assert_eq!(peers, vec![peer_c]);
-					assert_eq!(manifest, BackedCandidateManifest {
-						relay_parent,
-						candidate_hash,
-						group_index: local_validator.group_index.unwrap(),
-						para_id: local_para,
-						parent_head_data_hash: pvd.parent_head.hash(),
-						statement_knowledge: StatementFilter {
-							seconded_in_group: bitvec::bitvec![u8, Lsb0; 1, 1, 1],
-							validated_in_group: bitvec::bitvec![u8, Lsb0; 0, 0, 0],
-						},
-					});
-				}
-			);
-
-			answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await;
-		}
-
-		let mask = StatementFilter {
-			seconded_in_group: bitvec::bitvec![u8, Lsb0; 0, 0, 1],
-			validated_in_group: bitvec::bitvec![u8, Lsb0; 0, 0, 0],
-		};
-
-		let relay_2 = Hash::repeat_byte(2);
-		let disabled_validators = vec![v_a];
-		let leaf_2 = state.make_dummy_leaf_with_disabled_validators(relay_2, disabled_validators);
-		activate_leaf(&mut overseer, &leaf_2, &state, false, vec![]).await;
-
-		// Incoming request to local node. Local node should not send the response as v_a is
-		// disabled and hence the quorum is not reached.
-		{
-			let response = state
-				.send_request(
-					peer_c,
-					request_v2::AttestedCandidateRequest { candidate_hash: candidate.hash(), mask },
-				)
-				.await
-				.await;
-
-			assert!(
-				response.is_none(),
-				"We should not send a response as the quorum is not reached yet"
-			);
-		}
-
-		overseer
-	});
-}
-
-#[test]
-fn disabling_works_from_the_latest_state_not_relay_parent() {
+fn disabling_works_from_relay_parent_not_the_latest_state() {
 	let group_size = 3;
 	let config = TestConfig {
 		validator_count: 20,
@@ -1642,7 +1257,7 @@ fn disabling_works_from_the_latest_state_not_relay_parent() {
 		);
 		let candidate_1_hash = candidate_1.hash();
 
-		let (candidate_2, _) = make_candidate(
+		let (candidate_2, pvd_2) = make_candidate(
 			relay_1,
 			1,
 			local_para,
@@ -1652,6 +1267,16 @@ fn disabling_works_from_the_latest_state_not_relay_parent() {
 		);
 		let candidate_2_hash = candidate_2.hash();
 
+		let (candidate_3, _) = make_candidate(
+			relay_2,
+			1,
+			local_para,
+			leaf_1.para_data(local_para).head_data.clone(),
+			vec![4, 5, 6, 7].into(),
+			Hash::repeat_byte(42).into(),
+		);
+		let candidate_3_hash = candidate_3.hash();
+
 		{
 			connect_peer(
 				&mut overseer,
@@ -1681,6 +1306,16 @@ fn disabling_works_from_the_latest_state_not_relay_parent() {
 			)
 			.as_unchecked()
 			.clone();
+
+		let seconded_3 = state
+			.sign_statement(
+				index_disabled,
+				CompactStatement::Seconded(candidate_3_hash),
+				&SigningContext { parent_hash: relay_2, session_index: 1 },
+			)
+			.as_unchecked()
+			.clone();
+
 		{
 			send_peer_message(
 				&mut overseer,
@@ -1733,6 +1368,48 @@ fn disabling_works_from_the_latest_state_not_relay_parent() {
 			)
 			.await;
 
+			assert_matches!(
+				overseer.recv().await,
+				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
+					if p == peer_disabled && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { }
+			);
+		}
+
+		{
+			handle_sent_request(
+				&mut overseer,
+				peer_disabled,
+				candidate_2_hash,
+				StatementFilter::blank(group_size),
+				candidate_2.clone(),
+				pvd_2.clone(),
+				vec![seconded_2.clone()],
+			)
+			.await;
+
+			assert_matches!(
+				overseer.recv().await,
+				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
+					if p == peer_disabled && r == BENEFIT_VALID_STATEMENT.into() => { }
+			);
+
+			assert_matches!(
+				overseer.recv().await,
+				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
+					if p == peer_disabled && r == BENEFIT_VALID_RESPONSE.into() => { }
+			);
+
+			answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await;
+		}
+
+		{
+			send_peer_message(
+				&mut overseer,
+				peer_disabled.clone(),
+				protocol_v2::StatementDistributionMessage::Statement(relay_2, seconded_3.clone()),
+			)
+			.await;
+
 			assert_matches!(
 				overseer.recv().await,
 				AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r)))
diff --git a/polkadot/node/overseer/Cargo.toml b/polkadot/node/overseer/Cargo.toml
index ef79cfe2f702bb2b32c7901448da5e1b073c0b72..e77cead4a7565de9afd71d484c57e9fddc4e2d00 100644
--- a/polkadot/node/overseer/Cargo.toml
+++ b/polkadot/node/overseer/Cargo.toml
@@ -10,7 +10,7 @@ description = "System overseer of the Polkadot node"
 workspace = true
 
 [dependencies]
-client = { package = "sc-client-api", path = "../../../substrate/client/api" }
+sc-client-api = { path = "../../../substrate/client/api" }
 sp-api = { path = "../../../substrate/primitives/api" }
 futures = "0.3.30"
 futures-timer = "3.0.2"
@@ -32,8 +32,8 @@ sp-core = { path = "../../../substrate/primitives/core" }
 futures = { version = "0.3.30", features = ["thread-pool"] }
 femme = "2.2.1"
 assert_matches = "1.4.0"
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" }
-node-test-helpers = { package = "polkadot-node-subsystem-test-helpers", path = "../subsystem-test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" }
+polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 tikv-jemalloc-ctl = "0.5.0"
diff --git a/polkadot/node/overseer/examples/minimal-example.rs b/polkadot/node/overseer/examples/minimal-example.rs
index 857cdba673db267d2824d8a995257316fc67225f..86a1801a5f2d8f08f2c176c53171031de3fceff0 100644
--- a/polkadot/node/overseer/examples/minimal-example.rs
+++ b/polkadot/node/overseer/examples/minimal-example.rs
@@ -23,7 +23,6 @@ use futures_timer::Delay;
 use orchestra::async_trait;
 use std::time::Duration;
 
-use ::test_helpers::{dummy_candidate_descriptor, dummy_hash};
 use polkadot_node_primitives::{BlockData, PoV};
 use polkadot_node_subsystem_types::messages::CandidateValidationMessage;
 use polkadot_overseer::{
@@ -33,6 +32,7 @@ use polkadot_overseer::{
 	HeadSupportsParachains, SubsystemError,
 };
 use polkadot_primitives::{CandidateReceipt, Hash, PvfExecKind};
+use polkadot_primitives_test_helpers::{dummy_candidate_descriptor, dummy_hash};
 
 struct AlwaysSupportsParachains;
 
diff --git a/polkadot/node/overseer/src/lib.rs b/polkadot/node/overseer/src/lib.rs
index 167b32a15bc4d1e6cdb150a3e1d0133e035fb617..24985a99913d82cc265d1cd3b6d6db66dd282247 100644
--- a/polkadot/node/overseer/src/lib.rs
+++ b/polkadot/node/overseer/src/lib.rs
@@ -71,8 +71,8 @@ use std::{
 
 use futures::{channel::oneshot, future::BoxFuture, select, Future, FutureExt, StreamExt};
 
-use client::{BlockImportNotification, BlockchainEvents, FinalityNotification};
 use polkadot_primitives::{Block, BlockNumber, Hash};
+use sc_client_api::{BlockImportNotification, BlockchainEvents, FinalityNotification};
 
 use self::messages::{BitfieldSigningMessage, PvfCheckerMessage};
 use polkadot_node_subsystem_types::messages::{
diff --git a/polkadot/node/overseer/src/tests.rs b/polkadot/node/overseer/src/tests.rs
index 55a6bdb74ba73c04bc66847a1b04ff6175608fa7..177e3addf368d715d51c5bcd7d7437515d56cd5b 100644
--- a/polkadot/node/overseer/src/tests.rs
+++ b/polkadot/node/overseer/src/tests.rs
@@ -18,13 +18,12 @@ use async_trait::async_trait;
 use futures::{executor, pending, pin_mut, poll, select, stream, FutureExt};
 use std::{collections::HashMap, sync::atomic, task::Poll};
 
-use ::test_helpers::{dummy_candidate_descriptor, dummy_candidate_receipt, dummy_hash};
-use node_test_helpers::mock::{dummy_unpin_handle, new_leaf};
 use polkadot_node_network_protocol::{PeerId, UnifiedReputationChange};
 use polkadot_node_primitives::{
 	BlockData, CollationGenerationConfig, CollationResult, DisputeMessage, InvalidDisputeVote, PoV,
 	UncheckedDisputeMessage, ValidDisputeVote,
 };
+use polkadot_node_subsystem_test_helpers::mock::{dummy_unpin_handle, new_leaf};
 use polkadot_node_subsystem_types::messages::{
 	NetworkBridgeEvent, ReportPeerMessage, RuntimeApiRequest,
 };
@@ -32,6 +31,9 @@ use polkadot_primitives::{
 	CandidateHash, CandidateReceipt, CollatorPair, Id as ParaId, InvalidDisputeStatementKind,
 	PvfExecKind, SessionIndex, ValidDisputeStatementKind, ValidatorIndex,
 };
+use polkadot_primitives_test_helpers::{
+	dummy_candidate_descriptor, dummy_candidate_receipt, dummy_hash,
+};
 
 use crate::{
 	self as overseer,
@@ -856,6 +858,7 @@ fn test_availability_recovery_msg() -> AvailabilityRecoveryMessage {
 		dummy_candidate_receipt(dummy_hash()),
 		Default::default(),
 		None,
+		None,
 		sender,
 	)
 }
diff --git a/polkadot/node/primitives/Cargo.toml b/polkadot/node/primitives/Cargo.toml
index 526d4e480bb05d745aad137f94b611f4cf91c838..0a84e5dae2a589ef5cd165ce2825bf811751af94 100644
--- a/polkadot/node/primitives/Cargo.toml
+++ b/polkadot/node/primitives/Cargo.toml
@@ -13,7 +13,7 @@ workspace = true
 bounded-vec = "0.7"
 futures = "0.3.30"
 polkadot-primitives = { path = "../../primitives" }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sp-core = { path = "../../../substrate/primitives/core" }
 sp-application-crypto = { path = "../../../substrate/primitives/application-crypto" }
 sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe" }
diff --git a/polkadot/node/primitives/src/approval.rs b/polkadot/node/primitives/src/approval.rs
index b73cb4c717db7ff856669b528d5e065e413d6101..66883b33367bceaeeaa61cb7152e735eb8dbfcc6 100644
--- a/polkadot/node/primitives/src/approval.rs
+++ b/polkadot/node/primitives/src/approval.rs
@@ -23,7 +23,7 @@ pub mod v1 {
 		Randomness, Slot, VrfPreOutput, VrfProof, VrfSignature, VrfTranscript,
 	};
 
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 	use polkadot_primitives::{
 		BlockNumber, CandidateHash, CandidateIndex, CoreIndex, Hash, Header, SessionIndex,
 		ValidatorIndex, ValidatorSignature,
@@ -212,7 +212,7 @@ pub mod v1 {
 
 /// A list of primitives introduced by v2.
 pub mod v2 {
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 	pub use sp_consensus_babe::{
 		Randomness, Slot, VrfPreOutput, VrfProof, VrfSignature, VrfTranscript,
 	};
diff --git a/polkadot/node/primitives/src/disputes/message.rs b/polkadot/node/primitives/src/disputes/message.rs
index 31fe73a7ba1c4dec821762714195f3c1792beac8..f9dec073bf50112437b4526b4cf5b4109ab07433 100644
--- a/polkadot/node/primitives/src/disputes/message.rs
+++ b/polkadot/node/primitives/src/disputes/message.rs
@@ -21,7 +21,7 @@
 
 use thiserror::Error;
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 use super::{InvalidDisputeVote, SignedDisputeStatement, ValidDisputeVote};
 use polkadot_primitives::{
diff --git a/polkadot/node/primitives/src/disputes/mod.rs b/polkadot/node/primitives/src/disputes/mod.rs
index 5814ecee44f4e9ee333f1898c92341799978d646..0f08b4733654a483431be44fce11d2100e0c263c 100644
--- a/polkadot/node/primitives/src/disputes/mod.rs
+++ b/polkadot/node/primitives/src/disputes/mod.rs
@@ -19,7 +19,7 @@ use std::collections::{
 	BTreeMap, BTreeSet,
 };
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 use sp_application_crypto::AppCrypto;
 use sp_keystore::{Error as KeystoreError, KeystorePtr};
diff --git a/polkadot/node/primitives/src/disputes/status.rs b/polkadot/node/primitives/src/disputes/status.rs
index d93c3ec846ce6f45392e3baeb325afd56dccf9d9..b9a1c57d53de5727fb5af5a4d6b232cd6cec456c 100644
--- a/polkadot/node/primitives/src/disputes/status.rs
+++ b/polkadot/node/primitives/src/disputes/status.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 
 /// Timestamp based on the 1 Jan 1970 UNIX base, which is persistent across node restarts and OS
 /// reboots.
diff --git a/polkadot/node/primitives/src/lib.rs b/polkadot/node/primitives/src/lib.rs
index 0f97250a934e0865d799fc1ea3923bbceff57a99..ecf79eac2883e930213fb54e4bf16b8a266a0c42 100644
--- a/polkadot/node/primitives/src/lib.rs
+++ b/polkadot/node/primitives/src/lib.rs
@@ -25,18 +25,19 @@
 use std::pin::Pin;
 
 use bounded_vec::BoundedVec;
+use codec::{Decode, Encode, Error as CodecError, Input};
 use futures::Future;
-use parity_scale_codec::{Decode, Encode, Error as CodecError, Input};
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 
 use polkadot_primitives::{
-	BlakeTwo256, BlockNumber, CandidateCommitments, CandidateHash, CollatorPair,
+	BlakeTwo256, BlockNumber, CandidateCommitments, CandidateHash, ChunkIndex, CollatorPair,
 	CommittedCandidateReceipt, CompactStatement, CoreIndex, EncodeAs, Hash, HashT, HeadData,
 	Id as ParaId, PersistedValidationData, SessionIndex, Signed, UncheckedSigned, ValidationCode,
-	ValidationCodeHash, ValidatorIndex, MAX_CODE_SIZE, MAX_POV_SIZE,
+	ValidationCodeHash, MAX_CODE_SIZE, MAX_POV_SIZE,
 };
 pub use sp_consensus_babe::{
 	AllowedSlots as BabeAllowedSlots, BabeEpochConfiguration, Epoch as BabeEpoch,
+	Randomness as BabeRandomness,
 };
 
 pub use polkadot_parachain_primitives::primitives::{
@@ -58,7 +59,7 @@ pub use disputes::{
 /// relatively rare.
 ///
 /// The associated worker binaries should use the same version as the node that spawns them.
-pub const NODE_VERSION: &'static str = "1.11.0";
+pub const NODE_VERSION: &'static str = "1.13.0";
 
 // For a 16-ary Merkle Prefix Trie, we can expect at most 16 32-byte hashes per node
 // plus some overhead:
@@ -639,7 +640,7 @@ pub struct ErasureChunk {
 	/// The erasure-encoded chunk of data belonging to the candidate block.
 	pub chunk: Vec<u8>,
 	/// The index of this erasure-encoded chunk of data.
-	pub index: ValidatorIndex,
+	pub index: ChunkIndex,
 	/// Proof for this chunk's branch in the Merkle tree.
 	pub proof: Proof,
 }
diff --git a/polkadot/node/service/Cargo.toml b/polkadot/node/service/Cargo.toml
index b3f1c22d0e705bfddc1a5fb42e9da1d5cb244746..ec5113d2c8a5f0bc40e404dbf78201c5b2a65102 100644
--- a/polkadot/node/service/Cargo.toml
+++ b/polkadot/node/service/Cargo.toml
@@ -13,9 +13,9 @@ workspace = true
 [dependencies]
 # Substrate Client
 sc-authority-discovery = { path = "../../../substrate/client/authority-discovery" }
-babe = { package = "sc-consensus-babe", path = "../../../substrate/client/consensus/babe" }
-beefy = { package = "sc-consensus-beefy", path = "../../../substrate/client/consensus/beefy" }
-grandpa = { package = "sc-consensus-grandpa", path = "../../../substrate/client/consensus/grandpa" }
+sc-consensus-babe = { path = "../../../substrate/client/consensus/babe" }
+sc-consensus-beefy = { path = "../../../substrate/client/consensus/beefy" }
+sc-consensus-grandpa = { path = "../../../substrate/client/consensus/grandpa" }
 mmr-gadget = { path = "../../../substrate/client/merkle-mountain-range" }
 sp-mmr-primitives = { path = "../../../substrate/primitives/merkle-mountain-range" }
 sc-block-builder = { path = "../../../substrate/client/block-builder" }
@@ -35,14 +35,14 @@ sc-keystore = { path = "../../../substrate/client/keystore" }
 sc-basic-authorship = { path = "../../../substrate/client/basic-authorship" }
 sc-offchain = { path = "../../../substrate/client/offchain" }
 sc-sysinfo = { path = "../../../substrate/client/sysinfo" }
-service = { package = "sc-service", path = "../../../substrate/client/service", default-features = false }
-telemetry = { package = "sc-telemetry", path = "../../../substrate/client/telemetry" }
+sc-service = { path = "../../../substrate/client/service", default-features = false }
+sc-telemetry = { path = "../../../substrate/client/telemetry" }
 
 # Substrate Primitives
 sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery" }
-consensus_common = { package = "sp-consensus", path = "../../../substrate/primitives/consensus/common" }
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy" }
-grandpa_primitives = { package = "sp-consensus-grandpa", path = "../../../substrate/primitives/consensus/grandpa" }
+sp-consensus = { path = "../../../substrate/primitives/consensus/common" }
+sp-consensus-beefy = { path = "../../../substrate/primitives/consensus/beefy" }
+sp-consensus-grandpa = { path = "../../../substrate/primitives/consensus/grandpa" }
 sp-inherents = { path = "../../../substrate/primitives/inherents" }
 sp-keyring = { path = "../../../substrate/primitives/keyring" }
 sp-api = { path = "../../../substrate/primitives/api" }
@@ -67,6 +67,7 @@ sp-version = { path = "../../../substrate/primitives/version" }
 pallet-babe = { path = "../../../substrate/frame/babe" }
 pallet-staking = { path = "../../../substrate/frame/staking" }
 pallet-transaction-payment-rpc-runtime-api = { path = "../../../substrate/frame/transaction-payment/rpc/runtime-api" }
+frame-metadata-hash-extension = { path = "../../../substrate/frame/metadata-hash-extension", optional = true }
 frame-system = { path = "../../../substrate/frame/system" }
 
 # Substrate Other
@@ -147,7 +148,7 @@ xcm-fee-payment-runtime-api = { path = "../../xcm/xcm-fee-payment-runtime-api" }
 [dev-dependencies]
 polkadot-test-client = { path = "../test/client" }
 polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" }
 env_logger = "0.11"
 assert_matches = "1.5.0"
 serial_test = "2.0.0"
@@ -156,7 +157,7 @@ tempfile = "3.2"
 [features]
 default = ["db", "full-node"]
 
-db = ["service/rocksdb"]
+db = ["sc-service/rocksdb"]
 
 full-node = [
 	"kvdb-rocksdb",
@@ -187,8 +188,18 @@ full-node = [
 ]
 
 # Configure the native runtimes to use.
-westend-native = ["bitvec", "westend-runtime", "westend-runtime-constants"]
-rococo-native = ["bitvec", "rococo-runtime", "rococo-runtime-constants"]
+westend-native = [
+	"bitvec",
+	"frame-metadata-hash-extension",
+	"westend-runtime",
+	"westend-runtime-constants",
+]
+rococo-native = [
+	"bitvec",
+	"frame-metadata-hash-extension",
+	"rococo-runtime",
+	"rococo-runtime-constants",
+]
 
 runtime-benchmarks = [
 	"frame-benchmarking-cli/runtime-benchmarks",
@@ -203,7 +214,7 @@ runtime-benchmarks = [
 	"polkadot-test-client/runtime-benchmarks",
 	"rococo-runtime?/runtime-benchmarks",
 	"sc-client-db/runtime-benchmarks",
-	"service/runtime-benchmarks",
+	"sc-service/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"westend-runtime?/runtime-benchmarks",
 	"xcm-fee-payment-runtime-api/runtime-benchmarks",
@@ -227,7 +238,3 @@ runtime-metrics = [
 	"rococo-runtime?/runtime-metrics",
 	"westend-runtime?/runtime-metrics",
 ]
-
-elastic-scaling-experimental = [
-	"polkadot-collator-protocol?/elastic-scaling-experimental",
-]
diff --git a/polkadot/node/service/chain-specs/kusama.json b/polkadot/node/service/chain-specs/kusama.json
index 899b302155f79c2e889ca8300f9cf277059bd3d4..dfe79fd9c5e5d920ad1da8f1cab38a6796316e97 100644
--- a/polkadot/node/service/chain-specs/kusama.json
+++ b/polkadot/node/service/chain-specs/kusama.json
@@ -14,8 +14,8 @@
     "/dns/boot.stake.plus/tcp/31334/wss/p2p/12D3KooWLa1UyG5xLPds2GbiRBCTJjpsVwRWHWN7Dff14yiNJRpR",
     "/dns/boot-node.helikon.io/tcp/7060/p2p/12D3KooWL4KPqfAsPE2aY1g5Zo1CxsDwcdJ7mmAghK7cg6M2fdbD",
     "/dns/boot-node.helikon.io/tcp/7062/wss/p2p/12D3KooWL4KPqfAsPE2aY1g5Zo1CxsDwcdJ7mmAghK7cg6M2fdbD",
-    "/dns/kusama.bootnode.amforc.com/tcp/30333/p2p/12D3KooWLx6nsj6Fpd8biP1VDyuCUjazvRiGWyBam8PsqRJkbUb9",
-    "/dns/kusama.bootnode.amforc.com/tcp/30334/wss/p2p/12D3KooWLx6nsj6Fpd8biP1VDyuCUjazvRiGWyBam8PsqRJkbUb9",
+    "/dns/kusama.bootnode.amforc.com/tcp/30001/p2p/12D3KooWKvYf6qKaAF8UUDw3KsTwjHLnvkED23yxHbH3npMe8w4G",
+    "/dns/kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWKvYf6qKaAF8UUDw3KsTwjHLnvkED23yxHbH3npMe8w4G",
     "/dns/kusama.bootnodes.polkadotters.com/tcp/30311/p2p/12D3KooWHB5rTeNkQdXNJ9ynvGz8Lpnmsctt7Tvp7mrYv6bcwbPG",
     "/dns/kusama.bootnodes.polkadotters.com/tcp/30313/wss/p2p/12D3KooWHB5rTeNkQdXNJ9ynvGz8Lpnmsctt7Tvp7mrYv6bcwbPG",
     "/dns/boot.gatotech.network/tcp/33200/p2p/12D3KooWRNZXf99BfzQDE1C8YhuBbuy7Sj18UEf7FNpD8egbURYD",
diff --git a/polkadot/node/service/chain-specs/paseo.json b/polkadot/node/service/chain-specs/paseo.json
index 5a67ddcd4c4361f4f1fc4e87ac6ffdf649e06feb..e307d5213a396ee9221701e39a9b4be239f591b2 100644
--- a/polkadot/node/service/chain-specs/paseo.json
+++ b/polkadot/node/service/chain-specs/paseo.json
@@ -3,8 +3,8 @@
   "id": "paseo",
   "chainType": "Live",
   "bootNodes": [
-    "/dns/paseo.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWFD81HC9memUwuGMLvhDDEfmXjn6jC4n7zyNs3vToXapS",
-    "/dns/paseo.bootnode.amforc.com/tcp/30344/p2p/12D3KooWFD81HC9memUwuGMLvhDDEfmXjn6jC4n7zyNs3vToXapS",
+    "/dns/paseo.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWSdf63rZjtGdeWXpQwQwPh8K8c22upcB3B1VmqW8rxrjw",
+    "/dns/paseo.bootnode.amforc.com/tcp/30001/p2p/12D3KooWSdf63rZjtGdeWXpQwQwPh8K8c22upcB3B1VmqW8rxrjw",
     "/dns/boot.stake.plus/tcp/43334/wss/p2p/12D3KooWNhgAC3hjZHxaT52EpPFZohkCL1AHFAijqcN8xB9Rwud2",
     "/dns/boot.stake.plus/tcp/43333/p2p/12D3KooWNhgAC3hjZHxaT52EpPFZohkCL1AHFAijqcN8xB9Rwud2",
     "/dns/boot.metaspan.io/tcp/36017/wss/p2p/12D3KooWSW6nDfM3SS8rUtjMyjdszivK31bu4a1sRngGa2hFETz7",
diff --git a/polkadot/node/service/chain-specs/polkadot.json b/polkadot/node/service/chain-specs/polkadot.json
index 04def54f794cbc6381c3b2aadaa3e2d02763b6f2..f79b6db90fcf0cc3513f644edf468ed0c2fc2cd7 100644
--- a/polkadot/node/service/chain-specs/polkadot.json
+++ b/polkadot/node/service/chain-specs/polkadot.json
@@ -15,8 +15,8 @@
     "/dns/boot.stake.plus/tcp/30334/wss/p2p/12D3KooWKT4ZHNxXH4icMjdrv7EwWBkfbz5duxE5sdJKKeWFYi5n",
     "/dns/boot-node.helikon.io/tcp/7070/p2p/12D3KooWS9ZcvRxyzrSf6p63QfTCWs12nLoNKhGux865crgxVA4H",
     "/dns/boot-node.helikon.io/tcp/7072/wss/p2p/12D3KooWS9ZcvRxyzrSf6p63QfTCWs12nLoNKhGux865crgxVA4H",
-    "/dns/polkadot.bootnode.amforc.com/tcp/30333/p2p/12D3KooWAsuCEVCzUVUrtib8W82Yne3jgVGhQZN3hizko5FTnDg3",
-    "/dns/polkadot.bootnode.amforc.com/tcp/30334/wss/p2p/12D3KooWAsuCEVCzUVUrtib8W82Yne3jgVGhQZN3hizko5FTnDg3",
+    "/dns/polkadot.bootnode.amforc.com/tcp/30001/p2p/12D3KooWT2HyZx5C6BBeLbCKhYG2SqJYuiu7sLMxGzUcQBko3BMr",
+    "/dns/polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWT2HyZx5C6BBeLbCKhYG2SqJYuiu7sLMxGzUcQBko3BMr",
     "/dns/polkadot.bootnodes.polkadotters.com/tcp/30314/p2p/12D3KooWPAVUgBaBk6n8SztLrMk8ESByncbAfRKUdxY1nygb9zG3",
     "/dns/polkadot.bootnodes.polkadotters.com/tcp/30316/wss/p2p/12D3KooWPAVUgBaBk6n8SztLrMk8ESByncbAfRKUdxY1nygb9zG3",
     "/dns/boot.gatotech.network/tcp/33100/p2p/12D3KooWK4E16jKk9nRhvC4RfrDVgcZzExg8Q3Q2G7ABUUitks1w",
diff --git a/polkadot/node/service/chain-specs/westend.json b/polkadot/node/service/chain-specs/westend.json
index 16bc7ff07b0fdd4805b7ffb3a4099c5b0c728363..1bfb5ba334cef24e70b6335436ec10c77929f9e2 100644
--- a/polkadot/node/service/chain-specs/westend.json
+++ b/polkadot/node/service/chain-specs/westend.json
@@ -12,8 +12,8 @@
     "/dns/boot.stake.plus/tcp/32334/wss/p2p/12D3KooWK8fjVoSvMq5copQYMsdYreSGPGgcMbGMgbMDPfpf3sm7",
     "/dns/boot-node.helikon.io/tcp/7080/p2p/12D3KooWRFDPyT8vA8mLzh6dJoyujn4QNjeqi6Ch79eSMz9beKXC",
     "/dns/boot-node.helikon.io/tcp/7082/wss/p2p/12D3KooWRFDPyT8vA8mLzh6dJoyujn4QNjeqi6Ch79eSMz9beKXC",
-    "/dns/westend.bootnode.amforc.com/tcp/30333/p2p/12D3KooWJ5y9ZgVepBQNW4aabrxgmnrApdVnscqgKWiUu4BNJbC8",
-    "/dns/westend.bootnode.amforc.com/tcp/30334/wss/p2p/12D3KooWJ5y9ZgVepBQNW4aabrxgmnrApdVnscqgKWiUu4BNJbC8",
+    "/dns/westend.bootnode.amforc.com/tcp/30001/p2p/12D3KooWAPmR7rbm2axPjHzF51yvQNDM5GvWfkF5BTV44Y5vJ3ct",
+    "/dns/westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWAPmR7rbm2axPjHzF51yvQNDM5GvWfkF5BTV44Y5vJ3ct",
     "/dns/westend.bootnodes.polkadotters.com/tcp/30308/p2p/12D3KooWHPHb64jXMtSRJDrYFATWeLnvChL8NtWVttY67DCH1eC5",
     "/dns/westend.bootnodes.polkadotters.com/tcp/30310/wss/p2p/12D3KooWHPHb64jXMtSRJDrYFATWeLnvChL8NtWVttY67DCH1eC5",
     "/dns/boot.gatotech.network/tcp/33300/p2p/12D3KooWQGR1vUhoy6mvQorFp3bZFn6NNezhQZ6NWnVV7tpFgoPd",
diff --git a/polkadot/node/service/src/benchmarking.rs b/polkadot/node/service/src/benchmarking.rs
index a0c4d3b04469b1bcf85990d4f6f62922f09bf88a..4dcff2078419c9161ec752dc269f3f6a919748a2 100644
--- a/polkadot/node/service/src/benchmarking.rs
+++ b/polkadot/node/service/src/benchmarking.rs
@@ -201,6 +201,7 @@ fn westend_sign_call(
 		frame_system::CheckNonce::<runtime::Runtime>::from(nonce),
 		frame_system::CheckWeight::<runtime::Runtime>::new(),
 		pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
+		frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(false),
 	);
 
 	let payload = runtime::SignedPayload::from_raw(
@@ -215,6 +216,7 @@ fn westend_sign_call(
 			(),
 			(),
 			(),
+			None,
 		),
 	);
 
@@ -253,6 +255,7 @@ fn rococo_sign_call(
 		frame_system::CheckNonce::<runtime::Runtime>::from(nonce),
 		frame_system::CheckWeight::<runtime::Runtime>::new(),
 		pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
+		frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(false),
 	);
 
 	let payload = runtime::SignedPayload::from_raw(
@@ -267,6 +270,7 @@ fn rococo_sign_call(
 			(),
 			(),
 			(),
+			None,
 		),
 	);
 
diff --git a/polkadot/node/service/src/chain_spec.rs b/polkadot/node/service/src/chain_spec.rs
index 1b990af2394b6fba31b0c8ddb2c1839cb2c09fb0..0358bc300ab06289b428c480439cc33a5fcae7ed 100644
--- a/polkadot/node/service/src/chain_spec.rs
+++ b/polkadot/node/service/src/chain_spec.rs
@@ -16,13 +16,13 @@
 
 //! Polkadot chain configurations.
 
-use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId;
-use grandpa::AuthorityId as GrandpaId;
 #[cfg(feature = "westend-native")]
 use pallet_staking::Forcing;
 use polkadot_primitives::{AccountId, AccountPublic, AssignmentId, ValidatorId};
+use sc_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
 use sp_consensus_babe::AuthorityId as BabeId;
+use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId;
 
 #[cfg(feature = "westend-native")]
 use polkadot_primitives::vstaging::SchedulerParams;
@@ -31,13 +31,13 @@ use rococo_runtime as rococo;
 use sc_chain_spec::ChainSpecExtension;
 #[cfg(any(feature = "westend-native", feature = "rococo-native"))]
 use sc_chain_spec::ChainType;
+#[cfg(any(feature = "westend-native", feature = "rococo-native"))]
+use sc_telemetry::TelemetryEndpoints;
 use serde::{Deserialize, Serialize};
 use sp_core::{sr25519, Pair, Public};
 use sp_runtime::traits::IdentifyAccount;
 #[cfg(feature = "westend-native")]
 use sp_runtime::Perbill;
-#[cfg(any(feature = "westend-native", feature = "rococo-native"))]
-use telemetry::TelemetryEndpoints;
 #[cfg(feature = "westend-native")]
 use westend_runtime as westend;
 #[cfg(feature = "westend-native")]
@@ -70,11 +70,11 @@ pub struct Extensions {
 }
 
 // Generic chain spec, in case when we don't have the native runtime.
-pub type GenericChainSpec = service::GenericChainSpec<(), Extensions>;
+pub type GenericChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// The `ChainSpec` parameterized for the westend runtime.
 #[cfg(feature = "westend-native")]
-pub type WestendChainSpec = service::GenericChainSpec<(), Extensions>;
+pub type WestendChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// The `ChainSpec` parameterized for the westend runtime.
 // Dummy chain spec, but that is fine when we don't have the native runtime.
@@ -83,7 +83,7 @@ pub type WestendChainSpec = GenericChainSpec;
 
 /// The `ChainSpec` parameterized for the rococo runtime.
 #[cfg(feature = "rococo-native")]
-pub type RococoChainSpec = service::GenericChainSpec<(), Extensions>;
+pub type RococoChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// The `ChainSpec` parameterized for the rococo runtime.
 // Dummy chain spec, but that is fine when we don't have the native runtime.
diff --git a/polkadot/node/service/src/fake_runtime_api.rs b/polkadot/node/service/src/fake_runtime_api.rs
index 03c4836020d98cdd15719619856db0be38dae66b..dd8a0a7e635bc67e298f31f537f9c41fa207b6a5 100644
--- a/polkadot/node/service/src/fake_runtime_api.rs
+++ b/polkadot/node/service/src/fake_runtime_api.rs
@@ -19,8 +19,6 @@
 //! These are used to provide a type that implements these runtime APIs without requiring to import
 //! the native runtimes.
 
-use beefy_primitives::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature};
-use grandpa_primitives::AuthorityId as GrandpaId;
 use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
 use polkadot_primitives::{
 	runtime_api, slashing, AccountId, AuthorityDiscoveryId, Balance, Block, BlockNumber,
@@ -30,6 +28,8 @@ use polkadot_primitives::{
 	ScrapedOnChainVotes, SessionIndex, SessionInfo, ValidationCode, ValidationCodeHash,
 	ValidatorId, ValidatorIndex, ValidatorSignature,
 };
+use sp_consensus_beefy::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature};
+use sp_consensus_grandpa::AuthorityId as GrandpaId;
 
 use sp_core::OpaqueMetadata;
 use sp_runtime::{
@@ -232,30 +232,30 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl beefy_primitives::BeefyApi<Block, BeefyId> for Runtime {
+	impl sp_consensus_beefy::BeefyApi<Block, BeefyId> for Runtime {
 		fn beefy_genesis() -> Option<BlockNumber> {
 			unimplemented!()
 		}
 
-		fn validator_set() -> Option<beefy_primitives::ValidatorSet<BeefyId>> {
+		fn validator_set() -> Option<sp_consensus_beefy::ValidatorSet<BeefyId>> {
 			unimplemented!()
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			_: beefy_primitives::DoubleVotingProof<
+			_: sp_consensus_beefy::DoubleVotingProof<
 				BlockNumber,
 				BeefyId,
 				BeefySignature,
 			>,
-			_: beefy_primitives::OpaqueKeyOwnershipProof,
+			_: sp_consensus_beefy::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			unimplemented!()
 		}
 
 		fn generate_key_ownership_proof(
-			_: beefy_primitives::ValidatorSetId,
+			_: sp_consensus_beefy::ValidatorSetId,
 			_: BeefyId,
-		) -> Option<beefy_primitives::OpaqueKeyOwnershipProof> {
+		) -> Option<sp_consensus_beefy::OpaqueKeyOwnershipProof> {
 			unimplemented!()
 		}
 	}
@@ -291,29 +291,29 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl grandpa_primitives::GrandpaApi<Block> for Runtime {
+	impl sp_consensus_grandpa::GrandpaApi<Block> for Runtime {
 		fn grandpa_authorities() -> Vec<(GrandpaId, u64)> {
 			unimplemented!()
 		}
 
-		fn current_set_id() -> grandpa_primitives::SetId {
+		fn current_set_id() -> sp_consensus_grandpa::SetId {
 			unimplemented!()
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			_: grandpa_primitives::EquivocationProof<
+			_: sp_consensus_grandpa::EquivocationProof<
 				<Block as BlockT>::Hash,
 				sp_runtime::traits::NumberFor<Block>,
 			>,
-			_: grandpa_primitives::OpaqueKeyOwnershipProof,
+			_: sp_consensus_grandpa::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			unimplemented!()
 		}
 
 		fn generate_key_ownership_proof(
-			_: grandpa_primitives::SetId,
-			_: grandpa_primitives::AuthorityId,
-		) -> Option<grandpa_primitives::OpaqueKeyOwnershipProof> {
+			_: sp_consensus_grandpa::SetId,
+			_: sp_consensus_grandpa::AuthorityId,
+		) -> Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof> {
 			unimplemented!()
 		}
 	}
@@ -416,8 +416,8 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi<Block, (), ()> for Runtime {
-		fn dry_run_extrinsic(_: <Block as BlockT>::Extrinsic) -> Result<xcm_fee_payment_runtime_api::dry_run::ExtrinsicDryRunEffects<()>, xcm_fee_payment_runtime_api::dry_run::Error> {
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, (), (), ()> for Runtime {
+		fn dry_run_call(_: (), _: ()) -> Result<xcm_fee_payment_runtime_api::dry_run::CallDryRunEffects<()>, xcm_fee_payment_runtime_api::dry_run::Error> {
 			unimplemented!()
 		}
 
diff --git a/polkadot/node/service/src/grandpa_support.rs b/polkadot/node/service/src/grandpa_support.rs
index 729dbfde5c76b850dd1b76bd9195de5066d551bc..c85d5eb32b192e99189a5c1fae6c233dd2a51aaa 100644
--- a/polkadot/node/service/src/grandpa_support.rs
+++ b/polkadot/node/service/src/grandpa_support.rs
@@ -64,7 +64,7 @@ where
 /// w3f validators and randomly selected validators from the latest session (at
 /// #1500988).
 #[cfg(feature = "full-node")]
-pub(crate) fn kusama_hard_forks() -> Vec<grandpa::AuthoritySetHardFork<Block>> {
+pub(crate) fn kusama_hard_forks() -> Vec<sc_consensus_grandpa::AuthoritySetHardFork<Block>> {
 	use sp_core::crypto::Ss58Codec;
 	use std::str::FromStr;
 
@@ -141,7 +141,7 @@ pub(crate) fn kusama_hard_forks() -> Vec<grandpa::AuthoritySetHardFork<Block>> {
 		.into_iter()
 		.map(|address| {
 			(
-				grandpa_primitives::AuthorityId::from_ss58check(address)
+				sp_consensus_grandpa::AuthorityId::from_ss58check(address)
 					.expect("hard fork authority addresses are static and they should be carefully defined; qed."),
 				1,
 			)
@@ -154,7 +154,7 @@ pub(crate) fn kusama_hard_forks() -> Vec<grandpa::AuthoritySetHardFork<Block>> {
 			let hash = Hash::from_str(hash)
 				.expect("hard fork hashes are static and they should be carefully defined; qed.");
 
-			grandpa::AuthoritySetHardFork {
+			sc_consensus_grandpa::AuthoritySetHardFork {
 				set_id,
 				block: (hash, number),
 				authorities: authorities.clone(),
diff --git a/polkadot/node/service/src/lib.rs b/polkadot/node/service/src/lib.rs
index 665533e9bc70a9173a5a9f6ff106657de07f859f..b4f63bd2aa06b20b30f4adef7cf4498061cd65e9 100644
--- a/polkadot/node/service/src/lib.rs
+++ b/polkadot/node/service/src/lib.rs
@@ -41,7 +41,6 @@ mod tests;
 
 #[cfg(feature = "full-node")]
 use {
-	grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider},
 	gum::info,
 	polkadot_node_core_approval_voting::{
 		self as approval_voting_subsystem, Config as ApprovalVotingConfig,
@@ -58,6 +57,7 @@ use {
 		request_response::ReqProtocolNames,
 	},
 	sc_client_api::BlockBackend,
+	sc_consensus_grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider},
 	sc_transaction_pool_api::OffchainTransactionPoolFactory,
 	sp_core::traits::SpawnNamed,
 };
@@ -82,14 +82,13 @@ use std::{collections::HashMap, path::PathBuf, sync::Arc, time::Duration};
 
 use prometheus_endpoint::Registry;
 #[cfg(feature = "full-node")]
-use service::KeystoreContainer;
-use service::RpcHandlers;
-use telemetry::TelemetryWorker;
+use sc_service::KeystoreContainer;
+use sc_service::RpcHandlers;
+use sc_telemetry::TelemetryWorker;
 #[cfg(feature = "full-node")]
-use telemetry::{Telemetry, TelemetryWorkerHandle};
+use sc_telemetry::{Telemetry, TelemetryWorkerHandle};
 
 pub use chain_spec::{GenericChainSpec, RococoChainSpec, WestendChainSpec};
-pub use consensus_common::{Proposal, SelectChain};
 use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE;
 use mmr_gadget::MmrGadget;
 use polkadot_node_subsystem_types::DefaultSubsystemClient;
@@ -98,12 +97,14 @@ pub use sc_client_api::{Backend, CallExecutor};
 pub use sc_consensus::{BlockImport, LongestChain};
 pub use sc_executor::NativeExecutionDispatch;
 use sc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY};
-pub use service::{
+pub use sc_service::{
 	config::{DatabaseSource, PrometheusConfig},
-	ChainSpec, Configuration, Error as SubstrateServiceError, PruningMode, Role, RuntimeGenesis,
-	TFullBackend, TFullCallExecutor, TFullClient, TaskManager, TransactionPoolOptions,
+	ChainSpec, Configuration, Error as SubstrateServiceError, PruningMode, Role, TFullBackend,
+	TFullCallExecutor, TFullClient, TaskManager, TransactionPoolOptions,
 };
 pub use sp_api::{ApiRef, ConstructRuntimeApi, Core as CoreApi, ProvideRuntimeApi};
+pub use sp_consensus::{Proposal, SelectChain};
+use sp_consensus_beefy::ecdsa_crypto;
 pub use sp_runtime::{
 	generic,
 	traits::{self as runtime_traits, BlakeTwo256, Block as BlockT, Header as HeaderT, NumberFor},
@@ -117,10 +118,10 @@ pub use {westend_runtime, westend_runtime_constants};
 pub use fake_runtime_api::{GetLastTimestamp, RuntimeApi};
 
 #[cfg(feature = "full-node")]
-pub type FullBackend = service::TFullBackend<Block>;
+pub type FullBackend = sc_service::TFullBackend<Block>;
 
 #[cfg(feature = "full-node")]
-pub type FullClient = service::TFullClient<
+pub type FullClient = sc_service::TFullClient<
 	Block,
 	RuntimeApi,
 	WasmExecutor<(sp_io::SubstrateHostFunctions, frame_benchmarking::benchmarking::HostFunctions)>,
@@ -209,7 +210,7 @@ pub enum Error {
 	Blockchain(#[from] sp_blockchain::Error),
 
 	#[error(transparent)]
-	Consensus(#[from] consensus_common::Error),
+	Consensus(#[from] sp_consensus::Error),
 
 	#[error("Failed to create an overseer")]
 	Overseer(#[from] polkadot_overseer::SubsystemError),
@@ -218,7 +219,7 @@ pub enum Error {
 	Prometheus(#[from] prometheus_endpoint::PrometheusError),
 
 	#[error(transparent)]
-	Telemetry(#[from] telemetry::Error),
+	Telemetry(#[from] sc_telemetry::Error),
 
 	#[error(transparent)]
 	Jaeger(#[from] polkadot_node_subsystem::jaeger::JaegerError),
@@ -392,10 +393,16 @@ fn jaeger_launch_collector_with_agent(
 type FullSelectChain = relay_chain_selection::SelectRelayChain<FullBackend>;
 #[cfg(feature = "full-node")]
 type FullGrandpaBlockImport<ChainSelection = FullSelectChain> =
-	grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, ChainSelection>;
+	sc_consensus_grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, ChainSelection>;
 #[cfg(feature = "full-node")]
-type FullBeefyBlockImport<InnerBlockImport> =
-	beefy::import::BeefyBlockImport<Block, FullBackend, FullClient, InnerBlockImport>;
+type FullBeefyBlockImport<InnerBlockImport, AuthorityId> =
+	sc_consensus_beefy::import::BeefyBlockImport<
+		Block,
+		FullBackend,
+		FullClient,
+		InnerBlockImport,
+		AuthorityId,
+	>;
 
 #[cfg(feature = "full-node")]
 struct Basics {
@@ -416,7 +423,7 @@ fn new_partial_basics(
 		.telemetry_endpoints
 		.clone()
 		.filter(|x| !x.is_empty())
-		.map(move |endpoints| -> Result<_, telemetry::Error> {
+		.map(move |endpoints| -> Result<_, sc_telemetry::Error> {
 			let (worker, mut worker_handle) = if let Some(worker_handle) = telemetry_worker_handle {
 				(None, worker_handle)
 			} else {
@@ -442,7 +449,7 @@ fn new_partial_basics(
 		.build();
 
 	let (client, backend, keystore_container, task_manager) =
-		service::new_full_parts::<Block, RuntimeApi, _>(
+		sc_service::new_full_parts::<Block, RuntimeApi, _>(
 			&config,
 			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
 			executor,
@@ -471,7 +478,7 @@ fn new_partial<ChainSelection>(
 	Basics { task_manager, backend, client, keystore_container, telemetry }: Basics,
 	select_chain: ChainSelection,
 ) -> Result<
-	service::PartialComponents<
+	sc_service::PartialComponents<
 		FullClient,
 		FullBackend,
 		ChainSelection,
@@ -483,16 +490,19 @@ fn new_partial<ChainSelection>(
 				polkadot_rpc::SubscriptionTaskExecutor,
 			) -> Result<polkadot_rpc::RpcExtension, SubstrateServiceError>,
 			(
-				babe::BabeBlockImport<
+				sc_consensus_babe::BabeBlockImport<
 					Block,
 					FullClient,
-					FullBeefyBlockImport<FullGrandpaBlockImport<ChainSelection>>,
+					FullBeefyBlockImport<
+						FullGrandpaBlockImport<ChainSelection>,
+						ecdsa_crypto::AuthorityId,
+					>,
 				>,
-				grandpa::LinkHalf<Block, FullClient, ChainSelection>,
-				babe::BabeLink<Block>,
-				beefy::BeefyVoterLinks<Block>,
+				sc_consensus_grandpa::LinkHalf<Block, FullClient, ChainSelection>,
+				sc_consensus_babe::BabeLink<Block>,
+				sc_consensus_beefy::BeefyVoterLinks<Block, ecdsa_crypto::AuthorityId>,
 			),
-			grandpa::SharedVoterState,
+			sc_consensus_grandpa::SharedVoterState,
 			sp_consensus_babe::SlotDuration,
 			Option<Telemetry>,
 		),
@@ -516,55 +526,57 @@ where
 		Vec::new()
 	};
 
-	let (grandpa_block_import, grandpa_link) = grandpa::block_import_with_authority_set_hard_forks(
-		client.clone(),
-		GRANDPA_JUSTIFICATION_PERIOD,
-		&(client.clone() as Arc<_>),
-		select_chain.clone(),
-		grandpa_hard_forks,
-		telemetry.as_ref().map(|x| x.handle()),
-	)?;
+	let (grandpa_block_import, grandpa_link) =
+		sc_consensus_grandpa::block_import_with_authority_set_hard_forks(
+			client.clone(),
+			GRANDPA_JUSTIFICATION_PERIOD,
+			&(client.clone() as Arc<_>),
+			select_chain.clone(),
+			grandpa_hard_forks,
+			telemetry.as_ref().map(|x| x.handle()),
+		)?;
 	let justification_import = grandpa_block_import.clone();
 
 	let (beefy_block_import, beefy_voter_links, beefy_rpc_links) =
-		beefy::beefy_block_import_and_links(
+		sc_consensus_beefy::beefy_block_import_and_links(
 			grandpa_block_import,
 			backend.clone(),
 			client.clone(),
 			config.prometheus_registry().cloned(),
 		);
 
-	let babe_config = babe::configuration(&*client)?;
+	let babe_config = sc_consensus_babe::configuration(&*client)?;
 	let (block_import, babe_link) =
-		babe::block_import(babe_config.clone(), beefy_block_import, client.clone())?;
+		sc_consensus_babe::block_import(babe_config.clone(), beefy_block_import, client.clone())?;
 
 	let slot_duration = babe_link.config().slot_duration();
-	let (import_queue, babe_worker_handle) = babe::import_queue(babe::ImportQueueParams {
-		link: babe_link.clone(),
-		block_import: block_import.clone(),
-		justification_import: Some(Box::new(justification_import)),
-		client: client.clone(),
-		select_chain: select_chain.clone(),
-		create_inherent_data_providers: move |_, ()| async move {
-			let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
+	let (import_queue, babe_worker_handle) =
+		sc_consensus_babe::import_queue(sc_consensus_babe::ImportQueueParams {
+			link: babe_link.clone(),
+			block_import: block_import.clone(),
+			justification_import: Some(Box::new(justification_import)),
+			client: client.clone(),
+			select_chain: select_chain.clone(),
+			create_inherent_data_providers: move |_, ()| async move {
+				let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
 
-			let slot =
+				let slot =
 				sp_consensus_babe::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
 					*timestamp,
 					slot_duration,
 				);
 
-			Ok((slot, timestamp))
-		},
-		spawner: &task_manager.spawn_essential_handle(),
-		registry: config.prometheus_registry(),
-		telemetry: telemetry.as_ref().map(|x| x.handle()),
-		offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool.clone()),
-	})?;
+				Ok((slot, timestamp))
+			},
+			spawner: &task_manager.spawn_essential_handle(),
+			registry: config.prometheus_registry(),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool.clone()),
+		})?;
 
 	let justification_stream = grandpa_link.justification_stream();
 	let shared_authority_set = grandpa_link.shared_authority_set().clone();
-	let shared_voter_state = grandpa::SharedVoterState::empty();
+	let shared_voter_state = sc_consensus_grandpa::SharedVoterState::empty();
 	let finality_proof_provider = GrandpaFinalityProofProvider::new_for_service(
 		backend.clone(),
 		Some(shared_authority_set.clone()),
@@ -583,7 +595,7 @@ where
 
 		move |deny_unsafe,
 		      subscription_executor: polkadot_rpc::SubscriptionTaskExecutor|
-		      -> Result<polkadot_rpc::RpcExtension, service::Error> {
+		      -> Result<polkadot_rpc::RpcExtension, sc_service::Error> {
 			let deps = polkadot_rpc::FullDeps {
 				client: client.clone(),
 				pool: transaction_pool.clone(),
@@ -601,7 +613,7 @@ where
 					subscription_executor: subscription_executor.clone(),
 					finality_provider: finality_proof_provider.clone(),
 				},
-				beefy: polkadot_rpc::BeefyDeps {
+				beefy: polkadot_rpc::BeefyDeps::<ecdsa_crypto::AuthorityId> {
 					beefy_finality_proof_stream: beefy_rpc_links.from_voter_justif_stream.clone(),
 					beefy_best_block_stream: beefy_rpc_links.from_voter_best_beefy_stream.clone(),
 					subscription_executor,
@@ -613,7 +625,7 @@ where
 		}
 	};
 
-	Ok(service::PartialComponents {
+	Ok(sc_service::PartialComponents {
 		client,
 		backend,
 		task_manager,
@@ -750,6 +762,7 @@ pub fn new_full<
 		prepare_workers_hard_max_num,
 	}: NewFullParams<OverseerGenerator>,
 ) -> Result<NewFull, Error> {
+	use polkadot_availability_recovery::FETCH_CHUNKS_THRESHOLD;
 	use polkadot_node_network_protocol::request_response::IncomingRequest;
 	use sc_network_sync::WarpSyncParams;
 
@@ -807,7 +820,7 @@ pub fn new_full<
 		SelectRelayChain::new_longest_chain(basics.backend.clone())
 	};
 
-	let service::PartialComponents::<_, _, SelectRelayChain<_>, _, _, _> {
+	let sc_service::PartialComponents::<_, _, SelectRelayChain<_>, _, _, _> {
 		client,
 		backend,
 		mut task_manager,
@@ -834,9 +847,10 @@ pub fn new_full<
 	// Note: GrandPa is pushed before the Polkadot-specific protocols. This doesn't change
 	// anything in terms of behaviour, but makes the logs more consistent with the other
 	// Substrate nodes.
-	let grandpa_protocol_name = grandpa::protocol_standard_name(&genesis_hash, &config.chain_spec);
+	let grandpa_protocol_name =
+		sc_consensus_grandpa::protocol_standard_name(&genesis_hash, &config.chain_spec);
 	let (grandpa_protocol_config, grandpa_notification_service) =
-		grandpa::grandpa_peers_set_config::<_, Network>(
+		sc_consensus_grandpa::grandpa_peers_set_config::<_, Network>(
 			grandpa_protocol_name.clone(),
 			metrics.clone(),
 			Arc::clone(&peer_store_handle),
@@ -844,21 +858,19 @@ pub fn new_full<
 	net_config.add_notification_protocol(grandpa_protocol_config);
 
 	let beefy_gossip_proto_name =
-		beefy::gossip_protocol_name(&genesis_hash, config.chain_spec.fork_id());
+		sc_consensus_beefy::gossip_protocol_name(&genesis_hash, config.chain_spec.fork_id());
 	// `beefy_on_demand_justifications_handler` is given to `beefy-gadget` task to be run,
 	// while `beefy_req_resp_cfg` is added to `config.network.request_response_protocols`.
 	let (beefy_on_demand_justifications_handler, beefy_req_resp_cfg) =
-		beefy::communication::request_response::BeefyJustifsRequestHandler::new::<_, Network>(
-			&genesis_hash,
-			config.chain_spec.fork_id(),
-			client.clone(),
-			prometheus_registry.clone(),
-		);
+		sc_consensus_beefy::communication::request_response::BeefyJustifsRequestHandler::new::<
+			_,
+			Network,
+		>(&genesis_hash, config.chain_spec.fork_id(), client.clone(), prometheus_registry.clone());
 	let beefy_notification_service = match enable_beefy {
 		false => None,
 		true => {
 			let (beefy_notification_config, beefy_notification_service) =
-				beefy::communication::beefy_peers_set_config::<_, Network>(
+				sc_consensus_beefy::communication::beefy_peers_set_config::<_, Network>(
 					beefy_gossip_proto_name.clone(),
 					metrics.clone(),
 					Arc::clone(&peer_store_handle),
@@ -914,7 +926,10 @@ pub fn new_full<
 	let (pov_req_receiver, cfg) =
 		IncomingRequest::get_config_receiver::<_, Network>(&req_protocol_names);
 	net_config.add_request_response_protocol(cfg);
-	let (chunk_req_receiver, cfg) =
+	let (chunk_req_v1_receiver, cfg) =
+		IncomingRequest::get_config_receiver::<_, Network>(&req_protocol_names);
+	net_config.add_request_response_protocol(cfg);
+	let (chunk_req_v2_receiver, cfg) =
 		IncomingRequest::get_config_receiver::<_, Network>(&req_protocol_names);
 	net_config.add_request_response_protocol(cfg);
 
@@ -924,7 +939,7 @@ pub fn new_full<
 		Vec::new()
 	};
 
-	let warp_sync = Arc::new(grandpa::warp_proof::NetworkProvider::new(
+	let warp_sync = Arc::new(sc_consensus_grandpa::warp_proof::NetworkProvider::new(
 		backend.clone(),
 		import_setup.1.shared_authority_set().clone(),
 		grandpa_hard_forks,
@@ -988,24 +1003,31 @@ pub fn new_full<
 			stagnant_check_interval: Default::default(),
 			stagnant_check_mode: chain_selection_subsystem::StagnantCheckMode::PruneOnly,
 		};
+
+		// Kusama + testnets get a higher threshold, we are conservative on Polkadot for now.
+		let fetch_chunks_threshold =
+			if config.chain_spec.is_polkadot() { None } else { Some(FETCH_CHUNKS_THRESHOLD) };
+
 		Some(ExtendedOverseerGenArgs {
 			keystore,
 			parachains_db,
 			candidate_validation_config,
 			availability_config: AVAILABILITY_CONFIG,
 			pov_req_receiver,
-			chunk_req_receiver,
+			chunk_req_v1_receiver,
+			chunk_req_v2_receiver,
 			statement_req_receiver,
 			candidate_req_v2_receiver,
 			approval_voting_config,
 			dispute_req_receiver,
 			dispute_coordinator_config,
 			chain_selection_config,
+			fetch_chunks_threshold,
 		})
 	};
 
 	let (network, system_rpc_tx, tx_handler_controller, network_starter, sync_service) =
-		service::build_network(service::BuildNetworkParams {
+		sc_service::build_network(sc_service::BuildNetworkParams {
 			config: &config,
 			net_config,
 			client: client.clone(),
@@ -1041,7 +1063,7 @@ pub fn new_full<
 		);
 	}
 
-	let rpc_handlers = service::spawn_tasks(service::SpawnTasksParams {
+	let rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
 		config,
 		backend: backend.clone(),
 		client: client.clone(),
@@ -1137,7 +1159,7 @@ pub fn new_full<
 
 	let overseer_handle = if let Some(authority_discovery_service) = authority_discovery_service {
 		let (overseer, overseer_handle) = overseer_gen
-			.generate::<service::SpawnTaskHandle, DefaultSubsystemClient<FullClient>>(
+			.generate::<sc_service::SpawnTaskHandle, DefaultSubsystemClient<FullClient>>(
 				overseer_connector,
 				OverseerGenArgs {
 					runtime_client,
@@ -1209,7 +1231,7 @@ pub fn new_full<
 		let overseer_handle =
 			overseer_handle.as_ref().ok_or(Error::AuthoritiesRequireRealOverseer)?.clone();
 		let slot_duration = babe_link.config().slot_duration();
-		let babe_config = babe::BabeParams {
+		let babe_config = sc_consensus_babe::BabeParams {
 			keystore: keystore_container.keystore(),
 			client: client.clone(),
 			select_chain,
@@ -1243,12 +1265,12 @@ pub fn new_full<
 			force_authoring,
 			backoff_authoring_blocks,
 			babe_link,
-			block_proposal_slot_portion: babe::SlotProportion::new(2f32 / 3f32),
+			block_proposal_slot_portion: sc_consensus_babe::SlotProportion::new(2f32 / 3f32),
 			max_block_proposal_slot_portion: None,
 			telemetry: telemetry.as_ref().map(|x| x.handle()),
 		};
 
-		let babe = babe::start_babe(babe_config)?;
+		let babe = sc_consensus_babe::start_babe(babe_config)?;
 		task_manager.spawn_essential_handle().spawn_blocking("babe", None, babe);
 	}
 
@@ -1259,7 +1281,7 @@ pub fn new_full<
 	// beefy is enabled if its notification service exists
 	if let Some(notification_service) = beefy_notification_service {
 		let justifications_protocol_name = beefy_on_demand_justifications_handler.protocol_name();
-		let network_params = beefy::BeefyNetworkParams {
+		let network_params = sc_consensus_beefy::BeefyNetworkParams {
 			network: Arc::new(network.clone()),
 			sync: sync_service.clone(),
 			gossip_protocol_name: beefy_gossip_proto_name,
@@ -1267,8 +1289,8 @@ pub fn new_full<
 			notification_service,
 			_phantom: core::marker::PhantomData::<Block>,
 		};
-		let payload_provider = beefy_primitives::mmr::MmrRootProvider::new(client.clone());
-		let beefy_params = beefy::BeefyParams {
+		let payload_provider = sp_consensus_beefy::mmr::MmrRootProvider::new(client.clone());
+		let beefy_params = sc_consensus_beefy::BeefyParams {
 			client: client.clone(),
 			backend: backend.clone(),
 			payload_provider,
@@ -1282,7 +1304,16 @@ pub fn new_full<
 			is_authority: role.is_authority(),
 		};
 
-		let gadget = beefy::start_beefy_gadget::<_, _, _, _, _, _, _>(beefy_params);
+		let gadget = sc_consensus_beefy::start_beefy_gadget::<
+			_,
+			_,
+			_,
+			_,
+			_,
+			_,
+			_,
+			ecdsa_crypto::AuthorityId,
+		>(beefy_params);
 
 		// BEEFY is part of consensus, if it fails we'll bring the node down with it to make sure it
 		// is noticed.
@@ -1303,7 +1334,7 @@ pub fn new_full<
 		);
 	}
 
-	let config = grandpa::Config {
+	let config = sc_consensus_grandpa::Config {
 		// FIXME substrate#1578 make this available through chainspec
 		// Grandpa performance can be improved a bit by tuning this parameter, see:
 		// https://github.com/paritytech/polkadot/issues/5464
@@ -1326,17 +1357,18 @@ pub fn new_full<
 		// provide better guarantees of block and vote data availability than
 		// the observer.
 
-		let mut voting_rules_builder = grandpa::VotingRulesBuilder::default();
+		let mut voting_rules_builder = sc_consensus_grandpa::VotingRulesBuilder::default();
 
 		#[cfg(not(feature = "malus"))]
 		let _malus_finality_delay = None;
 
 		if let Some(delay) = _malus_finality_delay {
 			info!(?delay, "Enabling malus finality delay",);
-			voting_rules_builder = voting_rules_builder.add(grandpa::BeforeBestBlockBy(delay));
+			voting_rules_builder =
+				voting_rules_builder.add(sc_consensus_grandpa::BeforeBestBlockBy(delay));
 		};
 
-		let grandpa_config = grandpa::GrandpaParams {
+		let grandpa_config = sc_consensus_grandpa::GrandpaParams {
 			config,
 			link: link_half,
 			network: network.clone(),
@@ -1352,7 +1384,7 @@ pub fn new_full<
 		task_manager.spawn_essential_handle().spawn_blocking(
 			"grandpa-voter",
 			None,
-			grandpa::run_grandpa_voter(grandpa_config)?,
+			sc_consensus_grandpa::run_grandpa_voter(grandpa_config)?,
 		);
 	}
 
@@ -1381,7 +1413,7 @@ macro_rules! chain_ops {
 		// use the longest chain selection, since there is no overseer available
 		let chain_selection = LongestChain::new(basics.backend.clone());
 
-		let service::PartialComponents { client, backend, import_queue, task_manager, .. } =
+		let sc_service::PartialComponents { client, backend, import_queue, task_manager, .. } =
 			new_partial::<LongestChain<_, Block>>(&mut config, basics, chain_selection)?;
 		Ok((client, backend, import_queue, task_manager))
 	}};
@@ -1394,7 +1426,7 @@ pub fn new_chain_ops(
 	jaeger_agent: Option<std::net::SocketAddr>,
 ) -> Result<(Arc<FullClient>, Arc<FullBackend>, sc_consensus::BasicQueue<Block>, TaskManager), Error>
 {
-	config.keystore = service::config::KeystoreConfig::InMemory;
+	config.keystore = sc_service::config::KeystoreConfig::InMemory;
 
 	if config.chain_spec.is_rococo() ||
 		config.chain_spec.is_wococo() ||
@@ -1472,8 +1504,8 @@ pub fn revert_backend(
 	revert_approval_voting(parachains_db.clone(), hash)?;
 	revert_chain_selection(parachains_db, hash)?;
 	// Revert Substrate consensus related components
-	babe::revert(client.clone(), backend, blocks)?;
-	grandpa::revert(client, blocks)?;
+	sc_consensus_babe::revert(client.clone(), backend, blocks)?;
+	sc_consensus_grandpa::revert(client, blocks)?;
 
 	Ok(())
 }
@@ -1502,7 +1534,7 @@ fn revert_approval_voting(db: Arc<dyn Database>, hash: Hash) -> sp_blockchain::R
 		config,
 		db,
 		Arc::new(sc_keystore::LocalKeystore::in_memory()),
-		Box::new(consensus_common::NoNetwork),
+		Box::new(sp_consensus::NoNetwork),
 		approval_voting_subsystem::Metrics::default(),
 	);
 
diff --git a/polkadot/node/service/src/overseer.rs b/polkadot/node/service/src/overseer.rs
index 26b1446bf515afa342bd53c6237a87e7e750022d..5f4db99b00ef9f29ff90267f1d70cc4fcb94a249 100644
--- a/polkadot/node/service/src/overseer.rs
+++ b/polkadot/node/service/src/overseer.rs
@@ -82,7 +82,7 @@ where
 	/// Underlying network service implementation.
 	pub network_service: Arc<dyn sc_network::service::traits::NetworkService>,
 	/// Underlying syncing service implementation.
-	pub sync_service: Arc<dyn consensus_common::SyncOracle + Send + Sync>,
+	pub sync_service: Arc<dyn sp_consensus::SyncOracle + Send + Sync>,
 	/// Underlying authority discovery service.
 	pub authority_discovery_service: AuthorityDiscoveryService,
 	/// Collations request receiver for network protocol v1.
@@ -119,8 +119,10 @@ pub struct ExtendedOverseerGenArgs {
 	pub availability_config: AvailabilityConfig,
 	/// POV request receiver.
 	pub pov_req_receiver: IncomingRequestReceiver<request_v1::PoVFetchingRequest>,
-	/// Erasure chunks request receiver.
-	pub chunk_req_receiver: IncomingRequestReceiver<request_v1::ChunkFetchingRequest>,
+	/// Erasure chunk request v1 receiver.
+	pub chunk_req_v1_receiver: IncomingRequestReceiver<request_v1::ChunkFetchingRequest>,
+	/// Erasure chunk request v2 receiver.
+	pub chunk_req_v2_receiver: IncomingRequestReceiver<request_v2::ChunkFetchingRequest>,
 	/// Receiver for incoming large statement requests.
 	pub statement_req_receiver: IncomingRequestReceiver<request_v1::StatementFetchingRequest>,
 	/// Receiver for incoming candidate requests.
@@ -133,6 +135,10 @@ pub struct ExtendedOverseerGenArgs {
 	pub dispute_coordinator_config: DisputeCoordinatorConfig,
 	/// Configuration for the chain selection subsystem.
 	pub chain_selection_config: ChainSelectionConfig,
+	/// Optional availability recovery fetch chunks threshold. If PoV size size is lower
+	/// than the value put in here we always try to recovery availability from backers.
+	/// The presence of this parameter here is needed to have different values per chain.
+	pub fetch_chunks_threshold: Option<usize>,
 }
 
 /// Obtain a prepared validator `Overseer`, that is initialized with all default values.
@@ -159,13 +165,15 @@ pub fn validator_overseer_builder<Spawner, RuntimeClient>(
 		candidate_validation_config,
 		availability_config,
 		pov_req_receiver,
-		chunk_req_receiver,
+		chunk_req_v1_receiver,
+		chunk_req_v2_receiver,
 		statement_req_receiver,
 		candidate_req_v2_receiver,
 		approval_voting_config,
 		dispute_req_receiver,
 		dispute_coordinator_config,
 		chain_selection_config,
+		fetch_chunks_threshold,
 	}: ExtendedOverseerGenArgs,
 ) -> Result<
 	InitializedOverseerBuilder<
@@ -221,7 +229,7 @@ where
 			network_service.clone(),
 			authority_discovery_service.clone(),
 			network_bridge_metrics.clone(),
-			req_protocol_names,
+			req_protocol_names.clone(),
 			peerset_protocol_names.clone(),
 			notification_sinks.clone(),
 		))
@@ -236,11 +244,18 @@ where
 		))
 		.availability_distribution(AvailabilityDistributionSubsystem::new(
 			keystore.clone(),
-			IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver },
+			IncomingRequestReceivers {
+				pov_req_receiver,
+				chunk_req_v1_receiver,
+				chunk_req_v2_receiver,
+			},
+			req_protocol_names.clone(),
 			Metrics::register(registry)?,
 		))
-		.availability_recovery(AvailabilityRecoverySubsystem::with_chunks_if_pov_large(
+		.availability_recovery(AvailabilityRecoverySubsystem::for_validator(
+			fetch_chunks_threshold,
 			available_data_req_receiver,
+			&req_protocol_names,
 			Metrics::register(registry)?,
 		))
 		.availability_store(AvailabilityStoreSubsystem::new(
@@ -385,7 +400,7 @@ pub fn collator_overseer_builder<Spawner, RuntimeClient>(
 		DummySubsystem,
 		DummySubsystem,
 		DummySubsystem,
-		ProspectiveParachainsSubsystem,
+		DummySubsystem,
 	>,
 	Error,
 >
@@ -406,7 +421,7 @@ where
 			network_service.clone(),
 			authority_discovery_service.clone(),
 			network_bridge_metrics.clone(),
-			req_protocol_names,
+			req_protocol_names.clone(),
 			peerset_protocol_names.clone(),
 			notification_sinks.clone(),
 		))
@@ -421,7 +436,9 @@ where
 		))
 		.availability_distribution(DummySubsystem)
 		.availability_recovery(AvailabilityRecoverySubsystem::for_collator(
+			None,
 			available_data_req_receiver,
+			&req_protocol_names,
 			Metrics::register(registry)?,
 		))
 		.availability_store(DummySubsystem)
@@ -462,7 +479,7 @@ where
 		.dispute_coordinator(DummySubsystem)
 		.dispute_distribution(DummySubsystem)
 		.chain_selection(DummySubsystem)
-		.prospective_parachains(ProspectiveParachainsSubsystem::new(Metrics::register(registry)?))
+		.prospective_parachains(DummySubsystem)
 		.activation_external_listeners(Default::default())
 		.span_per_active_leaf(Default::default())
 		.active_leaves(Default::default())
diff --git a/polkadot/node/service/src/parachains_db/upgrade.rs b/polkadot/node/service/src/parachains_db/upgrade.rs
index 4d7370859609d5559eb9f3b440bb6b4ee28cddff..808acf04b4e704d4a5e5c91556d8aac1524cc545 100644
--- a/polkadot/node/service/src/parachains_db/upgrade.rs
+++ b/polkadot/node/service/src/parachains_db/upgrade.rs
@@ -463,7 +463,7 @@ mod tests {
 		v3::migration_helpers::{v1_to_latest_sanity_check, v2_fill_test_data},
 	};
 	use polkadot_node_subsystem_util::database::kvdb_impl::DbAdapter;
-	use test_helpers::dummy_candidate_receipt;
+	use polkadot_primitives_test_helpers::dummy_candidate_receipt;
 
 	#[test]
 	fn test_paritydb_migrate_0_to_1() {
diff --git a/polkadot/node/service/src/relay_chain_selection.rs b/polkadot/node/service/src/relay_chain_selection.rs
index c5546c34bdba6b2ca42a6bf2a5fc12f06be6e39a..c0b1ce8b0ebe1e38db56c3692ca473d7b31d13c4 100644
--- a/polkadot/node/service/src/relay_chain_selection.rs
+++ b/polkadot/node/service/src/relay_chain_selection.rs
@@ -36,7 +36,6 @@
 #![cfg(feature = "full-node")]
 
 use super::{HeaderProvider, HeaderProviderProvider};
-use consensus_common::{Error as ConsensusError, SelectChain};
 use futures::channel::oneshot;
 use polkadot_node_primitives::MAX_FINALITY_LAG as PRIMITIVES_MAX_FINALITY_LAG;
 use polkadot_node_subsystem::messages::{
@@ -46,9 +45,10 @@ use polkadot_node_subsystem::messages::{
 use polkadot_node_subsystem_util::metrics::{self, prometheus};
 use polkadot_overseer::{AllMessages, Handle};
 use polkadot_primitives::{Block as PolkadotBlock, BlockNumber, Hash, Header as PolkadotHeader};
+use sp_consensus::{Error as ConsensusError, SelectChain};
 use std::sync::Arc;
 
-pub use service::SpawnTaskHandle;
+pub use sc_service::SpawnTaskHandle;
 
 /// The maximum amount of unfinalized blocks we are willing to allow due to approval checking
 /// or disputes.
diff --git a/polkadot/node/service/src/tests.rs b/polkadot/node/service/src/tests.rs
index 26c8083185d84e9f18c27bfbc00779fce6a0b91e..bebd050710135a97ab616c8fe8c3ba21b6d0b9b9 100644
--- a/polkadot/node/service/src/tests.rs
+++ b/polkadot/node/service/src/tests.rs
@@ -19,7 +19,6 @@ use super::{relay_chain_selection::*, *};
 use futures::channel::oneshot::Receiver;
 use polkadot_node_primitives::approval::v2::VrfSignature;
 use polkadot_node_subsystem::messages::{AllMessages, BlockDescription};
-use polkadot_node_subsystem_test_helpers as test_helpers;
 use polkadot_node_subsystem_util::TimeoutExt;
 use polkadot_test_client::Sr25519Keyring;
 use sp_consensus_babe::{
@@ -46,7 +45,8 @@ use polkadot_primitives::{Block, BlockNumber, Hash, Header};
 use polkadot_node_subsystem_test_helpers::TestSubsystemSender;
 use polkadot_overseer::{SubsystemContext, SubsystemSender};
 
-type VirtualOverseer = test_helpers::TestSubsystemContextHandle<ApprovalVotingMessage>;
+type VirtualOverseer =
+	polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle<ApprovalVotingMessage>;
 
 #[async_trait::async_trait]
 impl OverseerHandleT for TestSubsystemSender {
@@ -76,7 +76,8 @@ fn test_harness<T: Future<Output = VirtualOverseer>>(
 		.try_init();
 
 	let pool = TaskExecutor::new();
-	let (mut context, virtual_overseer) = test_helpers::make_subsystem_context(pool);
+	let (mut context, virtual_overseer) =
+		polkadot_node_subsystem_test_helpers::make_subsystem_context(pool);
 
 	let (finality_target_tx, finality_target_rx) = oneshot::channel::<Option<Hash>>();
 
diff --git a/polkadot/node/subsystem-bench/Cargo.toml b/polkadot/node/subsystem-bench/Cargo.toml
index 37c6681b273430ab4f3f5699e014491a50fbf88a..5001104f929a2dc2c596567c8b7febd8088e09f2 100644
--- a/polkadot/node/subsystem-bench/Cargo.toml
+++ b/polkadot/node/subsystem-bench/Cargo.toml
@@ -28,6 +28,7 @@ polkadot-primitives = { path = "../../primitives" }
 polkadot-node-network-protocol = { path = "../network/protocol" }
 polkadot-availability-recovery = { path = "../network/availability-recovery", features = ["subsystem-benchmarks"] }
 polkadot-availability-distribution = { path = "../network/availability-distribution" }
+polkadot-statement-distribution = { path = "../network/statement-distribution" }
 polkadot-node-core-av-store = { path = "../core/av-store" }
 polkadot-node-core-chain-api = { path = "../core/chain-api" }
 polkadot-availability-bitfield-distribution = { path = "../network/bitfield-distribution" }
@@ -55,7 +56,7 @@ rand_distr = "0.4.3"
 bitvec = "1.0.1"
 kvdb-memorydb = "0.13.0"
 
-parity-scale-codec = { version = "3.6.12", features = ["derive", "std"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["derive", "std"] }
 tokio = { version = "1.24.2", features = ["parking_lot", "rt-multi-thread"] }
 clap-num = "1.0.2"
 polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" }
@@ -68,7 +69,7 @@ sp-consensus = { path = "../../../substrate/primitives/consensus/common" }
 polkadot-node-metrics = { path = "../metrics" }
 itertools = "0.11"
 polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" }
-prometheus_endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" }
 prometheus = { version = "0.13.0", default-features = false }
 serde = { workspace = true, default-features = true }
 serde_yaml = { workspace = true }
@@ -86,8 +87,9 @@ rand_core = "0.6.2"
 rand_chacha = { version = "0.3.1" }
 paste = "1.0.14"
 orchestra = { version = "0.3.5", default-features = false, features = ["futures_channel"] }
-pyroscope = "0.5.7"
+pyroscope = { version = "0.5.7" }
 pyroscope_pprofrs = "0.2.7"
+strum = { version = "0.24", features = ["derive"] }
 
 [features]
 default = []
diff --git a/polkadot/node/subsystem-bench/examples/availability_read.yaml b/polkadot/node/subsystem-bench/examples/availability_read.yaml
index 82355b0e2973aaff490a5c2d3ed54d37c61430de..263a6988242e22c4c6f947dbd472a34167ef7453 100644
--- a/polkadot/node/subsystem-bench/examples/availability_read.yaml
+++ b/polkadot/node/subsystem-bench/examples/availability_read.yaml
@@ -1,8 +1,8 @@
 TestConfiguration:
 # Test 1
 - objective: !DataAvailabilityRead
-    fetch_from_backers: true
-  n_validators: 300
+    strategy: FullFromBackers
+  n_validators: 500
   n_cores: 20
   min_pov_size: 5120
   max_pov_size: 5120
@@ -16,7 +16,7 @@ TestConfiguration:
 
 # Test 2
 - objective: !DataAvailabilityRead
-    fetch_from_backers: true
+    strategy: FullFromBackers
   n_validators: 500
   n_cores: 20
   min_pov_size: 5120
@@ -31,7 +31,7 @@ TestConfiguration:
 
 # Test 3
 - objective: !DataAvailabilityRead
-    fetch_from_backers: true
+    strategy: FullFromBackers
   n_validators: 1000
   n_cores: 20
   min_pov_size: 5120
diff --git a/polkadot/node/subsystem-bench/examples/statement_distribution.yaml b/polkadot/node/subsystem-bench/examples/statement_distribution.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e86669ffefc356430c6ce4aa0ccd2ed5fca77474
--- /dev/null
+++ b/polkadot/node/subsystem-bench/examples/statement_distribution.yaml
@@ -0,0 +1,5 @@
+TestConfiguration:
+- objective: StatementDistribution
+  num_blocks: 10
+  n_cores: 100
+  n_validators: 500
diff --git a/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs b/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs
index 10953b6c7839d8ea2a4e0396a4ee37b9875828e9..346a058b9796e2ccfe0aab2b6fbbac6fb1f600d7 100644
--- a/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs
+++ b/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs
@@ -20,7 +20,7 @@
 use clap::Parser;
 use color_eyre::eyre;
 use colored::Colorize;
-use polkadot_subsystem_bench::{approval, availability, configuration};
+use polkadot_subsystem_bench::{approval, availability, configuration, statement};
 use pyroscope::PyroscopeAgent;
 use pyroscope_pprofrs::{pprof_backend, PprofConfig};
 use serde::{Deserialize, Serialize};
@@ -40,6 +40,8 @@ pub enum TestObjective {
 	DataAvailabilityWrite,
 	/// Benchmark the approval-voting and approval-distribution subsystems.
 	ApprovalVoting(approval::ApprovalsOptions),
+	// Benchmark the statement-distribution subsystem
+	StatementDistribution,
 }
 
 impl std::fmt::Display for TestObjective {
@@ -51,6 +53,7 @@ impl std::fmt::Display for TestObjective {
 				Self::DataAvailabilityRead(_) => "DataAvailabilityRead",
 				Self::DataAvailabilityWrite => "DataAvailabilityWrite",
 				Self::ApprovalVoting(_) => "ApprovalVoting",
+				Self::StatementDistribution => "StatementDistribution",
 			}
 		)
 	}
@@ -142,11 +145,8 @@ impl BenchCli {
 						availability::TestDataAvailability::Read(opts),
 						true,
 					);
-					env.runtime().block_on(availability::benchmark_availability_read(
-						&benchmark_name,
-						&mut env,
-						&state,
-					))
+					env.runtime()
+						.block_on(availability::benchmark_availability_read(&mut env, &state))
 				},
 				TestObjective::DataAvailabilityWrite => {
 					let state = availability::TestState::new(&test_config);
@@ -155,23 +155,22 @@ impl BenchCli {
 						availability::TestDataAvailability::Write,
 						true,
 					);
-					env.runtime().block_on(availability::benchmark_availability_write(
-						&benchmark_name,
-						&mut env,
-						&state,
-					))
+					env.runtime()
+						.block_on(availability::benchmark_availability_write(&mut env, &state))
 				},
 				TestObjective::ApprovalVoting(ref options) => {
 					let (mut env, state) =
 						approval::prepare_test(test_config.clone(), options.clone(), true);
-					env.runtime().block_on(approval::bench_approvals(
-						&benchmark_name,
-						&mut env,
-						state,
-					))
+					env.runtime().block_on(approval::bench_approvals(&mut env, state))
+				},
+				TestObjective::StatementDistribution => {
+					let state = statement::TestState::new(&test_config);
+					let (mut env, _protocol_config) = statement::prepare_test(&state, true);
+					env.runtime()
+						.block_on(statement::benchmark_statement_distribution(&mut env, &state))
 				},
 			};
-			println!("{}", usage);
+			println!("\n{}\n{}", benchmark_name.purple(), usage);
 		}
 
 		if let Some(agent_running) = agent_running {
diff --git a/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs b/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs
index e4a6c207970febc06fc364237e8f277728ec905e..6d3e7dd92db151d067c9385dfdb4d39419152b76 100644
--- a/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs
+++ b/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs
@@ -25,9 +25,9 @@ use crate::{
 	mock::runtime_api::session_info_for_peers,
 	NODE_UNDER_TEST,
 };
+use codec::Encode;
 use futures::SinkExt;
 use itertools::Itertools;
-use parity_scale_codec::Encode;
 use polkadot_node_core_approval_voting::{
 	criteria::{compute_assignments, Config},
 	time::tranche_to_tick,
diff --git a/polkadot/node/subsystem-bench/src/lib/approval/mod.rs b/polkadot/node/subsystem-bench/src/lib/approval/mod.rs
index 6ac0776d2d35a496be7737987988a68fd854d956..5c0c65b11cdb5db521ba0045b83f937f72e6b246 100644
--- a/polkadot/node/subsystem-bench/src/lib/approval/mod.rs
+++ b/polkadot/node/subsystem-bench/src/lib/approval/mod.rs
@@ -30,7 +30,7 @@ use crate::{
 	mock::{
 		chain_api::{ChainApiState, MockChainApi},
 		network_bridge::{MockNetworkBridgeRx, MockNetworkBridgeTx},
-		runtime_api::MockRuntimeApi,
+		runtime_api::{MockRuntimeApi, MockRuntimeApiCoreState},
 		AlwaysSupportsParachains, TestSyncOracle,
 	},
 	network::{
@@ -40,12 +40,12 @@ use crate::{
 	usage::BenchmarkUsage,
 	NODE_UNDER_TEST,
 };
+use codec::{Decode, Encode};
 use colored::Colorize;
 use futures::channel::oneshot;
 use itertools::Itertools;
 use orchestra::TimeoutExt;
 use overseer::{metrics::Metrics as OverseerMetrics, MetricsTrait};
-use parity_scale_codec::{Decode, Encode};
 use polkadot_approval_distribution::ApprovalDistribution;
 use polkadot_node_core_approval_voting::{
 	time::{slot_number_to_tick, tick_to_slot_number, Clock, ClockExt, SystemClock},
@@ -465,8 +465,9 @@ impl ApprovalTestState {
 	}
 }
 
+#[async_trait::async_trait]
 impl HandleNetworkMessage for ApprovalTestState {
-	fn handle(
+	async fn handle(
 		&self,
 		_message: crate::network::NetworkMessage,
 		_node_sender: &mut futures::channel::mpsc::UnboundedSender<crate::network::NetworkMessage>,
@@ -807,6 +808,7 @@ fn build_overseer(
 		state.candidate_events_by_block(),
 		Some(state.babe_epoch.clone()),
 		1,
+		MockRuntimeApiCoreState::Occupied,
 	);
 	let mock_tx_bridge = MockNetworkBridgeTx::new(
 		network.clone(),
@@ -886,7 +888,6 @@ fn prepare_test_inner(
 }
 
 pub async fn bench_approvals(
-	benchmark_name: &str,
 	env: &mut TestEnvironment,
 	mut state: ApprovalTestState,
 ) -> BenchmarkUsage {
@@ -898,12 +899,11 @@ pub async fn bench_approvals(
 			env.registry().clone(),
 		)
 		.await;
-	bench_approvals_run(benchmark_name, env, state, producer_rx).await
+	bench_approvals_run(env, state, producer_rx).await
 }
 
 /// Runs the approval benchmark.
 pub async fn bench_approvals_run(
-	benchmark_name: &str,
 	env: &mut TestEnvironment,
 	state: ApprovalTestState,
 	producer_rx: oneshot::Receiver<()>,
@@ -915,7 +915,9 @@ pub async fn bench_approvals_run(
 
 	// First create the initialization messages that make sure that then node under
 	// tests receives notifications about the topology used and the connected peers.
-	let mut initialization_messages = env.network().generate_peer_connected();
+	let mut initialization_messages = env.network().generate_peer_connected(|e| {
+		AllMessages::ApprovalDistribution(ApprovalDistributionMessage::NetworkBridgeUpdate(e))
+	});
 	initialization_messages.extend(generate_new_session_topology(
 		&state.test_authorities,
 		ValidatorIndex(NODE_UNDER_TEST),
@@ -1068,5 +1070,5 @@ pub async fn bench_approvals_run(
 		state.total_unique_messages.load(std::sync::atomic::Ordering::SeqCst)
 	);
 
-	env.collect_resource_usage(benchmark_name, &["approval-distribution", "approval-voting"])
+	env.collect_resource_usage(&["approval-distribution", "approval-voting"])
 }
diff --git a/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs b/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs
index 9641b62a94d8a8612cd394b5964fd66eb1d6a0b4..d23c2552b8b37f51273545763e8275dd637af14a 100644
--- a/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs
+++ b/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs
@@ -18,8 +18,8 @@ use crate::{
 	approval::{ApprovalsOptions, BlockTestData, CandidateTestData},
 	configuration::TestAuthorities,
 };
+use codec::{Decode, Encode};
 use itertools::Itertools;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_node_network_protocol::v3 as protocol_v3;
 use polkadot_primitives::{CandidateIndex, Hash, ValidatorIndex};
 use sc_network_types::PeerId;
diff --git a/polkadot/node/subsystem-bench/src/lib/availability/mod.rs b/polkadot/node/subsystem-bench/src/lib/availability/mod.rs
index 5b93c3d862de683ea35dde9f0a9e313b1a77ad4d..32dc8ae2c8dca329df20277111ef79a036a82bb2 100644
--- a/polkadot/node/subsystem-bench/src/lib/availability/mod.rs
+++ b/polkadot/node/subsystem-bench/src/lib/availability/mod.rs
@@ -17,12 +17,14 @@
 use crate::{
 	availability::av_store_helpers::new_av_store,
 	dummy_builder,
-	environment::{TestEnvironment, TestEnvironmentDependencies, GENESIS_HASH},
+	environment::{TestEnvironment, TestEnvironmentDependencies},
 	mock::{
-		av_store::{self, MockAvailabilityStore, NetworkAvailabilityState},
+		av_store::{MockAvailabilityStore, NetworkAvailabilityState},
 		chain_api::{ChainApiState, MockChainApi},
 		network_bridge::{self, MockNetworkBridgeRx, MockNetworkBridgeTx},
-		runtime_api::{self, MockRuntimeApi},
+		runtime_api::{
+			node_features_with_chunk_mapping_enabled, MockRuntimeApi, MockRuntimeApiCoreState,
+		},
 		AlwaysSupportsParachains,
 	},
 	network::new_network,
@@ -30,16 +32,17 @@ use crate::{
 };
 use colored::Colorize;
 use futures::{channel::oneshot, stream::FuturesUnordered, StreamExt};
-use parity_scale_codec::Encode;
+
+use codec::Encode;
 use polkadot_availability_bitfield_distribution::BitfieldDistribution;
 use polkadot_availability_distribution::{
 	AvailabilityDistributionSubsystem, IncomingRequestReceivers,
 };
-use polkadot_availability_recovery::AvailabilityRecoverySubsystem;
+use polkadot_availability_recovery::{AvailabilityRecoverySubsystem, RecoveryStrategyKind};
 use polkadot_node_core_av_store::AvailabilityStoreSubsystem;
 use polkadot_node_metrics::metrics::Metrics;
 use polkadot_node_network_protocol::{
-	request_response::{IncomingRequest, ReqProtocolNames},
+	request_response::{v1, v2, IncomingRequest},
 	OurView,
 };
 use polkadot_node_subsystem::{
@@ -51,12 +54,13 @@ use polkadot_node_subsystem_types::{
 	Span,
 };
 use polkadot_overseer::{metrics::Metrics as OverseerMetrics, Handle as OverseerHandle};
-use polkadot_primitives::{Block, GroupIndex, Hash};
+use polkadot_primitives::{Block, CoreIndex, GroupIndex, Hash};
 use sc_network::request_responses::{IncomingRequest as RawIncomingRequest, ProtocolConfig};
+use std::{ops::Sub, sync::Arc, time::Instant};
+use strum::Display;
 
 use sc_service::SpawnTaskHandle;
 use serde::{Deserialize, Serialize};
-use std::{ops::Sub, sync::Arc, time::Instant};
 pub use test_state::TestState;
 
 mod av_store_helpers;
@@ -64,15 +68,26 @@ mod test_state;
 
 const LOG_TARGET: &str = "subsystem-bench::availability";
 
+#[derive(clap::ValueEnum, Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Display)]
+#[value(rename_all = "kebab-case")]
+#[strum(serialize_all = "kebab-case")]
+pub enum Strategy {
+	/// Regular random chunk recovery. This is also the fallback for the next strategies.
+	Chunks,
+	/// Recovery from systematic chunks. Much faster than regular chunk recovery becasue it avoid
+	/// doing the reed-solomon reconstruction.
+	Systematic,
+	/// Fetch the full availability datafrom backers first. Saves CPU as we don't need to
+	/// re-construct from chunks. Typically this is only faster if nodes have enough bandwidth.
+	FullFromBackers,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, clap::Parser)]
 #[clap(rename_all = "kebab-case")]
 #[allow(missing_docs)]
 pub struct DataAvailabilityReadOptions {
-	#[clap(short, long, default_value_t = false)]
-	/// Turbo boost AD Read by fetching the full availability datafrom backers first. Saves CPU as
-	/// we don't need to re-construct from chunks. Typically this is only faster if nodes have
-	/// enough bandwidth.
-	pub fetch_from_backers: bool,
+	#[clap(short, long, default_value_t = Strategy::Systematic)]
+	pub strategy: Strategy,
 }
 
 pub enum TestDataAvailability {
@@ -84,7 +99,7 @@ fn build_overseer_for_availability_read(
 	spawn_task_handle: SpawnTaskHandle,
 	runtime_api: MockRuntimeApi,
 	av_store: MockAvailabilityStore,
-	network_bridge: (MockNetworkBridgeTx, MockNetworkBridgeRx),
+	(network_bridge_tx, network_bridge_rx): (MockNetworkBridgeTx, MockNetworkBridgeRx),
 	availability_recovery: AvailabilityRecoverySubsystem,
 	dependencies: &TestEnvironmentDependencies,
 ) -> (Overseer<SpawnGlue<SpawnTaskHandle>, AlwaysSupportsParachains>, OverseerHandle) {
@@ -95,8 +110,8 @@ fn build_overseer_for_availability_read(
 	let builder = dummy
 		.replace_runtime_api(|_| runtime_api)
 		.replace_availability_store(|_| av_store)
-		.replace_network_bridge_tx(|_| network_bridge.0)
-		.replace_network_bridge_rx(|_| network_bridge.1)
+		.replace_network_bridge_tx(|_| network_bridge_tx)
+		.replace_network_bridge_rx(|_| network_bridge_rx)
 		.replace_availability_recovery(|_| availability_recovery);
 
 	let (overseer, raw_handle) =
@@ -109,7 +124,7 @@ fn build_overseer_for_availability_read(
 fn build_overseer_for_availability_write(
 	spawn_task_handle: SpawnTaskHandle,
 	runtime_api: MockRuntimeApi,
-	network_bridge: (MockNetworkBridgeTx, MockNetworkBridgeRx),
+	(network_bridge_tx, network_bridge_rx): (MockNetworkBridgeTx, MockNetworkBridgeRx),
 	availability_distribution: AvailabilityDistributionSubsystem,
 	chain_api: MockChainApi,
 	availability_store: AvailabilityStoreSubsystem,
@@ -123,8 +138,8 @@ fn build_overseer_for_availability_write(
 	let builder = dummy
 		.replace_runtime_api(|_| runtime_api)
 		.replace_availability_store(|_| availability_store)
-		.replace_network_bridge_tx(|_| network_bridge.0)
-		.replace_network_bridge_rx(|_| network_bridge.1)
+		.replace_network_bridge_tx(|_| network_bridge_tx)
+		.replace_network_bridge_rx(|_| network_bridge_rx)
 		.replace_chain_api(|_| chain_api)
 		.replace_bitfield_distribution(|_| bitfield_distribution)
 		// This is needed to test own chunk recovery for `n_cores`.
@@ -142,10 +157,14 @@ pub fn prepare_test(
 	with_prometheus_endpoint: bool,
 ) -> (TestEnvironment, Vec<ProtocolConfig>) {
 	let dependencies = TestEnvironmentDependencies::default();
+
 	let availability_state = NetworkAvailabilityState {
 		candidate_hashes: state.candidate_hashes.clone(),
+		candidate_hash_to_core_index: state.candidate_hash_to_core_index.clone(),
 		available_data: state.available_data.clone(),
 		chunks: state.chunks.clone(),
+		chunk_indices: state.chunk_indices.clone(),
+		req_protocol_names: state.req_protocol_names.clone(),
 	};
 
 	let mut req_cfgs = Vec::new();
@@ -153,20 +172,31 @@ pub fn prepare_test(
 	let (collation_req_receiver, collation_req_cfg) = IncomingRequest::get_config_receiver::<
 		Block,
 		sc_network::NetworkWorker<Block, Hash>,
-	>(&ReqProtocolNames::new(GENESIS_HASH, None));
+	>(&state.req_protocol_names);
 	req_cfgs.push(collation_req_cfg);
 
 	let (pov_req_receiver, pov_req_cfg) = IncomingRequest::get_config_receiver::<
 		Block,
 		sc_network::NetworkWorker<Block, Hash>,
-	>(&ReqProtocolNames::new(GENESIS_HASH, None));
-
-	let (chunk_req_receiver, chunk_req_cfg) = IncomingRequest::get_config_receiver::<
-		Block,
-		sc_network::NetworkWorker<Block, Hash>,
-	>(&ReqProtocolNames::new(GENESIS_HASH, None));
+	>(&state.req_protocol_names);
 	req_cfgs.push(pov_req_cfg);
 
+	let (chunk_req_v1_receiver, chunk_req_v1_cfg) =
+		IncomingRequest::<v1::ChunkFetchingRequest>::get_config_receiver::<
+			Block,
+			sc_network::NetworkWorker<Block, Hash>,
+		>(&state.req_protocol_names);
+
+	// We won't use v1 chunk fetching requests, but we need to keep the inbound queue alive.
+	// Otherwise, av-distribution subsystem will terminate.
+	std::mem::forget(chunk_req_v1_cfg);
+
+	let (chunk_req_v2_receiver, chunk_req_v2_cfg) =
+		IncomingRequest::<v2::ChunkFetchingRequest>::get_config_receiver::<
+			Block,
+			sc_network::NetworkWorker<Block, Hash>,
+		>(&state.req_protocol_names);
+
 	let (network, network_interface, network_receiver) = new_network(
 		&state.config,
 		&dependencies,
@@ -180,37 +210,48 @@ pub fn prepare_test(
 		state.test_authorities.clone(),
 	);
 	let network_bridge_rx =
-		network_bridge::MockNetworkBridgeRx::new(network_receiver, Some(chunk_req_cfg));
+		network_bridge::MockNetworkBridgeRx::new(network_receiver, Some(chunk_req_v2_cfg));
 
-	let runtime_api = runtime_api::MockRuntimeApi::new(
+	let runtime_api = MockRuntimeApi::new(
 		state.config.clone(),
 		state.test_authorities.clone(),
 		state.candidate_receipts.clone(),
 		Default::default(),
 		Default::default(),
 		0,
+		MockRuntimeApiCoreState::Occupied,
 	);
 
 	let (overseer, overseer_handle) = match &mode {
 		TestDataAvailability::Read(options) => {
-			let use_fast_path = options.fetch_from_backers;
-
-			let subsystem = if use_fast_path {
-				AvailabilityRecoverySubsystem::with_fast_path(
+			let subsystem = match options.strategy {
+				Strategy::FullFromBackers =>
+					AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
+						collation_req_receiver,
+						&state.req_protocol_names,
+						Metrics::try_register(&dependencies.registry).unwrap(),
+						RecoveryStrategyKind::BackersFirstAlways,
+					),
+				Strategy::Chunks => AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
 					collation_req_receiver,
+					&state.req_protocol_names,
 					Metrics::try_register(&dependencies.registry).unwrap(),
-				)
-			} else {
-				AvailabilityRecoverySubsystem::with_chunks_only(
+					RecoveryStrategyKind::ChunksAlways,
+				),
+				Strategy::Systematic => AvailabilityRecoverySubsystem::with_recovery_strategy_kind(
 					collation_req_receiver,
+					&state.req_protocol_names,
 					Metrics::try_register(&dependencies.registry).unwrap(),
-				)
+					RecoveryStrategyKind::SystematicChunks,
+				),
 			};
 
 			// Use a mocked av-store.
-			let av_store = av_store::MockAvailabilityStore::new(
+			let av_store = MockAvailabilityStore::new(
 				state.chunks.clone(),
+				state.chunk_indices.clone(),
 				state.candidate_hashes.clone(),
+				state.candidate_hash_to_core_index.clone(),
 			);
 
 			build_overseer_for_availability_read(
@@ -225,7 +266,12 @@ pub fn prepare_test(
 		TestDataAvailability::Write => {
 			let availability_distribution = AvailabilityDistributionSubsystem::new(
 				state.test_authorities.keyring.keystore(),
-				IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver },
+				IncomingRequestReceivers {
+					pov_req_receiver,
+					chunk_req_v1_receiver,
+					chunk_req_v2_receiver,
+				},
+				state.req_protocol_names.clone(),
 				Metrics::try_register(&dependencies.registry).unwrap(),
 			);
 
@@ -261,7 +307,6 @@ pub fn prepare_test(
 }
 
 pub async fn benchmark_availability_read(
-	benchmark_name: &str,
 	env: &mut TestEnvironment,
 	state: &TestState,
 ) -> BenchmarkUsage {
@@ -295,6 +340,7 @@ pub async fn benchmark_availability_read(
 					Some(GroupIndex(
 						candidate_num as u32 % (std::cmp::max(5, config.n_cores) / 5) as u32,
 					)),
+					Some(*state.candidate_hash_to_core_index.get(&candidate.hash()).unwrap()),
 					tx,
 				),
 			);
@@ -326,11 +372,10 @@ pub async fn benchmark_availability_read(
 	);
 
 	env.stop().await;
-	env.collect_resource_usage(benchmark_name, &["availability-recovery"])
+	env.collect_resource_usage(&["availability-recovery"])
 }
 
 pub async fn benchmark_availability_write(
-	benchmark_name: &str,
 	env: &mut TestEnvironment,
 	state: &TestState,
 ) -> BenchmarkUsage {
@@ -340,7 +385,7 @@ pub async fn benchmark_availability_write(
 	env.metrics().set_n_cores(config.n_cores);
 
 	gum::info!(target: LOG_TARGET, "Seeding availability store with candidates ...");
-	for backed_candidate in state.backed_candidates.clone() {
+	for (core_index, backed_candidate) in state.backed_candidates.clone().into_iter().enumerate() {
 		let candidate_index = *state.candidate_hashes.get(&backed_candidate.hash()).unwrap();
 		let available_data = state.available_data[candidate_index].clone();
 		let (tx, rx) = oneshot::channel();
@@ -351,6 +396,8 @@ pub async fn benchmark_availability_write(
 				available_data,
 				expected_erasure_root: backed_candidate.descriptor().erasure_root,
 				tx,
+				core_index: CoreIndex(core_index as u32),
+				node_features: node_features_with_chunk_mapping_enabled(),
 			},
 		))
 		.await;
@@ -459,8 +506,9 @@ pub async fn benchmark_availability_write(
 	);
 
 	env.stop().await;
-	env.collect_resource_usage(
-		benchmark_name,
-		&["availability-distribution", "bitfield-distribution", "availability-store"],
-	)
+	env.collect_resource_usage(&[
+		"availability-distribution",
+		"bitfield-distribution",
+		"availability-store",
+	])
 }
diff --git a/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs b/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs
index c328ffedf916e1ae9ce7fcd05e25750e01dc7506..173b23f6b76e41b925eea27133cf726d07a0f67c 100644
--- a/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs
+++ b/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs
@@ -14,22 +14,28 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::configuration::{TestAuthorities, TestConfiguration};
+use crate::{
+	configuration::{TestAuthorities, TestConfiguration},
+	environment::GENESIS_HASH,
+	mock::runtime_api::node_features_with_chunk_mapping_enabled,
+};
 use bitvec::bitvec;
+use codec::Encode;
 use colored::Colorize;
 use itertools::Itertools;
-use parity_scale_codec::Encode;
 use polkadot_node_network_protocol::{
-	request_response::v1::ChunkFetchingRequest, Versioned, VersionedValidationProtocol,
+	request_response::{v2::ChunkFetchingRequest, ReqProtocolNames},
+	Versioned, VersionedValidationProtocol,
 };
 use polkadot_node_primitives::{AvailableData, BlockData, ErasureChunk, PoV};
 use polkadot_node_subsystem_test_helpers::{
 	derive_erasure_chunks_with_proofs_and_root, mock::new_block_import_info,
 };
+use polkadot_node_subsystem_util::availability_chunks::availability_chunk_indices;
 use polkadot_overseer::BlockInfo;
 use polkadot_primitives::{
-	AvailabilityBitfield, BlockNumber, CandidateHash, CandidateReceipt, Hash, HeadData, Header,
-	PersistedValidationData, Signed, SigningContext, ValidatorIndex,
+	AvailabilityBitfield, BlockNumber, CandidateHash, CandidateReceipt, ChunkIndex, CoreIndex,
+	Hash, HeadData, Header, PersistedValidationData, Signed, SigningContext, ValidatorIndex,
 };
 use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash};
 use sp_core::H256;
@@ -49,14 +55,20 @@ pub struct TestState {
 	pub pov_size_to_candidate: HashMap<usize, usize>,
 	// Map from generated candidate hashes to candidate index in `available_data` and `chunks`.
 	pub candidate_hashes: HashMap<CandidateHash, usize>,
+	// Map from candidate hash to occupied core index.
+	pub candidate_hash_to_core_index: HashMap<CandidateHash, CoreIndex>,
 	// Per candidate index receipts.
 	pub candidate_receipt_templates: Vec<CandidateReceipt>,
 	// Per candidate index `AvailableData`
 	pub available_data: Vec<AvailableData>,
-	// Per candiadte index chunks
+	// Per candidate index chunks
 	pub chunks: Vec<Vec<ErasureChunk>>,
+	// Per-core ValidatorIndex -> ChunkIndex mapping
+	pub chunk_indices: Vec<Vec<ChunkIndex>>,
 	// Per relay chain block - candidate backed by our backing group
 	pub backed_candidates: Vec<CandidateReceipt>,
+	// Request protcol names
+	pub req_protocol_names: ReqProtocolNames,
 	// Relay chain block infos
 	pub block_infos: Vec<BlockInfo>,
 	// Chung fetching requests for backed candidates
@@ -89,6 +101,9 @@ impl TestState {
 			candidate_receipts: Default::default(),
 			block_headers: Default::default(),
 			test_authorities: config.generate_authorities(),
+			req_protocol_names: ReqProtocolNames::new(GENESIS_HASH, None),
+			chunk_indices: Default::default(),
+			candidate_hash_to_core_index: Default::default(),
 		};
 
 		// we use it for all candidates.
@@ -99,6 +114,17 @@ impl TestState {
 			relay_parent_storage_root: Default::default(),
 		};
 
+		test_state.chunk_indices = (0..config.n_cores)
+			.map(|core_index| {
+				availability_chunk_indices(
+					Some(&node_features_with_chunk_mapping_enabled()),
+					config.n_validators,
+					CoreIndex(core_index as u32),
+				)
+				.unwrap()
+			})
+			.collect();
+
 		// For each unique pov we create a candidate receipt.
 		for (index, pov_size) in config.pov_sizes().iter().cloned().unique().enumerate() {
 			gum::info!(target: LOG_TARGET, index, pov_size, "{}", "Generating template candidate".bright_blue());
@@ -167,6 +193,11 @@ impl TestState {
 				// Store the new candidate in the state
 				test_state.candidate_hashes.insert(candidate_receipt.hash(), candidate_index);
 
+				let core_index = (index % config.n_cores) as u32;
+				test_state
+					.candidate_hash_to_core_index
+					.insert(candidate_receipt.hash(), core_index.into());
+
 				gum::debug!(target: LOG_TARGET, candidate_hash = ?candidate_receipt.hash(), "new candidate");
 
 				candidate_receipt
diff --git a/polkadot/node/subsystem-bench/src/lib/configuration.rs b/polkadot/node/subsystem-bench/src/lib/configuration.rs
index 1e0efb72a7dff163898bcf6974ce9bc048bfa086..f614a5e552a803f0a6e2d2475efc5a824b64e9a2 100644
--- a/polkadot/node/subsystem-bench/src/lib/configuration.rs
+++ b/polkadot/node/subsystem-bench/src/lib/configuration.rs
@@ -18,12 +18,13 @@
 
 use crate::keyring::Keyring;
 use itertools::Itertools;
-use polkadot_primitives::{AssignmentId, AuthorityDiscoveryId, ValidatorId};
+use polkadot_primitives::{AssignmentId, AuthorityDiscoveryId, ValidatorId, ValidatorPair};
 use rand::thread_rng;
 use rand_distr::{Distribution, Normal, Uniform};
 use sc_network_types::PeerId;
 use serde::{Deserialize, Serialize};
 use sp_consensus_babe::AuthorityId;
+use sp_core::Pair;
 use std::collections::HashMap;
 
 /// Peer networking latency configuration.
@@ -89,6 +90,15 @@ fn default_n_delay_tranches() -> usize {
 fn default_no_show_slots() -> usize {
 	3
 }
+fn default_minimum_backing_votes() -> u32 {
+	2
+}
+fn default_max_candidate_depth() -> u32 {
+	3
+}
+fn default_allowed_ancestry_len() -> u32 {
+	2
+}
 
 /// The test input parameters
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -137,6 +147,15 @@ pub struct TestConfiguration {
 	pub connectivity: usize,
 	/// Number of blocks to run the test for
 	pub num_blocks: usize,
+	/// Number of minimum backing votes
+	#[serde(default = "default_minimum_backing_votes")]
+	pub minimum_backing_votes: u32,
+	/// Async Backing max_candidate_depth
+	#[serde(default = "default_max_candidate_depth")]
+	pub max_candidate_depth: u32,
+	/// Async Backing allowed_ancestry_len
+	#[serde(default = "default_allowed_ancestry_len")]
+	pub allowed_ancestry_len: u32,
 }
 
 impl Default for TestConfiguration {
@@ -158,6 +177,9 @@ impl Default for TestConfiguration {
 			latency: default_peer_latency(),
 			connectivity: default_connectivity(),
 			num_blocks: Default::default(),
+			minimum_backing_votes: default_minimum_backing_votes(),
+			max_candidate_depth: default_max_candidate_depth(),
+			allowed_ancestry_len: default_allowed_ancestry_len(),
 		}
 	}
 }
@@ -208,6 +230,11 @@ impl TestConfiguration {
 			.map(|(peer_id, authority_id)| (*peer_id, authority_id.clone()))
 			.collect();
 
+		let validator_pairs = key_seeds
+			.iter()
+			.map(|seed| ValidatorPair::from_string_with_seed(seed, None).unwrap().0)
+			.collect();
+
 		TestAuthorities {
 			keyring,
 			validator_public,
@@ -217,6 +244,7 @@ impl TestConfiguration {
 			validator_assignment_id,
 			key_seeds,
 			peer_id_to_authority,
+			validator_pairs,
 		}
 	}
 }
@@ -246,6 +274,7 @@ pub struct TestAuthorities {
 	pub key_seeds: Vec<String>,
 	pub peer_ids: Vec<PeerId>,
 	pub peer_id_to_authority: HashMap<PeerId, AuthorityDiscoveryId>,
+	pub validator_pairs: Vec<ValidatorPair>,
 }
 
 /// Sample latency (in milliseconds) from a normal distribution with parameters
diff --git a/polkadot/node/subsystem-bench/src/lib/environment.rs b/polkadot/node/subsystem-bench/src/lib/environment.rs
index 42955d0302232f35e387a044e34a0c7d665512e8..a63f90da50b3aabcacca38874d723e7166173842 100644
--- a/polkadot/node/subsystem-bench/src/lib/environment.rs
+++ b/polkadot/node/subsystem-bench/src/lib/environment.rs
@@ -351,13 +351,8 @@ impl TestEnvironment {
 		}
 	}
 
-	pub fn collect_resource_usage(
-		&self,
-		benchmark_name: &str,
-		subsystems_under_test: &[&str],
-	) -> BenchmarkUsage {
+	pub fn collect_resource_usage(&self, subsystems_under_test: &[&str]) -> BenchmarkUsage {
 		BenchmarkUsage {
-			benchmark_name: benchmark_name.to_string(),
 			network_usage: self.network_usage(),
 			cpu_usage: self.cpu_usage(subsystems_under_test),
 		}
diff --git a/polkadot/node/subsystem-bench/src/lib/lib.rs b/polkadot/node/subsystem-bench/src/lib/lib.rs
index ef2724abc98920c79d8dd9d94f97bed32b0ab8e2..e18227af8be349debc38043529bd1649c67e1c56 100644
--- a/polkadot/node/subsystem-bench/src/lib/lib.rs
+++ b/polkadot/node/subsystem-bench/src/lib/lib.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-// The validator index that represent the node that is under test.
+// The validator index that represents the node that is under test.
 pub const NODE_UNDER_TEST: u32 = 0;
 
 pub mod approval;
@@ -25,5 +25,6 @@ pub(crate) mod environment;
 pub(crate) mod keyring;
 pub(crate) mod mock;
 pub(crate) mod network;
+pub mod statement;
 pub mod usage;
 pub mod utils;
diff --git a/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs b/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs
index fba33523be85dbfd241bc1fcf42d8f8069ebf95c..7586e848ab4756bbcbb4a2d8f74cc2325477f58d 100644
--- a/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs
+++ b/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs
@@ -17,10 +17,10 @@
 //! A generic av store subsystem mockup suitable to be used in benchmarks.
 
 use crate::network::{HandleNetworkMessage, NetworkMessage};
+use codec::Encode;
 use futures::{channel::oneshot, FutureExt};
-use parity_scale_codec::Encode;
 use polkadot_node_network_protocol::request_response::{
-	v1::{AvailableDataFetchingResponse, ChunkFetchingResponse, ChunkResponse},
+	v1::AvailableDataFetchingResponse, v2::ChunkFetchingResponse, Protocol, ReqProtocolNames,
 	Requests,
 };
 use polkadot_node_primitives::{AvailableData, ErasureChunk};
@@ -28,13 +28,14 @@ use polkadot_node_subsystem::{
 	messages::AvailabilityStoreMessage, overseer, SpawnedSubsystem, SubsystemError,
 };
 use polkadot_node_subsystem_types::OverseerSignal;
-use polkadot_primitives::CandidateHash;
-use sc_network::ProtocolName;
+use polkadot_primitives::{CandidateHash, ChunkIndex, CoreIndex, ValidatorIndex};
 use std::collections::HashMap;
 
 pub struct AvailabilityStoreState {
 	candidate_hashes: HashMap<CandidateHash, usize>,
 	chunks: Vec<Vec<ErasureChunk>>,
+	chunk_indices: Vec<Vec<ChunkIndex>>,
+	candidate_hash_to_core_index: HashMap<CandidateHash, CoreIndex>,
 }
 
 const LOG_TARGET: &str = "subsystem-bench::av-store-mock";
@@ -43,21 +44,25 @@ const LOG_TARGET: &str = "subsystem-bench::av-store-mock";
 /// used in a test.
 #[derive(Clone)]
 pub struct NetworkAvailabilityState {
+	pub req_protocol_names: ReqProtocolNames,
 	pub candidate_hashes: HashMap<CandidateHash, usize>,
 	pub available_data: Vec<AvailableData>,
 	pub chunks: Vec<Vec<ErasureChunk>>,
+	pub chunk_indices: Vec<Vec<ChunkIndex>>,
+	pub candidate_hash_to_core_index: HashMap<CandidateHash, CoreIndex>,
 }
 
 // Implement access to the state.
+#[async_trait::async_trait]
 impl HandleNetworkMessage for NetworkAvailabilityState {
-	fn handle(
+	async fn handle(
 		&self,
 		message: NetworkMessage,
 		_node_sender: &mut futures::channel::mpsc::UnboundedSender<NetworkMessage>,
 	) -> Option<NetworkMessage> {
 		match message {
 			NetworkMessage::RequestFromNode(peer, request) => match request {
-				Requests::ChunkFetchingV1(outgoing_request) => {
+				Requests::ChunkFetching(outgoing_request) => {
 					gum::debug!(target: LOG_TARGET, request = ?outgoing_request, "Received `RequestFromNode`");
 					let validator_index: usize = outgoing_request.payload.index.0 as usize;
 					let candidate_hash = outgoing_request.payload.candidate_hash;
@@ -68,11 +73,22 @@ impl HandleNetworkMessage for NetworkAvailabilityState {
 						.expect("candidate was generated previously; qed");
 					gum::warn!(target: LOG_TARGET, ?candidate_hash, candidate_index, "Candidate mapped to index");
 
-					let chunk: ChunkResponse =
-						self.chunks.get(*candidate_index).unwrap()[validator_index].clone().into();
+					let candidate_chunks = self.chunks.get(*candidate_index).unwrap();
+					let chunk_indices = self
+						.chunk_indices
+						.get(
+							self.candidate_hash_to_core_index.get(&candidate_hash).unwrap().0
+								as usize,
+						)
+						.unwrap();
+
+					let chunk = candidate_chunks
+						.get(chunk_indices.get(validator_index).unwrap().0 as usize)
+						.unwrap();
+
 					let response = Ok((
-						ChunkFetchingResponse::from(Some(chunk)).encode(),
-						ProtocolName::Static("dummy"),
+						ChunkFetchingResponse::from(Some(chunk.clone())).encode(),
+						self.req_protocol_names.get_name(Protocol::ChunkFetchingV2),
 					));
 
 					if let Err(err) = outgoing_request.pending_response.send(response) {
@@ -93,7 +109,7 @@ impl HandleNetworkMessage for NetworkAvailabilityState {
 
 					let response = Ok((
 						AvailableDataFetchingResponse::from(Some(available_data)).encode(),
-						ProtocolName::Static("dummy"),
+						self.req_protocol_names.get_name(Protocol::AvailableDataFetchingV1),
 					));
 					outgoing_request
 						.pending_response
@@ -118,16 +134,25 @@ pub struct MockAvailabilityStore {
 impl MockAvailabilityStore {
 	pub fn new(
 		chunks: Vec<Vec<ErasureChunk>>,
+		chunk_indices: Vec<Vec<ChunkIndex>>,
 		candidate_hashes: HashMap<CandidateHash, usize>,
+		candidate_hash_to_core_index: HashMap<CandidateHash, CoreIndex>,
 	) -> MockAvailabilityStore {
-		Self { state: AvailabilityStoreState { chunks, candidate_hashes } }
+		Self {
+			state: AvailabilityStoreState {
+				chunks,
+				candidate_hashes,
+				chunk_indices,
+				candidate_hash_to_core_index,
+			},
+		}
 	}
 
 	async fn respond_to_query_all_request(
 		&self,
 		candidate_hash: CandidateHash,
-		send_chunk: impl Fn(usize) -> bool,
-		tx: oneshot::Sender<Vec<ErasureChunk>>,
+		send_chunk: impl Fn(ValidatorIndex) -> bool,
+		tx: oneshot::Sender<Vec<(ValidatorIndex, ErasureChunk)>>,
 	) {
 		let candidate_index = self
 			.state
@@ -136,15 +161,27 @@ impl MockAvailabilityStore {
 			.expect("candidate was generated previously; qed");
 		gum::debug!(target: LOG_TARGET, ?candidate_hash, candidate_index, "Candidate mapped to index");
 
-		let v = self
-			.state
-			.chunks
-			.get(*candidate_index)
-			.unwrap()
-			.iter()
-			.filter(|c| send_chunk(c.index.0 as usize))
-			.cloned()
-			.collect();
+		let n_validators = self.state.chunks[0].len();
+		let candidate_chunks = self.state.chunks.get(*candidate_index).unwrap();
+		let core_index = self.state.candidate_hash_to_core_index.get(&candidate_hash).unwrap();
+		// We'll likely only send our chunk, so use capacity 1.
+		let mut v = Vec::with_capacity(1);
+
+		for validator_index in 0..n_validators {
+			if !send_chunk(ValidatorIndex(validator_index as u32)) {
+				continue;
+			}
+			let chunk_index = self
+				.state
+				.chunk_indices
+				.get(core_index.0 as usize)
+				.unwrap()
+				.get(validator_index)
+				.unwrap();
+
+			let chunk = candidate_chunks.get(chunk_index.0 as usize).unwrap().clone();
+			v.push((ValidatorIndex(validator_index as u32), chunk.clone()));
+		}
 
 		let _ = tx.send(v);
 	}
@@ -181,8 +218,12 @@ impl MockAvailabilityStore {
 					AvailabilityStoreMessage::QueryAllChunks(candidate_hash, tx) => {
 						// We always have our own chunk.
 						gum::debug!(target: LOG_TARGET, candidate_hash = ?candidate_hash, "Responding to QueryAllChunks");
-						self.respond_to_query_all_request(candidate_hash, |index| index == 0, tx)
-							.await;
+						self.respond_to_query_all_request(
+							candidate_hash,
+							|index| index == 0.into(),
+							tx,
+						)
+						.await;
 					},
 					AvailabilityStoreMessage::QueryChunkSize(candidate_hash, tx) => {
 						gum::debug!(target: LOG_TARGET, candidate_hash = ?candidate_hash, "Responding to QueryChunkSize");
@@ -194,12 +235,29 @@ impl MockAvailabilityStore {
 							.expect("candidate was generated previously; qed");
 						gum::debug!(target: LOG_TARGET, ?candidate_hash, candidate_index, "Candidate mapped to index");
 
-						let chunk_size =
-							self.state.chunks.get(*candidate_index).unwrap()[0].encoded_size();
+						let chunk_size = self
+							.state
+							.chunks
+							.get(*candidate_index)
+							.unwrap()
+							.first()
+							.unwrap()
+							.encoded_size();
 						let _ = tx.send(Some(chunk_size));
 					},
-					AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk, tx } => {
-						gum::debug!(target: LOG_TARGET, chunk_index = ?chunk.index ,candidate_hash = ?candidate_hash, "Responding to StoreChunk");
+					AvailabilityStoreMessage::StoreChunk {
+						candidate_hash,
+						chunk,
+						tx,
+						validator_index,
+					} => {
+						gum::debug!(
+							target: LOG_TARGET,
+							chunk_index = ?chunk.index,
+							validator_index = ?validator_index,
+							candidate_hash = ?candidate_hash,
+							"Responding to StoreChunk"
+						);
 						let _ = tx.send(Ok(()));
 					},
 					_ => {
diff --git a/polkadot/node/subsystem-bench/src/lib/mock/candidate_backing.rs b/polkadot/node/subsystem-bench/src/lib/mock/candidate_backing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51494016e185e5e04f00c264eb341bf25d8991dd
--- /dev/null
+++ b/polkadot/node/subsystem-bench/src/lib/mock/candidate_backing.rs
@@ -0,0 +1,171 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A generic candidate backing subsystem mockup suitable to be used in benchmarks.
+
+use crate::{configuration::TestConfiguration, NODE_UNDER_TEST};
+use futures::FutureExt;
+use polkadot_node_primitives::{SignedFullStatementWithPVD, Statement, StatementWithPVD};
+use polkadot_node_subsystem::{
+	messages::CandidateBackingMessage, overseer, SpawnedSubsystem, SubsystemError,
+};
+use polkadot_node_subsystem_types::OverseerSignal;
+use polkadot_primitives::{
+	CandidateHash, Hash, PersistedValidationData, SigningContext, ValidatorIndex, ValidatorPair,
+};
+use sp_core::Pair;
+use std::collections::HashMap;
+
+const LOG_TARGET: &str = "subsystem-bench::candidate-backing-mock";
+
+struct MockCandidateBackingState {
+	pair: ValidatorPair,
+	pvd: PersistedValidationData,
+	own_backing_group: Vec<ValidatorIndex>,
+}
+
+pub struct MockCandidateBacking {
+	config: TestConfiguration,
+	state: MockCandidateBackingState,
+}
+
+impl MockCandidateBacking {
+	pub fn new(
+		config: TestConfiguration,
+		pair: ValidatorPair,
+		pvd: PersistedValidationData,
+		own_backing_group: Vec<ValidatorIndex>,
+	) -> Self {
+		Self { config, state: MockCandidateBackingState { pair, pvd, own_backing_group } }
+	}
+
+	fn handle_statement(
+		&self,
+		relay_parent: Hash,
+		statement: SignedFullStatementWithPVD,
+		statements_tracker: &mut HashMap<CandidateHash, u32>,
+	) -> Vec<polkadot_node_subsystem::messages::StatementDistributionMessage> {
+		let mut messages = vec![];
+		let validator_id = statement.validator_index();
+		let is_own_backing_group = self.state.own_backing_group.contains(&validator_id);
+
+		match statement.payload() {
+			StatementWithPVD::Seconded(receipt, _pvd) => {
+				let candidate_hash = receipt.hash();
+				statements_tracker
+					.entry(candidate_hash)
+					.and_modify(|v| {
+						*v += 1;
+					})
+					.or_insert(1);
+
+				let statements_received_count = *statements_tracker.get(&candidate_hash).unwrap();
+				if statements_received_count == (self.config.minimum_backing_votes - 1) &&
+					is_own_backing_group
+				{
+					let statement = Statement::Valid(candidate_hash);
+					let context = SigningContext { parent_hash: relay_parent, session_index: 0 };
+					let payload = statement.to_compact().signing_payload(&context);
+					let message =
+						polkadot_node_subsystem::messages::StatementDistributionMessage::Share(
+							relay_parent,
+							SignedFullStatementWithPVD::new(
+								statement.supply_pvd(self.state.pvd.clone()),
+								ValidatorIndex(NODE_UNDER_TEST),
+								self.state.pair.sign(&payload[..]),
+								&context,
+								&self.state.pair.public(),
+							)
+							.unwrap(),
+						);
+					messages.push(message);
+				}
+
+				if statements_received_count == self.config.minimum_backing_votes {
+					let message =
+						polkadot_node_subsystem::messages::StatementDistributionMessage::Backed(
+							candidate_hash,
+						);
+					messages.push(message);
+				}
+			},
+			StatementWithPVD::Valid(candidate_hash) => {
+				statements_tracker
+					.entry(*candidate_hash)
+					.and_modify(|v| {
+						*v += 1;
+					})
+					.or_insert(1);
+
+				let statements_received_count = *statements_tracker.get(candidate_hash).unwrap();
+				if statements_received_count == self.config.minimum_backing_votes {
+					let message =
+						polkadot_node_subsystem::messages::StatementDistributionMessage::Backed(
+							*candidate_hash,
+						);
+					messages.push(message);
+				}
+			},
+		}
+
+		messages
+	}
+}
+
+#[overseer::subsystem(CandidateBacking, error=SubsystemError, prefix=self::overseer)]
+impl<Context> MockCandidateBacking {
+	fn start(self, ctx: Context) -> SpawnedSubsystem {
+		let future = self.run(ctx).map(|_| Ok(())).boxed();
+
+		SpawnedSubsystem { name: "test-environment", future }
+	}
+}
+
+#[overseer::contextbounds(CandidateBacking, prefix = self::overseer)]
+impl MockCandidateBacking {
+	async fn run<Context>(self, mut ctx: Context) {
+		let mut statements_tracker: HashMap<CandidateHash, u32> = Default::default();
+
+		loop {
+			let msg = ctx.recv().await.expect("Overseer never fails us");
+			match msg {
+				orchestra::FromOrchestra::Signal(signal) =>
+					if signal == OverseerSignal::Conclude {
+						return
+					},
+				orchestra::FromOrchestra::Communication { msg } => {
+					gum::trace!(target: LOG_TARGET, msg=?msg, "recv message");
+
+					match msg {
+						CandidateBackingMessage::Statement(relay_parent, statement) => {
+							let messages = self.handle_statement(
+								relay_parent,
+								statement,
+								&mut statements_tracker,
+							);
+							for message in messages {
+								ctx.send_message(message).await;
+							}
+						},
+						_ => {
+							unimplemented!("Unexpected candidate-backing message")
+						},
+					}
+				},
+			}
+		}
+	}
+}
diff --git a/polkadot/node/subsystem-bench/src/lib/mock/mod.rs b/polkadot/node/subsystem-bench/src/lib/mock/mod.rs
index 6dda9a47d398f3e6e952cd054bce9769e8942e70..12766374bfa9f49ad67699173cdda512623c4b8b 100644
--- a/polkadot/node/subsystem-bench/src/lib/mock/mod.rs
+++ b/polkadot/node/subsystem-bench/src/lib/mock/mod.rs
@@ -19,9 +19,11 @@ use polkadot_node_subsystem_types::Hash;
 use sp_consensus::SyncOracle;
 
 pub mod av_store;
+pub mod candidate_backing;
 pub mod chain_api;
 pub mod dummy;
 pub mod network_bridge;
+pub mod prospective_parachains;
 pub mod runtime_api;
 
 pub struct AlwaysSupportsParachains {}
diff --git a/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs b/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs
index ec66ad4e279c217f7510d4c09def128f41fbffe5..d70953926d130eabc7be096cab71ff59d6e91bc8 100644
--- a/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs
+++ b/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs
@@ -27,14 +27,19 @@ use polkadot_node_subsystem::{
 	messages::NetworkBridgeTxMessage, overseer, SpawnedSubsystem, SubsystemError,
 };
 use polkadot_node_subsystem_types::{
-	messages::{ApprovalDistributionMessage, BitfieldDistributionMessage, NetworkBridgeEvent},
+	messages::{
+		ApprovalDistributionMessage, BitfieldDistributionMessage, NetworkBridgeEvent,
+		StatementDistributionMessage,
+	},
 	OverseerSignal,
 };
 use sc_network::{request_responses::ProtocolConfig, RequestFailure};
 
 const LOG_TARGET: &str = "subsystem-bench::network-bridge";
-const CHUNK_REQ_PROTOCOL_NAME_V1: &str =
-	"/ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/req_chunk/1";
+const ALLOWED_PROTOCOLS: &[&str] = &[
+	"/ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/req_chunk/2",
+	"/ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/req_attested_candidate/2",
+];
 
 /// A mock of the network bridge tx subsystem.
 pub struct MockNetworkBridgeTx {
@@ -106,8 +111,15 @@ impl MockNetworkBridgeTx {
 					NetworkBridgeTxMessage::SendRequests(requests, _if_disconnected) => {
 						for request in requests {
 							gum::debug!(target: LOG_TARGET, request = ?request, "Processing request");
-							let peer_id =
-								request.authority_id().expect("all nodes are authorities").clone();
+							let peer_id = match request.authority_id() {
+								Some(v) => v.clone(),
+								None => self
+									.test_authorities
+									.peer_id_to_authority
+									.get(request.peer_id().expect("Should exist"))
+									.expect("Should exist")
+									.clone(),
+							};
 
 							if !self.network.is_peer_connected(&peer_id) {
 								// Attempting to send a request to a disconnected peer.
@@ -141,7 +153,23 @@ impl MockNetworkBridgeTx {
 								.expect("Should not fail");
 						}
 					},
-					_ => unimplemented!("Unexpected network bridge message"),
+					NetworkBridgeTxMessage::SendValidationMessages(messages) => {
+						for (peers, message) in messages {
+							for peer in peers {
+								self.to_network_interface
+									.unbounded_send(NetworkMessage::MessageFromNode(
+										self.test_authorities
+											.peer_id_to_authority
+											.get(&peer)
+											.unwrap()
+											.clone(),
+										message.clone(),
+									))
+									.expect("Should not fail");
+							}
+						}
+					},
+					message => unimplemented!("Unexpected network bridge message {:?}", message),
 				},
 			}
 		}
@@ -175,13 +203,20 @@ impl MockNetworkBridgeRx {
 										ApprovalDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage(peer_id, polkadot_node_network_protocol::Versioned::V3(msg)))
 									).await;
 								}
+								Versioned::V3(
+									polkadot_node_network_protocol::v3::ValidationProtocol::StatementDistribution(msg)
+								) => {
+									ctx.send_message(
+										StatementDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage(peer_id, polkadot_node_network_protocol::Versioned::V3(msg)))
+									).await;
+								}
 								_ => {
 									unimplemented!("We only talk v2 network protocol")
 								},
 							},
 							NetworkMessage::RequestFromPeer(request) => {
 								if let Some(protocol) = self.chunk_request_sender.as_mut() {
-									assert_eq!(&*protocol.name, CHUNK_REQ_PROTOCOL_NAME_V1);
+									assert!(ALLOWED_PROTOCOLS.contains(&&*protocol.name));
 									if let Some(inbound_queue) = protocol.inbound_queue.as_ref() {
 										inbound_queue
 											.send(request)
diff --git a/polkadot/node/subsystem-bench/src/lib/mock/prospective_parachains.rs b/polkadot/node/subsystem-bench/src/lib/mock/prospective_parachains.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8a865af21a073aefe55b85b37e7ccd091e8a2f0f
--- /dev/null
+++ b/polkadot/node/subsystem-bench/src/lib/mock/prospective_parachains.rs
@@ -0,0 +1,74 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A generic prospective parachains subsystem mockup suitable to be used in benchmarks.
+
+use futures::FutureExt;
+use polkadot_node_subsystem::{
+	messages::ProspectiveParachainsMessage, overseer, SpawnedSubsystem, SubsystemError,
+};
+use polkadot_node_subsystem_types::OverseerSignal;
+use polkadot_primitives::Hash;
+
+pub struct MockProspectiveParachains {}
+
+impl MockProspectiveParachains {
+	pub fn new() -> Self {
+		Self {}
+	}
+}
+
+#[overseer::subsystem(ProspectiveParachains, error=SubsystemError, prefix=self::overseer)]
+impl<Context> MockProspectiveParachains {
+	fn start(self, ctx: Context) -> SpawnedSubsystem {
+		let future = self.run(ctx).map(|_| Ok(())).boxed();
+
+		SpawnedSubsystem { name: "test-environment", future }
+	}
+}
+
+#[overseer::contextbounds(ProspectiveParachains, prefix = self::overseer)]
+impl MockProspectiveParachains {
+	async fn run<Context>(self, mut ctx: Context) {
+		loop {
+			let msg = ctx.recv().await.expect("Overseer never fails us");
+			match msg {
+				orchestra::FromOrchestra::Signal(signal) =>
+					if signal == OverseerSignal::Conclude {
+						return
+					},
+				orchestra::FromOrchestra::Communication { msg } => match msg {
+					ProspectiveParachainsMessage::GetMinimumRelayParents(_relay_parent, tx) => {
+						tx.send(vec![]).unwrap();
+					},
+					ProspectiveParachainsMessage::GetHypotheticalMembership(req, tx) => {
+						tx.send(
+							req.candidates
+								.iter()
+								.cloned()
+								.map(|candidate| (candidate, vec![Hash::repeat_byte(0)]))
+								.collect(),
+						)
+						.unwrap();
+					},
+					_ => {
+						unimplemented!("Unexpected chain-api message")
+					},
+				},
+			}
+		}
+	}
+}
diff --git a/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs b/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs
index b73d61321cd3b274915dda37233c1945240c2b11..be9dbd55cb6f9898a879e7bbaa6c5f5b9c303484 100644
--- a/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs
+++ b/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs
@@ -26,8 +26,9 @@ use polkadot_node_subsystem::{
 };
 use polkadot_node_subsystem_types::OverseerSignal;
 use polkadot_primitives::{
-	CandidateEvent, CandidateReceipt, CoreState, GroupIndex, IndexedVec, NodeFeatures,
-	OccupiedCore, SessionIndex, SessionInfo, ValidatorIndex,
+	node_features, AsyncBackingParams, CandidateEvent, CandidateReceipt, CoreState, GroupIndex,
+	GroupRotationInfo, IndexedVec, NodeFeatures, OccupiedCore, ScheduledCore, SessionIndex,
+	SessionInfo, ValidatorIndex,
 };
 use sp_consensus_babe::Epoch as BabeEpoch;
 use sp_core::H256;
@@ -40,6 +41,8 @@ const LOG_TARGET: &str = "subsystem-bench::runtime-api-mock";
 pub struct RuntimeApiState {
 	// All authorities in the test,
 	authorities: TestAuthorities,
+	// Node features state in the runtime
+	node_features: NodeFeatures,
 	// Candidate hashes per block
 	candidate_hashes: HashMap<H256, Vec<CandidateReceipt>>,
 	// Included candidates per bock
@@ -49,11 +52,20 @@ pub struct RuntimeApiState {
 	session_index: SessionIndex,
 }
 
+#[derive(Clone)]
+pub enum MockRuntimeApiCoreState {
+	Occupied,
+	Scheduled,
+	#[allow(dead_code)]
+	Free,
+}
+
 /// A mocked `runtime-api` subsystem.
 #[derive(Clone)]
 pub struct MockRuntimeApi {
 	state: RuntimeApiState,
 	config: TestConfiguration,
+	core_state: MockRuntimeApiCoreState,
 }
 
 impl MockRuntimeApi {
@@ -64,7 +76,11 @@ impl MockRuntimeApi {
 		included_candidates: HashMap<H256, Vec<CandidateEvent>>,
 		babe_epoch: Option<BabeEpoch>,
 		session_index: SessionIndex,
+		core_state: MockRuntimeApiCoreState,
 	) -> MockRuntimeApi {
+		// Enable chunk mapping feature to make systematic av-recovery possible.
+		let node_features = node_features_with_chunk_mapping_enabled();
+
 		Self {
 			state: RuntimeApiState {
 				authorities,
@@ -72,8 +88,10 @@ impl MockRuntimeApi {
 				included_candidates,
 				babe_epoch,
 				session_index,
+				node_features,
 			},
 			config,
+			core_state,
 		}
 	}
 
@@ -156,15 +174,15 @@ impl MockRuntimeApi {
 						},
 						RuntimeApiMessage::Request(
 							_block_hash,
-							RuntimeApiRequest::SessionExecutorParams(_session_index, sender),
+							RuntimeApiRequest::NodeFeatures(_session_index, sender),
 						) => {
-							let _ = sender.send(Ok(Some(Default::default())));
+							let _ = sender.send(Ok(self.state.node_features.clone()));
 						},
 						RuntimeApiMessage::Request(
-							_request,
-							RuntimeApiRequest::NodeFeatures(_session_index, sender),
+							_block_hash,
+							RuntimeApiRequest::SessionExecutorParams(_session_index, sender),
 						) => {
-							let _ = sender.send(Ok(NodeFeatures::EMPTY));
+							let _ = sender.send(Ok(Some(Default::default())));
 						},
 						RuntimeApiMessage::Request(
 							_block_hash,
@@ -198,16 +216,26 @@ impl MockRuntimeApi {
 									// Ensure test breaks if badly configured.
 									assert!(index < validator_group_count);
 
-									CoreState::Occupied(OccupiedCore {
-										next_up_on_available: None,
-										occupied_since: 0,
-										time_out_at: 0,
-										next_up_on_time_out: None,
-										availability: BitVec::default(),
-										group_responsible: GroupIndex(index as u32),
-										candidate_hash: candidate_receipt.hash(),
-										candidate_descriptor: candidate_receipt.descriptor.clone(),
-									})
+									use MockRuntimeApiCoreState::*;
+									match self.core_state {
+										Occupied => CoreState::Occupied(OccupiedCore {
+											next_up_on_available: None,
+											occupied_since: 0,
+											time_out_at: 0,
+											next_up_on_time_out: None,
+											availability: BitVec::default(),
+											group_responsible: GroupIndex(index as u32),
+											candidate_hash: candidate_receipt.hash(),
+											candidate_descriptor: candidate_receipt
+												.descriptor
+												.clone(),
+										}),
+										Scheduled => CoreState::Scheduled(ScheduledCore {
+											para_id: (index + 1).into(),
+											collator: None,
+										}),
+										Free => todo!(),
+									}
 								})
 								.collect::<Vec<_>>();
 
@@ -223,6 +251,43 @@ impl MockRuntimeApi {
 								.clone()
 								.expect("Babe epoch unpopulated")));
 						},
+						RuntimeApiMessage::Request(
+							_block_hash,
+							RuntimeApiRequest::AsyncBackingParams(sender),
+						) => {
+							let _ = sender.send(Ok(AsyncBackingParams {
+								max_candidate_depth: self.config.max_candidate_depth,
+								allowed_ancestry_len: self.config.allowed_ancestry_len,
+							}));
+						},
+						RuntimeApiMessage::Request(_parent, RuntimeApiRequest::Version(tx)) => {
+							tx.send(Ok(RuntimeApiRequest::DISABLED_VALIDATORS_RUNTIME_REQUIREMENT))
+								.unwrap();
+						},
+						RuntimeApiMessage::Request(
+							_parent,
+							RuntimeApiRequest::DisabledValidators(tx),
+						) => {
+							tx.send(Ok(vec![])).unwrap();
+						},
+						RuntimeApiMessage::Request(
+							_parent,
+							RuntimeApiRequest::MinimumBackingVotes(_session_index, tx),
+						) => {
+							tx.send(Ok(self.config.minimum_backing_votes)).unwrap();
+						},
+						RuntimeApiMessage::Request(
+							_parent,
+							RuntimeApiRequest::ValidatorGroups(tx),
+						) => {
+							let groups = self.session_info().validator_groups.to_vec();
+							let group_rotation_info = GroupRotationInfo {
+								session_start_block: 1,
+								group_rotation_frequency: 12,
+								now: 1,
+							};
+							tx.send(Ok((groups, group_rotation_info))).unwrap();
+						},
 						// Long term TODO: implement more as needed.
 						message => {
 							unimplemented!("Unexpected runtime-api message: {:?}", message)
@@ -233,3 +298,10 @@ impl MockRuntimeApi {
 		}
 	}
 }
+
+pub fn node_features_with_chunk_mapping_enabled() -> NodeFeatures {
+	let mut node_features = NodeFeatures::new();
+	node_features.resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false);
+	node_features.set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true);
+	node_features
+}
diff --git a/polkadot/node/subsystem-bench/src/lib/network.rs b/polkadot/node/subsystem-bench/src/lib/network.rs
index 9bf2415e5a864a9c4512350b9387b6c172b37114..331dd7d25156675c6866a153b3a3fac3e3988256 100644
--- a/polkadot/node/subsystem-bench/src/lib/network.rs
+++ b/polkadot/node/subsystem-bench/src/lib/network.rs
@@ -38,6 +38,7 @@ use crate::{
 	environment::TestEnvironmentDependencies,
 	NODE_UNDER_TEST,
 };
+use codec::Encode;
 use colored::Colorize;
 use futures::{
 	channel::{
@@ -51,13 +52,13 @@ use futures::{
 };
 use itertools::Itertools;
 use net_protocol::{
-	peer_set::{ProtocolVersion, ValidationVersion},
+	peer_set::ValidationVersion,
 	request_response::{Recipient, Requests, ResponseSender},
-	ObservedRole, VersionedValidationProtocol,
+	ObservedRole, VersionedValidationProtocol, View,
 };
-use parity_scale_codec::Encode;
 use polkadot_node_network_protocol::{self as net_protocol, Versioned};
-use polkadot_node_subsystem_types::messages::{ApprovalDistributionMessage, NetworkBridgeEvent};
+use polkadot_node_subsystem::messages::StatementDistributionMessage;
+use polkadot_node_subsystem_types::messages::NetworkBridgeEvent;
 use polkadot_node_subsystem_util::metrics::prometheus::{
 	self, CounterVec, Opts, PrometheusError, Registry,
 };
@@ -437,6 +438,7 @@ pub struct EmulatedPeerHandle {
 	/// Send actions to be performed by the peer.
 	actions_tx: UnboundedSender<NetworkMessage>,
 	peer_id: PeerId,
+	authority_id: AuthorityDiscoveryId,
 }
 
 impl EmulatedPeerHandle {
@@ -496,29 +498,31 @@ impl EmulatedPeer {
 }
 
 /// Interceptor pattern for handling messages.
+#[async_trait::async_trait]
 pub trait HandleNetworkMessage {
 	/// Returns `None` if the message was handled, or the `message`
 	/// otherwise.
 	///
 	/// `node_sender` allows sending of messages to the node in response
 	/// to the handled message.
-	fn handle(
+	async fn handle(
 		&self,
 		message: NetworkMessage,
 		node_sender: &mut UnboundedSender<NetworkMessage>,
 	) -> Option<NetworkMessage>;
 }
 
+#[async_trait::async_trait]
 impl<T> HandleNetworkMessage for Arc<T>
 where
-	T: HandleNetworkMessage,
+	T: HandleNetworkMessage + Sync + Send,
 {
-	fn handle(
+	async fn handle(
 		&self,
 		message: NetworkMessage,
 		node_sender: &mut UnboundedSender<NetworkMessage>,
 	) -> Option<NetworkMessage> {
-		self.as_ref().handle(message, node_sender)
+		T::handle(self, message, node_sender).await
 	}
 }
 
@@ -551,7 +555,7 @@ async fn emulated_peer_loop(
 					for handler in handlers.iter() {
 						// The check below guarantees that message is always `Some`: we are still
 						// inside the loop.
-						message = handler.handle(message.unwrap(), &mut to_network_interface);
+						message = handler.handle(message.unwrap(), &mut to_network_interface).await;
 						if message.is_none() {
 							break
 						}
@@ -613,6 +617,7 @@ async fn emulated_peer_loop(
 }
 
 /// Creates a new peer emulator task and returns a handle to it.
+#[allow(clippy::too_many_arguments)]
 pub fn new_peer(
 	bandwidth: usize,
 	spawn_task_handle: SpawnTaskHandle,
@@ -621,6 +626,7 @@ pub fn new_peer(
 	to_network_interface: UnboundedSender<NetworkMessage>,
 	latency_ms: usize,
 	peer_id: PeerId,
+	authority_id: AuthorityDiscoveryId,
 ) -> EmulatedPeerHandle {
 	let (messages_tx, messages_rx) = mpsc::unbounded::<NetworkMessage>();
 	let (actions_tx, actions_rx) = mpsc::unbounded::<NetworkMessage>();
@@ -649,7 +655,7 @@ pub fn new_peer(
 		.boxed(),
 	);
 
-	EmulatedPeerHandle { messages_tx, actions_tx, peer_id }
+	EmulatedPeerHandle { messages_tx, actions_tx, peer_id, authority_id }
 }
 
 /// Book keeping of sent and received bytes.
@@ -714,6 +720,18 @@ impl Peer {
 			Peer::Disconnected(ref emulator) => emulator,
 		}
 	}
+
+	pub fn authority_id(&self) -> AuthorityDiscoveryId {
+		match self {
+			Peer::Connected(handle) | Peer::Disconnected(handle) => handle.authority_id.clone(),
+		}
+	}
+
+	pub fn peer_id(&self) -> PeerId {
+		match self {
+			Peer::Connected(handle) | Peer::Disconnected(handle) => handle.peer_id,
+		}
+	}
 }
 
 /// A ha emulated network implementation.
@@ -728,21 +746,34 @@ pub struct NetworkEmulatorHandle {
 }
 
 impl NetworkEmulatorHandle {
+	pub fn generate_statement_distribution_peer_view_change(&self, view: View) -> Vec<AllMessages> {
+		self.peers
+			.iter()
+			.filter(|peer| peer.is_connected())
+			.map(|peer| {
+				AllMessages::StatementDistribution(
+					StatementDistributionMessage::NetworkBridgeUpdate(
+						NetworkBridgeEvent::PeerViewChange(peer.peer_id(), view.clone()),
+					),
+				)
+			})
+			.collect_vec()
+	}
+
 	/// Generates peer_connected messages for all peers in `test_authorities`
-	pub fn generate_peer_connected(&self) -> Vec<AllMessages> {
+	pub fn generate_peer_connected<F, T>(&self, mapper: F) -> Vec<AllMessages>
+	where
+		F: Fn(NetworkBridgeEvent<T>) -> AllMessages,
+	{
 		self.peers
 			.iter()
 			.filter(|peer| peer.is_connected())
 			.map(|peer| {
-				let network = NetworkBridgeEvent::PeerConnected(
+				mapper(NetworkBridgeEvent::PeerConnected(
 					peer.handle().peer_id,
-					ObservedRole::Full,
-					ProtocolVersion::from(ValidationVersion::V3),
-					None,
-				);
-
-				AllMessages::ApprovalDistribution(ApprovalDistributionMessage::NetworkBridgeUpdate(
-					network,
+					ObservedRole::Authority,
+					ValidationVersion::V3.into(),
+					Some(vec![peer.authority_id()].into_iter().collect()),
 				))
 			})
 			.collect_vec()
@@ -772,7 +803,7 @@ pub fn new_network(
 	let (stats, mut peers): (_, Vec<_>) = (0..n_peers)
 		.zip(authorities.validator_authority_id.clone())
 		.map(|(peer_index, authority_id)| {
-			validator_authority_id_mapping.insert(authority_id, peer_index);
+			validator_authority_id_mapping.insert(authority_id.clone(), peer_index);
 			let stats = Arc::new(PeerEmulatorStats::new(peer_index, metrics.clone()));
 			(
 				stats.clone(),
@@ -784,6 +815,7 @@ pub fn new_network(
 					to_network_interface.clone(),
 					random_latency(config.latency.as_ref()),
 					*authorities.peer_ids.get(peer_index).unwrap(),
+					authority_id,
 				)),
 			)
 		})
@@ -971,6 +1003,8 @@ impl Metrics {
 pub trait RequestExt {
 	/// Get the authority id if any from the request.
 	fn authority_id(&self) -> Option<&AuthorityDiscoveryId>;
+	/// Get the peer id if any from the request.
+	fn peer_id(&self) -> Option<&PeerId>;
 	/// Consume self and return the response sender.
 	fn into_response_sender(self) -> ResponseSender;
 	/// Allows to change the `ResponseSender` in place.
@@ -982,7 +1016,7 @@ pub trait RequestExt {
 impl RequestExt for Requests {
 	fn authority_id(&self) -> Option<&AuthorityDiscoveryId> {
 		match self {
-			Requests::ChunkFetchingV1(request) => {
+			Requests::ChunkFetching(request) => {
 				if let Recipient::Authority(authority_id) = &request.peer {
 					Some(authority_id)
 				} else {
@@ -996,15 +1030,29 @@ impl RequestExt for Requests {
 					None
 				}
 			},
+			// Requested by PeerId
+			Requests::AttestedCandidateV2(_) => None,
 			request => {
 				unimplemented!("RequestAuthority not implemented for {:?}", request)
 			},
 		}
 	}
 
+	fn peer_id(&self) -> Option<&PeerId> {
+		match self {
+			Requests::AttestedCandidateV2(request) => match &request.peer {
+				Recipient::Authority(_) => None,
+				Recipient::Peer(peer_id) => Some(peer_id),
+			},
+			request => {
+				unimplemented!("peer_id() is not implemented for {:?}", request)
+			},
+		}
+	}
+
 	fn into_response_sender(self) -> ResponseSender {
 		match self {
-			Requests::ChunkFetchingV1(outgoing_request) => outgoing_request.pending_response,
+			Requests::ChunkFetching(outgoing_request) => outgoing_request.pending_response,
 			Requests::AvailableDataFetchingV1(outgoing_request) =>
 				outgoing_request.pending_response,
 			_ => unimplemented!("unsupported request type"),
@@ -1014,10 +1062,12 @@ impl RequestExt for Requests {
 	/// Swaps the `ResponseSender` and returns the previous value.
 	fn swap_response_sender(&mut self, new_sender: ResponseSender) -> ResponseSender {
 		match self {
-			Requests::ChunkFetchingV1(outgoing_request) =>
+			Requests::ChunkFetching(outgoing_request) =>
 				std::mem::replace(&mut outgoing_request.pending_response, new_sender),
 			Requests::AvailableDataFetchingV1(outgoing_request) =>
 				std::mem::replace(&mut outgoing_request.pending_response, new_sender),
+			Requests::AttestedCandidateV2(outgoing_request) =>
+				std::mem::replace(&mut outgoing_request.pending_response, new_sender),
 			_ => unimplemented!("unsupported request type"),
 		}
 	}
@@ -1025,9 +1075,11 @@ impl RequestExt for Requests {
 	/// Returns the size in bytes of the request payload.
 	fn size(&self) -> usize {
 		match self {
-			Requests::ChunkFetchingV1(outgoing_request) => outgoing_request.payload.encoded_size(),
+			Requests::ChunkFetching(outgoing_request) => outgoing_request.payload.encoded_size(),
 			Requests::AvailableDataFetchingV1(outgoing_request) =>
 				outgoing_request.payload.encoded_size(),
+			Requests::AttestedCandidateV2(outgoing_request) =>
+				outgoing_request.payload.encoded_size(),
 			_ => unimplemented!("received an unexpected request"),
 		}
 	}
diff --git a/polkadot/node/subsystem-bench/src/lib/statement/mod.rs b/polkadot/node/subsystem-bench/src/lib/statement/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bd47505f56aeabc201f0d57bec57fa6a3f3380d4
--- /dev/null
+++ b/polkadot/node/subsystem-bench/src/lib/statement/mod.rs
@@ -0,0 +1,449 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+	configuration::TestAuthorities,
+	dummy_builder,
+	environment::{TestEnvironment, TestEnvironmentDependencies, GENESIS_HASH},
+	mock::{
+		candidate_backing::MockCandidateBacking,
+		chain_api::{ChainApiState, MockChainApi},
+		network_bridge::{MockNetworkBridgeRx, MockNetworkBridgeTx},
+		prospective_parachains::MockProspectiveParachains,
+		runtime_api::{MockRuntimeApi, MockRuntimeApiCoreState},
+		AlwaysSupportsParachains,
+	},
+	network::{new_network, NetworkEmulatorHandle, NetworkInterface, NetworkInterfaceReceiver},
+	usage::BenchmarkUsage,
+	NODE_UNDER_TEST,
+};
+use bitvec::vec::BitVec;
+use colored::Colorize;
+use itertools::Itertools;
+use polkadot_node_metrics::metrics::Metrics;
+use polkadot_node_network_protocol::{
+	grid_topology::{SessionGridTopology, TopologyPeerInfo},
+	request_response::{IncomingRequest, ReqProtocolNames},
+	v3::{self, BackedCandidateManifest, StatementFilter},
+	view, Versioned, View,
+};
+use polkadot_node_subsystem::messages::{
+	network_bridge_event::NewGossipTopology, AllMessages, NetworkBridgeEvent,
+	StatementDistributionMessage,
+};
+use polkadot_overseer::{
+	Handle as OverseerHandle, Overseer, OverseerConnector, OverseerMetrics, SpawnGlue,
+};
+use polkadot_primitives::{
+	AuthorityDiscoveryId, Block, GroupIndex, Hash, Id, ValidatorId, ValidatorIndex,
+};
+use polkadot_statement_distribution::StatementDistributionSubsystem;
+use rand::SeedableRng;
+use sc_keystore::LocalKeystore;
+use sc_network::request_responses::ProtocolConfig;
+use sc_network_types::PeerId;
+use sc_service::SpawnTaskHandle;
+use sp_keystore::{Keystore, KeystorePtr};
+use sp_runtime::RuntimeAppPublic;
+use std::{
+	sync::{atomic::Ordering, Arc},
+	time::{Duration, Instant},
+};
+pub use test_state::TestState;
+
+mod test_state;
+
+const LOG_TARGET: &str = "subsystem-bench::statement";
+
+pub fn make_keystore() -> KeystorePtr {
+	let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory());
+	Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, Some("//Node0"))
+		.expect("Insert key into keystore");
+	Keystore::sr25519_generate_new(&*keystore, AuthorityDiscoveryId::ID, Some("//Node0"))
+		.expect("Insert key into keystore");
+	keystore
+}
+
+fn build_overseer(
+	state: &TestState,
+	network: NetworkEmulatorHandle,
+	network_interface: NetworkInterface,
+	network_receiver: NetworkInterfaceReceiver,
+	dependencies: &TestEnvironmentDependencies,
+) -> (
+	Overseer<SpawnGlue<SpawnTaskHandle>, AlwaysSupportsParachains>,
+	OverseerHandle,
+	Vec<ProtocolConfig>,
+) {
+	let overseer_connector = OverseerConnector::with_event_capacity(64000);
+	let overseer_metrics = OverseerMetrics::try_register(&dependencies.registry).unwrap();
+	let spawn_task_handle = dependencies.task_manager.spawn_handle();
+	let mock_runtime_api = MockRuntimeApi::new(
+		state.config.clone(),
+		state.test_authorities.clone(),
+		state.candidate_receipts.clone(),
+		Default::default(),
+		Default::default(),
+		0,
+		MockRuntimeApiCoreState::Scheduled,
+	);
+	let chain_api_state = ChainApiState { block_headers: state.block_headers.clone() };
+	let mock_chain_api = MockChainApi::new(chain_api_state);
+	let mock_prospective_parachains = MockProspectiveParachains::new();
+	let mock_candidate_backing = MockCandidateBacking::new(
+		state.config.clone(),
+		state
+			.test_authorities
+			.validator_pairs
+			.get(NODE_UNDER_TEST as usize)
+			.unwrap()
+			.clone(),
+		state.pvd.clone(),
+		state.own_backing_group.clone(),
+	);
+	let (statement_req_receiver, statement_req_cfg) = IncomingRequest::get_config_receiver::<
+		Block,
+		sc_network::NetworkWorker<Block, Hash>,
+	>(&ReqProtocolNames::new(GENESIS_HASH, None));
+	let (candidate_req_receiver, candidate_req_cfg) = IncomingRequest::get_config_receiver::<
+		Block,
+		sc_network::NetworkWorker<Block, Hash>,
+	>(&ReqProtocolNames::new(GENESIS_HASH, None));
+	let keystore = make_keystore();
+	let subsystem = StatementDistributionSubsystem::new(
+		keystore.clone(),
+		statement_req_receiver,
+		candidate_req_receiver,
+		Metrics::try_register(&dependencies.registry).unwrap(),
+		rand::rngs::StdRng::from_entropy(),
+	);
+	let network_bridge_tx = MockNetworkBridgeTx::new(
+		network,
+		network_interface.subsystem_sender(),
+		state.test_authorities.clone(),
+	);
+	let network_bridge_rx = MockNetworkBridgeRx::new(network_receiver, Some(candidate_req_cfg));
+
+	let dummy = dummy_builder!(spawn_task_handle, overseer_metrics)
+		.replace_runtime_api(|_| mock_runtime_api)
+		.replace_chain_api(|_| mock_chain_api)
+		.replace_prospective_parachains(|_| mock_prospective_parachains)
+		.replace_candidate_backing(|_| mock_candidate_backing)
+		.replace_statement_distribution(|_| subsystem)
+		.replace_network_bridge_tx(|_| network_bridge_tx)
+		.replace_network_bridge_rx(|_| network_bridge_rx);
+	let (overseer, raw_handle) = dummy.build_with_connector(overseer_connector).unwrap();
+	let overseer_handle = OverseerHandle::new(raw_handle);
+
+	(overseer, overseer_handle, vec![statement_req_cfg])
+}
+
+pub fn prepare_test(
+	state: &TestState,
+	with_prometheus_endpoint: bool,
+) -> (TestEnvironment, Vec<ProtocolConfig>) {
+	let dependencies = TestEnvironmentDependencies::default();
+	let (network, network_interface, network_receiver) = new_network(
+		&state.config,
+		&dependencies,
+		&state.test_authorities,
+		vec![Arc::new(state.clone())],
+	);
+	let (overseer, overseer_handle, cfg) =
+		build_overseer(state, network.clone(), network_interface, network_receiver, &dependencies);
+
+	(
+		TestEnvironment::new(
+			dependencies,
+			state.config.clone(),
+			network,
+			overseer,
+			overseer_handle,
+			state.test_authorities.clone(),
+			with_prometheus_endpoint,
+		),
+		cfg,
+	)
+}
+
+pub fn generate_peer_view_change(block_hash: Hash, peer_id: PeerId) -> AllMessages {
+	let network = NetworkBridgeEvent::PeerViewChange(peer_id, View::new([block_hash], 0));
+
+	AllMessages::StatementDistribution(StatementDistributionMessage::NetworkBridgeUpdate(network))
+}
+
+pub fn generate_new_session_topology(
+	topology: &SessionGridTopology,
+	test_node: ValidatorIndex,
+) -> Vec<AllMessages> {
+	let event = NetworkBridgeEvent::NewGossipTopology(NewGossipTopology {
+		session: 0,
+		topology: topology.clone(),
+		local_index: Some(test_node),
+	});
+	vec![AllMessages::StatementDistribution(StatementDistributionMessage::NetworkBridgeUpdate(
+		event,
+	))]
+}
+
+/// Generates a topology to be used for this benchmark.
+pub fn generate_topology(test_authorities: &TestAuthorities) -> SessionGridTopology {
+	let keyrings = test_authorities
+		.validator_authority_id
+		.clone()
+		.into_iter()
+		.zip(test_authorities.peer_ids.clone())
+		.collect_vec();
+
+	let topology = keyrings
+		.clone()
+		.into_iter()
+		.enumerate()
+		.map(|(index, (discovery_id, peer_id))| TopologyPeerInfo {
+			peer_ids: vec![peer_id],
+			validator_index: ValidatorIndex(index as u32),
+			discovery_id,
+		})
+		.collect_vec();
+	let shuffled = (0..keyrings.len()).collect_vec();
+
+	SessionGridTopology::new(shuffled, topology)
+}
+
+pub async fn benchmark_statement_distribution(
+	env: &mut TestEnvironment,
+	state: &TestState,
+) -> BenchmarkUsage {
+	state.reset_trackers();
+
+	let connected_validators = state
+		.test_authorities
+		.validator_authority_id
+		.iter()
+		.enumerate()
+		.filter_map(|(i, id)| if env.network().is_peer_connected(id) { Some(i) } else { None })
+		.collect_vec();
+	let seconding_validator_in_own_backing_group = state
+		.own_backing_group
+		.iter()
+		.find(|v| connected_validators.contains(&(v.0 as usize)))
+		.unwrap()
+		.to_owned();
+
+	let config = env.config().clone();
+	let groups = state.session_info.validator_groups.clone();
+	let own_backing_group_index = groups
+		.iter()
+		.position(|group| group.iter().any(|v| v.0 == NODE_UNDER_TEST))
+		.unwrap();
+
+	env.metrics().set_n_validators(config.n_validators);
+	env.metrics().set_n_cores(config.n_cores);
+
+	let topology = generate_topology(&state.test_authorities);
+	let peer_connected_messages = env.network().generate_peer_connected(|e| {
+		AllMessages::StatementDistribution(StatementDistributionMessage::NetworkBridgeUpdate(e))
+	});
+	let new_session_topology_messages =
+		generate_new_session_topology(&topology, ValidatorIndex(NODE_UNDER_TEST));
+	for message in peer_connected_messages.into_iter().chain(new_session_topology_messages) {
+		env.send_message(message).await;
+	}
+
+	let test_start = Instant::now();
+	let mut candidates_advertised = 0;
+	for block_info in state.block_infos.iter() {
+		let block_num = block_info.number as usize;
+		gum::info!(target: LOG_TARGET, "Current block {}/{} {:?}", block_num, config.num_blocks, block_info.hash);
+		env.metrics().set_current_block(block_num);
+		env.import_block(block_info.clone()).await;
+
+		for peer_view_change in env
+			.network()
+			.generate_statement_distribution_peer_view_change(view![block_info.hash])
+		{
+			env.send_message(peer_view_change).await;
+		}
+
+		let seconding_peer_id = *state
+			.test_authorities
+			.peer_ids
+			.get(seconding_validator_in_own_backing_group.0 as usize)
+			.unwrap();
+		let candidate = state.candidate_receipts.get(&block_info.hash).unwrap().first().unwrap();
+		let candidate_hash = candidate.hash();
+		let statement = state
+			.statements
+			.get(&candidate_hash)
+			.unwrap()
+			.get(seconding_validator_in_own_backing_group.0 as usize)
+			.unwrap()
+			.clone();
+		let message = AllMessages::StatementDistribution(
+			StatementDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage(
+				seconding_peer_id,
+				Versioned::V3(v3::StatementDistributionMessage::Statement(
+					block_info.hash,
+					statement,
+				)),
+			)),
+		);
+		env.send_message(message).await;
+
+		let max_messages_per_candidate = state.config.max_candidate_depth + 1;
+		// One was just sent for the own backing group
+		let mut messages_tracker = (0..groups.len())
+			.map(|i| if i == own_backing_group_index { max_messages_per_candidate } else { 0 })
+			.collect_vec();
+
+		let neighbors =
+			topology.compute_grid_neighbors_for(ValidatorIndex(NODE_UNDER_TEST)).unwrap();
+		let connected_neighbors_x = neighbors
+			.validator_indices_x
+			.iter()
+			.filter(|&v| connected_validators.contains(&(v.0 as usize)))
+			.cloned()
+			.collect_vec();
+		let connected_neighbors_y = neighbors
+			.validator_indices_y
+			.iter()
+			.filter(|&v| connected_validators.contains(&(v.0 as usize)))
+			.cloned()
+			.collect_vec();
+		let one_hop_peers_and_groups = connected_neighbors_x
+			.iter()
+			.chain(connected_neighbors_y.iter())
+			.map(|validator_index| {
+				let peer_id =
+					*state.test_authorities.peer_ids.get(validator_index.0 as usize).unwrap();
+				let group_index =
+					groups.iter().position(|group| group.contains(validator_index)).unwrap();
+				(peer_id, group_index)
+			})
+			.collect_vec();
+		let two_hop_x_peers_and_groups = connected_neighbors_x
+			.iter()
+			.flat_map(|validator_index| {
+				let peer_id =
+					*state.test_authorities.peer_ids.get(validator_index.0 as usize).unwrap();
+				topology
+					.compute_grid_neighbors_for(*validator_index)
+					.unwrap()
+					.validator_indices_y
+					.iter()
+					.map(|validator_neighbor| {
+						let group_index = groups
+							.iter()
+							.position(|group| group.contains(validator_neighbor))
+							.unwrap();
+						(peer_id, group_index)
+					})
+					.collect_vec()
+			})
+			.collect_vec();
+		let two_hop_y_peers_and_groups = connected_neighbors_y
+			.iter()
+			.flat_map(|validator_index| {
+				let peer_id =
+					*state.test_authorities.peer_ids.get(validator_index.0 as usize).unwrap();
+				topology
+					.compute_grid_neighbors_for(*validator_index)
+					.unwrap()
+					.validator_indices_x
+					.iter()
+					.map(|validator_neighbor| {
+						let group_index = groups
+							.iter()
+							.position(|group| group.contains(validator_neighbor))
+							.unwrap();
+						(peer_id, group_index)
+					})
+					.collect_vec()
+			})
+			.collect_vec();
+
+		for (seconding_peer_id, group_index) in one_hop_peers_and_groups
+			.into_iter()
+			.chain(two_hop_x_peers_and_groups)
+			.chain(two_hop_y_peers_and_groups)
+		{
+			let messages_sent_count = messages_tracker.get_mut(group_index).unwrap();
+			if *messages_sent_count == max_messages_per_candidate {
+				continue
+			}
+			*messages_sent_count += 1;
+
+			let candidate_hash = state
+				.candidate_receipts
+				.get(&block_info.hash)
+				.unwrap()
+				.get(group_index)
+				.unwrap()
+				.hash();
+			let manifest = BackedCandidateManifest {
+				relay_parent: block_info.hash,
+				candidate_hash,
+				group_index: GroupIndex(group_index as u32),
+				para_id: Id::new(group_index as u32 + 1),
+				parent_head_data_hash: state.pvd.parent_head.hash(),
+				statement_knowledge: StatementFilter {
+					seconded_in_group: BitVec::from_iter(
+						groups.get(GroupIndex(group_index as u32)).unwrap().iter().map(|_| true),
+					),
+					validated_in_group: BitVec::from_iter(
+						groups.get(GroupIndex(group_index as u32)).unwrap().iter().map(|_| false),
+					),
+				},
+			};
+			let message = AllMessages::StatementDistribution(
+				StatementDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage(
+					seconding_peer_id,
+					Versioned::V3(v3::StatementDistributionMessage::BackedCandidateManifest(
+						manifest,
+					)),
+				)),
+			);
+			env.send_message(message).await;
+		}
+
+		candidates_advertised += messages_tracker.iter().filter(|&&v| v > 0).collect_vec().len();
+
+		loop {
+			let manifests_count = state
+				.manifests_tracker
+				.values()
+				.filter(|v| v.load(Ordering::SeqCst))
+				.collect::<Vec<_>>()
+				.len();
+			gum::debug!(target: LOG_TARGET, "{}/{} manifest exchanges", manifests_count, candidates_advertised);
+
+			if manifests_count == candidates_advertised {
+				break;
+			}
+			tokio::time::sleep(Duration::from_millis(50)).await;
+		}
+	}
+
+	let duration: u128 = test_start.elapsed().as_millis();
+	gum::info!(target: LOG_TARGET, "All blocks processed in {}", format!("{:?}ms", duration).cyan());
+	gum::info!(target: LOG_TARGET,
+		"Avg block time: {}",
+		format!("{} ms", test_start.elapsed().as_millis() / env.config().num_blocks as u128).red()
+	);
+
+	env.stop().await;
+	env.collect_resource_usage(&["statement-distribution"])
+}
diff --git a/polkadot/node/subsystem-bench/src/lib/statement/test_state.rs b/polkadot/node/subsystem-bench/src/lib/statement/test_state.rs
new file mode 100644
index 0000000000000000000000000000000000000000..88b5e8b76b6252dfb470c38d344b60246008fd97
--- /dev/null
+++ b/polkadot/node/subsystem-bench/src/lib/statement/test_state.rs
@@ -0,0 +1,436 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::{
+	configuration::{TestAuthorities, TestConfiguration},
+	mock::runtime_api::session_info_for_peers,
+	network::{HandleNetworkMessage, NetworkMessage},
+	NODE_UNDER_TEST,
+};
+use bitvec::vec::BitVec;
+use codec::{Decode, Encode};
+use futures::channel::oneshot;
+use itertools::Itertools;
+use polkadot_node_network_protocol::{
+	request_response::{
+		v2::{AttestedCandidateRequest, AttestedCandidateResponse},
+		Requests,
+	},
+	v3::{
+		BackedCandidateAcknowledgement, StatementDistributionMessage, StatementFilter,
+		ValidationProtocol,
+	},
+	Versioned,
+};
+use polkadot_node_primitives::{AvailableData, BlockData, PoV};
+use polkadot_node_subsystem_test_helpers::{
+	derive_erasure_chunks_with_proofs_and_root, mock::new_block_import_info,
+};
+use polkadot_overseer::BlockInfo;
+use polkadot_primitives::{
+	BlockNumber, CandidateHash, CandidateReceipt, CommittedCandidateReceipt, CompactStatement,
+	Hash, Header, Id, PersistedValidationData, SessionInfo, SignedStatement, SigningContext,
+	UncheckedSigned, ValidatorIndex, ValidatorPair,
+};
+use polkadot_primitives_test_helpers::{
+	dummy_committed_candidate_receipt, dummy_hash, dummy_head_data, dummy_pvd,
+};
+use sc_network::{config::IncomingRequest, ProtocolName};
+use sp_core::{Pair, H256};
+use std::{
+	collections::HashMap,
+	sync::{
+		atomic::{AtomicBool, Ordering},
+		Arc,
+	},
+};
+
+#[derive(Clone)]
+pub struct TestState {
+	// Full test config
+	pub config: TestConfiguration,
+	// Authority keys for the network emulation.
+	pub test_authorities: TestAuthorities,
+	// Relay chain block infos
+	pub block_infos: Vec<BlockInfo>,
+	// Map from generated candidate receipts
+	pub candidate_receipts: HashMap<H256, Vec<CandidateReceipt>>,
+	// Map from generated commited candidate receipts
+	pub commited_candidate_receipts: HashMap<H256, Vec<CommittedCandidateReceipt>>,
+	// PersistedValidationData, we use one for all candidates
+	pub pvd: PersistedValidationData,
+	// Relay chain block headers
+	pub block_headers: HashMap<H256, Header>,
+	// Session info
+	pub session_info: SessionInfo,
+	// Pregenerated statements
+	pub statements: HashMap<CandidateHash, Vec<UncheckedSigned<CompactStatement>>>,
+	// Indices in the backing group where the node under test is
+	pub own_backing_group: Vec<ValidatorIndex>,
+	// Tracks how many statements we received for a candidates
+	pub statements_tracker: HashMap<CandidateHash, Vec<Arc<AtomicBool>>>,
+	// Tracks if manifest exchange happened
+	pub manifests_tracker: HashMap<CandidateHash, Arc<AtomicBool>>,
+}
+
+impl TestState {
+	pub fn new(config: &TestConfiguration) -> Self {
+		let test_authorities = config.generate_authorities();
+		let session_info = session_info_for_peers(config, &test_authorities);
+		let own_backing_group = session_info
+			.validator_groups
+			.iter()
+			.find(|g| g.contains(&ValidatorIndex(NODE_UNDER_TEST)))
+			.unwrap()
+			.clone();
+		let mut state = Self {
+			config: config.clone(),
+			test_authorities,
+			block_infos: (1..=config.num_blocks).map(generate_block_info).collect(),
+			candidate_receipts: Default::default(),
+			commited_candidate_receipts: Default::default(),
+			pvd: dummy_pvd(dummy_head_data(), 0),
+			block_headers: Default::default(),
+			statements_tracker: Default::default(),
+			manifests_tracker: Default::default(),
+			session_info,
+			own_backing_group,
+			statements: Default::default(),
+		};
+
+		state.block_headers = state.block_infos.iter().map(generate_block_header).collect();
+
+		// For each unique pov we create a candidate receipt.
+		let pov_sizes = Vec::from(config.pov_sizes()); // For n_cores
+		let pov_size_to_candidate = generate_pov_size_to_candidate(&pov_sizes);
+		let receipt_templates =
+			generate_receipt_templates(&pov_size_to_candidate, config.n_validators, &state.pvd);
+
+		for block_info in state.block_infos.iter() {
+			for core_idx in 0..config.n_cores {
+				let pov_size = pov_sizes.get(core_idx).expect("This is a cycle; qed");
+				let candidate_index =
+					*pov_size_to_candidate.get(pov_size).expect("pov_size always exists; qed");
+				let mut receipt = receipt_templates[candidate_index].clone();
+				receipt.descriptor.para_id = Id::new(core_idx as u32 + 1);
+				receipt.descriptor.relay_parent = block_info.hash;
+
+				state.candidate_receipts.entry(block_info.hash).or_default().push(
+					CandidateReceipt {
+						descriptor: receipt.descriptor.clone(),
+						commitments_hash: receipt.commitments.hash(),
+					},
+				);
+				state.statements_tracker.entry(receipt.hash()).or_default().extend(
+					(0..config.n_validators)
+						.map(|_| Arc::new(AtomicBool::new(false)))
+						.collect_vec(),
+				);
+				state.manifests_tracker.insert(receipt.hash(), Arc::new(AtomicBool::new(false)));
+				state
+					.commited_candidate_receipts
+					.entry(block_info.hash)
+					.or_default()
+					.push(receipt);
+			}
+		}
+
+		let groups = state.session_info.validator_groups.clone();
+
+		for block_info in state.block_infos.iter() {
+			for (index, group) in groups.iter().enumerate() {
+				let candidate =
+					state.candidate_receipts.get(&block_info.hash).unwrap().get(index).unwrap();
+				let statements = group
+					.iter()
+					.map(|&v| {
+						sign_statement(
+							CompactStatement::Seconded(candidate.hash()),
+							block_info.hash,
+							v,
+							state.test_authorities.validator_pairs.get(v.0 as usize).unwrap(),
+						)
+					})
+					.collect_vec();
+				state.statements.insert(candidate.hash(), statements);
+			}
+		}
+
+		state
+	}
+
+	pub fn reset_trackers(&self) {
+		self.statements_tracker.values().for_each(|v| {
+			v.iter()
+				.enumerate()
+				.for_each(|(index, v)| v.as_ref().store(index <= 1, Ordering::SeqCst))
+		});
+		self.manifests_tracker
+			.values()
+			.for_each(|v| v.as_ref().store(false, Ordering::SeqCst));
+	}
+}
+
+fn sign_statement(
+	statement: CompactStatement,
+	relay_parent: H256,
+	validator_index: ValidatorIndex,
+	pair: &ValidatorPair,
+) -> UncheckedSigned<CompactStatement> {
+	let context = SigningContext { parent_hash: relay_parent, session_index: 0 };
+	let payload = statement.signing_payload(&context);
+
+	SignedStatement::new(
+		statement,
+		validator_index,
+		pair.sign(&payload[..]),
+		&context,
+		&pair.public(),
+	)
+	.unwrap()
+	.as_unchecked()
+	.to_owned()
+}
+
+fn generate_block_info(block_num: usize) -> BlockInfo {
+	new_block_import_info(Hash::repeat_byte(block_num as u8), block_num as BlockNumber)
+}
+
+fn generate_block_header(info: &BlockInfo) -> (H256, Header) {
+	(
+		info.hash,
+		Header {
+			digest: Default::default(),
+			number: info.number,
+			parent_hash: info.parent_hash,
+			extrinsics_root: Default::default(),
+			state_root: Default::default(),
+		},
+	)
+}
+
+fn generate_pov_size_to_candidate(pov_sizes: &[usize]) -> HashMap<usize, usize> {
+	pov_sizes
+		.iter()
+		.cloned()
+		.unique()
+		.enumerate()
+		.map(|(index, pov_size)| (pov_size, index))
+		.collect()
+}
+
+fn generate_receipt_templates(
+	pov_size_to_candidate: &HashMap<usize, usize>,
+	n_validators: usize,
+	pvd: &PersistedValidationData,
+) -> Vec<CommittedCandidateReceipt> {
+	pov_size_to_candidate
+		.iter()
+		.map(|(&pov_size, &index)| {
+			let mut receipt = dummy_committed_candidate_receipt(dummy_hash());
+			let (_, erasure_root) = derive_erasure_chunks_with_proofs_and_root(
+				n_validators,
+				&AvailableData {
+					validation_data: pvd.clone(),
+					pov: Arc::new(PoV { block_data: BlockData(vec![index as u8; pov_size]) }),
+				},
+				|_, _| {},
+			);
+			receipt.descriptor.persisted_validation_data_hash = pvd.hash();
+			receipt.descriptor.erasure_root = erasure_root;
+			receipt
+		})
+		.collect()
+}
+
+#[async_trait::async_trait]
+impl HandleNetworkMessage for TestState {
+	async fn handle(
+		&self,
+		message: NetworkMessage,
+		node_sender: &mut futures::channel::mpsc::UnboundedSender<NetworkMessage>,
+	) -> Option<NetworkMessage> {
+		match message {
+			NetworkMessage::RequestFromNode(_authority_id, Requests::AttestedCandidateV2(req)) => {
+				let payload = req.payload;
+				let candidate_receipt = self
+					.commited_candidate_receipts
+					.values()
+					.flatten()
+					.find(|v| v.hash() == payload.candidate_hash)
+					.unwrap()
+					.clone();
+				let persisted_validation_data = self.pvd.clone();
+				let statements = self.statements.get(&payload.candidate_hash).unwrap().clone();
+				let res = AttestedCandidateResponse {
+					candidate_receipt,
+					persisted_validation_data,
+					statements,
+				};
+				let _ = req.pending_response.send(Ok((res.encode(), ProtocolName::from(""))));
+				None
+			},
+			NetworkMessage::MessageFromNode(
+				authority_id,
+				Versioned::V3(ValidationProtocol::StatementDistribution(
+					StatementDistributionMessage::Statement(relay_parent, statement),
+				)),
+			) => {
+				let index = self
+					.test_authorities
+					.validator_authority_id
+					.iter()
+					.position(|v| v == &authority_id)
+					.unwrap();
+				let candidate_hash = *statement.unchecked_payload().candidate_hash();
+
+				let statements_sent_count = self
+					.statements_tracker
+					.get(&candidate_hash)
+					.unwrap()
+					.get(index)
+					.unwrap()
+					.as_ref();
+				if statements_sent_count.load(Ordering::SeqCst) {
+					return None
+				} else {
+					statements_sent_count.store(true, Ordering::SeqCst);
+				}
+
+				let group_statements = self.statements.get(&candidate_hash).unwrap();
+				if !group_statements.iter().any(|s| s.unchecked_validator_index().0 == index as u32)
+				{
+					return None
+				}
+
+				let statement = CompactStatement::Valid(candidate_hash);
+				let context = SigningContext { parent_hash: relay_parent, session_index: 0 };
+				let payload = statement.signing_payload(&context);
+				let pair = self.test_authorities.validator_pairs.get(index).unwrap();
+				let signature = pair.sign(&payload[..]);
+				let statement = SignedStatement::new(
+					statement,
+					ValidatorIndex(index as u32),
+					signature,
+					&context,
+					&pair.public(),
+				)
+				.unwrap()
+				.as_unchecked()
+				.to_owned();
+
+				node_sender
+					.start_send(NetworkMessage::MessageFromPeer(
+						*self.test_authorities.peer_ids.get(index).unwrap(),
+						Versioned::V3(ValidationProtocol::StatementDistribution(
+							StatementDistributionMessage::Statement(relay_parent, statement),
+						)),
+					))
+					.unwrap();
+				None
+			},
+			NetworkMessage::MessageFromNode(
+				authority_id,
+				Versioned::V3(ValidationProtocol::StatementDistribution(
+					StatementDistributionMessage::BackedCandidateManifest(manifest),
+				)),
+			) => {
+				let index = self
+					.test_authorities
+					.validator_authority_id
+					.iter()
+					.position(|v| v == &authority_id)
+					.unwrap();
+				let backing_group =
+					self.session_info.validator_groups.get(manifest.group_index).unwrap();
+				let group_size = backing_group.len();
+				let is_own_backing_group = backing_group.contains(&ValidatorIndex(NODE_UNDER_TEST));
+				let mut seconded_in_group =
+					BitVec::from_iter((0..group_size).map(|_| !is_own_backing_group));
+				let mut validated_in_group = BitVec::from_iter((0..group_size).map(|_| false));
+
+				if is_own_backing_group {
+					let (pending_response, response_receiver) = oneshot::channel();
+					let peer_id = self.test_authorities.peer_ids.get(index).unwrap().to_owned();
+					node_sender
+						.start_send(NetworkMessage::RequestFromPeer(IncomingRequest {
+							peer: peer_id,
+							payload: AttestedCandidateRequest {
+								candidate_hash: manifest.candidate_hash,
+								mask: StatementFilter::blank(self.own_backing_group.len()),
+							}
+							.encode(),
+							pending_response,
+						}))
+						.unwrap();
+
+					let response = response_receiver.await.unwrap();
+					let response =
+						AttestedCandidateResponse::decode(&mut response.result.unwrap().as_ref())
+							.unwrap();
+
+					for statement in response.statements {
+						let validator_index = statement.unchecked_validator_index();
+						let position_in_group =
+							backing_group.iter().position(|v| *v == validator_index).unwrap();
+						match statement.unchecked_payload() {
+							CompactStatement::Seconded(_) =>
+								seconded_in_group.set(position_in_group, true),
+							CompactStatement::Valid(_) =>
+								validated_in_group.set(position_in_group, true),
+						}
+					}
+				}
+
+				let ack = BackedCandidateAcknowledgement {
+					candidate_hash: manifest.candidate_hash,
+					statement_knowledge: StatementFilter { seconded_in_group, validated_in_group },
+				};
+				node_sender
+					.start_send(NetworkMessage::MessageFromPeer(
+						*self.test_authorities.peer_ids.get(index).unwrap(),
+						Versioned::V3(ValidationProtocol::StatementDistribution(
+							StatementDistributionMessage::BackedCandidateKnown(ack),
+						)),
+					))
+					.unwrap();
+
+				self.manifests_tracker
+					.get(&manifest.candidate_hash)
+					.unwrap()
+					.as_ref()
+					.store(true, Ordering::SeqCst);
+
+				None
+			},
+			NetworkMessage::MessageFromNode(
+				_authority_id,
+				Versioned::V3(ValidationProtocol::StatementDistribution(
+					StatementDistributionMessage::BackedCandidateKnown(ack),
+				)),
+			) => {
+				self.manifests_tracker
+					.get(&ack.candidate_hash)
+					.unwrap()
+					.as_ref()
+					.store(true, Ordering::SeqCst);
+
+				None
+			},
+			_ => Some(message),
+		}
+	}
+}
diff --git a/polkadot/node/subsystem-bench/src/lib/usage.rs b/polkadot/node/subsystem-bench/src/lib/usage.rs
index bfaac3265a2e3741aaa2fa4811785bd90e8ea016..883e9aa7ad0a0cec210ef49ccd7542f17d7256ee 100644
--- a/polkadot/node/subsystem-bench/src/lib/usage.rs
+++ b/polkadot/node/subsystem-bench/src/lib/usage.rs
@@ -23,7 +23,6 @@ use std::collections::HashMap;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct BenchmarkUsage {
-	pub benchmark_name: String,
 	pub network_usage: Vec<ResourceUsage>,
 	pub cpu_usage: Vec<ResourceUsage>,
 }
@@ -32,8 +31,7 @@ impl std::fmt::Display for BenchmarkUsage {
 	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 		write!(
 			f,
-			"\n{}\n\n{}\n{}\n\n{}\n{}\n",
-			self.benchmark_name.purple(),
+			"\n{}\n{}\n\n{}\n{}\n",
 			format!("{:<32}{:>12}{:>12}", "Network usage, KiB", "total", "per block").blue(),
 			self.network_usage
 				.iter()
@@ -59,18 +57,17 @@ impl BenchmarkUsage {
 		let all_cpu_usage: Vec<&ResourceUsage> = usages.iter().flat_map(|v| &v.cpu_usage).collect();
 
 		Self {
-			benchmark_name: usages.first().map(|v| v.benchmark_name.clone()).unwrap_or_default(),
 			network_usage: ResourceUsage::average_by_resource_name(&all_network_usages),
 			cpu_usage: ResourceUsage::average_by_resource_name(&all_cpu_usage),
 		}
 	}
 
 	pub fn check_network_usage(&self, checks: &[ResourceUsageCheck]) -> Vec<String> {
-		check_usage(&self.benchmark_name, &self.network_usage, checks)
+		check_usage(&self.network_usage, checks)
 	}
 
 	pub fn check_cpu_usage(&self, checks: &[ResourceUsageCheck]) -> Vec<String> {
-		check_usage(&self.benchmark_name, &self.cpu_usage, checks)
+		check_usage(&self.cpu_usage, checks)
 	}
 
 	pub fn cpu_usage_diff(&self, other: &Self, resource_name: &str) -> Option<f64> {
@@ -105,18 +102,8 @@ impl BenchmarkUsage {
 	}
 }
 
-fn check_usage(
-	benchmark_name: &str,
-	usage: &[ResourceUsage],
-	checks: &[ResourceUsageCheck],
-) -> Vec<String> {
-	checks
-		.iter()
-		.filter_map(|check| {
-			check_resource_usage(usage, check)
-				.map(|message| format!("{}: {}", benchmark_name, message))
-		})
-		.collect()
+fn check_usage(usage: &[ResourceUsage], checks: &[ResourceUsageCheck]) -> Vec<String> {
+	checks.iter().filter_map(|check| check_resource_usage(usage, check)).collect()
 }
 
 fn check_resource_usage(
diff --git a/polkadot/node/subsystem-test-helpers/src/lib.rs b/polkadot/node/subsystem-test-helpers/src/lib.rs
index 6c1ac86c4507b798e4270b7c52e97a4dad74b64c..375121c3746377157e852de382c9d2cb64bce496 100644
--- a/polkadot/node/subsystem-test-helpers/src/lib.rs
+++ b/polkadot/node/subsystem-test-helpers/src/lib.rs
@@ -25,7 +25,7 @@ use polkadot_node_subsystem::{
 	SubsystemError, SubsystemResult, TrySendError,
 };
 use polkadot_node_subsystem_util::TimeoutExt;
-use polkadot_primitives::{Hash, ValidatorIndex};
+use polkadot_primitives::{ChunkIndex, Hash};
 
 use futures::{channel::mpsc, poll, prelude::*};
 use parking_lot::Mutex;
@@ -487,7 +487,7 @@ pub fn derive_erasure_chunks_with_proofs_and_root(
 		.enumerate()
 		.map(|(index, (proof, chunk))| ErasureChunk {
 			chunk: chunk.to_vec(),
-			index: ValidatorIndex(index as _),
+			index: ChunkIndex(index as _),
 			proof: Proof::try_from(proof).unwrap(),
 		})
 		.collect::<Vec<ErasureChunk>>();
diff --git a/polkadot/node/subsystem-types/Cargo.toml b/polkadot/node/subsystem-types/Cargo.toml
index 93dd43c5dbfc495ff92fa76f28e3ad80992b8a6a..0178b193cba8c88f2cc7b4a980beae8f7de106ff 100644
--- a/polkadot/node/subsystem-types/Cargo.toml
+++ b/polkadot/node/subsystem-types/Cargo.toml
@@ -11,6 +11,7 @@ workspace = true
 
 [dependencies]
 derive_more = "0.99.17"
+fatality = "0.1.1"
 futures = "0.3.30"
 polkadot-primitives = { path = "../../primitives" }
 polkadot-node-primitives = { path = "../primitives" }
@@ -28,7 +29,7 @@ sp-authority-discovery = { path = "../../../substrate/primitives/authority-disco
 sc-client-api = { path = "../../../substrate/client/api" }
 sc-transaction-pool-api = { path = "../../../substrate/client/transaction-pool/api" }
 smallvec = "1.8.0"
-substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" }
 thiserror = { workspace = true }
 async-trait = "0.1.79"
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
diff --git a/polkadot/node/subsystem-types/src/errors.rs b/polkadot/node/subsystem-types/src/errors.rs
index 44136362a69efa0ba316413cc9f78d834b5c3e9f..8e1b515c8db0acc4ff30727ed0986c6322d941ce 100644
--- a/polkadot/node/subsystem-types/src/errors.rs
+++ b/polkadot/node/subsystem-types/src/errors.rs
@@ -18,6 +18,7 @@
 
 use crate::JaegerError;
 use ::orchestra::OrchestraError as OverseerError;
+use fatality::fatality;
 
 /// A description of an error causing the runtime API request to be unservable.
 #[derive(thiserror::Error, Debug, Clone)]
@@ -68,32 +69,21 @@ impl core::fmt::Display for ChainApiError {
 impl std::error::Error for ChainApiError {}
 
 /// An error that may happen during Availability Recovery process.
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Clone)]
+#[fatality(splitable)]
+#[allow(missing_docs)]
 pub enum RecoveryError {
-	/// A chunk is recovered but is invalid.
+	#[error("Invalid data")]
 	Invalid,
 
-	/// A requested chunk is unavailable.
+	#[error("Data is unavailable")]
 	Unavailable,
 
-	/// Erasure task channel closed, usually means node is shutting down.
+	#[fatal]
+	#[error("Erasure task channel closed")]
 	ChannelClosed,
 }
 
-impl std::fmt::Display for RecoveryError {
-	fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
-		let msg = match self {
-			RecoveryError::Invalid => "Invalid",
-			RecoveryError::Unavailable => "Unavailable",
-			RecoveryError::ChannelClosed => "ChannelClosed",
-		};
-
-		write!(f, "{}", msg)
-	}
-}
-
-impl std::error::Error for RecoveryError {}
-
 /// An error type that describes faults that may happen
 ///
 /// These are:
@@ -117,7 +107,7 @@ pub enum SubsystemError {
 	Infallible(#[from] std::convert::Infallible),
 
 	#[error(transparent)]
-	Prometheus(#[from] substrate_prometheus_endpoint::PrometheusError),
+	Prometheus(#[from] prometheus_endpoint::PrometheusError),
 
 	#[error(transparent)]
 	Jaeger(#[from] JaegerError),
diff --git a/polkadot/node/subsystem-types/src/messages.rs b/polkadot/node/subsystem-types/src/messages.rs
index 2a54b3aed301e7dcdcdaf87fe49775b43954a102..722a97989bce0b8587c8992827f6438fd78ff21e 100644
--- a/polkadot/node/subsystem-types/src/messages.rs
+++ b/polkadot/node/subsystem-types/src/messages.rs
@@ -480,6 +480,8 @@ pub enum AvailabilityRecoveryMessage {
 		CandidateReceipt,
 		SessionIndex,
 		Option<GroupIndex>, // Optional backing group to request from first.
+		Option<CoreIndex>,  /* A `CoreIndex` needs to be specified for the recovery process to
+		                     * prefer systematic chunk recovery. */
 		oneshot::Sender<Result<AvailableData, crate::errors::RecoveryError>>,
 	),
 }
@@ -515,7 +517,7 @@ pub enum AvailabilityStoreMessage {
 	QueryChunkSize(CandidateHash, oneshot::Sender<Option<usize>>),
 
 	/// Query all chunks that we have for the given candidate hash.
-	QueryAllChunks(CandidateHash, oneshot::Sender<Vec<ErasureChunk>>),
+	QueryAllChunks(CandidateHash, oneshot::Sender<Vec<(ValidatorIndex, ErasureChunk)>>),
 
 	/// Query whether an `ErasureChunk` exists within the AV Store.
 	///
@@ -530,6 +532,8 @@ pub enum AvailabilityStoreMessage {
 	StoreChunk {
 		/// A hash of the candidate this chunk belongs to.
 		candidate_hash: CandidateHash,
+		/// Validator index. May not be equal to the chunk index.
+		validator_index: ValidatorIndex,
 		/// The chunk itself.
 		chunk: ErasureChunk,
 		/// Sending side of the channel to send result to.
@@ -549,6 +553,11 @@ pub enum AvailabilityStoreMessage {
 		available_data: AvailableData,
 		/// Erasure root we expect to get after chunking.
 		expected_erasure_root: Hash,
+		/// Core index where the candidate was backed.
+		core_index: CoreIndex,
+		/// Node features at the candidate relay parent. Used for computing the validator->chunk
+		/// mapping.
+		node_features: NodeFeatures,
 		/// Sending side of the channel to send result to.
 		tx: oneshot::Sender<Result<(), StoreAvailableDataError>>,
 	},
diff --git a/polkadot/node/subsystem-util/Cargo.toml b/polkadot/node/subsystem-util/Cargo.toml
index 219ea4d3f57d0e513c04c4f567f6681555889ca6..b7fb75b94b2c726cb0171b48b023a9d9517970ac 100644
--- a/polkadot/node/subsystem-util/Cargo.toml
+++ b/polkadot/node/subsystem-util/Cargo.toml
@@ -14,7 +14,7 @@ async-trait = "0.1.79"
 futures = "0.3.30"
 futures-channel = "0.3.23"
 itertools = "0.11"
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 parking_lot = "0.12.1"
 pin-project = "1.0.9"
 rand = "0.8.5"
@@ -24,6 +24,7 @@ gum = { package = "tracing-gum", path = "../gum" }
 derive_more = "0.99.17"
 schnellru = "0.2.1"
 
+polkadot-erasure-coding = { path = "../../erasure-coding" }
 polkadot-node-subsystem = { path = "../subsystem" }
 polkadot-node-subsystem-types = { path = "../subsystem-types" }
 polkadot-node-jaeger = { path = "../jaeger" }
diff --git a/polkadot/node/subsystem-util/src/availability_chunks.rs b/polkadot/node/subsystem-util/src/availability_chunks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..651dd3633cfcc386a1244dea59f1c04a670def9d
--- /dev/null
+++ b/polkadot/node/subsystem-util/src/availability_chunks.rs
@@ -0,0 +1,227 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use polkadot_erasure_coding::systematic_recovery_threshold;
+use polkadot_primitives::{node_features, ChunkIndex, CoreIndex, NodeFeatures, ValidatorIndex};
+
+/// Compute the per-validator availability chunk index.
+/// WARNING: THIS FUNCTION IS CRITICAL TO PARACHAIN CONSENSUS.
+/// Any modification to the output of the function needs to be coordinated via the runtime.
+/// It's best to use minimal/no external dependencies.
+pub fn availability_chunk_index(
+	maybe_node_features: Option<&NodeFeatures>,
+	n_validators: usize,
+	core_index: CoreIndex,
+	validator_index: ValidatorIndex,
+) -> Result<ChunkIndex, polkadot_erasure_coding::Error> {
+	if let Some(features) = maybe_node_features {
+		if let Some(&true) = features
+			.get(usize::from(node_features::FeatureIndex::AvailabilityChunkMapping as u8))
+			.as_deref()
+		{
+			let systematic_threshold = systematic_recovery_threshold(n_validators)? as u32;
+			let core_start_pos = core_index.0 * systematic_threshold;
+
+			return Ok(ChunkIndex((core_start_pos + validator_index.0) % n_validators as u32))
+		}
+	}
+
+	Ok(validator_index.into())
+}
+
+/// Compute the per-core availability chunk indices. Returns a Vec which maps ValidatorIndex to
+/// ChunkIndex for a given availability core index
+/// WARNING: THIS FUNCTION IS CRITICAL TO PARACHAIN CONSENSUS.
+/// Any modification to the output of the function needs to be coordinated via the
+/// runtime. It's best to use minimal/no external dependencies.
+pub fn availability_chunk_indices(
+	maybe_node_features: Option<&NodeFeatures>,
+	n_validators: usize,
+	core_index: CoreIndex,
+) -> Result<Vec<ChunkIndex>, polkadot_erasure_coding::Error> {
+	let identity = (0..n_validators).map(|index| ChunkIndex(index as u32));
+	if let Some(features) = maybe_node_features {
+		if let Some(&true) = features
+			.get(usize::from(node_features::FeatureIndex::AvailabilityChunkMapping as u8))
+			.as_deref()
+		{
+			let systematic_threshold = systematic_recovery_threshold(n_validators)? as u32;
+			let core_start_pos = core_index.0 * systematic_threshold;
+
+			return Ok(identity
+				.into_iter()
+				.cycle()
+				.skip(core_start_pos as usize)
+				.take(n_validators)
+				.collect())
+		}
+	}
+
+	Ok(identity.collect())
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::collections::HashSet;
+
+	pub fn node_features_with_mapping_enabled() -> NodeFeatures {
+		let mut node_features = NodeFeatures::new();
+		node_features
+			.resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false);
+		node_features
+			.set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true);
+		node_features
+	}
+
+	pub fn node_features_with_other_bits_enabled() -> NodeFeatures {
+		let mut node_features = NodeFeatures::new();
+		node_features.resize(node_features::FeatureIndex::FirstUnassigned as usize + 1, true);
+		node_features
+			.set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, false);
+		node_features
+	}
+
+	#[test]
+	fn test_availability_chunk_indices() {
+		let n_validators = 20u32;
+		let n_cores = 15u32;
+
+		// If the mapping feature is not enabled, it should always be the identity vector.
+		{
+			for node_features in
+				[None, Some(NodeFeatures::EMPTY), Some(node_features_with_other_bits_enabled())]
+			{
+				for core_index in 0..n_cores {
+					let indices = availability_chunk_indices(
+						node_features.as_ref(),
+						n_validators as usize,
+						CoreIndex(core_index),
+					)
+					.unwrap();
+
+					for validator_index in 0..n_validators {
+						assert_eq!(
+							indices[validator_index as usize],
+							availability_chunk_index(
+								node_features.as_ref(),
+								n_validators as usize,
+								CoreIndex(core_index),
+								ValidatorIndex(validator_index)
+							)
+							.unwrap()
+						)
+					}
+
+					assert_eq!(
+						indices,
+						(0..n_validators).map(|i| ChunkIndex(i)).collect::<Vec<_>>()
+					);
+				}
+			}
+		}
+
+		// Test when mapping feature is enabled.
+		{
+			let node_features = node_features_with_mapping_enabled();
+			let mut previous_indices = None;
+
+			for core_index in 0..n_cores {
+				let indices = availability_chunk_indices(
+					Some(&node_features),
+					n_validators as usize,
+					CoreIndex(core_index),
+				)
+				.unwrap();
+
+				for validator_index in 0..n_validators {
+					assert_eq!(
+						indices[validator_index as usize],
+						availability_chunk_index(
+							Some(&node_features),
+							n_validators as usize,
+							CoreIndex(core_index),
+							ValidatorIndex(validator_index)
+						)
+						.unwrap()
+					)
+				}
+
+				// Check that it's not equal to the previous core's indices.
+				if let Some(previous_indices) = previous_indices {
+					assert_ne!(previous_indices, indices);
+				}
+
+				previous_indices = Some(indices.clone());
+
+				// Check that it's indeed a permutation.
+				assert_eq!(
+					(0..n_validators).map(|i| ChunkIndex(i)).collect::<HashSet<_>>(),
+					indices.into_iter().collect::<HashSet<_>>()
+				);
+			}
+		}
+	}
+
+	#[test]
+	// This is just a dummy test that checks the mapping against some hardcoded outputs, to prevent
+	// accidental changes to the algorithms.
+	fn prevent_changes_to_mapping() {
+		let n_validators = 7;
+		let node_features = node_features_with_mapping_enabled();
+
+		assert_eq!(
+			availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(0))
+				.unwrap()
+				.into_iter()
+				.map(|i| i.0)
+				.collect::<Vec<u32>>(),
+			vec![0, 1, 2, 3, 4, 5, 6]
+		);
+		assert_eq!(
+			availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(1))
+				.unwrap()
+				.into_iter()
+				.map(|i| i.0)
+				.collect::<Vec<u32>>(),
+			vec![2, 3, 4, 5, 6, 0, 1]
+		);
+		assert_eq!(
+			availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(2))
+				.unwrap()
+				.into_iter()
+				.map(|i| i.0)
+				.collect::<Vec<u32>>(),
+			vec![4, 5, 6, 0, 1, 2, 3]
+		);
+		assert_eq!(
+			availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(3))
+				.unwrap()
+				.into_iter()
+				.map(|i| i.0)
+				.collect::<Vec<u32>>(),
+			vec![6, 0, 1, 2, 3, 4, 5]
+		);
+		assert_eq!(
+			availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(4))
+				.unwrap()
+				.into_iter()
+				.map(|i| i.0)
+				.collect::<Vec<u32>>(),
+			vec![1, 2, 3, 4, 5, 6, 0]
+		);
+	}
+}
diff --git a/polkadot/node/subsystem-util/src/backing_implicit_view.rs b/polkadot/node/subsystem-util/src/backing_implicit_view.rs
index a14536a17666c8e2d9183755e3579990f6185113..23a758d25715bbd33251b5edf8835ca3625f3ffa 100644
--- a/polkadot/node/subsystem-util/src/backing_implicit_view.rs
+++ b/polkadot/node/subsystem-util/src/backing_implicit_view.rs
@@ -17,23 +17,45 @@
 use futures::channel::oneshot;
 use polkadot_node_subsystem::{
 	errors::ChainApiError,
-	messages::{ChainApiMessage, ProspectiveParachainsMessage},
+	messages::{ChainApiMessage, ProspectiveParachainsMessage, RuntimeApiMessage},
 	SubsystemSender,
 };
 use polkadot_primitives::{BlockNumber, Hash, Id as ParaId};
 
 use std::collections::HashMap;
 
+use crate::{
+	request_session_index_for_child,
+	runtime::{self, prospective_parachains_mode, recv_runtime, ProspectiveParachainsMode},
+};
+
 // Always aim to retain 1 block before the active leaves.
 const MINIMUM_RETAIN_LENGTH: BlockNumber = 2;
 
 /// Handles the implicit view of the relay chain derived from the immediate view, which
 /// is composed of active leaves, and the minimum relay-parents allowed for
 /// candidates of various parachains at those leaves.
-#[derive(Default, Clone)]
+#[derive(Clone)]
 pub struct View {
 	leaves: HashMap<Hash, ActiveLeafPruningInfo>,
 	block_info_storage: HashMap<Hash, BlockInfo>,
+	collating_for: Option<ParaId>,
+}
+
+impl View {
+	/// Create a new empty view.
+	/// If `collating_for` is `Some`, the node is a collator and is only interested in the allowed
+	/// relay parents of a single paraid. When this is true, prospective-parachains is no longer
+	/// queried.
+	pub fn new(collating_for: Option<ParaId>) -> Self {
+		Self { leaves: Default::default(), block_info_storage: Default::default(), collating_for }
+	}
+}
+
+impl Default for View {
+	fn default() -> Self {
+		Self::new(None)
+	}
 }
 
 // Minimum relay parents implicitly relative to a particular block.
@@ -106,15 +128,13 @@ impl View {
 	}
 
 	/// Activate a leaf in the view.
-	/// This will request the minimum relay parents from the
-	/// Prospective Parachains subsystem for each leaf and will load headers in the ancestry of each
-	/// leaf in the view as needed. These are the 'implicit ancestors' of the leaf.
+	/// This will request the minimum relay parents the leaf and will load headers in the
+	/// ancestry of the leaf as needed. These are the 'implicit ancestors' of the leaf.
 	///
 	/// To maximize reuse of outdated leaves, it's best to activate new leaves before
 	/// deactivating old ones.
 	///
-	/// This returns a list of para-ids which are relevant to the leaf,
-	/// and the allowed relay parents for these paras under this leaf can be
+	/// The allowed relay parents for the relevant paras under this leaf can be
 	/// queried with [`View::known_allowed_relay_parents_under`].
 	///
 	/// No-op for known leaves.
@@ -122,10 +142,11 @@ impl View {
 		&mut self,
 		sender: &mut Sender,
 		leaf_hash: Hash,
-	) -> Result<Vec<ParaId>, FetchError>
+	) -> Result<(), FetchError>
 	where
-		Sender: SubsystemSender<ChainApiMessage>,
-		Sender: SubsystemSender<ProspectiveParachainsMessage>,
+		Sender: SubsystemSender<ChainApiMessage>
+			+ SubsystemSender<ProspectiveParachainsMessage>
+			+ SubsystemSender<RuntimeApiMessage>,
 	{
 		if self.leaves.contains_key(&leaf_hash) {
 			return Err(FetchError::AlreadyKnown)
@@ -135,6 +156,7 @@ impl View {
 			leaf_hash,
 			&mut self.block_info_storage,
 			&mut *sender,
+			self.collating_for,
 		)
 		.await;
 
@@ -150,7 +172,7 @@ impl View {
 
 				self.leaves.insert(leaf_hash, ActiveLeafPruningInfo { retain_minimum });
 
-				Ok(fetched.relevant_paras)
+				Ok(())
 			},
 			Err(e) => Err(e),
 		}
@@ -249,6 +271,10 @@ pub enum FetchError {
 	/// Request to the Chain API subsystem failed.
 	#[error("The chain API subsystem was unavailable")]
 	ChainApiUnavailable,
+
+	/// Request to the runtime API failed.
+	#[error("Runtime API error: {0}")]
+	RuntimeApi(#[from] runtime::Error),
 }
 
 /// Reasons a block header might have been unavailable.
@@ -265,30 +291,92 @@ pub enum BlockHeaderUnavailableReason {
 struct FetchSummary {
 	minimum_ancestor_number: BlockNumber,
 	leaf_number: BlockNumber,
-	relevant_paras: Vec<ParaId>,
 }
 
-async fn fetch_fresh_leaf_and_insert_ancestry<Sender>(
+// Request the min relay parents from prospective-parachains.
+async fn fetch_min_relay_parents_from_prospective_parachains<
+	Sender: SubsystemSender<ProspectiveParachainsMessage>,
+>(
 	leaf_hash: Hash,
-	block_info_storage: &mut HashMap<Hash, BlockInfo>,
 	sender: &mut Sender,
-) -> Result<FetchSummary, FetchError>
+) -> Result<Vec<(ParaId, BlockNumber)>, FetchError> {
+	let (tx, rx) = oneshot::channel();
+	sender
+		.send_message(ProspectiveParachainsMessage::GetMinimumRelayParents(leaf_hash, tx))
+		.await;
+
+	rx.await.map_err(|_| FetchError::ProspectiveParachainsUnavailable)
+}
+
+// Request the min relay parent for the purposes of a collator, directly using ChainApi (where
+// prospective-parachains is not available).
+async fn fetch_min_relay_parents_for_collator<Sender>(
+	leaf_hash: Hash,
+	leaf_number: BlockNumber,
+	sender: &mut Sender,
+) -> Result<Option<BlockNumber>, FetchError>
 where
-	Sender: SubsystemSender<ChainApiMessage>,
-	Sender: SubsystemSender<ProspectiveParachainsMessage>,
+	Sender: SubsystemSender<ProspectiveParachainsMessage>
+		+ SubsystemSender<RuntimeApiMessage>
+		+ SubsystemSender<ChainApiMessage>,
 {
-	let min_relay_parents_raw = {
-		let (tx, rx) = oneshot::channel();
-		sender
-			.send_message(ProspectiveParachainsMessage::GetMinimumRelayParents(leaf_hash, tx))
-			.await;
+	let Ok(ProspectiveParachainsMode::Enabled { allowed_ancestry_len, .. }) =
+		prospective_parachains_mode(sender, leaf_hash).await
+	else {
+		// This should never happen, leaves that don't have prospective parachains mode enabled
+		// should not use implicit view.
+		return Ok(None)
+	};
 
-		match rx.await {
-			Ok(m) => m,
-			Err(_) => return Err(FetchError::ProspectiveParachainsUnavailable),
+	// Fetch the session of the leaf. We must make sure that we stop at the ancestor which has a
+	// different session index.
+	let required_session =
+		recv_runtime(request_session_index_for_child(leaf_hash, sender).await).await?;
+
+	let mut min = leaf_number;
+
+	// Fetch the ancestors, up to allowed_ancestry_len.
+	let (tx, rx) = oneshot::channel();
+	sender
+		.send_message(ChainApiMessage::Ancestors {
+			hash: leaf_hash,
+			k: allowed_ancestry_len,
+			response_channel: tx,
+		})
+		.await;
+	let hashes = rx
+		.await
+		.map_err(|_| FetchError::ChainApiUnavailable)?
+		.map_err(|err| FetchError::ChainApiError(leaf_hash, err))?;
+
+	for hash in hashes {
+		// The relay chain cannot accept blocks backed from previous sessions, with
+		// potentially previous validators. This is a technical limitation we need to
+		// respect here.
+		let session = recv_runtime(request_session_index_for_child(hash, sender).await).await?;
+
+		if session == required_session {
+			// We should never underflow here, the ChainAPI stops at genesis block.
+			min = min.saturating_sub(1);
+		} else {
+			break
 		}
-	};
+	}
 
+	Ok(Some(min))
+}
+
+async fn fetch_fresh_leaf_and_insert_ancestry<Sender>(
+	leaf_hash: Hash,
+	block_info_storage: &mut HashMap<Hash, BlockInfo>,
+	sender: &mut Sender,
+	collating_for: Option<ParaId>,
+) -> Result<FetchSummary, FetchError>
+where
+	Sender: SubsystemSender<ChainApiMessage>
+		+ SubsystemSender<ProspectiveParachainsMessage>
+		+ SubsystemSender<RuntimeApiMessage>,
+{
 	let leaf_header = {
 		let (tx, rx) = oneshot::channel();
 		sender.send_message(ChainApiMessage::BlockHeader(leaf_hash, tx)).await;
@@ -313,8 +401,18 @@ where
 		}
 	};
 
-	let min_min = min_relay_parents_raw.iter().map(|x| x.1).min().unwrap_or(leaf_header.number);
-	let relevant_paras = min_relay_parents_raw.iter().map(|x| x.0).collect();
+	// If the node is a collator, bypass prospective-parachains. We're only interested in the one
+	// paraid and the subsystem is not present.
+	let min_relay_parents = if let Some(para_id) = collating_for {
+		fetch_min_relay_parents_for_collator(leaf_hash, leaf_header.number, sender)
+			.await?
+			.map(|x| vec![(para_id, x)])
+			.unwrap_or_default()
+	} else {
+		fetch_min_relay_parents_from_prospective_parachains(leaf_hash, sender).await?
+	};
+
+	let min_min = min_relay_parents.iter().map(|x| x.1).min().unwrap_or(leaf_header.number);
 	let expected_ancestry_len = (leaf_header.number.saturating_sub(min_min) as usize) + 1;
 
 	let ancestry = if leaf_header.number > 0 {
@@ -380,14 +478,11 @@ where
 		vec![leaf_hash]
 	};
 
-	let fetched_ancestry = FetchSummary {
-		minimum_ancestor_number: min_min,
-		leaf_number: leaf_header.number,
-		relevant_paras,
-	};
+	let fetched_ancestry =
+		FetchSummary { minimum_ancestor_number: min_min, leaf_number: leaf_header.number };
 
 	let allowed_relay_parents = AllowedRelayParents {
-		minimum_relay_parents: min_relay_parents_raw.iter().cloned().collect(),
+		minimum_relay_parents: min_relay_parents.into_iter().collect(),
 		allowed_relay_parents_contiguous: ancestry,
 	};
 
@@ -408,12 +503,12 @@ mod tests {
 	use crate::TimeoutExt;
 	use assert_matches::assert_matches;
 	use futures::future::{join, FutureExt};
-	use polkadot_node_subsystem::AllMessages;
+	use polkadot_node_subsystem::{messages::RuntimeApiRequest, AllMessages};
 	use polkadot_node_subsystem_test_helpers::{
 		make_subsystem_context, TestSubsystemContextHandle,
 	};
 	use polkadot_overseer::SubsystemContext;
-	use polkadot_primitives::Header;
+	use polkadot_primitives::{AsyncBackingParams, Header};
 	use sp_core::testing::TaskExecutor;
 	use std::time::Duration;
 
@@ -514,6 +609,71 @@ mod tests {
 		);
 	}
 
+	async fn assert_async_backing_params_request(
+		virtual_overseer: &mut VirtualOverseer,
+		leaf: Hash,
+		params: AsyncBackingParams,
+	) {
+		assert_matches!(
+			overseer_recv(virtual_overseer).await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(
+					leaf_hash,
+					RuntimeApiRequest::AsyncBackingParams(
+						tx
+					)
+				)
+			) => {
+				assert_eq!(leaf, leaf_hash, "received unexpected leaf hash");
+				tx.send(Ok(params)).unwrap();
+			}
+		);
+	}
+
+	async fn assert_session_index_request(
+		virtual_overseer: &mut VirtualOverseer,
+		leaf: Hash,
+		session: u32,
+	) {
+		assert_matches!(
+			overseer_recv(virtual_overseer).await,
+			AllMessages::RuntimeApi(
+				RuntimeApiMessage::Request(
+					leaf_hash,
+					RuntimeApiRequest::SessionIndexForChild(
+						tx
+					)
+				)
+			) => {
+				assert_eq!(leaf, leaf_hash, "received unexpected leaf hash");
+				tx.send(Ok(session)).unwrap();
+			}
+		);
+	}
+
+	async fn assert_ancestors_request(
+		virtual_overseer: &mut VirtualOverseer,
+		leaf: Hash,
+		expected_ancestor_len: u32,
+		response: Vec<Hash>,
+	) {
+		assert_matches!(
+			overseer_recv(virtual_overseer).await,
+			AllMessages::ChainApi(
+				ChainApiMessage::Ancestors {
+					hash: leaf_hash,
+					k,
+					response_channel: tx
+				}
+			) => {
+				assert_eq!(leaf, leaf_hash, "received unexpected leaf hash");
+				assert_eq!(k, expected_ancestor_len as usize);
+
+				tx.send(Ok(response)).unwrap();
+			}
+		);
+	}
+
 	#[test]
 	fn construct_fresh_view() {
 		let pool = TaskExecutor::new();
@@ -521,6 +681,8 @@ mod tests {
 
 		let mut view = View::default();
 
+		assert_eq!(view.collating_for, None);
+
 		// Chain B.
 		const PARA_A_MIN_PARENT: u32 = 4;
 		const PARA_B_MIN_PARENT: u32 = 3;
@@ -528,15 +690,17 @@ mod tests {
 		let prospective_response = vec![(PARA_A, PARA_A_MIN_PARENT), (PARA_B, PARA_B_MIN_PARENT)];
 
 		let leaf = CHAIN_B.last().unwrap();
+		let leaf_idx = CHAIN_B.len() - 1;
 		let min_min_idx = (PARA_B_MIN_PARENT - GENESIS_NUMBER - 1) as usize;
 
 		let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| {
-			let paras = res.expect("`activate_leaf` timed out").unwrap();
-			assert_eq!(paras, vec![PARA_A, PARA_B]);
+			res.expect("`activate_leaf` timed out").unwrap();
 		});
 		let overseer_fut = async {
+			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[leaf_idx..]).await;
 			assert_min_relay_parents_request(&mut ctx_handle, leaf, prospective_response).await;
-			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_min_idx..]).await;
+			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_min_idx..leaf_idx])
+				.await;
 		};
 		futures::executor::block_on(join(fut, overseer_fut));
 
@@ -558,6 +722,11 @@ mod tests {
 					allowed_relay_parents.allowed_relay_parents_contiguous,
 					expected_ancestry
 				);
+
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..]));
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)), Some(&expected_ancestry[..(PARA_A_MIN_PARENT - 1) as usize]));
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)), Some(&expected_ancestry[..]));
+				assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)).unwrap().is_empty());
 			}
 		);
 
@@ -566,18 +735,188 @@ mod tests {
 		let prospective_response = vec![(PARA_C, PARA_C_MIN_PARENT)];
 		let leaf = CHAIN_A.last().unwrap();
 		let blocks = [&[GENESIS_HASH], CHAIN_A].concat();
+		let leaf_idx = blocks.len() - 1;
 
 		let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| {
-			let paras = res.expect("`activate_leaf` timed out").unwrap();
-			assert_eq!(paras, vec![PARA_C]);
+			res.expect("`activate_leaf` timed out").unwrap();
 		});
 		let overseer_fut = async {
+			assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[leaf_idx..]).await;
 			assert_min_relay_parents_request(&mut ctx_handle, leaf, prospective_response).await;
-			assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks).await;
+			assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[..leaf_idx]).await;
+		};
+		futures::executor::block_on(join(fut, overseer_fut));
+
+		assert_eq!(view.leaves.len(), 2);
+
+		let leaf_info =
+			view.block_info_storage.get(leaf).expect("block must be present in storage");
+		assert_matches!(
+			leaf_info.maybe_allowed_relay_parents,
+			Some(ref allowed_relay_parents) => {
+				assert_eq!(allowed_relay_parents.minimum_relay_parents[&PARA_C], GENESIS_NUMBER);
+				let expected_ancestry: Vec<Hash> =
+					blocks[..].iter().rev().copied().collect();
+				assert_eq!(
+					allowed_relay_parents.allowed_relay_parents_contiguous,
+					expected_ancestry
+				);
+
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..]));
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)), Some(&expected_ancestry[..]));
+
+				assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)).unwrap().is_empty());
+				assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)).unwrap().is_empty());
+			}
+		);
+	}
+
+	#[test]
+	fn construct_fresh_view_single_para() {
+		let pool = TaskExecutor::new();
+		let (mut ctx, mut ctx_handle) = make_subsystem_context::<AllMessages, _>(pool);
+
+		let mut view = View::new(Some(PARA_A));
+
+		assert_eq!(view.collating_for, Some(PARA_A));
+
+		// Chain B.
+		const PARA_A_MIN_PARENT: u32 = 4;
+
+		let current_session = 2;
+
+		let leaf = CHAIN_B.last().unwrap();
+		let leaf_idx = CHAIN_B.len() - 1;
+		let min_min_idx = (PARA_A_MIN_PARENT - GENESIS_NUMBER - 1) as usize;
+
+		let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| {
+			res.expect("`activate_leaf` timed out").unwrap();
+		});
+		let overseer_fut = async {
+			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[leaf_idx..]).await;
+
+			assert_async_backing_params_request(
+				&mut ctx_handle,
+				*leaf,
+				AsyncBackingParams {
+					max_candidate_depth: 0,
+					allowed_ancestry_len: PARA_A_MIN_PARENT,
+				},
+			)
+			.await;
+
+			assert_session_index_request(&mut ctx_handle, *leaf, current_session).await;
+
+			assert_ancestors_request(
+				&mut ctx_handle,
+				*leaf,
+				PARA_A_MIN_PARENT,
+				CHAIN_B[min_min_idx..leaf_idx].iter().copied().rev().collect(),
+			)
+			.await;
+
+			for hash in CHAIN_B[min_min_idx..leaf_idx].into_iter().rev() {
+				assert_session_index_request(&mut ctx_handle, *hash, current_session).await;
+			}
+
+			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_min_idx..leaf_idx])
+				.await;
 		};
 		futures::executor::block_on(join(fut, overseer_fut));
 
+		for i in min_min_idx..(CHAIN_B.len() - 1) {
+			// No allowed relay parents constructed for ancestry.
+			assert!(view.known_allowed_relay_parents_under(&CHAIN_B[i], None).is_none());
+		}
+
+		let leaf_info =
+			view.block_info_storage.get(leaf).expect("block must be present in storage");
+		assert_matches!(
+			leaf_info.maybe_allowed_relay_parents,
+			Some(ref allowed_relay_parents) => {
+				assert_eq!(allowed_relay_parents.minimum_relay_parents[&PARA_A], PARA_A_MIN_PARENT);
+				let expected_ancestry: Vec<Hash> =
+					CHAIN_B[min_min_idx..].iter().rev().copied().collect();
+				assert_eq!(
+					allowed_relay_parents.allowed_relay_parents_contiguous,
+					expected_ancestry
+				);
+
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..]));
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)), Some(&expected_ancestry[..]));
+
+				assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)).unwrap().is_empty());
+				assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)).unwrap().is_empty());
+			}
+		);
+
+		// Suppose the whole test chain A is allowed up to genesis for para A, but the genesis block
+		// is in a different session.
+		let leaf = CHAIN_A.last().unwrap();
+		let blocks = [&[GENESIS_HASH], CHAIN_A].concat();
+		let leaf_idx = blocks.len() - 1;
+
+		let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| {
+			res.expect("`activate_leaf` timed out").unwrap();
+		});
+
+		let overseer_fut = async {
+			assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[leaf_idx..]).await;
+
+			assert_async_backing_params_request(
+				&mut ctx_handle,
+				*leaf,
+				AsyncBackingParams {
+					max_candidate_depth: 0,
+					allowed_ancestry_len: blocks.len() as u32,
+				},
+			)
+			.await;
+
+			assert_session_index_request(&mut ctx_handle, *leaf, current_session).await;
+
+			assert_ancestors_request(
+				&mut ctx_handle,
+				*leaf,
+				blocks.len() as u32,
+				blocks[..leaf_idx].iter().rev().copied().collect(),
+			)
+			.await;
+
+			for hash in blocks[1..leaf_idx].into_iter().rev() {
+				assert_session_index_request(&mut ctx_handle, *hash, current_session).await;
+			}
+
+			assert_session_index_request(&mut ctx_handle, GENESIS_HASH, 0).await;
+
+			// We won't request for the genesis block
+			assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[1..leaf_idx]).await;
+		};
+
+		futures::executor::block_on(join(fut, overseer_fut));
+
 		assert_eq!(view.leaves.len(), 2);
+
+		let leaf_info =
+			view.block_info_storage.get(leaf).expect("block must be present in storage");
+		assert_matches!(
+			leaf_info.maybe_allowed_relay_parents,
+			Some(ref allowed_relay_parents) => {
+				assert_eq!(allowed_relay_parents.minimum_relay_parents[&PARA_A], 1);
+				let expected_ancestry: Vec<Hash> =
+					CHAIN_A[..].iter().rev().copied().collect();
+				assert_eq!(
+					allowed_relay_parents.allowed_relay_parents_contiguous,
+					expected_ancestry
+				);
+
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..]));
+				assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)), Some(&expected_ancestry[..]));
+
+				assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)).unwrap().is_empty());
+				assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)).unwrap().is_empty());
+			}
+		);
 	}
 
 	#[test]
@@ -595,15 +934,20 @@ mod tests {
 		let prospective_response = vec![(PARA_A, PARA_A_MIN_PARENT)];
 
 		let fut = view.activate_leaf(ctx.sender(), leaf_a).timeout(TIMEOUT).map(|res| {
-			let paras = res.expect("`activate_leaf` timed out").unwrap();
-			assert_eq!(paras, vec![PARA_A]);
+			res.expect("`activate_leaf` timed out").unwrap();
 		});
 		let overseer_fut = async {
+			assert_block_header_requests(
+				&mut ctx_handle,
+				CHAIN_B,
+				&CHAIN_B[(leaf_a_number - 1)..leaf_a_number],
+			)
+			.await;
 			assert_min_relay_parents_request(&mut ctx_handle, &leaf_a, prospective_response).await;
 			assert_block_header_requests(
 				&mut ctx_handle,
 				CHAIN_B,
-				&CHAIN_B[min_min_idx..leaf_a_number],
+				&CHAIN_B[min_min_idx..(leaf_a_number - 1)],
 			)
 			.await;
 		};
@@ -617,15 +961,20 @@ mod tests {
 		let prospective_response = vec![(PARA_B, PARA_B_MIN_PARENT)];
 
 		let fut = view.activate_leaf(ctx.sender(), leaf_b).timeout(TIMEOUT).map(|res| {
-			let paras = res.expect("`activate_leaf` timed out").unwrap();
-			assert_eq!(paras, vec![PARA_B]);
+			res.expect("`activate_leaf` timed out").unwrap();
 		});
 		let overseer_fut = async {
+			assert_block_header_requests(
+				&mut ctx_handle,
+				CHAIN_B,
+				&CHAIN_B[(leaf_b_number - 1)..leaf_b_number],
+			)
+			.await;
 			assert_min_relay_parents_request(&mut ctx_handle, &leaf_b, prospective_response).await;
 			assert_block_header_requests(
 				&mut ctx_handle,
 				CHAIN_B,
-				&CHAIN_B[leaf_a_number..leaf_b_number], // Note the expected range.
+				&CHAIN_B[leaf_a_number..(leaf_b_number - 1)], // Note the expected range.
 			)
 			.await;
 		};
@@ -665,13 +1014,15 @@ mod tests {
 			.timeout(TIMEOUT)
 			.map(|res| res.unwrap().unwrap());
 		let overseer_fut = async {
-			assert_min_relay_parents_request(&mut ctx_handle, &leaf_a, prospective_response).await;
 			assert_block_header_requests(
 				&mut ctx_handle,
 				CHAIN_B,
-				&CHAIN_B[min_a_idx..=leaf_a_idx],
+				&CHAIN_B[leaf_a_idx..(leaf_a_idx + 1)],
 			)
 			.await;
+			assert_min_relay_parents_request(&mut ctx_handle, &leaf_a, prospective_response).await;
+			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_a_idx..leaf_a_idx])
+				.await;
 		};
 		futures::executor::block_on(join(fut, overseer_fut));
 
@@ -689,8 +1040,11 @@ mod tests {
 			.timeout(TIMEOUT)
 			.map(|res| res.expect("`activate_leaf` timed out").unwrap());
 		let overseer_fut = async {
+			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &blocks[(blocks.len() - 1)..])
+				.await;
 			assert_min_relay_parents_request(&mut ctx_handle, &leaf_b, prospective_response).await;
-			assert_block_header_requests(&mut ctx_handle, CHAIN_B, blocks).await;
+			assert_block_header_requests(&mut ctx_handle, CHAIN_B, &blocks[..(blocks.len() - 1)])
+				.await;
 		};
 		futures::executor::block_on(join(fut, overseer_fut));
 
@@ -721,19 +1075,18 @@ mod tests {
 
 		let prospective_response = vec![(PARA_A, PARA_A_MIN_PARENT)];
 		let fut = view.activate_leaf(ctx.sender(), GENESIS_HASH).timeout(TIMEOUT).map(|res| {
-			let paras = res.expect("`activate_leaf` timed out").unwrap();
-			assert_eq!(paras, vec![PARA_A]);
+			res.expect("`activate_leaf` timed out").unwrap();
 		});
 		let overseer_fut = async {
+			assert_block_header_requests(&mut ctx_handle, &[GENESIS_HASH], &[GENESIS_HASH]).await;
 			assert_min_relay_parents_request(&mut ctx_handle, &GENESIS_HASH, prospective_response)
 				.await;
-			assert_block_header_requests(&mut ctx_handle, &[GENESIS_HASH], &[GENESIS_HASH]).await;
 		};
 		futures::executor::block_on(join(fut, overseer_fut));
 
 		assert_matches!(
 			view.known_allowed_relay_parents_under(&GENESIS_HASH, None),
-			Some(hashes) if !hashes.is_empty()
+			Some(hashes) if hashes == &[GENESIS_HASH]
 		);
 	}
 }
diff --git a/polkadot/node/subsystem-util/src/lib.rs b/polkadot/node/subsystem-util/src/lib.rs
index b93818070a183e43e71f327bcc1770a71fae1cb6..92f2cd189054dc2c26430e85448bbf51f88f4ee7 100644
--- a/polkadot/node/subsystem-util/src/lib.rs
+++ b/polkadot/node/subsystem-util/src/lib.rs
@@ -25,29 +25,28 @@
 
 #![warn(missing_docs)]
 
+pub use overseer::{
+	gen::{OrchestraError as OverseerError, Timeout},
+	Subsystem, TimeoutExt,
+};
 use polkadot_node_subsystem::{
 	errors::{RuntimeApiError, SubsystemError},
 	messages::{RuntimeApiMessage, RuntimeApiRequest, RuntimeApiSender},
 	overseer, SubsystemSender,
 };
-use polkadot_primitives::{async_backing::BackingState, slashing, CoreIndex, ExecutorParams};
-
-pub use overseer::{
-	gen::{OrchestraError as OverseerError, Timeout},
-	Subsystem, TimeoutExt,
-};
 
 pub use polkadot_node_metrics::{metrics, Metronome};
 
+use codec::Encode;
 use futures::channel::{mpsc, oneshot};
-use parity_scale_codec::Encode;
 
 use polkadot_primitives::{
-	AsyncBackingParams, AuthorityDiscoveryId, CandidateEvent, CandidateHash,
-	CommittedCandidateReceipt, CoreState, EncodeAs, GroupIndex, GroupRotationInfo, Hash,
-	Id as ParaId, OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes,
-	SessionIndex, SessionInfo, Signed, SigningContext, ValidationCode, ValidationCodeHash,
-	ValidatorId, ValidatorIndex, ValidatorSignature,
+	async_backing::BackingState, slashing, AsyncBackingParams, AuthorityDiscoveryId,
+	CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreIndex, CoreState, EncodeAs,
+	ExecutorParams, GroupIndex, GroupRotationInfo, Hash, Id as ParaId, OccupiedCoreAssumption,
+	PersistedValidationData, ScrapedOnChainVotes, SessionIndex, SessionInfo, Signed,
+	SigningContext, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
+	ValidatorSignature,
 };
 pub use rand;
 use sp_application_crypto::AppCrypto;
@@ -60,17 +59,18 @@ use std::{
 use thiserror::Error;
 use vstaging::get_disabled_validators_with_fallback;
 
+pub use determine_new_blocks::determine_new_blocks;
 pub use metered;
 pub use polkadot_node_network_protocol::MIN_GOSSIP_PEERS;
 
-pub use determine_new_blocks::determine_new_blocks;
-
 /// These reexports are required so that external crates can use the `delegated_subsystem` macro
 /// properly.
 pub mod reexports {
 	pub use polkadot_overseer::gen::{SpawnedSubsystem, Spawner, Subsystem, SubsystemContext};
 }
 
+/// Helpers for the validator->chunk index mapping.
+pub mod availability_chunks;
 /// A utility for managing the implicit view of the relay-chain derived from active
 /// leaves and the minimum allowed relay-parents that parachain candidates can have
 /// and be backed in those leaves' children.
diff --git a/polkadot/node/subsystem-util/src/runtime/error.rs b/polkadot/node/subsystem-util/src/runtime/error.rs
index 8751693b078a6797584ed59a2ebd3c320d87cd78..1111b119e95f5926321f7a09de6af02bcbc4acba 100644
--- a/polkadot/node/subsystem-util/src/runtime/error.rs
+++ b/polkadot/node/subsystem-util/src/runtime/error.rs
@@ -28,7 +28,7 @@ pub enum Error {
 	/// Runtime API subsystem is down, which means we're shutting down.
 	#[fatal]
 	#[error("Runtime request got canceled")]
-	RuntimeRequestCanceled(oneshot::Canceled),
+	RuntimeRequestCanceled(#[from] oneshot::Canceled),
 
 	/// Some request to the runtime failed.
 	/// For example if we prune a block we're requesting info about.
diff --git a/polkadot/node/subsystem-util/src/runtime/mod.rs b/polkadot/node/subsystem-util/src/runtime/mod.rs
index 714384b32e37bcbd6ba7f077252fa23f50eac490..2c9ec8db3778bbe31981d38d3ba4b4b1e426ccc5 100644
--- a/polkadot/node/subsystem-util/src/runtime/mod.rs
+++ b/polkadot/node/subsystem-util/src/runtime/mod.rs
@@ -18,7 +18,7 @@
 
 use schnellru::{ByLength, LruMap};
 
-use parity_scale_codec::Encode;
+use codec::Encode;
 use sp_application_crypto::AppCrypto;
 use sp_core::crypto::ByteArray;
 use sp_keystore::{Keystore, KeystorePtr};
@@ -31,8 +31,8 @@ use polkadot_node_subsystem::{
 use polkadot_node_subsystem_types::UnpinHandle;
 use polkadot_primitives::{
 	node_features::FeatureIndex, slashing, AsyncBackingParams, CandidateEvent, CandidateHash,
-	CoreState, EncodeAs, ExecutorParams, GroupIndex, GroupRotationInfo, Hash, IndexedVec,
-	NodeFeatures, OccupiedCore, ScrapedOnChainVotes, SessionIndex, SessionInfo, Signed,
+	CoreIndex, CoreState, EncodeAs, ExecutorParams, GroupIndex, GroupRotationInfo, Hash,
+	IndexedVec, NodeFeatures, OccupiedCore, ScrapedOnChainVotes, SessionIndex, SessionInfo, Signed,
 	SigningContext, UncheckedSigned, ValidationCode, ValidationCodeHash, ValidatorId,
 	ValidatorIndex, LEGACY_MIN_BACKING_VOTES,
 };
@@ -348,7 +348,7 @@ where
 pub async fn get_occupied_cores<Sender>(
 	sender: &mut Sender,
 	relay_parent: Hash,
-) -> Result<Vec<OccupiedCore>>
+) -> Result<Vec<(CoreIndex, OccupiedCore)>>
 where
 	Sender: overseer::SubsystemSender<RuntimeApiMessage>,
 {
@@ -356,9 +356,10 @@ where
 
 	Ok(cores
 		.into_iter()
-		.filter_map(|core_state| {
+		.enumerate()
+		.filter_map(|(core_index, core_state)| {
 			if let CoreState::Occupied(occupied) = core_state {
-				Some(occupied)
+				Some((CoreIndex(core_index as u32), occupied))
 			} else {
 				None
 			}
diff --git a/polkadot/node/subsystem-util/src/vstaging.rs b/polkadot/node/subsystem-util/src/vstaging.rs
index b166a54f75c46ebfe4dd8d06af32a3dea3495b7a..b6cd73f412b33a10c814be9813e0cd14bd843934 100644
--- a/polkadot/node/subsystem-util/src/vstaging.rs
+++ b/polkadot/node/subsystem-util/src/vstaging.rs
@@ -31,7 +31,7 @@ const LOG_TARGET: &'static str = "parachain::subsystem-util-vstaging";
 
 /// A snapshot of the runtime claim queue at an arbitrary relay chain block.
 #[derive(Default)]
-pub struct ClaimQueueSnapshot(BTreeMap<CoreIndex, VecDeque<ParaId>>);
+pub struct ClaimQueueSnapshot(pub BTreeMap<CoreIndex, VecDeque<ParaId>>);
 
 impl From<BTreeMap<CoreIndex, VecDeque<ParaId>>> for ClaimQueueSnapshot {
 	fn from(claim_queue_snapshot: BTreeMap<CoreIndex, VecDeque<ParaId>>) -> Self {
@@ -56,6 +56,19 @@ impl ClaimQueueSnapshot {
 			.iter()
 			.filter_map(move |(core_index, paras)| Some((*core_index, *paras.get(depth)?)))
 	}
+
+	/// Returns an iterator over all claims on the given core.
+	pub fn iter_claims_for_core(
+		&self,
+		core_index: &CoreIndex,
+	) -> impl Iterator<Item = &ParaId> + '_ {
+		self.0.get(core_index).map(|c| c.iter()).into_iter().flatten()
+	}
+
+	/// Returns an iterator over the whole claim queue.
+	pub fn iter_all_claims(&self) -> impl Iterator<Item = (&CoreIndex, &VecDeque<ParaId>)> + '_ {
+		self.0.iter()
+	}
 }
 
 // TODO: https://github.com/paritytech/polkadot-sdk/issues/1940
diff --git a/polkadot/node/test/client/Cargo.toml b/polkadot/node/test/client/Cargo.toml
index 55d4d81d1c21bbb5007962ac71c8d38fe898d49b..0b49866ee2aec4f9676241a50271a16657b221e0 100644
--- a/polkadot/node/test/client/Cargo.toml
+++ b/polkadot/node/test/client/Cargo.toml
@@ -10,7 +10,7 @@ license.workspace = true
 workspace = true
 
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 
 # Polkadot dependencies
 polkadot-test-runtime = { path = "../../../runtime/test-runtime" }
diff --git a/polkadot/node/test/client/src/block_builder.rs b/polkadot/node/test/client/src/block_builder.rs
index 57e6008917af9cf6a5ceb6d173f680f9d90e5ebb..71bcdaffac4e7e69c7614abe4c51a50bd1e8556e 100644
--- a/polkadot/node/test/client/src/block_builder.rs
+++ b/polkadot/node/test/client/src/block_builder.rs
@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::Client;
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_primitives::{Block, InherentData as ParachainsInherentData};
 use polkadot_test_runtime::UncheckedExtrinsic;
 use polkadot_test_service::GetLastTimestamp;
diff --git a/polkadot/node/test/service/Cargo.toml b/polkadot/node/test/service/Cargo.toml
index 48a206f23c660ca9dbb5e0dd48b1cf0f4835b183..3fc6d060870b1c36940cd7b75e50cddcf55782d3 100644
--- a/polkadot/node/test/service/Cargo.toml
+++ b/polkadot/node/test/service/Cargo.toml
@@ -34,13 +34,13 @@ polkadot-runtime-parachains = { path = "../../../runtime/parachains" }
 # Substrate dependencies
 sp-authority-discovery = { path = "../../../../substrate/primitives/authority-discovery" }
 sc-authority-discovery = { path = "../../../../substrate/client/authority-discovery" }
-babe = { package = "sc-consensus-babe", path = "../../../../substrate/client/consensus/babe" }
-babe-primitives = { package = "sp-consensus-babe", path = "../../../../substrate/primitives/consensus/babe" }
-consensus_common = { package = "sp-consensus", path = "../../../../substrate/primitives/consensus/common" }
+sc-consensus-babe = { path = "../../../../substrate/client/consensus/babe" }
+sp-consensus-babe = { path = "../../../../substrate/primitives/consensus/babe" }
+sp-consensus = { path = "../../../../substrate/primitives/consensus/common" }
 frame-system = { path = "../../../../substrate/frame/system" }
-grandpa = { package = "sc-consensus-grandpa", path = "../../../../substrate/client/consensus/grandpa" }
-grandpa_primitives = { package = "sp-consensus-grandpa", path = "../../../../substrate/primitives/consensus/grandpa" }
-inherents = { package = "sp-inherents", path = "../../../../substrate/primitives/inherents" }
+sc-consensus-grandpa = { path = "../../../../substrate/client/consensus/grandpa" }
+sp-consensus-grandpa = { path = "../../../../substrate/primitives/consensus/grandpa" }
+sp-inherents = { path = "../../../../substrate/primitives/inherents" }
 pallet-staking = { path = "../../../../substrate/frame/staking" }
 pallet-balances = { path = "../../../../substrate/frame/balances" }
 pallet-transaction-payment = { path = "../../../../substrate/frame/transaction-payment" }
diff --git a/polkadot/node/test/service/src/chain_spec.rs b/polkadot/node/test/service/src/chain_spec.rs
index f14fa9fde58b4426690cd1bd0e16129f095c34ec..bd53fd843c693514b91f9ebda445a56675fbf27a 100644
--- a/polkadot/node/test/service/src/chain_spec.rs
+++ b/polkadot/node/test/service/src/chain_spec.rs
@@ -16,8 +16,6 @@
 
 //! Chain specifications for the test runtime.
 
-use babe_primitives::AuthorityId as BabeId;
-use grandpa::AuthorityId as GrandpaId;
 use pallet_staking::Forcing;
 use polkadot_primitives::{
 	vstaging::SchedulerParams, AccountId, AssignmentId, ValidatorId, MAX_CODE_SIZE, MAX_POV_SIZE,
@@ -25,7 +23,9 @@ use polkadot_primitives::{
 use polkadot_service::chain_spec::{get_account_id_from_seed, get_from_seed, Extensions};
 use polkadot_test_runtime::BABE_GENESIS_EPOCH_CONFIG;
 use sc_chain_spec::{ChainSpec, ChainType};
+use sc_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
+use sp_consensus_babe::AuthorityId as BabeId;
 use sp_core::sr25519;
 use sp_runtime::Perbill;
 use test_runtime_constants::currency::DOTS;
@@ -33,7 +33,7 @@ use test_runtime_constants::currency::DOTS;
 const DEFAULT_PROTOCOL_ID: &str = "dot";
 
 /// The `ChainSpec` parameterized for polkadot test runtime.
-pub type PolkadotChainSpec = sc_service::GenericChainSpec<(), Extensions>;
+pub type PolkadotChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// Returns the properties for the [`PolkadotChainSpec`].
 pub fn polkadot_chain_spec_properties() -> serde_json::map::Map<String, serde_json::Value> {
diff --git a/polkadot/node/zombienet-backchannel/Cargo.toml b/polkadot/node/zombienet-backchannel/Cargo.toml
index a0233bb46e5128b1b036a6fa7dd0181e587f1e9a..31662ccfc464913989e479a12e4bd976451498dc 100644
--- a/polkadot/node/zombienet-backchannel/Cargo.toml
+++ b/polkadot/node/zombienet-backchannel/Cargo.toml
@@ -17,7 +17,7 @@ url = "2.3.1"
 tokio-tungstenite = "0.20.1"
 futures-util = "0.3.30"
 lazy_static = "1.4.0"
-parity-scale-codec = { version = "3.6.12", features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["derive"] }
 reqwest = { version = "0.11", features = ["rustls-tls"], default-features = false }
 thiserror = { workspace = true }
 gum = { package = "tracing-gum", path = "../gum" }
diff --git a/polkadot/node/zombienet-backchannel/src/lib.rs b/polkadot/node/zombienet-backchannel/src/lib.rs
index fa9218d2d3502af7d55cfead12f5aebe1cb070ef..9068b03399ca5180ec17a03669be3ea25fc3c5db 100644
--- a/polkadot/node/zombienet-backchannel/src/lib.rs
+++ b/polkadot/node/zombienet-backchannel/src/lib.rs
@@ -19,9 +19,9 @@
 //! values in the test specifications, through a bidirectional message passing
 //! implemented as a `backchannel`.
 
+use codec;
 use futures_util::{SinkExt, StreamExt};
 use lazy_static::lazy_static;
-use parity_scale_codec as codec;
 use serde::{Deserialize, Serialize};
 use std::{env, sync::Mutex};
 use tokio::sync::broadcast;
diff --git a/polkadot/parachain/Cargo.toml b/polkadot/parachain/Cargo.toml
index 1344baac64b65246945b3bd09569cf21990fde5e..11e8e3ce6d843cf410ce4a2c0bfb2ceacde9ce3e 100644
--- a/polkadot/parachain/Cargo.toml
+++ b/polkadot/parachain/Cargo.toml
@@ -13,7 +13,7 @@ workspace = true
 # note: special care is taken to avoid inclusion of `sp-io` externals when compiling
 # this crate for WASM. This is critical to avoid forcing all parachain WASM into implementing
 # various unnecessary Substrate-specific endpoints.
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] }
 sp-std = { path = "../../substrate/primitives/std", default-features = false }
 sp-runtime = { path = "../../substrate/primitives/runtime", default-features = false, features = ["serde"] }
@@ -31,7 +31,7 @@ default = ["std"]
 wasm-api = []
 std = [
 	"bounded-collections/std",
-	"parity-scale-codec/std",
+	"codec/std",
 	"polkadot-core-primitives/std",
 	"scale-info/std",
 	"serde/std",
diff --git a/polkadot/parachain/src/primitives.rs b/polkadot/parachain/src/primitives.rs
index 2764384363727a8b7b350b02441903204eae717f..d92bbee8d28d16ea879094607ab74471551c9313 100644
--- a/polkadot/parachain/src/primitives.rs
+++ b/polkadot/parachain/src/primitives.rs
@@ -20,7 +20,7 @@
 use sp_std::vec::Vec;
 
 use bounded_collections::{BoundedVec, ConstU32};
-use parity_scale_codec::{CompactAs, Decode, Encode, MaxEncodedLen};
+use codec::{CompactAs, Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};
 use sp_core::{bytes, RuntimeDebug, TypeId};
diff --git a/polkadot/parachain/src/wasm_api.rs b/polkadot/parachain/src/wasm_api.rs
index 981d276af75ca5e06cfb108045d51eeb8cd6e99e..f0c832666284c2476401e2c8e7ced49a31864b7e 100644
--- a/polkadot/parachain/src/wasm_api.rs
+++ b/polkadot/parachain/src/wasm_api.rs
@@ -24,7 +24,7 @@
 pub unsafe fn load_params(params: *const u8, len: usize) -> crate::primitives::ValidationParams {
 	let mut slice = sp_std::slice::from_raw_parts(params, len);
 
-	parity_scale_codec::Decode::decode(&mut slice).expect("Invalid input data")
+	codec::Decode::decode(&mut slice).expect("Invalid input data")
 }
 
 /// Allocate the validation result in memory, getting the return-pointer back.
diff --git a/polkadot/parachain/test-parachains/Cargo.toml b/polkadot/parachain/test-parachains/Cargo.toml
index 22f3d2942e0c2076cae4e9e37a6d960b42969860..c58b11a11b01f9fb16d80fbe836cdcc956a84890 100644
--- a/polkadot/parachain/test-parachains/Cargo.toml
+++ b/polkadot/parachain/test-parachains/Cargo.toml
@@ -12,14 +12,14 @@ workspace = true
 
 [dependencies]
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 
-adder = { package = "test-parachain-adder", path = "adder" }
-halt = { package = "test-parachain-halt", path = "halt" }
+test-parachain-adder = { path = "adder" }
+test-parachain-halt = { path = "halt" }
 
 [dev-dependencies]
 sp-core = { path = "../../../substrate/primitives/core" }
 
 [features]
 default = ["std"]
-std = ["adder/std", "halt/std", "parity-scale-codec/std"]
+std = ["codec/std", "test-parachain-adder/std", "test-parachain-halt/std"]
diff --git a/polkadot/parachain/test-parachains/adder/Cargo.toml b/polkadot/parachain/test-parachains/adder/Cargo.toml
index 273fa93a50f412ffc282aeeafb07c0e173fd5e72..e0bbe177eedced788de07dc5bf753b4a2f9bb66e 100644
--- a/polkadot/parachain/test-parachains/adder/Cargo.toml
+++ b/polkadot/parachain/test-parachains/adder/Cargo.toml
@@ -12,8 +12,8 @@ publish = false
 workspace = true
 
 [dependencies]
-parachain = { package = "polkadot-parachain-primitives", path = "../..", default-features = false, features = ["wasm-api"] }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+polkadot-parachain-primitives = { path = "../..", default-features = false, features = ["wasm-api"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sp-std = { path = "../../../../substrate/primitives/std", default-features = false }
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
 dlmalloc = { version = "0.2.4", features = ["global"] }
@@ -26,4 +26,4 @@ substrate-wasm-builder = { path = "../../../../substrate/utils/wasm-builder" }
 
 [features]
 default = ["std"]
-std = ["parachain/std", "parity-scale-codec/std", "sp-io/std", "sp-std/std"]
+std = ["codec/std", "polkadot-parachain-primitives/std", "sp-io/std", "sp-std/std"]
diff --git a/polkadot/parachain/test-parachains/adder/collator/Cargo.toml b/polkadot/parachain/test-parachains/adder/collator/Cargo.toml
index dbc8507d599bb5e7899a8ee99450e95e4c480618..996735e8c8bf8e641de15acf4bb2bd2e126c94fe 100644
--- a/polkadot/parachain/test-parachains/adder/collator/Cargo.toml
+++ b/polkadot/parachain/test-parachains/adder/collator/Cargo.toml
@@ -15,7 +15,7 @@ name = "adder-collator"
 path = "src/main.rs"
 
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 clap = { version = "4.5.3", features = ["derive"] }
 futures = "0.3.30"
 futures-timer = "3.0.2"
@@ -24,7 +24,7 @@ log = { workspace = true, default-features = true }
 test-parachain-adder = { path = ".." }
 polkadot-primitives = { path = "../../../../primitives" }
 polkadot-cli = { path = "../../../../cli" }
-polkadot-service = { path = "../../../../node/service", features = ["elastic-scaling-experimental", "rococo-native"] }
+polkadot-service = { path = "../../../../node/service", features = ["rococo-native"] }
 polkadot-node-primitives = { path = "../../../../node/primitives" }
 polkadot-node-subsystem = { path = "../../../../node/subsystem" }
 
diff --git a/polkadot/parachain/test-parachains/adder/collator/src/lib.rs b/polkadot/parachain/test-parachains/adder/collator/src/lib.rs
index c2ba93f389b03d3c3171bc68ad845d373da124f3..daeb8bc915dd613bd83d532406e2c9bfa92af2b0 100644
--- a/polkadot/parachain/test-parachains/adder/collator/src/lib.rs
+++ b/polkadot/parachain/test-parachains/adder/collator/src/lib.rs
@@ -16,9 +16,9 @@
 
 //! Collator for the adder test parachain.
 
+use codec::{Decode, Encode};
 use futures::channel::oneshot;
 use futures_timer::Delay;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_node_primitives::{
 	Collation, CollationResult, CollationSecondedSignal, CollatorFn, MaybeCompressedPoV, PoV,
 	Statement,
diff --git a/polkadot/parachain/test-parachains/adder/src/lib.rs b/polkadot/parachain/test-parachains/adder/src/lib.rs
index 4cf1ba8ac971df98142bc04d5deee1add1334fbd..28914f02511debbc1beba6253e9f1e74dbfacc17 100644
--- a/polkadot/parachain/test-parachains/adder/src/lib.rs
+++ b/polkadot/parachain/test-parachains/adder/src/lib.rs
@@ -18,7 +18,7 @@
 
 #![no_std]
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use tiny_keccak::{Hasher as _, Keccak};
 
 #[cfg(not(feature = "std"))]
diff --git a/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs b/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs
index 048330437cd7bb4b24e1dc4e1ae3d20c9ea18b65..7dba7a964d3b0468d48799557a363d374f4aea38 100644
--- a/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs
+++ b/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs
@@ -17,14 +17,14 @@
 //! WASM validation for adder parachain.
 
 use crate::{BlockData, HeadData};
+use codec::{Decode, Encode};
 use core::panic;
-use parachain::primitives::{HeadData as GenericHeadData, ValidationResult};
-use parity_scale_codec::{Decode, Encode};
+use polkadot_parachain_primitives::primitives::{HeadData as GenericHeadData, ValidationResult};
 use sp_std::vec::Vec;
 
 #[no_mangle]
 pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 {
-	let params = unsafe { parachain::load_params(params, len) };
+	let params = unsafe { polkadot_parachain_primitives::load_params(params, len) };
 	let parent_head =
 		HeadData::decode(&mut &params.parent_head.0[..]).expect("invalid parent head format.");
 
@@ -34,7 +34,7 @@ pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 {
 	let parent_hash = crate::keccak256(&params.parent_head.0[..]);
 
 	let new_head = crate::execute(parent_hash, parent_head, &block_data).expect("Executes block");
-	parachain::write_result(&ValidationResult {
+	polkadot_parachain_primitives::write_result(&ValidationResult {
 		head_data: GenericHeadData(new_head.encode()),
 		new_validation_code: None,
 		upward_messages: sp_std::vec::Vec::new().try_into().expect("empty vec fits into bounds"),
diff --git a/polkadot/parachain/test-parachains/undying/Cargo.toml b/polkadot/parachain/test-parachains/undying/Cargo.toml
index f2067a2c3b9bdc3c7e585fbb03fc79ee435f7d1d..4d3d2abaeafed85dea9a415da47b620981f1e5ca 100644
--- a/polkadot/parachain/test-parachains/undying/Cargo.toml
+++ b/polkadot/parachain/test-parachains/undying/Cargo.toml
@@ -12,8 +12,8 @@ license.workspace = true
 workspace = true
 
 [dependencies]
-parachain = { package = "polkadot-parachain-primitives", path = "../..", default-features = false, features = ["wasm-api"] }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+polkadot-parachain-primitives = { path = "../..", default-features = false, features = ["wasm-api"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sp-std = { path = "../../../../substrate/primitives/std", default-features = false }
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
 dlmalloc = { version = "0.2.4", features = ["global"] }
@@ -28,9 +28,9 @@ substrate-wasm-builder = { path = "../../../../substrate/utils/wasm-builder" }
 [features]
 default = ["std"]
 std = [
+	"codec/std",
 	"log/std",
-	"parachain/std",
-	"parity-scale-codec/std",
+	"polkadot-parachain-primitives/std",
 	"sp-io/std",
 	"sp-std/std",
 ]
diff --git a/polkadot/parachain/test-parachains/undying/collator/Cargo.toml b/polkadot/parachain/test-parachains/undying/collator/Cargo.toml
index 28efdbbf242f7879615928bb228a4975b54c2d0c..288549c2c268ab93a3b39d5bc2e184a28b7dc158 100644
--- a/polkadot/parachain/test-parachains/undying/collator/Cargo.toml
+++ b/polkadot/parachain/test-parachains/undying/collator/Cargo.toml
@@ -15,7 +15,7 @@ name = "undying-collator"
 path = "src/main.rs"
 
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 clap = { version = "4.5.3", features = ["derive"] }
 futures = "0.3.30"
 futures-timer = "3.0.2"
@@ -24,7 +24,7 @@ log = { workspace = true, default-features = true }
 test-parachain-undying = { path = ".." }
 polkadot-primitives = { path = "../../../../primitives" }
 polkadot-cli = { path = "../../../../cli" }
-polkadot-service = { path = "../../../../node/service", features = ["elastic-scaling-experimental", "rococo-native"] }
+polkadot-service = { path = "../../../../node/service", features = ["rococo-native"] }
 polkadot-node-primitives = { path = "../../../../node/primitives" }
 polkadot-node-subsystem = { path = "../../../../node/subsystem" }
 
diff --git a/polkadot/parachain/test-parachains/undying/collator/src/lib.rs b/polkadot/parachain/test-parachains/undying/collator/src/lib.rs
index 3c869233182f8faf98e8855017a0e255d5b43167..920099f4499d4467c1df6e6c6f482d489a0f8d26 100644
--- a/polkadot/parachain/test-parachains/undying/collator/src/lib.rs
+++ b/polkadot/parachain/test-parachains/undying/collator/src/lib.rs
@@ -16,9 +16,9 @@
 
 //! Collator for the `Undying` test parachain.
 
+use codec::{Decode, Encode};
 use futures::channel::oneshot;
 use futures_timer::Delay;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_node_primitives::{
 	maybe_compress_pov, Collation, CollationResult, CollationSecondedSignal, CollatorFn,
 	MaybeCompressedPoV, PoV, Statement,
diff --git a/polkadot/parachain/test-parachains/undying/src/lib.rs b/polkadot/parachain/test-parachains/undying/src/lib.rs
index abd88726b7fcb42f30f19bee37623f662547a1bf..dc056e64fa23fb801a34d7d7b276982e4adf4f55 100644
--- a/polkadot/parachain/test-parachains/undying/src/lib.rs
+++ b/polkadot/parachain/test-parachains/undying/src/lib.rs
@@ -18,7 +18,7 @@
 
 #![no_std]
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use sp_std::vec::Vec;
 use tiny_keccak::{Hasher as _, Keccak};
 
diff --git a/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs b/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs
index de4a1d7e2329c8ff2c6540abf91f0f3d02a3ed35..23fac43a3c73129b1af27d12cb0a4a79aa3c7be1 100644
--- a/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs
+++ b/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs
@@ -17,12 +17,12 @@
 //! WASM validation for the `Undying` parachain.
 
 use crate::{BlockData, HeadData};
-use parachain::primitives::{HeadData as GenericHeadData, ValidationResult};
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
+use polkadot_parachain_primitives::primitives::{HeadData as GenericHeadData, ValidationResult};
 
 #[no_mangle]
 pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 {
-	let params = unsafe { parachain::load_params(params, len) };
+	let params = unsafe { polkadot_parachain_primitives::load_params(params, len) };
 	let parent_head =
 		HeadData::decode(&mut &params.parent_head.0[..]).expect("invalid parent head format.");
 
@@ -34,7 +34,7 @@ pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 {
 	let (new_head, _) =
 		crate::execute(parent_hash, parent_head, block_data).expect("Executes block");
 
-	parachain::write_result(&ValidationResult {
+	polkadot_parachain_primitives::write_result(&ValidationResult {
 		head_data: GenericHeadData(new_head.encode()),
 		new_validation_code: None,
 		upward_messages: sp_std::vec::Vec::new().try_into().expect("empty vec fits within bounds"),
diff --git a/polkadot/primitives/Cargo.toml b/polkadot/primitives/Cargo.toml
index 603d08b8fee524f803b32c751cdd818249687132..d6df077b88b771ce556db3cc056745a5254a6bc5 100644
--- a/polkadot/primitives/Cargo.toml
+++ b/polkadot/primitives/Cargo.toml
@@ -12,15 +12,15 @@ workspace = true
 [dependencies]
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc", "serde"] }
 hex-literal = "0.4.1"
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["bit-vec", "derive"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["bit-vec", "derive", "serde"] }
 log = { workspace = true, default-features = false }
 serde = { features = ["alloc", "derive"], workspace = true }
 
-application-crypto = { package = "sp-application-crypto", path = "../../substrate/primitives/application-crypto", default-features = false, features = ["serde"] }
-inherents = { package = "sp-inherents", path = "../../substrate/primitives/inherents", default-features = false }
-primitives = { package = "sp-core", path = "../../substrate/primitives/core", default-features = false }
-runtime_primitives = { package = "sp-runtime", path = "../../substrate/primitives/runtime", default-features = false }
+sp-application-crypto = { path = "../../substrate/primitives/application-crypto", default-features = false, features = ["serde"] }
+sp-inherents = { path = "../../substrate/primitives/inherents", default-features = false }
+sp-core = { path = "../../substrate/primitives/core", default-features = false }
+sp-runtime = { path = "../../substrate/primitives/runtime", default-features = false }
 sp-api = { path = "../../substrate/primitives/api", default-features = false }
 sp-arithmetic = { path = "../../substrate/primitives/arithmetic", default-features = false, features = ["serde"] }
 sp-authority-discovery = { path = "../../substrate/primitives/authority-discovery", default-features = false, features = ["serde"] }
@@ -36,29 +36,29 @@ polkadot-parachain-primitives = { path = "../parachain", default-features = fals
 [features]
 default = ["std"]
 std = [
-	"application-crypto/std",
 	"bitvec/std",
-	"inherents/std",
+	"codec/std",
 	"log/std",
-	"parity-scale-codec/std",
 	"polkadot-core-primitives/std",
 	"polkadot-parachain-primitives/std",
-	"primitives/std",
-	"runtime_primitives/std",
 	"scale-info/std",
 	"serde/std",
 	"sp-api/std",
+	"sp-application-crypto/std",
 	"sp-arithmetic/std",
 	"sp-authority-discovery/std",
 	"sp-consensus-slots/std",
+	"sp-core/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-keystore",
 	"sp-keystore?/std",
+	"sp-runtime/std",
 	"sp-staking/std",
 	"sp-std/std",
 ]
 runtime-benchmarks = [
 	"polkadot-parachain-primitives/runtime-benchmarks",
-	"runtime_primitives/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
 ]
diff --git a/polkadot/primitives/src/lib.rs b/polkadot/primitives/src/lib.rs
index 01f393086a668f43d2e18abc10b4491f54aae2cf..061794ca06d1be1883fd3605eb5bc691e5b7b23b 100644
--- a/polkadot/primitives/src/lib.rs
+++ b/polkadot/primitives/src/lib.rs
@@ -41,26 +41,26 @@ pub use v7::{
 	ApprovalVotingParams, AssignmentId, AsyncBackingParams, AuthorityDiscoveryId,
 	AvailabilityBitfield, BackedCandidate, Balance, BlakeTwo256, Block, BlockId, BlockNumber,
 	CandidateCommitments, CandidateDescriptor, CandidateEvent, CandidateHash, CandidateIndex,
-	CandidateReceipt, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, CollatorId,
-	CollatorSignature, CommittedCandidateReceipt, CompactStatement, ConsensusLog, CoreIndex,
-	CoreState, DisputeState, DisputeStatement, DisputeStatementSet, DownwardMessage, EncodeAs,
-	ExecutorParam, ExecutorParamError, ExecutorParams, ExecutorParamsHash, ExecutorParamsPrepHash,
-	ExplicitDisputeStatement, GroupIndex, GroupRotationInfo, Hash, HashT, HeadData, Header,
-	HorizontalMessages, HrmpChannelId, Id, InboundDownwardMessage, InboundHrmpMessage, IndexedVec,
-	InherentData, InvalidDisputeStatementKind, Moment, MultiDisputeStatementSet, NodeFeatures,
-	Nonce, OccupiedCore, OccupiedCoreAssumption, OutboundHrmpMessage, ParathreadClaim,
-	ParathreadEntry, PersistedValidationData, PvfCheckStatement, PvfExecKind, PvfPrepKind,
-	RuntimeMetricLabel, RuntimeMetricLabelValue, RuntimeMetricLabelValues, RuntimeMetricLabels,
-	RuntimeMetricOp, RuntimeMetricUpdate, ScheduledCore, ScrapedOnChainVotes, SessionIndex,
-	SessionInfo, Signature, Signed, SignedAvailabilityBitfield, SignedAvailabilityBitfields,
-	SignedStatement, SigningContext, Slot, UncheckedSigned, UncheckedSignedAvailabilityBitfield,
-	UncheckedSignedAvailabilityBitfields, UncheckedSignedStatement, UpgradeGoAhead,
-	UpgradeRestriction, UpwardMessage, ValidDisputeStatementKind, ValidationCode,
-	ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature, ValidityAttestation,
-	ValidityError, ASSIGNMENT_KEY_TYPE_ID, LEGACY_MIN_BACKING_VOTES, LOWEST_PUBLIC_ID,
-	MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MAX_POV_SIZE, MIN_CODE_SIZE,
-	ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, ON_DEMAND_MAX_QUEUE_MAX_SIZE, PARACHAINS_INHERENT_IDENTIFIER,
-	PARACHAIN_KEY_TYPE_ID,
+	CandidateReceipt, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, ChunkIndex,
+	CollatorId, CollatorSignature, CommittedCandidateReceipt, CompactStatement, ConsensusLog,
+	CoreIndex, CoreState, DisputeState, DisputeStatement, DisputeStatementSet, DownwardMessage,
+	EncodeAs, ExecutorParam, ExecutorParamError, ExecutorParams, ExecutorParamsHash,
+	ExecutorParamsPrepHash, ExplicitDisputeStatement, GroupIndex, GroupRotationInfo, Hash, HashT,
+	HeadData, Header, HorizontalMessages, HrmpChannelId, Id, InboundDownwardMessage,
+	InboundHrmpMessage, IndexedVec, InherentData, InvalidDisputeStatementKind, Moment,
+	MultiDisputeStatementSet, NodeFeatures, Nonce, OccupiedCore, OccupiedCoreAssumption,
+	OutboundHrmpMessage, ParathreadClaim, ParathreadEntry, PersistedValidationData,
+	PvfCheckStatement, PvfExecKind, PvfPrepKind, RuntimeMetricLabel, RuntimeMetricLabelValue,
+	RuntimeMetricLabelValues, RuntimeMetricLabels, RuntimeMetricOp, RuntimeMetricUpdate,
+	ScheduledCore, ScrapedOnChainVotes, SessionIndex, SessionInfo, Signature, Signed,
+	SignedAvailabilityBitfield, SignedAvailabilityBitfields, SignedStatement, SigningContext, Slot,
+	UncheckedSigned, UncheckedSignedAvailabilityBitfield, UncheckedSignedAvailabilityBitfields,
+	UncheckedSignedStatement, UpgradeGoAhead, UpgradeRestriction, UpwardMessage,
+	ValidDisputeStatementKind, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
+	ValidatorSignature, ValidityAttestation, ValidityError, ASSIGNMENT_KEY_TYPE_ID,
+	LEGACY_MIN_BACKING_VOTES, LOWEST_PUBLIC_ID, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MAX_POV_SIZE,
+	MIN_CODE_SIZE, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, ON_DEMAND_MAX_QUEUE_MAX_SIZE,
+	PARACHAINS_INHERENT_IDENTIFIER, PARACHAIN_KEY_TYPE_ID,
 };
 
 #[cfg(feature = "std")]
diff --git a/polkadot/primitives/src/v7/async_backing.rs b/polkadot/primitives/src/v7/async_backing.rs
index 1abe87b6dec433122a6918f2f834a4a8e57817e8..a82d843d28bf1ca9993e7951fa8f51c458bd63c3 100644
--- a/polkadot/primitives/src/v7/async_backing.rs
+++ b/polkadot/primitives/src/v7/async_backing.rs
@@ -18,9 +18,9 @@
 
 use super::*;
 
-use parity_scale_codec::{Decode, Encode};
-use primitives::RuntimeDebug;
+use codec::{Decode, Encode};
 use scale_info::TypeInfo;
+use sp_core::RuntimeDebug;
 
 /// Candidate's acceptance limitations for asynchronous backing per relay parent.
 #[derive(
diff --git a/polkadot/primitives/src/v7/executor_params.rs b/polkadot/primitives/src/v7/executor_params.rs
index 918a7f17a7e3ba466bd8e06cb635cfbf2f9df839..e58cf3e76cc2c75137737c2a6e2b34685e1a78fd 100644
--- a/polkadot/primitives/src/v7/executor_params.rs
+++ b/polkadot/primitives/src/v7/executor_params.rs
@@ -22,7 +22,7 @@
 //! done in `polkadot-node-core-pvf`.
 
 use crate::{BlakeTwo256, HashT as _, PvfExecKind, PvfPrepKind};
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use polkadot_core_primitives::Hash;
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};
diff --git a/polkadot/primitives/src/v7/metrics.rs b/polkadot/primitives/src/v7/metrics.rs
index 97f7678e437371c47a9fc7d31a58e2c52196e492..1a29471c5450aa23ad00f8a41c54aca34ea7dbf4 100644
--- a/polkadot/primitives/src/v7/metrics.rs
+++ b/polkadot/primitives/src/v7/metrics.rs
@@ -16,7 +16,7 @@
 
 //! Runtime metric primitives.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use sp_std::prelude::*;
 
 /// Runtime metric operations.
diff --git a/polkadot/primitives/src/v7/mod.rs b/polkadot/primitives/src/v7/mod.rs
index 8a059408496c0f87e2d1394beb84263f48c4fbda..6b7985847a10699d36ef0f953cd5d2605c6beca0 100644
--- a/polkadot/primitives/src/v7/mod.rs
+++ b/polkadot/primitives/src/v7/mod.rs
@@ -17,7 +17,7 @@
 //! `V7` Primitives.
 
 use bitvec::{field::BitField, slice::BitSlice, vec::BitVec};
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_std::{
 	marker::PhantomData,
@@ -26,13 +26,13 @@ use sp_std::{
 	vec::IntoIter,
 };
 
-use application_crypto::KeyTypeId;
-use inherents::InherentIdentifier;
-use primitives::RuntimeDebug;
-use runtime_primitives::traits::{AppVerify, Header as HeaderT};
+use sp_application_crypto::KeyTypeId;
 use sp_arithmetic::traits::{BaseArithmetic, Saturating};
+use sp_core::RuntimeDebug;
+use sp_inherents::InherentIdentifier;
+use sp_runtime::traits::{AppVerify, Header as HeaderT};
 
-pub use runtime_primitives::traits::{BlakeTwo256, Hash as HashT};
+pub use sp_runtime::traits::{BlakeTwo256, Hash as HashT};
 
 // Export some core primitives.
 pub use polkadot_core_primitives::v2::{
@@ -77,7 +77,7 @@ pub const COLLATOR_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"coll");
 const LOG_TARGET: &str = "runtime::primitives";
 
 mod collator_app {
-	use application_crypto::{app_crypto, sr25519};
+	use sp_application_crypto::{app_crypto, sr25519};
 	app_crypto!(sr25519, super::COLLATOR_KEY_TYPE_ID);
 }
 
@@ -95,7 +95,7 @@ pub type CollatorSignature = collator_app::Signature;
 pub const PARACHAIN_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"para");
 
 mod validator_app {
-	use application_crypto::{app_crypto, sr25519};
+	use sp_application_crypto::{app_crypto, sr25519};
 	app_crypto!(sr25519, super::PARACHAIN_KEY_TYPE_ID);
 }
 
@@ -117,6 +117,34 @@ pub trait TypeIndex {
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Hash))]
 pub struct ValidatorIndex(pub u32);
 
+/// Index of an availability chunk.
+///
+/// The underlying type is identical to `ValidatorIndex`, because
+/// the number of chunks will always be equal to the number of validators.
+/// However, the chunk index held by a validator may not always be equal to its `ValidatorIndex`, so
+/// we use a separate type to make code easier to read.
+#[derive(Eq, Ord, PartialEq, PartialOrd, Copy, Clone, Encode, Decode, TypeInfo, RuntimeDebug)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Hash))]
+pub struct ChunkIndex(pub u32);
+
+impl From<ChunkIndex> for ValidatorIndex {
+	fn from(c_index: ChunkIndex) -> Self {
+		ValidatorIndex(c_index.0)
+	}
+}
+
+impl From<ValidatorIndex> for ChunkIndex {
+	fn from(v_index: ValidatorIndex) -> Self {
+		ChunkIndex(v_index.0)
+	}
+}
+
+impl From<u32> for ChunkIndex {
+	fn from(n: u32) -> Self {
+		ChunkIndex(n)
+	}
+}
+
 // We should really get https://github.com/paritytech/polkadot/issues/2403 going ..
 impl From<u32> for ValidatorIndex {
 	fn from(n: u32) -> Self {
@@ -130,7 +158,7 @@ impl TypeIndex for ValidatorIndex {
 	}
 }
 
-application_crypto::with_pair! {
+sp_application_crypto::with_pair! {
 	/// A Parachain validator keypair.
 	pub type ValidatorPair = validator_app::Pair;
 }
@@ -144,8 +172,8 @@ pub type ValidatorSignature = validator_app::Signature;
 /// A declarations of storage keys where an external observer can find some interesting data.
 pub mod well_known_keys {
 	use super::{HrmpChannelId, Id, WellKnownKey};
+	use codec::Encode as _;
 	use hex_literal::hex;
-	use parity_scale_codec::Encode as _;
 	use sp_io::hashing::twox_64;
 	use sp_std::prelude::*;
 
@@ -415,7 +443,7 @@ pub const LEGACY_MIN_BACKING_VOTES: u32 = 2;
 // The public key of a keypair used by a validator for determining assignments
 /// to approve included parachain candidates.
 mod assignment_app {
-	use application_crypto::{app_crypto, sr25519};
+	use sp_application_crypto::{app_crypto, sr25519};
 	app_crypto!(sr25519, super::ASSIGNMENT_KEY_TYPE_ID);
 }
 
@@ -423,7 +451,7 @@ mod assignment_app {
 /// to approve included parachain candidates.
 pub type AssignmentId = assignment_app::Public;
 
-application_crypto::with_pair! {
+sp_application_crypto::with_pair! {
 	/// The full keypair used by a validator for determining assignments to approve included
 	/// parachain candidates.
 	pub type AssignmentPair = assignment_app::Pair;
@@ -1333,7 +1361,7 @@ pub enum UpgradeGoAhead {
 }
 
 /// Consensus engine id for polkadot v1 consensus engine.
-pub const POLKADOT_ENGINE_ID: runtime_primitives::ConsensusEngineId = *b"POL1";
+pub const POLKADOT_ENGINE_ID: sp_runtime::ConsensusEngineId = *b"POL1";
 
 /// A consensus log item for polkadot validation. To be used with [`POLKADOT_ENGINE_ID`].
 #[derive(Decode, Encode, Clone, PartialEq, Eq)]
@@ -1363,18 +1391,18 @@ pub enum ConsensusLog {
 impl ConsensusLog {
 	/// Attempt to convert a reference to a generic digest item into a consensus log.
 	pub fn from_digest_item(
-		digest_item: &runtime_primitives::DigestItem,
-	) -> Result<Option<Self>, parity_scale_codec::Error> {
+		digest_item: &sp_runtime::DigestItem,
+	) -> Result<Option<Self>, codec::Error> {
 		match digest_item {
-			runtime_primitives::DigestItem::Consensus(id, encoded) if id == &POLKADOT_ENGINE_ID =>
+			sp_runtime::DigestItem::Consensus(id, encoded) if id == &POLKADOT_ENGINE_ID =>
 				Ok(Some(Self::decode(&mut &encoded[..])?)),
 			_ => Ok(None),
 		}
 	}
 }
 
-impl From<ConsensusLog> for runtime_primitives::DigestItem {
-	fn from(c: ConsensusLog) -> runtime_primitives::DigestItem {
+impl From<ConsensusLog> for sp_runtime::DigestItem {
+	fn from(c: ConsensusLog) -> sp_runtime::DigestItem {
 		Self::Consensus(POLKADOT_ENGINE_ID, c.encode())
 	}
 }
@@ -1724,25 +1752,23 @@ impl From<CompactStatement> for CompactStatementInner {
 	}
 }
 
-impl parity_scale_codec::Encode for CompactStatement {
+impl codec::Encode for CompactStatement {
 	fn size_hint(&self) -> usize {
 		// magic + discriminant + payload
 		4 + 1 + 32
 	}
 
-	fn encode_to<T: parity_scale_codec::Output + ?Sized>(&self, dest: &mut T) {
+	fn encode_to<T: codec::Output + ?Sized>(&self, dest: &mut T) {
 		dest.write(&BACKING_STATEMENT_MAGIC);
 		CompactStatementInner::from(self.clone()).encode_to(dest)
 	}
 }
 
-impl parity_scale_codec::Decode for CompactStatement {
-	fn decode<I: parity_scale_codec::Input>(
-		input: &mut I,
-	) -> Result<Self, parity_scale_codec::Error> {
+impl codec::Decode for CompactStatement {
+	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
 		let maybe_magic = <[u8; 4]>::decode(input)?;
 		if maybe_magic != BACKING_STATEMENT_MAGIC {
-			return Err(parity_scale_codec::Error::from("invalid magic string"))
+			return Err(codec::Error::from("invalid magic string"))
 		}
 
 		Ok(match CompactStatementInner::decode(input)? {
@@ -1787,6 +1813,14 @@ where
 		self.0.get(index.type_index())
 	}
 
+	/// Returns a mutable reference to an element indexed using `K`.
+	pub fn get_mut(&mut self, index: K) -> Option<&mut V>
+	where
+		K: TypeIndex,
+	{
+		self.0.get_mut(index.type_index())
+	}
+
 	/// Returns number of elements in vector.
 	pub fn len(&self) -> usize {
 		self.0.len()
@@ -1951,7 +1985,7 @@ impl<T: Decode> WellKnownKey<T> {
 	/// Gets the value or `None` if it does not exist or decoding failed.
 	pub fn get(&self) -> Option<T> {
 		sp_io::storage::get(&self.key)
-			.and_then(|raw| parity_scale_codec::DecodeAll::decode_all(&mut raw.as_ref()).ok())
+			.and_then(|raw| codec::DecodeAll::decode_all(&mut raw.as_ref()).ok())
 	}
 }
 
@@ -1989,6 +2023,7 @@ pub mod node_features {
 	/// A feature index used to identify a bit into the node_features array stored
 	/// in the HostConfiguration.
 	#[repr(u8)]
+	#[derive(Clone, Copy)]
 	pub enum FeatureIndex {
 		/// Tells if tranch0 assignments could be sent in a single certificate.
 		/// Reserved for: `<https://github.com/paritytech/polkadot-sdk/issues/628>`
@@ -1997,10 +2032,16 @@ pub mod node_features {
 		/// The value stored there represents the assumed core index where the candidates
 		/// are backed. This is needed for the elastic scaling MVP.
 		ElasticScalingMVP = 1,
+		/// Tells if the chunk mapping feature is enabled.
+		/// Enables the implementation of
+		/// [RFC-47](https://github.com/polkadot-fellows/RFCs/blob/main/text/0047-assignment-of-availability-chunks.md).
+		/// Must not be enabled unless all validators and collators have stopped using `req_chunk`
+		/// protocol version 1. If it is enabled, validators can start systematic chunk recovery.
+		AvailabilityChunkMapping = 2,
 		/// First unassigned feature bit.
 		/// Every time a new feature flag is assigned it should take this value.
 		/// and this should be incremented.
-		FirstUnassigned = 2,
+		FirstUnassigned = 3,
 	}
 }
 
@@ -2008,7 +2049,7 @@ pub mod node_features {
 mod tests {
 	use super::*;
 	use bitvec::bitvec;
-	use primitives::sr25519;
+	use sp_core::sr25519;
 
 	pub fn dummy_committed_candidate_receipt() -> CommittedCandidateReceipt {
 		let zeros = Hash::zero();
diff --git a/polkadot/primitives/src/v7/signed.rs b/polkadot/primitives/src/v7/signed.rs
index 96646d54cbbafbd9c1223a4fe43c5d48d70afaf9..62e4df2385038f02247ce41fc87a1f4243c73970 100644
--- a/polkadot/primitives/src/v7/signed.rs
+++ b/polkadot/primitives/src/v7/signed.rs
@@ -14,17 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 
 #[cfg(feature = "std")]
-use application_crypto::AppCrypto;
+use sp_application_crypto::AppCrypto;
 #[cfg(feature = "std")]
 use sp_keystore::{Error as KeystoreError, KeystorePtr};
 use sp_std::prelude::Vec;
 
-use primitives::RuntimeDebug;
-use runtime_primitives::traits::AppVerify;
+use sp_core::RuntimeDebug;
+use sp_runtime::traits::AppVerify;
 
 use super::{SigningContext, ValidatorId, ValidatorIndex, ValidatorSignature};
 
@@ -312,7 +312,7 @@ impl<Payload: EncodeAs<RealPayload>, RealPayload: Encode> UncheckedSigned<Payloa
 		context: &SigningContext<H>,
 		validator_index: ValidatorIndex,
 	) -> Self {
-		use application_crypto::RuntimeAppPublic;
+		use sp_application_crypto::RuntimeAppPublic;
 		let data = Self::payload_data(&payload, context);
 		let signature = public.sign(&data).unwrap();
 
@@ -343,7 +343,7 @@ impl<Payload, RealPayload> From<Signed<Payload, RealPayload>>
 /// This helper trait ensures that we can encode `Statement` as `CompactStatement`,
 /// and anything as itself.
 ///
-/// This resembles `parity_scale_codec::EncodeLike`, but it's distinct:
+/// This resembles `codec::EncodeLike`, but it's distinct:
 /// `EncodeLike` is a marker trait which asserts at the typesystem level that
 /// one type's encoding is a valid encoding for another type. It doesn't
 /// perform any type conversion when encoding.
diff --git a/polkadot/primitives/src/v7/slashing.rs b/polkadot/primitives/src/v7/slashing.rs
index bcd7d0c2fc4455e2ebf01fab027dbf0618f63dba..ea06e960b5bc533e449e4f2460856227738dbc40 100644
--- a/polkadot/primitives/src/v7/slashing.rs
+++ b/polkadot/primitives/src/v7/slashing.rs
@@ -17,7 +17,7 @@
 //! Primitives types used for dispute slashing.
 
 use crate::{CandidateHash, SessionIndex, ValidatorId, ValidatorIndex};
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_std::{collections::btree_map::BTreeMap, vec::Vec};
 
diff --git a/polkadot/primitives/src/vstaging/mod.rs b/polkadot/primitives/src/vstaging/mod.rs
index 1af73993f640cb8d28bc5145ffb797ab0619d16c..fecad783f7cbc7f2ea6bf6217d519b0a5abbcf11 100644
--- a/polkadot/primitives/src/vstaging/mod.rs
+++ b/polkadot/primitives/src/vstaging/mod.rs
@@ -20,10 +20,10 @@
 use crate::v7::*;
 use sp_std::prelude::*;
 
-use parity_scale_codec::{Decode, Encode};
-use primitives::RuntimeDebug;
+use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_arithmetic::Perbill;
+use sp_core::RuntimeDebug;
 
 /// Scheduler configuration parameters. All coretime/ondemand parameters are here.
 #[derive(
diff --git a/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md b/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md
index 345b3d2e6970403f3096272cc51f903e0566a22e..9b4082c49e2f003f0b7d0fd317bc2e8ce06580e4 100644
--- a/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md
+++ b/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md
@@ -396,7 +396,7 @@ On receiving an `ApprovedAncestor(Hash, BlockNumber, response_channel)`:
 * Requires `(SessionIndex, SessionInfo, CandidateReceipt, ValidatorIndex, backing_group, block_hash, candidate_index)`
 * Extract the public key of the `ValidatorIndex` from the `SessionInfo` for the session.
 * Issue an `AvailabilityRecoveryMessage::RecoverAvailableData(candidate, session_index, Some(backing_group),
-  response_sender)`
+Some(core_index), response_sender)`
 * Load the historical validation code of the parachain by dispatching a
   `RuntimeApiRequest::ValidationCodeByHash(descriptor.validation_code_hash)` against the state of `block_hash`.
 * Spawn a background task with a clone of `background_tx`
diff --git a/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md b/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md
index c57c4589244e79f6cd54a87f823abc466ed8eb43..5b756080becc05b4804138e64baeac3bfdaf97b8 100644
--- a/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md
+++ b/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md
@@ -1,84 +1,108 @@
 # Availability Recovery
 
-This subsystem is the inverse of the [Availability Distribution](availability-distribution.md) subsystem: validators
-will serve the availability chunks kept in the availability store to nodes who connect to them. And the subsystem will
-also implement the other side: the logic for nodes to connect to validators, request availability pieces, and
-reconstruct the `AvailableData`.
+This subsystem is responsible for recovering the data made available via the
+[Availability Distribution](availability-distribution.md) subsystem, neccessary for candidate validation during the
+approval/disputes processes. Additionally, it is also being used by collators to recover PoVs in adversarial scenarios
+where the other collators of the para are censoring blocks.
 
-This version of the availability recovery subsystem is based off of direct connections to validators. In order to
-recover any given `AvailableData`, we must recover at least `f + 1` pieces from validators of the session. Thus, we will
-connect to and query randomly chosen validators until we have received `f + 1` pieces.
+According to the Polkadot protocol, in order to recover any given `AvailableData`, we generally must recover at least
+`f + 1` pieces from validators of the session. Thus, we should connect to and query randomly chosen validators until we
+have received `f + 1` pieces.
+
+In practice, there are various optimisations implemented in this subsystem which avoid querying all chunks from
+different validators and/or avoid doing the chunk reconstruction altogether.
 
 ## Protocol
 
-`PeerSet`: `Validation`
+This version of the availability recovery subsystem is based only on request-response network protocols.
 
 Input:
 
-* `NetworkBridgeUpdate(update)`
-* `AvailabilityRecoveryMessage::RecoverAvailableData(candidate, session, backing_group, response)`
+* `AvailabilityRecoveryMessage::RecoverAvailableData(candidate, session, backing_group, core_index, response)`
 
 Output:
 
-* `NetworkBridge::SendValidationMessage`
-* `NetworkBridge::ReportPeer`
-* `AvailabilityStore::QueryChunk`
+* `NetworkBridgeMessage::SendRequests`
+* `AvailabilityStoreMessage::QueryAllChunks`
+* `AvailabilityStoreMessage::QueryAvailableData`
+* `AvailabilityStoreMessage::QueryChunkSize`
+
 
 ## Functionality
 
-We hold a state which tracks the currently ongoing recovery tasks, as well as which request IDs correspond to which
-task. A recovery task is a structure encapsulating all recovery tasks with the network necessary to recover the
-available data in respect to one candidate.
+We hold a state which tracks the currently ongoing recovery tasks. A `RecoveryTask` is a structure encapsulating all
+network tasks needed in order to recover the available data in respect to a candidate.
+
+Each `RecoveryTask` has a collection of ordered recovery strategies to try.
 
 ```rust
+/// Subsystem state.
 struct State {
-    /// Each recovery is implemented as an independent async task, and the handles only supply information about the result.
-    ongoing_recoveries: FuturesUnordered<RecoveryHandle>,
-    /// A recent block hash for which state should be available.
-    live_block_hash: Hash,
-    // An LRU cache of recently recovered data.
-    availability_lru: LruMap<CandidateHash, Result<AvailableData, RecoveryError>>,
+  /// Each recovery task is implemented as its own async task,
+  /// and these handles are for communicating with them.
+  ongoing_recoveries: FuturesUnordered<RecoveryHandle>,
+  /// A recent block hash for which state should be available.
+  live_block: (BlockNumber, Hash),
+  /// An LRU cache of recently recovered data.
+  availability_lru: LruMap<CandidateHash, CachedRecovery>,
+  /// Cached runtime info.
+  runtime_info: RuntimeInfo,
 }
 
-/// This is a future, which concludes either when a response is received from the recovery tasks,
-/// or all the `awaiting` channels have closed.
-struct RecoveryHandle {
-    candidate_hash: CandidateHash,
-    interaction_response: RemoteHandle<Concluded>,
-    awaiting: Vec<ResponseChannel<Result<AvailableData, RecoveryError>>>,
-}
-
-struct Unavailable;
-struct Concluded(CandidateHash, Result<AvailableData, RecoveryError>);
-
-struct RecoveryTaskParams {
-    validator_authority_keys: Vec<AuthorityId>,
-    validators: Vec<ValidatorId>,
-    // The number of pieces needed.
-    threshold: usize,
-    candidate_hash: Hash,
-    erasure_root: Hash,
+struct RecoveryParams {
+  /// Discovery ids of `validators`.
+  pub validator_authority_keys: Vec<AuthorityDiscoveryId>,
+  /// Number of validators.
+  pub n_validators: usize,
+  /// The number of regular chunks needed.
+  pub threshold: usize,
+  /// The number of systematic chunks needed.
+  pub systematic_threshold: usize,
+  /// A hash of the relevant candidate.
+  pub candidate_hash: CandidateHash,
+  /// The root of the erasure encoding of the candidate.
+  pub erasure_root: Hash,
+  /// Metrics to report.
+  pub metrics: Metrics,
+  /// Do not request data from availability-store. Useful for collators.
+  pub bypass_availability_store: bool,
+  /// The type of check to perform after available data was recovered.
+  pub post_recovery_check: PostRecoveryCheck,
+  /// The blake2-256 hash of the PoV.
+  pub pov_hash: Hash,
+  /// Protocol name for ChunkFetchingV1.
+  pub req_v1_protocol_name: ProtocolName,
+  /// Protocol name for ChunkFetchingV2.
+  pub req_v2_protocol_name: ProtocolName,
+  /// Whether or not chunk mapping is enabled.
+  pub chunk_mapping_enabled: bool,
+  /// Channel to the erasure task handler.
+	pub erasure_task_tx: mpsc::Sender<ErasureTask>,
 }
 
-enum RecoveryTask {
-    RequestFromBackers {
-        // a random shuffling of the validators from the backing group which indicates the order
-        // in which we connect to them and request the chunk.
-        shuffled_backers: Vec<ValidatorIndex>,
-    }
-    RequestChunksFromValidators {
-        // a random shuffling of the validators which indicates the order in which we connect to the validators and
-        // request the chunk from them.
-        shuffling: Vec<ValidatorIndex>,
-        received_chunks: Map<ValidatorIndex, ErasureChunk>,
-        requesting_chunks: FuturesUnordered<Receiver<ErasureChunkRequestResponse>>,
-    }
+pub struct RecoveryTask<Sender: overseer::AvailabilityRecoverySenderTrait> {
+	sender: Sender,
+	params: RecoveryParams,
+	strategies: VecDeque<Box<dyn RecoveryStrategy<Sender>>>,
+	state: task::State,
 }
 
-struct RecoveryTask {
-    to_subsystems: SubsystemSender,
-    params: RecoveryTaskParams,
-    source: Source,
+#[async_trait::async_trait]
+/// Common trait for runnable recovery strategies.
+pub trait RecoveryStrategy<Sender: overseer::AvailabilityRecoverySenderTrait>: Send {
+	/// Main entry point of the strategy.
+	async fn run(
+		mut self: Box<Self>,
+		state: &mut task::State,
+		sender: &mut Sender,
+		common_params: &RecoveryParams,
+	) -> Result<AvailableData, RecoveryError>;
+
+	/// Return the name of the strategy for logging purposes.
+	fn display_name(&self) -> &'static str;
+
+	/// Return the strategy type for use as a metric label.
+	fn strategy_type(&self) -> &'static str;
 }
 ```
 
@@ -90,68 +114,71 @@ Ignore `BlockFinalized` signals.
 
 On `Conclude`, shut down the subsystem.
 
-#### `AvailabilityRecoveryMessage::RecoverAvailableData(receipt, session, Option<backing_group_index>, response)`
+#### `AvailabilityRecoveryMessage::RecoverAvailableData(...)`
 
-1. Check the `availability_lru` for the candidate and return the data if so.
-1. Check if there is already an recovery handle for the request. If so, add the response handle to it.
+1. Check the `availability_lru` for the candidate and return the data if present.
+1. Check if there is already a recovery handle for the request. If so, add the response handle to it.
 1. Otherwise, load the session info for the given session under the state of `live_block_hash`, and initiate a recovery
-   task with *`launch_recovery_task`*. Add a recovery handle to the state and add the response channel to it.
+   task with `launch_recovery_task`. Add a recovery handle to the state and add the response channel to it.
 1. If the session info is not available, return `RecoveryError::Unavailable` on the response channel.
 
 ### Recovery logic
 
-#### `launch_recovery_task(session_index, session_info, candidate_receipt, candidate_hash, Option<backing_group_index>)`
+#### `handle_recover(...) -> Result<()>`
 
-1. Compute the threshold from the session info. It should be `f + 1`, where `n = 3f + k`, where `k in {1, 2, 3}`, and
-   `n` is the number of validators.
-1. Set the various fields of `RecoveryParams` based on the validator lists in `session_info` and information about the
-   candidate.
-1. If the `backing_group_index` is `Some`, start in the `RequestFromBackers` phase with a shuffling of the backing group
-   validator indices and a `None` requesting value.
-1. Otherwise, start in the `RequestChunksFromValidators` source with `received_chunks`,`requesting_chunks`, and
-   `next_shuffling` all empty.
-1. Set the `to_subsystems` sender to be equal to a clone of the `SubsystemContext`'s sender.
-1. Initialize `received_chunks` to an empty set, as well as `requesting_chunks`.
+Instantiate the appropriate `RecoveryStrategy`es, based on the subsystem configuration, params and session info.
+Call `launch_recovery_task()`.
 
-Launch the source as a background task running `run(recovery_task)`.
+#### `launch_recovery_task(state, ctx, response_sender, recovery_strategies, params) -> Result<()>`
 
-#### `run(recovery_task) -> Result<AvailableData, RecoveryError>`
+Create the `RecoveryTask` and launch it as a background task running `recovery_task.run()`.
 
-```rust
-// How many parallel requests to have going at once.
-const N_PARALLEL: usize = 50;
-```
+#### `recovery_task.run(mut self) -> Result<AvailableData, RecoveryError>`
+
+* Loop:
+  * Pop a strategy from the queue. If none are left, return `RecoveryError::Unavailable`.
+  * Run the strategy.
+  * If the strategy returned successfully or returned `RecoveryError::Invalid`, break the loop.
+
+### Recovery strategies
+
+#### `FetchFull`
+
+This strategy tries requesting the full available data from the validators in the backing group to
+which the node is already connected. They are tried one by one in a random order.
+It is very performant if there's enough network bandwidth and the backing group is not overloaded.
+The costly reed-solomon reconstruction is not needed.
+
+#### `FetchSystematicChunks`
+
+Very similar to `FetchChunks` below but requests from the validators that hold the systematic chunks, so that we avoid
+reed-solomon reconstruction. Only possible if `node_features::FeatureIndex::AvailabilityChunkMapping` is enabled and
+the `core_index` is supplied (currently only for recoveries triggered by approval voting).
+
+More info in
+[RFC-47](https://github.com/polkadot-fellows/RFCs/blob/main/text/0047-assignment-of-availability-chunks.md).
+
+#### `FetchChunks`
+
+The least performant strategy but also the most comprehensive one. It's the only one that cannot fail under the
+byzantine threshold assumption, so it's always added as the last one in the `recovery_strategies` queue.
+
+Performs parallel chunk requests to validators. When enough chunks were received, do the reconstruction.
+In the worst case, all validators will be tried.
+
+### Default recovery strategy configuration
+
+#### For validators
+
+If the estimated available data size is smaller than a configured constant (currently 1Mib for Polkadot or 4Mib for
+other networks), try doing `FetchFull` first.
+Next, if the preconditions described in `FetchSystematicChunks` above are met, try systematic recovery.
+As a last resort, do `FetchChunks`.
+
+#### For collators
+
+Collators currently only use `FetchChunks`, as they only attempt recoveries in rare scenarios.
 
-* Request `AvailabilityStoreMessage::QueryAvailableData`. If it exists, return that.
-* If the task contains `RequestFromBackers`
-  * Loop:
-    * If the `requesting_pov` is `Some`, poll for updates on it. If it concludes, set `requesting_pov` to `None`.
-    * If the `requesting_pov` is `None`, take the next backer off the `shuffled_backers`.
-        * If the backer is `Some`, issue a `NetworkBridgeMessage::Requests` with a network request for the
-          `AvailableData` and wait for the response.
-        * If it concludes with a `None` result, return to beginning.
-        * If it concludes with available data, attempt a re-encoding.
-            * If it has the correct erasure-root, break and issue a `Ok(available_data)`.
-            * If it has an incorrect erasure-root, return to beginning.
-        * Send the result to each member of `awaiting`.
-        * If the backer is `None`, set the source to `RequestChunksFromValidators` with a random shuffling of validators
-          and empty `received_chunks`, and `requesting_chunks` and break the loop.
-
-* If the task contains `RequestChunksFromValidators`:
-  * Request `AvailabilityStoreMessage::QueryAllChunks`. For each chunk that exists, add it to `received_chunks` and
-    remote the validator from `shuffling`.
-  * Loop:
-    * If `received_chunks + requesting_chunks + shuffling` lengths are less than the threshold, break and return
-      `Err(Unavailable)`.
-    * Poll for new updates from `requesting_chunks`. Check merkle proofs of any received chunks. If the request simply
-      fails due to network issues, insert into the front of `shuffling` to be retried.
-    * If `received_chunks` has more than `threshold` entries, attempt to recover the data.
-      * If that fails, return `Err(RecoveryError::Invalid)`
-      * If correct:
-        * If re-encoding produces an incorrect erasure-root, break and issue a `Err(RecoveryError::Invalid)`.
-        * break and issue `Ok(available_data)`
-    * Send the result to each member of `awaiting`.
-    * While there are fewer than `N_PARALLEL` entries in `requesting_chunks`,
-      * Pop the next item from `shuffling`. If it's empty and `requesting_chunks` is empty, return
-        `Err(RecoveryError::Unavailable)`.
-      * Issue a `NetworkBridgeMessage::Requests` and wait for the response in `requesting_chunks`.
+Moreover, the recovery task is specially configured to not attempt requesting data from the local availability-store
+(because it doesn't exist) and to not reencode the data after a succcessful recovery (because it's an expensive check
+that is not needed; checking the pov_hash is enough for collators).
diff --git a/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md b/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md
index e5eb9bd7642c1108c45e73134a00ee22b2f6475c..ce2ff3ca9139dc67ffd8aafa613a5fbde9f40448 100644
--- a/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md
+++ b/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md
@@ -130,23 +130,9 @@ accept statements from it. Filtering out of statements from disabled validators
 on the node side is purely an optimization, as it will be done in the runtime
 as well.
 
-Because we use the state of the active leaves to
-check whether a validator is disabled instead of the relay parent, the notion
-of being disabled is inherently racy:
-- the responder has learned about the disabled validator before the requester
-- the receiver has witnessed the disabled validator after sending the request
-
-We could have sent a manifest to a peer, then received information about
-disabling, and then receive a request. This can break an invariant of the grid
-mode:
-- the response is required to indicate quorum
-
-Due to the above, there should be no response at all for grid requests when
-the backing threshold is no longer met as a result of disabled validators.
-In addition to that, we add disabled validators to the request's unwanted
-mask. This ensures that the sender will not send statements from disabled
-validators (at least from the perspective of the receiver at the moment of the
-request). This doesn't fully avoid race conditions, but tries to minimize them.
+We use the state of the relay parent to check whether a validator is disabled
+to avoid race conditions and ensure that disabling works well in the presense
+of re-enabling.
 
 ## Messages
 
@@ -211,9 +197,9 @@ We also have a request/response protocol because validators do not eagerly send
    - Requests are queued up with `RequestManager::get_or_insert`.
      - Done as needed, when handling incoming manifests/statements.
    - `RequestManager::dispatch_requests` sends any queued-up requests.
-      - Calls `RequestManager::next_request` to completion.
-        - Creates the `OutgoingRequest`, saves the receiver in `RequestManager::pending_responses`.
-      - Does nothing if we have more responses pending than the limit of parallel requests.
+     - Calls `RequestManager::next_request` to completion.
+       - Creates the `OutgoingRequest`, saves the receiver in `RequestManager::pending_responses`.
+     - Does nothing if we have more responses pending than the limit of parallel requests.
 
 2. Peer
 
diff --git a/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md b/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md
index 083ed2b6feac9ed6d27c44bc2267744dd49fffd1..be1e71666ad20626711e23f828820155746cbb68 100644
--- a/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md
+++ b/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md
@@ -1,7 +1,7 @@
 # Scheduler Pallet
 
 > TODO: this section is still heavily under construction. key questions about availability cores and validator
-> assignment are still open and the flow of the the section may be contradictory or inconsistent
+> assignment are still open and the flow of the section may be contradictory or inconsistent
 
 The Scheduler module is responsible for two main tasks:
 
diff --git a/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md b/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md
index e011afb97089aaf59d685b8d4bf9998d21390146..c82d89d2d8799eff6a68b49bdb01ee15bbe43d84 100644
--- a/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md
+++ b/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md
@@ -238,6 +238,9 @@ enum AvailabilityRecoveryMessage {
         CandidateReceipt,
         SessionIndex,
         Option<GroupIndex>, // Backing validator group to request the data directly from.
+        Option<CoreIndex>, /* A `CoreIndex` needs to be specified for the recovery process to
+		                    * prefer systematic chunk recovery. This is the core that the candidate
+                            * was occupying while pending availability. */
         ResponseChannel<Result<AvailableData, RecoveryError>>,
     ),
 }
diff --git a/polkadot/rpc/Cargo.toml b/polkadot/rpc/Cargo.toml
index 5af5e63b175380f7e695deb973ea48df52c326e4..cceb4dc5a93b3f9ccf643572e1ba32b38aa5a853 100644
--- a/polkadot/rpc/Cargo.toml
+++ b/polkadot/rpc/Cargo.toml
@@ -17,8 +17,10 @@ sp-blockchain = { path = "../../substrate/primitives/blockchain" }
 sp-keystore = { path = "../../substrate/primitives/keystore" }
 sp-runtime = { path = "../../substrate/primitives/runtime" }
 sp-api = { path = "../../substrate/primitives/api" }
+sp-application-crypto = { path = "../../substrate/primitives/application-crypto" }
 sp-consensus = { path = "../../substrate/primitives/consensus/common" }
 sp-consensus-babe = { path = "../../substrate/primitives/consensus/babe" }
+sp-consensus-beefy = { path = "../../substrate/primitives/consensus/beefy" }
 sc-chain-spec = { path = "../../substrate/client/chain-spec" }
 sc-rpc = { path = "../../substrate/client/rpc" }
 sc-rpc-spec-v2 = { path = "../../substrate/client/rpc-spec-v2" }
@@ -30,8 +32,8 @@ sc-consensus-epochs = { path = "../../substrate/client/consensus/epochs" }
 sc-consensus-grandpa = { path = "../../substrate/client/consensus/grandpa" }
 sc-consensus-grandpa-rpc = { path = "../../substrate/client/consensus/grandpa/rpc" }
 sc-sync-state-rpc = { path = "../../substrate/client/sync-state-rpc" }
-txpool-api = { package = "sc-transaction-pool-api", path = "../../substrate/client/transaction-pool/api" }
-frame-rpc-system = { package = "substrate-frame-rpc-system", path = "../../substrate/utils/frame/rpc/system" }
+sc-transaction-pool-api = { path = "../../substrate/client/transaction-pool/api" }
+substrate-frame-rpc-system = { path = "../../substrate/utils/frame/rpc/system" }
 mmr-rpc = { path = "../../substrate/client/merkle-mountain-range/rpc" }
 pallet-transaction-payment-rpc = { path = "../../substrate/frame/transaction-payment/rpc" }
 sp-block-builder = { path = "../../substrate/primitives/block-builder" }
diff --git a/polkadot/rpc/src/lib.rs b/polkadot/rpc/src/lib.rs
index 4455efd3b5337be85fb975f368af9475b20b0b89..7d678ada5ff5d5da0b383765891bdaf44f65cd46 100644
--- a/polkadot/rpc/src/lib.rs
+++ b/polkadot/rpc/src/lib.rs
@@ -28,13 +28,15 @@ use sc_consensus_beefy::communication::notification::{
 };
 use sc_consensus_grandpa::FinalityProofProvider;
 pub use sc_rpc::{DenyUnsafe, SubscriptionTaskExecutor};
+use sc_transaction_pool_api::TransactionPool;
 use sp_api::ProvideRuntimeApi;
+use sp_application_crypto::RuntimeAppPublic;
 use sp_block_builder::BlockBuilder;
 use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 use sp_consensus::SelectChain;
 use sp_consensus_babe::BabeApi;
+use sp_consensus_beefy::AuthorityIdBound;
 use sp_keystore::KeystorePtr;
-use txpool_api::TransactionPool;
 
 /// A type representing all RPC extensions.
 pub type RpcExtension = RpcModule<()>;
@@ -62,9 +64,9 @@ pub struct GrandpaDeps<B> {
 }
 
 /// Dependencies for BEEFY
-pub struct BeefyDeps {
+pub struct BeefyDeps<AuthorityId: AuthorityIdBound> {
 	/// Receives notifications about finality proof events from BEEFY.
-	pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream<Block>,
+	pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream<Block, AuthorityId>,
 	/// Receives notifications about best block events from BEEFY.
 	pub beefy_best_block_stream: BeefyBestBlockStream<Block>,
 	/// Executor to drive the subscription manager in the BEEFY RPC handler.
@@ -72,7 +74,7 @@ pub struct BeefyDeps {
 }
 
 /// Full client dependencies
-pub struct FullDeps<C, P, SC, B> {
+pub struct FullDeps<C, P, SC, B, AuthorityId: AuthorityIdBound> {
 	/// The client instance to use.
 	pub client: Arc<C>,
 	/// Transaction pool instance.
@@ -88,14 +90,14 @@ pub struct FullDeps<C, P, SC, B> {
 	/// GRANDPA specific dependencies.
 	pub grandpa: GrandpaDeps<B>,
 	/// BEEFY specific dependencies.
-	pub beefy: BeefyDeps,
+	pub beefy: BeefyDeps<AuthorityId>,
 	/// Backend used by the node.
 	pub backend: Arc<B>,
 }
 
 /// Instantiate all RPC extensions.
-pub fn create_full<C, P, SC, B>(
-	FullDeps { client, pool, select_chain, chain_spec, deny_unsafe, babe, grandpa, beefy, backend } : FullDeps<C, P, SC, B>,
+pub fn create_full<C, P, SC, B, AuthorityId>(
+	FullDeps { client, pool, select_chain, chain_spec, deny_unsafe, babe, grandpa, beefy, backend } : FullDeps<C, P, SC, B, AuthorityId>,
 ) -> Result<RpcExtension, Box<dyn std::error::Error + Send + Sync>>
 where
 	C: ProvideRuntimeApi<Block>
@@ -105,7 +107,7 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	C::Api: frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
+	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
 	C::Api: mmr_rpc::MmrRuntimeApi<Block, <Block as sp_runtime::traits::Block>::Hash, BlockNumber>,
 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
 	C::Api: BabeApi<Block>,
@@ -114,8 +116,9 @@ where
 	SC: SelectChain<Block> + 'static,
 	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
 	B::State: sc_client_api::StateBackend<sp_runtime::traits::HashingFor<Block>>,
+	AuthorityId: AuthorityIdBound,
+	<AuthorityId as RuntimeAppPublic>::Signature: Send + Sync,
 {
-	use frame_rpc_system::{System, SystemApiServer};
 	use mmr_rpc::{Mmr, MmrApiServer};
 	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
 	use sc_consensus_babe_rpc::{Babe, BabeApiServer};
@@ -123,6 +126,7 @@ where
 	use sc_consensus_grandpa_rpc::{Grandpa, GrandpaApiServer};
 	use sc_rpc_spec_v2::chain_spec::{ChainSpec, ChainSpecApiServer};
 	use sc_sync_state_rpc::{SyncState, SyncStateApiServer};
+	use substrate_frame_rpc_system::{System, SystemApiServer};
 	use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer};
 
 	let mut io = RpcModule::new(());
@@ -171,7 +175,7 @@ where
 	)?;
 
 	io.merge(
-		Beefy::<Block>::new(
+		Beefy::<Block, AuthorityId>::new(
 			beefy.beefy_finality_proof_stream,
 			beefy.beefy_best_block_stream,
 			beefy.subscription_executor,
diff --git a/polkadot/runtime/common/Cargo.toml b/polkadot/runtime/common/Cargo.toml
index 3a64148817682096d409e9ea1c4e38a39b44d7b7..da89bd2251acff0d0c76b49908109a1ff662846c 100644
--- a/polkadot/runtime/common/Cargo.toml
+++ b/polkadot/runtime/common/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 [dependencies]
 impl-trait-for-tuples = "0.2.2"
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 log = { workspace = true }
 rustc-hex = { version = "2.1.0", default-features = false }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
@@ -21,7 +21,7 @@ serde_derive = { workspace = true }
 static_assertions = "1.1.0"
 
 sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false }
+sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false }
 sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false }
 sp-io = { path = "../../../substrate/primitives/io", default-features = false }
 sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false, features = ["serde"] }
@@ -51,9 +51,9 @@ frame-election-provider-support = { path = "../../../substrate/frame/election-pr
 frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true }
 pallet-babe = { path = "../../../substrate/frame/babe", default-features = false, optional = true }
 
-primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false }
+polkadot-primitives = { path = "../../primitives", default-features = false }
 libsecp256k1 = { version = "0.7.0", default-features = false }
-runtime-parachains = { package = "polkadot-runtime-parachains", path = "../parachains", default-features = false }
+polkadot-runtime-parachains = { path = "../parachains", default-features = false }
 
 slot-range-helper = { path = "slot_range_helper", default-features = false }
 xcm = { package = "staging-xcm", path = "../../xcm", default-features = false }
@@ -69,18 +69,18 @@ sp-keystore = { path = "../../../substrate/primitives/keystore" }
 sp-keyring = { path = "../../../substrate/primitives/keyring" }
 serde_json = { workspace = true, default-features = true }
 libsecp256k1 = "0.7.0"
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" }
 
 [features]
 default = ["std"]
 no_std = []
 std = [
 	"bitvec/std",
+	"codec/std",
 	"frame-benchmarking?/std",
 	"frame-election-provider-support/std",
 	"frame-support/std",
 	"frame-system/std",
-	"inherents/std",
 	"libsecp256k1/std",
 	"log/std",
 	"pallet-asset-rate?/std",
@@ -97,15 +97,15 @@ std = [
 	"pallet-transaction-payment/std",
 	"pallet-treasury/std",
 	"pallet-vesting/std",
-	"parity-scale-codec/std",
-	"primitives/std",
-	"runtime-parachains/std",
+	"polkadot-primitives/std",
+	"polkadot-runtime-parachains/std",
 	"rustc-hex/std",
 	"scale-info/std",
 	"serde/std",
 	"slot-range-helper/std",
 	"sp-api/std",
 	"sp-core/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-npos-elections/std",
 	"sp-runtime/std",
@@ -134,8 +134,8 @@ runtime-benchmarks = [
 	"pallet-timestamp/runtime-benchmarks",
 	"pallet-treasury/runtime-benchmarks",
 	"pallet-vesting/runtime-benchmarks",
-	"primitives/runtime-benchmarks",
-	"runtime-parachains/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
+	"polkadot-runtime-parachains/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
@@ -160,6 +160,6 @@ try-runtime = [
 	"pallet-transaction-payment/try-runtime",
 	"pallet-treasury/try-runtime",
 	"pallet-vesting/try-runtime",
-	"runtime-parachains/try-runtime",
+	"polkadot-runtime-parachains/try-runtime",
 	"sp-runtime/try-runtime",
 ]
diff --git a/polkadot/runtime/common/slot_range_helper/Cargo.toml b/polkadot/runtime/common/slot_range_helper/Cargo.toml
index 314e101ad221e9e842eb609a0ca6d80d8c8c52ad..47e8fea240025c02c2e6efa81ebbe54f7e3da115 100644
--- a/polkadot/runtime/common/slot_range_helper/Cargo.toml
+++ b/polkadot/runtime/common/slot_range_helper/Cargo.toml
@@ -12,10 +12,10 @@ workspace = true
 [dependencies]
 paste = "1.0"
 enumn = "0.1.12"
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sp-std = { package = "sp-std", path = "../../../../substrate/primitives/std", default-features = false }
 sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false }
 
 [features]
 default = ["std"]
-std = ["parity-scale-codec/std", "sp-runtime/std", "sp-std/std"]
+std = ["codec/std", "sp-runtime/std", "sp-std/std"]
diff --git a/polkadot/runtime/common/slot_range_helper/src/lib.rs b/polkadot/runtime/common/slot_range_helper/src/lib.rs
index bbe5b61ae1f3af6fd4a316ed4202942ba52e3264..f907390bc91b558d49f6aa29714fa5f90b1672ca 100644
--- a/polkadot/runtime/common/slot_range_helper/src/lib.rs
+++ b/polkadot/runtime/common/slot_range_helper/src/lib.rs
@@ -18,8 +18,8 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+pub use codec::{Decode, Encode};
 pub use enumn::N;
-pub use parity_scale_codec::{Decode, Encode};
 pub use paste;
 pub use sp_runtime::traits::CheckedSub;
 pub use sp_std::{ops::Add, result};
diff --git a/polkadot/runtime/common/src/assigned_slots/benchmarking.rs b/polkadot/runtime/common/src/assigned_slots/benchmarking.rs
index 61638fe6cabfce76d4323e65a1983e18fae22ffc..882bfa051c8307b32a45161db11f60e283d670e1 100644
--- a/polkadot/runtime/common/src/assigned_slots/benchmarking.rs
+++ b/polkadot/runtime/common/src/assigned_slots/benchmarking.rs
@@ -22,7 +22,7 @@ use super::*;
 use frame_benchmarking::v2::*;
 use frame_support::assert_ok;
 use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
-use primitives::Id as ParaId;
+use polkadot_primitives::Id as ParaId;
 use sp_runtime::traits::Bounded;
 
 type CurrencyOf<T> = <<T as Config>::Leaser as Leaser<BlockNumberFor<T>>>::Currency;
diff --git a/polkadot/runtime/common/src/assigned_slots/mod.rs b/polkadot/runtime/common/src/assigned_slots/mod.rs
index 9b24b99cfbe2a2f1d06fc842f798a6232077e2fb..d0a531b8b6ca5ad995803edc8cbc45daa88176c2 100644
--- a/polkadot/runtime/common/src/assigned_slots/mod.rs
+++ b/polkadot/runtime/common/src/assigned_slots/mod.rs
@@ -30,12 +30,12 @@ use crate::{
 	slots::{self, Pallet as Slots, WeightInfo as SlotsWeightInfo},
 	traits::{LeaseError, Leaser, Registrar},
 };
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::{pallet_prelude::*, traits::Currency};
 use frame_system::pallet_prelude::*;
 pub use pallet::*;
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
-use primitives::Id as ParaId;
-use runtime_parachains::{
+use polkadot_primitives::Id as ParaId;
+use polkadot_runtime_parachains::{
 	configuration,
 	paras::{self},
 };
@@ -428,7 +428,8 @@ pub mod pallet {
 
 			// Force downgrade to on-demand parachain (if needed) before end of lease period
 			if is_parachain {
-				if let Err(err) = runtime_parachains::schedule_parachain_downgrade::<T>(id) {
+				if let Err(err) = polkadot_runtime_parachains::schedule_parachain_downgrade::<T>(id)
+				{
 					// Treat failed downgrade as warning .. slot lease has been cleared,
 					// so the parachain will be downgraded anyway by the slots pallet
 					// at the end of the lease period .
@@ -630,12 +631,12 @@ mod tests {
 	use super::*;
 
 	use crate::{assigned_slots, mock::TestRegistrar, slots};
-	use ::test_helpers::{dummy_head_data, dummy_validation_code};
 	use frame_support::{assert_noop, assert_ok, derive_impl, parameter_types};
 	use frame_system::EnsureRoot;
 	use pallet_balances;
-	use primitives::BlockNumber;
-	use runtime_parachains::{
+	use polkadot_primitives::BlockNumber;
+	use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code};
+	use polkadot_runtime_parachains::{
 		configuration as parachains_configuration, paras as parachains_paras,
 		shared as parachains_shared,
 	};
@@ -671,10 +672,6 @@ mod tests {
 		type OverarchingCall = RuntimeCall;
 	}
 
-	parameter_types! {
-		pub const BlockHashCount: u32 = 250;
-	}
-
 	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 	impl frame_system::Config for Test {
 		type BaseCallFilter = frame_support::traits::Everything;
@@ -689,7 +686,6 @@ mod tests {
 		type Lookup = IdentityLookup<Self::AccountId>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type DbWeight = ();
 		type Version = ();
 		type PalletInfo = PalletInfo;
@@ -702,24 +698,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
-	parameter_types! {
-		pub const ExistentialDeposit: u64 = 1;
-	}
-
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
-		type WeightInfo = ();
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	impl parachains_configuration::Config for Test {
diff --git a/polkadot/runtime/common/src/auctions.rs b/polkadot/runtime/common/src/auctions.rs
index aa4caac96f154b43f60fb4aa0dc45b9017aff1d9..19d82ae85d0035aea89b5d07f0f042be237da42e 100644
--- a/polkadot/runtime/common/src/auctions.rs
+++ b/polkadot/runtime/common/src/auctions.rs
@@ -22,6 +22,7 @@ use crate::{
 	slot_range::SlotRange,
 	traits::{AuctionStatus, Auctioneer, LeaseError, Leaser, Registrar},
 };
+use codec::Decode;
 use frame_support::{
 	dispatch::DispatchResult,
 	ensure,
@@ -30,8 +31,7 @@ use frame_support::{
 };
 use frame_system::pallet_prelude::BlockNumberFor;
 pub use pallet::*;
-use parity_scale_codec::Decode;
-use primitives::Id as ParaId;
+use polkadot_primitives::Id as ParaId;
 use sp_runtime::traits::{CheckedSub, One, Saturating, Zero};
 use sp_std::{mem::swap, prelude::*};
 
@@ -671,15 +671,15 @@ impl<T: Config> Pallet<T> {
 mod tests {
 	use super::*;
 	use crate::{auctions, mock::TestRegistrar};
-	use ::test_helpers::{dummy_hash, dummy_head_data, dummy_validation_code};
 	use frame_support::{
 		assert_noop, assert_ok, assert_storage_noop, derive_impl, ord_parameter_types,
 		parameter_types,
-		traits::{ConstU32, EitherOfDiverse, OnFinalize, OnInitialize},
+		traits::{EitherOfDiverse, OnFinalize, OnInitialize},
 	};
 	use frame_system::{EnsureRoot, EnsureSignedBy};
 	use pallet_balances;
-	use primitives::{BlockNumber, Id as ParaId};
+	use polkadot_primitives::{BlockNumber, Id as ParaId};
+	use polkadot_primitives_test_helpers::{dummy_hash, dummy_head_data, dummy_validation_code};
 	use sp_core::H256;
 	use sp_runtime::{
 		traits::{BlakeTwo256, IdentityLookup},
@@ -699,10 +699,6 @@ mod tests {
 		}
 	);
 
-	parameter_types! {
-		pub const BlockHashCount: u32 = 250;
-	}
-
 	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 	impl frame_system::Config for Test {
 		type BaseCallFilter = frame_support::traits::Everything;
@@ -718,7 +714,6 @@ mod tests {
 		type Lookup = IdentityLookup<Self::AccountId>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type Version = ();
 		type PalletInfo = PalletInfo;
 		type AccountData = pallet_balances::AccountData<u64>;
@@ -730,25 +725,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
-	parameter_types! {
-		pub const ExistentialDeposit: u64 = 1;
-		pub const MaxReserves: u32 = 50;
-	}
-
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type DustRemoval = ();
-		type RuntimeEvent = RuntimeEvent;
-		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
-		type WeightInfo = ();
-		type MaxLocks = ();
-		type MaxReserves = MaxReserves;
-		type ReserveIdentifier = [u8; 8];
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug)]
@@ -1431,7 +1410,8 @@ mod tests {
 	#[test]
 	fn initialize_winners_in_ending_period_works() {
 		new_test_ext().execute_with(|| {
-			assert_eq!(<Test as pallet_balances::Config>::ExistentialDeposit::get(), 1);
+			let ed: u64 = <Test as pallet_balances::Config>::ExistentialDeposit::get();
+			assert_eq!(ed, 1);
 			run_to_block(1);
 			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 9, 1));
 			let para_1 = ParaId::from(1_u32);
@@ -1544,7 +1524,8 @@ mod tests {
 	#[test]
 	fn less_winning_samples_work() {
 		new_test_ext().execute_with(|| {
-			assert_eq!(<Test as pallet_balances::Config>::ExistentialDeposit::get(), 1);
+			let ed: u64 = <Test as pallet_balances::Config>::ExistentialDeposit::get();
+			assert_eq!(ed, 1);
 			EndingPeriod::set(30);
 			SampleLength::set(10);
 
@@ -1733,7 +1714,7 @@ mod benchmarking {
 		traits::{EnsureOrigin, OnInitialize},
 	};
 	use frame_system::RawOrigin;
-	use runtime_parachains::paras;
+	use polkadot_runtime_parachains::paras;
 	use sp_runtime::{traits::Bounded, SaturatedConversion};
 
 	use frame_benchmarking::{account, benchmarks, whitelisted_caller, BenchmarkError};
diff --git a/polkadot/runtime/common/src/claims.rs b/polkadot/runtime/common/src/claims.rs
index 8407c7f0dda9d9567d0f4283fbc9999c5b0f0a7d..c12af215a04d7119c1052a09a6eb6bee7ac0acb3 100644
--- a/polkadot/runtime/common/src/claims.rs
+++ b/polkadot/runtime/common/src/claims.rs
@@ -16,6 +16,7 @@
 
 //! Pallet to process claims from Ethereum addresses.
 
+use codec::{Decode, Encode};
 use frame_support::{
 	ensure,
 	traits::{Currency, Get, IsSubType, VestingSchedule},
@@ -23,8 +24,7 @@ use frame_support::{
 	DefaultNoBound,
 };
 pub use pallet::*;
-use parity_scale_codec::{Decode, Encode};
-use primitives::ValidityError;
+use polkadot_primitives::ValidityError;
 use scale_info::TypeInfo;
 use serde::{self, Deserialize, Deserializer, Serialize, Serializer};
 use sp_io::{crypto::secp256k1_ecdsa_recover, hashing::keccak_256};
@@ -699,7 +699,7 @@ mod tests {
 	use hex_literal::hex;
 	use secp_utils::*;
 
-	use parity_scale_codec::Encode;
+	use codec::Encode;
 	// The testing primitives are very useful for avoiding having to work with signatures
 	// or public keys. `u64` is used as the `AccountId` and no `Signature`s are required.
 	use crate::claims;
@@ -708,7 +708,7 @@ mod tests {
 		assert_err, assert_noop, assert_ok, derive_impl,
 		dispatch::{GetDispatchInfo, Pays},
 		ord_parameter_types, parameter_types,
-		traits::{ConstU32, ExistenceRequirement, WithdrawReasons},
+		traits::{ExistenceRequirement, WithdrawReasons},
 	};
 	use pallet_balances;
 	use sp_runtime::{
@@ -738,24 +738,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
-	parameter_types! {
-		pub const ExistentialDeposit: u64 = 1;
-	}
-
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type WeightInfo = ();
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	parameter_types! {
diff --git a/polkadot/runtime/common/src/crowdloan/mod.rs b/polkadot/runtime/common/src/crowdloan/mod.rs
index 477530467fa105d93b41569d851b5699aadc09b0..61d406aa681268d8ef0c66567faf7b74555a287d 100644
--- a/polkadot/runtime/common/src/crowdloan/mod.rs
+++ b/polkadot/runtime/common/src/crowdloan/mod.rs
@@ -55,6 +55,7 @@ use crate::{
 	slot_range::SlotRange,
 	traits::{Auctioneer, Registrar},
 };
+use codec::{Decode, Encode};
 use frame_support::{
 	ensure,
 	pallet_prelude::{DispatchResult, Weight},
@@ -68,8 +69,7 @@ use frame_support::{
 };
 use frame_system::pallet_prelude::BlockNumberFor;
 pub use pallet::*;
-use parity_scale_codec::{Decode, Encode};
-use primitives::Id as ParaId;
+use polkadot_primitives::Id as ParaId;
 use scale_info::TypeInfo;
 use sp_runtime::{
 	traits::{
@@ -860,9 +860,9 @@ mod tests {
 
 	use frame_support::{
 		assert_noop, assert_ok, derive_impl, parameter_types,
-		traits::{ConstU32, OnFinalize, OnInitialize},
+		traits::{OnFinalize, OnInitialize},
 	};
-	use primitives::Id as ParaId;
+	use polkadot_primitives::Id as ParaId;
 	use sp_core::H256;
 	use std::{cell::RefCell, collections::BTreeMap, sync::Arc};
 	// The testing primitives are very useful for avoiding having to work with signatures
@@ -872,7 +872,7 @@ mod tests {
 		mock::TestRegistrar,
 		traits::{AuctionStatus, OnSwap},
 	};
-	use ::test_helpers::{dummy_head_data, dummy_validation_code};
+	use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code};
 	use sp_keystore::{testing::MemoryKeystore, KeystoreExt};
 	use sp_runtime::{
 		traits::{BlakeTwo256, IdentityLookup, TrailingZeroInput},
@@ -890,10 +890,6 @@ mod tests {
 		}
 	);
 
-	parameter_types! {
-		pub const BlockHashCount: u32 = 250;
-	}
-
 	type BlockNumber = u64;
 
 	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
@@ -911,7 +907,6 @@ mod tests {
 		type Lookup = IdentityLookup<Self::AccountId>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type Version = ();
 		type PalletInfo = PalletInfo;
 		type AccountData = pallet_balances::AccountData<u64>;
@@ -923,24 +918,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
-	parameter_types! {
-		pub const ExistentialDeposit: u64 = 1;
-	}
-
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type WeightInfo = ();
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	#[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -985,7 +965,7 @@ mod tests {
 		let fund = Funds::<Test>::get(para).unwrap();
 		let account_id = Crowdloan::fund_account_id(fund.fund_index);
 		if winner {
-			let ed = <Test as pallet_balances::Config>::ExistentialDeposit::get();
+			let ed: u64 = <Test as pallet_balances::Config>::ExistentialDeposit::get();
 			let free_balance = Balances::free_balance(&account_id);
 			Balances::reserve(&account_id, free_balance - ed)
 				.expect("should be able to reserve free balance minus ED");
@@ -1820,7 +1800,8 @@ mod tests {
 	#[test]
 	fn withdraw_from_finished_works() {
 		new_test_ext().execute_with(|| {
-			assert_eq!(<Test as pallet_balances::Config>::ExistentialDeposit::get(), 1);
+			let ed: u64 = <Test as pallet_balances::Config>::ExistentialDeposit::get();
+			assert_eq!(ed, 1);
 			let para = new_para();
 			let index = NextFundIndex::<Test>::get();
 			let account_id = Crowdloan::fund_account_id(index);
@@ -1984,7 +1965,7 @@ mod benchmarking {
 	use super::{Pallet as Crowdloan, *};
 	use frame_support::{assert_ok, traits::OnInitialize};
 	use frame_system::RawOrigin;
-	use runtime_parachains::paras;
+	use polkadot_runtime_parachains::paras;
 	use sp_core::crypto::UncheckedFrom;
 	use sp_runtime::traits::{Bounded, CheckedSub};
 	use sp_std::prelude::*;
diff --git a/polkadot/runtime/common/src/identity_migrator.rs b/polkadot/runtime/common/src/identity_migrator.rs
index bf334a63e9588411f57ecc8b6ee2fca72861d7aa..7d02e24b5368126d22a8f75e1075a75c50fb7e87 100644
--- a/polkadot/runtime/common/src/identity_migrator.rs
+++ b/polkadot/runtime/common/src/identity_migrator.rs
@@ -172,10 +172,10 @@ impl<AccountId> OnReapIdentity<AccountId> for () {
 #[benchmarks]
 mod benchmarks {
 	use super::*;
+	use codec::Encode;
 	use frame_support::traits::EnsureOrigin;
 	use frame_system::RawOrigin;
 	use pallet_identity::{Data, IdentityInformationProvider, Judgement, Pallet as Identity};
-	use parity_scale_codec::Encode;
 	use sp_runtime::{
 		traits::{Bounded, Hash, StaticLookup},
 		Saturating,
diff --git a/polkadot/runtime/common/src/impls.rs b/polkadot/runtime/common/src/impls.rs
index 85531e9c04fc47f83fb007802e30e87799c2150c..72ece79f19401aa616c79df41edcc58cd44c41fa 100644
--- a/polkadot/runtime/common/src/impls.rs
+++ b/polkadot/runtime/common/src/impls.rs
@@ -16,14 +16,14 @@
 
 //! Auxiliary `struct`/`enum`s for polkadot runtime.
 
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::traits::{
 	fungible::{Balanced, Credit},
 	tokens::imbalance::ResolveTo,
 	Contains, ContainsPair, Imbalance, OnUnbalanced,
 };
 use pallet_treasury::TreasuryAccountId;
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
-use primitives::Balance;
+use polkadot_primitives::Balance;
 use sp_runtime::{traits::TryConvert, Perquintill, RuntimeDebug};
 use xcm::VersionedLocation;
 
@@ -32,8 +32,8 @@ pub struct ToAuthor<R>(sp_std::marker::PhantomData<R>);
 impl<R> OnUnbalanced<Credit<R::AccountId, pallet_balances::Pallet<R>>> for ToAuthor<R>
 where
 	R: pallet_balances::Config + pallet_authorship::Config,
-	<R as frame_system::Config>::AccountId: From<primitives::AccountId>,
-	<R as frame_system::Config>::AccountId: Into<primitives::AccountId>,
+	<R as frame_system::Config>::AccountId: From<polkadot_primitives::AccountId>,
+	<R as frame_system::Config>::AccountId: Into<polkadot_primitives::AccountId>,
 {
 	fn on_nonzero_unbalanced(
 		amount: Credit<<R as frame_system::Config>::AccountId, pallet_balances::Pallet<R>>,
@@ -48,8 +48,8 @@ pub struct DealWithFees<R>(sp_std::marker::PhantomData<R>);
 impl<R> OnUnbalanced<Credit<R::AccountId, pallet_balances::Pallet<R>>> for DealWithFees<R>
 where
 	R: pallet_balances::Config + pallet_authorship::Config + pallet_treasury::Config,
-	<R as frame_system::Config>::AccountId: From<primitives::AccountId>,
-	<R as frame_system::Config>::AccountId: Into<primitives::AccountId>,
+	<R as frame_system::Config>::AccountId: From<polkadot_primitives::AccountId>,
+	<R as frame_system::Config>::AccountId: Into<polkadot_primitives::AccountId>,
 {
 	fn on_unbalanceds<B>(
 		mut fees_then_tips: impl Iterator<Item = Credit<R::AccountId, pallet_balances::Pallet<R>>>,
@@ -249,13 +249,13 @@ mod tests {
 		parameter_types,
 		traits::{
 			tokens::{PayFromAccount, UnityAssetBalanceConversion},
-			ConstU32, FindAuthor,
+			FindAuthor,
 		},
 		weights::Weight,
 		PalletId,
 	};
 	use frame_system::limits;
-	use primitives::AccountId;
+	use polkadot_primitives::AccountId;
 	use sp_core::{ConstU64, H256};
 	use sp_runtime::{
 		traits::{BlakeTwo256, IdentityLookup},
@@ -276,7 +276,6 @@ mod tests {
 	);
 
 	parameter_types! {
-		pub const BlockHashCount: u64 = 250;
 		pub BlockWeights: limits::BlockWeights = limits::BlockWeights::builder()
 			.base_block(Weight::from_parts(10, 0))
 			.for_class(DispatchClass::all(), |weight| {
@@ -302,7 +301,6 @@ mod tests {
 		type Lookup = IdentityLookup<Self::AccountId>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type BlockLength = BlockLength;
 		type BlockWeights = BlockWeights;
 		type DbWeight = ();
@@ -317,20 +315,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ConstU64<1>;
 		type AccountStore = System;
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type WeightInfo = ();
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	parameter_types! {
@@ -345,9 +332,6 @@ mod tests {
 		type RejectOrigin = frame_system::EnsureRoot<AccountId>;
 		type RuntimeEvent = RuntimeEvent;
 		type OnSlash = ();
-		type ProposalBond = ();
-		type ProposalBondMinimum = ();
-		type ProposalBondMaximum = ();
 		type SpendPeriod = ();
 		type Burn = ();
 		type BurnDestination = ();
diff --git a/polkadot/runtime/common/src/integration_tests.rs b/polkadot/runtime/common/src/integration_tests.rs
index 3e9ac1fc1b152574ea86d42c7d48f51da47ddc39..052fb0389db40c086d2c13b3d30501e093ef5f90 100644
--- a/polkadot/runtime/common/src/integration_tests.rs
+++ b/polkadot/runtime/common/src/integration_tests.rs
@@ -24,6 +24,7 @@ use crate::{
 	slots,
 	traits::{AuctionStatus, Auctioneer, Leaser, Registrar as RegistrarT},
 };
+use codec::Encode;
 use frame_support::{
 	assert_noop, assert_ok, derive_impl, parameter_types,
 	traits::{ConstU32, Currency, OnFinalize, OnInitialize},
@@ -33,12 +34,11 @@ use frame_support::{
 use frame_support_test::TestRandomness;
 use frame_system::EnsureRoot;
 use pallet_identity::{self, legacy::IdentityInfo};
-use parity_scale_codec::Encode;
-use primitives::{
+use polkadot_primitives::{
 	BlockNumber, HeadData, Id as ParaId, SessionIndex, ValidationCode, LOWEST_PUBLIC_ID,
 	MAX_CODE_SIZE,
 };
-use runtime_parachains::{
+use polkadot_runtime_parachains::{
 	configuration, dmp, origin, paras, shared, Origin as ParaOrigin, ParaLifecycle,
 };
 use sp_core::H256;
@@ -109,7 +109,6 @@ where
 use crate::{auctions::Error as AuctionsError, crowdloan::Error as CrowdloanError};
 
 parameter_types! {
-	pub const BlockHashCount: u32 = 250;
 	pub BlockWeights: frame_system::limits::BlockWeights =
 		frame_system::limits::BlockWeights::simple_max(
 			Weight::from_parts(4 * 1024 * 1024, u64::MAX),
@@ -131,7 +130,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<Balance>;
@@ -175,23 +173,12 @@ impl pallet_timestamp::Config for Test {
 
 parameter_types! {
 	pub static ExistentialDeposit: Balance = 1;
-	pub const MaxReserves: u32 = 50;
 }
-
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxReserves = MaxReserves;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 impl configuration::Config for Test {
diff --git a/polkadot/runtime/common/src/lib.rs b/polkadot/runtime/common/src/lib.rs
index 60cc684149b48fe7bb4a102cbad7f96f3c7b5826..6e50384f68c9cf5972717a1cc60ad901b5f37dab 100644
--- a/polkadot/runtime/common/src/lib.rs
+++ b/polkadot/runtime/common/src/lib.rs
@@ -47,7 +47,7 @@ use frame_support::{
 	weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight},
 };
 use frame_system::limits;
-use primitives::{AssignmentId, Balance, BlockNumber, ValidatorId};
+use polkadot_primitives::{AssignmentId, Balance, BlockNumber, ValidatorId};
 use sp_runtime::{FixedPointNumber, Perbill, Perquintill};
 use static_assertions::const_assert;
 
@@ -123,7 +123,7 @@ macro_rules! impl_runtime_weights {
 		use frame_support::{dispatch::DispatchClass, weights::Weight};
 		use frame_system::limits;
 		use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment};
-		pub use runtime_common::{
+		pub use polkadot_runtime_common::{
 			impl_elections_weights, AVERAGE_ON_INITIALIZE_RATIO, MAXIMUM_BLOCK_WEIGHT,
 			NORMAL_DISPATCH_RATIO,
 		};
@@ -165,7 +165,7 @@ macro_rules! impl_runtime_weights {
 ///
 /// This must only be used as long as the balance type is `u128`.
 pub type CurrencyToVote = sp_staking::currency_to_vote::U128CurrencyToVote;
-static_assertions::assert_eq_size!(primitives::Balance, u128);
+static_assertions::assert_eq_size!(polkadot_primitives::Balance, u128);
 
 /// A placeholder since there is currently no provided session key handler for parachain validator
 /// keys.
diff --git a/polkadot/runtime/common/src/mock.rs b/polkadot/runtime/common/src/mock.rs
index c9e3a8c39f12d3424bd3fb47077812661b6202ba..6534110cc21043510e5944d1407d28f9d219c067 100644
--- a/polkadot/runtime/common/src/mock.rs
+++ b/polkadot/runtime/common/src/mock.rs
@@ -17,11 +17,13 @@
 //! Mocking utilities for testing.
 
 use crate::traits::Registrar;
+use codec::{Decode, Encode};
 use frame_support::{dispatch::DispatchResult, weights::Weight};
 use frame_system::pallet_prelude::BlockNumberFor;
-use parity_scale_codec::{Decode, Encode};
-use primitives::{HeadData, Id as ParaId, PvfCheckStatement, SessionIndex, ValidationCode};
-use runtime_parachains::paras;
+use polkadot_primitives::{
+	HeadData, Id as ParaId, PvfCheckStatement, SessionIndex, ValidationCode,
+};
+use polkadot_runtime_parachains::paras;
 use sp_keyring::Sr25519Keyring;
 use sp_runtime::{traits::SaturatedConversion, DispatchError, Permill};
 use std::{cell::RefCell, collections::HashMap};
@@ -239,7 +241,9 @@ impl frame_support::traits::EstimateNextSessionRotation<u32> for TestNextSession
 	}
 }
 
-pub fn validators_public_keys(validators: &[Sr25519Keyring]) -> Vec<primitives::ValidatorId> {
+pub fn validators_public_keys(
+	validators: &[Sr25519Keyring],
+) -> Vec<polkadot_primitives::ValidatorId> {
 	validators.iter().map(|v| v.public().into()).collect()
 }
 
@@ -248,7 +252,7 @@ pub fn conclude_pvf_checking<T: paras::Config>(
 	validators: &[Sr25519Keyring],
 	session_index: SessionIndex,
 ) {
-	let num_required = primitives::supermajority_threshold(validators.len());
+	let num_required = polkadot_primitives::supermajority_threshold(validators.len());
 	validators.iter().enumerate().take(num_required).for_each(|(idx, key)| {
 		let validator_index = idx as u32;
 		let statement = PvfCheckStatement {
diff --git a/polkadot/runtime/common/src/paras_registrar/mod.rs b/polkadot/runtime/common/src/paras_registrar/mod.rs
index a49ebab3e26a8df5ecfdf7615849b75d9e3c4671..6b9191f7c6f2db0f9e98b0a67ead596d4c3a9822 100644
--- a/polkadot/runtime/common/src/paras_registrar/mod.rs
+++ b/polkadot/runtime/common/src/paras_registrar/mod.rs
@@ -26,8 +26,10 @@ use frame_support::{
 	traits::{Currency, Get, ReservableCurrency},
 };
 use frame_system::{self, ensure_root, ensure_signed};
-use primitives::{HeadData, Id as ParaId, ValidationCode, LOWEST_PUBLIC_ID, MIN_CODE_SIZE};
-use runtime_parachains::{
+use polkadot_primitives::{
+	HeadData, Id as ParaId, ValidationCode, LOWEST_PUBLIC_ID, MIN_CODE_SIZE,
+};
+use polkadot_runtime_parachains::{
 	configuration, ensure_parachain,
 	paras::{self, ParaGenesisArgs, UpgradeStrategy},
 	Origin, ParaLifecycle,
@@ -35,9 +37,9 @@ use runtime_parachains::{
 use sp_std::{prelude::*, result};
 
 use crate::traits::{OnSwap, Registrar};
+use codec::{Decode, Encode};
 pub use pallet::*;
-use parity_scale_codec::{Decode, Encode};
-use runtime_parachains::paras::{OnNewHead, ParaKind};
+use polkadot_runtime_parachains::paras::{OnNewHead, ParaKind};
 use scale_info::TypeInfo;
 use sp_runtime::{
 	traits::{CheckedSub, Saturating},
@@ -425,7 +427,7 @@ pub mod pallet {
 			new_code: ValidationCode,
 		) -> DispatchResult {
 			Self::ensure_root_para_or_owner(origin, para)?;
-			runtime_parachains::schedule_code_upgrade::<T>(
+			polkadot_runtime_parachains::schedule_code_upgrade::<T>(
 				para,
 				new_code,
 				UpgradeStrategy::ApplyAtExpectedBlock,
@@ -445,7 +447,7 @@ pub mod pallet {
 			new_head: HeadData,
 		) -> DispatchResult {
 			Self::ensure_root_para_or_owner(origin, para)?;
-			runtime_parachains::set_current_head::<T>(para, new_head);
+			polkadot_runtime_parachains::set_current_head::<T>(para, new_head);
 			Ok(())
 		}
 	}
@@ -510,7 +512,7 @@ impl<T: Config> Registrar for Pallet<T> {
 			paras::Pallet::<T>::lifecycle(id) == Some(ParaLifecycle::Parathread),
 			Error::<T>::NotParathread
 		);
-		runtime_parachains::schedule_parathread_upgrade::<T>(id)
+		polkadot_runtime_parachains::schedule_parathread_upgrade::<T>(id)
 			.map_err(|_| Error::<T>::CannotUpgrade)?;
 
 		Ok(())
@@ -523,7 +525,7 @@ impl<T: Config> Registrar for Pallet<T> {
 			paras::Pallet::<T>::lifecycle(id) == Some(ParaLifecycle::Parachain),
 			Error::<T>::NotParachain
 		);
-		runtime_parachains::schedule_parachain_downgrade::<T>(id)
+		polkadot_runtime_parachains::schedule_parachain_downgrade::<T>(id)
 			.map_err(|_| Error::<T>::CannotDowngrade)?;
 		Ok(())
 	}
@@ -545,7 +547,7 @@ impl<T: Config> Registrar for Pallet<T> {
 
 	#[cfg(any(feature = "runtime-benchmarks", test))]
 	fn execute_pending_transitions() {
-		use runtime_parachains::shared;
+		use polkadot_runtime_parachains::shared;
 		shared::Pallet::<T>::set_session_index(shared::Pallet::<T>::scheduled_session());
 		paras::Pallet::<T>::test_on_new_session();
 	}
@@ -634,7 +636,7 @@ impl<T: Config> Pallet<T> {
 
 		Paras::<T>::insert(id, info);
 		// We check above that para has no lifecycle, so this should not fail.
-		let res = runtime_parachains::schedule_para_initialize::<T>(id, genesis);
+		let res = polkadot_runtime_parachains::schedule_para_initialize::<T>(id, genesis);
 		debug_assert!(res.is_ok());
 		Self::deposit_event(Event::<T>::Registered { para_id: id, manager: who });
 		Ok(())
@@ -647,7 +649,7 @@ impl<T: Config> Pallet<T> {
 			Some(ParaLifecycle::Parathread) | None => {},
 			_ => return Err(Error::<T>::NotParathread.into()),
 		}
-		runtime_parachains::schedule_para_cleanup::<T>(id)
+		polkadot_runtime_parachains::schedule_para_cleanup::<T>(id)
 			.map_err(|_| Error::<T>::CannotDeregister)?;
 
 		if let Some(info) = Paras::<T>::take(&id) {
@@ -686,9 +688,9 @@ impl<T: Config> Pallet<T> {
 	/// Swap a lease holding parachain and parathread (on-demand parachain), which involves
 	/// scheduling an appropriate lifecycle update.
 	fn do_thread_and_chain_swap(to_downgrade: ParaId, to_upgrade: ParaId) {
-		let res1 = runtime_parachains::schedule_parachain_downgrade::<T>(to_downgrade);
+		let res1 = polkadot_runtime_parachains::schedule_parachain_downgrade::<T>(to_downgrade);
 		debug_assert!(res1.is_ok());
-		let res2 = runtime_parachains::schedule_parathread_upgrade::<T>(to_upgrade);
+		let res2 = polkadot_runtime_parachains::schedule_parathread_upgrade::<T>(to_upgrade);
 		debug_assert!(res2.is_ok());
 		T::OnSwap::on_swap(to_upgrade, to_downgrade);
 	}
@@ -719,12 +721,12 @@ mod tests {
 		assert_noop, assert_ok, derive_impl,
 		error::BadOrigin,
 		parameter_types,
-		traits::{ConstU32, OnFinalize, OnInitialize},
+		traits::{OnFinalize, OnInitialize},
 	};
 	use frame_system::limits;
 	use pallet_balances::Error as BalancesError;
-	use primitives::{Balance, BlockNumber, SessionIndex, MAX_CODE_SIZE};
-	use runtime_parachains::{configuration, origin, shared};
+	use polkadot_primitives::{Balance, BlockNumber, SessionIndex, MAX_CODE_SIZE};
+	use polkadot_runtime_parachains::{configuration, origin, shared};
 	use sp_core::H256;
 	use sp_io::TestExternalities;
 	use sp_keyring::Sr25519Keyring;
@@ -761,7 +763,6 @@ mod tests {
 
 	const NORMAL_RATIO: Perbill = Perbill::from_percent(75);
 	parameter_types! {
-		pub const BlockHashCount: u32 = 250;
 		pub BlockWeights: limits::BlockWeights =
 			frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1024, u64::MAX));
 		pub BlockLength: limits::BlockLength =
@@ -780,7 +781,6 @@ mod tests {
 		type Lookup = IdentityLookup<u64>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type DbWeight = ();
 		type BlockWeights = BlockWeights;
 		type BlockLength = BlockLength;
@@ -799,20 +799,11 @@ mod tests {
 		pub const ExistentialDeposit: Balance = 1;
 	}
 
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u128;
-		type DustRemoval = ();
-		type RuntimeEvent = RuntimeEvent;
+		type Balance = Balance;
 		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type WeightInfo = ();
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	impl shared::Config for Test {
@@ -943,7 +934,7 @@ mod tests {
 	}
 
 	fn para_origin(id: ParaId) -> RuntimeOrigin {
-		runtime_parachains::Origin::Parachain(id).into()
+		polkadot_runtime_parachains::Origin::Parachain(id).into()
 	}
 
 	fn max_code_size() -> u32 {
@@ -1529,8 +1520,8 @@ mod benchmarking {
 	use crate::traits::Registrar as RegistrarT;
 	use frame_support::assert_ok;
 	use frame_system::RawOrigin;
-	use primitives::{MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MIN_CODE_SIZE};
-	use runtime_parachains::{paras, shared, Origin as ParaOrigin};
+	use polkadot_primitives::{MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MIN_CODE_SIZE};
+	use polkadot_runtime_parachains::{paras, shared, Origin as ParaOrigin};
 	use sp_runtime::traits::Bounded;
 
 	use frame_benchmarking::{account, benchmarks, whitelisted_caller};
@@ -1556,7 +1547,7 @@ mod benchmarking {
 			genesis_head,
 			validation_code.clone()
 		));
-		assert_ok!(runtime_parachains::paras::Pallet::<T>::add_trusted_validation_code(
+		assert_ok!(polkadot_runtime_parachains::paras::Pallet::<T>::add_trusted_validation_code(
 			frame_system::Origin::<T>::Root.into(),
 			validation_code,
 		));
@@ -1597,7 +1588,7 @@ mod benchmarking {
 		verify {
 			assert_last_event::<T>(Event::<T>::Registered{ para_id: para, manager: caller }.into());
 			assert_eq!(paras::Pallet::<T>::lifecycle(para), Some(ParaLifecycle::Onboarding));
-			assert_ok!(runtime_parachains::paras::Pallet::<T>::add_trusted_validation_code(
+			assert_ok!(polkadot_runtime_parachains::paras::Pallet::<T>::add_trusted_validation_code(
 				frame_system::Origin::<T>::Root.into(),
 				validation_code,
 			));
@@ -1615,7 +1606,7 @@ mod benchmarking {
 		verify {
 			assert_last_event::<T>(Event::<T>::Registered { para_id: para, manager }.into());
 			assert_eq!(paras::Pallet::<T>::lifecycle(para), Some(ParaLifecycle::Onboarding));
-			assert_ok!(runtime_parachains::paras::Pallet::<T>::add_trusted_validation_code(
+			assert_ok!(polkadot_runtime_parachains::paras::Pallet::<T>::add_trusted_validation_code(
 				frame_system::Origin::<T>::Root.into(),
 				validation_code,
 			));
diff --git a/polkadot/runtime/common/src/paras_sudo_wrapper.rs b/polkadot/runtime/common/src/paras_sudo_wrapper.rs
index b56dc96af436d0bdd2e4c4313e426a6e7bfc2995..3ff8d4ac08e15d88be618d79e21f2c5d97627982 100644
--- a/polkadot/runtime/common/src/paras_sudo_wrapper.rs
+++ b/polkadot/runtime/common/src/paras_sudo_wrapper.rs
@@ -16,12 +16,12 @@
 
 //! A simple wrapper allowing `Sudo` to call into `paras` routines.
 
+use codec::Encode;
 use frame_support::pallet_prelude::*;
 use frame_system::pallet_prelude::*;
 pub use pallet::*;
-use parity_scale_codec::Encode;
-use primitives::Id as ParaId;
-use runtime_parachains::{
+use polkadot_primitives::Id as ParaId;
+use polkadot_runtime_parachains::{
 	configuration, dmp, hrmp,
 	paras::{self, AssignCoretime, ParaGenesisArgs},
 	ParaLifecycle,
@@ -80,7 +80,7 @@ pub mod pallet {
 			genesis: ParaGenesisArgs,
 		) -> DispatchResult {
 			ensure_root(origin)?;
-			runtime_parachains::schedule_para_initialize::<T>(id, genesis)
+			polkadot_runtime_parachains::schedule_para_initialize::<T>(id, genesis)
 				.map_err(|_| Error::<T>::ParaAlreadyExists)?;
 
 			T::AssignCoretime::assign_coretime(id)?;
@@ -93,7 +93,7 @@ pub mod pallet {
 		#[pallet::weight((1_000, DispatchClass::Operational))]
 		pub fn sudo_schedule_para_cleanup(origin: OriginFor<T>, id: ParaId) -> DispatchResult {
 			ensure_root(origin)?;
-			runtime_parachains::schedule_para_cleanup::<T>(id)
+			polkadot_runtime_parachains::schedule_para_cleanup::<T>(id)
 				.map_err(|_| Error::<T>::CouldntCleanup)?;
 			Ok(())
 		}
@@ -111,7 +111,7 @@ pub mod pallet {
 				paras::Pallet::<T>::lifecycle(id) == Some(ParaLifecycle::Parathread),
 				Error::<T>::NotParathread,
 			);
-			runtime_parachains::schedule_parathread_upgrade::<T>(id)
+			polkadot_runtime_parachains::schedule_parathread_upgrade::<T>(id)
 				.map_err(|_| Error::<T>::CannotUpgrade)?;
 			Ok(())
 		}
@@ -129,7 +129,7 @@ pub mod pallet {
 				paras::Pallet::<T>::lifecycle(id) == Some(ParaLifecycle::Parachain),
 				Error::<T>::NotParachain,
 			);
-			runtime_parachains::schedule_parachain_downgrade::<T>(id)
+			polkadot_runtime_parachains::schedule_parachain_downgrade::<T>(id)
 				.map_err(|_| Error::<T>::CannotDowngrade)?;
 			Ok(())
 		}
diff --git a/polkadot/runtime/common/src/purchase.rs b/polkadot/runtime/common/src/purchase.rs
index b90bbb3a7cfb87c8753114de74d12119ad8b6c56..eb480e4efe1f82f657daaa03cd33d883a01d9f7d 100644
--- a/polkadot/runtime/common/src/purchase.rs
+++ b/polkadot/runtime/common/src/purchase.rs
@@ -16,13 +16,13 @@
 
 //! Pallet to process purchase of DOTs.
 
+use codec::{Decode, Encode};
 use frame_support::{
 	pallet_prelude::*,
 	traits::{Currency, EnsureOrigin, ExistenceRequirement, Get, VestingSchedule},
 };
 use frame_system::pallet_prelude::*;
 pub use pallet::*;
-use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_core::sr25519;
 use sp_runtime::{
@@ -508,10 +508,6 @@ mod tests {
 
 	type AccountId = AccountId32;
 
-	parameter_types! {
-		pub const BlockHashCount: u32 = 250;
-	}
-
 	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 	impl frame_system::Config for Test {
 		type BaseCallFilter = frame_support::traits::Everything;
@@ -527,7 +523,6 @@ mod tests {
 		type Lookup = IdentityLookup<AccountId>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type Version = ();
 		type PalletInfo = PalletInfo;
 		type AccountData = pallet_balances::AccountData<u64>;
@@ -539,24 +534,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
-	parameter_types! {
-		pub const ExistentialDeposit: u64 = 1;
-	}
-
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type WeightInfo = ();
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	parameter_types! {
diff --git a/polkadot/runtime/common/src/slots/mod.rs b/polkadot/runtime/common/src/slots/mod.rs
index 738569ff4416c0049ca134e5ea94cf5e9245f81d..747b7b5ca634ed0563061aea2d169624a2ed87ac 100644
--- a/polkadot/runtime/common/src/slots/mod.rs
+++ b/polkadot/runtime/common/src/slots/mod.rs
@@ -32,7 +32,7 @@ use frame_support::{
 };
 use frame_system::pallet_prelude::*;
 pub use pallet::*;
-use primitives::Id as ParaId;
+use polkadot_primitives::Id as ParaId;
 use sp_runtime::traits::{CheckedConversion, CheckedSub, Saturating, Zero};
 use sp_std::prelude::*;
 
@@ -503,11 +503,11 @@ mod tests {
 	use super::*;
 
 	use crate::{mock::TestRegistrar, slots};
-	use ::test_helpers::{dummy_head_data, dummy_validation_code};
 	use frame_support::{assert_noop, assert_ok, derive_impl, parameter_types};
 	use frame_system::EnsureRoot;
 	use pallet_balances;
-	use primitives::BlockNumber;
+	use polkadot_primitives::BlockNumber;
+	use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code};
 	use sp_core::H256;
 	use sp_runtime::{
 		traits::{BlakeTwo256, IdentityLookup},
@@ -525,10 +525,6 @@ mod tests {
 		}
 	);
 
-	parameter_types! {
-		pub const BlockHashCount: u32 = 250;
-	}
-
 	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 	impl frame_system::Config for Test {
 		type BaseCallFilter = frame_support::traits::Everything;
@@ -543,7 +539,6 @@ mod tests {
 		type Lookup = IdentityLookup<Self::AccountId>;
 		type Block = Block;
 		type RuntimeEvent = RuntimeEvent;
-		type BlockHashCount = BlockHashCount;
 		type DbWeight = ();
 		type Version = ();
 		type PalletInfo = PalletInfo;
@@ -556,24 +551,9 @@ mod tests {
 		type MaxConsumers = frame_support::traits::ConstU32<16>;
 	}
 
-	parameter_types! {
-		pub const ExistentialDeposit: u64 = 1;
-	}
-
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
-		type WeightInfo = ();
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type RuntimeHoldReason = RuntimeHoldReason;
-		type RuntimeFreezeReason = RuntimeFreezeReason;
-		type FreezeIdentifier = ();
-		type MaxFreezes = ConstU32<1>;
 	}
 
 	parameter_types! {
@@ -990,7 +970,7 @@ mod benchmarking {
 	use super::*;
 	use frame_support::assert_ok;
 	use frame_system::RawOrigin;
-	use runtime_parachains::paras;
+	use polkadot_runtime_parachains::paras;
 	use sp_runtime::traits::{Bounded, One};
 
 	use frame_benchmarking::{account, benchmarks, whitelisted_caller, BenchmarkError};
diff --git a/polkadot/runtime/common/src/traits.rs b/polkadot/runtime/common/src/traits.rs
index 8f75bf5c2fd8362e324f2bb42f28f462375921c1..2ed1fb8af9beacda31b0134ebc72c95b24c2d8cd 100644
--- a/polkadot/runtime/common/src/traits.rs
+++ b/polkadot/runtime/common/src/traits.rs
@@ -20,7 +20,7 @@ use frame_support::{
 	dispatch::DispatchResult,
 	traits::{Currency, ReservableCurrency},
 };
-use primitives::{HeadData, Id as ParaId, ValidationCode};
+use polkadot_primitives::{HeadData, Id as ParaId, ValidationCode};
 use sp_std::vec::*;
 
 /// Parachain registration API.
diff --git a/polkadot/runtime/common/src/xcm_sender.rs b/polkadot/runtime/common/src/xcm_sender.rs
index cbec1a8ca1036117275b5234229c2cfc06481056..5858a0ac3ca76e32729efa30b244f3bfadaa2bdf 100644
--- a/polkadot/runtime/common/src/xcm_sender.rs
+++ b/polkadot/runtime/common/src/xcm_sender.rs
@@ -16,11 +16,11 @@
 
 //! XCM sender for relay chain.
 
+use codec::{Decode, Encode};
 use frame_support::traits::Get;
 use frame_system::pallet_prelude::BlockNumberFor;
-use parity_scale_codec::{Decode, Encode};
-use primitives::Id as ParaId;
-use runtime_parachains::{
+use polkadot_primitives::Id as ParaId;
+use polkadot_runtime_parachains::{
 	configuration::{self, HostConfiguration},
 	dmp, FeeTracker,
 };
@@ -259,7 +259,7 @@ mod tests {
 	use super::*;
 	use crate::integration_tests::new_test_ext;
 	use frame_support::{assert_ok, parameter_types};
-	use runtime_parachains::FeeTracker;
+	use polkadot_runtime_parachains::FeeTracker;
 	use sp_runtime::FixedU128;
 	use xcm::MAX_XCM_DECODE_DEPTH;
 
diff --git a/polkadot/runtime/metrics/Cargo.toml b/polkadot/runtime/metrics/Cargo.toml
index 76c1d134fa18669768aff9e860bbaee35a201e67..342c5a885033884f025c34cadca03f37e1a7297e 100644
--- a/polkadot/runtime/metrics/Cargo.toml
+++ b/polkadot/runtime/metrics/Cargo.toml
@@ -12,8 +12,8 @@ workspace = true
 [dependencies]
 sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false }
 sp-tracing = { path = "../../../substrate/primitives/tracing", default-features = false }
-parity-scale-codec = { version = "3.6.12", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
+polkadot-primitives = { path = "../../primitives", default-features = false }
 frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true }
 
 bs58 = { version = "0.5.0", default-features = false, features = ["alloc"] }
@@ -22,9 +22,9 @@ bs58 = { version = "0.5.0", default-features = false, features = ["alloc"] }
 default = ["std"]
 std = [
 	"bs58/std",
+	"codec/std",
 	"frame-benchmarking?/std",
-	"parity-scale-codec/std",
-	"primitives/std",
+	"polkadot-primitives/std",
 	"sp-std/std",
 	"sp-tracing/std",
 ]
diff --git a/polkadot/runtime/metrics/src/with_runtime_metrics.rs b/polkadot/runtime/metrics/src/with_runtime_metrics.rs
index 562aa9ca162b55da49e7f384aa5470906fe8a7da..1339df9ff6879e6624823fe49cac55eb2854252a 100644
--- a/polkadot/runtime/metrics/src/with_runtime_metrics.rs
+++ b/polkadot/runtime/metrics/src/with_runtime_metrics.rs
@@ -22,8 +22,8 @@
 
 const TRACING_TARGET: &'static str = "metrics";
 
-use parity_scale_codec::Encode;
-use primitives::{
+use codec::Encode;
+use polkadot_primitives::{
 	metric_definitions::{CounterDefinition, CounterVecDefinition, HistogramDefinition},
 	RuntimeMetricLabelValues, RuntimeMetricOp, RuntimeMetricUpdate,
 };
diff --git a/polkadot/runtime/metrics/src/without_runtime_metrics.rs b/polkadot/runtime/metrics/src/without_runtime_metrics.rs
index 41d9c24635ae49e544f5fe1eaf18bc740d8a30c9..555cdf4751c8b46aff2c40075eafcf0b50800697 100644
--- a/polkadot/runtime/metrics/src/without_runtime_metrics.rs
+++ b/polkadot/runtime/metrics/src/without_runtime_metrics.rs
@@ -18,7 +18,7 @@
 //! provide a dummy implementation for the native runtime to avoid cluttering the runtime code
 //! with `#[cfg(feature = "runtime-metrics")]`.
 
-use primitives::metric_definitions::{
+use polkadot_primitives::metric_definitions::{
 	CounterDefinition, CounterVecDefinition, HistogramDefinition,
 };
 
diff --git a/polkadot/runtime/parachains/Cargo.toml b/polkadot/runtime/parachains/Cargo.toml
index d00a19c6ddb8e43881473d7b22daa31b4cc6990c..250fee65beefe7af6e9762b8ebcca8020b6a556a 100644
--- a/polkadot/runtime/parachains/Cargo.toml
+++ b/polkadot/runtime/parachains/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 [dependencies]
 impl-trait-for-tuples = "0.2.2"
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
 log = { workspace = true }
 rustc-hex = { version = "2.1.0", default-features = false }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
@@ -21,7 +21,7 @@ derive_more = "0.99.17"
 bitflags = "1.3.2"
 
 sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false }
+sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false }
 sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false }
 sp-io = { path = "../../../substrate/primitives/io", default-features = false }
 sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false, features = ["serde"] }
@@ -49,7 +49,7 @@ frame-system = { path = "../../../substrate/frame/system", default-features = fa
 
 xcm = { package = "staging-xcm", path = "../../xcm", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../xcm/xcm-executor", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false }
+polkadot-primitives = { path = "../../primitives", default-features = false }
 
 rand = { version = "0.8.5", default-features = false }
 rand_chacha = { version = "0.3.1", default-features = false }
@@ -61,10 +61,10 @@ polkadot-core-primitives = { path = "../../core-primitives", default-features =
 [dev-dependencies]
 futures = "0.3.30"
 hex-literal = "0.4.1"
-keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" }
+sp-keyring = { path = "../../../substrate/primitives/keyring" }
 frame-support-test = { path = "../../../substrate/frame/support/test" }
 sc-keystore = { path = "../../../substrate/client/keystore" }
-test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" }
+polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" }
 sp-tracing = { path = "../../../substrate/primitives/tracing" }
 sp-crypto-hashing = { path = "../../../substrate/primitives/crypto/hashing" }
 thousands = "0.2.0"
@@ -77,10 +77,10 @@ default = ["std"]
 no_std = []
 std = [
 	"bitvec/std",
+	"codec/std",
 	"frame-benchmarking?/std",
 	"frame-support/std",
 	"frame-system/std",
-	"inherents/std",
 	"log/std",
 	"pallet-authority-discovery/std",
 	"pallet-authorship/std",
@@ -92,11 +92,10 @@ std = [
 	"pallet-staking/std",
 	"pallet-timestamp/std",
 	"pallet-vesting/std",
-	"parity-scale-codec/std",
 	"polkadot-core-primitives/std",
 	"polkadot-parachain-primitives/std",
+	"polkadot-primitives/std",
 	"polkadot-runtime-metrics/std",
-	"primitives/std",
 	"rand/std",
 	"rand_chacha/std",
 	"rustc-hex/std",
@@ -106,6 +105,7 @@ std = [
 	"sp-application-crypto?/std",
 	"sp-arithmetic/std",
 	"sp-core/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-keystore",
 	"sp-keystore?/std",
@@ -128,7 +128,7 @@ runtime-benchmarks = [
 	"pallet-timestamp/runtime-benchmarks",
 	"pallet-vesting/runtime-benchmarks",
 	"polkadot-parachain-primitives/runtime-benchmarks",
-	"primitives/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
 	"sp-application-crypto",
 	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
diff --git a/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs b/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs
index e2ba0b4f7ea5d5ca2eb49c903afb764229e0491f..6c63e062c4b9f54ad66ccc3a20a52041a3659d1a 100644
--- a/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs
+++ b/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs
@@ -26,7 +26,7 @@ use crate::{
 };
 use sp_runtime::Perbill;
 
-use primitives::{Balance, HeadData, ValidationCode};
+use polkadot_primitives::{Balance, HeadData, ValidationCode};
 
 fn default_genesis_config() -> MockGenesisConfig {
 	MockGenesisConfig {
@@ -44,7 +44,7 @@ pub struct GenesisConfigBuilder {
 	pub on_demand_fee_variability: Perbill,
 	pub on_demand_max_queue_size: u32,
 	pub on_demand_target_queue_utilization: Perbill,
-	pub onboarded_on_demand_chains: Vec<primitives::Id>,
+	pub onboarded_on_demand_chains: Vec<polkadot_primitives::Id>,
 }
 
 impl Default for GenesisConfigBuilder {
diff --git a/polkadot/runtime/parachains/src/assigner_coretime/mod.rs b/polkadot/runtime/parachains/src/assigner_coretime/mod.rs
index 1e821dd86846824719f6d84f0bdc0e19222ddd84..e68ac2664b898b5594a19fa7a8626c2d3b257160 100644
--- a/polkadot/runtime/parachains/src/assigner_coretime/mod.rs
+++ b/polkadot/runtime/parachains/src/assigner_coretime/mod.rs
@@ -37,7 +37,7 @@ use crate::{
 use frame_support::{defensive, pallet_prelude::*};
 use frame_system::pallet_prelude::*;
 use pallet_broker::CoreAssignment;
-use primitives::CoreIndex;
+use polkadot_primitives::CoreIndex;
 use sp_runtime::traits::{One, Saturating};
 
 use sp_std::prelude::*;
@@ -317,7 +317,7 @@ impl<T: Config> AssignmentProvider<BlockNumberFor<T>> for Pallet<T> {
 	}
 
 	#[cfg(any(feature = "runtime-benchmarks", test))]
-	fn get_mock_assignment(_: CoreIndex, para_id: primitives::Id) -> Assignment {
+	fn get_mock_assignment(_: CoreIndex, para_id: polkadot_primitives::Id) -> Assignment {
 		// Given that we are not tracking anything in `Bulk` assignments, it is safe to always
 		// return a bulk assignment.
 		Assignment::Bulk(para_id)
diff --git a/polkadot/runtime/parachains/src/assigner_coretime/tests.rs b/polkadot/runtime/parachains/src/assigner_coretime/tests.rs
index 5d42a9d0c8eec877292b2d5d6ca318e7df8df5b4..81a0988ea67cd3eb3b76784d360d46a1ddf1633e 100644
--- a/polkadot/runtime/parachains/src/assigner_coretime/tests.rs
+++ b/polkadot/runtime/parachains/src/assigner_coretime/tests.rs
@@ -28,7 +28,7 @@ use crate::{
 };
 use frame_support::{assert_noop, assert_ok, pallet_prelude::*, traits::Currency};
 use pallet_broker::TaskId;
-use primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode};
+use polkadot_primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode};
 use sp_std::collections::btree_map::BTreeMap;
 
 fn schedule_blank_para(id: ParaId, parakind: ParaKind) {
@@ -75,7 +75,7 @@ fn run_to_block(
 		Scheduler::initializer_initialize(b + 1);
 
 		// In the real runtime this is expected to be called by the `InclusionInherent` pallet.
-		Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1);
+		Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1);
 	}
 }
 
diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs b/polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs
index 779d6f04e39638d5dfe2552c983de4715ee089d7..ba6951a146921f7f698c02bb49dcaffea76563e4 100644
--- a/polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs
+++ b/polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs
@@ -29,7 +29,7 @@ use frame_benchmarking::v2::*;
 use frame_system::RawOrigin;
 use sp_runtime::traits::Bounded;
 
-use primitives::{
+use polkadot_primitives::{
 	HeadData, Id as ParaId, SessionIndex, ValidationCode, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
 };
 
diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/migration.rs b/polkadot/runtime/parachains/src/assigner_on_demand/migration.rs
index 50e5e1daf41a56bb6bb191d0e2205d2cc9bb8b52..314be11adbeb79bab4fa0ce2d0b4f52fb5176ceb 100644
--- a/polkadot/runtime/parachains/src/assigner_on_demand/migration.rs
+++ b/polkadot/runtime/parachains/src/assigner_on_demand/migration.rs
@@ -143,7 +143,7 @@ pub type MigrateV0ToV1<T> = VersionedMigration<
 mod tests {
 	use super::{v0, v1, UncheckedOnRuntimeUpgrade, Weight};
 	use crate::mock::{new_test_ext, MockGenesisConfig, OnDemandAssigner, Test};
-	use primitives::Id as ParaId;
+	use polkadot_primitives::Id as ParaId;
 
 	#[test]
 	fn migration_to_v1_preserves_queue_ordering() {
diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs b/polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs
index f8d1a894f0e4d5c619377ba4c34158c8f6d60597..d2a7a221587da1c9d76f18a0a64042c7992e1623 100644
--- a/polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs
+++ b/polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs
@@ -25,7 +25,7 @@ use crate::{
 	paras::{ParaGenesisArgs, ParaKind},
 };
 
-use primitives::{Balance, HeadData, ValidationCode};
+use polkadot_primitives::{Balance, HeadData, ValidationCode};
 
 fn default_genesis_config() -> MockGenesisConfig {
 	MockGenesisConfig {
diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/mod.rs b/polkadot/runtime/parachains/src/assigner_on_demand/mod.rs
index 37788a67ea0c46d6c75b45039d994b8e40641e1c..043a36d99c4974c5dd75f3f4172848a4707c871a 100644
--- a/polkadot/runtime/parachains/src/assigner_on_demand/mod.rs
+++ b/polkadot/runtime/parachains/src/assigner_on_demand/mod.rs
@@ -53,7 +53,7 @@ use frame_support::{
 	},
 };
 use frame_system::pallet_prelude::*;
-use primitives::{CoreIndex, Id as ParaId, ON_DEMAND_MAX_QUEUE_MAX_SIZE};
+use polkadot_primitives::{CoreIndex, Id as ParaId, ON_DEMAND_MAX_QUEUE_MAX_SIZE};
 use sp_runtime::{
 	traits::{One, SaturatedConversion},
 	FixedPointNumber, FixedPointOperand, FixedU128, Perbill, Saturating,
@@ -173,7 +173,7 @@ impl QueueStatusType {
 	fn consume_index(&mut self, removed_index: QueueIndex) {
 		if removed_index != self.smallest_index {
 			self.freed_indices.push(removed_index.reverse());
-			return
+			return;
 		}
 		let mut index = self.smallest_index.0.overflowing_add(1).0;
 		// Even more to advance?
@@ -368,10 +368,10 @@ pub mod pallet {
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
-		/// An order was placed at some spot price amount.
-		OnDemandOrderPlaced { para_id: ParaId, spot_price: BalanceOf<T> },
-		/// The value of the spot traffic multiplier changed.
-		SpotTrafficSet { traffic: FixedU128 },
+		/// An order was placed at some spot price amount by orderer ordered_by
+		OnDemandOrderPlaced { para_id: ParaId, spot_price: BalanceOf<T>, ordered_by: T::AccountId },
+		/// The value of the spot price has likely changed
+		SpotPriceSet { spot_price: BalanceOf<T> },
 	}
 
 	#[pallet::error]
@@ -410,12 +410,11 @@ pub mod pallet {
 		///
 		/// Errors:
 		/// - `InsufficientBalance`: from the Currency implementation
-		/// - `InvalidParaId`
 		/// - `QueueFull`
 		/// - `SpotPriceHigherThanMaxAmount`
 		///
 		/// Events:
-		/// - `SpotOrderPlaced`
+		/// - `OnDemandOrderPlaced`
 		#[pallet::call_index(0)]
 		#[pallet::weight(<T as Config>::WeightInfo::place_order_allow_death(QueueStatus::<T>::get().size()))]
 		pub fn place_order_allow_death(
@@ -437,12 +436,11 @@ pub mod pallet {
 		///
 		/// Errors:
 		/// - `InsufficientBalance`: from the Currency implementation
-		/// - `InvalidParaId`
 		/// - `QueueFull`
 		/// - `SpotPriceHigherThanMaxAmount`
 		///
 		/// Events:
-		/// - `SpotOrderPlaced`
+		/// - `OnDemandOrderPlaced`
 		#[pallet::call_index(1)]
 		#[pallet::weight(<T as Config>::WeightInfo::place_order_keep_alive(QueueStatus::<T>::get().size()))]
 		pub fn place_order_keep_alive(
@@ -539,12 +537,11 @@ where
 	///
 	/// Errors:
 	/// - `InsufficientBalance`: from the Currency implementation
-	/// - `InvalidParaId`
 	/// - `QueueFull`
 	/// - `SpotPriceHigherThanMaxAmount`
 	///
 	/// Events:
-	/// - `SpotOrderPlaced`
+	/// - `OnDemandOrderPlaced`
 	fn do_place_order(
 		sender: <T as frame_system::Config>::AccountId,
 		max_amount: BalanceOf<T>,
@@ -578,6 +575,12 @@ where
 				Error::<T>::QueueFull
 			);
 			Pallet::<T>::add_on_demand_order(queue_status, para_id, QueuePushDirection::Back);
+			Pallet::<T>::deposit_event(Event::<T>::OnDemandOrderPlaced {
+				para_id,
+				spot_price,
+				ordered_by: sender,
+			});
+
 			Ok(())
 		})
 	}
@@ -599,7 +602,14 @@ where
 				// Only update storage on change
 				if new_traffic != old_traffic {
 					queue_status.traffic = new_traffic;
-					Pallet::<T>::deposit_event(Event::<T>::SpotTrafficSet { traffic: new_traffic });
+
+					// calculate the new spot price
+					let spot_price: BalanceOf<T> = new_traffic.saturating_mul_int(
+						config.scheduler_params.on_demand_base_fee.saturated_into::<BalanceOf<T>>(),
+					);
+
+					// emit the event for updated new price
+					Pallet::<T>::deposit_event(Event::<T>::SpotPriceSet { spot_price });
 				}
 			},
 			Err(err) => {
@@ -721,7 +731,7 @@ where
 			"Decreased affinity for a para that has not been served on a core?"
 		);
 		if affinity != Some(0) {
-			return
+			return;
 		}
 		// No affinity more for entries on this core, free any entries:
 		//
@@ -754,7 +764,7 @@ where
 				} else {
 					*maybe_affinity = None;
 				}
-				return Some(new_count)
+				return Some(new_count);
 			} else {
 				None
 			}
diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/tests.rs b/polkadot/runtime/parachains/src/assigner_on_demand/tests.rs
index 982efe77b939cf64d355e1111606c3856c4a0aea..5747413e71478eeb5b65984b58c3fe35beecadab 100644
--- a/polkadot/runtime/parachains/src/assigner_on_demand/tests.rs
+++ b/polkadot/runtime/parachains/src/assigner_on_demand/tests.rs
@@ -27,7 +27,7 @@ use crate::{
 };
 use frame_support::{assert_noop, assert_ok, error::BadOrigin};
 use pallet_balances::Error as BalancesError;
-use primitives::{BlockNumber, SessionIndex, ValidationCode};
+use polkadot_primitives::{BlockNumber, SessionIndex, ValidationCode};
 use sp_std::collections::btree_map::BTreeMap;
 
 fn schedule_blank_para(id: ParaId, parakind: ParaKind) {
@@ -77,7 +77,7 @@ fn run_to_block(
 		OnDemandAssigner::on_initialize(b + 1);
 
 		// In the real runtime this is expected to be called by the `InclusionInherent` pallet.
-		Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1);
+		Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1);
 	}
 }
 
diff --git a/polkadot/runtime/parachains/src/assigner_parachains.rs b/polkadot/runtime/parachains/src/assigner_parachains.rs
index e79facd1fef0856ba7933b1d03901e2e0d397b12..3c735b999cf2313b01150cb64832d0a394ce542e 100644
--- a/polkadot/runtime/parachains/src/assigner_parachains.rs
+++ b/polkadot/runtime/parachains/src/assigner_parachains.rs
@@ -23,7 +23,7 @@ mod mock_helpers;
 mod tests;
 
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::CoreIndex;
+use polkadot_primitives::CoreIndex;
 
 use crate::{
 	configuration, paras,
@@ -59,7 +59,7 @@ impl<T: Config> AssignmentProvider<BlockNumberFor<T>> for Pallet<T> {
 	fn push_back_assignment(_: Assignment) {}
 
 	#[cfg(any(feature = "runtime-benchmarks", test))]
-	fn get_mock_assignment(_: CoreIndex, para_id: primitives::Id) -> Assignment {
+	fn get_mock_assignment(_: CoreIndex, para_id: polkadot_primitives::Id) -> Assignment {
 		Assignment::Bulk(para_id)
 	}
 
diff --git a/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs b/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs
index a46e114daeaf458fb6bc985a5bb2ebad951d7e3b..d984fd9232c33a0eb12a09586ba349a3c57db493 100644
--- a/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs
+++ b/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs
@@ -21,7 +21,7 @@ use crate::{
 	paras::{ParaGenesisArgs, ParaKind},
 };
 
-use primitives::{Balance, HeadData, ValidationCode};
+use polkadot_primitives::{Balance, HeadData, ValidationCode};
 use sp_runtime::Perbill;
 
 fn default_genesis_config() -> MockGenesisConfig {
@@ -40,7 +40,7 @@ pub struct GenesisConfigBuilder {
 	pub on_demand_fee_variability: Perbill,
 	pub on_demand_max_queue_size: u32,
 	pub on_demand_target_queue_utilization: Perbill,
-	pub onboarded_on_demand_chains: Vec<primitives::Id>,
+	pub onboarded_on_demand_chains: Vec<polkadot_primitives::Id>,
 }
 
 impl Default for GenesisConfigBuilder {
diff --git a/polkadot/runtime/parachains/src/assigner_parachains/tests.rs b/polkadot/runtime/parachains/src/assigner_parachains/tests.rs
index a110686aaeb08d6bcbb77c0bf42ba2ef4ab7adbf..14cb1a8978602b6273243ec463dfa36eb7b7c80c 100644
--- a/polkadot/runtime/parachains/src/assigner_parachains/tests.rs
+++ b/polkadot/runtime/parachains/src/assigner_parachains/tests.rs
@@ -24,7 +24,7 @@ use crate::{
 	paras::{ParaGenesisArgs, ParaKind},
 };
 use frame_support::{assert_ok, pallet_prelude::*};
-use primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode};
+use polkadot_primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode};
 use sp_std::collections::btree_map::BTreeMap;
 
 fn schedule_blank_para(id: ParaId, parakind: ParaKind) {
@@ -71,7 +71,7 @@ fn run_to_block(
 		Scheduler::initializer_initialize(b + 1);
 
 		// In the real runtime this is expected to be called by the `InclusionInherent` pallet.
-		Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1);
+		Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1);
 	}
 }
 
diff --git a/polkadot/runtime/parachains/src/builder.rs b/polkadot/runtime/parachains/src/builder.rs
index d1e2bc392febe67deeda2f545387665435e42eaa..c046526ba372b537d48fac8d7be65e97a6b846f9 100644
--- a/polkadot/runtime/parachains/src/builder.rs
+++ b/polkadot/runtime/parachains/src/builder.rs
@@ -24,7 +24,7 @@ use crate::{
 use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec};
 use frame_support::pallet_prelude::*;
 use frame_system::pallet_prelude::*;
-use primitives::{
+use polkadot_primitives::{
 	collator_signature_payload, node_features::FeatureIndex, AvailabilityBitfield, BackedCandidate,
 	CandidateCommitments, CandidateDescriptor, CandidateHash, CollatorId, CollatorSignature,
 	CommittedCandidateReceipt, CompactStatement, CoreIndex, DisputeStatement, DisputeStatementSet,
@@ -92,11 +92,17 @@ pub(crate) struct BenchBuilder<T: paras_inherent::Config> {
 	/// will correspond to core index 3. There must be one entry for each core with a dispute
 	/// statement set.
 	dispute_sessions: Vec<u32>,
+	/// Paras here will both be backed in the inherent data and already occupying a core (which is
+	/// freed via bitfields).
+	///
 	/// Map from para id to number of validity votes. Core indices are generated based on
 	/// `elastic_paras` configuration. Each para id in `elastic_paras` gets the
 	/// specified amount of consecutive cores assigned to it. If a para id is not present
 	/// in `elastic_paras` it get assigned to a single core.
 	backed_and_concluding_paras: BTreeMap<u32, u32>,
+
+	/// Paras which don't yet occupy a core, but will after the inherent has been processed.
+	backed_in_inherent_paras: BTreeMap<u32, u32>,
 	/// Map from para id (seed) to number of chained candidates.
 	elastic_paras: BTreeMap<u32, u8>,
 	/// Make every candidate include a code upgrade by setting this to `Some` where the interior
@@ -132,6 +138,7 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 			dispute_statements: BTreeMap::new(),
 			dispute_sessions: Default::default(),
 			backed_and_concluding_paras: Default::default(),
+			backed_in_inherent_paras: Default::default(),
 			elastic_paras: Default::default(),
 			code_upgrade: None,
 			fill_claimqueue: true,
@@ -167,6 +174,12 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 		self
 	}
 
+	/// Set a map from para id seed to number of validity votes for votes in inherent data.
+	pub(crate) fn set_backed_in_inherent_paras(mut self, backed: BTreeMap<u32, u32>) -> Self {
+		self.backed_in_inherent_paras = backed;
+		self
+	}
+
 	/// Set a map from para id seed to number of cores assigned to it.
 	pub(crate) fn set_elastic_paras(mut self, elastic_paras: BTreeMap<u32, u8>) -> Self {
 		self.elastic_paras = elastic_paras;
@@ -753,8 +766,8 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 	///
 	/// Note that this API only allows building scenarios where the `backed_and_concluding_paras`
 	/// are mutually exclusive with the cores for disputes. So
-	/// `backed_and_concluding_paras.len() + dispute_sessions.len()` must be less than the max
-	/// number of cores.
+	/// `backed_and_concluding_paras.len() + dispute_sessions.len() + backed_in_inherent_paras` must
+	/// be less than the max number of cores.
 	pub(crate) fn build(self) -> Bench<T> {
 		// Make sure relevant storage is cleared. This is just to get the asserts to work when
 		// running tests because it seems the storage is not cleared in between.
@@ -771,8 +784,10 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 			.sum::<usize>()
 			.saturating_sub(self.elastic_paras.len() as usize);
 
-		let used_cores =
-			self.dispute_sessions.len() + self.backed_and_concluding_paras.len() + extra_cores;
+		let used_cores = self.dispute_sessions.len() +
+			self.backed_and_concluding_paras.len() +
+			self.backed_in_inherent_paras.len() +
+			extra_cores;
 
 		assert!(used_cores <= max_cores);
 		let fill_claimqueue = self.fill_claimqueue;
@@ -793,8 +808,12 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 			&builder.elastic_paras,
 			used_cores,
 		);
+
+		let mut backed_in_inherent = BTreeMap::new();
+		backed_in_inherent.append(&mut builder.backed_and_concluding_paras.clone());
+		backed_in_inherent.append(&mut builder.backed_in_inherent_paras.clone());
 		let backed_candidates = builder.create_backed_candidates(
-			&builder.backed_and_concluding_paras,
+			&backed_in_inherent,
 			&builder.elastic_paras,
 			builder.code_upgrade,
 		);
@@ -845,12 +864,16 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 		scheduler::AvailabilityCores::<T>::set(cores);
 
 		core_idx = 0u32;
+
+		// We need entries in the claim queue for those:
+		all_cores.append(&mut builder.backed_in_inherent_paras.clone());
+
 		if fill_claimqueue {
 			let cores = all_cores
 				.keys()
 				.flat_map(|para_id| {
 					(0..elastic_paras.get(&para_id).cloned().unwrap_or(1))
-						.filter_map(|_para_local_core_idx| {
+						.map(|_para_local_core_idx| {
 							let ttl = configuration::ActiveConfig::<T>::get().scheduler_params.ttl;
 							// Load an assignment into provider so that one is present to pop
 							let assignment =
@@ -859,17 +882,11 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
 									ParaId::from(*para_id),
 								);
 
-							let entry = (
-								CoreIndex(core_idx),
-								[ParasEntry::new(assignment, now + ttl)].into(),
-							);
-							let res = if builder.unavailable_cores.contains(&core_idx) {
-								None
-							} else {
-								Some(entry)
-							};
 							core_idx += 1;
-							res
+							(
+								CoreIndex(core_idx - 1),
+								[ParasEntry::new(assignment, now + ttl)].into(),
+							)
 						})
 						.collect::<Vec<(CoreIndex, VecDeque<ParasEntry<_>>)>>()
 				})
diff --git a/polkadot/runtime/parachains/src/configuration.rs b/polkadot/runtime/parachains/src/configuration.rs
index 34923897f02b38891ca7af122f48ee91988a483e..bffeab4a0d21b13d492550eeb0323624cc8c588c 100644
--- a/polkadot/runtime/parachains/src/configuration.rs
+++ b/polkadot/runtime/parachains/src/configuration.rs
@@ -19,13 +19,13 @@
 //! Configuration can change only at session boundaries and is buffered until then.
 
 use crate::{inclusion::MAX_UPWARD_MESSAGE_SIZE_BOUND, shared};
+use codec::{Decode, Encode};
 use frame_support::{pallet_prelude::*, DefaultNoBound};
 use frame_system::pallet_prelude::*;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_parachain_primitives::primitives::{
 	MAX_HORIZONTAL_MESSAGE_NUM, MAX_UPWARD_MESSAGE_NUM,
 };
-use primitives::{
+use polkadot_primitives::{
 	ApprovalVotingParams, AsyncBackingParams, Balance, ExecutorParamError, ExecutorParams,
 	NodeFeatures, SessionIndex, LEGACY_MIN_BACKING_VOTES, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE,
 	MAX_POV_SIZE, ON_DEMAND_MAX_QUEUE_MAX_SIZE,
@@ -42,7 +42,7 @@ mod benchmarking;
 pub mod migration;
 
 pub use pallet::*;
-use primitives::vstaging::SchedulerParams;
+use polkadot_primitives::vstaging::SchedulerParams;
 
 const LOG_TARGET: &str = "runtime::configuration";
 
@@ -335,6 +335,8 @@ pub enum InconsistentError<BlockNumber> {
 	InconsistentExecutorParams { inner: ExecutorParamError },
 	/// TTL should be bigger than lookahead
 	LookaheadExceedsTTL,
+	/// Lookahead is zero, while it must be at least 1 for parachains to work.
+	LookaheadZero,
 	/// Passed in queue size for on-demand was too large.
 	OnDemandQueueSizeTooLarge,
 	/// Number of delay tranches cannot be 0.
@@ -432,6 +434,10 @@ where
 			return Err(LookaheadExceedsTTL)
 		}
 
+		if self.scheduler_params.lookahead == 0 {
+			return Err(LookaheadZero)
+		}
+
 		if self.scheduler_params.on_demand_queue_max_size > ON_DEMAND_MAX_QUEUE_MAX_SIZE {
 			return Err(OnDemandQueueSizeTooLarge)
 		}
@@ -1276,7 +1282,7 @@ pub mod pallet {
 		fn integrity_test() {
 			assert_eq!(
 				&ActiveConfig::<T>::hashed_key(),
-				primitives::well_known_keys::ACTIVE_CONFIG,
+				polkadot_primitives::well_known_keys::ACTIVE_CONFIG,
 				"`well_known_keys::ACTIVE_CONFIG` doesn't match key of `ActiveConfig`! Make sure that the name of the\
 				 configuration pallet is `Configuration` in the runtime!",
 			);
diff --git a/polkadot/runtime/parachains/src/configuration/benchmarking.rs b/polkadot/runtime/parachains/src/configuration/benchmarking.rs
index 882b5aab096ad2f8227aa7ad0efaddfd2078c3ad..adc7f31a7b2913e020b3db5f7595de96abaac742 100644
--- a/polkadot/runtime/parachains/src/configuration/benchmarking.rs
+++ b/polkadot/runtime/parachains/src/configuration/benchmarking.rs
@@ -17,7 +17,7 @@
 use crate::configuration::*;
 use frame_benchmarking::{benchmarks, BenchmarkError, BenchmarkResult};
 use frame_system::RawOrigin;
-use primitives::{ExecutorParam, ExecutorParams, PvfExecKind, PvfPrepKind};
+use polkadot_primitives::{ExecutorParam, ExecutorParams, PvfExecKind, PvfPrepKind};
 use sp_runtime::traits::One;
 
 benchmarks! {
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v10.rs b/polkadot/runtime/parachains/src/configuration/migration/v10.rs
index fa72c357d7dab20dfee26fefa270e677f6b8549f..c53f58faaf03a8ca85d2d6ac3272425976e0f177 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v10.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v10.rs
@@ -23,7 +23,7 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{
+use polkadot_primitives::{
 	AsyncBackingParams, Balance, ExecutorParams, NodeFeatures, SessionIndex,
 	LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
 };
@@ -275,7 +275,7 @@ fn migrate_to_v10<T: Config>() -> Weight {
 mod tests {
 	use super::*;
 	use crate::mock::{new_test_ext, Test};
-	use primitives::LEGACY_MIN_BACKING_VOTES;
+	use polkadot_primitives::LEGACY_MIN_BACKING_VOTES;
 
 	#[test]
 	fn v10_deserialized_from_actual_data() {
@@ -304,7 +304,8 @@ mod tests {
 	];
 
 		let v10 =
-			V10HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
+			V10HostConfiguration::<polkadot_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
 
 		// We check only a sample of the values here. If we missed any fields or messed up data
 		// types that would skew all the fields coming after.
@@ -333,7 +334,7 @@ mod tests {
 		// We specify only the picked fields and the rest should be provided by the `Default`
 		// implementation. That implementation is copied over between the two types and should work
 		// fine.
-		let v9 = V9HostConfiguration::<primitives::BlockNumber> {
+		let v9 = V9HostConfiguration::<polkadot_primitives::BlockNumber> {
 			needed_approvals: 69,
 			paras_availability_period: 55,
 			hrmp_recipient_deposit: 1337,
@@ -368,7 +369,7 @@ mod tests {
 	// pallet's storage.
 	#[test]
 	fn test_migrate_to_v10_no_pending() {
-		let v9 = V9HostConfiguration::<primitives::BlockNumber>::default();
+		let v9 = V9HostConfiguration::<polkadot_primitives::BlockNumber>::default();
 
 		new_test_ext(Default::default()).execute_with(|| {
 			// Implant the v9 version in the state.
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v11.rs b/polkadot/runtime/parachains/src/configuration/migration/v11.rs
index 65656e8d7c065ac916dde9be670e8c3dfdbfc477..4d1bfc26196ca2ade0b904da2c9be4159b0a099e 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v11.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v11.rs
@@ -24,7 +24,7 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{
+use polkadot_primitives::{
 	ApprovalVotingParams, AsyncBackingParams, ExecutorParams, NodeFeatures, SessionIndex,
 	LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
 };
@@ -289,7 +289,7 @@ approval_voting_params                   : ApprovalVotingParams {
 
 #[cfg(test)]
 mod tests {
-	use primitives::LEGACY_MIN_BACKING_VOTES;
+	use polkadot_primitives::LEGACY_MIN_BACKING_VOTES;
 
 	use super::*;
 	use crate::mock::{new_test_ext, Test};
@@ -321,7 +321,8 @@ mod tests {
 	];
 
 		let v11 =
-			V11HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
+			V11HostConfiguration::<polkadot_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
 
 		// We check only a sample of the values here. If we missed any fields or messed up data
 		// types that would skew all the fields coming after.
@@ -348,7 +349,7 @@ mod tests {
 		// We specify only the picked fields and the rest should be provided by the `Default`
 		// implementation. That implementation is copied over between the two types and should work
 		// fine.
-		let v10 = V10HostConfiguration::<primitives::BlockNumber> {
+		let v10 = V10HostConfiguration::<polkadot_primitives::BlockNumber> {
 			needed_approvals: 69,
 			paras_availability_period: 55,
 			hrmp_recipient_deposit: 1337,
@@ -424,7 +425,7 @@ mod tests {
 	// pallet's storage.
 	#[test]
 	fn test_migrate_to_v11_no_pending() {
-		let v10 = V10HostConfiguration::<primitives::BlockNumber>::default();
+		let v10 = V10HostConfiguration::<polkadot_primitives::BlockNumber>::default();
 
 		new_test_ext(Default::default()).execute_with(|| {
 			// Implant the v10 version in the state.
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v12.rs b/polkadot/runtime/parachains/src/configuration/migration/v12.rs
index 69bacc83d044670ed65c9b168c07ae9acca508a5..126597ed845447c059eebb28b230e988db5ac77d 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v12.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v12.rs
@@ -23,7 +23,7 @@ use frame_support::{
 	traits::{Defensive, UncheckedOnRuntimeUpgrade},
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::vstaging::SchedulerParams;
+use polkadot_primitives::vstaging::SchedulerParams;
 use sp_core::Get;
 use sp_staking::SessionIndex;
 use sp_std::vec::Vec;
@@ -181,7 +181,7 @@ fn migrate_to_v12<T: Config>() -> Weight {
 
 #[cfg(test)]
 mod tests {
-	use primitives::LEGACY_MIN_BACKING_VOTES;
+	use polkadot_primitives::LEGACY_MIN_BACKING_VOTES;
 	use sp_arithmetic::Perbill;
 
 	use super::*;
@@ -214,7 +214,8 @@ mod tests {
 	];
 
 		let v12 =
-			V12HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
+			V12HostConfiguration::<polkadot_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
 
 		// We check only a sample of the values here. If we missed any fields or messed up data
 		// types that would skew all the fields coming after.
@@ -251,7 +252,7 @@ mod tests {
 		// We specify only the picked fields and the rest should be provided by the `Default`
 		// implementation. That implementation is copied over between the two types and should work
 		// fine.
-		let v11 = V11HostConfiguration::<primitives::BlockNumber> {
+		let v11 = V11HostConfiguration::<polkadot_primitives::BlockNumber> {
 			needed_approvals: 69,
 			paras_availability_period: 55,
 			hrmp_recipient_deposit: 1337,
@@ -334,7 +335,7 @@ mod tests {
 	// pallet's storage.
 	#[test]
 	fn test_migrate_to_v12_no_pending() {
-		let v11 = V11HostConfiguration::<primitives::BlockNumber>::default();
+		let v11 = V11HostConfiguration::<polkadot_primitives::BlockNumber>::default();
 
 		new_test_ext(Default::default()).execute_with(|| {
 			// Implant the v10 version in the state.
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v6.rs b/polkadot/runtime/parachains/src/configuration/migration/v6.rs
index 19031a90bab45c5c4cf58e50f07111db547365a6..bec41d3ea0dc51ec83ecce67f7373751cd7e2432 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v6.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v6.rs
@@ -21,11 +21,11 @@ use frame_support::pallet_prelude::*;
 use frame_system::pallet_prelude::BlockNumberFor;
 use sp_std::vec::Vec;
 
-use primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex};
+use polkadot_primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex};
 #[cfg(feature = "try-runtime")]
 use sp_std::prelude::*;
 
-#[derive(parity_scale_codec::Encode, parity_scale_codec::Decode, Debug, Clone)]
+#[derive(codec::Encode, codec::Decode, Debug, Clone)]
 pub struct V6HostConfiguration<BlockNumber> {
 	pub max_code_size: u32,
 	pub max_head_data_size: u32,
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v7.rs b/polkadot/runtime/parachains/src/configuration/migration/v7.rs
index 1754b78e0a1d3bd1d764f44352601fdf187b85b5..8fe4087cf9b170754e07f07175a3de1eac6ce216 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v7.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v7.rs
@@ -23,14 +23,14 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex};
+use polkadot_primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex};
 use sp_std::vec::Vec;
 
 use frame_support::traits::OnRuntimeUpgrade;
 
 use super::v6::V6HostConfiguration;
 
-#[derive(parity_scale_codec::Encode, parity_scale_codec::Decode, Debug, Clone)]
+#[derive(codec::Encode, codec::Decode, Debug, Clone)]
 pub struct V7HostConfiguration<BlockNumber> {
 	pub max_code_size: u32,
 	pub max_head_data_size: u32,
@@ -289,7 +289,8 @@ mod tests {
 		let raw_config = hex_literal::hex!["00003000005000005555150000008000fbff0100000200000a000000c80000006400000000000000000000000000500000c800000a0000000000000000c0220fca950300000000000000000000c0220fca9503000000000000000000e8030000009001000a0000000000000000900100008070000000000000000000000a000000050000000500000001000000010500000001c80000000600000058020000020000002800000000000000020000000100000001020000000f000000"];
 
 		let v6 =
-			V6HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
+			V6HostConfiguration::<polkadot_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
 
 		// We check only a sample of the values here. If we missed any fields or messed up data
 		// types that would skew all the fields coming after.
@@ -312,7 +313,7 @@ mod tests {
 		// We specify only the picked fields and the rest should be provided by the `Default`
 		// implementation. That implementation is copied over between the two types and should work
 		// fine.
-		let v6 = V6HostConfiguration::<primitives::BlockNumber> {
+		let v6 = V6HostConfiguration::<polkadot_primitives::BlockNumber> {
 			needed_approvals: 69,
 			thread_availability_period: 55,
 			hrmp_recipient_deposit: 1337,
@@ -390,7 +391,7 @@ mod tests {
 	// pallet's storage.
 	#[test]
 	fn test_migrate_to_v7_no_pending() {
-		let v6 = V6HostConfiguration::<primitives::BlockNumber>::default();
+		let v6 = V6HostConfiguration::<polkadot_primitives::BlockNumber>::default();
 
 		new_test_ext(Default::default()).execute_with(|| {
 			// Implant the v6 version in the state.
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v8.rs b/polkadot/runtime/parachains/src/configuration/migration/v8.rs
index 537dfa9abd77040f7017be6bd46150aa29bfef3c..0aa7f550b102afea143c762a70e2056f918d5bc8 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v8.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v8.rs
@@ -23,7 +23,7 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{
+use polkadot_primitives::{
 	AsyncBackingParams, Balance, ExecutorParams, SessionIndex, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
 };
 use sp_runtime::Perbill;
@@ -304,7 +304,8 @@ mod tests {
 	];
 
 		let v8 =
-			V8HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
+			V8HostConfiguration::<polkadot_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
 
 		// We check only a sample of the values here. If we missed any fields or messed up data
 		// types that would skew all the fields coming after.
@@ -329,7 +330,7 @@ mod tests {
 		// We specify only the picked fields and the rest should be provided by the `Default`
 		// implementation. That implementation is copied over between the two types and should work
 		// fine.
-		let v7 = V7HostConfiguration::<primitives::BlockNumber> {
+		let v7 = V7HostConfiguration::<polkadot_primitives::BlockNumber> {
 			needed_approvals: 69,
 			thread_availability_period: 55,
 			hrmp_recipient_deposit: 1337,
@@ -403,7 +404,7 @@ mod tests {
 	// pallet's storage.
 	#[test]
 	fn test_migrate_to_v8_no_pending() {
-		let v7 = V7HostConfiguration::<primitives::BlockNumber>::default();
+		let v7 = V7HostConfiguration::<polkadot_primitives::BlockNumber>::default();
 
 		new_test_ext(Default::default()).execute_with(|| {
 			// Implant the v6 version in the state.
diff --git a/polkadot/runtime/parachains/src/configuration/migration/v9.rs b/polkadot/runtime/parachains/src/configuration/migration/v9.rs
index ca4bbd9dacef3fb645c41a060798e0298a0efc27..6afdd3cec29efbb8988cfab5a79c712553b7b8aa 100644
--- a/polkadot/runtime/parachains/src/configuration/migration/v9.rs
+++ b/polkadot/runtime/parachains/src/configuration/migration/v9.rs
@@ -23,7 +23,7 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{
+use polkadot_primitives::{
 	AsyncBackingParams, Balance, ExecutorParams, SessionIndex, LEGACY_MIN_BACKING_VOTES,
 	ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
 };
@@ -308,7 +308,8 @@ mod tests {
 	];
 
 		let v9 =
-			V9HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
+			V9HostConfiguration::<polkadot_primitives::BlockNumber>::decode(&mut &raw_config[..])
+				.unwrap();
 
 		// We check only a sample of the values here. If we missed any fields or messed up data
 		// types that would skew all the fields coming after.
@@ -334,7 +335,7 @@ mod tests {
 		// We specify only the picked fields and the rest should be provided by the `Default`
 		// implementation. That implementation is copied over between the two types and should work
 		// fine.
-		let v8 = V8HostConfiguration::<primitives::BlockNumber> {
+		let v8 = V8HostConfiguration::<polkadot_primitives::BlockNumber> {
 			needed_approvals: 69,
 			paras_availability_period: 55,
 			hrmp_recipient_deposit: 1337,
@@ -408,7 +409,7 @@ mod tests {
 	// pallet's storage.
 	#[test]
 	fn test_migrate_to_v9_no_pending() {
-		let v8 = V8HostConfiguration::<primitives::BlockNumber>::default();
+		let v8 = V8HostConfiguration::<polkadot_primitives::BlockNumber>::default();
 
 		new_test_ext(Default::default()).execute_with(|| {
 			// Implant the v8 version in the state.
diff --git a/polkadot/runtime/parachains/src/configuration/tests.rs b/polkadot/runtime/parachains/src/configuration/tests.rs
index 64bbb8481fc1ba63ff8f851aa8b3d2ba5d6bd7df..dad8b6458e10ae16868d4354054ad80923f548d0 100644
--- a/polkadot/runtime/parachains/src/configuration/tests.rs
+++ b/polkadot/runtime/parachains/src/configuration/tests.rs
@@ -513,7 +513,7 @@ fn verify_externally_accessible() {
 	// This test verifies that the value can be accessed through the well known keys and the
 	// host configuration decodes into the abridged version.
 
-	use primitives::{well_known_keys, AbridgedHostConfiguration};
+	use polkadot_primitives::{well_known_keys, AbridgedHostConfiguration};
 
 	new_test_ext(Default::default()).execute_with(|| {
 		let mut ground_truth = HostConfiguration::default();
diff --git a/polkadot/runtime/parachains/src/coretime/migration.rs b/polkadot/runtime/parachains/src/coretime/migration.rs
index 6c8ddaa8aab30c702a4c13c25e3d1c571e6a79cf..3f82472da8aa4ed15d26230693a7ef7d3d586c79 100644
--- a/polkadot/runtime/parachains/src/coretime/migration.rs
+++ b/polkadot/runtime/parachains/src/coretime/migration.rs
@@ -27,6 +27,10 @@ mod v_coretime {
 		paras,
 	};
 	#[cfg(feature = "try-runtime")]
+	use codec::Decode;
+	#[cfg(feature = "try-runtime")]
+	use codec::Encode;
+	#[cfg(feature = "try-runtime")]
 	use frame_support::ensure;
 	use frame_support::{
 		traits::{OnRuntimeUpgrade, PalletInfoAccess, StorageVersion},
@@ -34,12 +38,8 @@ mod v_coretime {
 	};
 	use frame_system::pallet_prelude::BlockNumberFor;
 	use pallet_broker::{CoreAssignment, CoreMask, ScheduleItem};
-	#[cfg(feature = "try-runtime")]
-	use parity_scale_codec::Decode;
-	#[cfg(feature = "try-runtime")]
-	use parity_scale_codec::Encode;
 	use polkadot_parachain_primitives::primitives::IsSystem;
-	use primitives::{CoreIndex, Id as ParaId};
+	use polkadot_primitives::{CoreIndex, Id as ParaId};
 	use sp_arithmetic::traits::SaturatedConversion;
 	use sp_core::Get;
 	use sp_runtime::BoundedVec;
diff --git a/polkadot/runtime/parachains/src/coretime/mod.rs b/polkadot/runtime/parachains/src/coretime/mod.rs
index 33cbcb98fb29992a4eac77db9eb7def4088af16f..dedffb733d33ef120f6b220afc550f04b77f0979 100644
--- a/polkadot/runtime/parachains/src/coretime/mod.rs
+++ b/polkadot/runtime/parachains/src/coretime/mod.rs
@@ -24,7 +24,7 @@ use frame_support::{pallet_prelude::*, traits::Currency};
 use frame_system::pallet_prelude::*;
 pub use pallet::*;
 use pallet_broker::{CoreAssignment, CoreIndex as BrokerCoreIndex};
-use primitives::{CoreIndex, Id as ParaId};
+use polkadot_primitives::{CoreIndex, Id as ParaId};
 use sp_arithmetic::traits::SaturatedConversion;
 use xcm::prelude::{
 	send_xcm, Instruction, Junction, Location, OriginKind, SendXcm, WeightLimit, Xcm,
diff --git a/polkadot/runtime/parachains/src/disputes.rs b/polkadot/runtime/parachains/src/disputes.rs
index 62e02e67157d9e0e84de995dae18ee14143488a5..4a0f2390b45dc87b1e4eb3425ee430e0499d3895 100644
--- a/polkadot/runtime/parachains/src/disputes.rs
+++ b/polkadot/runtime/parachains/src/disputes.rs
@@ -20,17 +20,17 @@ use crate::{
 	configuration, initializer::SessionChangeNotification, metrics::METRICS, session_info,
 };
 use bitvec::{bitvec, order::Lsb0 as BitOrderLsb0};
+use codec::{Decode, Encode};
 use frame_support::{ensure, weights::Weight};
 use frame_system::pallet_prelude::*;
-use parity_scale_codec::{Decode, Encode};
-use polkadot_runtime_metrics::get_current_time;
-use primitives::{
+use polkadot_primitives::{
 	byzantine_threshold, supermajority_threshold, ApprovalVote, ApprovalVoteMultipleCandidates,
 	CandidateHash, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, CompactStatement,
 	ConsensusLog, DisputeState, DisputeStatement, DisputeStatementSet, ExplicitDisputeStatement,
 	InvalidDisputeStatementKind, MultiDisputeStatementSet, SessionIndex, SigningContext,
 	ValidDisputeStatementKind, ValidatorId, ValidatorIndex, ValidatorSignature,
 };
+use polkadot_runtime_metrics::get_current_time;
 use scale_info::TypeInfo;
 use sp_runtime::{
 	traits::{AppVerify, One, Saturating, Zero},
diff --git a/polkadot/runtime/parachains/src/disputes/migration.rs b/polkadot/runtime/parachains/src/disputes/migration.rs
index ccd367e41b36e619d246bcd2785ae771aeafdec3..e12edffb51b38d83e016d79dabe62c83ee20a098 100644
--- a/polkadot/runtime/parachains/src/disputes/migration.rs
+++ b/polkadot/runtime/parachains/src/disputes/migration.rs
@@ -24,7 +24,7 @@ pub mod v1 {
 	use frame_support::{
 		pallet_prelude::*, storage_alias, traits::OnRuntimeUpgrade, weights::Weight,
 	};
-	use primitives::SessionIndex;
+	use polkadot_primitives::SessionIndex;
 	use sp_std::prelude::*;
 
 	#[storage_alias]
diff --git a/polkadot/runtime/parachains/src/disputes/slashing.rs b/polkadot/runtime/parachains/src/disputes/slashing.rs
index a61d0c8998364c111f6e3a49fc03d5d39a5d76af..b50853ecc696c79d5d8b94cda6161f6d912c96f3 100644
--- a/polkadot/runtime/parachains/src/disputes/slashing.rs
+++ b/polkadot/runtime/parachains/src/disputes/slashing.rs
@@ -50,7 +50,7 @@ use frame_support::{
 };
 use frame_system::pallet_prelude::BlockNumberFor;
 
-use primitives::{
+use polkadot_primitives::{
 	slashing::{DisputeProof, DisputesTimeSlot, PendingSlashes, SlashingOffenceKind},
 	CandidateHash, SessionIndex, ValidatorId, ValidatorIndex,
 };
@@ -456,7 +456,8 @@ pub mod pallet {
 
 			let validator_set_count = key_owner_proof.validator_count() as ValidatorSetCount;
 			// check the membership proof to extract the offender's id
-			let key = (primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone());
+			let key =
+				(polkadot_primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone());
 			let offender = T::KeyOwnerProofSystem::check_proof(key, key_owner_proof)
 				.ok_or(Error::<T>::InvalidKeyOwnershipProof)?;
 
@@ -615,7 +616,7 @@ fn is_known_offence<T: Config>(
 	key_owner_proof: &T::KeyOwnerProof,
 ) -> Result<(), TransactionValidityError> {
 	// check the membership proof to extract the offender's id
-	let key = (primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone());
+	let key = (polkadot_primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone());
 
 	let offender = T::KeyOwnerProofSystem::check_proof(key, key_owner_proof.clone())
 		.ok_or(InvalidTransaction::BadProof)?;
diff --git a/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs b/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs
index 42a64725160c31746f9f1fe02b8239befd106a1e..b53f98caeea30cd2d55317eb59e705517ed07ec5 100644
--- a/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs
+++ b/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs
@@ -17,12 +17,12 @@
 use super::*;
 
 use crate::{disputes::SlashingHandler, initializer, shared};
+use codec::Decode;
 use frame_benchmarking::{benchmarks, whitelist_account};
 use frame_support::traits::{OnFinalize, OnInitialize};
 use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
 use pallet_staking::testing_utils::create_validators;
-use parity_scale_codec::Decode;
-use primitives::{Hash, PARACHAIN_KEY_TYPE_ID};
+use polkadot_primitives::{Hash, PARACHAIN_KEY_TYPE_ID};
 use sp_runtime::traits::{One, OpaqueKeys, StaticLookup};
 use sp_session::MembershipProof;
 
diff --git a/polkadot/runtime/parachains/src/disputes/tests.rs b/polkadot/runtime/parachains/src/disputes/tests.rs
index 16b4fa3a9f1a6b551cb94ff56dd3ba8ac53323f6..f505bf4625a6429db3aedce23f81bc3849b7baf6 100644
--- a/polkadot/runtime/parachains/src/disputes/tests.rs
+++ b/polkadot/runtime/parachains/src/disputes/tests.rs
@@ -29,7 +29,7 @@ use frame_support::{
 	traits::{OnFinalize, OnInitialize},
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::BlockNumber;
+use polkadot_primitives::BlockNumber;
 use sp_core::{crypto::CryptoType, Pair};
 
 const VOTE_FOR: VoteKind = VoteKind::ExplicitValid;
diff --git a/polkadot/runtime/parachains/src/dmp.rs b/polkadot/runtime/parachains/src/dmp.rs
index df2f93e194214c7bec474668f197ceaca53818ed..c0e1635ba1692c3f3d62a13bb686e95d3511bc0a 100644
--- a/polkadot/runtime/parachains/src/dmp.rs
+++ b/polkadot/runtime/parachains/src/dmp.rs
@@ -48,7 +48,7 @@ use crate::{
 };
 use frame_support::pallet_prelude::*;
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{DownwardMessage, Hash, Id as ParaId, InboundDownwardMessage};
+use polkadot_primitives::{DownwardMessage, Hash, Id as ParaId, InboundDownwardMessage};
 use sp_core::MAX_POSSIBLE_ALLOCATION;
 use sp_runtime::{
 	traits::{BlakeTwo256, Hash as HashT, SaturatedConversion},
diff --git a/polkadot/runtime/parachains/src/dmp/tests.rs b/polkadot/runtime/parachains/src/dmp/tests.rs
index f39d7ae167330be3a32b9454c449373515ac28bc..de15159581252aa29775addda7797d84abc4d115 100644
--- a/polkadot/runtime/parachains/src/dmp/tests.rs
+++ b/polkadot/runtime/parachains/src/dmp/tests.rs
@@ -19,10 +19,10 @@ use crate::{
 	configuration::ActiveConfig,
 	mock::{new_test_ext, Dmp, MockGenesisConfig, Paras, System, Test},
 };
+use codec::Encode;
 use frame_support::assert_ok;
 use hex_literal::hex;
-use parity_scale_codec::Encode;
-use primitives::BlockNumber;
+use polkadot_primitives::BlockNumber;
 
 pub(crate) fn run_to_block(to: BlockNumber, new_session: Option<Vec<BlockNumber>>) {
 	while System::block_number() < to {
@@ -210,7 +210,7 @@ fn queue_downward_message_critical() {
 #[test]
 fn verify_dmq_mqc_head_is_externally_accessible() {
 	use hex_literal::hex;
-	use primitives::well_known_keys;
+	use polkadot_primitives::well_known_keys;
 
 	let a = ParaId::from(2020);
 
diff --git a/polkadot/runtime/parachains/src/hrmp.rs b/polkadot/runtime/parachains/src/hrmp.rs
index 42a9c23e5aa1132c5f0ff4044b53df2407efdc1e..e34e4a03e711c3592f66a303fb8a2c4d37b64db8 100644
--- a/polkadot/runtime/parachains/src/hrmp.rs
+++ b/polkadot/runtime/parachains/src/hrmp.rs
@@ -18,11 +18,11 @@ use crate::{
 	configuration::{self, HostConfiguration},
 	dmp, ensure_parachain, initializer, paras,
 };
+use codec::{Decode, Encode};
 use frame_support::{pallet_prelude::*, traits::ReservableCurrency, DefaultNoBound};
 use frame_system::pallet_prelude::*;
-use parity_scale_codec::{Decode, Encode};
 use polkadot_parachain_primitives::primitives::{HorizontalMessages, IsSystem};
-use primitives::{
+use polkadot_primitives::{
 	Balance, Hash, HrmpChannelId, Id as ParaId, InboundHrmpMessage, OutboundHrmpMessage,
 	SessionIndex,
 };
@@ -1864,7 +1864,7 @@ impl<T: Config> Pallet<T> {
 	/// If the XCM version is unknown, the latest XCM version is used as a best effort.
 	fn wrap_notification(
 		mut notification: impl FnMut() -> xcm::opaque::latest::opaque::Xcm,
-	) -> impl FnOnce(ParaId) -> primitives::DownwardMessage {
+	) -> impl FnOnce(ParaId) -> polkadot_primitives::DownwardMessage {
 		use xcm::{
 			opaque::VersionedXcm,
 			prelude::{Junction, Location},
@@ -1892,7 +1892,7 @@ impl<T: Config> Pallet<T> {
 		log_label: &str,
 		config: &HostConfiguration<BlockNumberFor<T>>,
 		dest: ParaId,
-		notification_bytes_for: impl FnOnce(ParaId) -> primitives::DownwardMessage,
+		notification_bytes_for: impl FnOnce(ParaId) -> polkadot_primitives::DownwardMessage,
 	) {
 		// prepare notification
 		let notification_bytes = notification_bytes_for(dest);
diff --git a/polkadot/runtime/parachains/src/hrmp/tests.rs b/polkadot/runtime/parachains/src/hrmp/tests.rs
index acfaa8f2d290510d9d11ed85872c281e8b9c7d85..4fcbc69e98ad8e905afa5b18cd52dc526d6f0c67 100644
--- a/polkadot/runtime/parachains/src/hrmp/tests.rs
+++ b/polkadot/runtime/parachains/src/hrmp/tests.rs
@@ -28,7 +28,7 @@ use crate::{
 	shared,
 };
 use frame_support::{assert_noop, assert_ok, error::BadOrigin};
-use primitives::{BlockNumber, InboundDownwardMessage};
+use polkadot_primitives::{BlockNumber, InboundDownwardMessage};
 use std::collections::BTreeMap;
 
 pub(crate) fn run_to_block(to: BlockNumber, new_session: Option<Vec<BlockNumber>>) {
@@ -660,7 +660,7 @@ fn check_sent_messages() {
 
 #[test]
 fn verify_externally_accessible() {
-	use primitives::{well_known_keys, AbridgedHrmpChannel};
+	use polkadot_primitives::{well_known_keys, AbridgedHrmpChannel};
 
 	let para_a = 2020.into();
 	let para_b = 2021.into();
diff --git a/polkadot/runtime/parachains/src/inclusion/migration.rs b/polkadot/runtime/parachains/src/inclusion/migration.rs
index 5f35680ee694c45f519a1e31478c4aef0f7c19b9..a340d52643e05df356889a95186170c1e615480e 100644
--- a/polkadot/runtime/parachains/src/inclusion/migration.rs
+++ b/polkadot/runtime/parachains/src/inclusion/migration.rs
@@ -16,10 +16,10 @@ pub use v1::MigrateToV1;
 pub mod v0 {
 	use crate::inclusion::{Config, Pallet};
 	use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec};
+	use codec::{Decode, Encode};
 	use frame_support::{storage_alias, Twox64Concat};
 	use frame_system::pallet_prelude::BlockNumberFor;
-	use parity_scale_codec::{Decode, Encode};
-	use primitives::{
+	use polkadot_primitives::{
 		AvailabilityBitfield, CandidateCommitments, CandidateDescriptor, CandidateHash, CoreIndex,
 		GroupIndex, Id as ParaId, ValidatorIndex,
 	};
@@ -77,13 +77,13 @@ mod v1 {
 	use sp_core::Get;
 	use sp_std::{collections::vec_deque::VecDeque, vec::Vec};
 
+	#[cfg(feature = "try-runtime")]
+	use codec::{Decode, Encode};
 	#[cfg(feature = "try-runtime")]
 	use frame_support::{
 		ensure,
 		traits::{GetStorageVersion, StorageVersion},
 	};
-	#[cfg(feature = "try-runtime")]
-	use parity_scale_codec::{Decode, Encode};
 
 	pub struct VersionUncheckedMigrateToV1<T>(sp_std::marker::PhantomData<T>);
 
@@ -217,8 +217,10 @@ mod tests {
 		mock::{new_test_ext, MockGenesisConfig, Test},
 	};
 	use frame_support::traits::UncheckedOnRuntimeUpgrade;
-	use primitives::{AvailabilityBitfield, Id as ParaId};
-	use test_helpers::{dummy_candidate_commitments, dummy_candidate_descriptor, dummy_hash};
+	use polkadot_primitives::{AvailabilityBitfield, Id as ParaId};
+	use polkadot_primitives_test_helpers::{
+		dummy_candidate_commitments, dummy_candidate_descriptor, dummy_hash,
+	};
 
 	#[test]
 	fn migrate_to_v1() {
diff --git a/polkadot/runtime/parachains/src/inclusion/mod.rs b/polkadot/runtime/parachains/src/inclusion/mod.rs
index 31befefa32201b4bf343301c2956abcfbfb6a896..a86941a1a0b8e5d4f56eeb50ccf20a6dd81cc62c 100644
--- a/polkadot/runtime/parachains/src/inclusion/mod.rs
+++ b/polkadot/runtime/parachains/src/inclusion/mod.rs
@@ -28,6 +28,7 @@ use crate::{
 	util::make_persisted_validation_data_with_parent,
 };
 use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec};
+use codec::{Decode, Encode};
 use frame_support::{
 	defensive,
 	pallet_prelude::*,
@@ -36,8 +37,7 @@ use frame_support::{
 };
 use frame_system::pallet_prelude::*;
 use pallet_message_queue::OnQueueChanged;
-use parity_scale_codec::{Decode, Encode};
-use primitives::{
+use polkadot_primitives::{
 	effective_minimum_backing_votes, supermajority_threshold, well_known_keys, BackedCandidate,
 	CandidateCommitments, CandidateDescriptor, CandidateHash, CandidateReceipt,
 	CommittedCandidateReceipt, CoreIndex, GroupIndex, Hash, HeadData, Id as ParaId,
@@ -421,6 +421,7 @@ impl From<hrmp::OutboundHrmpAcceptanceErr> for AcceptanceCheckErr {
 /// An error returned by [`Pallet::check_upward_messages`] that indicates a violation of one of
 /// acceptance criteria rules.
 #[cfg_attr(test, derive(PartialEq))]
+#[allow(dead_code)]
 pub(crate) enum UmpAcceptanceCheckErr {
 	/// The maximal number of messages that can be submitted in one batch was exceeded.
 	MoreMessagesThanPermitted { sent: u32, permitted: u32 },
@@ -745,7 +746,7 @@ impl<T: Config> Pallet<T> {
 			backed_candidate.validator_indices_and_core_index(core_index_enabled);
 
 		// check the signatures in the backing and that it is a majority.
-		let maybe_amount_validated = primitives::check_candidate_backing(
+		let maybe_amount_validated = polkadot_primitives::check_candidate_backing(
 			backed_candidate.candidate().hash(),
 			backed_candidate.validity_votes(),
 			validator_indices,
@@ -794,7 +795,7 @@ impl<T: Config> Pallet<T> {
 	pub(crate) fn check_validation_outputs_for_runtime_api(
 		para_id: ParaId,
 		relay_parent_number: BlockNumberFor<T>,
-		validation_outputs: primitives::CandidateCommitments,
+		validation_outputs: polkadot_primitives::CandidateCommitments,
 	) -> bool {
 		let prev_context = paras::MostRecentContext::<T>::get(para_id);
 		let check_ctx = CandidateCheckContext::<T>::new(prev_context);
@@ -1318,11 +1319,11 @@ impl<T: Config> CandidateCheckContext<T> {
 		para_id: ParaId,
 		relay_parent_number: BlockNumberFor<T>,
 		head_data: &HeadData,
-		new_validation_code: &Option<primitives::ValidationCode>,
+		new_validation_code: &Option<polkadot_primitives::ValidationCode>,
 		processed_downward_messages: u32,
-		upward_messages: &[primitives::UpwardMessage],
+		upward_messages: &[polkadot_primitives::UpwardMessage],
 		hrmp_watermark: BlockNumberFor<T>,
-		horizontal_messages: &[primitives::OutboundHrmpMessage<ParaId>],
+		horizontal_messages: &[polkadot_primitives::OutboundHrmpMessage<ParaId>],
 	) -> Result<(), AcceptanceCheckErr> {
 		ensure!(
 			head_data.0.len() <= self.config.max_head_data_size as _,
diff --git a/polkadot/runtime/parachains/src/inclusion/tests.rs b/polkadot/runtime/parachains/src/inclusion/tests.rs
index c19bc6eb7bfc7eb8fcc13ad7de640990beeb4e40..18def664f4b284434a12e97d72e343d534721d37 100644
--- a/polkadot/runtime/parachains/src/inclusion/tests.rs
+++ b/polkadot/runtime/parachains/src/inclusion/tests.rs
@@ -25,24 +25,26 @@ use crate::{
 	paras_inherent::DisputedBitfield,
 	shared::AllowedRelayParentsTracker,
 };
-use primitives::{
+use polkadot_primitives::{
 	effective_minimum_backing_votes, AvailabilityBitfield, SignedAvailabilityBitfields,
 	UncheckedSignedAvailabilityBitfields,
 };
 
 use assert_matches::assert_matches;
+use codec::DecodeAll;
 use frame_support::assert_noop;
-use keyring::Sr25519Keyring;
-use parity_scale_codec::DecodeAll;
-use primitives::{
+use polkadot_primitives::{
 	BlockNumber, CandidateCommitments, CandidateDescriptor, CollatorId,
 	CompactStatement as Statement, Hash, SignedAvailabilityBitfield, SignedStatement,
 	ValidationCode, ValidatorId, ValidityAttestation, PARACHAIN_KEY_TYPE_ID,
 };
+use polkadot_primitives_test_helpers::{
+	dummy_collator, dummy_collator_signature, dummy_validation_code,
+};
 use sc_keystore::LocalKeystore;
+use sp_keyring::Sr25519Keyring;
 use sp_keystore::{Keystore, KeystorePtr};
 use std::sync::Arc;
-use test_helpers::{dummy_collator, dummy_collator_signature, dummy_validation_code};
 
 fn default_config() -> HostConfiguration<BlockNumber> {
 	let mut config = HostConfiguration::default();
@@ -100,7 +102,7 @@ pub(crate) fn collator_sign_candidate(
 ) {
 	candidate.descriptor.collator = collator.public().into();
 
-	let payload = primitives::collator_signature_payload(
+	let payload = polkadot_primitives::collator_signature_payload(
 		&candidate.descriptor.relay_parent,
 		&candidate.descriptor.para_id,
 		&candidate.descriptor.persisted_validation_data_hash,
@@ -158,7 +160,7 @@ pub(crate) fn back_candidate(
 	let backed =
 		BackedCandidate::new(candidate, validity_votes, validator_indices.clone(), core_index);
 
-	let successfully_backed = primitives::check_candidate_backing(
+	let successfully_backed = polkadot_primitives::check_candidate_backing(
 		backed.candidate().hash(),
 		backed.validity_votes(),
 		validator_indices.as_bitslice(),
diff --git a/polkadot/runtime/parachains/src/initializer.rs b/polkadot/runtime/parachains/src/initializer.rs
index 511d74421032e9e97028a90140189f97b1945599..fd0f1c3c065118f81821b0f8587335537421135d 100644
--- a/polkadot/runtime/parachains/src/initializer.rs
+++ b/polkadot/runtime/parachains/src/initializer.rs
@@ -25,13 +25,13 @@ use crate::{
 	disputes::{self, DisputesHandler as _, SlashingHandler as _},
 	dmp, hrmp, inclusion, paras, scheduler, session_info, shared,
 };
+use codec::{Decode, Encode};
 use frame_support::{
 	traits::{OneSessionHandler, Randomness},
 	weights::Weight,
 };
 use frame_system::limits::BlockWeights;
-use parity_scale_codec::{Decode, Encode};
-use primitives::{BlockNumber, ConsensusLog, SessionIndex, ValidatorId};
+use polkadot_primitives::{BlockNumber, ConsensusLog, SessionIndex, ValidatorId};
 use scale_info::TypeInfo;
 use sp_std::prelude::*;
 
diff --git a/polkadot/runtime/parachains/src/initializer/benchmarking.rs b/polkadot/runtime/parachains/src/initializer/benchmarking.rs
index ece41c726f04767fd7257cd8f016a209a9aecb66..2083c058fd04eb9bfcf7e1050275942bfbac9bb3 100644
--- a/polkadot/runtime/parachains/src/initializer/benchmarking.rs
+++ b/polkadot/runtime/parachains/src/initializer/benchmarking.rs
@@ -17,7 +17,7 @@
 use super::*;
 use frame_benchmarking::benchmarks;
 use frame_system::RawOrigin;
-use primitives::ConsensusLog;
+use polkadot_primitives::ConsensusLog;
 use sp_runtime::DigestItem;
 
 // Random large number for the digest
diff --git a/polkadot/runtime/parachains/src/initializer/tests.rs b/polkadot/runtime/parachains/src/initializer/tests.rs
index e757e6b9d1178121b2c500e292d9433a53c7e98d..a2bdb36eaa64f603f82f8d89e3d49469878bdc23 100644
--- a/polkadot/runtime/parachains/src/initializer/tests.rs
+++ b/polkadot/runtime/parachains/src/initializer/tests.rs
@@ -20,8 +20,8 @@ use crate::{
 	paras::ParaKind,
 	session_info,
 };
-use primitives::{HeadData, Id as ParaId};
-use test_helpers::dummy_validation_code;
+use polkadot_primitives::{HeadData, Id as ParaId};
+use polkadot_primitives_test_helpers::dummy_validation_code;
 
 use frame_support::{
 	assert_ok,
diff --git a/polkadot/runtime/parachains/src/lib.rs b/polkadot/runtime/parachains/src/lib.rs
index 97d6ab74904d5283bc60524adeaa1fab02a71f17..51110e89416c373efb1a5226a812ae6ab9f88431 100644
--- a/polkadot/runtime/parachains/src/lib.rs
+++ b/polkadot/runtime/parachains/src/lib.rs
@@ -55,7 +55,7 @@ mod ump_tests;
 
 pub use origin::{ensure_parachain, Origin};
 pub use paras::{ParaLifecycle, UpgradeStrategy};
-use primitives::{HeadData, Id as ParaId, ValidationCode};
+use polkadot_primitives::{HeadData, Id as ParaId, ValidationCode};
 use sp_runtime::{DispatchResult, FixedU128};
 
 /// Trait for tracking message delivery fees on a transport protocol.
@@ -86,7 +86,7 @@ pub fn schedule_para_initialize<T: paras::Config>(
 }
 
 /// Schedule a para to be cleaned up at the start of the next session.
-pub fn schedule_para_cleanup<T: paras::Config>(id: primitives::Id) -> Result<(), ()> {
+pub fn schedule_para_cleanup<T: paras::Config>(id: polkadot_primitives::Id) -> Result<(), ()> {
 	paras::Pallet::<T>::schedule_para_cleanup(id).map_err(|_| ())
 }
 
diff --git a/polkadot/runtime/parachains/src/metrics.rs b/polkadot/runtime/parachains/src/metrics.rs
index 023bd09f83a82577662eff7c2d95b82b39411dd3..7a17aafabd12d75b1e7cac6822d8430a07cdf3df 100644
--- a/polkadot/runtime/parachains/src/metrics.rs
+++ b/polkadot/runtime/parachains/src/metrics.rs
@@ -16,13 +16,13 @@
 
 //! Runtime declaration of the parachain metrics.
 
-use polkadot_runtime_metrics::{Counter, CounterVec, Histogram};
-use primitives::metric_definitions::{
+use polkadot_primitives::metric_definitions::{
 	PARACHAIN_CREATE_INHERENT_BITFIELDS_SIGNATURE_CHECKS,
 	PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED, PARACHAIN_INHERENT_DATA_CANDIDATES_PROCESSED,
 	PARACHAIN_INHERENT_DATA_DISPUTE_SETS_PROCESSED, PARACHAIN_INHERENT_DATA_WEIGHT,
 	PARACHAIN_VERIFY_DISPUTE_SIGNATURE,
 };
+use polkadot_runtime_metrics::{Counter, CounterVec, Histogram};
 
 pub struct Metrics {
 	/// Samples inherent data weight.
diff --git a/polkadot/runtime/parachains/src/mock.rs b/polkadot/runtime/parachains/src/mock.rs
index a32c9d11b36e737e436d998ebddea1e5d38143b2..18722ff463cf2398a209bf5589d5acea3283ac84 100644
--- a/polkadot/runtime/parachains/src/mock.rs
+++ b/polkadot/runtime/parachains/src/mock.rs
@@ -27,8 +27,9 @@ use crate::{
 	session_info, shared, ParaId,
 };
 use frame_support::pallet_prelude::*;
-use primitives::CoreIndex;
+use polkadot_primitives::CoreIndex;
 
+use codec::Decode;
 use frame_support::{
 	assert_ok, derive_impl, parameter_types,
 	traits::{
@@ -38,8 +39,7 @@ use frame_support::{
 };
 use frame_support_test::TestRandomness;
 use frame_system::limits;
-use parity_scale_codec::Decode;
-use primitives::{
+use polkadot_primitives::{
 	AuthorityDiscoveryId, Balance, BlockNumber, CandidateHash, Moment, SessionIndex, UpwardMessage,
 	ValidationCode, ValidatorIndex,
 };
@@ -100,7 +100,6 @@ where
 }
 
 parameter_types! {
-	pub const BlockHashCount: u32 = 250;
 	pub static BlockWeights: frame_system::limits::BlockWeights =
 		frame_system::limits::BlockWeights::simple_max(
 			Weight::from_parts(4 * 1024 * 1024, u64::MAX),
@@ -125,7 +124,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<u64>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u128>;
@@ -141,20 +139,11 @@ parameter_types! {
 	pub static ExistentialDeposit: u64 = 1;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 parameter_types! {
diff --git a/polkadot/runtime/parachains/src/origin.rs b/polkadot/runtime/parachains/src/origin.rs
index c83fec1b8923ad9048d1425e4de570c17fce5742..5202cba232d20a9f4303747f55c50ce144a0d68f 100644
--- a/polkadot/runtime/parachains/src/origin.rs
+++ b/polkadot/runtime/parachains/src/origin.rs
@@ -16,7 +16,7 @@
 
 //! Declaration of the parachain specific origin and a pallet that hosts it.
 
-use primitives::Id as ParaId;
+use polkadot_primitives::Id as ParaId;
 use sp_runtime::traits::BadOrigin;
 use sp_std::result;
 
diff --git a/polkadot/runtime/parachains/src/paras/benchmarking.rs b/polkadot/runtime/parachains/src/paras/benchmarking.rs
index 437c4091a98b58049a7cb3204f35079be8395ce0..0f3318612a77c7bc2ec831e2c7ac67c08eae0392 100644
--- a/polkadot/runtime/parachains/src/paras/benchmarking.rs
+++ b/polkadot/runtime/parachains/src/paras/benchmarking.rs
@@ -18,7 +18,9 @@ use super::*;
 use crate::configuration::HostConfiguration;
 use frame_benchmarking::benchmarks;
 use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
-use primitives::{HeadData, Id as ParaId, ValidationCode, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE};
+use polkadot_primitives::{
+	HeadData, Id as ParaId, ValidationCode, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE,
+};
 use sp_runtime::traits::{One, Saturating};
 
 mod pvf_check;
diff --git a/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs b/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs
index 9281332fdada8fa6078100586be9329430623fd4..0bf5fe783a0e7bc51e473240f87bcdb7692e5414 100644
--- a/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs
+++ b/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs
@@ -19,7 +19,7 @@
 use crate::{configuration, paras::*, shared::Pallet as ParasShared};
 use frame_support::assert_ok;
 use frame_system::RawOrigin;
-use primitives::{HeadData, Id as ParaId, ValidationCode, ValidatorId, ValidatorIndex};
+use polkadot_primitives::{HeadData, Id as ParaId, ValidationCode, ValidatorId, ValidatorIndex};
 use sp_application_crypto::RuntimeAppPublic;
 
 // Constants for the benchmarking
@@ -204,7 +204,7 @@ where
 {
 	let validators = shared::ActiveValidatorKeys::<T>::get();
 
-	let accept_threshold = primitives::supermajority_threshold(validators.len());
+	let accept_threshold = polkadot_primitives::supermajority_threshold(validators.len());
 	let required_votes = match vote_outcome {
 		VoteOutcome::Accept => accept_threshold,
 		VoteOutcome::Reject => validators.len() - accept_threshold,
diff --git a/polkadot/runtime/parachains/src/paras/mod.rs b/polkadot/runtime/parachains/src/paras/mod.rs
index 36a693bcc8e29a7a2cbce1cb75a430322b88b58b..8cffcbbbb024fd454f57ed89c7448ffc297e0977 100644
--- a/polkadot/runtime/parachains/src/paras/mod.rs
+++ b/polkadot/runtime/parachains/src/paras/mod.rs
@@ -114,10 +114,10 @@ use crate::{
 	shared,
 };
 use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec};
+use codec::{Decode, Encode};
 use frame_support::{pallet_prelude::*, traits::EstimateNextSessionRotation, DefaultNoBound};
 use frame_system::pallet_prelude::*;
-use parity_scale_codec::{Decode, Encode};
-use primitives::{
+use polkadot_primitives::{
 	ConsensusLog, HeadData, Id as ParaId, PvfCheckStatement, SessionIndex, UpgradeGoAhead,
 	UpgradeRestriction, ValidationCode, ValidationCodeHash, ValidatorSignature, MIN_CODE_SIZE,
 };
@@ -348,9 +348,7 @@ impl Encode for ParaKind {
 }
 
 impl Decode for ParaKind {
-	fn decode<I: parity_scale_codec::Input>(
-		input: &mut I,
-	) -> Result<Self, parity_scale_codec::Error> {
+	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
 		match bool::decode(input) {
 			Ok(true) => Ok(ParaKind::Parachain),
 			Ok(false) => Ok(ParaKind::Parathread),
@@ -487,7 +485,7 @@ impl<BlockNumber> PvfCheckActiveVoteState<BlockNumber> {
 
 	/// Returns `None` if the quorum is not reached, or the direction of the decision.
 	fn quorum(&self, n_validators: usize) -> Option<PvfCheckOutcome> {
-		let accept_threshold = primitives::supermajority_threshold(n_validators);
+		let accept_threshold = polkadot_primitives::supermajority_threshold(n_validators);
 		// At this threshold, a supermajority is no longer possible, so we reject.
 		let reject_threshold = n_validators - accept_threshold;
 
diff --git a/polkadot/runtime/parachains/src/paras/tests.rs b/polkadot/runtime/parachains/src/paras/tests.rs
index 0b458f2f91eb2db68fb5d56aa9c35df7c373e894..732b75417387ad549f87e9e091566b1734e35058 100644
--- a/polkadot/runtime/parachains/src/paras/tests.rs
+++ b/polkadot/runtime/parachains/src/paras/tests.rs
@@ -16,12 +16,12 @@
 
 use super::*;
 use frame_support::{assert_err, assert_ok, assert_storage_noop};
-use keyring::Sr25519Keyring;
-use primitives::{vstaging::SchedulerParams, BlockNumber, PARACHAIN_KEY_TYPE_ID};
+use polkadot_primitives::{vstaging::SchedulerParams, BlockNumber, PARACHAIN_KEY_TYPE_ID};
+use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code, validator_pubkeys};
 use sc_keystore::LocalKeystore;
+use sp_keyring::Sr25519Keyring;
 use sp_keystore::{Keystore, KeystorePtr};
 use std::sync::Arc;
-use test_helpers::{dummy_head_data, dummy_validation_code, validator_pubkeys};
 
 use crate::{
 	configuration::HostConfiguration,
@@ -135,7 +135,10 @@ fn check_code_is_not_stored(validation_code: &ValidationCode) {
 /// An utility for checking that certain events were deposited.
 struct EventValidator {
 	events: Vec<
-		frame_system::EventRecord<<Test as frame_system::Config>::RuntimeEvent, primitives::Hash>,
+		frame_system::EventRecord<
+			<Test as frame_system::Config>::RuntimeEvent,
+			polkadot_primitives::Hash,
+		>,
 	>,
 }
 
@@ -1810,7 +1813,7 @@ fn add_trusted_validation_code_enacts_existing_pvf_vote() {
 
 #[test]
 fn verify_upgrade_go_ahead_signal_is_externally_accessible() {
-	use primitives::well_known_keys;
+	use polkadot_primitives::well_known_keys;
 
 	let a = ParaId::from(2020);
 
@@ -1826,7 +1829,7 @@ fn verify_upgrade_go_ahead_signal_is_externally_accessible() {
 
 #[test]
 fn verify_upgrade_restriction_signal_is_externally_accessible() {
-	use primitives::well_known_keys;
+	use polkadot_primitives::well_known_keys;
 
 	let a = ParaId::from(2020);
 
@@ -1842,7 +1845,7 @@ fn verify_upgrade_restriction_signal_is_externally_accessible() {
 
 #[test]
 fn verify_para_head_is_externally_accessible() {
-	use primitives::well_known_keys;
+	use polkadot_primitives::well_known_keys;
 
 	let a = ParaId::from(2020);
 	let expected_head_data = HeadData(vec![0, 1, 2, 3]);
diff --git a/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs b/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs
index e643888ae29a1464a20130dc16dc756c95799949..4c8b093451ed5ac1e917ab980539bc8277374d70 100644
--- a/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs
+++ b/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs
@@ -20,7 +20,7 @@ use frame_benchmarking::{benchmarks, impl_benchmark_test_suite};
 use frame_system::RawOrigin;
 use sp_std::{cmp::min, collections::btree_map::BTreeMap};
 
-use primitives::v7::GroupIndex;
+use polkadot_primitives::v7::GroupIndex;
 
 use crate::builder::BenchBuilder;
 
@@ -110,7 +110,7 @@ benchmarks! {
 				.collect();
 
 		let scenario = BenchBuilder::<T>::new()
-			.set_backed_and_concluding_paras(cores_with_backed.clone())
+			.set_backed_in_inherent_paras(cores_with_backed.clone())
 			.build();
 
 		let mut benchmark = scenario.data.clone();
@@ -161,7 +161,7 @@ benchmarks! {
 				.collect();
 
 		let scenario = BenchBuilder::<T>::new()
-			.set_backed_and_concluding_paras(cores_with_backed.clone())
+			.set_backed_in_inherent_paras(cores_with_backed.clone())
 			.set_code_upgrade(v)
 			.build();
 
diff --git a/polkadot/runtime/parachains/src/paras_inherent/mod.rs b/polkadot/runtime/parachains/src/paras_inherent/mod.rs
index ac4cf5dc8d413397b6a740c6503f69e8d592e20d..8b527c09490d65c95d268e22d6be4a904d514e02 100644
--- a/polkadot/runtime/parachains/src/paras_inherent/mod.rs
+++ b/polkadot/runtime/parachains/src/paras_inherent/mod.rs
@@ -42,7 +42,7 @@ use frame_support::{
 };
 use frame_system::pallet_prelude::*;
 use pallet_babe::{self, ParentBlockRandomness};
-use primitives::{
+use polkadot_primitives::{
 	effective_minimum_backing_votes, node_features::FeatureIndex, BackedCandidate, CandidateHash,
 	CandidateReceipt, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, CoreIndex,
 	DisputeStatementSet, HeadData, InherentData as ParachainsInherentData,
@@ -560,7 +560,7 @@ impl<T: Config> Pallet<T> {
 			.chain(freed_disputed.into_iter().map(|core| (core, FreedReason::Concluded)))
 			.chain(freed_timeout.into_iter().map(|c| (c, FreedReason::TimedOut)))
 			.collect::<BTreeMap<CoreIndex, FreedReason>>();
-		scheduler::Pallet::<T>::free_cores_and_fill_claimqueue(freed, now);
+		scheduler::Pallet::<T>::free_cores_and_fill_claim_queue(freed, now);
 
 		METRICS.on_candidates_processed_total(backed_candidates.len() as u64);
 
@@ -570,12 +570,13 @@ impl<T: Config> Pallet<T> {
 			.map(|b| *b)
 			.unwrap_or(false);
 
-		let mut scheduled: BTreeMap<ParaId, BTreeSet<CoreIndex>> = BTreeMap::new();
-		let mut total_scheduled_cores = 0;
+		let mut eligible: BTreeMap<ParaId, BTreeSet<CoreIndex>> = BTreeMap::new();
+		let mut total_eligible_cores = 0;
 
-		for (core_idx, para_id) in scheduler::Pallet::<T>::scheduled_paras() {
-			total_scheduled_cores += 1;
-			scheduled.entry(para_id).or_default().insert(core_idx);
+		for (core_idx, para_id) in scheduler::Pallet::<T>::eligible_paras() {
+			total_eligible_cores += 1;
+			log::trace!(target: LOG_TARGET, "Found eligible para {:?} on core {:?}", para_id, core_idx);
+			eligible.entry(para_id).or_default().insert(core_idx);
 		}
 
 		let initial_candidate_count = backed_candidates.len();
@@ -583,12 +584,12 @@ impl<T: Config> Pallet<T> {
 			backed_candidates,
 			&allowed_relay_parents,
 			concluded_invalid_hashes,
-			scheduled,
+			eligible,
 			core_index_enabled,
 		);
 		let count = count_backed_candidates(&backed_candidates_with_core);
 
-		ensure!(count <= total_scheduled_cores, Error::<T>::UnscheduledCandidate);
+		ensure!(count <= total_eligible_cores, Error::<T>::UnscheduledCandidate);
 
 		METRICS.on_candidates_sanitized(count as u64);
 
@@ -1422,7 +1423,7 @@ fn map_candidates_to_cores<T: configuration::Config + scheduler::Config + inclus
 		} else {
 			log::debug!(
 				target: LOG_TARGET,
-				"Paraid: {:?} has no scheduled cores but {} candidates were supplied.",
+				"Paraid: {:?} has no entry in scheduled cores but {} candidates were supplied.",
 				para_id,
 				backed_candidates.len()
 			);
diff --git a/polkadot/runtime/parachains/src/paras_inherent/tests.rs b/polkadot/runtime/parachains/src/paras_inherent/tests.rs
index 64fbc9c4a4e0335a148ce55777b015ff6f99a11a..abf1c1a56b24b9ee27db011d4538d5864a10c556 100644
--- a/polkadot/runtime/parachains/src/paras_inherent/tests.rs
+++ b/polkadot/runtime/parachains/src/paras_inherent/tests.rs
@@ -20,7 +20,7 @@ use crate::{
 	configuration::{self, HostConfiguration},
 	mock::MockGenesisConfig,
 };
-use primitives::vstaging::SchedulerParams;
+use polkadot_primitives::vstaging::SchedulerParams;
 
 fn default_config() -> MockGenesisConfig {
 	MockGenesisConfig {
@@ -57,7 +57,7 @@ mod enter {
 	use core::panic;
 	use frame_support::assert_ok;
 	use frame_system::limits;
-	use primitives::{vstaging::SchedulerParams, AvailabilityBitfield, UncheckedSigned};
+	use polkadot_primitives::{vstaging::SchedulerParams, AvailabilityBitfield, UncheckedSigned};
 	use sp_runtime::Perbill;
 	use sp_std::collections::btree_map::BTreeMap;
 
@@ -166,7 +166,7 @@ mod enter {
 				.unwrap();
 
 			// The current schedule is empty prior to calling `create_inherent_enter`.
-			assert!(scheduler::Pallet::<Test>::claimqueue_is_empty());
+			assert!(scheduler::Pallet::<Test>::claim_queue_is_empty());
 
 			// Nothing is filtered out (including the backed candidates.)
 			assert_eq!(
@@ -257,7 +257,7 @@ mod enter {
 				.unwrap();
 
 			// The current schedule is empty prior to calling `create_inherent_enter`.
-			assert!(scheduler::Pallet::<Test>::claimqueue_is_empty());
+			assert!(scheduler::Pallet::<Test>::claim_queue_is_empty());
 
 			assert!(pallet::OnChainVotes::<Test>::get().is_none());
 
@@ -372,7 +372,7 @@ mod enter {
 			let mut inherent_data = InherentData::new();
 			inherent_data.put_data(PARACHAINS_INHERENT_IDENTIFIER, &scenario.data).unwrap();
 
-			assert!(!scheduler::Pallet::<Test>::claimqueue_is_empty());
+			assert!(!scheduler::Pallet::<Test>::claim_queue_is_empty());
 
 			// The right candidates have been filtered out (the ones for cores 0,4,5)
 			assert_eq!(
@@ -494,7 +494,7 @@ mod enter {
 	#[test]
 	fn test_session_is_tracked_in_on_chain_scraping() {
 		use crate::disputes::run_to_block;
-		use primitives::{
+		use polkadot_primitives::{
 			DisputeStatement, DisputeStatementSet, ExplicitDisputeStatement,
 			InvalidDisputeStatementKind, ValidDisputeStatementKind,
 		};
@@ -618,7 +618,7 @@ mod enter {
 				.unwrap();
 
 			// The current schedule is empty prior to calling `create_inherent_enter`.
-			assert!(scheduler::Pallet::<Test>::claimqueue_is_empty());
+			assert!(scheduler::Pallet::<Test>::claim_queue_is_empty());
 
 			let multi_dispute_inherent_data =
 				Pallet::<Test>::create_inherent_inner(&inherent_data.clone()).unwrap();
@@ -690,7 +690,7 @@ mod enter {
 				.unwrap();
 
 			// The current schedule is empty prior to calling `create_inherent_enter`.
-			assert!(scheduler::Pallet::<Test>::claimqueue_is_empty());
+			assert!(scheduler::Pallet::<Test>::claim_queue_is_empty());
 
 			let limit_inherent_data =
 				Pallet::<Test>::create_inherent_inner(&inherent_data.clone()).unwrap();
@@ -762,7 +762,7 @@ mod enter {
 				.unwrap();
 
 			// The current schedule is empty prior to calling `create_inherent_enter`.
-			assert!(scheduler::Pallet::<Test>::claimqueue_is_empty());
+			assert!(scheduler::Pallet::<Test>::claim_queue_is_empty());
 
 			// Nothing is filtered out (including the backed candidates.)
 			let limit_inherent_data =
@@ -849,7 +849,7 @@ mod enter {
 				.unwrap();
 
 			// The current schedule is empty prior to calling `create_inherent_enter`.
-			assert!(scheduler::Pallet::<Test>::claimqueue_is_empty());
+			assert!(scheduler::Pallet::<Test>::claim_queue_is_empty());
 
 			// Nothing is filtered out (including the backed candidates.)
 			let limit_inherent_data =
@@ -1467,8 +1467,8 @@ mod enter {
 	}
 }
 
-fn default_header() -> primitives::Header {
-	primitives::Header {
+fn default_header() -> polkadot_primitives::Header {
+	polkadot_primitives::Header {
 		parent_hash: Default::default(),
 		number: 0,
 		state_root: Default::default(),
@@ -1487,7 +1487,7 @@ mod sanitizers {
 		mock::new_test_ext,
 	};
 	use bitvec::order::Lsb0;
-	use primitives::{
+	use polkadot_primitives::{
 		AvailabilityBitfield, GroupIndex, Hash, Id as ParaId, SignedAvailabilityBitfield,
 		ValidatorIndex,
 	};
@@ -1495,13 +1495,13 @@ mod sanitizers {
 	use sp_core::crypto::UncheckedFrom;
 
 	use crate::mock::Test;
-	use keyring::Sr25519Keyring;
-	use primitives::PARACHAIN_KEY_TYPE_ID;
+	use polkadot_primitives::PARACHAIN_KEY_TYPE_ID;
 	use sc_keystore::LocalKeystore;
+	use sp_keyring::Sr25519Keyring;
 	use sp_keystore::{Keystore, KeystorePtr};
 	use std::sync::Arc;
 
-	fn validator_pubkeys(val_ids: &[keyring::Sr25519Keyring]) -> Vec<ValidatorId> {
+	fn validator_pubkeys(val_ids: &[sp_keyring::Sr25519Keyring]) -> Vec<ValidatorId> {
 		val_ids.iter().map(|v| v.public().into()).collect()
 	}
 
@@ -1518,10 +1518,10 @@ mod sanitizers {
 		let signing_context = SigningContext { parent_hash, session_index };
 
 		let validators = vec![
-			keyring::Sr25519Keyring::Alice,
-			keyring::Sr25519Keyring::Bob,
-			keyring::Sr25519Keyring::Charlie,
-			keyring::Sr25519Keyring::Dave,
+			sp_keyring::Sr25519Keyring::Alice,
+			sp_keyring::Sr25519Keyring::Bob,
+			sp_keyring::Sr25519Keyring::Charlie,
+			sp_keyring::Sr25519Keyring::Dave,
 		];
 		for validator in validators.iter() {
 			Keystore::sr25519_generate_new(
@@ -1744,7 +1744,7 @@ mod sanitizers {
 			scheduler::{common::Assignment, ParasEntry},
 			util::{make_persisted_validation_data, make_persisted_validation_data_with_parent},
 		};
-		use primitives::ValidationCode;
+		use polkadot_primitives::ValidationCode;
 		use sp_std::collections::vec_deque::VecDeque;
 
 		use super::*;
@@ -1754,7 +1754,7 @@ mod sanitizers {
 			backed_candidates: Vec<BackedCandidate>,
 			expected_backed_candidates_with_core:
 				BTreeMap<ParaId, Vec<(BackedCandidate, CoreIndex)>>,
-			scheduled_paras: BTreeMap<primitives::Id, BTreeSet<CoreIndex>>,
+			scheduled_paras: BTreeMap<polkadot_primitives::Id, BTreeSet<CoreIndex>>,
 		}
 
 		// Generate test data for the candidates and assert that the environment is set as expected
@@ -1780,11 +1780,11 @@ mod sanitizers {
 			let signing_context = SigningContext { parent_hash: relay_parent, session_index };
 
 			let validators = vec![
-				keyring::Sr25519Keyring::Alice,
-				keyring::Sr25519Keyring::Bob,
-				keyring::Sr25519Keyring::Charlie,
-				keyring::Sr25519Keyring::Dave,
-				keyring::Sr25519Keyring::Eve,
+				sp_keyring::Sr25519Keyring::Alice,
+				sp_keyring::Sr25519Keyring::Bob,
+				sp_keyring::Sr25519Keyring::Charlie,
+				sp_keyring::Sr25519Keyring::Dave,
+				sp_keyring::Sr25519Keyring::Eve,
 			];
 			for validator in validators.iter() {
 				Keystore::sr25519_generate_new(
@@ -1818,7 +1818,7 @@ mod sanitizers {
 			]);
 
 			// Update scheduler's claimqueue with the parachains
-			scheduler::Pallet::<Test>::set_claimqueue(BTreeMap::from([
+			scheduler::Pallet::<Test>::set_claim_queue(BTreeMap::from([
 				(
 					CoreIndex::from(0),
 					VecDeque::from([ParasEntry::new(
@@ -1965,14 +1965,14 @@ mod sanitizers {
 			let signing_context = SigningContext { parent_hash: relay_parent, session_index };
 
 			let validators = vec![
-				keyring::Sr25519Keyring::Alice,
-				keyring::Sr25519Keyring::Bob,
-				keyring::Sr25519Keyring::Charlie,
-				keyring::Sr25519Keyring::Dave,
-				keyring::Sr25519Keyring::Eve,
-				keyring::Sr25519Keyring::Ferdie,
-				keyring::Sr25519Keyring::One,
-				keyring::Sr25519Keyring::Two,
+				sp_keyring::Sr25519Keyring::Alice,
+				sp_keyring::Sr25519Keyring::Bob,
+				sp_keyring::Sr25519Keyring::Charlie,
+				sp_keyring::Sr25519Keyring::Dave,
+				sp_keyring::Sr25519Keyring::Eve,
+				sp_keyring::Sr25519Keyring::Ferdie,
+				sp_keyring::Sr25519Keyring::One,
+				sp_keyring::Sr25519Keyring::Two,
 			];
 			for validator in validators.iter() {
 				Keystore::sr25519_generate_new(
@@ -2001,7 +2001,7 @@ mod sanitizers {
 			]);
 
 			// Update scheduler's claimqueue with the parachains
-			scheduler::Pallet::<Test>::set_claimqueue(BTreeMap::from([
+			scheduler::Pallet::<Test>::set_claim_queue(BTreeMap::from([
 				(
 					CoreIndex::from(0),
 					VecDeque::from([ParasEntry::new(
@@ -2504,15 +2504,15 @@ mod sanitizers {
 			let signing_context = SigningContext { parent_hash: relay_parent, session_index };
 
 			let validators = vec![
-				keyring::Sr25519Keyring::Alice,
-				keyring::Sr25519Keyring::Bob,
-				keyring::Sr25519Keyring::Charlie,
-				keyring::Sr25519Keyring::Dave,
-				keyring::Sr25519Keyring::Eve,
-				keyring::Sr25519Keyring::Ferdie,
-				keyring::Sr25519Keyring::One,
-				keyring::Sr25519Keyring::Two,
-				keyring::Sr25519Keyring::AliceStash,
+				sp_keyring::Sr25519Keyring::Alice,
+				sp_keyring::Sr25519Keyring::Bob,
+				sp_keyring::Sr25519Keyring::Charlie,
+				sp_keyring::Sr25519Keyring::Dave,
+				sp_keyring::Sr25519Keyring::Eve,
+				sp_keyring::Sr25519Keyring::Ferdie,
+				sp_keyring::Sr25519Keyring::One,
+				sp_keyring::Sr25519Keyring::Two,
+				sp_keyring::Sr25519Keyring::AliceStash,
 			];
 			for validator in validators.iter() {
 				Keystore::sr25519_generate_new(
@@ -2542,7 +2542,7 @@ mod sanitizers {
 			]);
 
 			// Update scheduler's claimqueue with the parachains
-			scheduler::Pallet::<Test>::set_claimqueue(BTreeMap::from([
+			scheduler::Pallet::<Test>::set_claim_queue(BTreeMap::from([
 				(
 					CoreIndex::from(0),
 					VecDeque::from([ParasEntry::new(
diff --git a/polkadot/runtime/parachains/src/paras_inherent/weights.rs b/polkadot/runtime/parachains/src/paras_inherent/weights.rs
index 0f4e5be572a66d16c1476ada7671c495a27bbc83..37809396a82317eb2370c13d39acd60b1275154c 100644
--- a/polkadot/runtime/parachains/src/paras_inherent/weights.rs
+++ b/polkadot/runtime/parachains/src/paras_inherent/weights.rs
@@ -19,8 +19,8 @@
 //! the relay chain, but we do care about the size of the block, by putting the tx in the
 //! proof_size we can use the already existing weight limiting code to limit the used size as well.
 
-use parity_scale_codec::{Encode, WrapperTypeEncode};
-use primitives::{
+use codec::{Encode, WrapperTypeEncode};
+use polkadot_primitives::{
 	CheckedMultiDisputeStatementSet, MultiDisputeStatementSet, UncheckedSignedAvailabilityBitfield,
 	UncheckedSignedAvailabilityBitfields,
 };
diff --git a/polkadot/runtime/parachains/src/reward_points.rs b/polkadot/runtime/parachains/src/reward_points.rs
index 3be743a2c55133da56e52b654bfa87f26ef596d1..5f45445b0ba2a29cddc3806b84a25cbdcb1ce77d 100644
--- a/polkadot/runtime/parachains/src/reward_points.rs
+++ b/polkadot/runtime/parachains/src/reward_points.rs
@@ -23,7 +23,7 @@
 
 use crate::{session_info, shared};
 use frame_support::traits::{Defensive, ValidatorSet};
-use primitives::{SessionIndex, ValidatorIndex};
+use polkadot_primitives::{SessionIndex, ValidatorIndex};
 use sp_std::collections::btree_set::BTreeSet;
 
 /// The amount of era points given by backing a candidate that is included.
diff --git a/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs b/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs
index 3dca38050a0ac8c43bbb44cdd605572fd6760a82..4417ec75abd67bb1ba50b616ceb137e42cf6a7f6 100644
--- a/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs
+++ b/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs
@@ -24,7 +24,7 @@ use crate::{
 };
 use frame_support::traits::{GetStorageVersion, StorageVersion};
 use frame_system::pallet_prelude::*;
-use primitives::{
+use polkadot_primitives::{
 	async_backing::{
 		AsyncBackingParams, BackingState, CandidatePendingAvailability, Constraints,
 		InboundHrmpLimitations, OutboundHrmpChannelLimitations,
@@ -66,7 +66,7 @@ pub fn availability_cores<T: initializer::Config>() -> Vec<CoreState<T::Hash, Bl
 	//
 	// At the end of a session we clear the claim queues: Without this update call, nothing would be
 	// scheduled to the client.
-	scheduler::Pallet::<T>::free_cores_and_fill_claimqueue(Vec::new(), now);
+	scheduler::Pallet::<T>::free_cores_and_fill_claim_queue(Vec::new(), now);
 
 	let time_out_for = scheduler::Pallet::<T>::availability_timeout_predicate();
 
@@ -149,7 +149,10 @@ pub fn availability_cores<T: initializer::Config>() -> Vec<CoreState<T::Hash, Bl
 			},
 			CoreOccupied::Free => {
 				if let Some(para_id) = scheduled.get(&CoreIndex(i as _)).cloned() {
-					CoreState::Scheduled(primitives::ScheduledCore { para_id, collator: None })
+					CoreState::Scheduled(polkadot_primitives::ScheduledCore {
+						para_id,
+						collator: None,
+					})
 				} else {
 					CoreState::Free
 				}
@@ -161,7 +164,7 @@ pub fn availability_cores<T: initializer::Config>() -> Vec<CoreState<T::Hash, Bl
 /// Returns current block number being processed and the corresponding root hash.
 fn current_relay_parent<T: frame_system::Config>(
 ) -> (BlockNumberFor<T>, <T as frame_system::Config>::Hash) {
-	use parity_scale_codec::Decode as _;
+	use codec::Decode as _;
 	let state_version = frame_system::Pallet::<T>::runtime_version().state_version();
 	let relay_parent_number = frame_system::Pallet::<T>::block_number();
 	let relay_parent_storage_root = T::Hash::decode(&mut &sp_io::storage::root(state_version)[..])
@@ -241,7 +244,7 @@ pub fn assumed_validation_data<T: initializer::Config>(
 /// Implementation for the `check_validation_outputs` function of the runtime API.
 pub fn check_validation_outputs<T: initializer::Config>(
 	para_id: ParaId,
-	outputs: primitives::CandidateCommitments,
+	outputs: polkadot_primitives::CandidateCommitments,
 ) -> bool {
 	let relay_parent_number = frame_system::Pallet::<T>::block_number();
 	inclusion::Pallet::<T>::check_validation_outputs_for_runtime_api(
@@ -302,7 +305,7 @@ pub fn validation_code<T: initializer::Config>(
 
 /// Implementation for the `candidate_pending_availability` function of the runtime API.
 #[deprecated(
-	note = "`candidate_pending_availability` will be removed. Use `candidates_pending_availability` to query 
+	note = "`candidate_pending_availability` will be removed. Use `candidates_pending_availability` to query
 	all candidates pending availability"
 )]
 pub fn candidate_pending_availability<T: initializer::Config>(
diff --git a/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs b/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs
index 32bbdca84a3cce4946ce39edb4e3a3f8e5211188..f4e3db185fead7144e6cb0ae3455af98229d59f7 100644
--- a/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs
+++ b/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs
@@ -16,8 +16,8 @@
 
 //! Put implementations of functions from staging APIs here.
 
-use crate::{inclusion, initializer, scheduler};
-use primitives::{CommittedCandidateReceipt, CoreIndex, Id as ParaId};
+use crate::{configuration, inclusion, initializer, scheduler};
+use polkadot_primitives::{CommittedCandidateReceipt, CoreIndex, Id as ParaId};
 use sp_runtime::traits::One;
 use sp_std::{
 	collections::{btree_map::BTreeMap, vec_deque::VecDeque},
@@ -28,16 +28,25 @@ use sp_std::{
 pub fn claim_queue<T: scheduler::Config>() -> BTreeMap<CoreIndex, VecDeque<ParaId>> {
 	let now = <frame_system::Pallet<T>>::block_number() + One::one();
 
-	// This explicit update is only strictly required for session boundaries:
-	//
-	// At the end of a session we clear the claim queues: Without this update call, nothing would be
-	// scheduled to the client.
-	<scheduler::Pallet<T>>::free_cores_and_fill_claimqueue(Vec::new(), now);
+	// This is needed so that the claim queue always has the right size (equal to
+	// scheduling_lookahead). Otherwise, if a candidate is backed in the same block where the
+	// previous candidate is included, the claim queue will have already pop()-ed the next item
+	// from the queue and the length would be `scheduling_lookahead - 1`.
+	<scheduler::Pallet<T>>::free_cores_and_fill_claim_queue(Vec::new(), now);
+	let config = configuration::ActiveConfig::<T>::get();
+	// Extra sanity, config should already never be smaller than 1:
+	let n_lookahead = config.scheduler_params.lookahead.max(1);
 
 	scheduler::ClaimQueue::<T>::get()
 		.into_iter()
 		.map(|(core_index, entries)| {
-			(core_index, entries.into_iter().map(|e| e.para_id()).collect())
+			// on cores timing out internal claim queue size may be temporarily longer than it
+			// should be as the timed out assignment might got pushed back to an already full claim
+			// queue:
+			(
+				core_index,
+				entries.into_iter().map(|e| e.para_id()).take(n_lookahead as usize).collect(),
+			)
 		})
 		.collect()
 }
diff --git a/polkadot/runtime/parachains/src/scheduler.rs b/polkadot/runtime/parachains/src/scheduler.rs
index baeec49839dfd03a9fb8fd71e7e88d2a3c79dc5c..d7fe5c06863c87413f988a972790c5d3482b513f 100644
--- a/polkadot/runtime/parachains/src/scheduler.rs
+++ b/polkadot/runtime/parachains/src/scheduler.rs
@@ -36,16 +36,21 @@
 //! number of groups as availability cores. Validator groups will be assigned to different
 //! availability cores over time.
 
+use core::iter::Peekable;
+
 use crate::{configuration, initializer::SessionChangeNotification, paras};
 use frame_support::{pallet_prelude::*, traits::Defensive};
 use frame_system::pallet_prelude::BlockNumberFor;
 pub use polkadot_core_primitives::v2::BlockNumber;
-use primitives::{
+use polkadot_primitives::{
 	CoreIndex, GroupIndex, GroupRotationInfo, Id as ParaId, ScheduledCore, ValidatorIndex,
 };
 use sp_runtime::traits::One;
 use sp_std::{
-	collections::{btree_map::BTreeMap, vec_deque::VecDeque},
+	collections::{
+		btree_map::{self, BTreeMap},
+		vec_deque::VecDeque,
+	},
 	prelude::*,
 };
 
@@ -190,7 +195,29 @@ pub mod pallet {
 	}
 }
 
-type PositionInClaimqueue = u32;
+type PositionInClaimQueue = u32;
+
+struct ClaimQueueIterator<E> {
+	next_idx: u32,
+	queue: Peekable<btree_map::IntoIter<CoreIndex, VecDeque<E>>>,
+}
+
+impl<E> Iterator for ClaimQueueIterator<E> {
+	type Item = (CoreIndex, VecDeque<E>);
+
+	fn next(&mut self) -> Option<Self::Item> {
+		let (idx, _) = self.queue.peek()?;
+		let val = if idx != &CoreIndex(self.next_idx) {
+			log::trace!(target: LOG_TARGET, "idx did not match claim queue idx: {:?} vs {:?}", idx, self.next_idx);
+			(CoreIndex(self.next_idx), VecDeque::new())
+		} else {
+			let (idx, q) = self.queue.next()?;
+			(idx, q)
+		};
+		self.next_idx += 1;
+		Some(val)
+	}
+}
 
 impl<T: Config> Pallet<T> {
 	/// Called by the initializer to initialize the scheduler pallet.
@@ -203,7 +230,7 @@ impl<T: Config> Pallet<T> {
 
 	/// Called before the initializer notifies of a new session.
 	pub(crate) fn pre_new_session() {
-		Self::push_claimqueue_items_to_assignment_provider();
+		Self::push_claim_queue_items_to_assignment_provider();
 		Self::push_occupied_cores_to_assignment_provider();
 	}
 
@@ -309,37 +336,54 @@ impl<T: Config> Pallet<T> {
 		(concluded_paras, timedout_paras)
 	}
 
-	/// Note that the given cores have become occupied. Update the claimqueue accordingly.
+	/// Get an iterator into the claim queues.
+	///
+	/// This iterator will have an item for each and every core index up to the maximum core index
+	/// found in the claim queue. In other words there will be no holes/missing core indices,
+	/// between core 0 and the maximum, even if the claim queue was missing entries for particular
+	/// indices in between. (The iterator will return an empty `VecDeque` for those indices.
+	fn claim_queue_iterator() -> impl Iterator<Item = (CoreIndex, VecDeque<ParasEntryType<T>>)> {
+		let queues = ClaimQueue::<T>::get();
+		return ClaimQueueIterator::<ParasEntryType<T>> {
+			next_idx: 0,
+			queue: queues.into_iter().peekable(),
+		}
+	}
+
+	/// Note that the given cores have become occupied. Update the claim queue accordingly.
+	/// This will not push a new entry onto the claim queue, so the length after this call will be
+	/// the expected length - 1. The claim_queue runtime API will take care of adding another entry
+	/// here, to ensure the right lookahead.
 	pub(crate) fn occupied(
 		now_occupied: BTreeMap<CoreIndex, ParaId>,
-	) -> BTreeMap<CoreIndex, PositionInClaimqueue> {
+	) -> BTreeMap<CoreIndex, PositionInClaimQueue> {
 		let mut availability_cores = AvailabilityCores::<T>::get();
 
 		log::debug!(target: LOG_TARGET, "[occupied] now_occupied {:?}", now_occupied);
 
-		let pos_mapping: BTreeMap<CoreIndex, PositionInClaimqueue> = now_occupied
+		let pos_mapping: BTreeMap<CoreIndex, PositionInClaimQueue> = now_occupied
 			.iter()
 			.flat_map(|(core_idx, para_id)| {
-				match Self::remove_from_claimqueue(*core_idx, *para_id) {
+				match Self::remove_from_claim_queue(*core_idx, *para_id) {
 					Err(e) => {
 						log::debug!(
 							target: LOG_TARGET,
-							"[occupied] error on remove_from_claimqueue {}",
+							"[occupied] error on remove_from_claim queue {}",
 							e
 						);
 						None
 					},
-					Ok((pos_in_claimqueue, pe)) => {
+					Ok((pos_in_claim_queue, pe)) => {
 						availability_cores[core_idx.0 as usize] = CoreOccupied::Paras(pe);
 
-						Some((*core_idx, pos_in_claimqueue))
+						Some((*core_idx, pos_in_claim_queue))
 					},
 				}
 			})
 			.collect();
 
 		// Drop expired claims after processing now_occupied.
-		Self::drop_expired_claims_from_claimqueue();
+		Self::drop_expired_claims_from_claim_queue();
 
 		AvailabilityCores::<T>::set(availability_cores);
 
@@ -349,7 +393,7 @@ impl<T: Config> Pallet<T> {
 	/// Iterates through every element in all claim queues and tries to add new assignments from the
 	/// `AssignmentProvider`. A claim is considered expired if it's `ttl` field is lower than the
 	/// current block height.
-	fn drop_expired_claims_from_claimqueue() {
+	fn drop_expired_claims_from_claim_queue() {
 		let now = frame_system::Pallet::<T>::block_number();
 		let availability_cores = AvailabilityCores::<T>::get();
 		let ttl = configuration::ActiveConfig::<T>::get().scheduler_params.ttl;
@@ -357,13 +401,13 @@ impl<T: Config> Pallet<T> {
 		ClaimQueue::<T>::mutate(|cq| {
 			for (idx, _) in (0u32..).zip(availability_cores) {
 				let core_idx = CoreIndex(idx);
-				if let Some(core_claimqueue) = cq.get_mut(&core_idx) {
+				if let Some(core_claim_queue) = cq.get_mut(&core_idx) {
 					let mut i = 0;
 					let mut num_dropped = 0;
-					while i < core_claimqueue.len() {
-						let maybe_dropped = if let Some(entry) = core_claimqueue.get(i) {
+					while i < core_claim_queue.len() {
+						let maybe_dropped = if let Some(entry) = core_claim_queue.get(i) {
 							if entry.ttl < now {
-								core_claimqueue.remove(i)
+								core_claim_queue.remove(i)
 							} else {
 								None
 							}
@@ -381,11 +425,11 @@ impl<T: Config> Pallet<T> {
 
 					for _ in 0..num_dropped {
 						// For all claims dropped due to TTL, attempt to pop a new entry to
-						// the back of the claimqueue.
+						// the back of the claim queue.
 						if let Some(assignment) =
 							T::AssignmentProvider::pop_assignment_for_core(core_idx)
 						{
-							core_claimqueue.push_back(ParasEntry::new(assignment, now + ttl));
+							core_claim_queue.push_back(ParasEntry::new(assignment, now + ttl));
 						}
 					}
 				}
@@ -536,10 +580,10 @@ impl<T: Config> Pallet<T> {
 	}
 
 	// on new session
-	fn push_claimqueue_items_to_assignment_provider() {
+	fn push_claim_queue_items_to_assignment_provider() {
 		for (_, claim_queue) in ClaimQueue::<T>::take() {
 			// Push back in reverse order so that when we pop from the provider again,
-			// the entries in the claimqueue are in the same order as they are right now.
+			// the entries in the claim queue are in the same order as they are right now.
 			for para_entry in claim_queue.into_iter().rev() {
 				Self::maybe_push_assignment(para_entry);
 			}
@@ -554,15 +598,8 @@ impl<T: Config> Pallet<T> {
 		}
 	}
 
-	//
-	//  ClaimQueue related functions
-	//
-	fn claimqueue_lookahead() -> u32 {
-		configuration::ActiveConfig::<T>::get().scheduler_params.lookahead
-	}
-
-	/// Frees cores and fills the free claimqueue spots by popping from the `AssignmentProvider`.
-	pub fn free_cores_and_fill_claimqueue(
+	/// Frees cores and fills the free claim queue spots by popping from the `AssignmentProvider`.
+	pub fn free_cores_and_fill_claim_queue(
 		just_freed_cores: impl IntoIterator<Item = (CoreIndex, FreedReason)>,
 		now: BlockNumberFor<T>,
 	) {
@@ -573,26 +610,33 @@ impl<T: Config> Pallet<T> {
 		if ValidatorGroups::<T>::decode_len().map_or(true, |l| l == 0) {
 			return
 		}
-		// If there exists a core, ensure we schedule at least one job onto it.
-		let n_lookahead = Self::claimqueue_lookahead().max(1);
 		let n_session_cores = T::AssignmentProvider::session_core_count();
 		let cq = ClaimQueue::<T>::get();
 		let config = configuration::ActiveConfig::<T>::get();
+		// Extra sanity, config should already never be smaller than 1:
+		let n_lookahead = config.scheduler_params.lookahead.max(1);
 		let max_availability_timeouts = config.scheduler_params.max_availability_timeouts;
 		let ttl = config.scheduler_params.ttl;
 
 		for core_idx in 0..n_session_cores {
 			let core_idx = CoreIndex::from(core_idx);
 
+			let n_lookahead_used = cq.get(&core_idx).map_or(0, |v| v.len() as u32);
+
 			// add previously timedout paras back into the queue
 			if let Some(mut entry) = timedout_paras.remove(&core_idx) {
 				if entry.availability_timeouts < max_availability_timeouts {
 					// Increment the timeout counter.
 					entry.availability_timeouts += 1;
-					// Reset the ttl so that a timed out assignment.
-					entry.ttl = now + ttl;
-					Self::add_to_claimqueue(core_idx, entry);
-					// The claim has been added back into the claimqueue.
+					if n_lookahead_used < n_lookahead {
+						entry.ttl = now + ttl;
+					} else {
+						// Over max capacity, we need to bump ttl (we exceeded the claim queue
+						// size, so otherwise the entry might get dropped before reaching the top):
+						entry.ttl = now + ttl + One::one();
+					}
+					Self::add_to_claim_queue(core_idx, entry);
+					// The claim has been added back into the claim queue.
 					// Do not pop another assignment for the core.
 					continue
 				} else {
@@ -606,12 +650,9 @@ impl<T: Config> Pallet<T> {
 			if let Some(concluded_para) = concluded_paras.remove(&core_idx) {
 				T::AssignmentProvider::report_processed(concluded_para);
 			}
-			// We consider occupied cores to be part of the claimqueue
-			let n_lookahead_used = cq.get(&core_idx).map_or(0, |v| v.len() as u32) +
-				if Self::is_core_occupied(core_idx) { 1 } else { 0 };
 			for _ in n_lookahead_used..n_lookahead {
 				if let Some(assignment) = T::AssignmentProvider::pop_assignment_for_core(core_idx) {
-					Self::add_to_claimqueue(core_idx, ParasEntry::new(assignment, now + ttl));
+					Self::add_to_claim_queue(core_idx, ParasEntry::new(assignment, now + ttl));
 				}
 			}
 		}
@@ -620,24 +661,17 @@ impl<T: Config> Pallet<T> {
 		debug_assert!(concluded_paras.is_empty());
 	}
 
-	fn is_core_occupied(core_idx: CoreIndex) -> bool {
-		match AvailabilityCores::<T>::get().get(core_idx.0 as usize) {
-			None | Some(CoreOccupied::Free) => false,
-			Some(CoreOccupied::Paras(_)) => true,
-		}
-	}
-
-	fn add_to_claimqueue(core_idx: CoreIndex, pe: ParasEntryType<T>) {
+	fn add_to_claim_queue(core_idx: CoreIndex, pe: ParasEntryType<T>) {
 		ClaimQueue::<T>::mutate(|la| {
 			la.entry(core_idx).or_default().push_back(pe);
 		});
 	}
 
 	/// Returns `ParasEntry` with `para_id` at `core_idx` if found.
-	fn remove_from_claimqueue(
+	fn remove_from_claim_queue(
 		core_idx: CoreIndex,
 		para_id: ParaId,
-	) -> Result<(PositionInClaimqueue, ParasEntryType<T>), &'static str> {
+	) -> Result<(PositionInClaimQueue, ParasEntryType<T>), &'static str> {
 		ClaimQueue::<T>::mutate(|cq| {
 			let core_claims = cq.get_mut(&core_idx).ok_or("core_idx not found in lookahead")?;
 
@@ -654,20 +688,38 @@ impl<T: Config> Pallet<T> {
 
 	/// Paras scheduled next in the claim queue.
 	pub(crate) fn scheduled_paras() -> impl Iterator<Item = (CoreIndex, ParaId)> {
-		let claimqueue = ClaimQueue::<T>::get();
-		claimqueue
+		let claim_queue = ClaimQueue::<T>::get();
+		claim_queue
 			.into_iter()
 			.filter_map(|(core_idx, v)| v.front().map(|e| (core_idx, e.assignment.para_id())))
 	}
 
+	/// Paras that may get backed on cores.
+	///
+	/// 1. The para must be scheduled on core.
+	/// 2. Core needs to be free, otherwise backing is not possible.
+	pub(crate) fn eligible_paras() -> impl Iterator<Item = (CoreIndex, ParaId)> {
+		let availability_cores = AvailabilityCores::<T>::get();
+
+		Self::claim_queue_iterator().zip(availability_cores.into_iter()).filter_map(
+			|((core_idx, queue), core)| {
+				if core != CoreOccupied::Free {
+					return None
+				}
+				let next_scheduled = queue.front()?;
+				Some((core_idx, next_scheduled.assignment.para_id()))
+			},
+		)
+	}
+
 	#[cfg(any(feature = "try-runtime", test))]
-	fn claimqueue_len() -> usize {
+	fn claim_queue_len() -> usize {
 		ClaimQueue::<T>::get().iter().map(|la_vec| la_vec.1.len()).sum()
 	}
 
 	#[cfg(all(not(feature = "runtime-benchmarks"), test))]
-	pub(crate) fn claimqueue_is_empty() -> bool {
-		Self::claimqueue_len() == 0
+	pub(crate) fn claim_queue_is_empty() -> bool {
+		Self::claim_queue_len() == 0
 	}
 
 	#[cfg(test)]
@@ -676,7 +728,7 @@ impl<T: Config> Pallet<T> {
 	}
 
 	#[cfg(test)]
-	pub(crate) fn set_claimqueue(claimqueue: BTreeMap<CoreIndex, VecDeque<ParasEntryType<T>>>) {
-		ClaimQueue::<T>::set(claimqueue);
+	pub(crate) fn set_claim_queue(claim_queue: BTreeMap<CoreIndex, VecDeque<ParasEntryType<T>>>) {
+		ClaimQueue::<T>::set(claim_queue);
 	}
 }
diff --git a/polkadot/runtime/parachains/src/scheduler/common.rs b/polkadot/runtime/parachains/src/scheduler/common.rs
index 66a4e6d30be0830650295d5311b7d7e1fc3b1d20..114cd4b940bcdbeacdf0cbb7f62e74fc09dbad4d 100644
--- a/polkadot/runtime/parachains/src/scheduler/common.rs
+++ b/polkadot/runtime/parachains/src/scheduler/common.rs
@@ -22,7 +22,7 @@ use sp_runtime::{
 	RuntimeDebug,
 };
 
-use primitives::{CoreIndex, Id as ParaId};
+use polkadot_primitives::{CoreIndex, Id as ParaId};
 
 /// Assignment (ParaId -> CoreIndex).
 #[derive(Encode, Decode, TypeInfo, RuntimeDebug, Clone, PartialEq)]
diff --git a/polkadot/runtime/parachains/src/scheduler/migration.rs b/polkadot/runtime/parachains/src/scheduler/migration.rs
index 5482c8821e58c7bdf8fd29b4607837355640a1f3..84d7d4b567102f6757409d88018f2d4e3072644b 100644
--- a/polkadot/runtime/parachains/src/scheduler/migration.rs
+++ b/polkadot/runtime/parachains/src/scheduler/migration.rs
@@ -34,7 +34,7 @@ struct V0Assignment {
 /// Old scheduler with explicit parathreads and `Scheduled` storage instead of `ClaimQueue`.
 mod v0 {
 	use super::*;
-	use primitives::{CollatorId, Id};
+	use polkadot_primitives::{CollatorId, Id};
 
 	#[storage_alias]
 	pub(super) type Scheduled<T: Config> = StorageValue<Pallet<T>, Vec<CoreAssignment>, ValueQuery>;
@@ -248,7 +248,7 @@ mod v1 {
 				.count();
 
 			ensure!(
-				Pallet::<T>::claimqueue_len() as u32 + availability_cores_waiting as u32 ==
+				Pallet::<T>::claim_queue_len() as u32 + availability_cores_waiting as u32 ==
 					expected_len,
 				"ClaimQueue and AvailabilityCores should have the correct length",
 			);
diff --git a/polkadot/runtime/parachains/src/scheduler/tests.rs b/polkadot/runtime/parachains/src/scheduler/tests.rs
index 200f49ff2e820cd2716f25693628173c56b0f4aa..32811241e171cfd07af586bdf6b06b37df644603 100644
--- a/polkadot/runtime/parachains/src/scheduler/tests.rs
+++ b/polkadot/runtime/parachains/src/scheduler/tests.rs
@@ -17,10 +17,10 @@
 use super::*;
 
 use frame_support::assert_ok;
-use keyring::Sr25519Keyring;
-use primitives::{
+use polkadot_primitives::{
 	vstaging::SchedulerParams, BlockNumber, SessionIndex, ValidationCode, ValidatorId,
 };
+use sp_keyring::Sr25519Keyring;
 use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet};
 
 use crate::{
@@ -80,7 +80,7 @@ fn run_to_block(
 		Scheduler::initializer_initialize(b + 1);
 
 		// In the real runtime this is expected to be called by the `InclusionInherent` pallet.
-		Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1);
+		Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1);
 	}
 }
 
@@ -158,6 +158,37 @@ fn scheduled_entries() -> impl Iterator<Item = (CoreIndex, ParasEntry<BlockNumbe
 		.filter_map(|(core_idx, v)| v.front().map(|e| (core_idx, e.clone())))
 }
 
+#[test]
+fn claim_queue_iterator_handles_holes_correctly() {
+	let mut queue = BTreeMap::new();
+	queue.insert(CoreIndex(1), ["abc"].into_iter().collect());
+	queue.insert(CoreIndex(4), ["cde"].into_iter().collect());
+	let queue = queue.into_iter().peekable();
+	let mut i = ClaimQueueIterator { next_idx: 0, queue };
+
+	let (idx, e) = i.next().unwrap();
+	assert_eq!(idx, CoreIndex(0));
+	assert!(e.is_empty());
+
+	let (idx, e) = i.next().unwrap();
+	assert_eq!(idx, CoreIndex(1));
+	assert!(e.len() == 1);
+
+	let (idx, e) = i.next().unwrap();
+	assert_eq!(idx, CoreIndex(2));
+	assert!(e.is_empty());
+
+	let (idx, e) = i.next().unwrap();
+	assert_eq!(idx, CoreIndex(3));
+	assert!(e.is_empty());
+
+	let (idx, e) = i.next().unwrap();
+	assert_eq!(idx, CoreIndex(4));
+	assert!(e.len() == 1);
+
+	assert!(i.next().is_none());
+}
+
 #[test]
 fn claimqueue_ttl_drop_fn_works() {
 	let mut config = default_config();
@@ -176,52 +207,52 @@ fn claimqueue_ttl_drop_fn_works() {
 
 		// Add a claim on core 0 with a ttl in the past.
 		let paras_entry = ParasEntry::new(Assignment::Bulk(para_id), now - 5 as u32);
-		Scheduler::add_to_claimqueue(core_idx, paras_entry.clone());
+		Scheduler::add_to_claim_queue(core_idx, paras_entry.clone());
 
 		// Claim is in queue prior to call.
 		assert!(claimqueue_contains_para_ids::<Test>(vec![para_id]));
 
 		// Claim is dropped post call.
-		Scheduler::drop_expired_claims_from_claimqueue();
+		Scheduler::drop_expired_claims_from_claim_queue();
 		assert!(!claimqueue_contains_para_ids::<Test>(vec![para_id]));
 
 		// Add a claim on core 0 with a ttl in the future (15).
 		let paras_entry = ParasEntry::new(Assignment::Bulk(para_id), now + 5);
-		Scheduler::add_to_claimqueue(core_idx, paras_entry.clone());
+		Scheduler::add_to_claim_queue(core_idx, paras_entry.clone());
 
 		// Claim is in queue post call.
-		Scheduler::drop_expired_claims_from_claimqueue();
+		Scheduler::drop_expired_claims_from_claim_queue();
 		assert!(claimqueue_contains_para_ids::<Test>(vec![para_id]));
 
 		now = now + 6;
 		run_to_block(now, |_| None);
 
 		// Claim is dropped
-		Scheduler::drop_expired_claims_from_claimqueue();
+		Scheduler::drop_expired_claims_from_claim_queue();
 		assert!(!claimqueue_contains_para_ids::<Test>(vec![para_id]));
 
 		// Add a claim on core 0 with a ttl == now (16)
 		let paras_entry = ParasEntry::new(Assignment::Bulk(para_id), now);
-		Scheduler::add_to_claimqueue(core_idx, paras_entry.clone());
+		Scheduler::add_to_claim_queue(core_idx, paras_entry.clone());
 
 		// Claim is in queue post call.
-		Scheduler::drop_expired_claims_from_claimqueue();
+		Scheduler::drop_expired_claims_from_claim_queue();
 		assert!(claimqueue_contains_para_ids::<Test>(vec![para_id]));
 
 		now = now + 1;
 		run_to_block(now, |_| None);
 
 		// Drop expired claim.
-		Scheduler::drop_expired_claims_from_claimqueue();
+		Scheduler::drop_expired_claims_from_claim_queue();
 		assert!(!claimqueue_contains_para_ids::<Test>(vec![para_id]));
 
 		// Add a claim on core 0 with a ttl == now (17)
 		let paras_entry_non_expired = ParasEntry::new(Assignment::Bulk(para_id), now);
 		let paras_entry_expired = ParasEntry::new(Assignment::Bulk(para_id), now - 2);
 		// ttls = [17, 15, 17]
-		Scheduler::add_to_claimqueue(core_idx, paras_entry_non_expired.clone());
-		Scheduler::add_to_claimqueue(core_idx, paras_entry_expired.clone());
-		Scheduler::add_to_claimqueue(core_idx, paras_entry_non_expired.clone());
+		Scheduler::add_to_claim_queue(core_idx, paras_entry_non_expired.clone());
+		Scheduler::add_to_claim_queue(core_idx, paras_entry_expired.clone());
+		Scheduler::add_to_claim_queue(core_idx, paras_entry_non_expired.clone());
 		let cq = scheduler::ClaimQueue::<Test>::get();
 		assert_eq!(cq.get(&core_idx).unwrap().len(), 3);
 
@@ -231,7 +262,7 @@ fn claimqueue_ttl_drop_fn_works() {
 		MockAssigner::add_test_assignment(assignment.clone());
 
 		// Drop expired claim.
-		Scheduler::drop_expired_claims_from_claimqueue();
+		Scheduler::drop_expired_claims_from_claim_queue();
 
 		let cq = scheduler::ClaimQueue::<Test>::get();
 		let cqc = cq.get(&core_idx).unwrap();
@@ -378,7 +409,7 @@ fn fill_claimqueue_fills() {
 		run_to_block(2, |_| None);
 
 		{
-			assert_eq!(Scheduler::claimqueue_len(), 3);
+			assert_eq!(Scheduler::claim_queue_len(), 3);
 			let scheduled: BTreeMap<_, _> = scheduled_entries().collect();
 
 			// Was added a block later, note the TTL.
@@ -488,9 +519,8 @@ fn schedule_schedules_including_just_freed() {
 				.for_each(|(_core_idx, core_queue)| assert_eq!(core_queue.len(), 0))
 		}
 
-		// add a couple more para claims - the claim on `b` will go to the 3rd core
-		// (2) and the claim on `d` will go back to the 1st para core (0). The claim on `e`
-		// then will go for core `1`.
+		MockAssigner::add_test_assignment(assignment_a.clone());
+		MockAssigner::add_test_assignment(assignment_c.clone());
 		MockAssigner::add_test_assignment(assignment_b.clone());
 		MockAssigner::add_test_assignment(assignment_d.clone());
 		MockAssigner::add_test_assignment(assignment_e.clone());
@@ -500,8 +530,7 @@ fn schedule_schedules_including_just_freed() {
 		{
 			let scheduled: BTreeMap<_, _> = scheduled_entries().collect();
 
-			// cores 0 and 1 are occupied by claims. core 2 was free.
-			assert_eq!(scheduled.len(), 1);
+			assert_eq!(scheduled.len(), 3);
 			assert_eq!(
 				scheduled.get(&CoreIndex(2)).unwrap(),
 				&ParasEntry {
@@ -519,7 +548,7 @@ fn schedule_schedules_including_just_freed() {
 		]
 		.into_iter()
 		.collect();
-		Scheduler::free_cores_and_fill_claimqueue(just_updated, now);
+		Scheduler::free_cores_and_fill_claim_queue(just_updated, now);
 
 		{
 			let scheduled: BTreeMap<_, _> = scheduled_entries().collect();
@@ -529,17 +558,28 @@ fn schedule_schedules_including_just_freed() {
 			assert_eq!(
 				scheduled.get(&CoreIndex(0)).unwrap(),
 				&ParasEntry {
-					assignment: Assignment::Bulk(para_d),
+					// Next entry in queue is `a` again:
+					assignment: Assignment::Bulk(para_a),
 					availability_timeouts: 0,
 					ttl: 8
 				},
 			);
 			// Although C was descheduled, the core `2` was occupied so C goes back to the queue.
+			assert_eq!(
+				scheduler::ClaimQueue::<Test>::get()[&CoreIndex(1)][1],
+				ParasEntry {
+					assignment: Assignment::Bulk(para_c),
+					// End of the queue should be the pushed back entry:
+					availability_timeouts: 1,
+					// ttl 1 higher:
+					ttl: 9
+				},
+			);
 			assert_eq!(
 				scheduled.get(&CoreIndex(1)).unwrap(),
 				&ParasEntry {
 					assignment: Assignment::Bulk(para_c),
-					availability_timeouts: 1,
+					availability_timeouts: 0,
 					ttl: 8
 				},
 			);
@@ -552,8 +592,6 @@ fn schedule_schedules_including_just_freed() {
 				},
 			);
 
-			// Para A claim should have been wiped, but para C claim should remain.
-			assert!(!claimqueue_contains_para_ids::<Test>(vec![para_a]));
 			assert!(claimqueue_contains_para_ids::<Test>(vec![para_c]));
 			assert!(!availability_cores_contains_para_ids::<Test>(vec![para_a, para_c]));
 		}
@@ -627,12 +665,13 @@ fn schedule_clears_availability_cores() {
 
 		// Add more assignments
 		MockAssigner::add_test_assignment(assignment_a.clone());
+		MockAssigner::add_test_assignment(assignment_b.clone());
 		MockAssigner::add_test_assignment(assignment_c.clone());
 
 		run_to_block(3, |_| None);
 
 		// now note that cores 0 and 2 were freed.
-		Scheduler::free_cores_and_fill_claimqueue(
+		Scheduler::free_cores_and_fill_claim_queue(
 			vec![(CoreIndex(0), FreedReason::Concluded), (CoreIndex(2), FreedReason::Concluded)]
 				.into_iter()
 				.collect::<Vec<_>>(),
@@ -807,7 +846,7 @@ fn on_demand_claims_are_pruned_after_timing_out() {
 			]
 			.into_iter()
 			.collect();
-			Scheduler::free_cores_and_fill_claimqueue(just_updated, now);
+			Scheduler::free_cores_and_fill_claim_queue(just_updated, now);
 
 			// ParaId a exists in the claim queue until max_retries is reached.
 			if n < max_timeouts + now {
@@ -854,7 +893,7 @@ fn on_demand_claims_are_pruned_after_timing_out() {
 				}
 			}
 
-			Scheduler::free_cores_and_fill_claimqueue(just_updated, now);
+			Scheduler::free_cores_and_fill_claim_queue(just_updated, now);
 
 			// ParaId a exists in the claim queue until groups are rotated.
 			if n < 31 {
@@ -943,12 +982,12 @@ fn next_up_on_available_uses_next_scheduled_or_none() {
 			ttl: 5 as u32,
 		};
 
-		Scheduler::add_to_claimqueue(CoreIndex(0), entry_a.clone());
+		Scheduler::add_to_claim_queue(CoreIndex(0), entry_a.clone());
 
 		run_to_block(2, |_| None);
 
 		{
-			assert_eq!(Scheduler::claimqueue_len(), 1);
+			assert_eq!(Scheduler::claim_queue_len(), 1);
 			assert_eq!(scheduler::AvailabilityCores::<Test>::get().len(), 1);
 
 			let mut map = BTreeMap::new();
@@ -963,7 +1002,7 @@ fn next_up_on_available_uses_next_scheduled_or_none() {
 
 			assert!(Scheduler::next_up_on_available(CoreIndex(0)).is_none());
 
-			Scheduler::add_to_claimqueue(CoreIndex(0), entry_b);
+			Scheduler::add_to_claim_queue(CoreIndex(0), entry_b);
 
 			assert_eq!(
 				Scheduler::next_up_on_available(CoreIndex(0)).unwrap(),
@@ -1032,7 +1071,7 @@ fn next_up_on_time_out_reuses_claim_if_nothing_queued() {
 			MockAssigner::add_test_assignment(assignment_b.clone());
 
 			// Pop assignment_b into the claimqueue
-			Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), 2);
+			Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), 2);
 
 			//// Now that there is an earlier next-up, we use that.
 			assert_eq!(
@@ -1113,7 +1152,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() {
 			_ => None,
 		});
 
-		Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), 3);
+		Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), 3);
 
 		assert_eq!(
 			scheduler::ClaimQueue::<Test>::get(),
@@ -1161,7 +1200,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() {
 		let groups = ValidatorGroups::<Test>::get();
 		assert_eq!(groups.len(), 5);
 
-		Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), 4);
+		Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), 4);
 
 		assert_eq!(
 			scheduler::ClaimQueue::<Test>::get(),
diff --git a/polkadot/runtime/parachains/src/session_info.rs b/polkadot/runtime/parachains/src/session_info.rs
index 2f7f1ead76ade121d5ed06182cb7f69bf2ba71c4..ff032f7e34d5efc130b5ce0859fd3160b6039d39 100644
--- a/polkadot/runtime/parachains/src/session_info.rs
+++ b/polkadot/runtime/parachains/src/session_info.rs
@@ -29,7 +29,9 @@ use frame_support::{
 	traits::{OneSessionHandler, ValidatorSet, ValidatorSetWithIdentification},
 };
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{AssignmentId, AuthorityDiscoveryId, ExecutorParams, SessionIndex, SessionInfo};
+use polkadot_primitives::{
+	AssignmentId, AuthorityDiscoveryId, ExecutorParams, SessionIndex, SessionInfo,
+};
 use sp_std::vec::Vec;
 
 pub use pallet::*;
diff --git a/polkadot/runtime/parachains/src/session_info/tests.rs b/polkadot/runtime/parachains/src/session_info/tests.rs
index 18b9d8f59010eb49a26768ad31a3c3296d65b41a..3e81ca4987132ebbaacead0510688fa754b1d94f 100644
--- a/polkadot/runtime/parachains/src/session_info/tests.rs
+++ b/polkadot/runtime/parachains/src/session_info/tests.rs
@@ -24,8 +24,8 @@ use crate::{
 	},
 	util::take_active_subset,
 };
-use keyring::Sr25519Keyring;
-use primitives::{vstaging::SchedulerParams, BlockNumber, ValidatorId, ValidatorIndex};
+use polkadot_primitives::{vstaging::SchedulerParams, BlockNumber, ValidatorId, ValidatorIndex};
+use sp_keyring::Sr25519Keyring;
 
 fn run_to_block(
 	to: BlockNumber,
diff --git a/polkadot/runtime/parachains/src/shared.rs b/polkadot/runtime/parachains/src/shared.rs
index 319b22515889568b7e29f84a4710f0ff5e10d8d0..417de1fa3fb0debeb8099d167859dc21e20329ca 100644
--- a/polkadot/runtime/parachains/src/shared.rs
+++ b/polkadot/runtime/parachains/src/shared.rs
@@ -21,7 +21,7 @@
 
 use frame_support::{pallet_prelude::*, traits::DisabledValidators};
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{SessionIndex, ValidatorId, ValidatorIndex};
+use polkadot_primitives::{SessionIndex, ValidatorId, ValidatorIndex};
 use sp_runtime::traits::AtLeast32BitUnsigned;
 use sp_std::{
 	collections::{btree_map::BTreeMap, vec_deque::VecDeque},
diff --git a/polkadot/runtime/parachains/src/shared/tests.rs b/polkadot/runtime/parachains/src/shared/tests.rs
index 4ae37463a6d9d010332de3346750dc7d57156861..e47d1fd9cfe0d43adaf9b6c3f9befd2d604d2c8c 100644
--- a/polkadot/runtime/parachains/src/shared/tests.rs
+++ b/polkadot/runtime/parachains/src/shared/tests.rs
@@ -21,9 +21,9 @@ use crate::{
 	shared,
 };
 use assert_matches::assert_matches;
-use keyring::Sr25519Keyring;
-use primitives::Hash;
-use test_helpers::validator_pubkeys;
+use polkadot_primitives::Hash;
+use polkadot_primitives_test_helpers::validator_pubkeys;
+use sp_keyring::Sr25519Keyring;
 
 #[test]
 fn tracker_earliest_block_number() {
diff --git a/polkadot/runtime/parachains/src/ump_tests.rs b/polkadot/runtime/parachains/src/ump_tests.rs
index 43829974b5693ea9f57494722cad54600b1beb7b..4d6da8c9e3c1ba9047ebba784138869733f33ec7 100644
--- a/polkadot/runtime/parachains/src/ump_tests.rs
+++ b/polkadot/runtime/parachains/src/ump_tests.rs
@@ -31,7 +31,7 @@ use frame_support::{
 	traits::{EnqueueMessage, ExecuteOverweightError, ServiceQueues},
 	weights::Weight,
 };
-use primitives::{well_known_keys, Id as ParaId, UpwardMessage};
+use polkadot_primitives::{well_known_keys, Id as ParaId, UpwardMessage};
 use sp_crypto_hashing::{blake2_256, twox_64};
 use sp_runtime::traits::Bounded;
 use sp_std::prelude::*;
@@ -426,7 +426,7 @@ fn relay_dispatch_queue_size_key_is_correct() {
 		// A "random" para id.
 		let para: ParaId = u32::from_ne_bytes(twox_64(&i.encode())[..4].try_into().unwrap()).into();
 
-		let well_known = primitives::well_known_keys::relay_dispatch_queue_size(para);
+		let well_known = polkadot_primitives::well_known_keys::relay_dispatch_queue_size(para);
 		let aliased = RelayDispatchQueueSize::hashed_key_for(para);
 
 		assert_eq!(well_known, aliased, "Old and new key must match");
diff --git a/polkadot/runtime/parachains/src/util.rs b/polkadot/runtime/parachains/src/util.rs
index 5aa2d58da3c9bd70ec8ec201a59705c21faffb9b..cb2deffd7f6593ac69ea1fd7f10d5dfee9dc4577 100644
--- a/polkadot/runtime/parachains/src/util.rs
+++ b/polkadot/runtime/parachains/src/util.rs
@@ -18,7 +18,7 @@
 //! on all modules.
 
 use frame_system::pallet_prelude::BlockNumberFor;
-use primitives::{HeadData, Id as ParaId, PersistedValidationData, ValidatorIndex};
+use polkadot_primitives::{HeadData, Id as ParaId, PersistedValidationData, ValidatorIndex};
 use sp_std::{collections::btree_set::BTreeSet, vec::Vec};
 
 use crate::{configuration, hrmp, paras};
@@ -121,7 +121,7 @@ mod tests {
 	use sp_std::vec::Vec;
 
 	use crate::util::{split_active_subset, take_active_subset};
-	use primitives::ValidatorIndex;
+	use polkadot_primitives::ValidatorIndex;
 
 	#[test]
 	fn take_active_subset_is_compatible_with_split_active_subset() {
diff --git a/polkadot/runtime/rococo/Cargo.toml b/polkadot/runtime/rococo/Cargo.toml
index 4765de08c1a4f421a2ae9fa974236f034f09cb67..d342926d3c5a08eb50e6317882a9b4521c3115d2 100644
--- a/polkadot/runtime/rococo/Cargo.toml
+++ b/polkadot/runtime/rococo/Cargo.toml
@@ -11,7 +11,7 @@ license.workspace = true
 workspace = true
 
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 log = { workspace = true }
 serde = { workspace = true }
@@ -21,16 +21,16 @@ static_assertions = "1.1.0"
 smallvec = "1.8.0"
 bitvec = { version = "1.0.1", default-features = false, features = ["alloc"] }
 
-authority-discovery-primitives = { package = "sp-authority-discovery", path = "../../../substrate/primitives/authority-discovery", default-features = false }
-babe-primitives = { package = "sp-consensus-babe", path = "../../../substrate/primitives/consensus/babe", default-features = false }
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy", default-features = false }
-grandpa_primitives = { package = "sp-consensus-grandpa", path = "../../../substrate/primitives/consensus/grandpa", default-features = false }
+sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery", default-features = false }
+sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe", default-features = false }
+sp-consensus-beefy = { path = "../../../substrate/primitives/consensus/beefy", default-features = false }
+sp-consensus-grandpa = { path = "../../../substrate/primitives/consensus/grandpa", default-features = false }
 binary-merkle-tree = { path = "../../../substrate/utils/binary-merkle-tree", default-features = false }
 rococo-runtime-constants = { package = "rococo-runtime-constants", path = "constants", default-features = false }
 sp-api = { path = "../../../substrate/primitives/api", default-features = false }
 sp-genesis-builder = { path = "../../../substrate/primitives/genesis-builder", default-features = false }
-inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false }
-offchain-primitives = { package = "sp-offchain", path = "../../../substrate/primitives/offchain", default-features = false }
+sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false }
+sp-offchain = { path = "../../../substrate/primitives/offchain", default-features = false }
 sp-arithmetic = { path = "../../../substrate/primitives/arithmetic", default-features = false }
 sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false }
 sp-io = { path = "../../../substrate/primitives/io", default-features = false }
@@ -41,8 +41,8 @@ sp-core = { path = "../../../substrate/primitives/core", default-features = fals
 sp-session = { path = "../../../substrate/primitives/session", default-features = false }
 sp-storage = { path = "../../../substrate/primitives/storage", default-features = false }
 sp-version = { path = "../../../substrate/primitives/version", default-features = false }
-tx-pool-api = { package = "sp-transaction-pool", path = "../../../substrate/primitives/transaction-pool", default-features = false }
-block-builder-api = { package = "sp-block-builder", path = "../../../substrate/primitives/block-builder", default-features = false }
+sp-transaction-pool = { path = "../../../substrate/primitives/transaction-pool", default-features = false }
+sp-block-builder = { path = "../../../substrate/primitives/block-builder", default-features = false }
 
 pallet-authority-discovery = { path = "../../../substrate/frame/authority-discovery", default-features = false }
 pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false }
@@ -95,13 +95,14 @@ pallet-xcm-benchmarks = { path = "../../xcm/pallet-xcm-benchmarks", default-feat
 pallet-root-testing = { path = "../../../substrate/frame/root-testing", default-features = false }
 
 frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true }
+frame-metadata-hash-extension = { path = "../../../substrate/frame/metadata-hash-extension", default-features = false }
 frame-try-runtime = { path = "../../../substrate/frame/try-runtime", default-features = false, optional = true }
 frame-system-benchmarking = { path = "../../../substrate/frame/system/benchmarking", default-features = false, optional = true }
 hex-literal = { version = "0.4.1" }
 
-runtime-common = { package = "polkadot-runtime-common", path = "../common", default-features = false }
-runtime-parachains = { package = "polkadot-runtime-parachains", path = "../parachains", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false }
+polkadot-runtime-common = { path = "../common", default-features = false }
+polkadot-runtime-parachains = { path = "../parachains", default-features = false }
+polkadot-primitives = { path = "../../primitives", default-features = false }
 polkadot-parachain-primitives = { path = "../../parachain", default-features = false }
 
 xcm = { package = "staging-xcm", path = "../../xcm", default-features = false }
@@ -111,7 +112,7 @@ xcm-fee-payment-runtime-api = { path = "../../xcm/xcm-fee-payment-runtime-api",
 
 [dev-dependencies]
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
-keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" }
+sp-keyring = { path = "../../../substrate/primitives/keyring" }
 remote-externalities = { package = "frame-remote-externalities", path = "../../../substrate/utils/frame/remote-externalities" }
 sp-trie = { path = "../../../substrate/primitives/trie" }
 separator = "0.4.1"
@@ -126,23 +127,18 @@ substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder", optio
 default = ["std"]
 no_std = []
 std = [
-	"authority-discovery-primitives/std",
-	"babe-primitives/std",
-	"beefy-primitives/std",
 	"binary-merkle-tree/std",
 	"bitvec/std",
-	"block-builder-api/std",
+	"codec/std",
 	"frame-benchmarking?/std",
 	"frame-executive/std",
+	"frame-metadata-hash-extension/std",
 	"frame-support/std",
 	"frame-system-benchmarking?/std",
 	"frame-system-rpc-runtime-api/std",
 	"frame-system/std",
 	"frame-try-runtime/std",
-	"grandpa_primitives/std",
-	"inherents/std",
 	"log/std",
-	"offchain-primitives/std",
 	"pallet-asset-rate/std",
 	"pallet-authority-discovery/std",
 	"pallet-authorship/std",
@@ -188,31 +184,37 @@ std = [
 	"pallet-whitelist/std",
 	"pallet-xcm-benchmarks?/std",
 	"pallet-xcm/std",
-	"parity-scale-codec/std",
 	"polkadot-parachain-primitives/std",
-	"primitives/std",
+	"polkadot-primitives/std",
+	"polkadot-runtime-common/std",
+	"polkadot-runtime-parachains/std",
 	"rococo-runtime-constants/std",
-	"runtime-common/std",
-	"runtime-parachains/std",
 	"scale-info/std",
 	"serde/std",
 	"serde_derive",
 	"serde_json/std",
 	"sp-api/std",
 	"sp-arithmetic/std",
+	"sp-authority-discovery/std",
+	"sp-block-builder/std",
+	"sp-consensus-babe/std",
+	"sp-consensus-beefy/std",
+	"sp-consensus-grandpa/std",
 	"sp-core/std",
 	"sp-genesis-builder/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-mmr-primitives/std",
+	"sp-offchain/std",
 	"sp-runtime/std",
 	"sp-session/std",
 	"sp-staking/std",
 	"sp-std/std",
 	"sp-storage/std",
 	"sp-tracing/std",
+	"sp-transaction-pool/std",
 	"sp-version/std",
 	"substrate-wasm-builder",
-	"tx-pool-api/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
 	"xcm-fee-payment-runtime-api/std",
@@ -261,9 +263,9 @@ runtime-benchmarks = [
 	"pallet-xcm-benchmarks/runtime-benchmarks",
 	"pallet-xcm/runtime-benchmarks",
 	"polkadot-parachain-primitives/runtime-benchmarks",
-	"primitives/runtime-benchmarks",
-	"runtime-common/runtime-benchmarks",
-	"runtime-parachains/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
+	"polkadot-runtime-common/runtime-benchmarks",
+	"polkadot-runtime-parachains/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
@@ -319,17 +321,20 @@ try-runtime = [
 	"pallet-vesting/try-runtime",
 	"pallet-whitelist/try-runtime",
 	"pallet-xcm/try-runtime",
-	"runtime-common/try-runtime",
-	"runtime-parachains/try-runtime",
+	"polkadot-runtime-common/try-runtime",
+	"polkadot-runtime-parachains/try-runtime",
 	"sp-runtime/try-runtime",
 ]
 
+# Enable the metadata hash generation in the wasm builder.
+metadata-hash = ["substrate-wasm-builder/metadata-hash"]
+
 # Set timing constants (e.g. session period) to faster versions to speed up testing.
 fast-runtime = ["rococo-runtime-constants/fast-runtime"]
 
-runtime-metrics = ["runtime-parachains/runtime-metrics", "sp-io/with-tracing"]
+runtime-metrics = ["polkadot-runtime-parachains/runtime-metrics", "sp-io/with-tracing"]
 
 # A feature that should be enabled when the runtime should be built for on-chain
 # deployment. This will disable stuff that shouldn't be part of the on-chain wasm
 # to make it smaller, like logging for example.
-on-chain-release-build = ["sp-api/disable-logging"]
+on-chain-release-build = ["metadata-hash", "sp-api/disable-logging"]
diff --git a/polkadot/runtime/rococo/build.rs b/polkadot/runtime/rococo/build.rs
index 403c31ff21c70f679059fa5b7e65478d309ba6a3..7aae84cd5e0fedcb29265f98d40bcd9ccd83ae43 100644
--- a/polkadot/runtime/rococo/build.rs
+++ b/polkadot/runtime/rococo/build.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
-#[cfg(feature = "std")]
+#[cfg(all(not(feature = "metadata-hash"), feature = "std"))]
 fn main() {
 	substrate_wasm_builder::WasmBuilder::build_using_defaults();
 
@@ -24,5 +24,18 @@ fn main() {
 		.build();
 }
 
+#[cfg(all(feature = "metadata-hash", feature = "std"))]
+fn main() {
+	substrate_wasm_builder::WasmBuilder::init_with_defaults()
+		.enable_metadata_hash("ROC", 12)
+		.build();
+
+	substrate_wasm_builder::WasmBuilder::init_with_defaults()
+		.set_file_name("fast_runtime_binary.rs")
+		.enable_feature("fast-runtime")
+		.enable_metadata_hash("ROC", 12)
+		.build();
+}
+
 #[cfg(not(feature = "std"))]
 fn main() {}
diff --git a/polkadot/runtime/rococo/constants/Cargo.toml b/polkadot/runtime/rococo/constants/Cargo.toml
index 3ca3877a7650e453c25851ddb35899478a67faeb..2c49488077e6f82b6a306c2b98d7d0f493c4681c 100644
--- a/polkadot/runtime/rococo/constants/Cargo.toml
+++ b/polkadot/runtime/rococo/constants/Cargo.toml
@@ -13,8 +13,8 @@ workspace = true
 smallvec = "1.8.0"
 
 frame-support = { path = "../../../../substrate/frame/support", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../../primitives", default-features = false }
-runtime-common = { package = "polkadot-runtime-common", path = "../../common", default-features = false }
+polkadot-primitives = { path = "../../../primitives", default-features = false }
+polkadot-runtime-common = { path = "../../common", default-features = false }
 sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false }
 sp-weights = { path = "../../../../substrate/primitives/weights", default-features = false }
 sp-core = { path = "../../../../substrate/primitives/core", default-features = false }
@@ -26,8 +26,8 @@ xcm-builder = { package = "staging-xcm-builder", path = "../../../xcm/xcm-builde
 default = ["std"]
 std = [
 	"frame-support/std",
-	"primitives/std",
-	"runtime-common/std",
+	"polkadot-primitives/std",
+	"polkadot-runtime-common/std",
 	"sp-core/std",
 	"sp-runtime/std",
 	"sp-weights/std",
diff --git a/polkadot/runtime/rococo/constants/src/lib.rs b/polkadot/runtime/rococo/constants/src/lib.rs
index 89d5deb86f1a0ff78a05255f9f5f3bdaca8333a6..1dcafdcbc4d9a6fe48fd460e3ac836d95bb3372b 100644
--- a/polkadot/runtime/rococo/constants/src/lib.rs
+++ b/polkadot/runtime/rococo/constants/src/lib.rs
@@ -20,7 +20,7 @@ pub mod weights;
 
 /// Money matters.
 pub mod currency {
-	use primitives::Balance;
+	use polkadot_primitives::Balance;
 
 	/// The existential deposit.
 	pub const EXISTENTIAL_DEPOSIT: Balance = 1 * CENTS;
@@ -37,9 +37,9 @@ pub mod currency {
 
 /// Time and blocks.
 pub mod time {
-	use runtime_common::prod_or_fast;
+	use polkadot_runtime_common::prod_or_fast;
 
-	use primitives::{BlockNumber, Moment};
+	use polkadot_primitives::{BlockNumber, Moment};
 	pub const MILLISECS_PER_BLOCK: Moment = 6000;
 	pub const SLOT_DURATION: Moment = MILLISECS_PER_BLOCK;
 
@@ -67,7 +67,7 @@ pub mod fee {
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
-	use primitives::Balance;
+	use polkadot_primitives::Balance;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 
@@ -103,7 +103,7 @@ pub mod fee {
 
 /// System Parachains.
 pub mod system_parachain {
-	use primitives::Id;
+	use polkadot_primitives::Id;
 	use xcm_builder::IsChildSystemParachain;
 
 	/// Network's Asset Hub parachain ID.
@@ -134,7 +134,7 @@ mod tests {
 	};
 	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::WeightToFee as WeightToFeeT;
-	use runtime_common::MAXIMUM_BLOCK_WEIGHT;
+	use polkadot_runtime_common::MAXIMUM_BLOCK_WEIGHT;
 
 	#[test]
 	// Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds.
diff --git a/polkadot/runtime/rococo/src/genesis_config_presets.rs b/polkadot/runtime/rococo/src/genesis_config_presets.rs
index bac6902383e3b549bc99181f921905760a71cd96..1c70c94ce04840db1c25f525cca32fff8d99ffeb 100644
--- a/polkadot/runtime/rococo/src/genesis_config_presets.rs
+++ b/polkadot/runtime/rococo/src/genesis_config_presets.rs
@@ -17,12 +17,14 @@
 //! Genesis configs presets for the Rococo runtime
 
 use crate::{SessionKeys, BABE_GENESIS_EPOCH_CONFIG};
-use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
-use babe_primitives::AuthorityId as BabeId;
-use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId;
-use grandpa_primitives::AuthorityId as GrandpaId;
-use primitives::{vstaging::SchedulerParams, AccountId, AccountPublic, AssignmentId, ValidatorId};
+use polkadot_primitives::{
+	vstaging::SchedulerParams, AccountId, AccountPublic, AssignmentId, ValidatorId,
+};
 use rococo_runtime_constants::currency::UNITS as ROC;
+use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
+use sp_consensus_babe::AuthorityId as BabeId;
+use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId;
+use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{sr25519, Pair, Public};
 use sp_runtime::traits::IdentifyAccount;
 #[cfg(not(feature = "std"))]
@@ -105,12 +107,13 @@ fn rococo_session_keys(
 }
 
 fn default_parachains_host_configuration(
-) -> runtime_parachains::configuration::HostConfiguration<primitives::BlockNumber> {
-	use primitives::{
+) -> polkadot_runtime_parachains::configuration::HostConfiguration<polkadot_primitives::BlockNumber>
+{
+	use polkadot_primitives::{
 		node_features::FeatureIndex, AsyncBackingParams, MAX_CODE_SIZE, MAX_POV_SIZE,
 	};
 
-	runtime_parachains::configuration::HostConfiguration {
+	polkadot_runtime_parachains::configuration::HostConfiguration {
 		validation_upgrade_cooldown: 2u32,
 		validation_upgrade_delay: 2,
 		code_retention_period: 1200,
@@ -205,7 +208,7 @@ fn rococo_testnet_genesis(
 		},
 		"sudo": { "key": Some(root_key.clone()) },
 		"configuration": {
-			"config": runtime_parachains::configuration::HostConfiguration {
+			"config": polkadot_runtime_parachains::configuration::HostConfiguration {
 				scheduler_params: SchedulerParams {
 					max_validators_per_core: Some(1),
 					..default_parachains_host_configuration().scheduler_params
@@ -214,7 +217,7 @@ fn rococo_testnet_genesis(
 			},
 		},
 		"registrar": {
-			"nextFreeParaId": primitives::LOWEST_PUBLIC_ID,
+			"nextFreeParaId": polkadot_primitives::LOWEST_PUBLIC_ID,
 		}
 	})
 }
@@ -473,7 +476,7 @@ fn rococo_staging_testnet_config_genesis() -> serde_json::Value {
 			"config": default_parachains_host_configuration(),
 		},
 		"registrar": {
-			"nextFreeParaId": primitives::LOWEST_PUBLIC_ID,
+			"nextFreeParaId": polkadot_primitives::LOWEST_PUBLIC_ID,
 		},
 	})
 }
diff --git a/polkadot/runtime/rococo/src/impls.rs b/polkadot/runtime/rococo/src/impls.rs
index ac7100d7858377dca5991e0d0308dc64577b9350..7b5c7b1fb4aca8b9e574734ca9bf21cf0bc5e527 100644
--- a/polkadot/runtime/rococo/src/impls.rs
+++ b/polkadot/runtime/rococo/src/impls.rs
@@ -15,12 +15,12 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::xcm_config;
+use codec::{Decode, Encode};
 use frame_support::pallet_prelude::DispatchResult;
 use frame_system::RawOrigin;
-use parity_scale_codec::{Decode, Encode};
-use primitives::Balance;
+use polkadot_primitives::Balance;
+use polkadot_runtime_common::identity_migrator::{OnReapIdentity, WeightInfo};
 use rococo_runtime_constants::currency::*;
-use runtime_common::identity_migrator::{OnReapIdentity, WeightInfo};
 use sp_std::{marker::PhantomData, prelude::*};
 use xcm::{latest::prelude::*, VersionedLocation, VersionedXcm};
 use xcm_executor::traits::TransactAsset;
diff --git a/polkadot/runtime/rococo/src/lib.rs b/polkadot/runtime/rococo/src/lib.rs
index 7f4027f6ffc7b07122ac46f3ac162fa31a36ad16..5023a709870ce834f9fe7cdc54b644957aea66c9 100644
--- a/polkadot/runtime/rococo/src/lib.rs
+++ b/polkadot/runtime/rococo/src/lib.rs
@@ -20,18 +20,13 @@
 // `construct_runtime!` does a lot of recursion and requires us to increase the limit.
 #![recursion_limit = "512"]
 
-use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
-use beefy_primitives::{
-	ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature},
-	mmr::{BeefyDataProvider, MmrLeafVersion},
-};
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::{
 	dynamic_params::{dynamic_pallet_params, dynamic_params},
 	traits::FromContains,
 };
 use pallet_nis::WithMaximumOf;
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
-use primitives::{
+use polkadot_primitives::{
 	slashing, AccountId, AccountIndex, ApprovalVotingParams, Balance, BlockNumber, CandidateEvent,
 	CandidateHash, CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams,
 	GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment,
@@ -39,8 +34,7 @@ use primitives::{
 	SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
 	PARACHAIN_KEY_TYPE_ID,
 };
-use rococo_runtime_constants::system_parachain::BROKER_ID;
-use runtime_common::{
+use polkadot_runtime_common::{
 	assigned_slots, auctions, claims, crowdloan, identity_migrator, impl_runtime_weights,
 	impls::{
 		ContainsParts, LocatableAssetConverter, ToAuthor, VersionedLocatableAsset,
@@ -50,7 +44,7 @@ use runtime_common::{
 	traits::{Leaser, OnSwap},
 	BlockHashCount, BlockLength, SlowAdjustingFeeUpdate,
 };
-use runtime_parachains::{
+use polkadot_runtime_parachains::{
 	assigner_coretime as parachains_assigner_coretime,
 	assigner_on_demand as parachains_assigner_on_demand, configuration as parachains_configuration,
 	configuration::ActiveConfigHrmpChannelSizeAndCapacityRatio,
@@ -66,7 +60,13 @@ use runtime_parachains::{
 	scheduler as parachains_scheduler, session_info as parachains_session_info,
 	shared as parachains_shared,
 };
+use rococo_runtime_constants::system_parachain::BROKER_ID;
 use scale_info::TypeInfo;
+use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
+use sp_consensus_beefy::{
+	ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature},
+	mmr::{BeefyDataProvider, MmrLeafVersion},
+};
 use sp_genesis_builder::PresetId;
 use sp_std::{
 	cmp::Ordering,
@@ -106,10 +106,7 @@ use sp_staking::SessionIndex;
 #[cfg(any(feature = "std", test))]
 use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
-use xcm::{
-	latest::prelude::*, IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation,
-	VersionedXcm,
-};
+use xcm::{latest::prelude::*, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm};
 use xcm_builder::PayOverXcm;
 
 pub use frame_system::Call as SystemCall;
@@ -135,7 +132,7 @@ use governance::{
 	TreasurySpender,
 };
 use xcm_fee_payment_runtime_api::{
-	dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects},
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
 	fees::Error as XcmPaymentApiError,
 };
 
@@ -165,18 +162,18 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("rococo"),
 	impl_name: create_runtime_str!("parity-rococo-v2.0"),
 	authoring_version: 0,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
-	transaction_version: 25,
+	transaction_version: 26,
 	state_version: 1,
 };
 
 /// The BABE epoch configuration at genesis.
-pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
-	babe_primitives::BabeEpochConfiguration {
+pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration =
+	sp_consensus_babe::BabeEpochConfiguration {
 		c: PRIMARY_PROBABILITY,
-		allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
+		allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryVRFSlots,
 	};
 
 /// Native version.
@@ -479,9 +476,6 @@ parameter_types! {
 }
 
 parameter_types! {
-	pub const ProposalBond: Permill = Permill::from_percent(5);
-	pub const ProposalBondMinimum: Balance = 2000 * CENTS;
-	pub const ProposalBondMaximum: Balance = 1 * GRAND;
 	pub const SpendPeriod: BlockNumber = 6 * DAYS;
 	pub const Burn: Permill = Permill::from_perthousand(2);
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
@@ -508,9 +502,6 @@ impl pallet_treasury::Config for Runtime {
 	type RejectOrigin = EitherOfDiverse<EnsureRoot<AccountId>, Treasurer>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = Treasury;
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ProposalBondMinimum;
-	type ProposalBondMaximum = ProposalBondMaximum;
 	type SpendPeriod = SpendPeriod;
 	type Burn = Burn;
 	type BurnDestination = Society;
@@ -542,7 +533,7 @@ impl pallet_treasury::Config for Runtime {
 	>;
 	type PayoutPeriod = PayoutSpendPeriod;
 	#[cfg(feature = "runtime-benchmarks")]
-	type BenchmarkHelper = runtime_common::impls::benchmarks::TreasuryArguments;
+	type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::TreasuryArguments;
 }
 
 parameter_types! {
@@ -643,7 +634,9 @@ where
 			frame_system::CheckNonce::<Runtime>::from(nonce),
 			frame_system::CheckWeight::<Runtime>::new(),
 			pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
+			frame_metadata_hash_extension::CheckMetadataHash::new(true),
 		);
+
 		let raw_payload = SignedPayload::new(call, extra)
 			.map_err(|e| {
 				log::warn!("Unable to create signed payload: {:?}", e);
@@ -957,7 +950,7 @@ impl parachains_session_info::Config for Runtime {
 
 /// Special `RewardValidators` that does nothing ;)
 pub struct RewardValidators;
-impl runtime_parachains::inclusion::RewardValidators for RewardValidators {
+impl polkadot_runtime_parachains::inclusion::RewardValidators for RewardValidators {
 	fn reward_backing(_: impl IntoIterator<Item = ValidatorIndex>) {}
 	fn reward_bitfields(_: impl IntoIterator<Item = ValidatorIndex>) {}
 }
@@ -1365,7 +1358,7 @@ impl pallet_asset_rate::Config for Runtime {
 	type Currency = Balances;
 	type AssetKind = <Runtime as pallet_treasury::Config>::AssetKind;
 	#[cfg(feature = "runtime-benchmarks")]
-	type BenchmarkHelper = runtime_common::impls::benchmarks::AssetRateArguments;
+	type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::AssetRateArguments;
 }
 
 // Notify `coretime` pallet when a lease swap occurs
@@ -1528,6 +1521,7 @@ pub type SignedExtra = (
 	frame_system::CheckNonce<Runtime>,
 	frame_system::CheckWeight<Runtime>,
 	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+	frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 
 /// Unchecked extrinsic type as expected by this runtime.
@@ -1701,22 +1695,22 @@ mod benches {
 		// Polkadot
 		// NOTE: Make sure to prefix these with `runtime_common::` so
 		// the that path resolves correctly in the generated file.
-		[runtime_common::assigned_slots, AssignedSlots]
-		[runtime_common::auctions, Auctions]
-		[runtime_common::coretime, Coretime]
-		[runtime_common::crowdloan, Crowdloan]
-		[runtime_common::claims, Claims]
-		[runtime_common::identity_migrator, IdentityMigrator]
-		[runtime_common::slots, Slots]
-		[runtime_common::paras_registrar, Registrar]
-		[runtime_parachains::configuration, Configuration]
-		[runtime_parachains::hrmp, Hrmp]
-		[runtime_parachains::disputes, ParasDisputes]
-		[runtime_parachains::inclusion, ParaInclusion]
-		[runtime_parachains::initializer, Initializer]
-		[runtime_parachains::paras_inherent, ParaInherent]
-		[runtime_parachains::paras, Paras]
-		[runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider]
+		[polkadot_runtime_common::assigned_slots, AssignedSlots]
+		[polkadot_runtime_common::auctions, Auctions]
+		[polkadot_runtime_common::coretime, Coretime]
+		[polkadot_runtime_common::crowdloan, Crowdloan]
+		[polkadot_runtime_common::claims, Claims]
+		[polkadot_runtime_common::identity_migrator, IdentityMigrator]
+		[polkadot_runtime_common::slots, Slots]
+		[polkadot_runtime_common::paras_registrar, Registrar]
+		[polkadot_runtime_parachains::configuration, Configuration]
+		[polkadot_runtime_parachains::hrmp, Hrmp]
+		[polkadot_runtime_parachains::disputes, ParasDisputes]
+		[polkadot_runtime_parachains::inclusion, ParaInclusion]
+		[polkadot_runtime_parachains::initializer, Initializer]
+		[polkadot_runtime_parachains::paras_inherent, ParaInherent]
+		[polkadot_runtime_parachains::paras, Paras]
+		[polkadot_runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider]
 		// Substrate
 		[pallet_balances, Balances]
 		[pallet_balances, NisCounterpartBalances]
@@ -1769,15 +1763,8 @@ sp_api::impl_runtime_apis! {
 
 	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
 		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
-			let acceptable = vec![
-				// native token
-				VersionedAssetId::from(AssetId(xcm_config::TokenLocation::get()))
-			];
-
-			Ok(acceptable
-				.into_iter()
-				.filter_map(|asset| asset.into_version(xcm_version).ok())
-				.collect())
+			let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())];
+			XcmPallet::query_acceptable_payment_assets(xcm_version, acceptable_assets)
 		}
 
 		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
@@ -1806,63 +1793,13 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi<Block, RuntimeCall, RuntimeEvent> for Runtime {
-		fn dry_run_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> Result<ExtrinsicDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			use xcm_executor::RecordXcm;
-			pallet_xcm::Pallet::<Runtime>::set_record_xcm(true);
-			let result = Executive::apply_extrinsic(extrinsic).map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_extrinsic",
-					"Applying extrinsic failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::InvalidExtrinsic
-			})?;
-			let local_xcm = pallet_xcm::Pallet::<Runtime>::recorded_xcm();
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(ExtrinsicDryRunEffects {
-				local_xcm: local_xcm.map(VersionedXcm::<()>::V4),
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			XcmPallet::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
 		}
 
 		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			let origin_location: Location = origin_location.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Location version conversion failed with error: {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let xcm: Xcm<RuntimeCall> = xcm.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Xcm version conversion failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256);
-			let result = xcm_executor::XcmExecutor::<xcm_config::XcmConfig>::prepare_and_execute(
-				origin_location,
-				xcm,
-				&mut hash,
-				Weight::MAX, // Max limit available for execution.
-				Weight::zero(),
-			);
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(XcmDryRunEffects {
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+			XcmPallet::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
 		}
 	}
 
@@ -1880,7 +1817,7 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl block_builder_api::BlockBuilder<Block> for Runtime {
+	impl sp_block_builder::BlockBuilder<Block> for Runtime {
 		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
 			Executive::apply_extrinsic(extrinsic)
 		}
@@ -1889,19 +1826,19 @@ sp_api::impl_runtime_apis! {
 			Executive::finalize_block()
 		}
 
-		fn inherent_extrinsics(data: inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
 			data.create_extrinsics()
 		}
 
 		fn check_inherents(
 			block: Block,
-			data: inherents::InherentData,
-		) -> inherents::CheckInherentsResult {
+			data: sp_inherents::InherentData,
+		) -> sp_inherents::CheckInherentsResult {
 			data.check_extrinsics(&block)
 		}
 	}
 
-	impl tx_pool_api::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
 		fn validate_transaction(
 			source: TransactionSource,
 			tx: <Block as BlockT>::Extrinsic,
@@ -1911,14 +1848,14 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
+	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
 		fn offchain_worker(header: &<Block as BlockT>::Header) {
 			Executive::offchain_worker(header)
 		}
 	}
 
 	#[api_version(11)]
-	impl primitives::runtime_api::ParachainHost<Block> for Runtime {
+	impl polkadot_primitives::runtime_api::ParachainHost<Block> for Runtime {
 		fn validators() -> Vec<ValidatorId> {
 			parachains_runtime_api_impl::validators::<Runtime>()
 		}
@@ -1948,7 +1885,7 @@ sp_api::impl_runtime_apis! {
 
 		fn check_validation_outputs(
 			para_id: ParaId,
-			outputs: primitives::CandidateCommitments,
+			outputs: polkadot_primitives::CandidateCommitments,
 		) -> bool {
 			parachains_runtime_api_impl::check_validation_outputs::<Runtime>(para_id, outputs)
 		}
@@ -2005,8 +1942,8 @@ sp_api::impl_runtime_apis! {
 		}
 
 		fn submit_pvf_check_statement(
-			stmt: primitives::PvfCheckStatement,
-			signature: primitives::ValidatorSignature
+			stmt: polkadot_primitives::PvfCheckStatement,
+			signature: polkadot_primitives::ValidatorSignature
 		) {
 			parachains_runtime_api_impl::submit_pvf_check_statement::<Runtime>(stmt, signature)
 		}
@@ -2033,7 +1970,7 @@ sp_api::impl_runtime_apis! {
 		fn key_ownership_proof(
 			validator_id: ValidatorId,
 		) -> Option<slashing::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+			use codec::Encode;
 
 			Historical::prove((PARACHAIN_KEY_TYPE_ID, validator_id))
 				.map(|p| p.encode())
@@ -2054,11 +1991,11 @@ sp_api::impl_runtime_apis! {
 			parachains_runtime_api_impl::minimum_backing_votes::<Runtime>()
 		}
 
-		fn para_backing_state(para_id: ParaId) -> Option<primitives::async_backing::BackingState> {
+		fn para_backing_state(para_id: ParaId) -> Option<polkadot_primitives::async_backing::BackingState> {
 			parachains_runtime_api_impl::backing_state::<Runtime>(para_id)
 		}
 
-		fn async_backing_params() -> primitives::AsyncBackingParams {
+		fn async_backing_params() -> polkadot_primitives::AsyncBackingParams {
 			parachains_runtime_api_impl::async_backing_params::<Runtime>()
 		}
 
@@ -2084,22 +2021,22 @@ sp_api::impl_runtime_apis! {
 	}
 
 	#[api_version(3)]
-	impl beefy_primitives::BeefyApi<Block, BeefyId> for Runtime {
+	impl sp_consensus_beefy::BeefyApi<Block, BeefyId> for Runtime {
 		fn beefy_genesis() -> Option<BlockNumber> {
 			pallet_beefy::GenesisBlock::<Runtime>::get()
 		}
 
-		fn validator_set() -> Option<beefy_primitives::ValidatorSet<BeefyId>> {
+		fn validator_set() -> Option<sp_consensus_beefy::ValidatorSet<BeefyId>> {
 			Beefy::validator_set()
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			equivocation_proof: beefy_primitives::DoubleVotingProof<
+			equivocation_proof: sp_consensus_beefy::DoubleVotingProof<
 				BlockNumber,
 				BeefyId,
 				BeefySignature,
 			>,
-			key_owner_proof: beefy_primitives::OpaqueKeyOwnershipProof,
+			key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			let key_owner_proof = key_owner_proof.decode()?;
 
@@ -2110,14 +2047,14 @@ sp_api::impl_runtime_apis! {
 		}
 
 		fn generate_key_ownership_proof(
-			_set_id: beefy_primitives::ValidatorSetId,
+			_set_id: sp_consensus_beefy::ValidatorSetId,
 			authority_id: BeefyId,
-		) -> Option<beefy_primitives::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+		) -> Option<sp_consensus_beefy::OpaqueKeyOwnershipProof> {
+			use codec::Encode;
 
-			Historical::prove((beefy_primitives::KEY_TYPE, authority_id))
+			Historical::prove((sp_consensus_beefy::KEY_TYPE, authority_id))
 				.map(|p| p.encode())
-				.map(beefy_primitives::OpaqueKeyOwnershipProof::new)
+				.map(sp_consensus_beefy::OpaqueKeyOwnershipProof::new)
 		}
 	}
 
@@ -2196,7 +2133,7 @@ sp_api::impl_runtime_apis! {
 			_set_id: fg_primitives::SetId,
 			authority_id: fg_primitives::AuthorityId,
 		) -> Option<fg_primitives::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+			use codec::Encode;
 
 			Historical::prove((fg_primitives::KEY_TYPE, authority_id))
 				.map(|p| p.encode())
@@ -2204,10 +2141,10 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl babe_primitives::BabeApi<Block> for Runtime {
-		fn configuration() -> babe_primitives::BabeConfiguration {
+	impl sp_consensus_babe::BabeApi<Block> for Runtime {
+		fn configuration() -> sp_consensus_babe::BabeConfiguration {
 			let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG);
-			babe_primitives::BabeConfiguration {
+			sp_consensus_babe::BabeConfiguration {
 				slot_duration: Babe::slot_duration(),
 				epoch_length: EpochDurationInBlocks::get().into(),
 				c: epoch_config.c,
@@ -2217,32 +2154,32 @@ sp_api::impl_runtime_apis! {
 			}
 		}
 
-		fn current_epoch_start() -> babe_primitives::Slot {
+		fn current_epoch_start() -> sp_consensus_babe::Slot {
 			Babe::current_epoch_start()
 		}
 
-		fn current_epoch() -> babe_primitives::Epoch {
+		fn current_epoch() -> sp_consensus_babe::Epoch {
 			Babe::current_epoch()
 		}
 
-		fn next_epoch() -> babe_primitives::Epoch {
+		fn next_epoch() -> sp_consensus_babe::Epoch {
 			Babe::next_epoch()
 		}
 
 		fn generate_key_ownership_proof(
-			_slot: babe_primitives::Slot,
-			authority_id: babe_primitives::AuthorityId,
-		) -> Option<babe_primitives::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+			_slot: sp_consensus_babe::Slot,
+			authority_id: sp_consensus_babe::AuthorityId,
+		) -> Option<sp_consensus_babe::OpaqueKeyOwnershipProof> {
+			use codec::Encode;
 
-			Historical::prove((babe_primitives::KEY_TYPE, authority_id))
+			Historical::prove((sp_consensus_babe::KEY_TYPE, authority_id))
 				.map(|p| p.encode())
-				.map(babe_primitives::OpaqueKeyOwnershipProof::new)
+				.map(sp_consensus_babe::OpaqueKeyOwnershipProof::new)
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			equivocation_proof: babe_primitives::EquivocationProof<<Block as BlockT>::Header>,
-			key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof,
+			equivocation_proof: sp_consensus_babe::EquivocationProof<<Block as BlockT>::Header>,
+			key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			let key_owner_proof = key_owner_proof.decode()?;
 
@@ -2253,7 +2190,7 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl authority_discovery_primitives::AuthorityDiscoveryApi<Block> for Runtime {
+	impl sp_authority_discovery::AuthorityDiscoveryApi<Block> for Runtime {
 		fn authorities() -> Vec<AuthorityDiscoveryId> {
 			parachains_runtime_api_impl::relevant_authority_ids::<Runtime>()
 		}
@@ -2296,11 +2233,11 @@ sp_api::impl_runtime_apis! {
 	}
 
 	impl pallet_beefy_mmr::BeefyMmrApi<Block, Hash> for RuntimeApi {
-		fn authority_set_proof() -> beefy_primitives::mmr::BeefyAuthoritySet<Hash> {
+		fn authority_set_proof() -> sp_consensus_beefy::mmr::BeefyAuthoritySet<Hash> {
 			MmrLeaf::authority_set_proof()
 		}
 
-		fn next_authority_set_proof() -> beefy_primitives::mmr::BeefyNextAuthoritySet<Hash> {
+		fn next_authority_set_proof() -> sp_consensus_beefy::mmr::BeefyNextAuthoritySet<Hash> {
 			MmrLeaf::next_authority_set_proof()
 		}
 	}
@@ -2376,14 +2313,14 @@ sp_api::impl_runtime_apis! {
 			impl frame_benchmarking::baseline::Config for Runtime {}
 			impl pallet_xcm::benchmarking::Config for Runtime {
 				type DeliveryHelper = (
-					runtime_common::xcm_sender::ToParachainDeliveryHelper<
+					polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper<
 						XcmConfig,
 						ExistentialDepositAsset,
 						xcm_config::PriceForChildParachainDelivery,
 						AssetHubParaId,
 						(),
 					>,
-					runtime_common::xcm_sender::ToParachainDeliveryHelper<
+					polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper<
 						XcmConfig,
 						ExistentialDepositAsset,
 						xcm_config::PriceForChildParachainDelivery,
@@ -2442,7 +2379,7 @@ sp_api::impl_runtime_apis! {
 			impl pallet_xcm_benchmarks::Config for Runtime {
 				type XcmConfig = XcmConfig;
 				type AccountIdConverter = LocationConverter;
-				type DeliveryHelper = runtime_common::xcm_sender::ToParachainDeliveryHelper<
+				type DeliveryHelper = polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper<
 					XcmConfig,
 					ExistentialDepositAsset,
 					xcm_config::PriceForChildParachainDelivery,
diff --git a/polkadot/runtime/rococo/src/weights/pallet_treasury.rs b/polkadot/runtime/rococo/src/weights/pallet_treasury.rs
index 144e9d5b872382b7381e2d77c6fb08a8fbece4fa..06246ada72f16fb04623f3fc6534265cc1156b79 100644
--- a/polkadot/runtime/rococo/src/weights/pallet_treasury.rs
+++ b/polkadot/runtime/rococo/src/weights/pallet_treasury.rs
@@ -63,51 +63,6 @@ impl<T: frame_system::Config> pallet_treasury::WeightInfo for WeightInfo<T> {
 			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().writes(3))
 	}
-	/// Storage: Treasury ProposalCount (r:1 w:1)
-	/// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
-	/// Storage: Treasury Proposals (r:0 w:1)
-	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
-	fn propose_spend() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `143`
-		//  Estimated: `1489`
-		// Minimum execution time: 354_000_000 picoseconds.
-		Weight::from_parts(376_000_000, 0)
-			.saturating_add(Weight::from_parts(0, 1489))
-			.saturating_add(T::DbWeight::get().reads(1))
-			.saturating_add(T::DbWeight::get().writes(2))
-	}
-	/// Storage: Treasury Proposals (r:1 w:1)
-	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
-	/// Storage: System Account (r:1 w:1)
-	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
-	fn reject_proposal() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `301`
-		//  Estimated: `3593`
-		// Minimum execution time: 547_000_000 picoseconds.
-		Weight::from_parts(550_000_000, 0)
-			.saturating_add(Weight::from_parts(0, 3593))
-			.saturating_add(T::DbWeight::get().reads(2))
-			.saturating_add(T::DbWeight::get().writes(2))
-	}
-	/// Storage: Treasury Proposals (r:1 w:0)
-	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
-	/// Storage: Treasury Approvals (r:1 w:1)
-	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
-	/// The range of component `p` is `[0, 99]`.
-	fn approve_proposal(p: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `470 + p * (8 ±0)`
-		//  Estimated: `3573`
-		// Minimum execution time: 104_000_000 picoseconds.
-		Weight::from_parts(121_184_402, 0)
-			.saturating_add(Weight::from_parts(0, 3573))
-			// Standard Error: 42_854
-			.saturating_add(Weight::from_parts(153_112, 0).saturating_mul(p.into()))
-			.saturating_add(T::DbWeight::get().reads(2))
-			.saturating_add(T::DbWeight::get().writes(1))
-	}
 	/// Storage: Treasury Approvals (r:1 w:1)
 	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
 	fn remove_approval() -> Weight {
diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_assigned_slots.rs b/polkadot/runtime/rococo/src/weights/runtime_common_assigned_slots.rs
index a6beeded428649fdda8530fda4c10492867f11a2..2aaf282c59d5c82a48e9cb228412eb2e4b83f7a1 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_common_assigned_slots.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_common_assigned_slots.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::assigned_slots`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::assigned_slots::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::assigned_slots::WeightInfo for WeightInfo<T> {
 	/// Storage: `Registrar::Paras` (r:1 w:1)
 	/// Proof: `Registrar::Paras` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Paras::ParaLifecycles` (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_auctions.rs b/polkadot/runtime/rococo/src/weights/runtime_common_auctions.rs
index 3cd7c7a47e90ee1bf6590d0421faf580c1c776f6..897dc1c1752a5697f903b53a394237736fcc4c0c 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_common_auctions.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_common_auctions.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::auctions`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::auctions::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::auctions::WeightInfo for WeightInfo<T> {
 	/// Storage: Auctions AuctionInfo (r:1 w:1)
 	/// Proof: Auctions AuctionInfo (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
 	/// Storage: Auctions AuctionCounter (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_claims.rs b/polkadot/runtime/rococo/src/weights/runtime_common_claims.rs
index 52e0dd24afa0aa5e4cd75d53f53ca7d032ca9588..8fbc798dbd46156c93e606b1ca669b2db706c613 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_common_claims.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_common_claims.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::claims`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::claims::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::claims::WeightInfo for WeightInfo<T> {
 	/// Storage: Claims Claims (r:1 w:1)
 	/// Proof Skipped: Claims Claims (max_values: None, max_size: None, mode: Measured)
 	/// Storage: Claims Signing (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_crowdloan.rs b/polkadot/runtime/rococo/src/weights/runtime_common_crowdloan.rs
index 0e7420cba2e6c981d4f9c0dd9e3c95c9ce26f1c5..b75ff8d42e7e0949f89293fff1e7dd22f0cf8e1e 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_common_crowdloan.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_common_crowdloan.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::crowdloan`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::crowdloan::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::crowdloan::WeightInfo for WeightInfo<T> {
 	/// Storage: Crowdloan Funds (r:1 w:1)
 	/// Proof Skipped: Crowdloan Funds (max_values: None, max_size: None, mode: Measured)
 	/// Storage: Registrar Paras (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs b/polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs
index cec357453b67be400c0191ac7d5c12e6961a4bee..4ea6f67968017e312562842c5f2400754ac83b95 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs
@@ -42,7 +42,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::identity_migrator`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::identity_migrator::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::identity_migrator::WeightInfo for WeightInfo<T> {
 	/// Storage: `Identity::IdentityOf` (r:1 w:1)
 	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`)
 	/// Storage: `Identity::SubsOf` (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_paras_registrar.rs b/polkadot/runtime/rococo/src/weights/runtime_common_paras_registrar.rs
index 0a56562a1a95f24e9efddc6c26e16c4feeaf37c2..0ce09d1be2a46afebc421526bad324acef4bdeb6 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_common_paras_registrar.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_common_paras_registrar.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::paras_registrar`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::paras_registrar::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::paras_registrar::WeightInfo for WeightInfo<T> {
 	/// Storage: Registrar NextFreeParaId (r:1 w:1)
 	/// Proof Skipped: Registrar NextFreeParaId (max_values: Some(1), max_size: None, mode: Measured)
 	/// Storage: Registrar Paras (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_slots.rs b/polkadot/runtime/rococo/src/weights/runtime_common_slots.rs
index 23ab1ed3ee0efff9e95fd3526d022c9becad7b93..8c601aa8486f86ad702c94dfa6ef69ba46407dbf 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_common_slots.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_common_slots.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::slots`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::slots::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::slots::WeightInfo for WeightInfo<T> {
 	/// Storage: Slots Leases (r:1 w:1)
 	/// Proof Skipped: Slots Leases (max_values: None, max_size: None, mode: Measured)
 	/// Storage: System Account (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_assigner_on_demand.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_assigner_on_demand.rs
index dba9e7904c79065c33c9fffc9851171c72c2e66a..9f275e7b8cdc24fdcb251ef95beca3eb2b81be25 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_assigner_on_demand.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_assigner_on_demand.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::assigner_on_demand`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::assigner_on_demand::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::assigner_on_demand::WeightInfo for WeightInfo<T> {
 	/// Storage: `OnDemandAssignmentProvider::QueueStatus` (r:1 w:1)
 	/// Proof: `OnDemandAssignmentProvider::QueueStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `OnDemandAssignmentProvider::ParaIdAffinity` (r:1 w:0)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs
index ca0575cb1b64689b7b016d63a2cfc5080dc874a5..5592a85c90fab339f57ca8d52f2e8e5330aa1813 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::configuration`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::configuration::WeightInfo for WeightInfo<T> {
 	/// Storage: `Configuration::PendingConfigs` (r:1 w:1)
 	/// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_coretime.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_coretime.rs
index d9f2d45207b923e3afe661a6021629cb8441970e..0ad32996c49595db1a414e4d0c0fc5961ea2d3e7 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_coretime.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_coretime.rs
@@ -45,11 +45,11 @@
 use frame_support::{traits::Get, weights::Weight};
 use core::marker::PhantomData;
 
-use runtime_parachains::configuration::{self, WeightInfo as ConfigWeightInfo};
+use polkadot_runtime_parachains::configuration::{self, WeightInfo as ConfigWeightInfo};
 
 /// Weight functions for `runtime_common::coretime`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config + configuration::Config> runtime_parachains::coretime::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config + configuration::Config> polkadot_runtime_parachains::coretime::WeightInfo for WeightInfo<T> {
 	fn request_core_count() -> Weight {
 		<T as configuration::Config>::WeightInfo::set_config_with_u32()
 	}
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_disputes.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_disputes.rs
index 63a8c3addc7da4296041627ee8492945945bce7f..a20515502b1910ccb8eaf6477d3c51e00db9064e 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_disputes.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_disputes.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::disputes`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::disputes::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::disputes::WeightInfo for WeightInfo<T> {
 	/// Storage: ParasDisputes Frozen (r:0 w:1)
 	/// Proof Skipped: ParasDisputes Frozen (max_values: Some(1), max_size: None, mode: Measured)
 	fn force_unfreeze() -> Weight {
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_hrmp.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_hrmp.rs
index 572ecc7d4110f0335b18a3c276032b4f6d285db5..3c9def0b37e5dccdb03b8dd99169e3038edace9a 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_hrmp.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_hrmp.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::hrmp`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::hrmp::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::hrmp::WeightInfo for WeightInfo<T> {
 	/// Storage: `Paras::ParaLifecycles` (r:1 w:0)
 	/// Proof: `Paras::ParaLifecycles` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Hrmp::HrmpOpenChannelRequests` (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_inclusion.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_inclusion.rs
index a121ad774cefecf91e57838e03107fde22674f94..da1b7a0dad9ad9ef93a6d78e564ff6a096add497 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_inclusion.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_inclusion.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::inclusion`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::inclusion::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::inclusion::WeightInfo for WeightInfo<T> {
 	/// Storage: MessageQueue BookStateFor (r:1 w:1)
 	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(55), added: 2530, mode: MaxEncodedLen)
 	/// Storage: MessageQueue Pages (r:1 w:999)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_initializer.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_initializer.rs
index 5c627507dfb682a603152fee2155b620773dcd49..6065c32b17411fe60ba4797fc9d34f224867abdd 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_initializer.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_initializer.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::initializer`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::initializer::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::initializer::WeightInfo for WeightInfo<T> {
 	/// Storage: System Digest (r:1 w:1)
 	/// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured)
 	/// The range of component `d` is `[0, 65536]`.
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_paras.rs
index dfd95006dc7d0a6cedeeab9908d99a2c1c7e561a..2dcabb7c36bbdf994e2460b320566efca709facc 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_paras.rs
@@ -46,7 +46,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::paras`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::paras::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::paras::WeightInfo for WeightInfo<T> {
 	/// Storage: Paras CurrentCodeHash (r:1 w:1)
 	/// Proof Skipped: Paras CurrentCodeHash (max_values: None, max_size: None, mode: Measured)
 	/// Storage: Paras CodeByHashRefs (r:1 w:1)
diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras_inherent.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_paras_inherent.rs
index c250c86665be0eebf54e570e73290a3ebdbdab82..c00966fb8048d0e09f5547eb1eaa354876f27f8c 100644
--- a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras_inherent.rs
+++ b/polkadot/runtime/rococo/src/weights/runtime_parachains_paras_inherent.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::paras_inherent`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::paras_inherent::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::paras_inherent::WeightInfo for WeightInfo<T> {
 	/// Storage: `ParaInherent::Included` (r:1 w:1)
 	/// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `System::ParentHash` (r:1 w:0)
diff --git a/polkadot/runtime/rococo/src/xcm_config.rs b/polkadot/runtime/rococo/src/xcm_config.rs
index decbc795143f006ee50cc98d860e795165269cf5..96416821e4c8396c20c45409fe3ec524ebee066b 100644
--- a/polkadot/runtime/rococo/src/xcm_config.rs
+++ b/polkadot/runtime/rococo/src/xcm_config.rs
@@ -29,11 +29,11 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::EnsureRoot;
-use rococo_runtime_constants::{currency::CENTS, system_parachain::*};
-use runtime_common::{
+use polkadot_runtime_common::{
 	xcm_sender::{ChildParachainRouter, ExponentialPrice},
 	ToAuthor,
 };
+use rococo_runtime_constants::{currency::CENTS, system_parachain::*};
 use sp_core::ConstU32;
 use xcm::latest::prelude::*;
 use xcm_builder::{
diff --git a/polkadot/runtime/test-runtime/Cargo.toml b/polkadot/runtime/test-runtime/Cargo.toml
index 596cc974c82599289eb9203704d37af81811b004..c4d78b1081a626effc136b3a3ee42acd4b514bdf 100644
--- a/polkadot/runtime/test-runtime/Cargo.toml
+++ b/polkadot/runtime/test-runtime/Cargo.toml
@@ -11,17 +11,17 @@ license.workspace = true
 workspace = true
 
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 log = { workspace = true }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 serde = { workspace = true }
 
-authority-discovery-primitives = { package = "sp-authority-discovery", path = "../../../substrate/primitives/authority-discovery", default-features = false }
-babe-primitives = { package = "sp-consensus-babe", path = "../../../substrate/primitives/consensus/babe", default-features = false }
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy", default-features = false }
+sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery", default-features = false }
+sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe", default-features = false }
+sp-consensus-beefy = { path = "../../../substrate/primitives/consensus/beefy", default-features = false }
 sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false }
-offchain-primitives = { package = "sp-offchain", path = "../../../substrate/primitives/offchain", default-features = false }
+sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false }
+sp-offchain = { path = "../../../substrate/primitives/offchain", default-features = false }
 sp-std = { path = "../../../substrate/primitives/std", default-features = false }
 sp-io = { path = "../../../substrate/primitives/io", default-features = false }
 sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
@@ -32,8 +32,8 @@ sp-mmr-primitives = { path = "../../../substrate/primitives/merkle-mountain-rang
 sp-session = { path = "../../../substrate/primitives/session", default-features = false }
 sp-version = { path = "../../../substrate/primitives/version", default-features = false }
 frame-election-provider-support = { path = "../../../substrate/frame/election-provider-support", default-features = false }
-tx-pool-api = { package = "sp-transaction-pool", path = "../../../substrate/primitives/transaction-pool", default-features = false }
-block-builder-api = { package = "sp-block-builder", path = "../../../substrate/primitives/block-builder", default-features = false }
+sp-transaction-pool = { path = "../../../substrate/primitives/transaction-pool", default-features = false }
+sp-block-builder = { path = "../../../substrate/primitives/block-builder", default-features = false }
 
 pallet-authority-discovery = { path = "../../../substrate/frame/authority-discovery", default-features = false }
 pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false }
@@ -56,8 +56,8 @@ pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-featur
 pallet-sudo = { path = "../../../substrate/frame/sudo", default-features = false }
 pallet-vesting = { path = "../../../substrate/frame/vesting", default-features = false }
 
-runtime-common = { package = "polkadot-runtime-common", path = "../common", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false }
+polkadot-runtime-common = { path = "../common", default-features = false }
+polkadot-primitives = { path = "../../primitives", default-features = false }
 pallet-xcm = { path = "../../xcm/pallet-xcm", default-features = false }
 polkadot-runtime-parachains = { path = "../parachains", default-features = false }
 xcm-builder = { package = "staging-xcm-builder", path = "../../xcm/xcm-builder", default-features = false }
@@ -67,7 +67,7 @@ xcm = { package = "staging-xcm", path = "../../xcm", default-features = false }
 [dev-dependencies]
 hex-literal = "0.4.1"
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
-keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" }
+sp-keyring = { path = "../../../substrate/primitives/keyring" }
 sp-trie = { path = "../../../substrate/primitives/trie" }
 serde_json = { workspace = true, default-features = true }
 
@@ -84,18 +84,13 @@ runtime-metrics = [
 ]
 
 std = [
-	"authority-discovery-primitives/std",
-	"babe-primitives/std",
-	"beefy-primitives/std",
-	"block-builder-api/std",
+	"codec/std",
 	"frame-election-provider-support/std",
 	"frame-executive/std",
 	"frame-support/std",
 	"frame-system-rpc-runtime-api/std",
 	"frame-system/std",
-	"inherents/std",
 	"log/std",
-	"offchain-primitives/std",
 	"pallet-authority-discovery/std",
 	"pallet-authorship/std",
 	"pallet-babe/std",
@@ -111,24 +106,29 @@ std = [
 	"pallet-transaction-payment/std",
 	"pallet-vesting/std",
 	"pallet-xcm/std",
-	"parity-scale-codec/std",
+	"polkadot-primitives/std",
+	"polkadot-runtime-common/std",
 	"polkadot-runtime-parachains/std",
-	"primitives/std",
-	"runtime-common/std",
 	"scale-info/std",
 	"serde/std",
 	"sp-api/std",
+	"sp-authority-discovery/std",
+	"sp-block-builder/std",
+	"sp-consensus-babe/std",
+	"sp-consensus-beefy/std",
 	"sp-core/std",
 	"sp-genesis-builder/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-mmr-primitives/std",
+	"sp-offchain/std",
 	"sp-runtime/std",
 	"sp-session/std",
 	"sp-staking/std",
 	"sp-std/std",
+	"sp-transaction-pool/std",
 	"sp-version/std",
 	"test-runtime-constants/std",
-	"tx-pool-api/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
 	"xcm/std",
@@ -148,9 +148,9 @@ runtime-benchmarks = [
 	"pallet-timestamp/runtime-benchmarks",
 	"pallet-vesting/runtime-benchmarks",
 	"pallet-xcm/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
+	"polkadot-runtime-common/runtime-benchmarks",
 	"polkadot-runtime-parachains/runtime-benchmarks",
-	"primitives/runtime-benchmarks",
-	"runtime-common/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
diff --git a/polkadot/runtime/test-runtime/constants/Cargo.toml b/polkadot/runtime/test-runtime/constants/Cargo.toml
index 5b8a4d7a051af84701065a3836d813630011bd0c..ed10ece54f67c43a7b8aedfaebfb03452605cfe8 100644
--- a/polkadot/runtime/test-runtime/constants/Cargo.toml
+++ b/polkadot/runtime/test-runtime/constants/Cargo.toml
@@ -13,13 +13,13 @@ workspace = true
 smallvec = "1.8.0"
 
 frame-support = { path = "../../../../substrate/frame/support", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../../primitives", default-features = false }
+polkadot-primitives = { path = "../../../primitives", default-features = false }
 sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false }
 
 [features]
 default = ["std"]
 std = [
 	"frame-support/std",
-	"primitives/std",
+	"polkadot-primitives/std",
 	"sp-runtime/std",
 ]
diff --git a/polkadot/runtime/test-runtime/constants/src/lib.rs b/polkadot/runtime/test-runtime/constants/src/lib.rs
index 2422762ca38e925cf9666f1c42e2aa10cf70dd90..0d16909b2990590105df1a2dbde0416728e105d1 100644
--- a/polkadot/runtime/test-runtime/constants/src/lib.rs
+++ b/polkadot/runtime/test-runtime/constants/src/lib.rs
@@ -20,7 +20,7 @@ pub mod weights;
 
 /// Money matters.
 pub mod currency {
-	use primitives::Balance;
+	use polkadot_primitives::Balance;
 
 	pub const DOTS: Balance = 1_000_000_000_000;
 	pub const DOLLARS: Balance = DOTS;
@@ -30,7 +30,7 @@ pub mod currency {
 
 /// Time and blocks.
 pub mod time {
-	use primitives::{BlockNumber, Moment};
+	use polkadot_primitives::{BlockNumber, Moment};
 	// Testnet
 	pub const MILLISECS_PER_BLOCK: Moment = 6000;
 	pub const SLOT_DURATION: Moment = MILLISECS_PER_BLOCK;
@@ -55,7 +55,7 @@ pub mod fee {
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
-	use primitives::Balance;
+	use polkadot_primitives::Balance;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 
diff --git a/polkadot/runtime/test-runtime/src/lib.rs b/polkadot/runtime/test-runtime/src/lib.rs
index b11d208171f63d4355efd9ecf8b5b4f87109631a..0fc06570e1aacdd81b2ef9451cd8489450e8d773 100644
--- a/polkadot/runtime/test-runtime/src/lib.rs
+++ b/polkadot/runtime/test-runtime/src/lib.rs
@@ -20,8 +20,8 @@
 // `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.
 #![recursion_limit = "256"]
 
+use codec::Encode;
 use pallet_transaction_payment::FungibleAdapter;
-use parity_scale_codec::Encode;
 use sp_std::{
 	collections::{btree_map::BTreeMap, vec_deque::VecDeque},
 	prelude::*,
@@ -41,8 +41,6 @@ use polkadot_runtime_parachains::{
 	shared as parachains_shared,
 };
 
-use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
-use beefy_primitives::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature};
 use frame_election_provider_support::{
 	bounds::{ElectionBounds, ElectionBoundsBuilder},
 	onchain, SequentialPhragmen,
@@ -55,9 +53,9 @@ use frame_support::{
 };
 use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
 use pallet_session::historical as session_historical;
+use pallet_timestamp::Now;
 use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
-use polkadot_runtime_parachains::reward_points::RewardValidatorsWithEraPoints;
-use primitives::{
+use polkadot_primitives::{
 	slashing, AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CandidateHash,
 	CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams,
 	GroupRotationInfo, Hash as HashT, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage,
@@ -65,10 +63,13 @@ use primitives::{
 	SessionInfo as SessionInfoData, Signature, ValidationCode, ValidationCodeHash, ValidatorId,
 	ValidatorIndex, PARACHAIN_KEY_TYPE_ID,
 };
-use runtime_common::{
+use polkadot_runtime_common::{
 	claims, impl_runtime_weights, paras_sudo_wrapper, BlockHashCount, BlockLength,
 	SlowAdjustingFeeUpdate,
 };
+use polkadot_runtime_parachains::reward_points::RewardValidatorsWithEraPoints;
+use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
+use sp_consensus_beefy::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature};
 use sp_core::{ConstU32, OpaqueMetadata};
 use sp_mmr_primitives as mmr;
 use sp_runtime::{
@@ -121,10 +122,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 };
 
 /// The BABE epoch configuration at genesis.
-pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
-	babe_primitives::BabeEpochConfiguration {
+pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration =
+	sp_consensus_babe::BabeEpochConfiguration {
 		c: PRIMARY_PROBABILITY,
-		allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
+		allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryVRFSlots,
 	};
 
 /// Native version.
@@ -324,7 +325,8 @@ parameter_types! {
 pub struct OnChainSeqPhragmen;
 impl onchain::Config for OnChainSeqPhragmen {
 	type System = Runtime;
-	type Solver = SequentialPhragmen<AccountId, runtime_common::elections::OnChainAccuracy>;
+	type Solver =
+		SequentialPhragmen<AccountId, polkadot_runtime_common::elections::OnChainAccuracy>;
 	type DataProvider = Staking;
 	type WeightInfo = ();
 	type Bounds = ElectionBoundsOnChain;
@@ -338,7 +340,7 @@ impl pallet_staking::Config for Runtime {
 	type Currency = Balances;
 	type CurrencyBalance = Balance;
 	type UnixTime = Timestamp;
-	type CurrencyToVote = runtime_common::CurrencyToVote;
+	type CurrencyToVote = polkadot_runtime_common::CurrencyToVote;
 	type RewardRemainder = ();
 	type RuntimeEvent = RuntimeEvent;
 	type Slash = ();
@@ -361,7 +363,7 @@ impl pallet_staking::Config for Runtime {
 	type MaxUnlockingChunks = frame_support::traits::ConstU32<32>;
 	type MaxControllersInDeprecationBatch = ConstU32<5900>;
 	type HistoryDepth = frame_support::traits::ConstU32<84>;
-	type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig;
+	type BenchmarkingConfig = polkadot_runtime_common::StakingBenchmarkingConfig;
 	type EventListeners = ();
 	type WeightInfo = ();
 	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
@@ -796,7 +798,7 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl block_builder_api::BlockBuilder<Block> for Runtime {
+	impl sp_block_builder::BlockBuilder<Block> for Runtime {
 		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
 			Executive::apply_extrinsic(extrinsic)
 		}
@@ -805,19 +807,19 @@ sp_api::impl_runtime_apis! {
 			Executive::finalize_block()
 		}
 
-		fn inherent_extrinsics(data: inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
 			data.create_extrinsics()
 		}
 
 		fn check_inherents(
 			block: Block,
-			data: inherents::InherentData,
-		) -> inherents::CheckInherentsResult {
+			data: sp_inherents::InherentData,
+		) -> sp_inherents::CheckInherentsResult {
 			data.check_extrinsics(&block)
 		}
 	}
 
-	impl tx_pool_api::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
 		fn validate_transaction(
 			source: TransactionSource,
 			tx: <Block as BlockT>::Extrinsic,
@@ -827,20 +829,20 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
+	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
 		fn offchain_worker(header: &<Block as BlockT>::Header) {
 			Executive::offchain_worker(header)
 		}
 	}
 
-	impl authority_discovery_primitives::AuthorityDiscoveryApi<Block> for Runtime {
+	impl sp_authority_discovery::AuthorityDiscoveryApi<Block> for Runtime {
 		fn authorities() -> Vec<AuthorityDiscoveryId> {
 			runtime_impl::relevant_authority_ids::<Runtime>()
 		}
 	}
 
 	#[api_version(11)]
-	impl primitives::runtime_api::ParachainHost<Block> for Runtime {
+	impl polkadot_primitives::runtime_api::ParachainHost<Block> for Runtime {
 		fn validators() -> Vec<ValidatorId> {
 			runtime_impl::validators::<Runtime>()
 		}
@@ -871,7 +873,7 @@ sp_api::impl_runtime_apis! {
 
 		fn check_validation_outputs(
 			para_id: ParaId,
-			outputs: primitives::CandidateCommitments,
+			outputs: polkadot_primitives::CandidateCommitments,
 		) -> bool {
 			runtime_impl::check_validation_outputs::<Runtime>(para_id, outputs)
 		}
@@ -924,8 +926,8 @@ sp_api::impl_runtime_apis! {
 		}
 
 		fn submit_pvf_check_statement(
-			stmt: primitives::PvfCheckStatement,
-			signature: primitives::ValidatorSignature,
+			stmt: polkadot_primitives::PvfCheckStatement,
+			signature: polkadot_primitives::ValidatorSignature,
 		) {
 			runtime_impl::submit_pvf_check_statement::<Runtime>(stmt, signature)
 		}
@@ -952,7 +954,7 @@ sp_api::impl_runtime_apis! {
 		fn key_ownership_proof(
 			validator_id: ValidatorId,
 		) -> Option<slashing::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+			use codec::Encode;
 
 			Historical::prove((PARACHAIN_KEY_TYPE_ID, validator_id))
 				.map(|p| p.encode())
@@ -973,15 +975,15 @@ sp_api::impl_runtime_apis! {
 			runtime_impl::minimum_backing_votes::<Runtime>()
 		}
 
-		fn para_backing_state(para_id: ParaId) -> Option<primitives::async_backing::BackingState> {
+		fn para_backing_state(para_id: ParaId) -> Option<polkadot_primitives::async_backing::BackingState> {
 			runtime_impl::backing_state::<Runtime>(para_id)
 		}
 
-		fn async_backing_params() -> primitives::AsyncBackingParams {
+		fn async_backing_params() -> polkadot_primitives::AsyncBackingParams {
 			runtime_impl::async_backing_params::<Runtime>()
 		}
 
-		fn approval_voting_params() -> primitives::ApprovalVotingParams {
+		fn approval_voting_params() -> polkadot_primitives::ApprovalVotingParams {
 			runtime_impl::approval_voting_params::<Runtime>()
 		}
 
@@ -989,7 +991,7 @@ sp_api::impl_runtime_apis! {
 			runtime_impl::disabled_validators::<Runtime>()
 		}
 
-		fn node_features() -> primitives::NodeFeatures {
+		fn node_features() -> polkadot_primitives::NodeFeatures {
 			runtime_impl::node_features::<Runtime>()
 		}
 
@@ -1002,32 +1004,32 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl beefy_primitives::BeefyApi<Block, BeefyId> for Runtime {
+	impl sp_consensus_beefy::BeefyApi<Block, BeefyId> for Runtime {
 		fn beefy_genesis() -> Option<BlockNumber> {
 			// dummy implementation due to lack of BEEFY pallet.
 			None
 		}
 
-		fn validator_set() -> Option<beefy_primitives::ValidatorSet<BeefyId>> {
+		fn validator_set() -> Option<sp_consensus_beefy::ValidatorSet<BeefyId>> {
 			// dummy implementation due to lack of BEEFY pallet.
 			None
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			_equivocation_proof: beefy_primitives::DoubleVotingProof<
+			_equivocation_proof: sp_consensus_beefy::DoubleVotingProof<
 				BlockNumber,
 				BeefyId,
 				BeefySignature,
 			>,
-			_key_owner_proof: beefy_primitives::OpaqueKeyOwnershipProof,
+			_key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			None
 		}
 
 		fn generate_key_ownership_proof(
-			_set_id: beefy_primitives::ValidatorSetId,
+			_set_id: sp_consensus_beefy::ValidatorSetId,
 			_authority_id: BeefyId,
-		) -> Option<beefy_primitives::OpaqueKeyOwnershipProof> {
+		) -> Option<sp_consensus_beefy::OpaqueKeyOwnershipProof> {
 			None
 		}
 	}
@@ -1090,10 +1092,10 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl babe_primitives::BabeApi<Block> for Runtime {
-		fn configuration() -> babe_primitives::BabeConfiguration {
+	impl sp_consensus_babe::BabeApi<Block> for Runtime {
+		fn configuration() -> sp_consensus_babe::BabeConfiguration {
 			let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG);
-			babe_primitives::BabeConfiguration {
+			sp_consensus_babe::BabeConfiguration {
 				slot_duration: Babe::slot_duration(),
 				epoch_length: EpochDuration::get(),
 				c: epoch_config.c,
@@ -1103,28 +1105,28 @@ sp_api::impl_runtime_apis! {
 			}
 		}
 
-		fn current_epoch_start() -> babe_primitives::Slot {
+		fn current_epoch_start() -> sp_consensus_babe::Slot {
 			Babe::current_epoch_start()
 		}
 
-		fn current_epoch() -> babe_primitives::Epoch {
+		fn current_epoch() -> sp_consensus_babe::Epoch {
 			Babe::current_epoch()
 		}
 
-		fn next_epoch() -> babe_primitives::Epoch {
+		fn next_epoch() -> sp_consensus_babe::Epoch {
 			Babe::next_epoch()
 		}
 
 		fn generate_key_ownership_proof(
-			_slot: babe_primitives::Slot,
-			_authority_id: babe_primitives::AuthorityId,
-		) -> Option<babe_primitives::OpaqueKeyOwnershipProof> {
+			_slot: sp_consensus_babe::Slot,
+			_authority_id: sp_consensus_babe::AuthorityId,
+		) -> Option<sp_consensus_babe::OpaqueKeyOwnershipProof> {
 			None
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			_equivocation_proof: babe_primitives::EquivocationProof<<Block as BlockT>::Header>,
-			_key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof,
+			_equivocation_proof: sp_consensus_babe::EquivocationProof<<Block as BlockT>::Header>,
+			_key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			None
 		}
@@ -1185,7 +1187,7 @@ sp_api::impl_runtime_apis! {
 
 	impl crate::GetLastTimestamp<Block> for Runtime {
 		fn get_last_timestamp() -> u64 {
-			Timestamp::now()
+			Now::<Runtime>::get()
 		}
 	}
 
diff --git a/polkadot/runtime/test-runtime/src/xcm_config.rs b/polkadot/runtime/test-runtime/src/xcm_config.rs
index fc3d0dc42a3b93408f15c8363b631aa9761cbe36..b1d86ff9a85e9fc6a9a5f361b933d78898715d49 100644
--- a/polkadot/runtime/test-runtime/src/xcm_config.rs
+++ b/polkadot/runtime/test-runtime/src/xcm_config.rs
@@ -20,8 +20,8 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::EnsureRoot;
+use polkadot_runtime_common::xcm_sender::{ChildParachainRouter, PriceForMessageDelivery};
 use polkadot_runtime_parachains::FeeTracker;
-use runtime_common::xcm_sender::{ChildParachainRouter, PriceForMessageDelivery};
 use xcm::latest::prelude::*;
 use xcm_builder::{
 	AllowUnpaidExecutionFrom, EnsureXcmOrigin, FixedWeightBounds, FrameTransactionalProcessor,
diff --git a/polkadot/runtime/westend/Cargo.toml b/polkadot/runtime/westend/Cargo.toml
index 6a919dd00a98985714b9ab21bc17dd53f08dc0fe..ccb8a02b981cc36782c796eae7b13081e0c985de 100644
--- a/polkadot/runtime/westend/Cargo.toml
+++ b/polkadot/runtime/westend/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 
 [dependencies]
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 log = { workspace = true }
 rustc-hex = { version = "2.1.0", default-features = false }
@@ -20,12 +20,12 @@ serde = { workspace = true }
 serde_derive = { optional = true, workspace = true }
 smallvec = "1.8.0"
 
-authority-discovery-primitives = { package = "sp-authority-discovery", path = "../../../substrate/primitives/authority-discovery", default-features = false }
-babe-primitives = { package = "sp-consensus-babe", path = "../../../substrate/primitives/consensus/babe", default-features = false }
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy", default-features = false }
+sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery", default-features = false }
+sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe", default-features = false }
+sp-consensus-beefy = { path = "../../../substrate/primitives/consensus/beefy", default-features = false }
 binary-merkle-tree = { path = "../../../substrate/utils/binary-merkle-tree", default-features = false }
-inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false }
-offchain-primitives = { package = "sp-offchain", path = "../../../substrate/primitives/offchain", default-features = false }
+sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false }
+sp-offchain = { path = "../../../substrate/primitives/offchain", default-features = false }
 sp-api = { path = "../../../substrate/primitives/api", default-features = false }
 sp-application-crypto = { path = "../../../substrate/primitives/application-crypto", default-features = false }
 sp-arithmetic = { path = "../../../substrate/primitives/arithmetic", default-features = false }
@@ -39,12 +39,13 @@ sp-core = { path = "../../../substrate/primitives/core", default-features = fals
 sp-session = { path = "../../../substrate/primitives/session", default-features = false }
 sp-storage = { path = "../../../substrate/primitives/storage", default-features = false }
 sp-version = { path = "../../../substrate/primitives/version", default-features = false }
-tx-pool-api = { package = "sp-transaction-pool", path = "../../../substrate/primitives/transaction-pool", default-features = false }
-block-builder-api = { package = "sp-block-builder", path = "../../../substrate/primitives/block-builder", default-features = false }
+sp-transaction-pool = { path = "../../../substrate/primitives/transaction-pool", default-features = false }
+sp-block-builder = { path = "../../../substrate/primitives/block-builder", default-features = false }
 sp-npos-elections = { path = "../../../substrate/primitives/npos-elections", default-features = false }
 
 frame-election-provider-support = { path = "../../../substrate/frame/election-provider-support", default-features = false }
 frame-executive = { path = "../../../substrate/frame/executive", default-features = false }
+frame-metadata-hash-extension = { path = "../../../substrate/frame/metadata-hash-extension", default-features = false }
 frame-support = { path = "../../../substrate/frame/support", default-features = false, features = ["experimental", "tuples-96"] }
 frame-system = { path = "../../../substrate/frame/system", default-features = false }
 frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api", default-features = false }
@@ -82,6 +83,7 @@ pallet-society = { path = "../../../substrate/frame/society", default-features =
 pallet-staking = { path = "../../../substrate/frame/staking", default-features = false }
 pallet-staking-reward-curve = { package = "pallet-staking-reward-curve", path = "../../../substrate/frame/staking/reward-curve" }
 pallet-staking-runtime-api = { path = "../../../substrate/frame/staking/runtime-api", default-features = false }
+pallet-delegated-staking = { path = "../../../substrate/frame/delegated-staking", default-features = false }
 pallet-state-trie-migration = { path = "../../../substrate/frame/state-trie-migration", default-features = false }
 pallet-sudo = { path = "../../../substrate/frame/sudo", default-features = false }
 pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false }
@@ -105,10 +107,10 @@ pallet-offences-benchmarking = { path = "../../../substrate/frame/offences/bench
 pallet-session-benchmarking = { path = "../../../substrate/frame/session/benchmarking", default-features = false, optional = true }
 hex-literal = { version = "0.4.1", optional = true }
 
-runtime-common = { package = "polkadot-runtime-common", path = "../common", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false }
+polkadot-runtime-common = { path = "../common", default-features = false }
+polkadot-primitives = { path = "../../primitives", default-features = false }
 polkadot-parachain-primitives = { path = "../../parachain", default-features = false }
-runtime-parachains = { package = "polkadot-runtime-parachains", path = "../parachains", default-features = false }
+polkadot-runtime-parachains = { path = "../parachains", default-features = false }
 
 xcm = { package = "staging-xcm", path = "../../xcm", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../../xcm/xcm-executor", default-features = false }
@@ -118,7 +120,7 @@ xcm-fee-payment-runtime-api = { path = "../../xcm/xcm-fee-payment-runtime-api",
 [dev-dependencies]
 hex-literal = "0.4.1"
 tiny-keccak = { version = "2.0.2", features = ["keccak"] }
-keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" }
+sp-keyring = { path = "../../../substrate/primitives/keyring" }
 serde_json = { workspace = true, default-features = true }
 remote-externalities = { package = "frame-remote-externalities", path = "../../../substrate/utils/frame/remote-externalities" }
 tokio = { version = "1.24.2", features = ["macros"] }
@@ -132,23 +134,19 @@ default = ["std"]
 no_std = []
 only-staking = []
 std = [
-	"authority-discovery-primitives/std",
-	"babe-primitives/std",
-	"beefy-primitives/std",
 	"binary-merkle-tree/std",
 	"bitvec/std",
-	"block-builder-api/std",
+	"codec/std",
 	"frame-benchmarking?/std",
 	"frame-election-provider-support/std",
 	"frame-executive/std",
+	"frame-metadata-hash-extension/std",
 	"frame-support/std",
 	"frame-system-benchmarking?/std",
 	"frame-system-rpc-runtime-api/std",
 	"frame-system/std",
 	"frame-try-runtime/std",
-	"inherents/std",
 	"log/std",
-	"offchain-primitives/std",
 	"pallet-asset-rate/std",
 	"pallet-authority-discovery/std",
 	"pallet-authorship/std",
@@ -159,6 +157,7 @@ std = [
 	"pallet-beefy/std",
 	"pallet-collective/std",
 	"pallet-conviction-voting/std",
+	"pallet-delegated-staking/std",
 	"pallet-democracy/std",
 	"pallet-election-provider-multi-phase/std",
 	"pallet-election-provider-support-benchmarking?/std",
@@ -198,11 +197,10 @@ std = [
 	"pallet-whitelist/std",
 	"pallet-xcm-benchmarks?/std",
 	"pallet-xcm/std",
-	"parity-scale-codec/std",
 	"polkadot-parachain-primitives/std",
-	"primitives/std",
-	"runtime-common/std",
-	"runtime-parachains/std",
+	"polkadot-primitives/std",
+	"polkadot-runtime-common/std",
+	"polkadot-runtime-parachains/std",
 	"rustc-hex/std",
 	"scale-info/std",
 	"serde/std",
@@ -210,19 +208,25 @@ std = [
 	"sp-api/std",
 	"sp-application-crypto/std",
 	"sp-arithmetic/std",
+	"sp-authority-discovery/std",
+	"sp-block-builder/std",
+	"sp-consensus-babe/std",
+	"sp-consensus-beefy/std",
 	"sp-core/std",
 	"sp-genesis-builder/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-mmr-primitives/std",
 	"sp-npos-elections/std",
+	"sp-offchain/std",
 	"sp-runtime/std",
 	"sp-session/std",
 	"sp-staking/std",
 	"sp-std/std",
 	"sp-storage/std",
 	"sp-tracing/std",
+	"sp-transaction-pool/std",
 	"sp-version/std",
-	"tx-pool-api/std",
 	"westend-runtime-constants/std",
 	"xcm-builder/std",
 	"xcm-executor/std",
@@ -242,6 +246,7 @@ runtime-benchmarks = [
 	"pallet-balances/runtime-benchmarks",
 	"pallet-collective/runtime-benchmarks",
 	"pallet-conviction-voting/runtime-benchmarks",
+	"pallet-delegated-staking/runtime-benchmarks",
 	"pallet-democracy/runtime-benchmarks",
 	"pallet-election-provider-multi-phase/runtime-benchmarks",
 	"pallet-election-provider-support-benchmarking/runtime-benchmarks",
@@ -276,9 +281,9 @@ runtime-benchmarks = [
 	"pallet-xcm-benchmarks/runtime-benchmarks",
 	"pallet-xcm/runtime-benchmarks",
 	"polkadot-parachain-primitives/runtime-benchmarks",
-	"primitives/runtime-benchmarks",
-	"runtime-common/runtime-benchmarks",
-	"runtime-parachains/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
+	"polkadot-runtime-common/runtime-benchmarks",
+	"polkadot-runtime-parachains/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
@@ -302,6 +307,7 @@ try-runtime = [
 	"pallet-beefy/try-runtime",
 	"pallet-collective/try-runtime",
 	"pallet-conviction-voting/try-runtime",
+	"pallet-delegated-staking/try-runtime",
 	"pallet-democracy/try-runtime",
 	"pallet-election-provider-multi-phase/try-runtime",
 	"pallet-elections-phragmen/try-runtime",
@@ -333,17 +339,20 @@ try-runtime = [
 	"pallet-vesting/try-runtime",
 	"pallet-whitelist/try-runtime",
 	"pallet-xcm/try-runtime",
-	"runtime-common/try-runtime",
-	"runtime-parachains/try-runtime",
+	"polkadot-runtime-common/try-runtime",
+	"polkadot-runtime-parachains/try-runtime",
 	"sp-runtime/try-runtime",
 ]
 
+# Enable the metadata hash generation in the wasm builder.
+metadata-hash = ["substrate-wasm-builder/metadata-hash"]
+
 # Set timing constants (e.g. session period) to faster versions to speed up testing.
 fast-runtime = []
 
-runtime-metrics = ["runtime-parachains/runtime-metrics", "sp-io/with-tracing"]
+runtime-metrics = ["polkadot-runtime-parachains/runtime-metrics", "sp-io/with-tracing"]
 
 # A feature that should be enabled when the runtime should be built for on-chain
 # deployment. This will disable stuff that shouldn't be part of the on-chain wasm
 # to make it smaller, like logging for example.
-on-chain-release-build = ["sp-api/disable-logging"]
+on-chain-release-build = ["metadata-hash", "sp-api/disable-logging"]
diff --git a/polkadot/runtime/westend/build.rs b/polkadot/runtime/westend/build.rs
index 0b3e12c78c746517a32538c8c1e5f9da63747fc5..8ff3a4fb9112c670882cd9794d6291d74cee194f 100644
--- a/polkadot/runtime/westend/build.rs
+++ b/polkadot/runtime/westend/build.rs
@@ -14,8 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use substrate_wasm_builder::WasmBuilder;
+#[cfg(all(not(feature = "metadata-hash"), feature = "std"))]
+fn main() {
+	substrate_wasm_builder::WasmBuilder::build_using_defaults();
+}
 
+#[cfg(all(feature = "metadata-hash", feature = "std"))]
 fn main() {
-	WasmBuilder::build_using_defaults();
+	substrate_wasm_builder::WasmBuilder::init_with_defaults()
+		.enable_metadata_hash("WND", 12)
+		.build();
 }
+
+#[cfg(not(feature = "std"))]
+fn main() {}
diff --git a/polkadot/runtime/westend/constants/Cargo.toml b/polkadot/runtime/westend/constants/Cargo.toml
index 81df8f4f024dd32f23edd679b651e2edc4d32687..d50b168fac52ee12709ece481375f73efdd878ac 100644
--- a/polkadot/runtime/westend/constants/Cargo.toml
+++ b/polkadot/runtime/westend/constants/Cargo.toml
@@ -13,8 +13,8 @@ workspace = true
 smallvec = "1.8.0"
 
 frame-support = { path = "../../../../substrate/frame/support", default-features = false }
-primitives = { package = "polkadot-primitives", path = "../../../primitives", default-features = false }
-runtime-common = { package = "polkadot-runtime-common", path = "../../common", default-features = false }
+polkadot-primitives = { path = "../../../primitives", default-features = false }
+polkadot-runtime-common = { path = "../../common", default-features = false }
 sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false }
 sp-weights = { path = "../../../../substrate/primitives/weights", default-features = false }
 sp-core = { path = "../../../../substrate/primitives/core", default-features = false }
@@ -26,8 +26,8 @@ xcm-builder = { package = "staging-xcm-builder", path = "../../../xcm/xcm-builde
 default = ["std"]
 std = [
 	"frame-support/std",
-	"primitives/std",
-	"runtime-common/std",
+	"polkadot-primitives/std",
+	"polkadot-runtime-common/std",
 	"sp-core/std",
 	"sp-runtime/std",
 	"sp-weights/std",
diff --git a/polkadot/runtime/westend/constants/src/lib.rs b/polkadot/runtime/westend/constants/src/lib.rs
index 1a4c1f3110614508cf3d934fe82cd5884f49d365..58048272e791a06b9169bf2ccf59a5e8d005c2d6 100644
--- a/polkadot/runtime/westend/constants/src/lib.rs
+++ b/polkadot/runtime/westend/constants/src/lib.rs
@@ -20,7 +20,7 @@ pub mod weights;
 
 /// Money matters.
 pub mod currency {
-	use primitives::Balance;
+	use polkadot_primitives::Balance;
 
 	/// The existential deposit.
 	pub const EXISTENTIAL_DEPOSIT: Balance = 1 * CENTS;
@@ -37,8 +37,8 @@ pub mod currency {
 
 /// Time and blocks.
 pub mod time {
-	use primitives::{BlockNumber, Moment};
-	use runtime_common::prod_or_fast;
+	use polkadot_primitives::{BlockNumber, Moment};
+	use polkadot_runtime_common::prod_or_fast;
 
 	pub const MILLISECS_PER_BLOCK: Moment = 6000;
 	pub const SLOT_DURATION: Moment = MILLISECS_PER_BLOCK;
@@ -62,7 +62,7 @@ pub mod fee {
 	use frame_support::weights::{
 		WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial,
 	};
-	use primitives::Balance;
+	use polkadot_primitives::Balance;
 	use smallvec::smallvec;
 	pub use sp_runtime::Perbill;
 
@@ -98,7 +98,7 @@ pub mod fee {
 
 /// System Parachains.
 pub mod system_parachain {
-	use primitives::Id;
+	use polkadot_primitives::Id;
 	use xcm_builder::IsChildSystemParachain;
 
 	/// Network's Asset Hub parachain ID.
@@ -144,7 +144,7 @@ mod tests {
 	};
 	use crate::weights::ExtrinsicBaseWeight;
 	use frame_support::weights::WeightToFee as WeightToFeeT;
-	use runtime_common::MAXIMUM_BLOCK_WEIGHT;
+	use polkadot_runtime_common::MAXIMUM_BLOCK_WEIGHT;
 
 	#[test]
 	// Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds.
diff --git a/polkadot/runtime/westend/src/impls.rs b/polkadot/runtime/westend/src/impls.rs
index 71e6b696a20a0feb89e669067d02b12e6eeb89fd..d7ca677a7620e26aeb2f00e35ec23e67057c8293 100644
--- a/polkadot/runtime/westend/src/impls.rs
+++ b/polkadot/runtime/westend/src/impls.rs
@@ -15,11 +15,11 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::xcm_config;
+use codec::{Decode, Encode};
 use frame_support::pallet_prelude::DispatchResult;
 use frame_system::RawOrigin;
-use parity_scale_codec::{Decode, Encode};
-use primitives::Balance;
-use runtime_common::identity_migrator::{OnReapIdentity, WeightInfo};
+use polkadot_primitives::Balance;
+use polkadot_runtime_common::identity_migrator::{OnReapIdentity, WeightInfo};
 use sp_std::{marker::PhantomData, prelude::*};
 use westend_runtime_constants::currency::*;
 use xcm::{latest::prelude::*, VersionedLocation, VersionedXcm};
diff --git a/polkadot/runtime/westend/src/lib.rs b/polkadot/runtime/westend/src/lib.rs
index 652820fad981308930c38b62148caf18aa47edce..4d6a885b4dad300bee84010f0d576ab176bd29c6 100644
--- a/polkadot/runtime/westend/src/lib.rs
+++ b/polkadot/runtime/westend/src/lib.rs
@@ -20,11 +20,7 @@
 // `#[frame_support::runtime]!` does a lot of recursion and requires us to increase the limit.
 #![recursion_limit = "512"]
 
-use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
-use beefy_primitives::{
-	ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature},
-	mmr::{BeefyDataProvider, MmrLeafVersion},
-};
+use codec::{Decode, Encode, MaxEncodedLen};
 use frame_election_provider_support::{bounds::ElectionBoundsBuilder, onchain, SequentialPhragmen};
 use frame_support::{
 	derive_impl,
@@ -33,7 +29,7 @@ use frame_support::{
 	traits::{
 		fungible::HoldConsideration, tokens::UnityOrOuterConversion, ConstU32, Contains, EitherOf,
 		EitherOfDiverse, EverythingBut, FromContains, InstanceFilter, KeyOwnerProofSystem,
-		LinearStoragePrice, ProcessMessage, ProcessMessageError, WithdrawReasons,
+		LinearStoragePrice, ProcessMessage, ProcessMessageError, VariantCountOf, WithdrawReasons,
 	},
 	weights::{ConstantMultiplier, WeightMeter, WeightToFee as _},
 	PalletId,
@@ -43,8 +39,7 @@ use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
 use pallet_identity::legacy::IdentityInfo;
 use pallet_session::historical as session_historical;
 use pallet_transaction_payment::{FeeDetails, FungibleAdapter, RuntimeDispatchInfo};
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
-use primitives::{
+use polkadot_primitives::{
 	slashing, AccountId, AccountIndex, ApprovalVotingParams, Balance, BlockNumber, CandidateEvent,
 	CandidateHash, CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams,
 	GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment,
@@ -52,7 +47,7 @@ use primitives::{
 	ScrapedOnChainVotes, SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId,
 	ValidatorIndex, ValidatorSignature, PARACHAIN_KEY_TYPE_ID,
 };
-use runtime_common::{
+use polkadot_runtime_common::{
 	assigned_slots, auctions, crowdloan,
 	elections::OnChainAccuracy,
 	identity_migrator, impl_runtime_weights,
@@ -65,7 +60,7 @@ use runtime_common::{
 	BalanceToU256, BlockHashCount, BlockLength, CurrencyToVote, SlowAdjustingFeeUpdate,
 	U256ToBalance,
 };
-use runtime_parachains::{
+use polkadot_runtime_parachains::{
 	assigner_coretime as parachains_assigner_coretime,
 	assigner_on_demand as parachains_assigner_on_demand, configuration as parachains_configuration,
 	configuration::ActiveConfigHrmpChannelSizeAndCapacityRatio,
@@ -82,6 +77,11 @@ use runtime_parachains::{
 	shared as parachains_shared,
 };
 use scale_info::TypeInfo;
+use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
+use sp_consensus_beefy::{
+	ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature},
+	mmr::{BeefyDataProvider, MmrLeafVersion},
+};
 use sp_core::{ConstU8, OpaqueMetadata, RuntimeDebug, H256};
 use sp_runtime::{
 	create_runtime_str,
@@ -102,14 +102,11 @@ use sp_std::{
 #[cfg(any(feature = "std", test))]
 use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
-use xcm::{
-	latest::prelude::*, IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation,
-	VersionedXcm,
-};
+use xcm::{latest::prelude::*, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm};
 use xcm_builder::PayOverXcm;
 
 use xcm_fee_payment_runtime_api::{
-	dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects},
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
 	fees::Error as XcmPaymentApiError,
 };
 
@@ -157,18 +154,18 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("westend"),
 	impl_name: create_runtime_str!("parity-westend"),
 	authoring_version: 2,
-	spec_version: 1_011_000,
+	spec_version: 1_013_000,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
-	transaction_version: 25,
+	transaction_version: 26,
 	state_version: 1,
 };
 
 /// The BABE epoch configuration at genesis.
-pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =
-	babe_primitives::BabeEpochConfiguration {
+pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration =
+	sp_consensus_babe::BabeEpochConfiguration {
 		c: PRIMARY_PROBABILITY,
-		allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
+		allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryVRFSlots,
 	};
 
 /// Native version.
@@ -313,7 +310,7 @@ impl pallet_balances::Config for Runtime {
 	type RuntimeHoldReason = RuntimeHoldReason;
 	type RuntimeFreezeReason = RuntimeFreezeReason;
 	type FreezeIdentifier = RuntimeFreezeReason;
-	type MaxFreezes = ConstU32<1>;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
 }
 
 parameter_types! {
@@ -573,7 +570,7 @@ impl pallet_election_provider_multi_phase::Config for Runtime {
 		pallet_election_provider_multi_phase::SolutionAccuracyOf<Self>,
 		(),
 	>;
-	type BenchmarkingConfig = runtime_common::elections::BenchmarkConfig;
+	type BenchmarkingConfig = polkadot_runtime_common::elections::BenchmarkConfig;
 	type ForceOrigin = EnsureRoot<AccountId>;
 	type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo<Self>;
 	type MaxWinners = MaxActiveValidators;
@@ -646,8 +643,8 @@ impl pallet_staking::Config for Runtime {
 	type MaxUnlockingChunks = frame_support::traits::ConstU32<32>;
 	type HistoryDepth = frame_support::traits::ConstU32<84>;
 	type MaxControllersInDeprecationBatch = MaxControllersInDeprecationBatch;
-	type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig;
-	type EventListeners = NominationPools;
+	type BenchmarkingConfig = polkadot_runtime_common::StakingBenchmarkingConfig;
+	type EventListeners = (NominationPools, DelegatedStaking);
 	type WeightInfo = weights::pallet_staking::WeightInfo<Runtime>;
 	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
@@ -664,9 +661,6 @@ impl pallet_fast_unstake::Config for Runtime {
 }
 
 parameter_types! {
-	pub const ProposalBond: Permill = Permill::from_percent(5);
-	pub const ProposalBondMinimum: Balance = 2000 * CENTS;
-	pub const ProposalBondMaximum: Balance = 1 * GRAND;
 	pub const SpendPeriod: BlockNumber = 6 * DAYS;
 	pub const Burn: Permill = Permill::from_perthousand(2);
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
@@ -693,9 +687,6 @@ impl pallet_treasury::Config for Runtime {
 	type RejectOrigin = EitherOfDiverse<EnsureRoot<AccountId>, Treasurer>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = Treasury;
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ProposalBondMinimum;
-	type ProposalBondMaximum = ProposalBondMaximum;
 	type SpendPeriod = SpendPeriod;
 	type Burn = Burn;
 	type BurnDestination = ();
@@ -727,7 +718,7 @@ impl pallet_treasury::Config for Runtime {
 	>;
 	type PayoutPeriod = PayoutSpendPeriod;
 	#[cfg(feature = "runtime-benchmarks")]
-	type BenchmarkHelper = runtime_common::impls::benchmarks::TreasuryArguments;
+	type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::TreasuryArguments;
 }
 
 impl pallet_offences::Config for Runtime {
@@ -797,6 +788,7 @@ where
 			frame_system::CheckNonce::<Runtime>::from(nonce),
 			frame_system::CheckWeight::<Runtime>::new(),
 			pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
+			frame_metadata_hash_extension::CheckMetadataHash::<Runtime>::new(true),
 		);
 		let raw_payload = SignedPayload::new(call, extra)
 			.map_err(|e| {
@@ -1359,7 +1351,8 @@ impl pallet_nomination_pools::Config for Runtime {
 	type RewardCounter = FixedU128;
 	type BalanceToU256 = BalanceToU256;
 	type U256ToBalance = U256ToBalance;
-	type Staking = Staking;
+	type StakeAdapter =
+		pallet_nomination_pools::adapter::DelegateStake<Self, Staking, DelegatedStaking>;
 	type PostUnbondingPoolsWindow = ConstU32<4>;
 	type MaxMetadataLen = ConstU32<256>;
 	// we use the same number of allowed unlocking chunks as with staking.
@@ -1369,6 +1362,21 @@ impl pallet_nomination_pools::Config for Runtime {
 	type AdminOrigin = EitherOf<EnsureRoot<AccountId>, StakingAdmin>;
 }
 
+parameter_types! {
+	pub const DelegatedStakingPalletId: PalletId = PalletId(*b"py/dlstk");
+	pub const SlashRewardFraction: Perbill = Perbill::from_percent(1);
+}
+
+impl pallet_delegated_staking::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = DelegatedStakingPalletId;
+	type Currency = Balances;
+	type OnSlash = ();
+	type SlashRewardFraction = SlashRewardFraction;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type CoreStaking = Staking;
+}
+
 impl pallet_root_testing::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 }
@@ -1389,7 +1397,7 @@ impl pallet_asset_rate::Config for Runtime {
 	type Currency = Balances;
 	type AssetKind = <Runtime as pallet_treasury::Config>::AssetKind;
 	#[cfg(feature = "runtime-benchmarks")]
-	type BenchmarkHelper = runtime_common::impls::benchmarks::AssetRateArguments;
+	type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::AssetRateArguments;
 }
 
 // Notify `coretime` pallet when a lease swap occurs
@@ -1517,6 +1525,10 @@ mod runtime {
 	#[runtime::pallet_index(37)]
 	pub type Treasury = pallet_treasury;
 
+	// Staking extension for delegation
+	#[runtime::pallet_index(38)]
+	pub type DelegatedStaking = pallet_delegated_staking;
+
 	// Parachains pallets. Start indices at 40 to leave room.
 	#[runtime::pallet_index(41)]
 	pub type ParachainsOrigin = parachains_origin;
@@ -1617,13 +1629,15 @@ pub type SignedExtra = (
 	frame_system::CheckNonce<Runtime>,
 	frame_system::CheckWeight<Runtime>,
 	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+	frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 
-pub struct NominationPoolsMigrationV4OldPallet;
-impl Get<Perbill> for NominationPoolsMigrationV4OldPallet {
-	fn get() -> Perbill {
-		Perbill::from_percent(100)
-	}
+parameter_types! {
+	// This is the max pools that will be migrated in the runtime upgrade. Westend has more pools
+	// than this, but we want to emulate some non migrated pools. In prod runtimes, if weight is not
+	// a concern, it is recommended to set to (existing pools + 10) to also account for any new
+	// pools getting created before the migration is actually executed.
+	pub const MaxPoolsToMigrate: u32 = 250;
 }
 
 /// All migrations that will run on the next runtime upgrade.
@@ -1656,7 +1670,15 @@ pub mod migrations {
 	}
 
 	/// Unreleased migrations. Add new ones here:
-	pub type Unreleased = (pallet_staking::migrations::v15::MigrateV14ToV15<Runtime>,);
+	pub type Unreleased = (
+		// Migrate NominationPools to `DelegateStake` adapter. This is unversioned upgrade and
+		// should not be applied yet in Kusama/Polkadot.
+		pallet_nomination_pools::migration::unversioned::DelegationStakeMigration<
+			Runtime,
+			MaxPoolsToMigrate,
+		>,
+		pallet_staking::migrations::v15::MigrateV14ToV15<Runtime>,
+	);
 }
 
 /// Unchecked extrinsic type as expected by this runtime.
@@ -1680,22 +1702,22 @@ mod benches {
 		// Polkadot
 		// NOTE: Make sure to prefix these with `runtime_common::` so
 		// the that path resolves correctly in the generated file.
-		[runtime_common::assigned_slots, AssignedSlots]
-		[runtime_common::auctions, Auctions]
-		[runtime_common::crowdloan, Crowdloan]
-		[runtime_common::identity_migrator, IdentityMigrator]
-		[runtime_common::paras_registrar, Registrar]
-		[runtime_common::slots, Slots]
-		[runtime_parachains::configuration, Configuration]
-		[runtime_parachains::disputes, ParasDisputes]
-		[runtime_parachains::disputes::slashing, ParasSlashing]
-		[runtime_parachains::hrmp, Hrmp]
-		[runtime_parachains::inclusion, ParaInclusion]
-		[runtime_parachains::initializer, Initializer]
-		[runtime_parachains::paras, Paras]
-		[runtime_parachains::paras_inherent, ParaInherent]
-		[runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider]
-		[runtime_parachains::coretime, Coretime]
+		[polkadot_runtime_common::assigned_slots, AssignedSlots]
+		[polkadot_runtime_common::auctions, Auctions]
+		[polkadot_runtime_common::crowdloan, Crowdloan]
+		[polkadot_runtime_common::identity_migrator, IdentityMigrator]
+		[polkadot_runtime_common::paras_registrar, Registrar]
+		[polkadot_runtime_common::slots, Slots]
+		[polkadot_runtime_parachains::configuration, Configuration]
+		[polkadot_runtime_parachains::disputes, ParasDisputes]
+		[polkadot_runtime_parachains::disputes::slashing, ParasSlashing]
+		[polkadot_runtime_parachains::hrmp, Hrmp]
+		[polkadot_runtime_parachains::inclusion, ParaInclusion]
+		[polkadot_runtime_parachains::initializer, Initializer]
+		[polkadot_runtime_parachains::paras, Paras]
+		[polkadot_runtime_parachains::paras_inherent, ParaInherent]
+		[polkadot_runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider]
+		[polkadot_runtime_parachains::coretime, Coretime]
 		// Substrate
 		[pallet_bags_list, VoterList]
 		[pallet_balances, Balances]
@@ -1761,7 +1783,7 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl block_builder_api::BlockBuilder<Block> for Runtime {
+	impl sp_block_builder::BlockBuilder<Block> for Runtime {
 		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
 			Executive::apply_extrinsic(extrinsic)
 		}
@@ -1770,19 +1792,19 @@ sp_api::impl_runtime_apis! {
 			Executive::finalize_block()
 		}
 
-		fn inherent_extrinsics(data: inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
 			data.create_extrinsics()
 		}
 
 		fn check_inherents(
 			block: Block,
-			data: inherents::InherentData,
-		) -> inherents::CheckInherentsResult {
+			data: sp_inherents::InherentData,
+		) -> sp_inherents::CheckInherentsResult {
 			data.check_extrinsics(&block)
 		}
 	}
 
-	impl tx_pool_api::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
 		fn validate_transaction(
 			source: TransactionSource,
 			tx: <Block as BlockT>::Extrinsic,
@@ -1792,14 +1814,14 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
+	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
 		fn offchain_worker(header: &<Block as BlockT>::Header) {
 			Executive::offchain_worker(header)
 		}
 	}
 
 	#[api_version(11)]
-	impl primitives::runtime_api::ParachainHost<Block> for Runtime {
+	impl polkadot_primitives::runtime_api::ParachainHost<Block> for Runtime {
 		fn validators() -> Vec<ValidatorId> {
 			parachains_runtime_api_impl::validators::<Runtime>()
 		}
@@ -1829,7 +1851,7 @@ sp_api::impl_runtime_apis! {
 
 		fn check_validation_outputs(
 			para_id: ParaId,
-			outputs: primitives::CandidateCommitments,
+			outputs: polkadot_primitives::CandidateCommitments,
 		) -> bool {
 			parachains_runtime_api_impl::check_validation_outputs::<Runtime>(para_id, outputs)
 		}
@@ -1914,7 +1936,7 @@ sp_api::impl_runtime_apis! {
 		fn key_ownership_proof(
 			validator_id: ValidatorId,
 		) -> Option<slashing::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+			use codec::Encode;
 
 			Historical::prove((PARACHAIN_KEY_TYPE_ID, validator_id))
 				.map(|p| p.encode())
@@ -1935,11 +1957,11 @@ sp_api::impl_runtime_apis! {
 			parachains_runtime_api_impl::minimum_backing_votes::<Runtime>()
 		}
 
-		fn para_backing_state(para_id: ParaId) -> Option<primitives::async_backing::BackingState> {
+		fn para_backing_state(para_id: ParaId) -> Option<polkadot_primitives::async_backing::BackingState> {
 			parachains_runtime_api_impl::backing_state::<Runtime>(para_id)
 		}
 
-		fn async_backing_params() -> primitives::AsyncBackingParams {
+		fn async_backing_params() -> polkadot_primitives::AsyncBackingParams {
 			parachains_runtime_api_impl::async_backing_params::<Runtime>()
 		}
 
@@ -1964,22 +1986,22 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl beefy_primitives::BeefyApi<Block, BeefyId> for Runtime {
+	impl sp_consensus_beefy::BeefyApi<Block, BeefyId> for Runtime {
 		fn beefy_genesis() -> Option<BlockNumber> {
 			pallet_beefy::GenesisBlock::<Runtime>::get()
 		}
 
-		fn validator_set() -> Option<beefy_primitives::ValidatorSet<BeefyId>> {
+		fn validator_set() -> Option<sp_consensus_beefy::ValidatorSet<BeefyId>> {
 			Beefy::validator_set()
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			equivocation_proof: beefy_primitives::DoubleVotingProof<
+			equivocation_proof: sp_consensus_beefy::DoubleVotingProof<
 				BlockNumber,
 				BeefyId,
 				BeefySignature,
 			>,
-			key_owner_proof: beefy_primitives::OpaqueKeyOwnershipProof,
+			key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			let key_owner_proof = key_owner_proof.decode()?;
 
@@ -1990,14 +2012,14 @@ sp_api::impl_runtime_apis! {
 		}
 
 		fn generate_key_ownership_proof(
-			_set_id: beefy_primitives::ValidatorSetId,
+			_set_id: sp_consensus_beefy::ValidatorSetId,
 			authority_id: BeefyId,
-		) -> Option<beefy_primitives::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+		) -> Option<sp_consensus_beefy::OpaqueKeyOwnershipProof> {
+			use codec::Encode;
 
-			Historical::prove((beefy_primitives::KEY_TYPE, authority_id))
+			Historical::prove((sp_consensus_beefy::KEY_TYPE, authority_id))
 				.map(|p| p.encode())
-				.map(beefy_primitives::OpaqueKeyOwnershipProof::new)
+				.map(sp_consensus_beefy::OpaqueKeyOwnershipProof::new)
 		}
 	}
 
@@ -2048,11 +2070,11 @@ sp_api::impl_runtime_apis! {
 	}
 
 	impl pallet_beefy_mmr::BeefyMmrApi<Block, Hash> for RuntimeApi {
-		fn authority_set_proof() -> beefy_primitives::mmr::BeefyAuthoritySet<Hash> {
+		fn authority_set_proof() -> sp_consensus_beefy::mmr::BeefyAuthoritySet<Hash> {
 			BeefyMmrLeaf::authority_set_proof()
 		}
 
-		fn next_authority_set_proof() -> beefy_primitives::mmr::BeefyNextAuthoritySet<Hash> {
+		fn next_authority_set_proof() -> sp_consensus_beefy::mmr::BeefyNextAuthoritySet<Hash> {
 			BeefyMmrLeaf::next_authority_set_proof()
 		}
 	}
@@ -2085,7 +2107,7 @@ sp_api::impl_runtime_apis! {
 			_set_id: fg_primitives::SetId,
 			authority_id: fg_primitives::AuthorityId,
 		) -> Option<fg_primitives::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+			use codec::Encode;
 
 			Historical::prove((fg_primitives::KEY_TYPE, authority_id))
 				.map(|p| p.encode())
@@ -2093,10 +2115,10 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl babe_primitives::BabeApi<Block> for Runtime {
-		fn configuration() -> babe_primitives::BabeConfiguration {
+	impl sp_consensus_babe::BabeApi<Block> for Runtime {
+		fn configuration() -> sp_consensus_babe::BabeConfiguration {
 			let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG);
-			babe_primitives::BabeConfiguration {
+			sp_consensus_babe::BabeConfiguration {
 				slot_duration: Babe::slot_duration(),
 				epoch_length: EpochDuration::get(),
 				c: epoch_config.c,
@@ -2106,32 +2128,32 @@ sp_api::impl_runtime_apis! {
 			}
 		}
 
-		fn current_epoch_start() -> babe_primitives::Slot {
+		fn current_epoch_start() -> sp_consensus_babe::Slot {
 			Babe::current_epoch_start()
 		}
 
-		fn current_epoch() -> babe_primitives::Epoch {
+		fn current_epoch() -> sp_consensus_babe::Epoch {
 			Babe::current_epoch()
 		}
 
-		fn next_epoch() -> babe_primitives::Epoch {
+		fn next_epoch() -> sp_consensus_babe::Epoch {
 			Babe::next_epoch()
 		}
 
 		fn generate_key_ownership_proof(
-			_slot: babe_primitives::Slot,
-			authority_id: babe_primitives::AuthorityId,
-		) -> Option<babe_primitives::OpaqueKeyOwnershipProof> {
-			use parity_scale_codec::Encode;
+			_slot: sp_consensus_babe::Slot,
+			authority_id: sp_consensus_babe::AuthorityId,
+		) -> Option<sp_consensus_babe::OpaqueKeyOwnershipProof> {
+			use codec::Encode;
 
-			Historical::prove((babe_primitives::KEY_TYPE, authority_id))
+			Historical::prove((sp_consensus_babe::KEY_TYPE, authority_id))
 				.map(|p| p.encode())
-				.map(babe_primitives::OpaqueKeyOwnershipProof::new)
+				.map(sp_consensus_babe::OpaqueKeyOwnershipProof::new)
 		}
 
 		fn submit_report_equivocation_unsigned_extrinsic(
-			equivocation_proof: babe_primitives::EquivocationProof<<Block as BlockT>::Header>,
-			key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof,
+			equivocation_proof: sp_consensus_babe::EquivocationProof<<Block as BlockT>::Header>,
+			key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof,
 		) -> Option<()> {
 			let key_owner_proof = key_owner_proof.decode()?;
 
@@ -2142,7 +2164,7 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl authority_discovery_primitives::AuthorityDiscoveryApi<Block> for Runtime {
+	impl sp_authority_discovery::AuthorityDiscoveryApi<Block> for Runtime {
 		fn authorities() -> Vec<AuthorityDiscoveryId> {
 			parachains_runtime_api_impl::relevant_authority_ids::<Runtime>()
 		}
@@ -2203,15 +2225,8 @@ sp_api::impl_runtime_apis! {
 
 	impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
 		fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
-			let acceptable = vec![
-				// native token
-				VersionedAssetId::from(AssetId(xcm_config::TokenLocation::get()))
-			];
-
-			Ok(acceptable
-				.into_iter()
-				.filter_map(|asset| asset.into_version(xcm_version).ok())
-				.collect())
+			let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())];
+			XcmPallet::query_acceptable_payment_assets(xcm_version, acceptable_assets)
 		}
 
 		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
@@ -2240,63 +2255,13 @@ sp_api::impl_runtime_apis! {
 		}
 	}
 
-	impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi<Block, RuntimeCall, RuntimeEvent> for Runtime {
-		fn dry_run_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> Result<ExtrinsicDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			use xcm_executor::RecordXcm;
-			pallet_xcm::Pallet::<Runtime>::set_record_xcm(true);
-			let result = Executive::apply_extrinsic(extrinsic).map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_extrinsic",
-					"Applying extrinsic failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::InvalidExtrinsic
-			})?;
-			let local_xcm = pallet_xcm::Pallet::<Runtime>::recorded_xcm();
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(ExtrinsicDryRunEffects {
-				local_xcm: local_xcm.map(VersionedXcm::<()>::V4),
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+	impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+			XcmPallet::dry_run_call::<Runtime, xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
 		}
 
 		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-			use xcm_builder::InspectMessageQueues;
-			let origin_location: Location = origin_location.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Location version conversion failed with error: {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let xcm: Xcm<RuntimeCall> = xcm.try_into().map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
-					"Xcm version conversion failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::VersionedConversionFailed
-			})?;
-			let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256);
-			let result = xcm_executor::XcmExecutor::<xcm_config::XcmConfig>::prepare_and_execute(
-				origin_location,
-				xcm,
-				&mut hash,
-				Weight::MAX, // Max limit available for execution.
-				Weight::zero(),
-			);
-			let forwarded_xcms = xcm_config::XcmRouter::get_messages();
-			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
-			Ok(XcmDryRunEffects {
-				forwarded_xcms,
-				emitted_events: events,
-				execution_result: result,
-			})
+			XcmPallet::dry_run_xcm::<Runtime, xcm_config::XcmRouter, RuntimeCall, xcm_config::XcmConfig>(origin_location, xcm)
 		}
 	}
 
@@ -2316,6 +2281,22 @@ sp_api::impl_runtime_apis! {
 		fn balance_to_points(pool_id: pallet_nomination_pools::PoolId, new_funds: Balance) -> Balance {
 			NominationPools::api_balance_to_points(pool_id, new_funds)
 		}
+
+		fn pool_pending_slash(pool_id: pallet_nomination_pools::PoolId) -> Balance {
+			NominationPools::api_pool_pending_slash(pool_id)
+		}
+
+		fn member_pending_slash(member: AccountId) -> Balance {
+			NominationPools::api_member_pending_slash(member)
+		}
+
+		fn pool_needs_delegate_migration(pool_id: pallet_nomination_pools::PoolId) -> bool {
+			NominationPools::api_pool_needs_delegate_migration(pool_id)
+		}
+
+		fn member_needs_delegate_migration(member: AccountId) -> bool {
+			NominationPools::api_member_needs_delegate_migration(member)
+		}
 	}
 
 	impl pallet_staking_runtime_api::StakingApi<Block, Balance, AccountId> for Runtime {
@@ -2413,14 +2394,14 @@ sp_api::impl_runtime_apis! {
 
 			impl pallet_xcm::benchmarking::Config for Runtime {
 				type DeliveryHelper = (
-					runtime_common::xcm_sender::ToParachainDeliveryHelper<
+					polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper<
 						xcm_config::XcmConfig,
 						ExistentialDepositAsset,
 						xcm_config::PriceForChildParachainDelivery,
 						AssetHubParaId,
 						(),
 					>,
-					runtime_common::xcm_sender::ToParachainDeliveryHelper<
+					polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper<
 						xcm_config::XcmConfig,
 						ExistentialDepositAsset,
 						xcm_config::PriceForChildParachainDelivery,
@@ -2476,7 +2457,7 @@ sp_api::impl_runtime_apis! {
 			}
 			impl frame_system_benchmarking::Config for Runtime {}
 			impl pallet_nomination_pools_benchmarking::Config for Runtime {}
-			impl runtime_parachains::disputes::slashing::benchmarking::Config for Runtime {}
+			impl polkadot_runtime_parachains::disputes::slashing::benchmarking::Config for Runtime {}
 
 			use xcm::latest::{
 				AssetId, Fungibility::*, InteriorLocation, Junction, Junctions::*,
@@ -2486,7 +2467,7 @@ sp_api::impl_runtime_apis! {
 			impl pallet_xcm_benchmarks::Config for Runtime {
 				type XcmConfig = xcm_config::XcmConfig;
 				type AccountIdConverter = xcm_config::LocationConverter;
-				type DeliveryHelper = runtime_common::xcm_sender::ToParachainDeliveryHelper<
+				type DeliveryHelper = polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper<
 					xcm_config::XcmConfig,
 					ExistentialDepositAsset,
 					xcm_config::PriceForChildParachainDelivery,
diff --git a/polkadot/runtime/westend/src/tests.rs b/polkadot/runtime/westend/src/tests.rs
index 4acb81e963b2165ee01881d189daf89c0c1a7924..4d5e2e946bce6e1cf26f061309b1a1000a3d1853 100644
--- a/polkadot/runtime/westend/src/tests.rs
+++ b/polkadot/runtime/westend/src/tests.rs
@@ -24,7 +24,7 @@ use sp_core::hexdisplay::HexDisplay;
 
 #[test]
 fn remove_keys_weight_is_sensible() {
-	use runtime_common::crowdloan::WeightInfo;
+	use polkadot_runtime_common::crowdloan::WeightInfo;
 	let max_weight = <Runtime as crowdloan::Config>::WeightInfo::refund(RemoveKeysLimit::get());
 	// Max remove keys limit should be no more than half the total block weight.
 	assert!((max_weight * 2).all_lt(BlockWeights::get().max_block));
@@ -32,7 +32,7 @@ fn remove_keys_weight_is_sensible() {
 
 #[test]
 fn sample_size_is_sensible() {
-	use runtime_common::auctions::WeightInfo;
+	use polkadot_runtime_common::auctions::WeightInfo;
 	// Need to clean up all samples at the end of an auction.
 	let samples: BlockNumber = EndingPeriod::get() / SampleLength::get();
 	let max_weight: frame_support::weights::Weight =
diff --git a/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs b/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs
index 6aa5ddd1ec8fb5251ac6bbd5059938e4bad93b22..35eef199fb7a974f7665a83c09318ee06b37fea2 100644
--- a/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs
+++ b/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs
@@ -16,10 +16,10 @@
 
 //! Autogenerated weights for `pallet_nomination_pools`
 //!
-//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-11-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2024-04-25, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-dcu62vjg-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024
 
 // Executed Command:
@@ -54,7 +54,7 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::BondedPools` (r:1 w:1)
 	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
-	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Storage: `Staking::Bonded` (r:2 w:0)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
@@ -62,7 +62,7 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0)
 	/// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:2 w:1)
+	/// Storage: `System::Account` (r:1 w:0)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::MaxPoolMembersPerPool` (r:1 w:0)
 	/// Proof: `NominationPools::MaxPoolMembersPerPool` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
@@ -70,10 +70,16 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Locks` (r:1 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:1 w:0)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:2 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListNodes` (r:3 w:3)
 	/// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListBags` (r:2 w:2)
@@ -82,13 +88,13 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn join() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3355`
+		//  Measured:  `3606`
 		//  Estimated: `8877`
-		// Minimum execution time: 173_707_000 picoseconds.
-		Weight::from_parts(179_920_000, 0)
+		// Minimum execution time: 204_877_000 picoseconds.
+		Weight::from_parts(210_389_000, 0)
 			.saturating_add(Weight::from_parts(0, 8877))
-			.saturating_add(T::DbWeight::get().reads(20))
-			.saturating_add(T::DbWeight::get().writes(13))
+			.saturating_add(T::DbWeight::get().reads(24))
+			.saturating_add(T::DbWeight::get().writes(15))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
@@ -98,16 +104,20 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0)
 	/// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:3 w:2)
+	/// Storage: `System::Account` (r:2 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
-	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Storage: `Staking::Bonded` (r:2 w:0)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Locks` (r:1 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:1 w:0)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:2 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListNodes` (r:3 w:3)
 	/// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListBags` (r:2 w:2)
@@ -116,13 +126,13 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn bond_extra_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3365`
+		//  Measured:  `3762`
 		//  Estimated: `8877`
-		// Minimum execution time: 174_414_000 picoseconds.
-		Weight::from_parts(178_068_000, 0)
+		// Minimum execution time: 203_362_000 picoseconds.
+		Weight::from_parts(209_899_000, 0)
 			.saturating_add(Weight::from_parts(0, 8877))
-			.saturating_add(T::DbWeight::get().reads(17))
-			.saturating_add(T::DbWeight::get().writes(13))
+			.saturating_add(T::DbWeight::get().reads(20))
+			.saturating_add(T::DbWeight::get().writes(14))
 	}
 	/// Storage: `NominationPools::ClaimPermissions` (r:1 w:0)
 	/// Proof: `NominationPools::ClaimPermissions` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
@@ -134,16 +144,20 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0)
 	/// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:3 w:3)
+	/// Storage: `System::Account` (r:2 w:2)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
-	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Storage: `Staking::Bonded` (r:2 w:0)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Locks` (r:1 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:1 w:0)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:2 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListNodes` (r:2 w:2)
 	/// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListBags` (r:2 w:2)
@@ -152,13 +166,13 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn bond_extra_other() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3312`
-		//  Estimated: `8799`
-		// Minimum execution time: 198_864_000 picoseconds.
-		Weight::from_parts(203_783_000, 0)
-			.saturating_add(Weight::from_parts(0, 8799))
-			.saturating_add(T::DbWeight::get().reads(17))
-			.saturating_add(T::DbWeight::get().writes(13))
+		//  Measured:  `3709`
+		//  Estimated: `6248`
+		// Minimum execution time: 230_686_000 picoseconds.
+		Weight::from_parts(237_502_000, 0)
+			.saturating_add(Weight::from_parts(0, 6248))
+			.saturating_add(T::DbWeight::get().reads(20))
+			.saturating_add(T::DbWeight::get().writes(14))
 	}
 	/// Storage: `NominationPools::ClaimPermissions` (r:1 w:0)
 	/// Proof: `NominationPools::ClaimPermissions` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
@@ -176,8 +190,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `1138`
 		//  Estimated: `4182`
-		// Minimum execution time: 70_250_000 picoseconds.
-		Weight::from_parts(72_231_000, 0)
+		// Minimum execution time: 70_821_000 picoseconds.
+		Weight::from_parts(72_356_000, 0)
 			.saturating_add(Weight::from_parts(0, 4182))
 			.saturating_add(T::DbWeight::get().reads(6))
 			.saturating_add(T::DbWeight::get().writes(4))
@@ -194,7 +208,7 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0)
 	/// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:2 w:1)
+	/// Storage: `System::Account` (r:1 w:0)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::CurrentEra` (r:1 w:0)
 	/// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
@@ -202,10 +216,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::MinNominatorBond` (r:1 w:0)
 	/// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Locks` (r:1 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:1 w:0)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListNodes` (r:3 w:3)
 	/// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`)
 	/// Storage: `VoterList::ListBags` (r:2 w:2)
@@ -216,13 +228,13 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::CounterForSubPoolsStorage` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	fn unbond() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3545`
+		//  Measured:  `3341`
 		//  Estimated: `8877`
-		// Minimum execution time: 155_853_000 picoseconds.
-		Weight::from_parts(161_032_000, 0)
+		// Minimum execution time: 156_714_000 picoseconds.
+		Weight::from_parts(158_305_000, 0)
 			.saturating_add(Weight::from_parts(0, 8877))
-			.saturating_add(T::DbWeight::get().reads(20))
-			.saturating_add(T::DbWeight::get().writes(13))
+			.saturating_add(T::DbWeight::get().reads(18))
+			.saturating_add(T::DbWeight::get().writes(11))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
 	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
@@ -232,23 +244,25 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::CurrentEra` (r:1 w:0)
 	/// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Locks` (r:1 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:1 w:0)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:0)
+	/// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::TotalValueLocked` (r:1 w:1)
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
 	/// The range of component `s` is `[0, 100]`.
 	fn pool_withdraw_unbonded(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1744`
-		//  Estimated: `4764`
-		// Minimum execution time: 62_933_000 picoseconds.
-		Weight::from_parts(65_847_171, 0)
-			.saturating_add(Weight::from_parts(0, 4764))
-			// Standard Error: 1_476
-			.saturating_add(Weight::from_parts(59_648, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(7))
+		//  Measured:  `1767`
+		//  Estimated: `4556`
+		// Minimum execution time: 56_836_000 picoseconds.
+		Weight::from_parts(59_738_398, 0)
+			.saturating_add(Weight::from_parts(0, 4556))
+			// Standard Error: 1_478
+			.saturating_add(Weight::from_parts(60_085, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(8))
 			.saturating_add(T::DbWeight::get().writes(3))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
@@ -259,18 +273,24 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::SubPoolsStorage` (r:1 w:1)
 	/// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Bonded` (r:1 w:0)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Locks` (r:1 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:1 w:0)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:1 w:1)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:0)
+	/// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::TotalValueLocked` (r:1 w:1)
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::ClaimPermissions` (r:0 w:1)
@@ -278,15 +298,15 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_update(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2134`
-		//  Estimated: `4764`
-		// Minimum execution time: 123_641_000 picoseconds.
-		Weight::from_parts(127_222_589, 0)
-			.saturating_add(Weight::from_parts(0, 4764))
-			// Standard Error: 2_493
-			.saturating_add(Weight::from_parts(83_361, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(11))
-			.saturating_add(T::DbWeight::get().writes(9))
+		//  Measured:  `2405`
+		//  Estimated: `4556`
+		// Minimum execution time: 136_737_000 picoseconds.
+		Weight::from_parts(141_757_658, 0)
+			.saturating_add(Weight::from_parts(0, 4556))
+			// Standard Error: 2_609
+			.saturating_add(Weight::from_parts(84_538, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(14))
+			.saturating_add(T::DbWeight::get().writes(11))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
@@ -296,28 +316,38 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::SubPoolsStorage` (r:1 w:1)
 	/// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Bonded` (r:1 w:1)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::SlashingSpans` (r:1 w:0)
 	/// Proof: `Staking::SlashingSpans` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// Storage: `Balances::Locks` (r:2 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:2 w:1)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:2 w:2)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::CounterForVirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::CounterForVirtualStakers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Validators` (r:1 w:0)
 	/// Proof: `Staking::Validators` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Nominators` (r:1 w:0)
 	/// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:1)
+	/// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::TotalValueLocked` (r:1 w:1)
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForAgents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForAgents` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:1)
-	/// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForReversePoolIdLookup` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForReversePoolIdLookup` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::RewardPools` (r:1 w:1)
@@ -326,6 +356,10 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::CounterForRewardPools` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForSubPoolsStorage` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForSubPoolsStorage` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Freezes` (r:1 w:1)
+	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Locks` (r:1 w:0)
+	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::Metadata` (r:1 w:1)
 	/// Proof: `NominationPools::Metadata` (`max_values`: None, `max_size`: Some(270), added: 2745, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForBondedPools` (r:1 w:1)
@@ -337,13 +371,13 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_kill(_s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2453`
-		//  Estimated: `8538`
-		// Minimum execution time: 219_469_000 picoseconds.
-		Weight::from_parts(227_526_000, 0)
-			.saturating_add(Weight::from_parts(0, 8538))
-			.saturating_add(T::DbWeight::get().reads(24))
-			.saturating_add(T::DbWeight::get().writes(20))
+		//  Measured:  `2809`
+		//  Estimated: `6274`
+		// Minimum execution time: 241_043_000 picoseconds.
+		Weight::from_parts(250_578_253, 0)
+			.saturating_add(Weight::from_parts(0, 6274))
+			.saturating_add(T::DbWeight::get().reads(29))
+			.saturating_add(T::DbWeight::get().writes(26))
 	}
 	/// Storage: `NominationPools::LastPoolId` (r:1 w:1)
 	/// Proof: `NominationPools::LastPoolId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
@@ -365,16 +399,30 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Bonded` (r:2 w:1)
+	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:2 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:2 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForAgents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForAgents` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `System::Account` (r:2 w:2)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
-	/// Storage: `Staking::Bonded` (r:1 w:1)
-	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Locks` (r:2 w:1)
-	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
-	/// Storage: `Balances::Freezes` (r:2 w:1)
-	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::CounterForVirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::CounterForVirtualStakers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::TotalValueLocked` (r:1 w:1)
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Freezes` (r:1 w:1)
+	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Locks` (r:1 w:0)
+	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::RewardPools` (r:1 w:1)
 	/// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForRewardPools` (r:1 w:1)
@@ -391,22 +439,28 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `Staking::Payee` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn create() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1102`
-		//  Estimated: `8538`
-		// Minimum execution time: 166_466_000 picoseconds.
-		Weight::from_parts(171_425_000, 0)
-			.saturating_add(Weight::from_parts(0, 8538))
-			.saturating_add(T::DbWeight::get().reads(23))
-			.saturating_add(T::DbWeight::get().writes(17))
+		//  Measured:  `1168`
+		//  Estimated: `6196`
+		// Minimum execution time: 180_902_000 picoseconds.
+		Weight::from_parts(187_769_000, 0)
+			.saturating_add(Weight::from_parts(0, 6196))
+			.saturating_add(T::DbWeight::get().reads(31))
+			.saturating_add(T::DbWeight::get().writes(23))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
 	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Bonded` (r:1 w:0)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:0)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::MinNominatorBond` (r:1 w:0)
 	/// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::MinCreateBond` (r:1 w:0)
+	/// Proof: `NominationPools::MinCreateBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::MinJoinBond` (r:1 w:0)
+	/// Proof: `NominationPools::MinJoinBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Nominators` (r:1 w:1)
 	/// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::MaxNominatorsCount` (r:1 w:0)
@@ -426,14 +480,14 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// The range of component `n` is `[1, 16]`.
 	fn nominate(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1738`
+		//  Measured:  `1921`
 		//  Estimated: `4556 + n * (2520 ±0)`
-		// Minimum execution time: 59_650_000 picoseconds.
-		Weight::from_parts(60_620_077, 0)
+		// Minimum execution time: 78_369_000 picoseconds.
+		Weight::from_parts(79_277_958, 0)
 			.saturating_add(Weight::from_parts(0, 4556))
-			// Standard Error: 7_316
-			.saturating_add(Weight::from_parts(1_467_406, 0).saturating_mul(n.into()))
-			.saturating_add(T::DbWeight::get().reads(12))
+			// Standard Error: 8_343
+			.saturating_add(Weight::from_parts(1_493_255, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(15))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(5))
 			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(n.into()))
@@ -446,10 +500,10 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	fn set_state() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1363`
+		//  Measured:  `1406`
 		//  Estimated: `4556`
-		// Minimum execution time: 31_170_000 picoseconds.
-		Weight::from_parts(32_217_000, 0)
+		// Minimum execution time: 32_631_000 picoseconds.
+		Weight::from_parts(33_356_000, 0)
 			.saturating_add(Weight::from_parts(0, 4556))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(1))
@@ -465,11 +519,11 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `498`
 		//  Estimated: `3735`
-		// Minimum execution time: 12_603_000 picoseconds.
-		Weight::from_parts(13_241_702, 0)
+		// Minimum execution time: 12_514_000 picoseconds.
+		Weight::from_parts(13_232_732, 0)
 			.saturating_add(Weight::from_parts(0, 3735))
-			// Standard Error: 116
-			.saturating_add(Weight::from_parts(1_428, 0).saturating_mul(n.into()))
+			// Standard Error: 150
+			.saturating_add(Weight::from_parts(2_371, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(3))
 			.saturating_add(T::DbWeight::get().writes(2))
 	}
@@ -489,8 +543,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 3_608_000 picoseconds.
-		Weight::from_parts(3_801_000, 0)
+		// Minimum execution time: 3_107_000 picoseconds.
+		Weight::from_parts(3_255_000, 0)
 			.saturating_add(Weight::from_parts(0, 0))
 			.saturating_add(T::DbWeight::get().writes(6))
 	}
@@ -500,18 +554,22 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `498`
 		//  Estimated: `3719`
-		// Minimum execution time: 16_053_000 picoseconds.
-		Weight::from_parts(16_473_000, 0)
+		// Minimum execution time: 16_568_000 picoseconds.
+		Weight::from_parts(17_019_000, 0)
 			.saturating_add(Weight::from_parts(0, 3719))
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
 	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Bonded` (r:1 w:0)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:0)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::MinNominatorBond` (r:1 w:0)
+	/// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Validators` (r:1 w:0)
 	/// Proof: `Staking::Validators` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Nominators` (r:1 w:1)
@@ -526,12 +584,12 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `VoterList::CounterForListNodes` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	fn chill() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1901`
+		//  Measured:  `2138`
 		//  Estimated: `4556`
-		// Minimum execution time: 57_251_000 picoseconds.
-		Weight::from_parts(59_390_000, 0)
+		// Minimum execution time: 73_717_000 picoseconds.
+		Weight::from_parts(77_030_000, 0)
 			.saturating_add(Weight::from_parts(0, 4556))
-			.saturating_add(T::DbWeight::get().reads(9))
+			.saturating_add(T::DbWeight::get().reads(11))
 			.saturating_add(T::DbWeight::get().writes(5))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:1)
@@ -546,8 +604,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `770`
 		//  Estimated: `3719`
-		// Minimum execution time: 29_888_000 picoseconds.
-		Weight::from_parts(31_056_000, 0)
+		// Minimum execution time: 30_770_000 picoseconds.
+		Weight::from_parts(31_556_000, 0)
 			.saturating_add(Weight::from_parts(0, 3719))
 			.saturating_add(T::DbWeight::get().reads(4))
 			.saturating_add(T::DbWeight::get().writes(2))
@@ -560,8 +618,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `538`
 		//  Estimated: `3719`
-		// Minimum execution time: 15_769_000 picoseconds.
-		Weight::from_parts(16_579_000, 0)
+		// Minimum execution time: 16_257_000 picoseconds.
+		Weight::from_parts(16_891_000, 0)
 			.saturating_add(Weight::from_parts(0, 3719))
 			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().writes(1))
@@ -572,8 +630,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `498`
 		//  Estimated: `3719`
-		// Minimum execution time: 15_385_000 picoseconds.
-		Weight::from_parts(16_402_000, 0)
+		// Minimum execution time: 16_548_000 picoseconds.
+		Weight::from_parts(18_252_000, 0)
 			.saturating_add(Weight::from_parts(0, 3719))
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
@@ -584,8 +642,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `498`
 		//  Estimated: `3719`
-		// Minimum execution time: 14_965_000 picoseconds.
-		Weight::from_parts(15_548_000, 0)
+		// Minimum execution time: 16_085_000 picoseconds.
+		Weight::from_parts(17_218_000, 0)
 			.saturating_add(Weight::from_parts(0, 3719))
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
@@ -598,8 +656,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `508`
 		//  Estimated: `4182`
-		// Minimum execution time: 13_549_000 picoseconds.
-		Weight::from_parts(14_307_000, 0)
+		// Minimum execution time: 13_648_000 picoseconds.
+		Weight::from_parts(13_990_000, 0)
 			.saturating_add(Weight::from_parts(0, 4182))
 			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().writes(1))
@@ -616,8 +674,8 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 		// Proof Size summary in bytes:
 		//  Measured:  `968`
 		//  Estimated: `3719`
-		// Minimum execution time: 60_153_000 picoseconds.
-		Weight::from_parts(61_369_000, 0)
+		// Minimum execution time: 60_321_000 picoseconds.
+		Weight::from_parts(61_512_000, 0)
 			.saturating_add(Weight::from_parts(0, 3719))
 			.saturating_add(T::DbWeight::get().reads(4))
 			.saturating_add(T::DbWeight::get().writes(2))
@@ -632,12 +690,135 @@ impl<T: frame_system::Config> pallet_nomination_pools::WeightInfo for WeightInfo
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	fn adjust_pool_deposit() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `867`
+		//  Measured:  `876`
 		//  Estimated: `4764`
-		// Minimum execution time: 64_985_000 picoseconds.
-		Weight::from_parts(66_616_000, 0)
+		// Minimum execution time: 65_609_000 picoseconds.
+		Weight::from_parts(67_320_000, 0)
 			.saturating_add(Weight::from_parts(0, 4764))
 			.saturating_add(T::DbWeight::get().reads(4))
 			.saturating_add(T::DbWeight::get().writes(2))
 	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
+	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Ledger` (r:1 w:0)
+	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0)
+	/// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn apply_slash() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3328`
+		//  Estimated: `4556`
+		// Minimum execution time: 99_605_000 picoseconds.
+		Weight::from_parts(101_986_000, 0)
+			.saturating_add(Weight::from_parts(0, 4556))
+			.saturating_add(T::DbWeight::get().reads(9))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:1 w:0)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:1 w:0)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
+	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Ledger` (r:1 w:0)
+	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0)
+	/// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`)
+	fn apply_slash_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3070`
+		//  Estimated: `4556`
+		// Minimum execution time: 58_103_000 picoseconds.
+		Weight::from_parts(59_680_000, 0)
+			.saturating_add(Weight::from_parts(0, 4556))
+			.saturating_add(T::DbWeight::get().reads(7))
+	}
+	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Validators` (r:1 w:0)
+	/// Proof: `Staking::Validators` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Nominators` (r:1 w:0)
+	/// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:2 w:1)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForAgents` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForAgents` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Ledger` (r:1 w:0)
+	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Locks` (r:1 w:1)
+	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Freezes` (r:1 w:0)
+	/// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::CounterForVirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::CounterForVirtualStakers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Payee` (r:0 w:1)
+	/// Proof: `Staking::Payee` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	fn pool_migrate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1359`
+		//  Estimated: `6196`
+		// Minimum execution time: 144_098_000 picoseconds.
+		Weight::from_parts(146_590_000, 0)
+			.saturating_add(Weight::from_parts(0, 6196))
+			.saturating_add(T::DbWeight::get().reads(16))
+			.saturating_add(T::DbWeight::get().writes(11))
+	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
+	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Bonded` (r:2 w:0)
+	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Ledger` (r:1 w:0)
+	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0)
+	/// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::MinJoinBond` (r:1 w:0)
+	/// Proof: `NominationPools::MinJoinBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Delegators` (r:2 w:2)
+	/// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::Agents` (r:2 w:0)
+	/// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:2 w:2)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1)
+	/// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn migrate_delegation() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2275`
+		//  Estimated: `6180`
+		// Minimum execution time: 148_594_000 picoseconds.
+		Weight::from_parts(152_119_000, 0)
+			.saturating_add(Weight::from_parts(0, 6180))
+			.saturating_add(T::DbWeight::get().reads(15))
+			.saturating_add(T::DbWeight::get().writes(6))
+	}
 }
diff --git a/polkadot/runtime/westend/src/weights/pallet_treasury.rs b/polkadot/runtime/westend/src/weights/pallet_treasury.rs
index 144e9d5b872382b7381e2d77c6fb08a8fbece4fa..06246ada72f16fb04623f3fc6534265cc1156b79 100644
--- a/polkadot/runtime/westend/src/weights/pallet_treasury.rs
+++ b/polkadot/runtime/westend/src/weights/pallet_treasury.rs
@@ -63,51 +63,6 @@ impl<T: frame_system::Config> pallet_treasury::WeightInfo for WeightInfo<T> {
 			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().writes(3))
 	}
-	/// Storage: Treasury ProposalCount (r:1 w:1)
-	/// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
-	/// Storage: Treasury Proposals (r:0 w:1)
-	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
-	fn propose_spend() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `143`
-		//  Estimated: `1489`
-		// Minimum execution time: 354_000_000 picoseconds.
-		Weight::from_parts(376_000_000, 0)
-			.saturating_add(Weight::from_parts(0, 1489))
-			.saturating_add(T::DbWeight::get().reads(1))
-			.saturating_add(T::DbWeight::get().writes(2))
-	}
-	/// Storage: Treasury Proposals (r:1 w:1)
-	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
-	/// Storage: System Account (r:1 w:1)
-	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
-	fn reject_proposal() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `301`
-		//  Estimated: `3593`
-		// Minimum execution time: 547_000_000 picoseconds.
-		Weight::from_parts(550_000_000, 0)
-			.saturating_add(Weight::from_parts(0, 3593))
-			.saturating_add(T::DbWeight::get().reads(2))
-			.saturating_add(T::DbWeight::get().writes(2))
-	}
-	/// Storage: Treasury Proposals (r:1 w:0)
-	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
-	/// Storage: Treasury Approvals (r:1 w:1)
-	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
-	/// The range of component `p` is `[0, 99]`.
-	fn approve_proposal(p: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `470 + p * (8 ±0)`
-		//  Estimated: `3573`
-		// Minimum execution time: 104_000_000 picoseconds.
-		Weight::from_parts(121_184_402, 0)
-			.saturating_add(Weight::from_parts(0, 3573))
-			// Standard Error: 42_854
-			.saturating_add(Weight::from_parts(153_112, 0).saturating_mul(p.into()))
-			.saturating_add(T::DbWeight::get().reads(2))
-			.saturating_add(T::DbWeight::get().writes(1))
-	}
 	/// Storage: Treasury Approvals (r:1 w:1)
 	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
 	fn remove_approval() -> Weight {
diff --git a/polkadot/runtime/westend/src/weights/runtime_common_assigned_slots.rs b/polkadot/runtime/westend/src/weights/runtime_common_assigned_slots.rs
index c3f1060a9ac0bce7f9bcaa36739f1d7199a8d737..08b0b0f34df13d2c92f9b9bde8bb11f6ba68a22b 100644
--- a/polkadot/runtime/westend/src/weights/runtime_common_assigned_slots.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_common_assigned_slots.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::assigned_slots`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::assigned_slots::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::assigned_slots::WeightInfo for WeightInfo<T> {
 	/// Storage: `Registrar::Paras` (r:1 w:1)
 	/// Proof: `Registrar::Paras` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Paras::ParaLifecycles` (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_common_auctions.rs b/polkadot/runtime/westend/src/weights/runtime_common_auctions.rs
index a6f5bbe5a1da3054a0ab17c2a8c2db94471d17c9..58ca2a083b2cbf58669f46281f1ffee8d38dc0f4 100644
--- a/polkadot/runtime/westend/src/weights/runtime_common_auctions.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_common_auctions.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::auctions`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::auctions::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::auctions::WeightInfo for WeightInfo<T> {
 	/// Storage: Auctions AuctionInfo (r:1 w:1)
 	/// Proof: Auctions AuctionInfo (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
 	/// Storage: Auctions AuctionCounter (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_common_crowdloan.rs b/polkadot/runtime/westend/src/weights/runtime_common_crowdloan.rs
index 97b0279544c761d2c344f189e16e7d7484242d57..47472406de1e5679872d07f45817ccc31a5d2476 100644
--- a/polkadot/runtime/westend/src/weights/runtime_common_crowdloan.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_common_crowdloan.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::crowdloan`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::crowdloan::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::crowdloan::WeightInfo for WeightInfo<T> {
 	/// Storage: Crowdloan Funds (r:1 w:1)
 	/// Proof Skipped: Crowdloan Funds (max_values: None, max_size: None, mode: Measured)
 	/// Storage: Registrar Paras (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs b/polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs
index cec357453b67be400c0191ac7d5c12e6961a4bee..4ea6f67968017e312562842c5f2400754ac83b95 100644
--- a/polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs
@@ -42,7 +42,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::identity_migrator`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::identity_migrator::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::identity_migrator::WeightInfo for WeightInfo<T> {
 	/// Storage: `Identity::IdentityOf` (r:1 w:1)
 	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`)
 	/// Storage: `Identity::SubsOf` (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_common_paras_registrar.rs b/polkadot/runtime/westend/src/weights/runtime_common_paras_registrar.rs
index 50290c0fe59f64031258b2fe2d1ff16124d60701..befd89874411a4e004ebdcf07aa4cfb32c3fb243 100644
--- a/polkadot/runtime/westend/src/weights/runtime_common_paras_registrar.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_common_paras_registrar.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::paras_registrar`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::paras_registrar::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::paras_registrar::WeightInfo for WeightInfo<T> {
 	/// Storage: Registrar NextFreeParaId (r:1 w:1)
 	/// Proof Skipped: Registrar NextFreeParaId (max_values: Some(1), max_size: None, mode: Measured)
 	/// Storage: Registrar Paras (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_common_slots.rs b/polkadot/runtime/westend/src/weights/runtime_common_slots.rs
index c95859221fa726dd79f15d34bb3ed0c4083f37ec..b1422e506ab1d24770a14eef622d1c713d476f5f 100644
--- a/polkadot/runtime/westend/src/weights/runtime_common_slots.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_common_slots.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_common::slots`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_common::slots::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_common::slots::WeightInfo for WeightInfo<T> {
 	/// Storage: Slots Leases (r:1 w:1)
 	/// Proof Skipped: Slots Leases (max_values: None, max_size: None, mode: Measured)
 	/// Storage: System Account (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_assigner_on_demand.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_assigner_on_demand.rs
index acd1834f79ed8c35ed83bd56d75c0907b02f7f5d..8b046f5d34ad7d3f0800b6d48f2cbb83cd5ab010 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_assigner_on_demand.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_assigner_on_demand.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::assigner_on_demand`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::assigner_on_demand::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::assigner_on_demand::WeightInfo for WeightInfo<T> {
 	/// Storage: `OnDemandAssignmentProvider::QueueStatus` (r:1 w:1)
 	/// Proof: `OnDemandAssignmentProvider::QueueStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `OnDemandAssignmentProvider::ParaIdAffinity` (r:1 w:0)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs
index 8fa3207c6446082a97877f488913d9c063114fca..5130b04668b2072f658b247e0697facea6e801ba 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::configuration`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::configuration::WeightInfo for WeightInfo<T> {
 	/// Storage: `Configuration::PendingConfigs` (r:1 w:1)
 	/// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_coretime.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_coretime.rs
index aa65a2e9034a7c9f10a3d596db9cf8d167f561ac..443651a6fda44380d89b02c53dc70338bdc7f4ee 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_coretime.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_coretime.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::coretime`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::coretime::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::coretime::WeightInfo for WeightInfo<T> {
 	/// Storage: `Configuration::PendingConfigs` (r:1 w:1)
 	/// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_disputes.rs
index 4a6a6079cf131a8d39ef3a812d2309b955762764..5beb82ec5944fc633eee924fd7f6fc887cef25ca 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_disputes.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::disputes`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::disputes::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::disputes::WeightInfo for WeightInfo<T> {
 	/// Storage: ParasDisputes Frozen (r:0 w:1)
 	/// Proof Skipped: ParasDisputes Frozen (max_values: Some(1), max_size: None, mode: Measured)
 	fn force_unfreeze() -> Weight {
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes_slashing.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_disputes_slashing.rs
index 8600717fee1e222f587c19cc7cf44f36d2bde6d2..a035ea2b0b5e2e226a1a2a36f0a11e570c56839f 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes_slashing.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_disputes_slashing.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::disputes::slashing`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::disputes::slashing::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::disputes::slashing::WeightInfo for WeightInfo<T> {
 	/// Storage: Session CurrentIndex (r:1 w:0)
 	/// Proof Skipped: Session CurrentIndex (max_values: Some(1), max_size: None, mode: Measured)
 	/// Storage: Historical HistoricalSessions (r:1 w:0)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_hrmp.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_hrmp.rs
index f1d7932fe8b7c09d069144f624c0f29bce7c4e5b..8946261664befb8afc96c2ff3d21ed3d8d5d325a 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_hrmp.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_hrmp.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::hrmp`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::hrmp::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::hrmp::WeightInfo for WeightInfo<T> {
 	/// Storage: `Paras::ParaLifecycles` (r:1 w:0)
 	/// Proof: `Paras::ParaLifecycles` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Hrmp::HrmpOpenChannelRequests` (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_inclusion.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_inclusion.rs
index 767097f660e81c2fc411334389b351a6c38d8b6d..25909beb6a071ea0d5e2a0dd35ee1be2ca0ed879 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_inclusion.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_inclusion.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::inclusion`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::inclusion::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::inclusion::WeightInfo for WeightInfo<T> {
 	/// Storage: MessageQueue BookStateFor (r:1 w:1)
 	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(55), added: 2530, mode: MaxEncodedLen)
 	/// Storage: MessageQueue Pages (r:1 w:999)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_initializer.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_initializer.rs
index 81aca5c958d90d96c90dba0f30d8555e4332db59..8e501de6e67f3ed01e93c8dca3999d1c5cf0d83c 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_initializer.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_initializer.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::initializer`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::initializer::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::initializer::WeightInfo for WeightInfo<T> {
 	/// Storage: System Digest (r:1 w:1)
 	/// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured)
 	/// The range of component `d` is `[0, 65536]`.
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_paras.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_paras.rs
index 07623f60b01235e78549744f03a7e40784bd9e29..d96964e69c11404cc8f3181115c64d46afa3aea6 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_paras.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_paras.rs
@@ -49,7 +49,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::paras`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::paras::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::paras::WeightInfo for WeightInfo<T> {
 	/// Storage: Paras CurrentCodeHash (r:1 w:1)
 	/// Proof Skipped: Paras CurrentCodeHash (max_values: None, max_size: None, mode: Measured)
 	/// Storage: Paras CodeByHashRefs (r:1 w:1)
diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_paras_inherent.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_paras_inherent.rs
index aa99ac9438c404aad48715370badd821207f669c..74dd55cc3f2cacd2b82bd60fe76b3060cc5f6c6c 100644
--- a/polkadot/runtime/westend/src/weights/runtime_parachains_paras_inherent.rs
+++ b/polkadot/runtime/westend/src/weights/runtime_parachains_paras_inherent.rs
@@ -47,7 +47,7 @@ use core::marker::PhantomData;
 
 /// Weight functions for `runtime_parachains::paras_inherent`.
 pub struct WeightInfo<T>(PhantomData<T>);
-impl<T: frame_system::Config> runtime_parachains::paras_inherent::WeightInfo for WeightInfo<T> {
+impl<T: frame_system::Config> polkadot_runtime_parachains::paras_inherent::WeightInfo for WeightInfo<T> {
 	/// Storage: `ParaInherent::Included` (r:1 w:1)
 	/// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `System::ParentHash` (r:1 w:0)
diff --git a/polkadot/runtime/westend/src/xcm_config.rs b/polkadot/runtime/westend/src/xcm_config.rs
index c6c5fb9e72a46afa70c6db09fd3a2b0f38d7e3a5..9d7143c96bb5eecda25309634d395ba24b6a8b11 100644
--- a/polkadot/runtime/westend/src/xcm_config.rs
+++ b/polkadot/runtime/westend/src/xcm_config.rs
@@ -28,7 +28,7 @@ use frame_support::{
 };
 use frame_system::EnsureRoot;
 use pallet_xcm::XcmPassthrough;
-use runtime_common::{
+use polkadot_runtime_common::{
 	xcm_sender::{ChildParachainRouter, ExponentialPrice},
 	ToAuthor,
 };
diff --git a/polkadot/statement-table/Cargo.toml b/polkadot/statement-table/Cargo.toml
index ad4a053fa3f9e434f8cc3f7ca9ef54f4435eba9c..7181afd9989ec9e0b00d1335bf35f2c5f2441836 100644
--- a/polkadot/statement-table/Cargo.toml
+++ b/polkadot/statement-table/Cargo.toml
@@ -10,7 +10,7 @@ description = "Stores messages other authorities issue about candidates in Polka
 workspace = true
 
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 sp-core = { path = "../../substrate/primitives/core" }
-primitives = { package = "polkadot-primitives", path = "../primitives" }
+polkadot-primitives = { path = "../primitives" }
 gum = { package = "tracing-gum", path = "../node/gum" }
diff --git a/polkadot/statement-table/src/generic.rs b/polkadot/statement-table/src/generic.rs
index 2ee6f6a4f781842866728e2105d6c23e2fa1cd70..e96ed6af73d9163678906f54efc064ccde62c602 100644
--- a/polkadot/statement-table/src/generic.rs
+++ b/polkadot/statement-table/src/generic.rs
@@ -30,12 +30,12 @@ use std::{
 	hash::Hash,
 };
 
-use primitives::{
+use polkadot_primitives::{
 	effective_minimum_backing_votes, ValidatorSignature,
 	ValidityAttestation as PrimitiveValidityAttestation,
 };
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 const LOG_TARGET: &str = "parachain::statement-table";
 
 /// Context for the statement table.
diff --git a/polkadot/statement-table/src/lib.rs b/polkadot/statement-table/src/lib.rs
index 3740d15cc4f326962b962557e61ca14e9163de7d..469c877eafc9fa4d56e6eae3187c2fb29b14a07a 100644
--- a/polkadot/statement-table/src/lib.rs
+++ b/polkadot/statement-table/src/lib.rs
@@ -34,7 +34,7 @@ pub use generic::{Config, Context, Table};
 /// Concrete instantiations suitable for v2 primitives.
 pub mod v2 {
 	use crate::generic;
-	use primitives::{
+	use polkadot_primitives::{
 		CandidateHash, CommittedCandidateReceipt, CompactStatement as PrimitiveStatement,
 		CoreIndex, ValidatorIndex, ValidatorSignature,
 	};
diff --git a/polkadot/xcm/Cargo.toml b/polkadot/xcm/Cargo.toml
index 2cd8e822ae16b39b4d9465b91b45869b1776dbf8..690fb377dad78a8f6fb6d946fabab1ce68ba91df 100644
--- a/polkadot/xcm/Cargo.toml
+++ b/polkadot/xcm/Cargo.toml
@@ -15,7 +15,7 @@ bounded-collections = { version = "0.2.0", default-features = false, features =
 derivative = { version = "2.2.0", default-features = false, features = ["use_core"] }
 impl-trait-for-tuples = "0.2.2"
 log = { workspace = true }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive", "max-encoded-len"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] }
 sp-weights = { path = "../../substrate/primitives/weights", default-features = false, features = ["serde"] }
 serde = { features = ["alloc", "derive", "rc"], workspace = true }
@@ -33,9 +33,9 @@ default = ["std"]
 wasm-api = []
 std = [
 	"bounded-collections/std",
+	"codec/std",
 	"environmental/std",
 	"log/std",
-	"parity-scale-codec/std",
 	"scale-info/std",
 	"serde/std",
 	"sp-weights/std",
diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/mod.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/mod.rs
index e3fdda2e733376ca3eb780acbc17256c12e6acac..e7d00ac71038b4f02d5172584a398f185864f46c 100644
--- a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/mod.rs
+++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/mod.rs
@@ -36,7 +36,7 @@ construct_runtime! {
 	}
 }
 
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type Block = Block;
 	type AccountId = AccountId;
@@ -49,8 +49,7 @@ impl mock_message_queue::Config for Runtime {
 	type XcmExecutor = XcmExecutor<XcmConfig>;
 }
 
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig as pallet_balances::DefaultConfig)]
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type Balance = Balance;
 	type AccountStore = System;
 }
diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/mod.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/mod.rs
index 25c35dd4aaa83c12b0176ea528d09f7d84bc87ce..686f86b37b73204e877ab3c935797ce92540816e 100644
--- a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/mod.rs
+++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/mod.rs
@@ -36,7 +36,7 @@ parameter_types! {
 	pub const BlockHashCount: u64 = 250;
 }
 
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
@@ -44,7 +44,7 @@ impl frame_system::Config for Runtime {
 	type AccountData = pallet_balances::AccountData<Balance>;
 }
 
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig as pallet_balances::DefaultConfig)]
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
 	type AccountStore = System;
 }
diff --git a/polkadot/xcm/pallet-xcm/src/benchmarking.rs b/polkadot/xcm/pallet-xcm/src/benchmarking.rs
index 081a4235b7794b72beda33895c2e5e5c9577d219..da46a6a37c0654f6ef34daf7bbd37cd5b655ac45 100644
--- a/polkadot/xcm/pallet-xcm/src/benchmarking.rs
+++ b/polkadot/xcm/pallet-xcm/src/benchmarking.rs
@@ -15,12 +15,11 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::*;
-use bounded_collections::{ConstU32, WeakBoundedVec};
 use frame_benchmarking::{benchmarks, whitelisted_caller, BenchmarkError, BenchmarkResult};
 use frame_support::{assert_ok, weights::Weight};
 use frame_system::RawOrigin;
 use sp_std::prelude::*;
-use xcm::{latest::prelude::*, v2};
+use xcm::latest::prelude::*;
 use xcm_builder::EnsureDelivery;
 use xcm_executor::traits::FeeReason;
 
@@ -313,15 +312,17 @@ benchmarks! {
 	}
 
 	notify_target_migration_fail {
-		let bad_loc: v2::MultiLocation = v2::Junction::Plurality {
-			id: v2::BodyId::Named(WeakBoundedVec::<u8, ConstU32<32>>::try_from(vec![0; 32])
-				.expect("vec has a length of 32 bits; qed")),
-			part: v2::BodyPart::Voice,
-		}
-		.into();
-		let bad_loc = VersionedLocation::from(bad_loc);
+		let newer_xcm_version = xcm::prelude::XCM_VERSION;
+		let older_xcm_version = newer_xcm_version - 1;
+		let bad_location: Location = Plurality {
+			id: BodyId::Unit,
+			part: BodyPart::Voice,
+		}.into();
+		let bad_location = VersionedLocation::from(bad_location)
+			.into_version(older_xcm_version)
+			.expect("Version convertion should work");
 		let current_version = T::AdvertisedXcmVersion::get();
-		VersionNotifyTargets::<T>::insert(current_version, bad_loc, (0, Weight::zero(), current_version));
+		VersionNotifyTargets::<T>::insert(current_version, bad_location, (0, Weight::zero(), current_version));
 	}: {
 		crate::Pallet::<T>::check_xcm_version_change(VersionMigrationStage::MigrateAndNotifyOldTargets, Weight::zero());
 	}
diff --git a/polkadot/xcm/pallet-xcm/src/lib.rs b/polkadot/xcm/pallet-xcm/src/lib.rs
index 37fc121ba2174c95f3a8ac82131d525ff8279f48..8f67e6e7d949693e25556af272ea73e443b620df 100644
--- a/polkadot/xcm/pallet-xcm/src/lib.rs
+++ b/polkadot/xcm/pallet-xcm/src/lib.rs
@@ -29,7 +29,9 @@ pub mod migration;
 
 use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
 use frame_support::{
-	dispatch::{DispatchErrorWithPostInfo, GetDispatchInfo, WithPostDispatchInfo},
+	dispatch::{
+		DispatchErrorWithPostInfo, GetDispatchInfo, PostDispatchInfo, WithPostDispatchInfo,
+	},
 	pallet_prelude::*,
 	traits::{
 		Contains, ContainsPair, Currency, Defensive, EnsureOrigin, Get, LockableCurrency,
@@ -50,18 +52,22 @@ use sp_runtime::{
 use sp_std::{boxed::Box, marker::PhantomData, prelude::*, result::Result, vec};
 use xcm::{latest::QueryResponseInfo, prelude::*};
 use xcm_builder::{
-	ExecuteController, ExecuteControllerWeightInfo, QueryController, QueryControllerWeightInfo,
-	SendController, SendControllerWeightInfo,
+	ExecuteController, ExecuteControllerWeightInfo, InspectMessageQueues, QueryController,
+	QueryControllerWeightInfo, SendController, SendControllerWeightInfo,
 };
 use xcm_executor::{
 	traits::{
 		AssetTransferError, CheckSuspension, ClaimAssets, ConvertLocation, ConvertOrigin,
 		DropAssets, MatchesFungible, OnResponse, Properties, QueryHandler, QueryResponseStatus,
-		TransactAsset, TransferType, VersionChangeNotifier, WeightBounds, XcmAssetTransfers,
+		RecordXcm, TransactAsset, TransferType, VersionChangeNotifier, WeightBounds,
+		XcmAssetTransfers,
 	},
 	AssetsInHolding,
 };
-use xcm_fee_payment_runtime_api::fees::Error as XcmPaymentApiError;
+use xcm_fee_payment_runtime_api::{
+	dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
+	fees::Error as XcmPaymentApiError,
+};
 
 #[cfg(any(feature = "try-runtime", test))]
 use sp_runtime::TryRuntimeError;
@@ -2432,6 +2438,100 @@ impl<T: Config> Pallet<T> {
 		AccountIdConversion::<T::AccountId>::into_account_truncating(&ID)
 	}
 
+	/// Dry-runs `call` with the given `origin`.
+	///
+	/// Returns not only the call result and events, but also the local XCM, if any,
+	/// and any XCMs forwarded to other locations.
+	/// Meant to be used in the `xcm_fee_payment_runtime_api::dry_run::DryRunApi` runtime API.
+	pub fn dry_run_call<Runtime, Router, OriginCaller, RuntimeCall>(
+		origin: OriginCaller,
+		call: RuntimeCall,
+	) -> Result<CallDryRunEffects<<Runtime as frame_system::Config>::RuntimeEvent>, XcmDryRunApiError>
+	where
+		Runtime: crate::Config,
+		Router: InspectMessageQueues,
+		RuntimeCall: Dispatchable<PostInfo = PostDispatchInfo>,
+		<RuntimeCall as Dispatchable>::RuntimeOrigin: From<OriginCaller>,
+	{
+		crate::Pallet::<Runtime>::set_record_xcm(true);
+		frame_system::Pallet::<Runtime>::reset_events(); // To make sure we only record events from current call.
+		let result = call.dispatch(origin.into());
+		crate::Pallet::<Runtime>::set_record_xcm(false);
+		let local_xcm = crate::Pallet::<Runtime>::recorded_xcm();
+		let forwarded_xcms = Router::get_messages();
+		let events: Vec<<Runtime as frame_system::Config>::RuntimeEvent> =
+			frame_system::Pallet::<Runtime>::read_events_no_consensus()
+				.map(|record| record.event.clone())
+				.collect();
+		Ok(CallDryRunEffects {
+			local_xcm: local_xcm.map(VersionedXcm::<()>::from),
+			forwarded_xcms,
+			emitted_events: events,
+			execution_result: result,
+		})
+	}
+
+	/// Dry-runs `xcm` with the given `origin_location`.
+	///
+	/// Returns execution result, events, and any forwarded XCMs to other locations.
+	/// Meant to be used in the `xcm_fee_payment_runtime_api::dry_run::DryRunApi` runtime API.
+	pub fn dry_run_xcm<Runtime, Router, RuntimeCall, XcmConfig>(
+		origin_location: VersionedLocation,
+		xcm: VersionedXcm<RuntimeCall>,
+	) -> Result<XcmDryRunEffects<<Runtime as frame_system::Config>::RuntimeEvent>, XcmDryRunApiError>
+	where
+		Runtime: frame_system::Config,
+		Router: InspectMessageQueues,
+		XcmConfig: xcm_executor::Config<RuntimeCall = RuntimeCall>,
+	{
+		let origin_location: Location = origin_location.try_into().map_err(|error| {
+			log::error!(
+				target: "xcm::DryRunApi::dry_run_xcm",
+				"Location version conversion failed with error: {:?}",
+				error,
+			);
+			XcmDryRunApiError::VersionedConversionFailed
+		})?;
+		let xcm: Xcm<RuntimeCall> = xcm.try_into().map_err(|error| {
+			log::error!(
+				target: "xcm::DryRunApi::dry_run_xcm",
+				"Xcm version conversion failed with error {:?}",
+				error,
+			);
+			XcmDryRunApiError::VersionedConversionFailed
+		})?;
+		let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256);
+		frame_system::Pallet::<Runtime>::reset_events(); // To make sure we only record events from current call.
+		let result = xcm_executor::XcmExecutor::<XcmConfig>::prepare_and_execute(
+			origin_location,
+			xcm,
+			&mut hash,
+			Weight::MAX, // Max limit available for execution.
+			Weight::zero(),
+		);
+		let forwarded_xcms = Router::get_messages();
+		let events: Vec<<Runtime as frame_system::Config>::RuntimeEvent> =
+			frame_system::Pallet::<Runtime>::read_events_no_consensus()
+				.map(|record| record.event.clone())
+				.collect();
+		Ok(XcmDryRunEffects { forwarded_xcms, emitted_events: events, execution_result: result })
+	}
+
+	/// Given a list of asset ids, returns the correct API response for
+	/// `XcmPaymentApi::query_acceptable_payment_assets`.
+	///
+	/// The assets passed in have to be supported for fee payment.
+	pub fn query_acceptable_payment_assets(
+		version: xcm::Version,
+		asset_ids: Vec<AssetId>,
+	) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
+		Ok(asset_ids
+			.into_iter()
+			.map(|asset_id| VersionedAssetId::from(asset_id))
+			.filter_map(|asset_id| asset_id.into_version(version).ok())
+			.collect())
+	}
+
 	pub fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
 		let message = Xcm::<()>::try_from(message)
 			.map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?;
@@ -3126,7 +3226,7 @@ impl<T: Config> CheckSuspension for Pallet<T> {
 	}
 }
 
-impl<T: Config> xcm_executor::traits::RecordXcm for Pallet<T> {
+impl<T: Config> RecordXcm for Pallet<T> {
 	fn should_record() -> bool {
 		ShouldRecordXcm::<T>::get()
 	}
diff --git a/polkadot/xcm/pallet-xcm/src/mock.rs b/polkadot/xcm/pallet-xcm/src/mock.rs
index b3b7529217f5a4929ce7beedcc1ffa423227112a..2be6f301f85621489ab6986aaf300251fd239fbc 100644
--- a/polkadot/xcm/pallet-xcm/src/mock.rs
+++ b/polkadot/xcm/pallet-xcm/src/mock.rs
@@ -238,10 +238,6 @@ impl SendXcm for TestPaidForPara3000SendXcm {
 	}
 }
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-}
-
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
 	type RuntimeOrigin = RuntimeOrigin;
@@ -253,7 +249,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type BlockWeights = ();
 	type BlockLength = ();
 	type Version = ();
@@ -271,24 +266,13 @@ impl frame_system::Config for Test {
 
 parameter_types! {
 	pub ExistentialDeposit: Balance = 1;
-	pub const MaxLocks: u32 = 50;
-	pub const MaxReserves: u32 = 50;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = MaxLocks;
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxReserves = MaxReserves;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 #[cfg(feature = "runtime-benchmarks")]
diff --git a/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs b/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs
index f42e220d693203f7fa6e1391676f36a84feb9be0..af81ac9cf43a978f08c4cee86adf4d72cee3a64b 100644
--- a/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs
+++ b/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs
@@ -76,7 +76,7 @@ fn limited_teleport_assets_works() {
 			)]
 		);
 		let versioned_sent = VersionedXcm::from(sent_xcm().into_iter().next().unwrap().1);
-		let _check_v2_ok: xcm::v2::Xcm<()> = versioned_sent.try_into().unwrap();
+		let _check_v3_ok: xcm::v3::Xcm<()> = versioned_sent.try_into().unwrap();
 
 		let mut last_events = last_events(3).into_iter();
 		assert_eq!(
diff --git a/polkadot/xcm/pallet-xcm/src/tests/mod.rs b/polkadot/xcm/pallet-xcm/src/tests/mod.rs
index 02aeafd68e83dffd01a7630ce357a4e9cd78cdf1..c16c1a1ba986e5c95da3ce63dd58c52393408464 100644
--- a/polkadot/xcm/pallet-xcm/src/tests/mod.rs
+++ b/polkadot/xcm/pallet-xcm/src/tests/mod.rs
@@ -602,11 +602,11 @@ fn basic_subscription_works() {
 
 		let weight = BaseXcmWeight::get();
 		let mut message = Xcm::<()>(vec![
-			// Remote supports XCM v2
+			// Remote supports XCM v3
 			QueryResponse {
 				query_id: 0,
 				max_weight: Weight::zero(),
-				response: Response::Version(1),
+				response: Response::Version(3),
 				querier: None,
 			},
 		]);
@@ -764,14 +764,14 @@ fn subscription_side_upgrades_work_with_notify() {
 	new_test_ext_with_balances(vec![]).execute_with(|| {
 		AdvertisedXcmVersion::set(1);
 
-		// An entry from a previous runtime with v2 XCM.
-		let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1001).into());
-		VersionNotifyTargets::<Test>::insert(1, v2_location, (70, Weight::zero(), 2));
-		let v3_location = Parachain(1003).into_versioned();
-		VersionNotifyTargets::<Test>::insert(3, v3_location, (72, Weight::zero(), 2));
+		// An entry from a previous runtime with v3 XCM.
+		let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1001).into());
+		VersionNotifyTargets::<Test>::insert(3, v3_location, (70, Weight::zero(), 3));
+		let v4_location = Parachain(1003).into_versioned();
+		VersionNotifyTargets::<Test>::insert(4, v4_location, (72, Weight::zero(), 3));
 
 		// New version.
-		AdvertisedXcmVersion::set(3);
+		AdvertisedXcmVersion::set(4);
 
 		// A runtime upgrade which alters the version does send notifications.
 		CurrentMigration::<Test>::put(VersionMigrationStage::default());
@@ -780,13 +780,13 @@ fn subscription_side_upgrades_work_with_notify() {
 		let instr1 = QueryResponse {
 			query_id: 70,
 			max_weight: Weight::zero(),
-			response: Response::Version(3),
+			response: Response::Version(4),
 			querier: None,
 		};
 		let instr3 = QueryResponse {
 			query_id: 72,
 			max_weight: Weight::zero(),
-			response: Response::Version(3),
+			response: Response::Version(4),
 			querier: None,
 		};
 		let mut sent = take_sent_xcm();
@@ -807,8 +807,8 @@ fn subscription_side_upgrades_work_with_notify() {
 		assert_eq!(
 			contents,
 			vec![
-				(XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 3)),
-				(XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 3)),
+				(XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 4)),
+				(XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 4)),
 			]
 		);
 	});
@@ -817,11 +817,11 @@ fn subscription_side_upgrades_work_with_notify() {
 #[test]
 fn subscription_side_upgrades_work_without_notify() {
 	new_test_ext_with_balances(vec![]).execute_with(|| {
-		// An entry from a previous runtime with v2 XCM.
-		let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1001).into());
-		VersionNotifyTargets::<Test>::insert(1, v2_location, (70, Weight::zero(), 2));
-		let v3_location = Parachain(1003).into_versioned();
-		VersionNotifyTargets::<Test>::insert(3, v3_location, (72, Weight::zero(), 2));
+		// An entry from a previous runtime with v3 XCM.
+		let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1001).into());
+		VersionNotifyTargets::<Test>::insert(3, v3_location, (70, Weight::zero(), 3));
+		let v4_location = Parachain(1003).into_versioned();
+		VersionNotifyTargets::<Test>::insert(4, v4_location, (72, Weight::zero(), 3));
 
 		// A runtime upgrade which alters the version does send notifications.
 		CurrentMigration::<Test>::put(VersionMigrationStage::default());
@@ -854,11 +854,11 @@ fn subscriber_side_subscription_works() {
 
 		let weight = BaseXcmWeight::get();
 		let message = Xcm(vec![
-			// Remote supports XCM v2
+			// Remote supports XCM v3
 			QueryResponse {
 				query_id: 0,
 				max_weight: Weight::zero(),
-				response: Response::Version(1),
+				response: Response::Version(3),
 				querier: None,
 			},
 		]);
@@ -872,18 +872,21 @@ fn subscriber_side_subscription_works() {
 		);
 		assert_eq!(r, Outcome::Complete { used: weight });
 		assert_eq!(take_sent_xcm(), vec![]);
-		assert_eq!(XcmPallet::get_version_for(&remote), Some(1));
+		assert_eq!(XcmPallet::get_version_for(&remote), Some(3));
 
-		// This message cannot be sent to a v2 remote.
-		let v2_msg = xcm::v2::Xcm::<()>(vec![xcm::v2::Instruction::Trap(0)]);
-		assert_eq!(XcmPallet::wrap_version(&remote, v2_msg.clone()), Err(()));
+		// This message will be sent as v3.
+		let v4_msg = xcm::v4::Xcm::<()>(vec![xcm::v4::Instruction::Trap(0)]);
+		assert_eq!(
+			XcmPallet::wrap_version(&remote, v4_msg.clone()),
+			Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::Trap(0)])))
+		);
 
 		let message = Xcm(vec![
-			// Remote upgraded to XCM v2
+			// Remote upgraded to XCM v4
 			QueryResponse {
 				query_id: 0,
 				max_weight: Weight::zero(),
-				response: Response::Version(2),
+				response: Response::Version(4),
 				querier: None,
 			},
 		]);
@@ -897,12 +900,12 @@ fn subscriber_side_subscription_works() {
 		);
 		assert_eq!(r, Outcome::Complete { used: weight });
 		assert_eq!(take_sent_xcm(), vec![]);
-		assert_eq!(XcmPallet::get_version_for(&remote), Some(2));
+		assert_eq!(XcmPallet::get_version_for(&remote), Some(4));
 
-		// This message can now be sent to remote as it's v2.
+		// This message is now sent as v4.
 		assert_eq!(
-			XcmPallet::wrap_version(&remote, v2_msg.clone()),
-			Ok(VersionedXcm::from(v2_msg))
+			XcmPallet::wrap_version(&remote, v4_msg.clone()),
+			Ok(VersionedXcm::from(v4_msg))
 		);
 	});
 }
@@ -911,30 +914,36 @@ fn subscriber_side_subscription_works() {
 #[test]
 fn auto_subscription_works() {
 	new_test_ext_with_balances_and_xcm_version(vec![], None).execute_with(|| {
-		let remote_v2: Location = Parachain(1000).into();
+		let remote_v3: Location = Parachain(1000).into();
 		let remote_v4: Location = Parachain(1001).into();
 
-		assert_ok!(XcmPallet::force_default_xcm_version(RuntimeOrigin::root(), Some(2)));
+		assert_ok!(XcmPallet::force_default_xcm_version(RuntimeOrigin::root(), Some(3)));
 
 		// Wrapping a version for a destination we don't know elicits a subscription.
-		let msg_v2 = xcm::v2::Xcm::<()>(vec![xcm::v2::Instruction::Trap(0)]);
+		let msg_v3 = xcm::v3::Xcm::<()>(vec![xcm::v3::Instruction::Trap(0)]);
 		let msg_v4 = xcm::v4::Xcm::<()>(vec![xcm::v4::Instruction::ClearTopic]);
 		assert_eq!(
-			XcmPallet::wrap_version(&remote_v2, msg_v2.clone()),
-			Ok(VersionedXcm::from(msg_v2.clone())),
+			XcmPallet::wrap_version(&remote_v3, msg_v3.clone()),
+			Ok(VersionedXcm::from(msg_v3.clone())),
+		);
+		assert_eq!(
+			XcmPallet::wrap_version(&remote_v3, msg_v4.clone()),
+			Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::ClearTopic])))
 		);
-		assert_eq!(XcmPallet::wrap_version(&remote_v2, msg_v4.clone()), Err(()));
 
-		let expected = vec![(remote_v2.clone().into(), 2)];
+		let expected = vec![(remote_v3.clone().into(), 2)];
 		assert_eq!(VersionDiscoveryQueue::<Test>::get().into_inner(), expected);
 
 		assert_eq!(
-			XcmPallet::wrap_version(&remote_v4, msg_v2.clone()),
-			Ok(VersionedXcm::from(msg_v2.clone())),
+			XcmPallet::wrap_version(&remote_v4, msg_v3.clone()),
+			Ok(VersionedXcm::from(msg_v3.clone())),
+		);
+		assert_eq!(
+			XcmPallet::wrap_version(&remote_v4, msg_v4.clone()),
+			Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::ClearTopic])))
 		);
-		assert_eq!(XcmPallet::wrap_version(&remote_v4, msg_v4.clone()), Err(()));
 
-		let expected = vec![(remote_v2.clone().into(), 2), (remote_v4.clone().into(), 2)];
+		let expected = vec![(remote_v3.clone().into(), 2), (remote_v4.clone().into(), 2)];
 		assert_eq!(VersionDiscoveryQueue::<Test>::get().into_inner(), expected);
 
 		XcmPallet::on_initialize(1);
@@ -968,10 +977,10 @@ fn auto_subscription_works() {
 		);
 		assert_eq!(r, Outcome::Complete { used: weight });
 
-		// V2 messages can be sent to remote_v4 under XCM v4.
+		// V3 messages can be sent to remote_v4 under XCM v4.
 		assert_eq!(
-			XcmPallet::wrap_version(&remote_v4, msg_v2.clone()),
-			Ok(VersionedXcm::from(msg_v2.clone()).into_version(4).unwrap()),
+			XcmPallet::wrap_version(&remote_v4, msg_v3.clone()),
+			Ok(VersionedXcm::from(msg_v3.clone()).into_version(4).unwrap()),
 		);
 		// This message can now be sent to remote_v4 as it's v4.
 		assert_eq!(
@@ -983,26 +992,26 @@ fn auto_subscription_works() {
 		assert_eq!(
 			take_sent_xcm(),
 			vec![(
-				remote_v2.clone(),
+				remote_v3.clone(),
 				Xcm(vec![SubscribeVersion { query_id: 1, max_response_weight: Weight::zero() }]),
 			)]
 		);
 
-		// Assume remote_v2 is working ok and XCM version 2.
+		// Assume remote_v3 is working ok and XCM version 3.
 
 		let weight = BaseXcmWeight::get();
 		let message = Xcm(vec![
-			// Remote supports XCM v2
+			// Remote supports XCM v3
 			QueryResponse {
 				query_id: 1,
 				max_weight: Weight::zero(),
-				response: Response::Version(2),
+				response: Response::Version(3),
 				querier: None,
 			},
 		]);
 		let mut hash = fake_message_hash(&message);
 		let r = XcmExecutor::<XcmConfig>::prepare_and_execute(
-			remote_v2.clone(),
+			remote_v3.clone(),
 			message,
 			&mut hash,
 			weight,
@@ -1010,12 +1019,15 @@ fn auto_subscription_works() {
 		);
 		assert_eq!(r, Outcome::Complete { used: weight });
 
-		// v4 messages cannot be sent to remote_v2...
+		// v4 messages cannot be sent to remote_v3...
+		assert_eq!(
+			XcmPallet::wrap_version(&remote_v3, msg_v3.clone()),
+			Ok(VersionedXcm::V3(msg_v3))
+		);
 		assert_eq!(
-			XcmPallet::wrap_version(&remote_v2, msg_v2.clone()),
-			Ok(VersionedXcm::V2(msg_v2))
+			XcmPallet::wrap_version(&remote_v3, msg_v4.clone()),
+			Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::ClearTopic])))
 		);
-		assert_eq!(XcmPallet::wrap_version(&remote_v2, msg_v4.clone()), Err(()));
 	})
 }
 
@@ -1025,15 +1037,15 @@ fn subscription_side_upgrades_work_with_multistage_notify() {
 		AdvertisedXcmVersion::set(1);
 
 		// An entry from a previous runtime with v0 XCM.
-		let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1001).into());
-		VersionNotifyTargets::<Test>::insert(1, v2_location, (70, Weight::zero(), 1));
-		let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1002).into());
-		VersionNotifyTargets::<Test>::insert(2, v2_location, (71, Weight::zero(), 1));
-		let v3_location = Parachain(1003).into_versioned();
-		VersionNotifyTargets::<Test>::insert(3, v3_location, (72, Weight::zero(), 1));
+		let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1001).into());
+		VersionNotifyTargets::<Test>::insert(3, v3_location, (70, Weight::zero(), 3));
+		let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1002).into());
+		VersionNotifyTargets::<Test>::insert(3, v3_location, (71, Weight::zero(), 3));
+		let v4_location = Parachain(1003).into_versioned();
+		VersionNotifyTargets::<Test>::insert(4, v4_location, (72, Weight::zero(), 3));
 
 		// New version.
-		AdvertisedXcmVersion::set(3);
+		AdvertisedXcmVersion::set(4);
 
 		// A runtime upgrade which alters the version does send notifications.
 		CurrentMigration::<Test>::put(VersionMigrationStage::default());
@@ -1049,19 +1061,19 @@ fn subscription_side_upgrades_work_with_multistage_notify() {
 		let instr1 = QueryResponse {
 			query_id: 70,
 			max_weight: Weight::zero(),
-			response: Response::Version(3),
+			response: Response::Version(4),
 			querier: None,
 		};
 		let instr2 = QueryResponse {
 			query_id: 71,
 			max_weight: Weight::zero(),
-			response: Response::Version(3),
+			response: Response::Version(4),
 			querier: None,
 		};
 		let instr3 = QueryResponse {
 			query_id: 72,
 			max_weight: Weight::zero(),
-			response: Response::Version(3),
+			response: Response::Version(4),
 			querier: None,
 		};
 		let mut sent = take_sent_xcm();
@@ -1083,9 +1095,9 @@ fn subscription_side_upgrades_work_with_multistage_notify() {
 		assert_eq!(
 			contents,
 			vec![
-				(XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 3)),
-				(XCM_VERSION, Parachain(1002).into_versioned(), (71, Weight::zero(), 3)),
-				(XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 3)),
+				(XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 4)),
+				(XCM_VERSION, Parachain(1002).into_versioned(), (71, Weight::zero(), 4)),
+				(XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 4)),
 			]
 		);
 	});
diff --git a/polkadot/xcm/procedural/tests/conversion_functions.rs b/polkadot/xcm/procedural/tests/conversion_functions.rs
index 5b6965167fcd318d3a7b10b3e56deeebf13ba7cb..7d2698d2cd776fe13f03a2a361edd32b552482ea 100644
--- a/polkadot/xcm/procedural/tests/conversion_functions.rs
+++ b/polkadot/xcm/procedural/tests/conversion_functions.rs
@@ -14,10 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use xcm::v2::prelude::*;
+use xcm::v3::prelude::*;
 
 #[test]
-fn slice_syntax_in_v2_works() {
+fn slice_syntax_in_v3_works() {
 	let old_junctions = Junctions::X2(Parachain(1), PalletInstance(1));
 	let new_junctions = Junctions::from([Parachain(1), PalletInstance(1)]);
 	assert_eq!(old_junctions, new_junctions);
diff --git a/polkadot/xcm/src/double_encoded.rs b/polkadot/xcm/src/double_encoded.rs
index 320cccf9b1f08dafa58497995a74943233d26c4b..a5eecdee97963530e29a37655ca4d153c6eae5c8 100644
--- a/polkadot/xcm/src/double_encoded.rs
+++ b/polkadot/xcm/src/double_encoded.rs
@@ -16,7 +16,7 @@
 
 use crate::MAX_XCM_DECODE_DEPTH;
 use alloc::vec::Vec;
-use parity_scale_codec::{Decode, DecodeLimit, Encode};
+use codec::{Decode, DecodeLimit, Encode};
 
 /// Wrapper around the encoded and decoded versions of a value.
 /// Caches the decoded value once computed.
diff --git a/polkadot/xcm/src/lib.rs b/polkadot/xcm/src/lib.rs
index 513dfe5501ba6c6ee8c233717c86b7f24f6eeb5f..1f5191c23407d7b88c52f872025583e4f701674d 100644
--- a/polkadot/xcm/src/lib.rs
+++ b/polkadot/xcm/src/lib.rs
@@ -21,13 +21,18 @@
 //
 // Hence, `no_std` rather than sp-runtime.
 #![cfg_attr(not(feature = "std"), no_std)]
+// Because of XCMv2.
+#![allow(deprecated)]
 
 extern crate alloc;
 
+use codec::{Decode, DecodeLimit, Encode, Error as CodecError, Input, MaxEncodedLen};
 use derivative::Derivative;
-use parity_scale_codec::{Decode, DecodeLimit, Encode, Error as CodecError, Input, MaxEncodedLen};
 use scale_info::TypeInfo;
 
+#[deprecated(
+	note = "XCMv2 will be removed once XCMv5 is released. Please use XCMv3 or XCMv4 instead."
+)]
 pub mod v2;
 pub mod v3;
 pub mod v4;
@@ -425,6 +430,7 @@ pub type VersionedMultiAssets = VersionedAssets;
 #[scale_info(replace_segment("staging_xcm", "xcm"))]
 pub enum VersionedXcm<RuntimeCall> {
 	#[codec(index = 2)]
+	#[deprecated]
 	V2(v2::Xcm<RuntimeCall>),
 	#[codec(index = 3)]
 	V3(v3::Xcm<RuntimeCall>),
diff --git a/polkadot/xcm/src/tests.rs b/polkadot/xcm/src/tests.rs
index 1aabbcef281d6638b4eabf3c077b5091514d07f0..4c666063f3f4706e77869b7aea5e16000f6dbc1d 100644
--- a/polkadot/xcm/src/tests.rs
+++ b/polkadot/xcm/src/tests.rs
@@ -158,18 +158,6 @@ fn encode_decode_versioned_multi_assets_v3() {
 	assert_eq!(assets, decoded);
 }
 
-#[test]
-fn encode_decode_versioned_xcm_v2() {
-	let xcm = VersionedXcm::V2(v2::Xcm::<()>::new());
-	let encoded = xcm.encode();
-
-	assert_eq!(encoded, hex_literal::hex!("0200"), "encode format changed");
-	assert_eq!(encoded[0], 2, "bad version number");
-
-	let decoded = VersionedXcm::decode(&mut &encoded[..]).unwrap();
-	assert_eq!(xcm, decoded);
-}
-
 #[test]
 fn encode_decode_versioned_xcm_v3() {
 	let xcm = VersionedXcm::V3(v3::Xcm::<()>::new());
diff --git a/polkadot/xcm/src/v2/junction.rs b/polkadot/xcm/src/v2/junction.rs
index 771931f4b566678829ebf07049842bab0232afc2..68a7886f303937870bb42aaee3e1f971a29e7044 100644
--- a/polkadot/xcm/src/v2/junction.rs
+++ b/polkadot/xcm/src/v2/junction.rs
@@ -19,7 +19,7 @@
 use super::{BodyId, BodyPart, Junctions, MultiLocation, NetworkId};
 use crate::v3::Junction as NewJunction;
 use bounded_collections::{ConstU32, WeakBoundedVec};
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
+use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// A single item in a path to describe the relative location of a consensus system.
diff --git a/polkadot/xcm/src/v2/mod.rs b/polkadot/xcm/src/v2/mod.rs
index 347f3f2c29206222ca546b7d543409da83cbedcf..38e55d0ea51e5844640b2e9613f830f7cd636e7f 100644
--- a/polkadot/xcm/src/v2/mod.rs
+++ b/polkadot/xcm/src/v2/mod.rs
@@ -15,6 +15,9 @@
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
 
 //! # XCM Version 2
+//!
+//! WARNING: DEPRECATED, please use version 3 or 4.
+//!
 //! Version 2 of the Cross-Consensus Message format data structures. The comprehensive list of
 //! changes can be found in
 //! [this PR description](https://github.com/paritytech/polkadot/pull/3629#issue-968428279).
@@ -52,16 +55,16 @@
 use super::{
 	v3::{
 		BodyId as NewBodyId, BodyPart as NewBodyPart, Instruction as NewInstruction,
-		NetworkId as NewNetworkId, Response as NewResponse, WeightLimit as NewWeightLimit,
-		Xcm as NewXcm,
+		NetworkId as NewNetworkId, OriginKind as NewOriginKind, Response as NewResponse,
+		WeightLimit as NewWeightLimit, Xcm as NewXcm,
 	},
 	DoubleEncoded,
 };
 use alloc::{vec, vec::Vec};
 use bounded_collections::{ConstU32, WeakBoundedVec};
+use codec::{self, Decode, Encode, MaxEncodedLen};
 use core::{fmt::Debug, result};
 use derivative::Derivative;
-use parity_scale_codec::{self, Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 mod junction;
@@ -104,6 +107,18 @@ pub enum OriginKind {
 	Xcm,
 }
 
+impl From<NewOriginKind> for OriginKind {
+	fn from(new: NewOriginKind) -> Self {
+		use NewOriginKind::*;
+		match new {
+			Native => Self::Native,
+			SovereignAccount => Self::SovereignAccount,
+			Superuser => Self::Superuser,
+			Xcm => Self::Xcm,
+		}
+	}
+}
+
 /// A global identifier of an account-bearing consensus system.
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
 #[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
@@ -262,6 +277,7 @@ pub const VERSION: super::Version = 2;
 /// An identifier for a query.
 pub type QueryId = u64;
 
+/// DEPRECATED. Please use XCMv3 or XCMv4 instead.
 #[derive(Derivative, Default, Encode, Decode, TypeInfo)]
 #[derivative(Clone(bound = ""), Eq(bound = ""), PartialEq(bound = ""), Debug(bound = ""))]
 #[codec(encode_bound())]
@@ -1065,7 +1081,7 @@ impl<RuntimeCall> TryFrom<NewInstruction<RuntimeCall>> for Instruction<RuntimeCa
 			HrmpChannelClosing { initiator, sender, recipient } =>
 				Self::HrmpChannelClosing { initiator, sender, recipient },
 			Transact { origin_kind, require_weight_at_most, call } => Self::Transact {
-				origin_type: origin_kind,
+				origin_type: origin_kind.into(),
 				require_weight_at_most: require_weight_at_most.ref_time(),
 				call: call.into(),
 			},
diff --git a/polkadot/xcm/src/v2/multiasset.rs b/polkadot/xcm/src/v2/multiasset.rs
index 5681e9ef8a447cfaf67c6e65c75adc1e1337120f..7090ef138ca2d3ef71ec9743722b85d9459bd3dc 100644
--- a/polkadot/xcm/src/v2/multiasset.rs
+++ b/polkadot/xcm/src/v2/multiasset.rs
@@ -34,8 +34,8 @@ use crate::v3::{
 	WildMultiAsset as NewWildMultiAsset,
 };
 use alloc::{vec, vec::Vec};
+use codec::{self as codec, Decode, Encode};
 use core::cmp::Ordering;
-use parity_scale_codec::{self as codec, Decode, Encode};
 use scale_info::TypeInfo;
 
 /// A general identifier for an instance of a non-fungible asset class.
@@ -317,7 +317,7 @@ impl TryFrom<NewMultiAsset> for MultiAsset {
 pub struct MultiAssets(Vec<MultiAsset>);
 
 impl Decode for MultiAssets {
-	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, parity_scale_codec::Error> {
+	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
 		Self::from_sorted_and_deduplicated(Vec::<MultiAsset>::decode(input)?)
 			.map_err(|()| "Out of order".into())
 	}
diff --git a/polkadot/xcm/src/v2/multilocation.rs b/polkadot/xcm/src/v2/multilocation.rs
index ac98da8d08c910160a099e92eeef3eacd7e56513..9399ca6619c0d6c2842cfa6ab312936d727d6518 100644
--- a/polkadot/xcm/src/v2/multilocation.rs
+++ b/polkadot/xcm/src/v2/multilocation.rs
@@ -18,8 +18,8 @@
 
 use super::Junction;
 use crate::v3::MultiLocation as NewMultiLocation;
+use codec::{Decode, Encode, MaxEncodedLen};
 use core::{mem, result};
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// A relative path between state-bearing consensus systems.
@@ -883,7 +883,7 @@ impl TryFrom<MultiLocation> for Junctions {
 mod tests {
 	use super::{Ancestor, AncestorThen, Junctions::*, MultiLocation, Parent, ParentThen};
 	use crate::opaque::v2::{Junction::*, NetworkId::*};
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 
 	#[test]
 	fn inverted_works() {
diff --git a/polkadot/xcm/src/v2/traits.rs b/polkadot/xcm/src/v2/traits.rs
index 9cfb9b051ab2a92f3cf0e405795fdd31460b2681..4dcb4c50c68cd7d727588988d32b0f514a15dfb5 100644
--- a/polkadot/xcm/src/v2/traits.rs
+++ b/polkadot/xcm/src/v2/traits.rs
@@ -17,8 +17,8 @@
 //! Cross-Consensus Message format data structures.
 
 use crate::v3::Error as NewError;
+use codec::{Decode, Encode};
 use core::result;
-use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 
 use super::*;
@@ -282,7 +282,7 @@ pub type SendResult = result::Result<(), SendError>;
 /// # Example
 /// ```rust
 /// # use staging_xcm::v2::prelude::*;
-/// # use parity_scale_codec::Encode;
+/// # use codec::Encode;
 ///
 /// /// A sender that only passes the message through and does nothing.
 /// struct Sender1;
diff --git a/polkadot/xcm/src/v3/junction.rs b/polkadot/xcm/src/v3/junction.rs
index 32ce352c5c02b0a7a3dd31fa02854767cf483efa..aea4e03725159bcd08233353c60de6cde6d6b9ed 100644
--- a/polkadot/xcm/src/v3/junction.rs
+++ b/polkadot/xcm/src/v3/junction.rs
@@ -26,7 +26,7 @@ use crate::{
 	VersionedLocation,
 };
 use bounded_collections::{BoundedSlice, BoundedVec, ConstU32};
-use parity_scale_codec::{self, Decode, Encode, MaxEncodedLen};
+use codec::{self, Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};
 
diff --git a/polkadot/xcm/src/v3/junctions.rs b/polkadot/xcm/src/v3/junctions.rs
index 7b014304fdaf7826861ad9e8ea469390bc0513b9..56f5326fe97c6f260d53f66a9bc8ec7b3f169537 100644
--- a/polkadot/xcm/src/v3/junctions.rs
+++ b/polkadot/xcm/src/v3/junctions.rs
@@ -17,8 +17,8 @@
 //! XCM `Junctions`/`InteriorMultiLocation` datatype.
 
 use super::{Junction, MultiLocation, NetworkId};
+use codec::{Decode, Encode, MaxEncodedLen};
 use core::{mem, result};
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// Maximum number of `Junction`s that a `Junctions` can contain.
diff --git a/polkadot/xcm/src/v3/mod.rs b/polkadot/xcm/src/v3/mod.rs
index e7c57f414eb786a50f3689a3d3706632bdc4f902..880520cfedc2a82d94d01d936cfc7a00b77ade14 100644
--- a/polkadot/xcm/src/v3/mod.rs
+++ b/polkadot/xcm/src/v3/mod.rs
@@ -16,25 +16,24 @@
 
 //! Version 3 of the Cross-Consensus Message format data structures.
 
-use super::{
-	v2::{
-		Instruction as OldInstruction, Response as OldResponse, WeightLimit as OldWeightLimit,
-		Xcm as OldXcm,
-	},
-	v4::{
-		Instruction as NewInstruction, PalletInfo as NewPalletInfo,
-		QueryResponseInfo as NewQueryResponseInfo, Response as NewResponse, Xcm as NewXcm,
-	},
+#[allow(deprecated)]
+use super::v2::{
+	Instruction as OldInstruction, OriginKind as OldOriginKind, Response as OldResponse,
+	WeightLimit as OldWeightLimit, Xcm as OldXcm,
+};
+use super::v4::{
+	Instruction as NewInstruction, PalletInfo as NewPalletInfo,
+	QueryResponseInfo as NewQueryResponseInfo, Response as NewResponse, Xcm as NewXcm,
 };
 use crate::DoubleEncoded;
 use alloc::{vec, vec::Vec};
 use bounded_collections::{parameter_types, BoundedVec};
-use core::{fmt::Debug, result};
-use derivative::Derivative;
-use parity_scale_codec::{
+use codec::{
 	self, decode_vec_with_len, Compact, Decode, Encode, Error as CodecError, Input as CodecInput,
 	MaxEncodedLen,
 };
+use core::{fmt::Debug, result};
+use derivative::Derivative;
 use scale_info::TypeInfo;
 
 mod junction;
@@ -53,11 +52,46 @@ pub use multilocation::{
 	Ancestor, AncestorThen, InteriorMultiLocation, Location, MultiLocation, Parent, ParentThen,
 };
 pub use traits::{
-	send_xcm, validate_send, Error, ExecuteXcm, Outcome, PreparedMessage, Result, SendError,
-	SendResult, SendXcm, Weight, XcmHash,
+	send_xcm, validate_send, Error, ExecuteXcm, GetWeight, Outcome, PreparedMessage, Result,
+	SendError, SendResult, SendXcm, Weight, XcmHash,
 };
-// These parts of XCM v2 are unchanged in XCM v3, and are re-imported here.
-pub use super::v2::{GetWeight, OriginKind};
+
+/// Basically just the XCM (more general) version of `ParachainDispatchOrigin`.
+#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, Debug, TypeInfo)]
+#[scale_info(replace_segment("staging_xcm", "xcm"))]
+#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
+pub enum OriginKind {
+	/// Origin should just be the native dispatch origin representation for the sender in the
+	/// local runtime framework. For Cumulus/Frame chains this is the `Parachain` or `Relay` origin
+	/// if coming from a chain, though there may be others if the `MultiLocation` XCM origin has a
+	/// primary/native dispatch origin form.
+	Native,
+
+	/// Origin should just be the standard account-based origin with the sovereign account of
+	/// the sender. For Cumulus/Frame chains, this is the `Signed` origin.
+	SovereignAccount,
+
+	/// Origin should be the super-user. For Cumulus/Frame chains, this is the `Root` origin.
+	/// This will not usually be an available option.
+	Superuser,
+
+	/// Origin should be interpreted as an XCM native origin and the `MultiLocation` should be
+	/// encoded directly in the dispatch origin unchanged. For Cumulus/Frame chains, this will be
+	/// the `pallet_xcm::Origin::Xcm` type.
+	Xcm,
+}
+
+impl From<OldOriginKind> for OriginKind {
+	fn from(old: OldOriginKind) -> Self {
+		use OldOriginKind::*;
+		match old {
+			Native => Self::Native,
+			SovereignAccount => Self::SovereignAccount,
+			Superuser => Self::Superuser,
+			Xcm => Self::Xcm,
+		}
+	}
+}
 
 /// This module's XCM version.
 pub const VERSION: super::Version = 3;
@@ -1310,6 +1344,7 @@ impl TryFrom<OldResponse> for Response {
 }
 
 // Convert from a v2 XCM to a v3 XCM.
+#[allow(deprecated)]
 impl<Call> TryFrom<OldXcm<Call>> for Xcm<Call> {
 	type Error = ();
 	fn try_from(old_xcm: OldXcm<Call>) -> result::Result<Self, ()> {
@@ -1500,7 +1535,7 @@ impl<Call> TryFrom<OldInstruction<Call>> for Instruction<Call> {
 			HrmpChannelClosing { initiator, sender, recipient } =>
 				Self::HrmpChannelClosing { initiator, sender, recipient },
 			Transact { origin_type, require_weight_at_most, call } => Self::Transact {
-				origin_kind: origin_type,
+				origin_kind: origin_type.into(),
 				require_weight_at_most: Weight::from_parts(
 					require_weight_at_most,
 					DEFAULT_PROOF_SIZE,
@@ -1572,118 +1607,6 @@ impl<Call> TryFrom<OldInstruction<Call>> for Instruction<Call> {
 #[cfg(test)]
 mod tests {
 	use super::{prelude::*, *};
-	use crate::v2::{
-		Junctions::Here as OldHere, MultiAssetFilter as OldMultiAssetFilter,
-		WildMultiAsset as OldWildMultiAsset,
-	};
-
-	#[test]
-	fn basic_roundtrip_works() {
-		let xcm = Xcm::<()>(vec![TransferAsset {
-			assets: (Here, 1u128).into(),
-			beneficiary: Here.into(),
-		}]);
-		let old_xcm = OldXcm::<()>(vec![OldInstruction::TransferAsset {
-			assets: (OldHere, 1).into(),
-			beneficiary: OldHere.into(),
-		}]);
-		assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap());
-		let new_xcm: Xcm<()> = old_xcm.try_into().unwrap();
-		assert_eq!(new_xcm, xcm);
-	}
-
-	#[test]
-	fn teleport_roundtrip_works() {
-		let xcm = Xcm::<()>(vec![
-			ReceiveTeleportedAsset((Here, 1u128).into()),
-			ClearOrigin,
-			DepositAsset { assets: Wild(AllCounted(1)), beneficiary: Here.into() },
-		]);
-		let old_xcm: OldXcm<()> = OldXcm::<()>(vec![
-			OldInstruction::ReceiveTeleportedAsset((OldHere, 1).into()),
-			OldInstruction::ClearOrigin,
-			OldInstruction::DepositAsset {
-				assets: crate::v2::MultiAssetFilter::Wild(crate::v2::WildMultiAsset::All),
-				max_assets: 1,
-				beneficiary: OldHere.into(),
-			},
-		]);
-		assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap());
-		let new_xcm: Xcm<()> = old_xcm.try_into().unwrap();
-		assert_eq!(new_xcm, xcm);
-	}
-
-	#[test]
-	fn reserve_deposit_roundtrip_works() {
-		let xcm = Xcm::<()>(vec![
-			ReserveAssetDeposited((Here, 1u128).into()),
-			ClearOrigin,
-			BuyExecution {
-				fees: (Here, 1u128).into(),
-				weight_limit: Some(Weight::from_parts(1, DEFAULT_PROOF_SIZE)).into(),
-			},
-			DepositAsset { assets: Wild(AllCounted(1)), beneficiary: Here.into() },
-		]);
-		let old_xcm = OldXcm::<()>(vec![
-			OldInstruction::ReserveAssetDeposited((OldHere, 1).into()),
-			OldInstruction::ClearOrigin,
-			OldInstruction::BuyExecution {
-				fees: (OldHere, 1).into(),
-				weight_limit: Some(1).into(),
-			},
-			OldInstruction::DepositAsset {
-				assets: crate::v2::MultiAssetFilter::Wild(crate::v2::WildMultiAsset::All),
-				max_assets: 1,
-				beneficiary: OldHere.into(),
-			},
-		]);
-		assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap());
-		let new_xcm: Xcm<()> = old_xcm.try_into().unwrap();
-		assert_eq!(new_xcm, xcm);
-	}
-
-	#[test]
-	fn deposit_asset_roundtrip_works() {
-		let xcm = Xcm::<()>(vec![
-			WithdrawAsset((Here, 1u128).into()),
-			DepositAsset { assets: Wild(AllCounted(1)), beneficiary: Here.into() },
-		]);
-		let old_xcm = OldXcm::<()>(vec![
-			OldInstruction::WithdrawAsset((OldHere, 1).into()),
-			OldInstruction::DepositAsset {
-				assets: OldMultiAssetFilter::Wild(OldWildMultiAsset::All),
-				max_assets: 1,
-				beneficiary: OldHere.into(),
-			},
-		]);
-		assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap());
-		let new_xcm: Xcm<()> = old_xcm.try_into().unwrap();
-		assert_eq!(new_xcm, xcm);
-	}
-
-	#[test]
-	fn deposit_reserve_asset_roundtrip_works() {
-		let xcm = Xcm::<()>(vec![
-			WithdrawAsset((Here, 1u128).into()),
-			DepositReserveAsset {
-				assets: Wild(AllCounted(1)),
-				dest: Here.into(),
-				xcm: Xcm::<()>(vec![]),
-			},
-		]);
-		let old_xcm = OldXcm::<()>(vec![
-			OldInstruction::WithdrawAsset((OldHere, 1).into()),
-			OldInstruction::DepositReserveAsset {
-				assets: OldMultiAssetFilter::Wild(OldWildMultiAsset::All),
-				max_assets: 1,
-				dest: OldHere.into(),
-				xcm: OldXcm::<()>(vec![]),
-			},
-		]);
-		assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap());
-		let new_xcm: Xcm<()> = old_xcm.try_into().unwrap();
-		assert_eq!(new_xcm, xcm);
-	}
 
 	#[test]
 	fn decoding_respects_limit() {
diff --git a/polkadot/xcm/src/v3/multiasset.rs b/polkadot/xcm/src/v3/multiasset.rs
index 9a67b0e4986caf1a52eaa108e77f9394537d7553..7db0fa7369028f94fe080437299835c7537f0f56 100644
--- a/polkadot/xcm/src/v3/multiasset.rs
+++ b/polkadot/xcm/src/v3/multiasset.rs
@@ -42,8 +42,8 @@ use crate::{
 };
 use alloc::{vec, vec::Vec};
 use bounded_collections::{BoundedVec, ConstU32};
+use codec::{self as codec, Decode, Encode, MaxEncodedLen};
 use core::cmp::Ordering;
-use parity_scale_codec::{self as codec, Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// A general identifier for an instance of a non-fungible asset class.
@@ -302,7 +302,7 @@ enum UncheckedFungibility {
 }
 
 impl Decode for Fungibility {
-	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, parity_scale_codec::Error> {
+	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
 		match UncheckedFungibility::decode(input)? {
 			UncheckedFungibility::Fungible(a) if a != 0 => Ok(Self::Fungible(a)),
 			UncheckedFungibility::NonFungible(i) => Ok(Self::NonFungible(i)),
diff --git a/polkadot/xcm/src/v3/multilocation.rs b/polkadot/xcm/src/v3/multilocation.rs
index 731e277b29d8897d46406a1c7a8927461bcf889b..e51981204d96ce709991007c91c6a52e133711fe 100644
--- a/polkadot/xcm/src/v3/multilocation.rs
+++ b/polkadot/xcm/src/v3/multilocation.rs
@@ -20,8 +20,8 @@ use super::{Junction, Junctions};
 use crate::{
 	v2::MultiLocation as OldMultiLocation, v4::Location as NewMultiLocation, VersionedLocation,
 };
+use codec::{Decode, Encode, MaxEncodedLen};
 use core::result;
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// A relative path between state-bearing consensus systems.
@@ -531,7 +531,7 @@ xcm_procedural::impl_conversion_functions_for_multilocation_v3!();
 #[cfg(test)]
 mod tests {
 	use crate::v3::prelude::*;
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 
 	#[test]
 	fn conversion_works() {
diff --git a/polkadot/xcm/src/v3/traits.rs b/polkadot/xcm/src/v3/traits.rs
index cfe387df1a86c3aa21da69ce37eadb307df1c51b..7fa8824c3568ac0a16571c826648af013da48b26 100644
--- a/polkadot/xcm/src/v3/traits.rs
+++ b/polkadot/xcm/src/v3/traits.rs
@@ -17,14 +17,19 @@
 //! Cross-Consensus Message format data structures.
 
 use crate::v2::Error as OldError;
+use codec::{Decode, Encode, MaxEncodedLen};
 use core::result;
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 pub use sp_weights::Weight;
 
 use super::*;
 
+// A simple trait to get the weight of some object.
+pub trait GetWeight<W> {
+	fn weight(&self) -> sp_weights::Weight;
+}
+
 /// Error codes used in XCM. The first errors codes have explicit indices and are part of the XCM
 /// format. Those trailing are merely part of the XCM implementation; there is no expectation that
 /// they will retain the same index over time.
@@ -402,7 +407,7 @@ pub type SendResult<T> = result::Result<(T, MultiAssets), SendError>;
 ///
 /// # Example
 /// ```rust
-/// # use parity_scale_codec::Encode;
+/// # use codec::Encode;
 /// # use staging_xcm::v3::{prelude::*, Weight};
 /// # use staging_xcm::VersionedXcm;
 /// # use std::convert::Infallible;
diff --git a/polkadot/xcm/src/v4/asset.rs b/polkadot/xcm/src/v4/asset.rs
index 6b6d200f32febca6ef5cb208bfed95d50724e58b..a081b595adb1b77085dc232034ccc7f961922d1a 100644
--- a/polkadot/xcm/src/v4/asset.rs
+++ b/polkadot/xcm/src/v4/asset.rs
@@ -34,8 +34,8 @@ use crate::v3::{
 };
 use alloc::{vec, vec::Vec};
 use bounded_collections::{BoundedVec, ConstU32};
+use codec::{self as codec, Decode, Encode, MaxEncodedLen};
 use core::cmp::Ordering;
-use parity_scale_codec::{self as codec, Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// A general identifier for an instance of a non-fungible asset class.
@@ -274,7 +274,7 @@ enum UncheckedFungibility {
 }
 
 impl Decode for Fungibility {
-	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, parity_scale_codec::Error> {
+	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
 		match UncheckedFungibility::decode(input)? {
 			UncheckedFungibility::Fungible(a) if a != 0 => Ok(Self::Fungible(a)),
 			UncheckedFungibility::NonFungible(i) => Ok(Self::NonFungible(i)),
@@ -559,7 +559,7 @@ impl MaxEncodedLen for Assets {
 }
 
 impl Decode for Assets {
-	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, parity_scale_codec::Error> {
+	fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
 		let bounded_instructions =
 			BoundedVec::<Asset, ConstU32<{ MAX_ITEMS_IN_ASSETS as u32 }>>::decode(input)?;
 		Self::from_sorted_and_deduplicated(bounded_instructions.into_inner())
diff --git a/polkadot/xcm/src/v4/junction.rs b/polkadot/xcm/src/v4/junction.rs
index 3ae97de5e9b83336c10e0c20e865ddbebfef8b50..36fb616d2dc549a05c71531e0ac63cf63c7d78d0 100644
--- a/polkadot/xcm/src/v4/junction.rs
+++ b/polkadot/xcm/src/v4/junction.rs
@@ -23,7 +23,7 @@ use crate::{
 	VersionedLocation,
 };
 use bounded_collections::{BoundedSlice, BoundedVec, ConstU32};
-use parity_scale_codec::{self, Decode, Encode, MaxEncodedLen};
+use codec::{self, Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};
 
diff --git a/polkadot/xcm/src/v4/junctions.rs b/polkadot/xcm/src/v4/junctions.rs
index 6d1af59e13dcb179399379010d037e1c5a112c3c..e5c54ecb21a5fd61772a011f6a34d359138a30dd 100644
--- a/polkadot/xcm/src/v4/junctions.rs
+++ b/polkadot/xcm/src/v4/junctions.rs
@@ -18,8 +18,8 @@
 
 use super::{Junction, Location, NetworkId};
 use alloc::sync::Arc;
+use codec::{Decode, Encode, MaxEncodedLen};
 use core::{mem, ops::Range, result};
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// Maximum number of `Junction`s that a `Junctions` can contain.
diff --git a/polkadot/xcm/src/v4/location.rs b/polkadot/xcm/src/v4/location.rs
index cee76b6894076cc1ba9ddf960b2ad68a0693351e..9e94d13626d619b2d4db5593561abacb7bad2e8f 100644
--- a/polkadot/xcm/src/v4/location.rs
+++ b/polkadot/xcm/src/v4/location.rs
@@ -18,8 +18,8 @@
 
 use super::{traits::Reanchorable, Junction, Junctions};
 use crate::{v3::MultiLocation as OldLocation, VersionedLocation};
+use codec::{Decode, Encode, MaxEncodedLen};
 use core::result;
-use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 /// A relative path between state-bearing consensus systems.
@@ -539,7 +539,7 @@ xcm_procedural::impl_conversion_functions_for_location_v4!();
 #[cfg(test)]
 mod tests {
 	use crate::v4::prelude::*;
-	use parity_scale_codec::{Decode, Encode};
+	use codec::{Decode, Encode};
 
 	#[test]
 	fn conversion_works() {
diff --git a/polkadot/xcm/src/v4/mod.rs b/polkadot/xcm/src/v4/mod.rs
index 77b6d915fcb5fa902e5168e46b38cdb677f98cbf..57840562ba3e4754efea5eb6185f86691bd3c326 100644
--- a/polkadot/xcm/src/v4/mod.rs
+++ b/polkadot/xcm/src/v4/mod.rs
@@ -16,7 +16,7 @@
 
 //! Version 4 of the Cross-Consensus Message format data structures.
 
-pub use super::v2::GetWeight;
+pub use super::v3::GetWeight;
 use super::v3::{
 	Instruction as OldInstruction, PalletInfo as OldPalletInfo,
 	QueryResponseInfo as OldQueryResponseInfo, Response as OldResponse, Xcm as OldXcm,
@@ -24,12 +24,12 @@ use super::v3::{
 use crate::DoubleEncoded;
 use alloc::{vec, vec::Vec};
 use bounded_collections::{parameter_types, BoundedVec};
-use core::{fmt::Debug, result};
-use derivative::Derivative;
-use parity_scale_codec::{
+use codec::{
 	self, decode_vec_with_len, Compact, Decode, Encode, Error as CodecError, Input as CodecInput,
 	MaxEncodedLen,
 };
+use core::{fmt::Debug, result};
+use derivative::Derivative;
 use scale_info::TypeInfo;
 
 mod asset;
diff --git a/polkadot/xcm/src/v4/traits.rs b/polkadot/xcm/src/v4/traits.rs
index f6136c76d808f1708bcf5c6c9f8db2e49b15b232..351de92c80edd169cfa1498a76597ef0b976e6ef 100644
--- a/polkadot/xcm/src/v4/traits.rs
+++ b/polkadot/xcm/src/v4/traits.rs
@@ -17,8 +17,8 @@
 //! Cross-Consensus Message format data structures.
 
 pub use crate::v3::{Error, Result, SendError, XcmHash};
+use codec::{Decode, Encode};
 use core::result;
-use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 
 pub use sp_weights::Weight;
@@ -161,7 +161,7 @@ pub type SendResult<T> = result::Result<(T, Assets), SendError>;
 ///
 /// # Example
 /// ```rust
-/// # use parity_scale_codec::Encode;
+/// # use codec::Encode;
 /// # use staging_xcm::v4::{prelude::*, Weight};
 /// # use staging_xcm::VersionedXcm;
 /// # use std::convert::Infallible;
diff --git a/polkadot/xcm/xcm-builder/Cargo.toml b/polkadot/xcm/xcm-builder/Cargo.toml
index 707e4aac7968a3032f717e802122903014d669ef..79c601b98b4fd012202a8a4de00b2d254a7c8023 100644
--- a/polkadot/xcm/xcm-builder/Cargo.toml
+++ b/polkadot/xcm/xcm-builder/Cargo.toml
@@ -11,7 +11,7 @@ workspace = true
 
 [dependencies]
 impl-trait-for-tuples = "0.2.1"
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 xcm = { package = "staging-xcm", path = "..", default-features = false }
 xcm-executor = { package = "staging-xcm-executor", path = "../xcm-executor", default-features = false }
@@ -34,7 +34,7 @@ pallet-balances = { path = "../../../substrate/frame/balances" }
 pallet-xcm = { path = "../pallet-xcm" }
 pallet-salary = { path = "../../../substrate/frame/salary" }
 pallet-assets = { path = "../../../substrate/frame/assets" }
-primitives = { package = "polkadot-primitives", path = "../../primitives" }
+polkadot-primitives = { path = "../../primitives" }
 polkadot-runtime-parachains = { path = "../../runtime/parachains" }
 assert_matches = "1.5.0"
 polkadot-test-runtime = { path = "../../runtime/test-runtime" }
@@ -49,18 +49,18 @@ runtime-benchmarks = [
 	"pallet-salary/runtime-benchmarks",
 	"pallet-xcm/runtime-benchmarks",
 	"polkadot-parachain-primitives/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
 	"polkadot-runtime-parachains/runtime-benchmarks",
 	"polkadot-test-runtime/runtime-benchmarks",
-	"primitives/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"xcm-executor/runtime-benchmarks",
 ]
 std = [
+	"codec/std",
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",
 	"pallet-transaction-payment/std",
-	"parity-scale-codec/std",
 	"polkadot-parachain-primitives/std",
 	"scale-info/std",
 	"sp-arithmetic/std",
diff --git a/polkadot/xcm/xcm-builder/src/currency_adapter.rs b/polkadot/xcm/xcm-builder/src/currency_adapter.rs
index 24261ac06583c4ca284f52071a4ee80afae2a6ec..99a736d6ac1f9dd197a6813cf377f35991638e9a 100644
--- a/polkadot/xcm/xcm-builder/src/currency_adapter.rs
+++ b/polkadot/xcm/xcm-builder/src/currency_adapter.rs
@@ -51,7 +51,7 @@ impl From<Error> for XcmError {
 ///
 /// # Example
 /// ```
-/// use parity_scale_codec::Decode;
+/// use codec::Decode;
 /// use frame_support::{parameter_types, PalletId};
 /// use sp_runtime::traits::{AccountIdConversion, TrailingZeroInput};
 /// use xcm::latest::prelude::*;
diff --git a/polkadot/xcm/xcm-builder/src/location_conversion.rs b/polkadot/xcm/xcm-builder/src/location_conversion.rs
index c9553030817a1a314022efd17dab00eef17cbe3c..f95258492381b387fd71c7186b74b0f09a0aea66 100644
--- a/polkadot/xcm/xcm-builder/src/location_conversion.rs
+++ b/polkadot/xcm/xcm-builder/src/location_conversion.rs
@@ -15,8 +15,8 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::universal_exports::ensure_is_remote;
+use codec::{Compact, Decode, Encode};
 use frame_support::traits::Get;
-use parity_scale_codec::{Compact, Decode, Encode};
 use sp_io::hashing::blake2_256;
 use sp_runtime::traits::{AccountIdConversion, TrailingZeroInput, TryConvert};
 use sp_std::{marker::PhantomData, prelude::*};
@@ -460,7 +460,7 @@ impl<UniversalLocation, AccountId>
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use primitives::AccountId;
+	use polkadot_primitives::AccountId;
 	pub type ForeignChainAliasAccount<AccountId> =
 		HashedDescription<AccountId, LegacyDescribeForeignChainAccount>;
 
diff --git a/polkadot/xcm/xcm-builder/src/process_xcm_message.rs b/polkadot/xcm/xcm-builder/src/process_xcm_message.rs
index 7760274f6e2451f1b5f695884086a31cd36f3209..ef8c71fc2495175c3db20d89688fb983e180776d 100644
--- a/polkadot/xcm/xcm-builder/src/process_xcm_message.rs
+++ b/polkadot/xcm/xcm-builder/src/process_xcm_message.rs
@@ -16,8 +16,8 @@
 
 //! Implementation of `ProcessMessage` for an `ExecuteXcm` implementation.
 
+use codec::{Decode, FullCodec, MaxEncodedLen};
 use frame_support::traits::{ProcessMessage, ProcessMessageError};
-use parity_scale_codec::{Decode, FullCodec, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_std::{fmt::Debug, marker::PhantomData};
 use sp_weights::{Weight, WeightMeter};
@@ -118,13 +118,13 @@ impl<
 #[cfg(test)]
 mod tests {
 	use super::*;
+	use codec::Encode;
 	use frame_support::{
 		assert_err, assert_ok,
 		traits::{ProcessMessageError, ProcessMessageError::*},
 	};
-	use parity_scale_codec::Encode;
 	use polkadot_test_runtime::*;
-	use xcm::{v2, v3, VersionedXcm};
+	use xcm::{v3, v4, VersionedXcm};
 
 	const ORIGIN: Junction = Junction::OnlyChild;
 	/// The processor to use for tests.
@@ -134,8 +134,8 @@ mod tests {
 	#[test]
 	fn process_message_trivial_works() {
 		// ClearOrigin works.
-		assert!(process(v2_xcm(true)).unwrap());
 		assert!(process(v3_xcm(true)).unwrap());
+		assert!(process(v4_xcm(true)).unwrap());
 	}
 
 	#[test]
@@ -194,7 +194,7 @@ mod tests {
 
 	#[test]
 	fn process_message_overweight_fails() {
-		for msg in [v3_xcm(true), v3_xcm(false), v3_xcm(false), v2_xcm(false)] {
+		for msg in [v4_xcm(true), v4_xcm(false), v4_xcm(false), v3_xcm(false)] {
 			let msg = &msg.encode()[..];
 
 			// Errors if we stay below a weight limit of 1000.
@@ -216,7 +216,7 @@ mod tests {
 		}
 	}
 
-	fn v2_xcm(success: bool) -> VersionedXcm<RuntimeCall> {
+	fn v3_xcm(success: bool) -> VersionedXcm<RuntimeCall> {
 		let instr = if success {
 			v3::Instruction::<RuntimeCall>::ClearOrigin
 		} else {
@@ -225,13 +225,13 @@ mod tests {
 		VersionedXcm::V3(v3::Xcm::<RuntimeCall>(vec![instr]))
 	}
 
-	fn v3_xcm(success: bool) -> VersionedXcm<RuntimeCall> {
+	fn v4_xcm(success: bool) -> VersionedXcm<RuntimeCall> {
 		let instr = if success {
-			v2::Instruction::<RuntimeCall>::ClearOrigin
+			v4::Instruction::<RuntimeCall>::ClearOrigin
 		} else {
-			v2::Instruction::<RuntimeCall>::Trap(1)
+			v4::Instruction::<RuntimeCall>::Trap(1)
 		};
-		VersionedXcm::V2(v2::Xcm::<RuntimeCall>(vec![instr]))
+		VersionedXcm::V4(v4::Xcm::<RuntimeCall>(vec![instr]))
 	}
 
 	fn process(msg: VersionedXcm<RuntimeCall>) -> Result<bool, ProcessMessageError> {
diff --git a/polkadot/xcm/xcm-builder/src/routing.rs b/polkadot/xcm/xcm-builder/src/routing.rs
index 5c284aaf1475fce0fba7e5cfa042428ceff8268d..543aef97c34095b06c8f4ef840d55f8a9eb0d49b 100644
--- a/polkadot/xcm/xcm-builder/src/routing.rs
+++ b/polkadot/xcm/xcm-builder/src/routing.rs
@@ -16,8 +16,8 @@
 
 //! Various implementations for `SendXcm`.
 
+use codec::Encode;
 use frame_system::unique;
-use parity_scale_codec::Encode;
 use sp_std::{marker::PhantomData, result::Result, vec::Vec};
 use xcm::prelude::*;
 use xcm_executor::{traits::FeeReason, FeesMode};
diff --git a/polkadot/xcm/xcm-builder/src/tests/mock.rs b/polkadot/xcm/xcm-builder/src/tests/mock.rs
index f45650ec5404d14780a3bff3d9bbef0d72a57a25..f35c73bdb68572b326557b362d20ec888850691e 100644
--- a/polkadot/xcm/xcm-builder/src/tests/mock.rs
+++ b/polkadot/xcm/xcm-builder/src/tests/mock.rs
@@ -26,6 +26,7 @@ pub use crate::{
 	AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, FixedRateOfFungible,
 	FixedWeightBounds, TakeWeightCredit,
 };
+pub use codec::{Decode, Encode};
 use frame_support::traits::{ContainsPair, Everything};
 pub use frame_support::{
 	dispatch::{DispatchInfo, DispatchResultWithPostInfo, GetDispatchInfo, PostDispatchInfo},
@@ -33,7 +34,6 @@ pub use frame_support::{
 	sp_runtime::{traits::Dispatchable, DispatchError, DispatchErrorWithPostInfo},
 	traits::{Contains, Get, IsInVec},
 };
-pub use parity_scale_codec::{Decode, Encode};
 pub use sp_std::{
 	cell::{Cell, RefCell},
 	collections::{btree_map::BTreeMap, btree_set::BTreeSet},
diff --git a/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs b/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs
index 34b204b434d6e3e547a8b1f5ec48d787bb1fded5..10e9f4c6c0855a82dce07949cc53e2950971047b 100644
--- a/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs
+++ b/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs
@@ -25,8 +25,8 @@ use frame_support::{
 	traits::{ConstU32, Everything},
 };
 use frame_system::{EnsureRoot, EnsureSigned};
+use polkadot_primitives::{AccountIndex, BlakeTwo256, Signature};
 use polkadot_test_runtime::SignedExtra;
-use primitives::{AccountIndex, BlakeTwo256, Signature};
 use sp_runtime::{generic, traits::MaybeEquivalence, AccountId32, BuildStorage};
 use xcm_executor::{traits::ConvertLocation, XcmExecutor};
 
@@ -54,7 +54,6 @@ impl frame_system::Config for Test {
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<Balance>;
 	type AccountId = AccountId;
-	type BlockHashCount = ConstU32<256>;
 	type Lookup = sp_runtime::traits::IdentityLookup<AccountId>;
 }
 
diff --git a/polkadot/xcm/xcm-builder/src/universal_exports.rs b/polkadot/xcm/xcm-builder/src/universal_exports.rs
index 04ceb7e51688994b65701419020ffd5fd5bfdcd7..9820d535f7efdeab1097d8b305fb9f62a19a02f4 100644
--- a/polkadot/xcm/xcm-builder/src/universal_exports.rs
+++ b/polkadot/xcm/xcm-builder/src/universal_exports.rs
@@ -17,8 +17,8 @@
 //! Traits and utilities to help with origin mutation and bridging.
 
 use crate::InspectMessageQueues;
+use codec::{Decode, Encode};
 use frame_support::{ensure, traits::Get};
-use parity_scale_codec::{Decode, Encode};
 use sp_std::{convert::TryInto, marker::PhantomData, prelude::*};
 use xcm::prelude::*;
 use xcm_executor::traits::{validate_export, ExportXcm};
diff --git a/polkadot/xcm/xcm-builder/src/weight.rs b/polkadot/xcm/xcm-builder/src/weight.rs
index 6141b0142eed00fa8fb3a3e834b71fae51cffe86..1efa42ce95601d34b1f28e69b3c3ce59685ce9af 100644
--- a/polkadot/xcm/xcm-builder/src/weight.rs
+++ b/polkadot/xcm/xcm-builder/src/weight.rs
@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
+use codec::Decode;
 use frame_support::{
 	dispatch::GetDispatchInfo,
 	traits::{
@@ -25,7 +26,6 @@ use frame_support::{
 		WeightToFee as WeightToFeeT,
 	},
 };
-use parity_scale_codec::Decode;
 use sp_runtime::traits::{SaturatedConversion, Saturating, Zero};
 use sp_std::{marker::PhantomData, result::Result};
 use xcm::latest::{prelude::*, GetWeight, Weight};
diff --git a/polkadot/xcm/xcm-builder/tests/mock/mod.rs b/polkadot/xcm/xcm-builder/tests/mock/mod.rs
index 45bfba2355630e4e5b40d1bb9e00114c889811a1..582d596b78f1092397dc821dd9152f4295a350fd 100644
--- a/polkadot/xcm/xcm-builder/tests/mock/mod.rs
+++ b/polkadot/xcm/xcm-builder/tests/mock/mod.rs
@@ -14,13 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
+use codec::Encode;
 use frame_support::{
 	construct_runtime, derive_impl, parameter_types,
-	traits::{ConstU32, Everything, Nothing},
+	traits::{Everything, Nothing},
 	weights::Weight,
 };
 use frame_system::EnsureRoot;
-use parity_scale_codec::Encode;
 use primitive_types::H256;
 use sp_runtime::{traits::IdentityLookup, AccountId32, BuildStorage};
 use sp_std::cell::RefCell;
@@ -74,10 +74,6 @@ pub type TestXcmRouter = EnsureDecodableXcm<TestSendXcm>;
 pub const UNITS: Balance = 1_000_000_000_000;
 pub const CENTS: Balance = UNITS / 30_000;
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-}
-
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type RuntimeOrigin = RuntimeOrigin;
@@ -89,7 +85,6 @@ impl frame_system::Config for Runtime {
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type BlockWeights = ();
 	type BlockLength = ();
 	type Version = ();
@@ -107,24 +102,14 @@ impl frame_system::Config for Runtime {
 
 parameter_types! {
 	pub ExistentialDeposit: Balance = 1 * CENTS;
-	pub const MaxLocks: u32 = 50;
-	pub const MaxReserves: u32 = 50;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = MaxLocks;
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxReserves = MaxReserves;
 	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 impl shared::Config for Runtime {
diff --git a/polkadot/xcm/xcm-executor/Cargo.toml b/polkadot/xcm/xcm-executor/Cargo.toml
index 64b2d405b9068213d88582ec79ca2897d78dcc1f..3b30b4f13e2dd498945767a6e6d4c87a43333bc1 100644
--- a/polkadot/xcm/xcm-executor/Cargo.toml
+++ b/polkadot/xcm/xcm-executor/Cargo.toml
@@ -12,7 +12,7 @@ workspace = true
 [dependencies]
 impl-trait-for-tuples = "0.2.2"
 environmental = { version = "1.1.4", default-features = false }
-parity-scale-codec = { version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] }
 xcm = { package = "staging-xcm", path = "..", default-features = false }
 sp-std = { path = "../../../substrate/primitives/std", default-features = false }
@@ -33,11 +33,11 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 ]
 std = [
+	"codec/std",
 	"environmental/std",
 	"frame-benchmarking/std",
 	"frame-support/std",
 	"log/std",
-	"parity-scale-codec/std",
 	"scale-info/std",
 	"sp-arithmetic/std",
 	"sp-core/std",
diff --git a/polkadot/xcm/xcm-executor/src/lib.rs b/polkadot/xcm/xcm-executor/src/lib.rs
index e0b8a8a9c73e4aba1274993d23ac27a77c2a6c78..da9de93ca0f6f1a94f388d9078e95305e5c210e9 100644
--- a/polkadot/xcm/xcm-executor/src/lib.rs
+++ b/polkadot/xcm/xcm-executor/src/lib.rs
@@ -16,12 +16,12 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use codec::{Decode, Encode};
 use frame_support::{
 	dispatch::GetDispatchInfo,
 	ensure,
 	traits::{Contains, ContainsPair, Defensive, Get, PalletsInfoAccess},
 };
-use parity_scale_codec::{Decode, Encode};
 use sp_core::defer;
 use sp_io::hashing::blake2_128;
 use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
diff --git a/polkadot/xcm/xcm-executor/src/traits/on_response.rs b/polkadot/xcm/xcm-executor/src/traits/on_response.rs
index 1049bacdca5f9eee964cf810835c69b7ba1ba1ea..5d2412d6137552db68d30cf61b25b10521afd966 100644
--- a/polkadot/xcm/xcm-executor/src/traits/on_response.rs
+++ b/polkadot/xcm/xcm-executor/src/traits/on_response.rs
@@ -15,9 +15,9 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::{Junctions::Here, Xcm};
+use codec::{Decode, Encode};
 use core::result;
 use frame_support::{pallet_prelude::Get, parameter_types};
-use parity_scale_codec::{Decode, Encode};
 use sp_arithmetic::traits::Zero;
 use sp_std::fmt::Debug;
 use xcm::latest::{
diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/src/dry_run.rs b/polkadot/xcm/xcm-fee-payment-runtime-api/src/dry_run.rs
index 62a422d6efeb0928e4f279798382dd139d95ee0a..9828acab402300a55abf2ece820cf8871c76a858 100644
--- a/polkadot/xcm/xcm-fee-payment-runtime-api/src/dry_run.rs
+++ b/polkadot/xcm/xcm-fee-payment-runtime-api/src/dry_run.rs
@@ -19,16 +19,15 @@
 //! that need to be paid.
 
 use codec::{Decode, Encode};
-use frame_support::pallet_prelude::{DispatchResult, TypeInfo};
-use sp_runtime::traits::Block as BlockT;
+use frame_support::pallet_prelude::{DispatchResultWithPostInfo, TypeInfo};
 use sp_std::vec::Vec;
 use xcm::prelude::*;
 
 /// Effects of dry-running an extrinsic.
 #[derive(Encode, Decode, Debug, TypeInfo)]
-pub struct ExtrinsicDryRunEffects<Event> {
+pub struct CallDryRunEffects<Event> {
 	/// The result of executing the extrinsic.
-	pub execution_result: DispatchResult,
+	pub execution_result: DispatchResultWithPostInfo,
 	/// The list of events fired by the extrinsic.
 	pub emitted_events: Vec<Event>,
 	/// The local XCM that was attempted to be executed, if any.
@@ -55,12 +54,12 @@ sp_api::decl_runtime_apis! {
 	/// If there's local execution, the location will be "Here".
 	/// This vector can be used to calculate both execution and delivery fees.
 	///
-	/// Extrinsics or XCMs might fail when executed, this doesn't mean the result of these calls will be an `Err`.
+	/// Calls or XCMs might fail when executed, this doesn't mean the result of these calls will be an `Err`.
 	/// In those cases, there might still be a valid result, with the execution error inside it.
 	/// The only reasons why these calls might return an error are listed in the [`Error`] enum.
-	pub trait XcmDryRunApi<Call, Event: Decode> {
-		/// Dry run extrinsic.
-		fn dry_run_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> Result<ExtrinsicDryRunEffects<Event>, Error>;
+	pub trait DryRunApi<Call: Encode, Event: Decode, OriginCaller: Encode> {
+		/// Dry run call.
+		fn dry_run_call(origin: OriginCaller, call: Call) -> Result<CallDryRunEffects<Event>, Error>;
 
 		/// Dry run XCM program
 		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<Call>) -> Result<XcmDryRunEffects<Event>, Error>;
@@ -76,8 +75,4 @@ pub enum Error {
 	/// Converting a versioned data structure from one version to another failed.
 	#[codec(index = 1)]
 	VersionedConversionFailed,
-
-	/// Extrinsic was invalid.
-	#[codec(index = 2)]
-	InvalidExtrinsic,
 }
diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/fee_estimation.rs b/polkadot/xcm/xcm-fee-payment-runtime-api/tests/fee_estimation.rs
index 7a9bfa4a7968129a13395f2520b6ca1a7b14ff69..33611c8a471c03a34c125a921b24a51880dfbb3f 100644
--- a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/fee_estimation.rs
+++ b/polkadot/xcm/xcm-fee-payment-runtime-api/tests/fee_estimation.rs
@@ -16,19 +16,17 @@
 
 //! Tests for using both the XCM fee payment API and the dry-run API.
 
-use frame_support::{
-	dispatch::DispatchInfo,
-	pallet_prelude::{DispatchClass, Pays},
-};
+use frame_system::RawOrigin;
 use sp_api::ProvideRuntimeApi;
 use sp_runtime::testing::H256;
 use xcm::prelude::*;
-use xcm_fee_payment_runtime_api::{dry_run::XcmDryRunApi, fees::XcmPaymentApi};
+use xcm_fee_payment_runtime_api::{dry_run::DryRunApi, fees::XcmPaymentApi};
 
 mod mock;
 use mock::{
-	extra, fake_message_hash, new_test_ext_with_balances, new_test_ext_with_balances_and_assets,
-	DeliveryFees, ExistentialDeposit, HereLocation, RuntimeCall, RuntimeEvent, TestClient, TestXt,
+	fake_message_hash, new_test_ext_with_balances, new_test_ext_with_balances_and_assets,
+	DeliveryFees, ExistentialDeposit, HereLocation, OriginCaller, RuntimeCall, RuntimeEvent,
+	TestClient,
 };
 
 // Scenario: User `1` in the local chain (id 2000) wants to transfer assets to account `[0u8; 32]`
@@ -50,26 +48,26 @@ fn fee_estimation_for_teleport() {
 	new_test_ext_with_balances_and_assets(balances, assets).execute_with(|| {
 		let client = TestClient;
 		let runtime_api = client.runtime_api();
-		let extrinsic = TestXt::new(
-			RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets {
-				dest: Box::new(VersionedLocation::V4((Parent, Parachain(1000)).into())),
-				beneficiary: Box::new(VersionedLocation::V4(
-					AccountId32 { id: [0u8; 32], network: None }.into(),
-				)),
-				assets: Box::new(VersionedAssets::V4(
-					vec![(Here, 100u128).into(), (Parent, 20u128).into()].into(),
-				)),
-				fee_asset_item: 1, // Fees are paid with the RelayToken
-				weight_limit: Unlimited,
-			}),
-			Some((who, extra())),
-		);
+		let call = RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets {
+			dest: Box::new(VersionedLocation::from((Parent, Parachain(1000)))),
+			beneficiary: Box::new(VersionedLocation::from(AccountId32 {
+				id: [0u8; 32],
+				network: None,
+			})),
+			assets: Box::new(VersionedAssets::from(vec![
+				(Here, 100u128).into(),
+				(Parent, 20u128).into(),
+			])),
+			fee_asset_item: 1, // Fees are paid with the RelayToken
+			weight_limit: Unlimited,
+		});
+		let origin = OriginCaller::system(RawOrigin::Signed(who));
 		let dry_run_effects =
-			runtime_api.dry_run_extrinsic(H256::zero(), extrinsic).unwrap().unwrap();
+			runtime_api.dry_run_call(H256::zero(), origin, call).unwrap().unwrap();
 
 		assert_eq!(
 			dry_run_effects.local_xcm,
-			Some(VersionedXcm::V4(
+			Some(VersionedXcm::from(
 				Xcm::builder_unsafe()
 					.withdraw_asset((Parent, 20u128))
 					.burn_asset((Parent, 20u128))
@@ -89,8 +87,8 @@ fn fee_estimation_for_teleport() {
 		assert_eq!(
 			dry_run_effects.forwarded_xcms,
 			vec![(
-				VersionedLocation::V4(send_destination.clone()),
-				vec![VersionedXcm::V4(send_message.clone())],
+				VersionedLocation::from(send_destination.clone()),
+				vec![VersionedXcm::from(send_message.clone())],
 			),],
 		);
 
@@ -128,14 +126,6 @@ fn fee_estimation_for_teleport() {
 					message: send_message.clone(),
 					message_id: fake_message_hash(&send_message),
 				}),
-				RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
-					dispatch_info: DispatchInfo {
-						weight: Weight::from_parts(107074070, 0), /* Will break if weights get
-						                                           * updated. */
-						class: DispatchClass::Normal,
-						pays_fee: Pays::Yes,
-					}
-				}),
 			]
 		);
 
@@ -153,7 +143,7 @@ fn fee_estimation_for_teleport() {
 			.query_weight_to_asset_fee(
 				H256::zero(),
 				weight,
-				VersionedAssetId::V4(HereLocation::get().into()),
+				VersionedAssetId::from(AssetId(HereLocation::get())),
 			)
 			.unwrap()
 			.unwrap();
@@ -168,7 +158,7 @@ fn fee_estimation_for_teleport() {
 			.query_delivery_fees(H256::zero(), destination.clone(), remote_message.clone())
 			.unwrap()
 			.unwrap();
-		assert_eq!(delivery_fees, VersionedAssets::V4((Here, 20u128).into()));
+		assert_eq!(delivery_fees, VersionedAssets::from((Here, 20u128)));
 
 		// This would have to be the runtime API of the destination,
 		// which we have the location for.
@@ -182,7 +172,7 @@ fn fee_estimation_for_teleport() {
 			.query_weight_to_asset_fee(
 				H256::zero(),
 				remote_execution_weight,
-				VersionedAssetId::V4(HereLocation::get().into()),
+				VersionedAssetId::from(AssetId(HereLocation::get())),
 			)
 			.unwrap()
 			.unwrap();
@@ -214,24 +204,23 @@ fn dry_run_reserve_asset_transfer() {
 	new_test_ext_with_balances_and_assets(balances, assets).execute_with(|| {
 		let client = TestClient;
 		let runtime_api = client.runtime_api();
-		let extrinsic = TestXt::new(
-			RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets {
-				dest: Box::new(VersionedLocation::V4((Parent, Parachain(1000)).into())),
-				beneficiary: Box::new(VersionedLocation::V4(
-					AccountId32 { id: [0u8; 32], network: None }.into(),
-				)),
-				assets: Box::new(VersionedAssets::V4((Parent, 100u128).into())),
-				fee_asset_item: 0,
-				weight_limit: Unlimited,
-			}),
-			Some((who, extra())),
-		);
+		let call = RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets {
+			dest: Box::new(VersionedLocation::from((Parent, Parachain(1000)))),
+			beneficiary: Box::new(VersionedLocation::from(AccountId32 {
+				id: [0u8; 32],
+				network: None,
+			})),
+			assets: Box::new(VersionedAssets::from((Parent, 100u128))),
+			fee_asset_item: 0,
+			weight_limit: Unlimited,
+		});
+		let origin = OriginCaller::system(RawOrigin::Signed(who));
 		let dry_run_effects =
-			runtime_api.dry_run_extrinsic(H256::zero(), extrinsic).unwrap().unwrap();
+			runtime_api.dry_run_call(H256::zero(), origin, call).unwrap().unwrap();
 
 		assert_eq!(
 			dry_run_effects.local_xcm,
-			Some(VersionedXcm::V4(
+			Some(VersionedXcm::from(
 				Xcm::builder_unsafe()
 					.withdraw_asset((Parent, 100u128))
 					.burn_asset((Parent, 100u128))
@@ -251,8 +240,8 @@ fn dry_run_reserve_asset_transfer() {
 		assert_eq!(
 			dry_run_effects.forwarded_xcms,
 			vec![(
-				VersionedLocation::V4(send_destination.clone()),
-				vec![VersionedXcm::V4(send_message.clone())],
+				VersionedLocation::from(send_destination.clone()),
+				vec![VersionedXcm::from(send_message.clone())],
 			),],
 		);
 
@@ -278,14 +267,6 @@ fn dry_run_reserve_asset_transfer() {
 					message: send_message.clone(),
 					message_id: fake_message_hash(&send_message),
 				}),
-				RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
-					dispatch_info: DispatchInfo {
-						weight: Weight::from_parts(107074066, 0), /* Will break if weights get
-						                                           * updated. */
-						class: DispatchClass::Normal,
-						pays_fee: Pays::Yes,
-					}
-				}),
 			]
 		);
 	});
@@ -310,11 +291,15 @@ fn dry_run_xcm() {
 	let client = TestClient;
 	let runtime_api = client.runtime_api();
 	let xcm_weight = runtime_api
-		.query_xcm_weight(H256::zero(), VersionedXcm::V4(xcm_to_weigh.clone().into()))
+		.query_xcm_weight(H256::zero(), VersionedXcm::from(xcm_to_weigh.clone().into()))
 		.unwrap()
 		.unwrap();
 	let execution_fees = runtime_api
-		.query_weight_to_asset_fee(H256::zero(), xcm_weight, VersionedAssetId::V4(Here.into()))
+		.query_weight_to_asset_fee(
+			H256::zero(),
+			xcm_weight,
+			VersionedAssetId::from(AssetId(Here.into())),
+		)
 		.unwrap()
 		.unwrap();
 	let xcm = Xcm::<RuntimeCall>::builder_unsafe()
@@ -331,16 +316,16 @@ fn dry_run_xcm() {
 		let dry_run_effects = runtime_api
 			.dry_run_xcm(
 				H256::zero(),
-				VersionedLocation::V4(AccountIndex64 { index: 1, network: None }.into()),
-				VersionedXcm::V4(xcm),
+				VersionedLocation::from([AccountIndex64 { index: 1, network: None }]),
+				VersionedXcm::from(xcm),
 			)
 			.unwrap()
 			.unwrap();
 		assert_eq!(
 			dry_run_effects.forwarded_xcms,
 			vec![(
-				VersionedLocation::V4((Parent, Parachain(2100)).into()),
-				vec![VersionedXcm::V4(
+				VersionedLocation::from((Parent, Parachain(2100))),
+				vec![VersionedXcm::from(
 					Xcm::<()>::builder_unsafe()
 						.reserve_asset_deposited((
 							(Parent, Parachain(2000)),
diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/mock.rs b/polkadot/xcm/xcm-fee-payment-runtime-api/tests/mock.rs
index d7b18d90a501815018fde21e25481872e33753a6..aa6c1422b608c955fc74934811f4f136212507cb 100644
--- a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/mock.rs
+++ b/polkadot/xcm/xcm-fee-payment-runtime-api/tests/mock.rs
@@ -29,7 +29,7 @@ use frame_support::{
 use frame_system::{EnsureRoot, RawOrigin as SystemRawOrigin};
 use pallet_xcm::TestWeightInfo;
 use sp_runtime::{
-	traits::{Block as BlockT, Get, IdentityLookup, MaybeEquivalence, TryConvert},
+	traits::{Dispatchable, Get, IdentityLookup, MaybeEquivalence, TryConvert},
 	BuildStorage, SaturatedConversion,
 };
 use sp_std::{cell::RefCell, marker::PhantomData};
@@ -45,7 +45,7 @@ use xcm_executor::{
 };
 
 use xcm_fee_payment_runtime_api::{
-	dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunApi, XcmDryRunEffects},
+	dry_run::{CallDryRunEffects, DryRunApi, Error as XcmDryRunApiError, XcmDryRunEffects},
 	fees::{Error as XcmPaymentApiError, XcmPaymentApi},
 };
 
@@ -58,30 +58,13 @@ construct_runtime! {
 	}
 }
 
-pub type SignedExtra = (
-	// frame_system::CheckEra<TestRuntime>,
-	// frame_system::CheckNonce<TestRuntime>,
-	frame_system::CheckWeight<TestRuntime>,
-);
+pub type SignedExtra = (frame_system::CheckWeight<TestRuntime>,);
 pub type TestXt = sp_runtime::testing::TestXt<RuntimeCall, SignedExtra>;
 type Block = sp_runtime::testing::Block<TestXt>;
 type Balance = u128;
 type AssetIdForAssetsPallet = u32;
 type AccountId = u64;
 
-pub fn extra() -> SignedExtra {
-	(frame_system::CheckWeight::new(),)
-}
-
-type Executive = frame_executive::Executive<
-	TestRuntime,
-	Block,
-	frame_system::ChainContext<TestRuntime>,
-	TestRuntime,
-	AllPalletsWithSystem,
-	(),
->;
-
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for TestRuntime {
 	type Block = Block;
@@ -429,8 +412,11 @@ impl sp_api::ProvideRuntimeApi<Block> for TestClient {
 sp_api::mock_impl_runtime_apis! {
 	impl XcmPaymentApi<Block> for RuntimeApi {
 		fn query_acceptable_payment_assets(xcm_version: XcmVersion) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
-			if xcm_version != 4 { return Err(XcmPaymentApiError::UnhandledXcmVersion) };
-			Ok(vec![VersionedAssetId::V4(HereLocation::get().into())])
+			Ok(vec![
+				VersionedAssetId::from(AssetId(HereLocation::get()))
+					.into_version(xcm_version)
+					.map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?
+			])
 		}
 
 		fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
@@ -438,14 +424,25 @@ sp_api::mock_impl_runtime_apis! {
 		}
 
 		fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
-			let local_asset = VersionedAssetId::V4(HereLocation::get().into());
-			let asset = asset
-				.into_version(4)
-				.map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?;
-
-			if asset != local_asset { return Err(XcmPaymentApiError::AssetNotFound); }
-
-			Ok(WeightToFee::weight_to_fee(&weight))
+			match asset.try_as::<AssetId>() {
+				Ok(asset_id) if asset_id.0 == HereLocation::get() => {
+					Ok(WeightToFee::weight_to_fee(&weight))
+				},
+				Ok(asset_id) => {
+					log::trace!(
+						target: "xcm::XcmPaymentApi::query_weight_to_asset_fee",
+						"query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"
+					);
+					Err(XcmPaymentApiError::AssetNotFound)
+				},
+				Err(_) => {
+					log::trace!(
+						target: "xcm::XcmPaymentApi::query_weight_to_asset_fee",
+						"query_weight_to_asset_fee - failed to convert asset: {asset:?}!"
+					);
+					Err(XcmPaymentApiError::VersionedConversionFailed)
+				}
+			}
 		}
 
 		fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
@@ -453,30 +450,22 @@ sp_api::mock_impl_runtime_apis! {
 		}
 	}
 
-	impl XcmDryRunApi<Block, RuntimeCall, RuntimeEvent> for RuntimeApi {
-		fn dry_run_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> Result<ExtrinsicDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
+	impl DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for RuntimeApi {
+		fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
 			use xcm_executor::RecordXcm;
-			// We want to record the XCM that's executed, so we can return it.
 			pallet_xcm::Pallet::<TestRuntime>::set_record_xcm(true);
-			let result = Executive::apply_extrinsic(extrinsic).map_err(|error| {
-				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_extrinsic",
-					"Applying extrinsic failed with error {:?}",
-					error,
-				);
-				XcmDryRunApiError::InvalidExtrinsic
-			})?;
-			// Nothing gets committed to storage in runtime APIs, so there's no harm in leaving the flag as true.
+			let result = call.dispatch(origin.into());
+			pallet_xcm::Pallet::<TestRuntime>::set_record_xcm(false);
 			let local_xcm = pallet_xcm::Pallet::<TestRuntime>::recorded_xcm();
 			let forwarded_xcms = sent_xcm()
-				.into_iter()
-				.map(|(location, message)| (
-					VersionedLocation::V4(location),
-					vec![VersionedXcm::V4(message)],
-				)).collect();
-			let events: Vec<RuntimeEvent> = System::events().iter().map(|record| record.event.clone()).collect();
-			Ok(ExtrinsicDryRunEffects {
-				local_xcm: local_xcm.map(VersionedXcm::<()>::V4),
+							   .into_iter()
+							   .map(|(location, message)| (
+									   VersionedLocation::from(location),
+									   vec![VersionedXcm::from(message)],
+							   )).collect();
+			let events: Vec<RuntimeEvent> = System::read_events_no_consensus().map(|record| record.event.clone()).collect();
+			Ok(CallDryRunEffects {
+				local_xcm: local_xcm.map(VersionedXcm::<()>::from),
 				forwarded_xcms,
 				emitted_events: events,
 				execution_result: result,
@@ -486,7 +475,7 @@ sp_api::mock_impl_runtime_apis! {
 		fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
 			let origin_location: Location = origin_location.try_into().map_err(|error| {
 				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
+					target: "xcm::DryRunApi::dry_run_xcm",
 					"Location version conversion failed with error: {:?}",
 					error,
 				);
@@ -494,7 +483,7 @@ sp_api::mock_impl_runtime_apis! {
 			})?;
 			let xcm: Xcm<RuntimeCall> = xcm.try_into().map_err(|error| {
 				log::error!(
-					target: "xcm::XcmDryRunApi::dry_run_xcm",
+					target: "xcm::DryRunApi::dry_run_xcm",
 					"Xcm version conversion failed with error {:?}",
 					error,
 				);
@@ -511,8 +500,8 @@ sp_api::mock_impl_runtime_apis! {
 			let forwarded_xcms = sent_xcm()
 				.into_iter()
 				.map(|(location, message)| (
-					VersionedLocation::V4(location),
-					vec![VersionedXcm::V4(message)],
+					VersionedLocation::from(location),
+					vec![VersionedXcm::from(message)],
 				)).collect();
 			let events: Vec<RuntimeEvent> = System::events().iter().map(|record| record.event.clone()).collect();
 			Ok(XcmDryRunEffects {
diff --git a/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs b/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs
index 502bcca2d44270263a45eeaf305b924d8b37c509..11435868d4682ae4229b7939f2a8685316c7e296 100644
--- a/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs
+++ b/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs
@@ -24,7 +24,6 @@ use frame_support::{
 };
 
 use frame_system::EnsureRoot;
-use sp_core::ConstU32;
 use sp_runtime::{
 	generic,
 	traits::{AccountIdLookup, BlakeTwo256, Hash, IdentifyAccount, Verify},
@@ -73,24 +72,13 @@ impl frame_system::Config for Runtime {
 
 parameter_types! {
 	pub ExistentialDeposit: Balance = 1;
-	pub const MaxLocks: u32 = 50;
-	pub const MaxReserves: u32 = 50;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = MaxLocks;
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxReserves = MaxReserves;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 parameter_types! {
diff --git a/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs b/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs
index 4740aee83d870a0e260512ac15a982c515a1e803..459d2640b6d908b14e0964aa2e2a697f95c7dbd3 100644
--- a/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs
+++ b/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs
@@ -72,24 +72,13 @@ impl frame_system::Config for Runtime {
 
 parameter_types! {
 	pub ExistentialDeposit: Balance = 1;
-	pub const MaxLocks: u32 = 50;
-	pub const MaxReserves: u32 = 50;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = MaxLocks;
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxReserves = MaxReserves;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 impl shared::Config for Runtime {
diff --git a/polkadot/zombienet_tests/assign-core.js b/polkadot/zombienet_tests/assign-core.js
new file mode 100644
index 0000000000000000000000000000000000000000..5ddb86930f5a0a04380e1e4cbef5c96f81db4fe0
--- /dev/null
+++ b/polkadot/zombienet_tests/assign-core.js
@@ -0,0 +1,48 @@
+async function run(nodeName, networkInfo, args) {
+  const wsUri = networkInfo.nodesByName[nodeName].wsUri;
+  const api = await zombie.connect(wsUri);
+
+  let core = Number(args[0]);
+
+  let assignments = [];
+
+  for (let i = 1; i < args.length; i += 2) {
+    let [para, parts] = [args[i], args[i + 1]];
+
+    console.log(`Assigning para ${para} to core ${core}`);
+
+    assignments.push(
+      [{ task: para }, parts]
+    );
+  }
+  await zombie.util.cryptoWaitReady();
+
+  // account to submit tx
+  const keyring = new zombie.Keyring({ type: "sr25519" });
+  const alice = keyring.addFromUri("//Alice");
+
+  await new Promise(async (resolve, reject) => {
+    const unsub = await api.tx.sudo
+      .sudo(api.tx.coretime.assignCore(core, 0, assignments, null))
+      .signAndSend(alice, ({ status, isError }) => {
+        if (status.isInBlock) {
+          console.log(
+            `Transaction included at blockhash ${status.asInBlock}`,
+          );
+        } else if (status.isFinalized) {
+          console.log(
+            `Transaction finalized at blockHash ${status.asFinalized}`,
+          );
+          unsub();
+          return resolve();
+        } else if (isError) {
+          console.log(`Transaction error`);
+          reject(`Transaction error`);
+        }
+      });
+  });
+
+  return 0;
+}
+
+module.exports = { run };
diff --git a/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl b/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl
index d624cbaf9df6a62448db2cef637e6d29a0d419b5..d47ef8f415f7ac9ca94b825de23580ab6131f013 100644
--- a/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl
+++ b/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl
@@ -11,8 +11,8 @@ elastic-validator-4: reports node_roles is 4
 
 
 # Register 2 extra cores to this some-parachain.
-elastic-validator-0: js-script ./assign-core.js with "2000,0" return is 0 within 600 seconds
-elastic-validator-0: js-script ./assign-core.js with "2000,1" return is 0 within 600 seconds
+elastic-validator-0: js-script ./assign-core.js with "0,2000,57600" return is 0 within 600 seconds
+elastic-validator-0: js-script ./assign-core.js with "1,2000,57600" return is 0 within 600 seconds
 
 # Wait for 20 relay chain blocks 
 elastic-validator-0: reports substrate_block_height{status="best"} is at least 20 within 600 seconds
diff --git a/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl b/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl
index 900a3befbc6fc56f5200e9399f5fe5b21eb7af40..7ba896e1c90397642ff0736477f9c793bdb746ec 100644
--- a/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl
+++ b/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl
@@ -11,8 +11,8 @@ validator: reports substrate_block_height{status="finalized"} is at least 10 wit
 validator: parachain 2000 block height is at least 10 within 200 seconds
 
 # Register the second core assigned to this parachain.
-alice: js-script ./assign-core.js with "2000,0" return is 0 within 600 seconds
-alice: js-script ./assign-core.js with "2000,1" return is 0 within 600 seconds
+alice: js-script ./assign-core.js with "0,2000,57600" return is 0 within 600 seconds
+alice: js-script ./assign-core.js with "0,2000,57600" return is 0 within 600 seconds
 
 validator: reports substrate_block_height{status="finalized"} is at least 35 within 100 seconds
 
diff --git a/polkadot/zombienet_tests/elastic_scaling/assign-core.js b/polkadot/zombienet_tests/elastic_scaling/assign-core.js
deleted file mode 100644
index add63b6d30859d2c50a38a73e33ec75ed3669433..0000000000000000000000000000000000000000
--- a/polkadot/zombienet_tests/elastic_scaling/assign-core.js
+++ /dev/null
@@ -1,39 +0,0 @@
-async function run(nodeName, networkInfo, args) {
-  const wsUri = networkInfo.nodesByName[nodeName].wsUri;
-  const api = await zombie.connect(wsUri);
-
-  let para = Number(args[0]);
-  let core = Number(args[1]);
-  console.log(`Assigning para ${para} to core ${core}`);
-
-  await zombie.util.cryptoWaitReady();
-
-  // account to submit tx
-  const keyring = new zombie.Keyring({ type: "sr25519" });
-  const alice = keyring.addFromUri("//Alice");
-
-  await new Promise(async (resolve, reject) => {
-    const unsub = await api.tx.sudo
-      .sudo(api.tx.coretime.assignCore(core, 0, [[{ task: para }, 57600]], null))
-      .signAndSend(alice, ({ status, isError }) => {
-        if (status.isInBlock) {
-          console.log(
-            `Transaction included at blockhash ${status.asInBlock}`,
-          );
-        } else if (status.isFinalized) {
-          console.log(
-            `Transaction finalized at blockHash ${status.asFinalized}`,
-          );
-          unsub();
-          return resolve();
-        } else if (isError) {
-          console.log(`Transaction error`);
-          reject(`Transaction error`);
-        }
-      });
-  });
-
-  return 0;
-}
-
-module.exports = { run };
diff --git a/polkadot/zombienet_tests/elastic_scaling/assign-core.js b/polkadot/zombienet_tests/elastic_scaling/assign-core.js
new file mode 120000
index 0000000000000000000000000000000000000000..eeb6402c06f5e52cedf150f924d6791beb1d9867
--- /dev/null
+++ b/polkadot/zombienet_tests/elastic_scaling/assign-core.js
@@ -0,0 +1 @@
+../assign-core.js
\ No newline at end of file
diff --git a/polkadot/zombienet_tests/functional/0013-enable-node-feature.js b/polkadot/zombienet_tests/functional/0013-enable-node-feature.js
new file mode 100644
index 0000000000000000000000000000000000000000..5fe2e38dad7d4f0ba340e48617445ae7f907fce5
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0013-enable-node-feature.js
@@ -0,0 +1,35 @@
+async function run(nodeName, networkInfo, index) {
+  const { wsUri, userDefinedTypes } = networkInfo.nodesByName[nodeName];
+  const api = await zombie.connect(wsUri, userDefinedTypes);
+
+  await zombie.util.cryptoWaitReady();
+
+  // account to submit tx
+  const keyring = new zombie.Keyring({ type: "sr25519" });
+  const alice = keyring.addFromUri("//Alice");
+
+  await new Promise(async (resolve, reject) => {
+    const unsub = await api.tx.sudo
+      .sudo(api.tx.configuration.setNodeFeature(Number(index), true))
+      .signAndSend(alice, ({ status, isError }) => {
+        if (status.isInBlock) {
+          console.log(
+            `Transaction included at blockhash ${status.asInBlock}`,
+          );
+        } else if (status.isFinalized) {
+          console.log(
+            `Transaction finalized at blockHash ${status.asFinalized}`,
+          );
+          unsub();
+          return resolve();
+        } else if (isError) {
+          console.log(`Transaction error`);
+          reject(`Transaction error`);
+        }
+      });
+  });
+
+  return 0;
+}
+
+module.exports = { run };
diff --git a/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.toml b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.toml
new file mode 100644
index 0000000000000000000000000000000000000000..67925a3d3a7c64201cede004b20fc52dfbae181c
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.toml
@@ -0,0 +1,46 @@
+[settings]
+timeout = 1000
+bootnode = true
+
+[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
+  max_validators_per_core = 2
+
+[relaychain.genesis.runtimeGenesis.patch.configuration.config]
+  needed_approvals = 4
+
+[relaychain]
+default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
+chain = "rococo-local"
+default_command = "polkadot"
+
+[relaychain.default_resources]
+limits = { memory = "4G", cpu = "2" }
+requests = { memory = "2G", cpu = "1" }
+
+  [[relaychain.nodes]]
+  name = "alice"
+  validator = "true"
+
+  [[relaychain.node_groups]]
+  name = "validator"
+  count = 3
+  args = ["-lparachain=debug,parachain::availability-recovery=trace,parachain::availability-distribution=trace"]
+
+{% for id in range(2000,2002) %}
+[[parachains]]
+id = {{id}}
+addToGenesis = true
+cumulus_based = true
+chain = "glutton-westend-local-{{id}}"
+    [parachains.genesis.runtimeGenesis.patch.glutton]
+    compute = "50000000"
+    storage = "2500000000"
+    trashDataCount = 5120
+
+    [parachains.collator]
+    name = "collator"
+    image = "{{CUMULUS_IMAGE}}"
+    command = "polkadot-parachain"
+    args = ["-lparachain=debug"]
+
+{% endfor %}
diff --git a/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.zndsl b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.zndsl
new file mode 100644
index 0000000000000000000000000000000000000000..e9e5a429e2a2c4913a61e30fc45114f65a939300
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.zndsl
@@ -0,0 +1,43 @@
+Description: Systematic chunk recovery is used if the chunk mapping feature is enabled.
+Network: ./0013-systematic-chunk-recovery.toml
+Creds: config
+
+# Check authority status.
+alice: reports node_roles is 4
+validator: reports node_roles is 4
+
+# Ensure parachains are registered.
+validator: parachain 2000 is registered within 60 seconds
+validator: parachain 2001 is registered within 60 seconds
+
+# Ensure parachains made progress and approval checking works.
+validator: parachain 2000 block height is at least 15 within 600 seconds
+validator: parachain 2001 block height is at least 15 within 600 seconds
+
+validator: reports substrate_block_height{status="finalized"} is at least 30 within 400 seconds
+
+validator: reports polkadot_parachain_approval_checking_finality_lag < 3
+
+validator: reports polkadot_parachain_approvals_no_shows_total < 3 within 100 seconds
+
+# Ensure we used regular chunk recovery and that there are no failed recoveries.
+validator: count of log lines containing "Data recovery from chunks complete" is at least 10 within 300 seconds
+validator: count of log lines containing "Data recovery from systematic chunks complete" is 0 within 10 seconds
+validator: count of log lines containing "Data recovery from systematic chunks is not possible" is 0 within 10 seconds
+validator: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds
+validator: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds
+
+# Enable the chunk mapping feature
+alice: js-script ./0013-enable-node-feature.js with "2" return is 0 within 600 seconds
+
+validator: reports substrate_block_height{status="finalized"} is at least 60 within 400 seconds
+
+validator: reports polkadot_parachain_approval_checking_finality_lag < 3
+
+validator: reports polkadot_parachain_approvals_no_shows_total < 3 within 100 seconds
+
+# Ensure we used systematic chunk recovery and that there are no failed recoveries.
+validator: count of log lines containing "Data recovery from systematic chunks complete" is at least 10 within 300 seconds
+validator: count of log lines containing "Data recovery from systematic chunks is not possible" is 0 within 10 seconds
+validator: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds
+validator: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds
diff --git a/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.toml b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.toml
new file mode 100644
index 0000000000000000000000000000000000000000..881abab64fd07b8495189982119b3f985332b8a7
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.toml
@@ -0,0 +1,48 @@
+[settings]
+timeout = 1000
+bootnode = true
+
+[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
+  max_validators_per_core = 2
+
+[relaychain.genesis.runtimeGenesis.patch.configuration.config]
+  needed_approvals = 4
+
+[relaychain]
+default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
+chain = "rococo-local"
+default_command = "polkadot"
+
+[relaychain.default_resources]
+limits = { memory = "4G", cpu = "2" }
+requests = { memory = "2G", cpu = "1" }
+
+  [[relaychain.node_groups]]
+  # Use an image that doesn't speak /req_chunk/2 protocol.
+  image = "{{POLKADOT_IMAGE}}:master-bde0bbe5"
+  name = "old"
+  count = 2
+  args = ["-lparachain=debug,parachain::availability-recovery=trace,parachain::availability-distribution=trace"]
+
+  [[relaychain.node_groups]]
+  name = "new"
+  count = 2
+  args = ["-lparachain=debug,parachain::availability-recovery=trace,parachain::availability-distribution=trace,sub-libp2p=trace"]
+
+{% for id in range(2000,2002) %}
+[[parachains]]
+id = {{id}}
+addToGenesis = true
+cumulus_based = true
+chain = "glutton-westend-local-{{id}}"
+    [parachains.genesis.runtimeGenesis.patch.glutton]
+    compute = "50000000"
+    storage = "2500000000"
+    trashDataCount = 5120
+
+    [parachains.collator]
+    name = "collator"
+    image = "{{CUMULUS_IMAGE}}"
+    args = ["-lparachain=debug"]
+
+{% endfor %}
diff --git a/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.zndsl b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.zndsl
new file mode 100644
index 0000000000000000000000000000000000000000..2ac5012db668d102b1078b4bf694e98b6c0ff302
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.zndsl
@@ -0,0 +1,53 @@
+Description: Validators preserve backwards compatibility with peers speaking an older version of the /req_chunk protocol
+Network: ./0014-chunk-fetching-network-compatibility.toml
+Creds: config
+
+# Check authority status.
+new: reports node_roles is 4
+old: reports node_roles is 4
+
+# Ensure parachains are registered.
+new: parachain 2000 is registered within 60 seconds
+old: parachain 2000 is registered within 60 seconds
+old: parachain 2001 is registered within 60 seconds
+new: parachain 2001 is registered within 60 seconds
+
+# Ensure parachains made progress and approval checking works.
+new: parachain 2000 block height is at least 15 within 600 seconds
+old: parachain 2000 block height is at least 15 within 600 seconds
+new: parachain 2001 block height is at least 15 within 600 seconds
+old: parachain 2001 block height is at least 15 within 600 seconds
+
+new: reports substrate_block_height{status="finalized"} is at least 30 within 400 seconds
+old: reports substrate_block_height{status="finalized"} is at least 30 within 400 seconds
+
+new: reports polkadot_parachain_approval_checking_finality_lag < 3
+old: reports polkadot_parachain_approval_checking_finality_lag < 3
+
+new: reports polkadot_parachain_approvals_no_shows_total < 3 within 10 seconds
+old: reports polkadot_parachain_approvals_no_shows_total < 3 within 10 seconds
+
+# Ensure that there are no failed recoveries.
+new: count of log lines containing "Data recovery from chunks complete" is at least 10 within 300 seconds
+old: count of log lines containing "Data recovery from chunks complete" is at least 10 within 300 seconds
+new: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds
+old: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds
+new: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds
+old: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds
+
+# Ensure we used the fallback network request.
+new: log line contains "Trying the fallback protocol" within 100 seconds
+
+# Ensure systematic recovery was not used.
+old: count of log lines containing "Data recovery from systematic chunks complete" is 0 within 10 seconds
+new: count of log lines containing "Data recovery from systematic chunks complete" is 0 within 10 seconds
+
+# Ensure availability-distribution worked fine
+new: reports polkadot_parachain_fetched_chunks_total{success="succeeded"} is at least 10 within 400 seconds
+old: reports polkadot_parachain_fetched_chunks_total{success="succeeded"} is at least 10 within 400 seconds
+
+new: reports polkadot_parachain_fetched_chunks_total{success="failed"} is 0 within 10 seconds
+old: reports polkadot_parachain_fetched_chunks_total{success="failed"} is 0 within 10 seconds
+
+new: reports polkadot_parachain_fetched_chunks_total{success="not-found"} is 0 within 10 seconds
+old: reports polkadot_parachain_fetched_chunks_total{success="not-found"} is 0 within 10 seconds
diff --git a/polkadot/zombienet_tests/functional/0015-coretime-shared-core.toml b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fed30e0db05321631fdce66da858e1431ded64dd
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.toml
@@ -0,0 +1,44 @@
+[settings]
+timeout = 1000
+
+[relaychain.genesis.runtimeGenesis.patch.configuration.config.async_backing_params]
+  max_candidate_depth = 3
+  allowed_ancestry_len = 2
+
+[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
+  max_validators_per_core = 1
+  lookahead = 2
+  num_cores = 4
+
+[relaychain.genesis.runtimeGenesis.patch.configuration.config.approval_voting_params]
+  needed_approvals = 3
+
+[relaychain]
+default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
+chain = "rococo-local"
+command = "polkadot"
+
+  [[relaychain.node_groups]]
+  name = "validator"
+  args = ["-lruntime=debug,parachain=debug,parachain::backing=trace,parachain::collator-protocol=trace,parachain::prospective-parachains=trace,runtime::parachains::scheduler=trace,runtime::inclusion-inherent=trace,runtime::inclusion=trace" ]
+  count = 4
+
+{% for id in range(2000,2004) %}
+[[parachains]]
+id = {{id}}
+register_para = false
+onboard_as_parachain = false
+add_to_genesis = false
+chain = "glutton-westend-local-{{id}}"
+    [parachains.genesis.runtimeGenesis.patch.glutton]
+    compute = "50000000"
+    storage = "2500000000"
+    trashDataCount = 5120
+
+    [parachains.collator]
+    name = "collator-{{id}}"
+    image = "{{CUMULUS_IMAGE}}"
+    command = "polkadot-parachain"
+    args = ["-lparachain=debug"]
+
+{% endfor %}
diff --git a/polkadot/zombienet_tests/functional/0015-coretime-shared-core.zndsl b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.zndsl
new file mode 100644
index 0000000000000000000000000000000000000000..b8b8887df85782268735f906eab771ddfcc22fcf
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.zndsl
@@ -0,0 +1,16 @@
+Description: CT shared core test
+Network: ./0015-coretime-shared-core.toml
+Creds: config
+
+validator: reports node_roles is 4
+
+# register paras 2 by 2 to speed up the test. registering all at once will exceed the weight limit.
+validator-0: js-script ./0015-force-register-paras.js with "2000,2001" return is 0 within 600 seconds
+validator-0: js-script ./0015-force-register-paras.js with "2002,2003" return is 0 within 600 seconds
+# assign core 0 to be shared by all paras.
+validator-0: js-script ./assign-core.js with "0,2000,14400,2001,14400,2002,14400,2003,14400" return is 0 within 600 seconds
+
+collator-2000: reports block height is at least 6 within 200 seconds
+collator-2001: reports block height is at least 6 within 50 seconds
+collator-2002: reports block height is at least 6 within 50 seconds
+collator-2003: reports block height is at least 6 within 50 seconds
diff --git a/polkadot/zombienet_tests/functional/0015-force-register-paras.js b/polkadot/zombienet_tests/functional/0015-force-register-paras.js
new file mode 100644
index 0000000000000000000000000000000000000000..f82163b01105a4b7bee09d6827860b685c38890e
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/0015-force-register-paras.js
@@ -0,0 +1,63 @@
+async function run(nodeName, networkInfo, args) {
+  const init = networkInfo.nodesByName[nodeName];
+  let wsUri = init.wsUri;
+  let userDefinedTypes = init.userDefinedTypes;
+  const api = await zombie.connect(wsUri, userDefinedTypes);
+
+  // account to submit tx
+  const keyring = new zombie.Keyring({ type: "sr25519" });
+  const alice = keyring.addFromUri("//Alice");
+
+  let calls = [];
+
+  for (let i = 0; i < args.length; i++) {
+    let para = args[i];
+    const sec = networkInfo.nodesByName["collator-" + para];
+    const api_collator = await zombie.connect(sec.wsUri, sec.userDefinedTypes);
+
+    await zombie.util.cryptoWaitReady();
+
+    // Get the genesis header and the validation code of the parachain
+    const genesis_header = await api_collator.rpc.chain.getHeader();
+    const validation_code = await api_collator.rpc.state.getStorage("0x3A636F6465");
+
+    calls.push(
+      api.tx.paras.addTrustedValidationCode(validation_code.toHex())
+    );
+    calls.push(
+      api.tx.registrar.forceRegister(
+        alice.address,
+        0,
+        Number(para),
+        genesis_header.toHex(),
+        validation_code.toHex(),
+      )
+    );
+  }
+
+  const sudo_batch = api.tx.sudo.sudo(api.tx.utility.batch(calls));
+
+  await new Promise(async (resolve, reject) => {
+    const unsub = await sudo_batch
+      .signAndSend(alice, ({ status, isError }) => {
+        if (status.isInBlock) {
+          console.log(
+            `Transaction included at blockhash ${status.asInBlock}`,
+          );
+        } else if (status.isFinalized) {
+          console.log(
+            `Transaction finalized at blockHash ${status.asFinalized}`,
+          );
+          unsub();
+          return resolve();
+        } else if (isError) {
+          console.log(`Transaction error`);
+          reject(`Transaction error`);
+        }
+      });
+  });
+
+  return 0;
+}
+
+module.exports = { run };
diff --git a/polkadot/zombienet_tests/functional/assign-core.js b/polkadot/zombienet_tests/functional/assign-core.js
new file mode 120000
index 0000000000000000000000000000000000000000..eeb6402c06f5e52cedf150f924d6791beb1d9867
--- /dev/null
+++ b/polkadot/zombienet_tests/functional/assign-core.js
@@ -0,0 +1 @@
+../assign-core.js
\ No newline at end of file
diff --git a/prdoc/pr_2226.prdoc b/prdoc/1.12.0/pr_2226.prdoc
similarity index 100%
rename from prdoc/pr_2226.prdoc
rename to prdoc/1.12.0/pr_2226.prdoc
diff --git a/prdoc/pr_3444.prdoc b/prdoc/1.12.0/pr_3444.prdoc
similarity index 100%
rename from prdoc/pr_3444.prdoc
rename to prdoc/1.12.0/pr_3444.prdoc
diff --git a/prdoc/pr_3701.prdoc b/prdoc/1.12.0/pr_3701.prdoc
similarity index 100%
rename from prdoc/pr_3701.prdoc
rename to prdoc/1.12.0/pr_3701.prdoc
diff --git a/prdoc/pr_3865.prdoc b/prdoc/1.12.0/pr_3865.prdoc
similarity index 100%
rename from prdoc/pr_3865.prdoc
rename to prdoc/1.12.0/pr_3865.prdoc
diff --git a/prdoc/pr_3872.prdoc b/prdoc/1.12.0/pr_3872.prdoc
similarity index 100%
rename from prdoc/pr_3872.prdoc
rename to prdoc/1.12.0/pr_3872.prdoc
diff --git a/prdoc/pr_3904.prdoc b/prdoc/1.12.0/pr_3904.prdoc
similarity index 100%
rename from prdoc/pr_3904.prdoc
rename to prdoc/1.12.0/pr_3904.prdoc
diff --git a/prdoc/pr_3962.prdoc b/prdoc/1.12.0/pr_3962.prdoc
similarity index 100%
rename from prdoc/pr_3962.prdoc
rename to prdoc/1.12.0/pr_3962.prdoc
diff --git a/prdoc/pr_3964.prdoc b/prdoc/1.12.0/pr_3964.prdoc
similarity index 100%
rename from prdoc/pr_3964.prdoc
rename to prdoc/1.12.0/pr_3964.prdoc
diff --git a/prdoc/pr_4034.prdoc b/prdoc/1.12.0/pr_4034.prdoc
similarity index 100%
rename from prdoc/pr_4034.prdoc
rename to prdoc/1.12.0/pr_4034.prdoc
diff --git a/prdoc/pr_4035.prdoc b/prdoc/1.12.0/pr_4035.prdoc
similarity index 100%
rename from prdoc/pr_4035.prdoc
rename to prdoc/1.12.0/pr_4035.prdoc
diff --git a/prdoc/pr_4091.prdoc b/prdoc/1.12.0/pr_4091.prdoc
similarity index 100%
rename from prdoc/pr_4091.prdoc
rename to prdoc/1.12.0/pr_4091.prdoc
diff --git a/prdoc/pr_4102.prdoc b/prdoc/1.12.0/pr_4102.prdoc
similarity index 100%
rename from prdoc/pr_4102.prdoc
rename to prdoc/1.12.0/pr_4102.prdoc
diff --git a/prdoc/pr_4157.prdoc b/prdoc/1.12.0/pr_4157.prdoc
similarity index 100%
rename from prdoc/pr_4157.prdoc
rename to prdoc/1.12.0/pr_4157.prdoc
diff --git a/prdoc/pr_4175.prdoc b/prdoc/1.12.0/pr_4175.prdoc
similarity index 100%
rename from prdoc/pr_4175.prdoc
rename to prdoc/1.12.0/pr_4175.prdoc
diff --git a/prdoc/pr_4185.prdoc b/prdoc/1.12.0/pr_4185.prdoc
similarity index 100%
rename from prdoc/pr_4185.prdoc
rename to prdoc/1.12.0/pr_4185.prdoc
diff --git a/prdoc/pr_4202.prdoc b/prdoc/1.12.0/pr_4202.prdoc
similarity index 100%
rename from prdoc/pr_4202.prdoc
rename to prdoc/1.12.0/pr_4202.prdoc
diff --git a/prdoc/pr_4211.prdoc b/prdoc/1.12.0/pr_4211.prdoc
similarity index 100%
rename from prdoc/pr_4211.prdoc
rename to prdoc/1.12.0/pr_4211.prdoc
diff --git a/prdoc/pr_4213.prdoc b/prdoc/1.12.0/pr_4213.prdoc
similarity index 100%
rename from prdoc/pr_4213.prdoc
rename to prdoc/1.12.0/pr_4213.prdoc
diff --git a/prdoc/pr_4220.prdoc b/prdoc/1.12.0/pr_4220.prdoc
similarity index 100%
rename from prdoc/pr_4220.prdoc
rename to prdoc/1.12.0/pr_4220.prdoc
diff --git a/prdoc/pr_4281.prdoc b/prdoc/1.12.0/pr_4281.prdoc
similarity index 100%
rename from prdoc/pr_4281.prdoc
rename to prdoc/1.12.0/pr_4281.prdoc
diff --git a/prdoc/pr_4295.prdoc b/prdoc/1.12.0/pr_4295.prdoc
similarity index 100%
rename from prdoc/pr_4295.prdoc
rename to prdoc/1.12.0/pr_4295.prdoc
diff --git a/prdoc/pr_4301.prdoc b/prdoc/1.12.0/pr_4301.prdoc
similarity index 100%
rename from prdoc/pr_4301.prdoc
rename to prdoc/1.12.0/pr_4301.prdoc
diff --git a/prdoc/pr_4302.prdoc b/prdoc/1.12.0/pr_4302.prdoc
similarity index 100%
rename from prdoc/pr_4302.prdoc
rename to prdoc/1.12.0/pr_4302.prdoc
diff --git a/prdoc/pr_4311.prdoc b/prdoc/1.12.0/pr_4311.prdoc
similarity index 100%
rename from prdoc/pr_4311.prdoc
rename to prdoc/1.12.0/pr_4311.prdoc
diff --git a/prdoc/pr_4312.prdoc b/prdoc/1.12.0/pr_4312.prdoc
similarity index 100%
rename from prdoc/pr_4312.prdoc
rename to prdoc/1.12.0/pr_4312.prdoc
diff --git a/prdoc/pr_4326.prdoc b/prdoc/1.12.0/pr_4326.prdoc
similarity index 100%
rename from prdoc/pr_4326.prdoc
rename to prdoc/1.12.0/pr_4326.prdoc
diff --git a/prdoc/pr_4329.prdoc b/prdoc/1.12.0/pr_4329.prdoc
similarity index 100%
rename from prdoc/pr_4329.prdoc
rename to prdoc/1.12.0/pr_4329.prdoc
diff --git a/prdoc/pr_4346.prdoc b/prdoc/1.12.0/pr_4346.prdoc
similarity index 100%
rename from prdoc/pr_4346.prdoc
rename to prdoc/1.12.0/pr_4346.prdoc
diff --git a/prdoc/pr_4349.prdoc b/prdoc/1.12.0/pr_4349.prdoc
similarity index 100%
rename from prdoc/pr_4349.prdoc
rename to prdoc/1.12.0/pr_4349.prdoc
diff --git a/prdoc/pr_4364.prdoc b/prdoc/1.12.0/pr_4364.prdoc
similarity index 100%
rename from prdoc/pr_4364.prdoc
rename to prdoc/1.12.0/pr_4364.prdoc
diff --git a/prdoc/pr_4394.prdoc b/prdoc/1.12.0/pr_4394.prdoc
similarity index 100%
rename from prdoc/pr_4394.prdoc
rename to prdoc/1.12.0/pr_4394.prdoc
diff --git a/prdoc/pr_4406.prdoc b/prdoc/1.12.0/pr_4406.prdoc
similarity index 100%
rename from prdoc/pr_4406.prdoc
rename to prdoc/1.12.0/pr_4406.prdoc
diff --git a/prdoc/pr_4414.prdoc b/prdoc/1.12.0/pr_4414.prdoc
similarity index 100%
rename from prdoc/pr_4414.prdoc
rename to prdoc/1.12.0/pr_4414.prdoc
diff --git a/prdoc/pr_4417.prdoc b/prdoc/1.12.0/pr_4417.prdoc
similarity index 100%
rename from prdoc/pr_4417.prdoc
rename to prdoc/1.12.0/pr_4417.prdoc
diff --git a/prdoc/pr_4426.prdoc b/prdoc/1.12.0/pr_4426.prdoc
similarity index 100%
rename from prdoc/pr_4426.prdoc
rename to prdoc/1.12.0/pr_4426.prdoc
diff --git a/prdoc/pr_4442.prdoc b/prdoc/1.12.0/pr_4442.prdoc
similarity index 100%
rename from prdoc/pr_4442.prdoc
rename to prdoc/1.12.0/pr_4442.prdoc
diff --git a/prdoc/pr_4457.prdoc b/prdoc/1.12.0/pr_4457.prdoc
similarity index 100%
rename from prdoc/pr_4457.prdoc
rename to prdoc/1.12.0/pr_4457.prdoc
diff --git a/prdoc/pr_4461.prdoc b/prdoc/1.12.0/pr_4461.prdoc
similarity index 100%
rename from prdoc/pr_4461.prdoc
rename to prdoc/1.12.0/pr_4461.prdoc
diff --git a/prdoc/1.13.0/pr_1223.prdoc b/prdoc/1.13.0/pr_1223.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..08b18557b70c6b649c49bb1dd62acc9528a79a86
--- /dev/null
+++ b/prdoc/1.13.0/pr_1223.prdoc
@@ -0,0 +1,13 @@
+title: Optimize storage append operation
+
+doc:
+  - audience: [Node Dev, Runtime Dev]
+    description: |
+      This pull request optimizes the storage append operation in the `OverlayedChanges`.
+      Before the internal buffer was cloned every time a new transaction was created. Cloning
+      the internal buffer is now only done when there is no other possibility. This should
+      improve the performance in situations like when depositing events from batched calls.
+
+crates:
+  - name: sp-state-machine
+    bump: major
diff --git a/prdoc/1.13.0/pr_1644.prdoc b/prdoc/1.13.0/pr_1644.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..cc43847fa09b2fee66924b08ea0aa9ff9842b036
--- /dev/null
+++ b/prdoc/1.13.0/pr_1644.prdoc
@@ -0,0 +1,59 @@
+title: Add availability-recovery from systematic chunks
+
+doc:
+  - audience: Node Operator
+    description: |
+      Implements https://github.com/polkadot-fellows/RFCs/pull/47. This optimisation is guarded by a configuration bit in
+      the runtime and will only be enabled once a supermajority of the validators have upgraded to this version.
+      It's strongly advised to upgrade to this version.
+  - audience: Node Dev
+    description: |
+      Implements https://github.com/polkadot-fellows/RFCs/pull/47 and adds the logic for availability recovery from systematic chunks.
+      The /req_chunk/1 req-response protocol is now considered deprecated in favour of /req_chunk/2. Systematic recovery is guarded
+      by a configuration bit in the runtime (bit with index 2 of the node_features field from the HostConfiguration)
+      and must not be enabled until all (or almost all) validators have upgraded to the node version that includes
+      this PR.
+
+crates:
+  - name: sc-network
+    bump: minor
+  - name: polkadot-primitives
+    bump: minor
+  - name: cumulus-client-pov-recovery
+    bump: none
+  - name: polkadot-overseer
+    bump: none
+  - name: polkadot-node-primitives
+    bump: major
+  - name: polkadot-erasure-coding
+    bump: major
+  - name: polkadot-node-jaeger
+    bump: major
+  - name: polkadot-node-subsystem-types
+    bump: major
+  - name: polkadot-node-network-protocol
+    bump: major
+  - name: polkadot-service
+    bump: major
+  - name: polkadot-node-subsystem-util
+    bump: major
+  - name: polkadot-availability-distribution
+    bump: major
+  - name: polkadot-availability-recovery
+    bump: major
+  - name: polkadot-node-core-approval-voting
+    bump: minor
+  - name: polkadot-node-core-av-store
+    bump: major
+  - name: polkadot-network-bridge
+    bump: minor
+  - name: polkadot-node-core-backing
+    bump: none
+  - name: polkadot-node-core-bitfield-signing
+    bump: none
+  - name: polkadot-node-core-dispute-coordinator
+    bump: none
+  - name: cumulus-relay-chain-minimal-node
+    bump: minor
+  - name: polkadot
+    bump: minor
diff --git a/prdoc/pr_3393.prdoc b/prdoc/1.13.0/pr_3393.prdoc
similarity index 100%
rename from prdoc/pr_3393.prdoc
rename to prdoc/1.13.0/pr_3393.prdoc
diff --git a/prdoc/1.13.0/pr_3905.prdoc b/prdoc/1.13.0/pr_3905.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..d1c03650c9b2365d8f33345fbcef98b4f3885a51
--- /dev/null
+++ b/prdoc/1.13.0/pr_3905.prdoc
@@ -0,0 +1,25 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Allows Nomination Pool to use different staking strategies including a new DelegateStake strategy.
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      This PR introduces a new staking strategy called `DelegateStake`. This strategy allows the nomination pool to
+      delegate its stake to a validator, that is, funds are locked in user account itself instead of being transferred
+      to the pool account. Includes migration of pools to this strategy for Westend.
+
+crates:
+    - name: pallet-nomination-pools
+      bump: major
+    - name: pallet-nomination-pools-benchmarking
+      bump: major
+    - name: sp-staking
+      bump: patch
+    - name: pallet-staking
+      bump: patch
+    - name: pallet-delegated-staking
+      bump: patch
+    - name: westend-runtime
+      bump: major
diff --git a/prdoc/1.13.0/pr_3935.prdoc b/prdoc/1.13.0/pr_3935.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..93b0fba5d99b47fa918a1100e644ea32f5cc4aa8
--- /dev/null
+++ b/prdoc/1.13.0/pr_3935.prdoc
@@ -0,0 +1,30 @@
+title: "Introduce Polkadot-SDK umbrella crate"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Introduces a new "umbrella" crate that re-exports all published crates of the Polkadot-SDK.
+      This helps developers to select a valid set of versions for all underlying dependencies.
+
+      You can now use this create and remove lots of dependencies from your runtime and node crates.
+      The `staging-node-cli` and `kitchensink-runtime` both adopt this pattern as an example.
+
+      Full docs in `docs/sdk/src/reference_docs/umbrella_crate.rs`.
+
+crates:
+  - name: cumulus-pallet-parachain-system
+    bump: patch
+  - name: sc-chain-spec-derive
+    bump: patch
+  - name: frame-election-provider-solution-type
+    bump: patch
+  - name: pallet-staking-reward-curve
+    bump: patch
+  - name: frame-support-procedural-tools
+    bump: patch
+  - name: sp-api-proc-macro
+    bump: patch
+  - name: polkadot-runtime-parachains
+    bump: patch
+  - name: polkadot-sdk
+    bump: major
diff --git a/prdoc/pr_3952.prdoc b/prdoc/1.13.0/pr_3952.prdoc
similarity index 100%
rename from prdoc/pr_3952.prdoc
rename to prdoc/1.13.0/pr_3952.prdoc
diff --git a/prdoc/1.13.0/pr_4131.prdoc b/prdoc/1.13.0/pr_4131.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..b0619eabe13b575cc6aa10f7215e68a57698b159
--- /dev/null
+++ b/prdoc/1.13.0/pr_4131.prdoc
@@ -0,0 +1,26 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Deprecate XCMv2
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      XCMv2 has been deprecated. It will be removed when XCMv5 is released.
+      Use version 3 or 4 instead.
+  - audience: Runtime User
+    description: |
+      XCMv2 has been deprecated. It will be removed when XCMv5 is released.
+      Use version 3 or 4 instead.
+
+crates:
+- name: staging-xcm
+  bump: minor
+- name: xcm-procedural
+  bump: minor
+- name: staging-xcm-builder
+  bump: minor
+- name: pallet-xcm
+  bump: minor
+- name: cumulus-pallet-xcmp-queue
+  bump: minor
diff --git a/prdoc/1.13.0/pr_4198.prdoc b/prdoc/1.13.0/pr_4198.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..cff956812606fc18a500a9cf0de0cc7252955283
--- /dev/null
+++ b/prdoc/1.13.0/pr_4198.prdoc
@@ -0,0 +1,31 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Replace `Multiaddr` & related types with substrate-specific types
+
+doc:
+  - audience: Node Dev
+    description: |
+      Introduce custom types / substrate wrappers for `Multiaddr`, `multiaddr::Protocol`,
+      `Multihash`, `ed25519::*` and supplementary types like errors and iterators.
+
+      Common code in substrate uses these custom types, while `libp2p` & `litep2p` network
+      backends use their corresponding libraries types.
+
+      This is needed to independently upgrade `libp2p` & `litep2p` dependencies.
+
+crates:
+  - name: sc-network-types
+    bump: minor
+  - name: sc-network
+    bump: minor
+  - name: sc-network-sync
+    bump: minor
+  - name: sc-authority-discovery
+    bump: minor
+  - name: sc-cli
+    bump: patch
+  - name: sc-mixnet
+    bump: patch
+  - name: sc-telemetry
+    bump: patch
diff --git a/prdoc/1.13.0/pr_4233.prdoc b/prdoc/1.13.0/pr_4233.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..c593fec68a66a133b2ee7db8a08eea38a9a05883
--- /dev/null
+++ b/prdoc/1.13.0/pr_4233.prdoc
@@ -0,0 +1,14 @@
+title: "[pallet_contracts] Update Host fn benchnmarks"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Update how the host functions are benchmarked.
+      Instead of benchnarking a contract that calls the host functions, we now benchmark the host functions directly.
+
+crates:
+  - name: pallet-contracts
+    bump: minor
+  - name: pallet-contracts-proc-macro
+    bump: minor
+
diff --git a/prdoc/1.13.0/pr_4249.prdoc b/prdoc/1.13.0/pr_4249.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..1a267e263924b7f5d0df62d1e1af6800e3ad255f
--- /dev/null
+++ b/prdoc/1.13.0/pr_4249.prdoc
@@ -0,0 +1,17 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Moves runtime macro out of experimental flag
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Now that the runtime macro (Construct Runtime V2) has been successfully deployed on Westend, 
+      this PR moves it out of the experimental feature flag and makes it generally available for
+      runtime devs.
+
+crates:
+  - name: frame-support
+    bump: minor
+  - name: frame-support-procedural
+    bump: minor
diff --git a/prdoc/1.13.0/pr_4274.prdoc b/prdoc/1.13.0/pr_4274.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..77f5d1387cf7bfc19cd548dbed1c7d7031e39c73
--- /dev/null
+++ b/prdoc/1.13.0/pr_4274.prdoc
@@ -0,0 +1,39 @@
+title: Introduce `CheckMetadataHash` signed extension
+
+doc:
+  - audience: Runtime Dev
+    description: |
+       Introduces the new `CheckMetadataHash` signed extension. This extension can be added to a
+       runtime to support verifying the metadata hash as described in
+       [RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html).
+       This removes the requirement for having a metadata portal and in general a centralized
+       authentication of the metadata. With this signed extension the runtime is able to verify
+       that the metadata used by the wallet was correct. This is mainly useful for offline wallets
+       which users need to trust any way, not that useful for online wallets.
+
+       There is a guide `generate_metadata_hash` for how to integrate this into a runtime that
+       should make it quite easy to integrate the signed extension.
+  - audience: Runtime User
+    description: |
+       This brings support for the new Ledger app and similar hardware wallets. These hardware
+       wallets will be able to decode the transaction using the metadata. The runtime will
+       ensure that the metadata used for this decoding process is correct and that the online
+       wallet did not tried to trick you.
+
+crates:
+  - name: substrate-wasm-builder
+    bump: minor
+  - name: sc-executor-wasmtime
+    bump: patch
+  - name: frame-metadata-hash-extension
+    bump: major
+  - name: polkadot-service
+    bump: none
+  - name: rococo-runtime
+    bump: major
+  - name: westend-runtime
+    bump: major
+  - name: asset-hub-rococo-runtime
+    bump: major
+  - name: asset-hub-westend-runtime
+    bump: major
diff --git a/prdoc/1.13.0/pr_4339.prdoc b/prdoc/1.13.0/pr_4339.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..634ccfa1a339df615db5957729c7833c972047ac
--- /dev/null
+++ b/prdoc/1.13.0/pr_4339.prdoc
@@ -0,0 +1,13 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Improving on_demand_assigner emitted events
+
+doc:
+  - audience: Runtime User
+    description: |
+      Registering OnDemandOrderPlaced event that is useful for indexers to save data related to on demand orders. Adds SpotPriceSet as a new event to monitor on-demand spot prices. It updates whenever the price changes due to traffic.
+
+crates:
+  - name: polkadot-runtime-parachains
+    bump: minor
\ No newline at end of file
diff --git a/prdoc/1.13.0/pr_4380.prdoc b/prdoc/1.13.0/pr_4380.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..1420409656b320c390ab05eecb15df0eca9e3432
--- /dev/null
+++ b/prdoc/1.13.0/pr_4380.prdoc
@@ -0,0 +1,15 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Remove `parametrized-consensus-hook` feature
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      `parametrized-consensus-hook` feature is obsolete and is removed by this PR. The
+      long-deprecated `CheckInherents` trait is set to be removed by September 2024.
+
+crates:
+  - name: cumulus-pallet-parachain-system
+    bump: major
+
diff --git a/prdoc/pr_4392.prdoc b/prdoc/1.13.0/pr_4392.prdoc
similarity index 100%
rename from prdoc/pr_4392.prdoc
rename to prdoc/1.13.0/pr_4392.prdoc
diff --git a/prdoc/1.13.0/pr_4410.prdoc b/prdoc/1.13.0/pr_4410.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..1dc1d4c1f87a728ef0edb60d7334ba97a59f539d
--- /dev/null
+++ b/prdoc/1.13.0/pr_4410.prdoc
@@ -0,0 +1,37 @@
+title: "[sc-chain-spec] Remove deprecated code"
+
+doc:
+  - audience: Node Dev
+    description: |
+      The RuntimeGenesisConfig generic type parameter was removed from GenericChainSpec struct.
+      ChainSpec::from_genesis method was removed.
+      Removed related deprecated code from `sc-chain-spec`.
+      This change simplifies the codebase and ensures the use of up-to-date definitions.
+
+crates:
+  - name: sc-service
+    bump: minor
+  - name: minimal-template-node
+    bump: minor
+  - name: sc-cli
+    bump: patch
+  - name: polkadot-test-service
+    bump: major
+  - name: sc-service-test
+    bump: major
+  - name: staging-node-cli
+    bump: major
+  - name: parachain-template-node
+    bump: minor
+  - name: solochain-template-node
+    bump: minor
+  - name: polkadot-parachain-bin
+    bump: major
+  - name: polkadot-service
+    bump: major
+  - name: sc-consensus-grandpa
+    bump: patch
+  - name: cumulus-test-service
+    bump: minor
+  - name: sc-chain-spec
+    bump: major
diff --git a/prdoc/1.13.0/pr_4418.prdoc b/prdoc/1.13.0/pr_4418.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..4372692b2b98ee578d8e4768b171ec1e02f15a2c
--- /dev/null
+++ b/prdoc/1.13.0/pr_4418.prdoc
@@ -0,0 +1,19 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: "[pallet_contracts] Add `READ_ONLY` flag to contract `call` function"
+
+doc:
+  - audience: Runtime User
+    description: |
+      This PR implements the `READ_ONLY` flag to be used as a `Callflag` in the contract `call` function.
+      The flag indicates that the callee is restricted from modifying the state during call execution.
+      It is equivalent to Ethereum's [STATICCALL](https://eips.ethereum.org/EIPS/eip-214).
+
+crates:
+  - name: pallet-contracts
+    bump: minor
+  - name: pallet-contracts-uapi
+    bump: minor
+  - name: pallet-contracts-proc-macro
+    bump: minor
diff --git a/prdoc/1.13.0/pr_4431.prdoc b/prdoc/1.13.0/pr_4431.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..993a7326b9aad4aa713f47dffeb9622493db1cf2
--- /dev/null
+++ b/prdoc/1.13.0/pr_4431.prdoc
@@ -0,0 +1,17 @@
+title: "Statement-Distribution validator disabling changes"
+
+doc:
+  - audience: Node Dev
+    description: |
+      In preparation for launching re-enabling (#2418), we need to adjust the
+      disabling strategy of statement-distribution to use the relay parent's
+      state instead of the latest state (union of active leaves). This will also
+      ensure no raciness of getting the latest state vs accepting statements from
+      disabling validators at the cost of being more lenient/potentially accepting
+      more statements from disabled validators.
+
+crates:
+  - name: polkadot-statement-distribution
+    bump: patch
+  - name: polkadot
+    bump: none
diff --git a/prdoc/1.13.0/pr_4444.prdoc b/prdoc/1.13.0/pr_4444.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..0b6a5715e47f858f17d845bb3b4b7e4bc49ae2fb
--- /dev/null
+++ b/prdoc/1.13.0/pr_4444.prdoc
@@ -0,0 +1,10 @@
+title: "Rococo AH: cleanup storage"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Remove old storage that is left over in the Rococo AH storage.
+
+crates:
+  - name: asset-hub-rococo-runtime
+    bump: patch
diff --git a/prdoc/1.13.0/pr_4465.prdoc b/prdoc/1.13.0/pr_4465.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..cbeff09f871f00d5ce3e646fa4adfb11148971a2
--- /dev/null
+++ b/prdoc/1.13.0/pr_4465.prdoc
@@ -0,0 +1,19 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: "Bridge: added force_set_pallet_state call to pallet-bridge-grandpa"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Added `force_set_pallet_state` to the `pallet-bridge-grandpa`. It is only callable by the
+      root (governance or sudo) and may be used to update current authorities set and the best
+      finalized header without any additional checks.
+
+crates:
+  - name: pallet-bridge-grandpa
+    bump: major
+  - name: bridge-hub-rococo-runtime
+    bump: minor
+  - name: bridge-hub-westend-runtime
+    bump: minor
diff --git a/prdoc/1.13.0/pr_4471.prdoc b/prdoc/1.13.0/pr_4471.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..6d589be81fd96904f0c5c76abccb1c9b5acd920d
--- /dev/null
+++ b/prdoc/1.13.0/pr_4471.prdoc
@@ -0,0 +1,16 @@
+title: "Remove prospective-parachains subsystem from collator nodes"
+
+doc:
+  - audience: Node Dev
+    description: |
+      Removes the prospective-parachains subsystem from collators. The GetMinimumRelayParents of the implicit view
+      is replaced by direct ChainAPI and runtime calls. The subsystem was causing performance problems when collating
+      connected to an RPC node, due to the high number of runtime API calls, which were unneccessary for a collator.
+
+crates:
+  - name: polkadot-collator-protocol
+    bump: minor
+  - name: polkadot-service
+    bump: minor
+  - name: polkadot-node-subsystem-util
+    bump: minor
diff --git a/prdoc/pr_4472.prdoc b/prdoc/1.13.0/pr_4472.prdoc
similarity index 100%
rename from prdoc/pr_4472.prdoc
rename to prdoc/1.13.0/pr_4472.prdoc
diff --git a/prdoc/pr_4475.prdoc b/prdoc/1.13.0/pr_4475.prdoc
similarity index 100%
rename from prdoc/pr_4475.prdoc
rename to prdoc/1.13.0/pr_4475.prdoc
diff --git a/prdoc/pr_4478.prdoc b/prdoc/1.13.0/pr_4478.prdoc
similarity index 100%
rename from prdoc/pr_4478.prdoc
rename to prdoc/1.13.0/pr_4478.prdoc
diff --git a/prdoc/pr_4503.prdoc b/prdoc/1.13.0/pr_4503.prdoc
similarity index 100%
rename from prdoc/pr_4503.prdoc
rename to prdoc/1.13.0/pr_4503.prdoc
diff --git a/prdoc/pr_4510.prdoc b/prdoc/1.13.0/pr_4510.prdoc
similarity index 100%
rename from prdoc/pr_4510.prdoc
rename to prdoc/1.13.0/pr_4510.prdoc
diff --git a/prdoc/pr_4514.prdoc b/prdoc/1.13.0/pr_4514.prdoc
similarity index 100%
rename from prdoc/pr_4514.prdoc
rename to prdoc/1.13.0/pr_4514.prdoc
diff --git a/prdoc/1.13.0/pr_4521.prdoc b/prdoc/1.13.0/pr_4521.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..a8b42a2c7ee3fd5f4beca6c2aede7a4a82a8a1b1
--- /dev/null
+++ b/prdoc/1.13.0/pr_4521.prdoc
@@ -0,0 +1,28 @@
+title: AdaptPrice trait is now price controlled
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      The broker pallet price adaptation interface is changed to be less opinionated and more
+      information is made available to the `AdaptPrice` trait. A new example impl is included which
+      adapts the price based not on the number of cores sold, but rather on the price that was
+      achieved during the sale to mitigate a potential price manipulation vector. More information
+      here:
+
+        https://github.com/paritytech/polkadot-sdk/issues/4360
+
+  - audience: Runtime User
+    description: |
+      The price controller of the Rococo and Westend Coretime chain will be
+      adjusted with this release. This will very likely be used in the
+      fellowship production runtime to have a much larger leadin. This fixes a
+      price manipulation issue we discovered with the Kusama launch.
+
+crates:
+  - name: pallet-broker
+    bump: minor
+  - name: coretime-rococo-runtime
+    bump: minor
+  - name: coretime-westend-runtime
+    bump: minor
+
diff --git a/prdoc/1.13.0/pr_4533.prdoc b/prdoc/1.13.0/pr_4533.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..a0835285fc012cb0018e499f87e380f7ac059999
--- /dev/null
+++ b/prdoc/1.13.0/pr_4533.prdoc
@@ -0,0 +1,10 @@
+title: "Fixed RPC subscriptions leak when subscription stream is finished"
+
+doc:
+  - audience: Node Operator
+    description: |
+      The node may leak RPC subscriptions in some cases, e.g. during
+      `author_submitAndWatchExtrinsic` calls. This PR fixes the issue.
+
+crates:
+  - name: sc-rpc
diff --git a/prdoc/1.13.0/pr_4534.prdoc b/prdoc/1.13.0/pr_4534.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..417e4d3dace01e2e840a074bf9aac8615dbb5f1a
--- /dev/null
+++ b/prdoc/1.13.0/pr_4534.prdoc
@@ -0,0 +1,13 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Add Extra Check in Primary Username Setter
+
+doc:
+  - audience: Runtime User
+    description: |
+      Setting primary usernames requires an additional verification.
+
+crates:
+  - name: pallet-identity
+    bump: patch
diff --git a/prdoc/1.13.0/pr_4537.prdoc b/prdoc/1.13.0/pr_4537.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..0148c95fb4e8bcddf530b66f66ffba9c6fdaec1e
--- /dev/null
+++ b/prdoc/1.13.0/pr_4537.prdoc
@@ -0,0 +1,27 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Runtime apis to help with delegate-stake based Nomination Pools.
+
+doc:
+  - audience: Runtime User
+    description: |
+      Introduces a new set of runtime apis to facilitate dapps and wallets to integrate with delegate-stake
+      functionalities of Nomination Pools. These apis support pool and member migration, as well as lazy application of
+      pending slashes of the pool members.
+
+crates:
+  - name: pallet-nomination-pools
+    bump: minor
+  - name: westend-runtime
+    bump: minor
+  - name: kitchensink-runtime
+    bump: minor
+  - name: pallet-delegated-staking
+    bump: minor
+  - name: sp-staking
+    bump: minor
+  - name: pallet-nomination-pools-benchmarking
+    bump: patch
+  - name: pallet-nomination-pools-runtime-api
+    bump: minor
diff --git a/prdoc/1.13.0/pr_4541.prdoc b/prdoc/1.13.0/pr_4541.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..815ea2c800625f78e1f92d153a0f3da664508829
--- /dev/null
+++ b/prdoc/1.13.0/pr_4541.prdoc
@@ -0,0 +1,16 @@
+title: "Remove warning about `BadCertificate` Version 2"
+
+doc:
+  - audience: Node Operator
+    description: |
+      The node was printing the following warning from time to time:
+      ```
+      Sending fatal alert BadCertificate
+      ```
+
+      This is not an user error and thus, the warning will now not be printed
+      anymore.
+
+crates:
+  - name: sc-tracing
+    bump: patch
diff --git a/prdoc/1.13.0/pr_4542.prdoc b/prdoc/1.13.0/pr_4542.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..faaf9dc2c288551ec84b7bcd739158dd817341e6
--- /dev/null
+++ b/prdoc/1.13.0/pr_4542.prdoc
@@ -0,0 +1,13 @@
+title: "Adds ability to specify chain type in chain-spec-builder"
+
+doc:
+  - audience: Node Operator
+    description: |
+      Currently, `chain-spec-builder` only creates a spec with Live chain type. This PR adds the 
+      ability to specify it while keeping the same default.
+
+crates:
+  - name: staging-chain-spec-builder
+    bump: patch
+  - name: sc-chain-spec
+    bump: patch
diff --git a/prdoc/1.13.0/pr_4555.prdoc b/prdoc/1.13.0/pr_4555.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..257115d236e76756007281a0b64d7a73fa2fdff9
--- /dev/null
+++ b/prdoc/1.13.0/pr_4555.prdoc
@@ -0,0 +1,11 @@
+title: Move `para_id` to `MockValidationDataInherentDataProvider`
+
+doc:
+  - audience: Node Dev
+    description: |
+      This moves the `para_id` from `MockXcmConfig` to `MockValidationDataInherentDataProvider` to make it more prominent. The `para_id` should
+      be set to the parachain id of the parachain that gets mocked to ensure that the relay chain storage proof is setup correctly etc.
+
+crates:
+  - name: cumulus-client-parachain-inherent
+    bump: major
diff --git a/prdoc/1.13.0/pr_4571.prdoc b/prdoc/1.13.0/pr_4571.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..b03fee8a5cc8746f9ae569a6ffd4902f1da4a510
--- /dev/null
+++ b/prdoc/1.13.0/pr_4571.prdoc
@@ -0,0 +1,19 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Ignore mandatory extrinsics in total PoV size check
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      The `CheckWeight` extension is checking that extrinsic length and used storage proof
+      weight together do not exceed the PoV size limit. This lead to problems when
+      the PoV size was already reached before mandatory extrinsics were applied.The `CheckWeight`
+      extension will now allow extrinsics of `DispatchClass::Mandatory` to be applied even if
+      the limit is reached.
+
+crates:
+  - name: frame-system
+    bump: minor
+  - name: polkadot-sdk
+    bump: minor
diff --git a/prdoc/1.13.0/pr_4595.prdoc b/prdoc/1.13.0/pr_4595.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..8baa6e8a91f3c54c50a5f20b2e03e812a8857162
--- /dev/null
+++ b/prdoc/1.13.0/pr_4595.prdoc
@@ -0,0 +1,25 @@
+title: "Remove `elastic-scaling-experimental` feature flag"
+
+doc:
+  - audience: Node Dev
+    description: |
+      The feature was masking the ability of collators to respond with `CollationWithParentHeadData`
+      to validator collation fetch requests, a requirement for elastic scaling. 
+      Please note that `CollationWithParentHeadData` is only sent by collators of parachains with 
+      multiple cores assigned, otherwise collators must respond with `CollationFetchingResponse::Collation`
+  - audience: Node Operator
+    description: |
+      This change enables elastic scaling support in collators. Please upgrade to latest version, 
+      otherwise validator nodes will not be able to back elastic parachain blocks leading to 
+      missed rewards. 
+
+crates:
+  - name: polkadot-collator-protocol
+    bump: major
+    validate: false
+  - name: polkadot-service
+    bump: major
+    validate: false
+  - name: polkadot-parachain-bin
+    bump: minor
+    validate: false
diff --git a/prdoc/1.13.0/pr_4621.prdoc b/prdoc/1.13.0/pr_4621.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..ebc06b92b39c3bf2956f0db71a790acd08f291a9
--- /dev/null
+++ b/prdoc/1.13.0/pr_4621.prdoc
@@ -0,0 +1,43 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Change XcmDryRunApi::dry_run_extrinsic to take a call instead
+
+doc:
+  - audience: Runtime User
+    description: |
+      The XcmDryRunApi now dry-run calls instead of extrinsics.
+      This means it's possible to dry-run an extrinsic before signing it,
+      allowing for seamless dry-running in dapps.
+      Additionally, calls can now be dry-run for different accounts.
+  - audience: Runtime Dev
+    description: |
+      The XcmDryRunApi::dry_run_extrinsic function was replaced by
+      XcmDryRunApi::dry_run_call.
+      This new function takes an origin (OriginCaller, the encodable inner variant)
+      and a call instead of an extrinsic.
+      This was needed to not require the user signing twice, once for the dry-run and
+      a second time to actually submit the extrinsic.
+      Additionally, calls can now be dry-run for different accounts.
+      The implementation for this runtime API is now simpler, being `call.dispatch(origin.into())`
+      instead of using the `Executive`.
+
+crates:
+  - name: xcm-fee-payment-runtime-api
+    bump: major
+  - name: penpal-runtime
+    bump: major
+  - name: xcm-emulator
+    bump: minor
+  - name: polkadot-service
+    bump: major
+  - name: rococo-runtime
+    bump: major
+  - name: westend-runtime
+    bump: major
+  - name: asset-hub-rococo-runtime
+    bump: major
+  - name: asset-hub-westend-runtime
+    bump: major
+  - name: pallet-xcm
+    bump: minor
diff --git a/prdoc/1.13.0/pr_4633.prdoc b/prdoc/1.13.0/pr_4633.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..f239191cc1985a531833e9a1a47a0d22bfce21f2
--- /dev/null
+++ b/prdoc/1.13.0/pr_4633.prdoc
@@ -0,0 +1,8 @@
+title: "Unify dependency aliases"
+
+doc:
+  - audience: [Runtime Dev, Node Dev]
+    description: |
+      Changes the re-export names of some crates but does not do any logic changes.
+
+crates: [ ]
diff --git a/prdoc/1.13.0/pr_4634.prdoc b/prdoc/1.13.0/pr_4634.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..0c16dedeae16e4cba3b0e69029abaf213771aade
--- /dev/null
+++ b/prdoc/1.13.0/pr_4634.prdoc
@@ -0,0 +1,34 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Implement XcmPaymentApi and DryRunApi on all system parachains
+
+doc:
+  - audience: Runtime User
+    description: |
+      The new XcmPaymentApi and DryRunApi have been implement on all westend and rococo system parachains.
+      You can test them out.
+  - audience: Runtime Dev
+    description: |
+      The new XcmPaymentApi and DryRunApi have been implement on all westend and rococo system parachains.
+      These can be used to build UIs that estimate XCM execution and sending, using libraries like PAPI or PJS.
+
+crates:
+  - name: bridge-hub-rococo-runtime
+    bump: minor
+  - name: bridge-hub-westend-runtime
+    bump: minor
+  - name: collectives-westend-runtime
+    bump: minor
+  - name: contracts-rococo-runtime
+    bump: minor
+  - name: coretime-rococo-runtime
+    bump: minor
+  - name: coretime-westend-runtime
+    bump: minor
+  - name: people-rococo-runtime
+    bump: minor
+  - name: people-westend-runtime
+    bump: minor
+  - name: penpal-runtime
+    bump: minor
diff --git a/prdoc/1.13.0/pr_4645.prdoc b/prdoc/1.13.0/pr_4645.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..1bc65f02ea578dace067b21f05cc298d448dffb4
--- /dev/null
+++ b/prdoc/1.13.0/pr_4645.prdoc
@@ -0,0 +1,16 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: make all storage items in parachain-system public
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      All storage items in cumulus-pallet-parachain-systemare now public. This allows
+      the usage of these storage items from within other runtime-pallets
+      or the runtime itself. For instance, it should allow to read the latests
+      relay state proof to read a certain well-known-key.
+
+crates:
+  - name: cumulus-pallet-parachain-system
+    bump: minor
\ No newline at end of file
diff --git a/prdoc/1.13.0/pr_4646.prdoc b/prdoc/1.13.0/pr_4646.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..0252deb57bddaf84414a2f241a1d3749b78eecd5
--- /dev/null
+++ b/prdoc/1.13.0/pr_4646.prdoc
@@ -0,0 +1,20 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: "[Identity] Remove double encoding username signature payload"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      The signature payload for setting a username for an account in `pallet-identity` is now just
+      the raw bytes of said username (still including the suffix), removing the need to first
+      encode these bytes before signing.
+  - audience: Runtime User
+    description: |
+      The signature payload for setting a username for an account in `pallet-identity` is now just
+      the raw bytes of said username (still including the suffix), removing the need to first
+      encode these bytes before signing.
+
+crates:
+  - name: pallet-identity
+    bump: major
diff --git a/prdoc/1.13.0/pr_4721.prdoc b/prdoc/1.13.0/pr_4721.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..730ac4d8308692001c20f30a89276af26a1b14ce
--- /dev/null
+++ b/prdoc/1.13.0/pr_4721.prdoc
@@ -0,0 +1,19 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Skip tree route calculation if no forks present
+
+doc:
+  - audience: Node Operator
+    description: |
+      Fixes an issue with synchronisation on parachains. Once they reached the tip of the chain,
+      nodes would show `Preparing  0.0 bps`. This is shown because the node is blocked on calculating
+      the tree route from genesis to the tip of the chain many times. This PR solves that by skipping
+      tree route calculation if there is only one leave. In addition, further optimizations have been
+      done to alleviate long finalization distances.
+
+crates:
+  - name: sp-blockchain
+    bump: minor
+  - name: sc-client-db
+    bump: none
diff --git a/prdoc/pr_3374.prdoc b/prdoc/pr_3374.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..76744f778db0a5bf5ba259ec2978d4b7e8d4e9b6
--- /dev/null
+++ b/prdoc/pr_3374.prdoc
@@ -0,0 +1,13 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: removed `pallet::getter` from `pallet-timestamp`
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      This PR removes all the `pallet::getter` usages from `pallet-timestamp`, and updates depdendant runtimes accordingly.
+      The syntax `StorageItem::<T, I>::get()` should be used instead.
+
+crates: 
+  - name: pallet-timestamp
\ No newline at end of file
diff --git a/prdoc/pr_3679.prdoc b/prdoc/pr_3679.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..86c1e9beafe99bfbc36e5308fb0f10b74841dc6c
--- /dev/null
+++ b/prdoc/pr_3679.prdoc
@@ -0,0 +1,14 @@
+title: "[pallet-contracts] bump wasmi to 0.32"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      - Bump wasmi to 0.32
+      - Turn on lazy and unchecked compilation when calling a contract.
+      See https://docs.rs/wasmi/0.32.0/wasmi/enum.CompilationMode.html#variant.Lazy
+      See https://docs.rs/wasmi/0.32.0/wasmi/struct.Module.html#method.new_unchecked
+      See https://wasmi-labs.github.io/blog/posts/wasmi-v0.32 for more details, on the wasmi update.
+
+crates:
+  - name: pallet-contracts
+  - name: pallet-contracts-proc-macro
diff --git a/prdoc/pr_3820.prdoc b/prdoc/pr_3820.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..33e8129df92a3c045f88531f40ee2d1793e591ab
--- /dev/null
+++ b/prdoc/pr_3820.prdoc
@@ -0,0 +1,32 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Remove deprecated calls from treasury pallet
+
+doc:
+  - audience: Runtime User
+    description: |
+      This PR remove deprecated calls, relevant tests from `pallet-treasury`.
+      - Remove deprecated calls `propose_spend`, `reject_proposal`, `approve_proposal`.
+      - Replace the code flow of `propose_spend` then `approve_proposal` with `spend_local`
+      - Remove deprecated calls' related weight functions and test cases.
+      - Remove deprecated parameter types: ProposalBond, ProposalBondMaximum, ProposalBondMinimum
+      - Remove pallet treasury's relevant deprecated code in pallet-tips, pallet-bounties and pallet-child-bounties
+
+crates:
+  - name: pallet-treasury
+    bump: major
+  - name: pallet-tips
+    bump: patch
+  - name: pallet-child-bounties
+    bump: patch
+  - name: pallet-bounties
+    bump: patch
+  - name: polkadot-runtime-common
+    bump: patch
+  - name: rococo-runtime
+    bump: patch
+  - name: westend-runtime
+    bump: patch
+  - name: collectives-westend-runtime
+    bump: patch
diff --git a/prdoc/pr_3843.prdoc b/prdoc/pr_3843.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..e01900dcc25b998124a2929f14171d049c2fa698
--- /dev/null
+++ b/prdoc/pr_3843.prdoc
@@ -0,0 +1,17 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Introduce a new dispatchable function `set_partial_params` in `pallet-core-fellowship`
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      This PR adds a new dispatchable function `set_partial_params` 
+      to update config with multiple arguments without duplicating the 
+      fields that does not need to update.
+
+crates:
+  - name: pallet-core-fellowship
+    bump: major
+  - name: collectives-westend-runtime
+    bump: patch
diff --git a/prdoc/pr_3951.prdoc b/prdoc/pr_3951.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..3a8096e6f448748e090cf0732a7b453fafcb6239
--- /dev/null
+++ b/prdoc/pr_3951.prdoc
@@ -0,0 +1,30 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Pallet Assets Freezer
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      This pallet is an extension of `pallet-assets`, supporting  
+      freezes similar to `pallet-balances`. 
+      To use this pallet, set `Freezer` of `pallet-assets` Config to the according instance of
+      `pallet-assets-freezer`.
+  - audience: Runtime User
+    description: |
+      The storage of this pallet contains a Vecs of account freezes. Applications UIs and Developer
+      Tools might benefit from observing it.
+
+crates:
+  - name: frame-support
+    bump: minor
+  - name: pallet-assets-freezer
+    bump: major
+  - name: pallet-assets
+    bump: patch
+  - name: pallet-balances
+    bump: patch
+  - name: asset-hub-rococo-runtime
+    bump: minor
+  - name: asset-hub-westend-runtime
+    bump: minor
diff --git a/prdoc/pr_4596.prdoc b/prdoc/pr_4596.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..d47aa3aedfb85abcae3bd76f0d0abe31d544816b
--- /dev/null
+++ b/prdoc/pr_4596.prdoc
@@ -0,0 +1,18 @@
+title: "Frame: `Consideration` trait generic over `Footprint` and handles zero cost"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      `Consideration` trait generic over `Footprint` and can handle zero cost for a give footprint.
+
+      `Consideration` trait is generic over `Footprint` (currently defined over the type with the same name). This makes it possible to setup a custom footprint (e.g. current number of proposals in the storage).
+
+      `Consideration::new` and `Consideration::update` return an `Option<Self>` instead `Self`, this make it possible to define no cost for a specific footprint (e.g. current number of proposals in the storage < max_proposal_count / 2).
+
+crates:
+  - name: frame-support
+    bump: major
+  - name: pallet-preimage
+    bump: major
+  - name: pallet-balances
+    bump: patch
diff --git a/prdoc/pr_4618.prdoc b/prdoc/pr_4618.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..3dd0fce81eeee54a411aef89442c233da204af68
--- /dev/null
+++ b/prdoc/pr_4618.prdoc
@@ -0,0 +1,20 @@
+title: Unify logic for fetching the `:code` of a block
+
+doc:
+  - audience: Node Operator
+    description: |
+      Fixes an issue on parachains when running with a custom `substitute` of the on chain wasm code
+      and having replaced the wasm code on the relay chain. The relay chain was rejecting blocks
+      build this way, because the collator was reporting the actual on chain wasm code hash
+      to the relay chain. However, the relay chain was expecting the code hash of the wasm code substitute
+      that was also registered on the relay chain.
+  - audience: Node Dev
+    description: |
+      `Client::code_at` will now use the same `substitute` to determine the code for a given block as it is
+      done when executing any runtime call.
+
+crates:
+  - name: cumulus-client-consensus-aura
+    bump: minor
+  - name: sc-service
+    bump: minor
diff --git a/prdoc/pr_4662.prdoc b/prdoc/pr_4662.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..50f8a5bfd011077cc218e6bcb6978cf7038ce25f
--- /dev/null
+++ b/prdoc/pr_4662.prdoc
@@ -0,0 +1,17 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Cleanup PVF artifact by cache limit and stale time
+
+doc:
+  - audience: Node Operator
+    description: |
+      Extend the PVF artifacts cleanup strategy. Previously, we pruned artifacts that were stale more than 24 hours.
+      After this change we attempt pruning artifacts only when they reach the 10 GB cache limit. If the least used
+      artifact is stale less than 24 hours we don't remove it.
+
+crates:
+  - name: polkadot-node-core-pvf-common
+    bump: patch
+  - name: polkadot-node-core-pvf
+    bump: patch
diff --git a/prdoc/pr_4684.prdoc b/prdoc/pr_4684.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..b1c429c57822494cd11f75beea93c4dabf2764cb
--- /dev/null
+++ b/prdoc/pr_4684.prdoc
@@ -0,0 +1,13 @@
+title: "Refactor of the parachain template"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Introduce the construct runtime V2 to the parachain template runtime. In addition, url links in the parachain pallet
+      template now direct to the polkadot sdk docs.
+
+crates:
+  - name: pallet-parachain-template
+    bump: none
+  - name: parachain-template-runtime
+    bump: none
diff --git a/prdoc/pr_4691.prdoc b/prdoc/pr_4691.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..18cbb2296d43b5c72e04b3de926da5d29b6c716a
--- /dev/null
+++ b/prdoc/pr_4691.prdoc
@@ -0,0 +1,14 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Fix claim queue size
+
+doc:
+  - audience: Runtime User
+    description: |
+      Ensure claim queue size is always the number configured by ` scheduler_params.lookahead`. Previously the claim queue of a core was shortened by 1 if the core was occupied.
+
+
+crates:
+  - name: polkadot-runtime-parachains
+    bump: minor
diff --git a/prdoc/pr_4710.prdoc b/prdoc/pr_4710.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..d7d31d817208a44402c53d2941750108c250f683
--- /dev/null
+++ b/prdoc/pr_4710.prdoc
@@ -0,0 +1,11 @@
+title: "Dont partially modify HRMP pages"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      The xcmp-queue pallet now does not partially modify a page anymore when the next message does
+      not fully fit into it but instead cleanly creates a new one.
+
+crates:
+  - name: cumulus-pallet-xcmp-queue
+    bump: patch
diff --git a/prdoc/pr_4724.prdoc b/prdoc/pr_4724.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..3723c2a70246ad40ad139c4da6e770fd386996f4
--- /dev/null
+++ b/prdoc/pr_4724.prdoc
@@ -0,0 +1,24 @@
+title: Fix core sharing and make use of scheduling_lookahead during backing
+
+doc:
+  - audience: Node Dev
+    description: |
+      Core sharing (two or more parachains scheduled on the same core with interlaced assignments) was not working correctly.
+      Adds the neccessary fixes to the backing subsystems. Moreover, adds support for backing collations which are built
+      and advertised ahead of time (with up to `scheduling_lookahead` relay chain blocks in advance).
+
+crates:
+  - name: polkadot-node-core-backing
+    bump: patch
+  - name: polkadot-node-core-prospective-parachains
+    bump: patch
+  - name: polkadot-collator-protocol
+    bump: patch
+  - name: polkadot-statement-distribution
+    bump: patch
+  - name: polkadot-node-subsystem-util
+    bump: minor
+  - name: polkadot-runtime-parachains
+    bump: none
+  - name: polkadot
+    bump: none
diff --git a/prdoc/pr_4728.prdoc b/prdoc/pr_4728.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..1494fbdbb2b9fb2a534e3fa47d13ee46996b180d
--- /dev/null
+++ b/prdoc/pr_4728.prdoc
@@ -0,0 +1,17 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: "Glutton - add support for bloating the parachain block length"
+
+doc:
+  - audience: [Runtime Dev, Runtime User]
+    description: |
+      Introduce a new configuration parameter `block_length` which can be configured via a call to
+      `set_block_length`. This sets the ration of the block length that is to be filled with trash.
+      This is implemented by an inherent that takes trash data as a parameter filling the block length.
+ 
+crates:
+  - name: pallet-glutton
+    bump: major
+  - name: glutton-westend-runtime
+    bump: major
diff --git a/prdoc/pr_4733.prdoc b/prdoc/pr_4733.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..e633248398526c43fc0da478779c4fea86524e7a
--- /dev/null
+++ b/prdoc/pr_4733.prdoc
@@ -0,0 +1,27 @@
+title: Add pov-recovery unit tests and support for elastic scaling
+
+doc:
+  - audience: Node Dev
+    description: |
+      Adds unit tests for cumulus pov-recovery and support for elastic scaling (recovering multiple candidates in a single relay chain block).
+
+crates:
+  - name: cumulus-client-network
+    bump: patch
+  - name: cumulus-client-pov-recovery
+    bump: patch
+  - name: cumulus-relay-chain-interface
+    bump: major
+    validate: false
+  - name: cumulus-relay-chain-inprocess-interface
+    bump: minor
+  - name: cumulus-relay-chain-rpc-interface
+    bump: minor
+  - name: cumulus-client-consensus-common
+    bump: none
+  - name: sc-client-api
+    bump: minor
+  - name: sp-blockchain
+    bump: minor
+  - name: sp-consensus
+    bump: minor
diff --git a/prdoc/pr_4756.prdoc b/prdoc/pr_4756.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..064a79fb06648a39c6983c92a80028fff093355d
--- /dev/null
+++ b/prdoc/pr_4756.prdoc
@@ -0,0 +1,15 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Do not make pallet-nfts benchmarks signature-dependent
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      - Adds extra functionality to pallet-nfts's BenchmarkHelper to provide signers and sign message.
+      - Abstracts away the explicit link with Sr25519 schema in the benchmarks, allowing parachains with a different one to be able to run them and calculate the weights.
+      - Adds a default implementation for the empty tuple that leaves the code equivalent.
+
+crates:
+    - name: pallet-nfts
+      bump: minor
diff --git a/prdoc/pr_4765.prdoc b/prdoc/pr_4765.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..f64b2fdc51ab12c59aac8a247bf69026dffb9bf1
--- /dev/null
+++ b/prdoc/pr_4765.prdoc
@@ -0,0 +1,18 @@
+title: CheckWeight - account for extrinsic len as proof size
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      This changes how CheckWeight extension works. It will now account for the extrinsic length
+      as proof size. When `on_idle` is called, the remaining weight parameter reflects this.
+
+crates:
+  - name: frame-system
+    bump: patch
+  - name: frame-executive
+    bump: none
+  - name: cumulus-primitives-storage-weight-reclaim
+    bump: none
+
+
+
diff --git a/prdoc/pr_4802.prdoc b/prdoc/pr_4802.prdoc
new file mode 100644
index 0000000000000000000000000000000000000000..5757c4cbae184444d4eb78b620bcef50a3b0e133
--- /dev/null
+++ b/prdoc/pr_4802.prdoc
@@ -0,0 +1,16 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Add `health/readiness endpoint` to the rpc server
+
+doc:
+  - audience: Node Operator
+    description: |
+      Add `/health/readiness endpoint` to the rpc server which returns HTTP status code 200 if the chain is synced
+      and can connect to the rest of the network otherwise status code 500 is returned.
+      The endpoint can be reached by performing a HTTP GET request to the
+      endpoint such as `$ curl <endpoint>/health/readiness`
+
+crates:
+  - name: sc-rpc-server
+    bump: patch
diff --git a/prdoc/schema_user.json b/prdoc/schema_user.json
index 294005f209d57d719816a40132ea7f5d49b3d029..e6c0468aaf8517956501324dc4ba087b444bb424 100644
--- a/prdoc/schema_user.json
+++ b/prdoc/schema_user.json
@@ -218,7 +218,7 @@
       },
       "doc": {
         "type": "object",
-        "description": "You have the the option to provide different description of your PR for different audiences.",
+        "description": "You have the option to provide different description of your PR for different audiences.",
         "additionalProperties": false,
         "properties": {
           "audience": {
diff --git a/scripts/bench-all.sh b/scripts/bench-all.sh
new file mode 100755
index 0000000000000000000000000000000000000000..e5512e26bbad75248f2983a2e3a653e3d1328435
--- /dev/null
+++ b/scripts/bench-all.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+set -eu -o pipefail
+shopt -s inherit_errexit
+shopt -s globstar
+
+. "$(realpath "$(dirname "${BASH_SOURCE[0]}")/command-utils.sh")"
+
+get_arg optional --pallet "$@"
+PALLET="${out:-""}"
+
+if [[ ! -z "$PALLET" ]]; then
+  . "$(dirname "${BASH_SOURCE[0]}")/lib/bench-all-pallet.sh" "$@"
+else
+  . "$(dirname "${BASH_SOURCE[0]}")/bench.sh" --subcommand=all "$@"
+fi
diff --git a/scripts/bench.sh b/scripts/bench.sh
new file mode 100755
index 0000000000000000000000000000000000000000..2f4ef7ec6a14118630964a835d181d9631a0c605
--- /dev/null
+++ b/scripts/bench.sh
@@ -0,0 +1,117 @@
+#!/bin/bash
+# Initially based on https://github.com/paritytech/bench-bot/blob/cd3b2943d911ae29e41fe6204788ef99c19412c3/bench.js
+
+# Most external variables used in this script, such as $GH_CONTRIBUTOR, are
+# related to https://github.com/paritytech/try-runtime-bot
+
+# This script relies on $GITHUB_TOKEN which is probably a protected GitLab CI
+# variable; if this assumption holds true, it is implied that this script should
+# be ran only on protected pipelines
+
+set -eu -o pipefail
+shopt -s inherit_errexit
+
+# realpath allows to reuse the current
+BENCH_ROOT_DIR=$(realpath "$(dirname "${BASH_SOURCE[0]}")")
+
+. "$(realpath "$(dirname "${BASH_SOURCE[0]}")/command-utils.sh")"
+
+repository_name="$(basename "$PWD")"
+
+get_arg optional --target_dir "$@"
+target_dir="${out:-""}"
+
+get_arg optional --noexit "$@"
+noexit="${out:-""}"
+
+output_path="."
+
+profile="production"
+
+if [[ "$repository_name" == "polkadot-sdk" ]]; then
+  output_path="./$target_dir"
+fi
+
+cargo_run_benchmarks="cargo run --quiet --profile=${profile}"
+
+echo "Repository: $repository_name"
+echo "Target Dir: $target_dir"
+echo "Output Path: $output_path"
+
+cargo_run() {
+  echo "Running $cargo_run_benchmarks" "${args[@]}"
+
+  # if not patched with PATCH_something=123 then use --locked
+  if [[ -z "${BENCH_PATCHED:-}" ]]; then
+    cargo_run_benchmarks+=" --locked"
+  fi
+
+  $cargo_run_benchmarks "${args[@]}"
+}
+
+
+main() {
+
+  # Remove the "github" remote since the same repository might be reused by a
+  # GitLab runner, therefore the remote might already exist from a previous run
+  # in case it was not cleaned up properly for some reason
+  &>/dev/null git remote remove github || :
+
+  tmp_dirs=()
+  cleanup() {
+    exit_code=$?
+    # Clean up the "github" remote at the end since it contains the
+    # $GITHUB_TOKEN secret, which is only available for protected pipelines on
+    # GitLab
+    &>/dev/null git remote remove github || :
+    rm -rf "${tmp_dirs[@]}"
+    echo "Done, exit: $exit_code"
+    exit $exit_code
+  }
+
+  # avoid exit if --noexit is passed
+  if [ -z "$noexit" ]; then
+    trap cleanup EXIT
+  fi
+
+  # set -x
+
+  get_arg required --subcommand "$@"
+  local subcommand="${out:-""}"
+
+  case "$subcommand" in
+    runtime|pallet|xcm)
+      echo 'Running bench_pallet'
+      . "$BENCH_ROOT_DIR/lib/bench-pallet.sh" "$@"
+    ;;
+    overhead)
+      echo 'Running bench_overhead'
+      . "$BENCH_ROOT_DIR/lib/bench-overhead.sh" "$@"
+    ;;
+    all)
+      echo "Running all-$target_dir"
+      . "$BENCH_ROOT_DIR/lib/bench-all-${target_dir}.sh" "$@"
+    ;;
+    *)
+      die "Invalid subcommand $subcommand to process_args"
+    ;;
+  esac
+
+  # set +x
+
+  # in case we used diener to patch some dependency during benchmark execution,
+  # revert the patches so that they're not included in the diff
+  git checkout --quiet HEAD Cargo.toml
+
+  # Save the generated weights to GitLab artifacts in case commit+push fails
+  echo "Showing weights diff for command"
+  git diff -P | tee -a "${ARTIFACTS_DIR}/weights.patch"
+  echo "Wrote weights patch to \"${ARTIFACTS_DIR}/weights.patch\""
+
+
+  # instead of using `cargo run --locked`, we allow the Cargo files to be updated
+  # but avoid committing them. It is so `cmd_runner_apply_patches` can work
+  git restore --staged Cargo.*
+}
+
+main "$@"
diff --git a/scripts/command-utils.sh b/scripts/command-utils.sh
new file mode 100644
index 0000000000000000000000000000000000000000..252e4c86480e6b259af8a46038e1b9e0658e70fb
--- /dev/null
+++ b/scripts/command-utils.sh
@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+
+if [ "${LOADED_UTILS_SH:-}" ]; then
+  return
+else
+  export LOADED_UTILS_SH=true
+fi
+
+export ARTIFACTS_DIR="$PWD/.git/.artifacts"
+
+die() {
+  if [ "${1:-}" ]; then
+    >&2 echo "$1"
+  fi
+  exit 1
+}
+
+get_arg() {
+  local arg_type="$1"
+  shift
+
+  local is_required
+  case "$arg_type" in
+    required|required-many)
+      is_required=true
+    ;;
+    optional|optional-many) ;;
+    *)
+      die "Invalid is_required argument \"$2\" in get_arg"
+    ;;
+  esac
+
+  local has_many_values
+  if [ "${arg_type: -6}" == "-many" ]; then
+    has_many_values=true
+  fi
+
+  local option_arg="$1"
+  shift
+
+  local args=("$@")
+
+  unset out
+  out=()
+
+  local get_next_arg
+  for arg in "${args[@]}"; do
+    if [ "${get_next_arg:-}" ]; then
+      out+=("$arg")
+      unset get_next_arg
+      if [ ! "${has_many_values:-}" ]; then
+        break
+      fi
+    # --foo=bar (get the value after '=')
+    elif [ "${arg:0:$(( ${#option_arg} + 1 ))}" == "$option_arg=" ]; then
+      out+=("${arg:$(( ${#option_arg} + 1 ))}")
+      if [ ! "${has_many_values:-}" ]; then
+        break
+      fi
+    # --foo bar (get the next argument)
+    elif [ "$arg" == "$option_arg" ]; then
+      get_next_arg=true
+    fi
+  done
+
+  # arg list ended with --something but no argument was provided next
+  if [ "${get_next_arg:-}" ]; then
+    die "Expected argument after \"${args[-1]}"\"
+  fi
+
+  if [ "${out[0]:-}" ]; then
+    if [ ! "${has_many_values:-}" ]; then
+      out="${out[0]}"
+    fi
+  elif [ "${is_required:-}" ]; then
+    die "Argument $option_arg is required, but was not found"
+  else
+    unset out
+  fi
+}
diff --git a/scripts/generate-umbrella.py b/scripts/generate-umbrella.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bdf160e63b176c6981ec18d8b72ee8782dd0e8b
--- /dev/null
+++ b/scripts/generate-umbrella.py
@@ -0,0 +1,204 @@
+"""
+
+Creates the Polkadot-SDK umbrella crate that re-exports all other crates.
+
+This re-creates the `umbrella/` folder. Ensure that it does not contain any changes you want to keep.
+
+Usage:
+    python3 polkadot-sdk-umbrella-crate.py --sdk <path> --version <version>
+
+Example:
+	python3 polkadot-sdk-umbrella-crate.py --sdk ../polkadot-sdk --version 1.11.0
+"""
+
+import argparse
+import os
+import re
+import toml
+import shutil
+
+from cargo_workspace import Workspace
+
+"""
+Crate names that should be excluded from the umbrella crate.
+"""
+def exclude(crate):
+	name = crate.name
+	if crate.metadata.get("polkadot-sdk.skip-umbrella", False):
+		return True
+
+	# No fuzzers or examples:
+	if "example" in name or name.endswith("fuzzer"):
+		return True
+	# No runtime crates:
+	if name.endswith("-runtime"):
+		# Note: this is a bit hacky. We should use custom crate metadata instead.
+		return name != "sp-runtime" and name != "bp-runtime" and name != "frame-try-runtime"
+
+	return False
+
+def main(path, version):
+	delete_umbrella(path)
+	workspace = Workspace.from_path(path)
+	print(f'Indexed {workspace}')
+
+	std_crates = [] # name -> path. use list for sorting
+	nostd_crates = []
+	for crate in workspace.crates:
+		if crate.name == 'polkadot-sdk':
+			continue
+		if not crate.publish:
+			print(f"Skipping {crate.name} as it is not published")
+			continue
+
+		lib_path = os.path.dirname(crate.abs_path)
+		manifest_path = os.path.join(lib_path, "Cargo.toml")
+		lib_path = os.path.join(lib_path, "src", "lib.rs")
+		path = os.path.dirname(crate.rel_path)
+
+		# Guess which crates support no_std. Proc-macro crates are always no_std:
+		with open(manifest_path, "r") as f:
+			manifest = toml.load(f)
+			if 'lib' in manifest and 'proc-macro' in manifest['lib']:
+				if manifest['lib']['proc-macro']:
+					nostd_crates.append((crate, path))
+					continue
+		
+		# Crates without a lib.rs cannot be no_std
+		if not os.path.exists(lib_path):
+			print(f"Skipping {crate.name} as it does not have a 'src/lib.rs'")
+			continue
+		if exclude(crate):
+			print(f"Skipping {crate.name} as it is in the exclude list")
+			continue
+
+		# No search for a no_std attribute:
+		with open(lib_path, "r") as f:
+			content = f.read()
+			if "#![no_std]" in content or '#![cfg_attr(not(feature = "std"), no_std)]' in content:
+				nostd_crates.append((crate, path))
+			elif 'no_std' in content:
+				raise Exception(f"Found 'no_std' in {lib_path} without knowing how to handle it")
+			else:
+				std_crates.append((crate, path))
+
+	# Sort by name
+	std_crates.sort(key=lambda x: x[0].name)
+	nostd_crates.sort(key=lambda x: x[0].name)
+	all_crates = std_crates + nostd_crates
+	all_crates.sort(key=lambda x: x[0].name)
+	dependencies = {}
+
+	for (crate, path) in nostd_crates:
+		dependencies[crate.name] = {"path": f"../{path}", "default-features": False, "optional": True}
+	
+	for (crate, path) in std_crates:
+		dependencies[crate.name] = {"path": f"../{path}", "default-features": False, "optional": True}
+	
+	# The empty features are filled by Zepter
+	features = {
+		"default": [ "std" ],
+		"std": [],
+		"runtime-benchmarks": [],
+		"try-runtime": [],
+		"serde": [],
+		"experimental": [],
+		"with-tracing": [],
+		"runtime": list([f"{d.name}" for d, _ in nostd_crates]),
+		"node": ["std"] + list([f"{d.name}" for d, _ in std_crates]),
+		"tuples-96": [],
+	}
+
+	manifest = {
+		"package": {
+			"name": "polkadot-sdk",
+			"version": version,
+			"edition": { "workspace": True },
+			"authors": { "workspace": True },
+			"description": "Polkadot SDK umbrella crate.",
+			"license": "Apache-2.0",
+			"metadata": { "docs": { "rs": {
+				"features": ["runtime", "node"],
+				"targets": ["x86_64-unknown-linux-gnu"]
+			}}}
+		},
+		"dependencies": dependencies,
+		"features": features,
+	}
+
+	umbrella_dir = os.path.join(workspace.path, "umbrella")
+	manifest_path = os.path.join(umbrella_dir, "Cargo.toml")
+	lib_path = os.path.join(umbrella_dir, "src", "lib.rs")
+	# create all dir
+	os.makedirs(os.path.dirname(lib_path), exist_ok=True)
+	# Write the manifest
+	with open(manifest_path, "w") as f:
+		toml_manifest = toml.dumps(manifest)
+		f.write(toml_manifest)
+		print(f"Wrote {manifest_path}")
+	# and the lib.rs
+	with open(lib_path, "w") as f:
+		f.write('''// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+//! Polkadot SDK umbrella crate re-exporting all other published crates.
+//!
+//! This helps to set a single version number for all your dependencies. Docs are in the
+//! `polkadot-sdk-docs` crate.
+
+// This file is auto-generated and checked by the CI.  You can edit it manually, but it must be
+// exactly the way that the CI expects it.
+''')
+
+		for crate, _ in all_crates:
+			use = crate.name.replace("-", "_")
+			desc = crate.description if crate.description.endswith(".") else crate.description + "."
+			f.write(f'\n/// {desc}')
+			f.write(f'\n#[cfg(feature = "{crate.name}")]\n')
+			f.write(f"pub use {use};\n")
+		
+		print(f"Wrote {lib_path}")
+	
+	add_to_workspace(workspace.path)
+
+"""
+Delete the umbrella folder and remove the umbrella crate from the workspace.
+"""
+def delete_umbrella(path):
+	umbrella_dir = os.path.join(path, "umbrella")
+	# remove the umbrella crate from the workspace
+	manifest = os.path.join(path, "Cargo.toml")
+	manifest = open(manifest, "r").read()
+	manifest = re.sub(r'\s+"umbrella",\n', "", manifest)
+	with open(os.path.join(path, "Cargo.toml"), "w") as f:
+		f.write(manifest)
+	if os.path.exists(umbrella_dir):
+		print(f"Deleting {umbrella_dir}")
+		shutil.rmtree(umbrella_dir)
+
+"""
+Create the umbrella crate and add it to the workspace.
+"""
+def add_to_workspace(path):
+	manifest = os.path.join(path, "Cargo.toml")
+	manifest = open(manifest, "r").read()
+	manifest = re.sub(r'^members = \[', 'members = [\n        "umbrella",', manifest, flags=re.M)
+	with open(os.path.join(path, "Cargo.toml"), "w") as f:
+		f.write(manifest)
+	
+	os.chdir(path) # hack
+	os.system("cargo metadata --format-version 1 > /dev/null") # update the lockfile
+	os.system(f"zepter") # enable the features
+	os.system(f"taplo format --config .config/taplo.toml Cargo.toml umbrella/Cargo.toml")
+
+def parse_args():
+	parser = argparse.ArgumentParser(description="Create a polkadot-sdk crate")
+	parser.add_argument("--sdk", type=str, default="polkadot-sdk", help="Path to the polkadot-sdk crate")
+	parser.add_argument("--version", type=str, help="Version of the polkadot-sdk crate")
+	return parser.parse_args()
+
+if __name__ == "__main__":
+	args = parse_args()
+	main(args.sdk, args.version)
diff --git a/scripts/lib/bench-all-cumulus.sh b/scripts/lib/bench-all-cumulus.sh
new file mode 100755
index 0000000000000000000000000000000000000000..f4c2a35c6b6b7ed8d30fa058666453f5c321b8e1
--- /dev/null
+++ b/scripts/lib/bench-all-cumulus.sh
@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# originally moved from https://github.com/paritytech/cumulus/blob/445f9277ab55b4d930ced4fbbb38d27c617c6658/scripts/benchmarks-ci.sh
+
+# default RUST_LOG is warn, but could be overridden
+export RUST_LOG="${RUST_LOG:-error}"
+
+THIS_DIR=$(dirname "${BASH_SOURCE[0]}")
+. "$THIS_DIR/../command-utils.sh"
+
+POLKADOT_PARACHAIN="./target/$profile/polkadot-parachain"
+
+run_cumulus_bench() {
+  local artifactsDir="$ARTIFACTS_DIR"
+  local category=$1
+  local runtimeName=$2
+  local paraId=${3:-}
+
+  local benchmarkOutput="$output_path/parachains/runtimes/$category/$runtimeName/src/weights"
+  local benchmarkRuntimeChain
+  if [[ ! -z "$paraId" ]]; then
+     benchmarkRuntimeChain="${runtimeName}-dev-$paraId"
+  else
+     benchmarkRuntimeChain="$runtimeName-dev"
+  fi
+
+  local benchmarkMetadataOutputDir="$artifactsDir/$runtimeName"
+  mkdir -p "$benchmarkMetadataOutputDir"
+
+  # Load all pallet names in an array.
+  echo "[+] Listing pallets for runtime $runtimeName for chain: $benchmarkRuntimeChain ..."
+  local pallets=($(
+    $POLKADOT_PARACHAIN benchmark pallet --list --chain="${benchmarkRuntimeChain}" |\
+      tail -n+2 |\
+      cut -d',' -f1 |\
+      sort |\
+      uniq
+  ))
+
+  if [ ${#pallets[@]} -ne 0 ]; then
+    echo "[+] Benchmarking ${#pallets[@]} pallets for runtime $runtimeName for chain: $benchmarkRuntimeChain, pallets:"
+    for pallet in "${pallets[@]}"; do
+        echo "   [+] $pallet"
+    done
+  else
+    echo "$runtimeName pallet list not found in benchmarks-ci.sh"
+    exit 1
+  fi
+
+  for pallet in "${pallets[@]}"; do
+    # (by default) do not choose output_file, like `pallet_assets.rs` because it does not work for multiple instances
+    # `benchmark pallet` command will decide the output_file name if there are multiple instances
+    local output_file=""
+    local extra_args=""
+    # a little hack for pallet_xcm_benchmarks - we want to force custom implementation for XcmWeightInfo
+    if [[ "$pallet" == "pallet_xcm_benchmarks::generic" ]] || [[ "$pallet" == "pallet_xcm_benchmarks::fungible" ]]; then
+      output_file="xcm/${pallet//::/_}.rs"
+      extra_args="--template=$output_path/templates/xcm-bench-template.hbs"
+    fi
+    $POLKADOT_PARACHAIN benchmark pallet \
+      $extra_args \
+      --chain="${benchmarkRuntimeChain}" \
+      --wasm-execution=compiled \
+      --pallet="$pallet" \
+      --no-storage-info \
+      --no-median-slopes \
+      --no-min-squares \
+      --extrinsic='*' \
+      --steps=50 \
+      --repeat=20 \
+      --json \
+      --header="$output_path/file_header.txt" \
+      --output="${benchmarkOutput}/${output_file}" >> "$benchmarkMetadataOutputDir/${pallet//::/_}_benchmark.json"
+  done
+}
+
+
+echo "[+] Compiling benchmarks..."
+cargo build --profile $profile --locked --features=runtime-benchmarks -p polkadot-parachain-bin
+
+# Run benchmarks for all pallets of a given runtime if runtime argument provided
+get_arg optional --runtime "$@"
+runtime="${out:-""}"
+
+if [[ $runtime ]]; then
+  paraId=""
+  case "$runtime" in
+    asset-*)
+      category="assets"
+    ;;
+    collectives-*)
+      category="collectives"
+    ;;
+    coretime-*)
+      category="coretime"
+    ;;
+    bridge-*)
+      category="bridge-hubs"
+    ;;
+    contracts-*)
+      category="contracts"
+    ;;
+    people-*)
+      category="people"
+    ;;
+    glutton-*)
+      category="glutton"
+      paraId="1300"
+    ;;
+    *)
+      echo "Unknown runtime: $runtime"
+      exit 1
+    ;;
+  esac
+
+  run_cumulus_bench $category $runtime $paraId
+
+else # run all
+  # Assets
+  run_cumulus_bench assets asset-hub-rococo
+  run_cumulus_bench assets asset-hub-westend
+
+  # Collectives
+  run_cumulus_bench collectives collectives-westend
+
+  # Coretime
+  run_cumulus_bench coretime coretime-rococo
+  run_cumulus_bench coretime coretime-westend
+
+  # People
+  run_cumulus_bench people people-rococo
+  run_cumulus_bench people people-westend
+
+  # Bridge Hubs
+  run_cumulus_bench bridge-hubs bridge-hub-rococo
+  run_cumulus_bench bridge-hubs bridge-hub-westend
+
+  # Glutton
+  run_cumulus_bench glutton glutton-westend 1300
+fi
diff --git a/scripts/lib/bench-all-pallet.sh b/scripts/lib/bench-all-pallet.sh
new file mode 100644
index 0000000000000000000000000000000000000000..e6908045ddbd7f34ba7cad0e4c102e4606dff7aa
--- /dev/null
+++ b/scripts/lib/bench-all-pallet.sh
@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+
+set -eu -o pipefail
+shopt -s inherit_errexit
+shopt -s globstar
+
+. "$(dirname "${BASH_SOURCE[0]}")/../command-utils.sh"
+
+get_arg required --pallet "$@"
+PALLET="${out:-""}"
+
+REPO_NAME="$(basename "$PWD")"
+BASE_COMMAND="$(dirname "${BASH_SOURCE[0]}")/../../bench/bench.sh --noexit=true --subcommand=pallet"
+
+WEIGHT_FILE_PATHS=( $(find . -type f -name "${PALLET}.rs" -path "**/weights/*" | sed 's|^\./||g') )
+
+# convert pallet_ranked_collective to ranked-collective
+CLEAN_PALLET=$(echo $PALLET | sed 's/pallet_//g' | sed 's/_/-/g')
+
+# add substrate pallet weights to a list
+SUBSTRATE_PALLET_PATH=$(ls substrate/frame/$CLEAN_PALLET/src/weights.rs || :)
+if [ ! -z "${SUBSTRATE_PALLET_PATH}" ]; then
+  WEIGHT_FILE_PATHS+=("$SUBSTRATE_PALLET_PATH")
+fi
+
+# add trappist pallet weights to a list
+TRAPPIST_PALLET_PATH=$(ls pallet/$CLEAN_PALLET/src/weights.rs || :)
+if [ ! -z "${TRAPPIST_PALLET_PATH}" ]; then
+  WEIGHT_FILE_PATHS+=("$TRAPPIST_PALLET_PATH")
+fi
+
+COMMANDS=()
+
+if [ "${#WEIGHT_FILE_PATHS[@]}" -eq 0 ]; then
+  echo "No weights files found for pallet: $PALLET"
+  exit 1
+else
+  echo "Found weights files for pallet: $PALLET"
+fi
+
+for f in ${WEIGHT_FILE_PATHS[@]}; do
+  echo "- $f"
+  # f examples:
+  # cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_balances.rs
+  # polkadot/runtime/rococo/src/weights/pallet_balances.rs
+  # runtime/trappist/src/weights/pallet_assets.rs
+  TARGET_DIR=$(echo $f | cut -d'/' -f 1)
+
+  if [ "$REPO_NAME" == "polkadot-sdk" ]; then
+    case $TARGET_DIR in
+      cumulus)
+        TYPE=$(echo $f | cut -d'/' -f 2)
+        # Example: cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_balances.rs
+        if [ "$TYPE" == "parachains" ]; then
+          RUNTIME=$(echo $f | cut -d'/' -f 5)
+          RUNTIME_DIR=$(echo $f | cut -d'/' -f 4)
+          COMMANDS+=("$BASE_COMMAND --runtime=$RUNTIME --runtime_dir=$RUNTIME_DIR --target_dir=$TARGET_DIR --pallet=$PALLET")
+        fi
+        ;;
+      polkadot)
+        # Example: polkadot/runtime/rococo/src/weights/pallet_balances.rs
+        RUNTIME=$(echo $f | cut -d'/' -f 3)
+        COMMANDS+=("$BASE_COMMAND --runtime=$RUNTIME --target_dir=$TARGET_DIR --pallet=$PALLET")
+        ;;
+      substrate)
+        # Example: substrate/frame/contracts/src/weights.rs
+        COMMANDS+=("$BASE_COMMAND --target_dir=$TARGET_DIR --runtime=dev --pallet=$PALLET")
+        ;;
+      *)
+        echo "Unknown dir: $TARGET_DIR"
+        exit 1
+        ;;
+    esac
+  fi
+
+  if [ "$REPO_NAME" == "trappist" ]; then
+    case $TARGET_DIR in
+      runtime)
+        TYPE=$(echo $f | cut -d'/' -f 2)
+        if [ "$TYPE" == "trappist" || "$TYPE" == "stout" ]; then
+          # Example: runtime/trappist/src/weights/pallet_assets.rs
+          COMMANDS+=("$BASE_COMMAND --target_dir=trappist --runtime=$TYPE --pallet=$PALLET")
+        fi
+        ;;
+      *)
+        echo "Unknown dir: $TARGET_DIR"
+        exit 1
+        ;;
+    esac
+  fi
+done
+
+for cmd in "${COMMANDS[@]}"; do
+  echo "Running command: $cmd"
+  . $cmd
+done
diff --git a/scripts/lib/bench-all-polkadot.sh b/scripts/lib/bench-all-polkadot.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ac52e00140e38de76fe082aa3fd0aaf670b465bb
--- /dev/null
+++ b/scripts/lib/bench-all-polkadot.sh
@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# Runs all benchmarks for all pallets, for a given runtime, provided by $1
+# Should be run on a reference machine to gain accurate benchmarks
+# current reference machine: https://github.com/paritytech/polkadot/pull/6508/files
+# original source: https://github.com/paritytech/polkadot/blob/b9842c4b52f6791fef6c11ecd020b22fe614f041/scripts/run_all_benches.sh
+
+get_arg required --runtime "$@"
+runtime="${out:-""}"
+
+# default RUST_LOG is error, but could be overridden
+export RUST_LOG="${RUST_LOG:-error}"
+
+echo "[+] Compiling benchmarks..."
+cargo build --profile $profile --locked --features=runtime-benchmarks -p polkadot
+
+POLKADOT_BIN="./target/$profile/polkadot"
+
+# Update the block and extrinsic overhead weights.
+echo "[+] Benchmarking block and extrinsic overheads..."
+OUTPUT=$(
+  $POLKADOT_BIN benchmark overhead \
+  --chain="${runtime}-dev" \
+  --wasm-execution=compiled \
+  --weight-path="$output_path/runtime/${runtime}/constants/src/weights/" \
+  --warmup=10 \
+  --repeat=100 \
+  --header="$output_path/file_header.txt"
+)
+if [ $? -ne 0 ]; then
+  echo "$OUTPUT" >> "$ERR_FILE"
+  echo "[-] Failed to benchmark the block and extrinsic overheads. Error written to $ERR_FILE; continuing..."
+fi
+
+
+# Load all pallet names in an array.
+PALLETS=($(
+  $POLKADOT_BIN benchmark pallet --list --chain="${runtime}-dev" |\
+    tail -n+2 |\
+    cut -d',' -f1 |\
+    sort |\
+    uniq
+))
+
+echo "[+] Benchmarking ${#PALLETS[@]} pallets for runtime $runtime"
+
+# Define the error file.
+ERR_FILE="${ARTIFACTS_DIR}/benchmarking_errors.txt"
+# Delete the error file before each run.
+rm -f $ERR_FILE
+
+# Benchmark each pallet.
+for PALLET in "${PALLETS[@]}"; do
+  echo "[+] Benchmarking $PALLET for $runtime";
+
+  output_file=""
+  if [[ $PALLET == *"::"* ]]; then
+    # translates e.g. "pallet_foo::bar" to "pallet_foo_bar"
+    output_file="${PALLET//::/_}.rs"
+  fi
+
+  OUTPUT=$(
+    $POLKADOT_BIN benchmark pallet \
+    --chain="${runtime}-dev" \
+    --steps=50 \
+    --repeat=20 \
+    --no-storage-info \
+    --no-median-slopes \
+    --no-min-squares \
+    --pallet="$PALLET" \
+    --extrinsic="*" \
+    --execution=wasm \
+    --wasm-execution=compiled \
+    --header="$output_path/file_header.txt" \
+    --output="$output_path/runtime/${runtime}/src/weights/${output_file}" 2>&1
+  )
+  if [ $? -ne 0 ]; then
+    echo "$OUTPUT" >> "$ERR_FILE"
+    echo "[-] Failed to benchmark $PALLET. Error written to $ERR_FILE; continuing..."
+  fi
+done
+
+# Check if the error file exists.
+if [ -f "$ERR_FILE" ]; then
+  echo "[-] Some benchmarks failed. See: $ERR_FILE"
+else
+  echo "[+] All benchmarks passed."
+fi
diff --git a/scripts/lib/bench-all-substrate.sh b/scripts/lib/bench-all-substrate.sh
new file mode 100644
index 0000000000000000000000000000000000000000..eeb18cdd8bbb31ee58daa93b35e45cf2a1f33e86
--- /dev/null
+++ b/scripts/lib/bench-all-substrate.sh
@@ -0,0 +1,148 @@
+#!/usr/bin/env bash
+
+# This file is part of Substrate.
+# Copyright (C) 2022 Parity Technologies (UK) Ltd.
+# SPDX-License-Identifier: Apache-2.0
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This script has three parts which all use the Substrate runtime:
+# - Pallet benchmarking to update the pallet weights
+# - Overhead benchmarking for the Extrinsic and Block weights
+# - Machine benchmarking
+#
+# Should be run on a reference machine to gain accurate benchmarks
+# current reference machine: https://github.com/paritytech/substrate/pull/5848
+
+# Original source: https://github.com/paritytech/substrate/blob/ff9921a260a67e3a71f25c8b402cd5c7da787a96/scripts/run_all_benchmarks.sh
+# Fail if any sub-command in a pipe fails, not just the last one.
+set -o pipefail
+# Fail on undeclared variables.
+set -u
+# Fail if any sub-command fails.
+set -e
+# Fail on traps.
+# set -E
+
+# default RUST_LOG is warn, but could be overridden
+export RUST_LOG="${RUST_LOG:-error}"
+
+echo "[+] Compiling Substrate benchmarks..."
+cargo build --profile=$profile --locked --features=runtime-benchmarks -p staging-node-cli
+
+# The executable to use.
+SUBSTRATE="./target/$profile/substrate-node"
+
+# Manually exclude some pallets.
+EXCLUDED_PALLETS=(
+  # Helper pallets
+  "pallet_election_provider_support_benchmarking"
+  # Pallets without automatic benchmarking
+  "pallet_babe"
+  "pallet_grandpa"
+  "pallet_mmr"
+  "pallet_offences"
+  # Only used for testing, does not need real weights.
+  "frame_benchmarking_pallet_pov"
+  "pallet_example_tasks"
+  "pallet_example_basic"
+  "pallet_example_split"
+  "pallet_example_kitchensink"
+  "pallet_example_mbm"
+  "tasks_example"
+)
+
+# Load all pallet names in an array.
+ALL_PALLETS=($(
+  $SUBSTRATE benchmark pallet --list --chain=dev |\
+    tail -n+2 |\
+    cut -d',' -f1 |\
+    sort |\
+    uniq
+))
+
+# Define the error file.
+ERR_FILE="${ARTIFACTS_DIR}/benchmarking_errors.txt"
+
+# Delete the error file before each run.
+rm -f "$ERR_FILE"
+
+mkdir -p "$(dirname "$ERR_FILE")"
+
+# Update the block and extrinsic overhead weights.
+echo "[+] Benchmarking block and extrinsic overheads..."
+OUTPUT=$(
+  $SUBSTRATE benchmark overhead \
+  --chain=dev \
+  --wasm-execution=compiled \
+  --weight-path="$output_path/frame/support/src/weights/" \
+  --header="$output_path/HEADER-APACHE2" \
+  --warmup=10 \
+  --repeat=100 2>&1
+)
+if [ $? -ne 0 ]; then
+  echo "$OUTPUT" >> "$ERR_FILE"
+  echo "[-] Failed to benchmark the block and extrinsic overheads. Error written to $ERR_FILE; continuing..."
+fi
+
+echo "[+] Benchmarking ${#ALL_PALLETS[@]} Substrate pallets and excluding ${#EXCLUDED_PALLETS[@]}."
+
+echo "[+] Excluded pallets ${EXCLUDED_PALLETS[@]}"
+echo "[+] ------ "
+echo "[+] Whole list pallets ${ALL_PALLETS[@]}"
+
+# Benchmark each pallet.
+for PALLET in "${ALL_PALLETS[@]}"; do
+  FOLDER="$(echo "${PALLET#*_}" | tr '_' '-')";
+  WEIGHT_FILE="$output_path/frame/${FOLDER}/src/weights.rs"
+
+   # Skip the pallet if it is in the excluded list.
+
+  if [[ " ${EXCLUDED_PALLETS[@]} " =~ " ${PALLET} " ]]; then
+    echo "[+] Skipping $PALLET as it is in the excluded list."
+    continue
+  fi
+
+  echo "[+] Benchmarking $PALLET with weight file $WEIGHT_FILE";
+
+  set +e # Disable exit on error for the benchmarking of the pallets
+  OUTPUT=$(
+    $SUBSTRATE benchmark pallet \
+    --chain=dev \
+    --steps=50 \
+    --repeat=20 \
+    --pallet="$PALLET" \
+    --no-storage-info \
+    --no-median-slopes \
+    --no-min-squares \
+    --extrinsic="*" \
+    --wasm-execution=compiled \
+    --heap-pages=4096 \
+    --output="$WEIGHT_FILE" \
+    --header="$output_path/HEADER-APACHE2" \
+    --template="$output_path/.maintain/frame-weight-template.hbs" 2>&1
+  )
+  if [ $? -ne 0 ]; then
+    echo -e "$PALLET: $OUTPUT\n" >> "$ERR_FILE"
+    echo "[-] Failed to benchmark $PALLET. Error written to $ERR_FILE; continuing..."
+  fi
+  set -e # Re-enable exit on error
+done
+
+
+# Check if the error file exists.
+if [ -s "$ERR_FILE" ]; then
+  echo "[-] Some benchmarks failed. See: $ERR_FILE"
+  exit 1
+else
+  echo "[+] All benchmarks passed."
+fi
diff --git a/scripts/lib/bench-overhead.sh b/scripts/lib/bench-overhead.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c4cca8b4c128ca201adebb1e353ac11ad30b0825
--- /dev/null
+++ b/scripts/lib/bench-overhead.sh
@@ -0,0 +1,66 @@
+#!/bin/bash
+
+THIS_DIR=$(dirname "${BASH_SOURCE[0]}")
+. "$THIS_DIR/../command-utils.sh"
+
+bench_overhead_common_args=(
+  --
+  benchmark
+  overhead
+  --wasm-execution=compiled
+  --warmup=10
+  --repeat=100
+)
+bench_overhead() {
+  local args
+  case "$target_dir" in
+    substrate)
+      args=(
+        --bin=substrate
+        "${bench_overhead_common_args[@]}"
+        --header="$output_path/HEADER-APACHE2"
+        --weight-path="$output_path/frame/support/src/weights"
+        --chain="dev"
+      )
+    ;;
+    polkadot)
+      get_arg required --runtime "$@"
+      local runtime="${out:-""}"
+      args=(
+        --bin=polkadot
+        "${bench_overhead_common_args[@]}"
+        --header="$output_path/file_header.txt"
+        --weight-path="$output_path/runtime/$runtime/constants/src/weights"
+        --chain="$runtime-dev"
+      )
+    ;;
+    cumulus)
+      get_arg required --runtime "$@"
+      local runtime="${out:-""}"
+      args=(
+        -p=polkadot-parachain-bin
+        "${bench_overhead_common_args[@]}"
+        --header="$output_path/file_header.txt"
+        --weight-path="$output_path/parachains/runtimes/assets/$runtime/src/weights"
+        --chain="$runtime"
+      )
+    ;;
+    trappist)
+      get_arg required --runtime "$@"
+      local runtime="${out:-""}"
+      args=(
+        "${bench_overhead_common_args[@]}"
+        --header="$output_path/templates/file_header.txt"
+        --weight-path="$output_path/runtime/$runtime/src/weights"
+        --chain="$runtime-dev"
+      )
+    ;;
+    *)
+      die "Target Dir \"$target_dir\" is not supported in bench_overhead"
+    ;;
+  esac
+
+  cargo_run "${args[@]}"
+}
+
+bench_overhead "$@"
diff --git a/scripts/lib/bench-pallet.sh b/scripts/lib/bench-pallet.sh
new file mode 100644
index 0000000000000000000000000000000000000000..15eac31e3a45cbb3c4f7c2dde3a1006164259f3a
--- /dev/null
+++ b/scripts/lib/bench-pallet.sh
@@ -0,0 +1,178 @@
+#!/bin/bash
+
+THIS_DIR=$(dirname "${BASH_SOURCE[0]}")
+. "$THIS_DIR/../command-utils.sh"
+
+bench_pallet_common_args=(
+  --
+  benchmark
+  pallet
+  --steps=50
+  --repeat=20
+  --extrinsic="*"
+  --wasm-execution=compiled
+  --heap-pages=4096
+  --json-file="${ARTIFACTS_DIR}/bench.json"
+)
+bench_pallet() {
+  get_arg required --subcommand "$@"
+  local subcommand="${out:-""}"
+
+  get_arg required --runtime "$@"
+  local runtime="${out:-""}"
+
+  get_arg required --pallet "$@"
+  local pallet="${out:-""}"
+
+  local args
+  case "$target_dir" in
+    substrate)
+      args=(
+        --features=runtime-benchmarks
+        --manifest-path="$output_path/bin/node/cli/Cargo.toml"
+        "${bench_pallet_common_args[@]}"
+        --pallet="$pallet"
+        --chain="$runtime"
+      )
+
+      case "$subcommand" in
+        pallet)
+          # Translates e.g. "pallet_foo::bar" to "pallet_foo_bar"
+          local output_dir="${pallet//::/_}"
+
+          # Substrate benchmarks are output to the "frame" directory but they aren't
+          # named exactly after the $pallet argument. For example:
+          # - When $pallet == pallet_balances, the output folder is frame/balances
+          # - When $pallet == frame_benchmarking, the output folder is frame/benchmarking
+          # The common pattern we infer from those examples is that we should remove
+          # the prefix
+          if [[ "$output_dir" =~ ^[A-Za-z]*[^A-Za-z](.*)$ ]]; then
+            output_dir="${BASH_REMATCH[1]}"
+          fi
+
+          # We also need to translate '_' to '-' due to the folders' naming
+          # conventions
+          output_dir="${output_dir//_/-}"
+
+          args+=(
+            --header="$output_path/HEADER-APACHE2"
+            --output="$output_path/frame/$output_dir/src/weights.rs"
+            --template="$output_path/.maintain/frame-weight-template.hbs"
+          )
+        ;;
+        *)
+          die "Subcommand $subcommand is not supported for $target_dir in bench_pallet"
+        ;;
+      esac
+    ;;
+    polkadot)
+      # For backward compatibility: replace "-dev" with ""
+      runtime=${runtime/-dev/}
+
+      local weights_dir="$output_path/runtime/${runtime}/src/weights"
+
+      args=(
+        --bin=polkadot
+        --features=runtime-benchmarks
+        "${bench_pallet_common_args[@]}"
+        --pallet="$pallet"
+        --chain="${runtime}-dev"
+      )
+
+      case "$subcommand" in
+        pallet)
+          args+=(
+            --header="$output_path/file_header.txt"
+            --output="${weights_dir}/"
+          )
+        ;;
+        xcm)
+          args+=(
+            --header="$output_path/file_header.txt"
+            --template="$output_path/xcm/pallet-xcm-benchmarks/template.hbs"
+            --output="${weights_dir}/xcm/"
+          )
+        ;;
+        *)
+          die "Subcommand $subcommand is not supported for $target_dir in bench_pallet"
+        ;;
+      esac
+    ;;
+    cumulus)
+      get_arg required --runtime_dir "$@"
+      local runtime_dir="${out:-""}"
+      local chain="$runtime"
+
+      # to support specifying parachain id from runtime name (e.g. ["glutton-westend", "glutton-westend-dev-1300"])
+      # If runtime ends with "-dev" or "-dev-\d+", leave as it is, otherwise concat "-dev" at the end of $chain
+      if [[ ! "$runtime" =~ -dev(-[0-9]+)?$ ]]; then
+          chain="${runtime}-dev"
+      fi
+
+      # replace "-dev" or "-dev-\d+" with "" for runtime
+      runtime=$(echo "$runtime" | sed 's/-dev.*//g')
+
+      args=(
+        -p=polkadot-parachain-bin
+        --features=runtime-benchmarks
+        "${bench_pallet_common_args[@]}"
+        --pallet="$pallet"
+        --chain="${chain}"
+        --header="$output_path/file_header.txt"
+      )
+
+      case "$subcommand" in
+        pallet)
+          args+=(
+            --output="$output_path/parachains/runtimes/$runtime_dir/$runtime/src/weights/"
+          )
+        ;;
+        xcm)
+          mkdir -p "$output_path/parachains/runtimes/$runtime_dir/$runtime/src/weights/xcm"
+          args+=(
+            --template="$output_path/templates/xcm-bench-template.hbs"
+            --output="$output_path/parachains/runtimes/$runtime_dir/$runtime/src/weights/xcm/"
+          )
+        ;;
+        *)
+          die "Subcommand $subcommand is not supported for $target_dir in bench_pallet"
+        ;;
+      esac
+    ;;
+    trappist)
+      local weights_dir="$output_path/runtime/$runtime/src/weights"
+
+      args=(
+        --features=runtime-benchmarks
+        "${bench_pallet_common_args[@]}"
+        --pallet="$pallet"
+        --chain="${runtime}-dev"
+        --header="$output_path/templates/file_header.txt"
+      )
+
+      case "$subcommand" in
+        pallet)
+          args+=(
+            --output="${weights_dir}/"
+          )
+        ;;
+        xcm)
+          args+=(
+            --template="$output_path/templates/xcm-bench-template.hbs"
+            --output="${weights_dir}/xcm/"
+          )
+        ;;
+        *)
+          die "Subcommand $subcommand is not supported for $target_dir in bench_pallet"
+        ;;
+      esac
+    ;;
+    *)
+      die "Repository $target_dir is not supported in bench_pallet"
+    ;;
+  esac
+
+  cargo_run "${args[@]}"
+}
+
+bench_pallet "$@"
diff --git a/scripts/sync.sh b/scripts/sync.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b5d8a521993717d23469ddce4e1399bdd265220f
--- /dev/null
+++ b/scripts/sync.sh
@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+
+set -eu -o pipefail
+
+. "$(realpath "$(dirname "${BASH_SOURCE[0]}")/command-utils.sh")"
+
+
+# Function to check syncing status
+check_syncing() {
+  # Send the system_health request and parse the isSyncing field
+  RESPONSE=$(curl -sSX POST http://127.0.0.1:9944 \
+    --header 'Content-Type: application/json' \
+    --data-raw '{"jsonrpc": "2.0", "method": "system_health", "params": [], "id": "1"}')
+
+  # Check for errors in the curl command
+  if [ $? -ne 0 ]; then
+    echo "Error: Unable to send request to Polkadot node"
+  fi
+
+  IS_SYNCING=$(echo $RESPONSE | jq -r '.result.isSyncing')
+
+  # Check for errors in the jq command or missing field in the response
+  if [ $? -ne 0 ] || [ "$IS_SYNCING" == "null" ]; then
+    echo "Error: Unable to parse sync status from response"
+  fi
+
+  # Return the isSyncing value
+  echo $IS_SYNCING
+}
+
+main() {
+  get_arg required --chain "$@"
+  local chain="${out:-""}"
+
+  get_arg required --type "$@"
+  local type="${out:-""}"
+
+  export RUST_LOG="${RUST_LOG:-remote-ext=debug,runtime=trace}"
+
+  cargo build --release
+
+  cp "./target/release/polkadot" ./polkadot-bin
+
+  # Start sync.
+  # "&" runs the process in the background
+  # "> /dev/tty" redirects the output of the process to the terminal
+  ./polkadot-bin --sync="$type" --chain="$chain" > "$ARTIFACTS_DIR/sync.log" 2>&1 &
+
+  # Get the PID of process
+  POLKADOT_SYNC_PID=$!
+
+  sleep 10
+
+  # Poll the node every 100 seconds until syncing is complete
+  while :; do
+    SYNC_STATUS="$(check_syncing)"
+    if [ "$SYNC_STATUS" == "true" ]; then
+      echo "Node is still syncing..."
+      sleep 100
+    elif [ "$SYNC_STATUS" == "false" ]; then
+      echo "Node sync is complete!"
+      kill "$POLKADOT_SYNC_PID" # Stop the Polkadot node process once syncing is complete
+      exit 0 # Success
+    elif [[ "$SYNC_STATUS" = Error:* ]]; then
+      echo "$SYNC_STATUS"
+      exit 1 # Error
+    else
+      echo "Unknown error: $SYNC_STATUS"
+      exit 1 # Unknown error
+    fi
+  done
+}
+
+main "$@"
diff --git a/substrate/bin/node/bench/src/import.rs b/substrate/bin/node/bench/src/import.rs
index 78b280076e0bd625f2c6fa76beb76a9439a7187a..e340869dea0281092b41c94d107e65e4831c7e95 100644
--- a/substrate/bin/node/bench/src/import.rs
+++ b/substrate/bin/node/bench/src/import.rs
@@ -122,7 +122,8 @@ impl core::Benchmark for ImportBenchmark {
 				match self.block_type {
 					BlockType::RandomTransfersKeepAlive => {
 						// should be 8 per signed extrinsic + 1 per unsigned
-						// we have 1 unsigned and the rest are signed in the block
+						// we have 2 unsigned (timestamp and glutton bloat) while the rest are
+						// signed in the block.
 						// those 8 events per signed are:
 						//    - transaction paid for the transaction payment
 						//    - withdraw (Balances::Withdraw) for charging the transaction fee
@@ -135,18 +136,18 @@ impl core::Benchmark for ImportBenchmark {
 						//    - extrinsic success
 						assert_eq!(
 							kitchensink_runtime::System::events().len(),
-							(self.block.extrinsics.len() - 1) * 8 + 1,
+							(self.block.extrinsics.len() - 2) * 8 + 2,
 						);
 					},
 					BlockType::Noop => {
 						assert_eq!(
 							kitchensink_runtime::System::events().len(),
 							// should be 2 per signed extrinsic + 1 per unsigned
-							// we have 1 unsigned and the rest are signed in the block
+							// we have 2 unsigned and the rest are signed in the block
 							// those 2 events per signed are:
 							//    - deposit event for charging transaction fee
 							//    - extrinsic success
-							(self.block.extrinsics.len() - 1) * 2 + 1,
+							(self.block.extrinsics.len() - 2) * 2 + 2,
 						);
 					},
 					_ => {},
diff --git a/substrate/bin/node/cli/Cargo.toml b/substrate/bin/node/cli/Cargo.toml
index ec9d6c306b58ffee59a7e9f4c9add93b828edd27..929cd6a29e3889dbd93d6e31277406cf61176114 100644
--- a/substrate/bin/node/cli/Cargo.toml
+++ b/substrate/bin/node/cli/Cargo.toml
@@ -23,13 +23,10 @@ wasm-opt = false
 targets = ["x86_64-unknown-linux-gnu"]
 
 [badges]
-travis-ci = { repository = "paritytech/substrate" }
 maintenance = { status = "actively-developed" }
-is-it-maintained-issue-resolution = { repository = "paritytech/substrate" }
-is-it-maintained-open-issues = { repository = "paritytech/substrate" }
+is-it-maintained-issue-resolution = { repository = "paritytech/polkadot-sdk" }
+is-it-maintained-open-issues = { repository = "paritytech/polkadot-sdk" }
 
-# The same node binary as the `substrate` (defined in the workspace `Cargo.toml`) binary,
-# but just exposed by this crate here.
 [[bin]]
 name = "substrate-node"
 path = "bin/main.rs"
@@ -40,7 +37,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 # third-party dependencies
-array-bytes = "6.2.2"
+array-bytes = "6.1"
 clap = { version = "4.5.3", features = ["derive"], optional = true }
 codec = { package = "parity-scale-codec", version = "3.6.12" }
 serde = { features = ["derive"], workspace = true, default-features = true }
@@ -48,87 +45,18 @@ jsonrpsee = { version = "0.22", features = ["server"] }
 futures = "0.3.30"
 log = { workspace = true, default-features = true }
 rand = "0.8"
+serde_json = { workspace = true, default-features = true }
+
+# The Polkadot-SDK:
+polkadot-sdk = { path = "../../../../umbrella", features = ["node"] }
 
-# primitives
-sp-authority-discovery = { path = "../../../primitives/authority-discovery" }
-sp-consensus-babe = { path = "../../../primitives/consensus/babe" }
-beefy-primitives = { package = "sp-consensus-beefy", path = "../../../primitives/consensus/beefy" }
-grandpa-primitives = { package = "sp-consensus-grandpa", path = "../../../primitives/consensus/grandpa" }
-sp-api = { path = "../../../primitives/api" }
-sp-core = { path = "../../../primitives/core" }
-sp-runtime = { path = "../../../primitives/runtime" }
-sp-timestamp = { path = "../../../primitives/timestamp" }
-sp-genesis-builder = { path = "../../../primitives/genesis-builder" }
-sp-inherents = { path = "../../../primitives/inherents" }
-sp-keyring = { path = "../../../primitives/keyring" }
-sp-keystore = { path = "../../../primitives/keystore" }
-sp-consensus = { path = "../../../primitives/consensus/common" }
-sp-transaction-storage-proof = { path = "../../../primitives/transaction-storage-proof" }
-sp-io = { path = "../../../primitives/io" }
-sp-mixnet = { path = "../../../primitives/mixnet" }
-sp-mmr-primitives = { path = "../../../primitives/merkle-mountain-range" }
-sp-statement-store = { path = "../../../primitives/statement-store" }
-
-# client dependencies
-sc-client-api = { path = "../../../client/api" }
-sc-chain-spec = { path = "../../../client/chain-spec" }
-sc-consensus = { path = "../../../client/consensus/common" }
-sc-transaction-pool = { path = "../../../client/transaction-pool" }
-sc-transaction-pool-api = { path = "../../../client/transaction-pool/api" }
-sc-statement-store = { path = "../../../client/statement-store" }
-sc-network = { path = "../../../client/network" }
-sc-network-common = { path = "../../../client/network/common" }
-sc-network-sync = { path = "../../../client/network/sync" }
-sc-network-statement = { path = "../../../client/network/statement" }
-sc-consensus-slots = { path = "../../../client/consensus/slots" }
-sc-consensus-babe = { path = "../../../client/consensus/babe" }
-beefy = { package = "sc-consensus-beefy", path = "../../../client/consensus/beefy" }
-grandpa = { package = "sc-consensus-grandpa", path = "../../../client/consensus/grandpa" }
-mmr-gadget = { path = "../../../client/merkle-mountain-range" }
-sc-rpc = { path = "../../../client/rpc" }
-sc-basic-authorship = { path = "../../../client/basic-authorship" }
-sc-service = { path = "../../../client/service", default-features = false }
-sc-telemetry = { path = "../../../client/telemetry" }
-sc-executor = { path = "../../../client/executor" }
-sc-authority-discovery = { path = "../../../client/authority-discovery" }
-sc-mixnet = { path = "../../../client/mixnet" }
-sc-sync-state-rpc = { path = "../../../client/sync-state-rpc" }
-sc-sysinfo = { path = "../../../client/sysinfo" }
-sc-storage-monitor = { path = "../../../client/storage-monitor" }
-sc-offchain = { path = "../../../client/offchain" }
-
-# frame dependencies
-frame-benchmarking = { path = "../../../frame/benchmarking" }
-frame-system = { path = "../../../frame/system" }
-frame-system-rpc-runtime-api = { path = "../../../frame/system/rpc/runtime-api" }
-pallet-assets = { path = "../../../frame/assets" }
-pallet-asset-conversion-tx-payment = { path = "../../../frame/transaction-payment/asset-conversion-tx-payment" }
-pallet-asset-tx-payment = { path = "../../../frame/transaction-payment/asset-tx-payment" }
-pallet-im-online = { path = "../../../frame/im-online", default-features = false }
-pallet-skip-feeless-payment = { path = "../../../frame/transaction-payment/skip-feeless-payment", default-features = false }
-
-# node-specific dependencies
+# Shared code between the staging node and kitchensink runtime:
 kitchensink-runtime = { path = "../runtime" }
 node-rpc = { path = "../rpc" }
 node-primitives = { path = "../primitives" }
-
-# CLI-specific dependencies
-sc-cli = { path = "../../../client/cli", optional = true }
-frame-benchmarking-cli = { path = "../../../utils/frame/benchmarking-cli", optional = true }
 node-inspect = { package = "staging-node-inspect", path = "../inspect", optional = true }
-serde_json = { workspace = true, default-features = true }
 
 [dev-dependencies]
-sc-keystore = { path = "../../../client/keystore" }
-sc-client-db = { path = "../../../client/db" }
-sc-consensus = { path = "../../../client/consensus/common" }
-sc-consensus-babe = { path = "../../../client/consensus/babe" }
-sc-consensus-epochs = { path = "../../../client/consensus/epochs" }
-sc-service-test = { path = "../../../client/service/test" }
-sc-block-builder = { path = "../../../client/block-builder" }
-sp-tracing = { path = "../../../primitives/tracing" }
-sp-blockchain = { path = "../../../primitives/blockchain" }
-sp-crypto-hashing = { path = "../../../primitives/crypto/hashing" }
 futures = "0.3.30"
 tempfile = "3.1.0"
 assert_cmd = "2.0.2"
@@ -140,92 +68,39 @@ criterion = { version = "0.5.1", features = ["async_tokio"] }
 tokio = { version = "1.22.0", features = ["macros", "parking_lot", "time"] }
 tokio-util = { version = "0.7.4", features = ["compat"] }
 wait-timeout = "0.2"
-substrate-rpc-client = { path = "../../../utils/frame/rpc/client" }
-pallet-timestamp = { path = "../../../frame/timestamp" }
-substrate-cli-test-utils = { path = "../../../test-utils/cli" }
-
 wat = "1.0"
-frame-support = { path = "../../../frame/support" }
-node-testing = { path = "../testing" }
-pallet-balances = { path = "../../../frame/balances" }
-pallet-contracts = { path = "../../../frame/contracts" }
-pallet-glutton = { path = "../../../frame/glutton" }
-pallet-sudo = { path = "../../../frame/sudo" }
-pallet-treasury = { path = "../../../frame/treasury" }
-pallet-transaction-payment = { path = "../../../frame/transaction-payment" }
-sp-application-crypto = { path = "../../../primitives/application-crypto" }
-pallet-root-testing = { path = "../../../frame/root-testing" }
-sp-consensus-babe = { path = "../../../primitives/consensus/babe" }
-sp-externalities = { path = "../../../primitives/externalities" }
-sp-keyring = { path = "../../../primitives/keyring" }
-sp-runtime = { path = "../../../primitives/runtime" }
 serde_json = { workspace = true, default-features = true }
 scale-info = { version = "2.11.1", features = ["derive", "serde"] }
-sp-trie = { path = "../../../primitives/trie" }
-sp-state-machine = { path = "../../../primitives/state-machine" }
+
+# These testing-only dependencies are not exported by the Polkadot-SDK crate:
+node-testing = { path = "../testing" }
+substrate-cli-test-utils = { path = "../../../test-utils/cli" }
+sc-service-test = { path = "../../../client/service/test" }
 
 [build-dependencies]
 clap = { version = "4.5.3", optional = true }
 clap_complete = { version = "4.0.2", optional = true }
+
 node-inspect = { package = "staging-node-inspect", path = "../inspect", optional = true }
-frame-benchmarking-cli = { path = "../../../utils/frame/benchmarking-cli", optional = true }
-substrate-build-script-utils = { path = "../../../utils/build-script-utils", optional = true }
-sc-cli = { path = "../../../client/cli", optional = true }
-pallet-balances = { path = "../../../frame/balances" }
-sc-storage-monitor = { path = "../../../client/storage-monitor" }
+
+polkadot-sdk = { path = "../../../../umbrella", features = ["frame-benchmarking-cli", "sc-cli", "sc-storage-monitor", "substrate-build-script-utils"], optional = true }
 
 [features]
 default = ["cli"]
 cli = [
 	"clap",
 	"clap_complete",
-	"frame-benchmarking-cli",
 	"node-inspect",
-	"sc-cli",
-	"sc-service/rocksdb",
-	"substrate-build-script-utils",
+	"polkadot-sdk",
 ]
 runtime-benchmarks = [
-	"frame-benchmarking-cli/runtime-benchmarks",
-	"frame-benchmarking/runtime-benchmarks",
-	"frame-support/runtime-benchmarks",
-	"frame-system/runtime-benchmarks",
 	"kitchensink-runtime/runtime-benchmarks",
 	"node-inspect?/runtime-benchmarks",
-	"pallet-asset-tx-payment/runtime-benchmarks",
-	"pallet-assets/runtime-benchmarks",
-	"pallet-balances/runtime-benchmarks",
-	"pallet-contracts/runtime-benchmarks",
-	"pallet-glutton/runtime-benchmarks",
-	"pallet-im-online/runtime-benchmarks",
-	"pallet-skip-feeless-payment/runtime-benchmarks",
-	"pallet-sudo/runtime-benchmarks",
-	"pallet-timestamp/runtime-benchmarks",
-	"pallet-treasury/runtime-benchmarks",
-	"sc-client-db/runtime-benchmarks",
-	"sc-service/runtime-benchmarks",
-	"sp-runtime/runtime-benchmarks",
+	"polkadot-sdk/runtime-benchmarks",
 ]
-# Enable features that allow the runtime to be tried and debugged. Name might be subject to change
-# in the near future.
 try-runtime = [
-	"frame-support/try-runtime",
-	"frame-system/try-runtime",
 	"kitchensink-runtime/try-runtime",
-	"pallet-asset-conversion-tx-payment/try-runtime",
-	"pallet-asset-tx-payment/try-runtime",
-	"pallet-assets/try-runtime",
-	"pallet-balances/try-runtime",
-	"pallet-contracts/try-runtime",
-	"pallet-glutton/try-runtime",
-	"pallet-im-online/try-runtime",
-	"pallet-root-testing/try-runtime",
-	"pallet-skip-feeless-payment/try-runtime",
-	"pallet-sudo/try-runtime",
-	"pallet-timestamp/try-runtime",
-	"pallet-transaction-payment/try-runtime",
-	"pallet-treasury/try-runtime",
-	"sp-runtime/try-runtime",
+	"polkadot-sdk/try-runtime",
 	"substrate-cli-test-utils/try-runtime",
 ]
 
diff --git a/substrate/bin/node/cli/benches/block_production.rs b/substrate/bin/node/cli/benches/block_production.rs
index ef7ae4fdf26308827e2745d4cb54c8fe21fbc14f..c16b25187e5f58a218fa22fc55cfdc58a214c6bf 100644
--- a/substrate/bin/node/cli/benches/block_production.rs
+++ b/substrate/bin/node/cli/benches/block_production.rs
@@ -16,6 +16,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+use polkadot_sdk::*;
+
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
 
 use kitchensink_runtime::{constants::currency::*, BalancesCall};
diff --git a/substrate/bin/node/cli/benches/executor.rs b/substrate/bin/node/cli/benches/executor.rs
index a326e1a79ea347f169e372581d07dc4f43848e24..fa4da5c13d4344208c6a51067fbf78e380923a82 100644
--- a/substrate/bin/node/cli/benches/executor.rs
+++ b/substrate/bin/node/cli/benches/executor.rs
@@ -15,6 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use polkadot_sdk::*;
+
 use codec::{Decode, Encode};
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use frame_support::Hashable;
@@ -55,7 +57,7 @@ const HEAP_PAGES: u64 = 20;
 type TestExternalities<H> = CoreTestExternalities<H>;
 
 fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
-	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH)
+	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None)
 }
 
 fn new_test_ext(genesis_config: &RuntimeGenesisConfig) -> TestExternalities<BlakeTwo256> {
diff --git a/substrate/bin/node/cli/benches/transaction_pool.rs b/substrate/bin/node/cli/benches/transaction_pool.rs
index c4488415b98343a15c8c81eb2ff164db4b36fa29..6618f4b1132e031cd7e6c69451e3ff8997e86684 100644
--- a/substrate/bin/node/cli/benches/transaction_pool.rs
+++ b/substrate/bin/node/cli/benches/transaction_pool.rs
@@ -16,6 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+use polkadot_sdk::*;
 use std::time::Duration;
 
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
diff --git a/substrate/bin/node/cli/bin/main.rs b/substrate/bin/node/cli/bin/main.rs
index ccc7d7b6b112558832549bf7e5435f68ac0fe944..b18d08880556093319cad2dfd3faa789fae819b1 100644
--- a/substrate/bin/node/cli/bin/main.rs
+++ b/substrate/bin/node/cli/bin/main.rs
@@ -20,6 +20,7 @@
 
 #![warn(missing_docs)]
 
+use polkadot_sdk::*;
 use staging_node_cli as node_cli;
 
 fn main() -> sc_cli::Result<()> {
diff --git a/substrate/bin/node/cli/build.rs b/substrate/bin/node/cli/build.rs
index 033f1e3349e6fae1f062f9a075dcb66295aab22d..c25d15de057425458230f48be270ca7ad09d895e 100644
--- a/substrate/bin/node/cli/build.rs
+++ b/substrate/bin/node/cli/build.rs
@@ -27,8 +27,10 @@ mod cli {
 
 	use clap::{CommandFactory, ValueEnum};
 	use clap_complete::{generate_to, Shell};
+	use polkadot_sdk::substrate_build_script_utils::{
+		generate_cargo_keys, rerun_if_git_head_changed,
+	};
 	use std::{env, fs, path::Path};
-	use substrate_build_script_utils::{generate_cargo_keys, rerun_if_git_head_changed};
 
 	pub fn main() {
 		build_shell_completion();
diff --git a/substrate/bin/node/cli/src/benchmarking.rs b/substrate/bin/node/cli/src/benchmarking.rs
index 333f855f2d7bb876d7768784b60dfa21e1d8d708..a2b28a0f317de4fcc74b963d3ccb1c026ddfa380 100644
--- a/substrate/bin/node/cli/src/benchmarking.rs
+++ b/substrate/bin/node/cli/src/benchmarking.rs
@@ -22,6 +22,8 @@
 
 use crate::service::{create_extrinsic, FullClient};
 
+use polkadot_sdk::*;
+
 use kitchensink_runtime::{BalancesCall, SystemCall};
 use node_primitives::{AccountId, Balance};
 use sc_cli::Result;
diff --git a/substrate/bin/node/cli/src/chain_spec.rs b/substrate/bin/node/cli/src/chain_spec.rs
index d48d4a50f85f2672d5e65c639a6a0b200c06756c..bc7821bfcf304bc7c41d50d0bf1606e33ac114bc 100644
--- a/substrate/bin/node/cli/src/chain_spec.rs
+++ b/substrate/bin/node/cli/src/chain_spec.rs
@@ -18,8 +18,8 @@
 
 //! Substrate chain configurations.
 
-use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId;
-use grandpa_primitives::AuthorityId as GrandpaId;
+use polkadot_sdk::*;
+
 use kitchensink_runtime::{
 	constants::currency::*, wasm_binary_unwrap, Block, MaxNominations, SessionKeys, StakerStatus,
 };
@@ -30,6 +30,8 @@ use sc_telemetry::TelemetryEndpoints;
 use serde::{Deserialize, Serialize};
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
 use sp_consensus_babe::AuthorityId as BabeId;
+use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId;
+use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{crypto::UncheckedInto, sr25519, Pair, Public};
 use sp_mixnet::types::AuthorityId as MixnetId;
 use sp_runtime::{
@@ -62,7 +64,7 @@ pub struct Extensions {
 }
 
 /// Specialized `ChainSpec`.
-pub type ChainSpec = sc_service::GenericChainSpec<RuntimeGenesisConfig, Extensions>;
+pub type ChainSpec = sc_service::GenericChainSpec<Extensions>;
 /// Flaming Fir testnet generator
 pub fn flaming_fir_config() -> Result<ChainSpec, String> {
 	ChainSpec::from_json_bytes(&include_bytes!("../res/flaming-fir.json")[..])
diff --git a/substrate/bin/node/cli/src/cli.rs b/substrate/bin/node/cli/src/cli.rs
index 1d1af6e03e9e6eb57055b416038ee97ba95f3e3a..c0dcacb2e4b451990ea08c0c29fd1f92f89b3eaa 100644
--- a/substrate/bin/node/cli/src/cli.rs
+++ b/substrate/bin/node/cli/src/cli.rs
@@ -16,6 +16,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+use polkadot_sdk::*;
+
 /// An overarching CLI command definition.
 #[derive(Debug, clap::Parser)]
 pub struct Cli {
diff --git a/substrate/bin/node/cli/src/command.rs b/substrate/bin/node/cli/src/command.rs
index d869b77e9122859550232136d3907e2f33a4eda3..51fbf0904cf8c303a6af3bed0c24587952723cd0 100644
--- a/substrate/bin/node/cli/src/command.rs
+++ b/substrate/bin/node/cli/src/command.rs
@@ -16,6 +16,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+use polkadot_sdk::*;
+
 use super::benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder};
 use crate::{
 	chain_spec, service,
@@ -215,7 +217,7 @@ pub fn run() -> Result<()> {
 					new_partial(&config, None)?;
 				let aux_revert = Box::new(|client: Arc<FullClient>, backend, blocks| {
 					sc_consensus_babe::revert(client.clone(), backend, blocks)?;
-					grandpa::revert(client, blocks)?;
+					sc_consensus_grandpa::revert(client, blocks)?;
 					Ok(())
 				});
 				Ok((cmd.run(client, backend, Some(aux_revert)), task_manager))
diff --git a/substrate/bin/node/cli/src/service.rs b/substrate/bin/node/cli/src/service.rs
index 5dc1193daf8d67f6f9067eb42a161dab9242efed..e57ca04f3b743ff3fab2f492e90a2d92cfdf8fd5 100644
--- a/substrate/bin/node/cli/src/service.rs
+++ b/substrate/bin/node/cli/src/service.rs
@@ -20,6 +20,11 @@
 
 //! Service implementation. Specialized wrapper over substrate service.
 
+use polkadot_sdk::{
+	sc_consensus_beefy as beefy, sc_consensus_grandpa as grandpa,
+	sp_consensus_beefy as beefy_primitives, *,
+};
+
 use crate::Cli;
 use codec::Encode;
 use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE;
@@ -65,8 +70,13 @@ type FullBackend = sc_service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
 type FullGrandpaBlockImport =
 	grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>;
-type FullBeefyBlockImport<InnerBlockImport> =
-	beefy::import::BeefyBlockImport<Block, FullBackend, FullClient, InnerBlockImport>;
+type FullBeefyBlockImport<InnerBlockImport> = beefy::import::BeefyBlockImport<
+	Block,
+	FullBackend,
+	FullClient,
+	InnerBlockImport,
+	beefy_primitives::ecdsa_crypto::AuthorityId,
+>;
 
 /// The transaction pool type definition.
 pub type TransactionPool = sc_transaction_pool::FullPool<Block, FullClient>;
@@ -126,6 +136,7 @@ pub fn create_extrinsic(
 					kitchensink_runtime::Runtime,
 				>::from(tip, None),
 			),
+			frame_metadata_hash_extension::CheckMetadataHash::new(false),
 		);
 
 	let raw_payload = kitchensink_runtime::SignedPayload::from_raw(
@@ -140,6 +151,7 @@ pub fn create_extrinsic(
 			(),
 			(),
 			(),
+			None,
 		),
 	);
 	let signature = raw_payload.using_encoded(|e| sender.sign(e));
@@ -176,7 +188,7 @@ pub fn new_partial(
 				>,
 				grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
 				sc_consensus_babe::BabeLink<Block>,
-				beefy::BeefyVoterLinks<Block>,
+				beefy::BeefyVoterLinks<Block, beefy_primitives::ecdsa_crypto::AuthorityId>,
 			),
 			grandpa::SharedVoterState,
 			Option<Telemetry>,
@@ -324,7 +336,7 @@ pub fn new_partial(
 						subscription_executor: subscription_executor.clone(),
 						finality_provider: finality_proof_provider.clone(),
 					},
-					beefy: node_rpc::BeefyDeps {
+					beefy: node_rpc::BeefyDeps::<beefy_primitives::ecdsa_crypto::AuthorityId> {
 						beefy_finality_proof_stream: beefy_rpc_links
 							.from_voter_justif_stream
 							.clone(),
@@ -668,7 +680,7 @@ pub fn new_full_base<N: NetworkBackend<Block, <Block as BlockT>::Hash>>(
 	let beefy_params = beefy::BeefyParams {
 		client: client.clone(),
 		backend: backend.clone(),
-		payload_provider: beefy_primitives::mmr::MmrRootProvider::new(client.clone()),
+		payload_provider: sp_consensus_beefy::mmr::MmrRootProvider::new(client.clone()),
 		runtime: client.clone(),
 		key_store: keystore.clone(),
 		network_params,
@@ -679,7 +691,7 @@ pub fn new_full_base<N: NetworkBackend<Block, <Block as BlockT>::Hash>>(
 		is_authority: role.is_authority(),
 	};
 
-	let beefy_gadget = beefy::start_beefy_gadget::<_, _, _, _, _, _, _>(beefy_params);
+	let beefy_gadget = beefy::start_beefy_gadget::<_, _, _, _, _, _, _, _>(beefy_params);
 	// BEEFY is part of consensus, if it fails we'll bring the node down with it to make sure it
 	// is noticed.
 	task_manager
@@ -842,6 +854,7 @@ mod tests {
 		Address, BalancesCall, RuntimeCall, UncheckedExtrinsic,
 	};
 	use node_primitives::{Block, DigestItem, Signature};
+	use polkadot_sdk::*;
 	use sc_client_api::BlockBackend;
 	use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy};
 	use sc_consensus_babe::{BabeIntermediate, CompatibleDigestItem, INTERMEDIATE_KEY};
@@ -1041,6 +1054,7 @@ mod tests {
 				let tx_payment = pallet_skip_feeless_payment::SkipCheckIfFeeless::from(
 					pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::from(0, None),
 				);
+				let metadata_hash = frame_metadata_hash_extension::CheckMetadataHash::new(false);
 				let extra = (
 					check_non_zero_sender,
 					check_spec_version,
@@ -1050,11 +1064,22 @@ mod tests {
 					check_nonce,
 					check_weight,
 					tx_payment,
+					metadata_hash,
 				);
 				let raw_payload = SignedPayload::from_raw(
 					function,
 					extra,
-					((), spec_version, transaction_version, genesis_hash, genesis_hash, (), (), ()),
+					(
+						(),
+						spec_version,
+						transaction_version,
+						genesis_hash,
+						genesis_hash,
+						(),
+						(),
+						(),
+						None,
+					),
 				);
 				let signature = raw_payload.using_encoded(|payload| signer.sign(payload));
 				let (function, extra, _) = raw_payload.deconstruct();
diff --git a/substrate/bin/node/cli/tests/basic.rs b/substrate/bin/node/cli/tests/basic.rs
index a9eea84d926000fafce766d3aa2889919ef5c376..b1f737ce399b32de652abd8c26bad1811727fcff 100644
--- a/substrate/bin/node/cli/tests/basic.rs
+++ b/substrate/bin/node/cli/tests/basic.rs
@@ -22,6 +22,7 @@ use frame_support::{
 	weights::Weight,
 };
 use frame_system::{self, AccountInfo, EventRecord, Phase};
+use polkadot_sdk::*;
 use sp_core::{storage::well_known_keys, traits::Externalities};
 use sp_runtime::{
 	traits::Hash as HashT, transaction_validity::InvalidTransaction, ApplyExtrinsicResult,
diff --git a/substrate/bin/node/cli/tests/common.rs b/substrate/bin/node/cli/tests/common.rs
index 2d74cdd5a0418aa7f93d7ebadfe3598036fb38ab..95583395f73403959f20162c543617a84d2741fa 100644
--- a/substrate/bin/node/cli/tests/common.rs
+++ b/substrate/bin/node/cli/tests/common.rs
@@ -18,6 +18,7 @@
 use codec::{Decode, Encode};
 use frame_support::Hashable;
 use frame_system::offchain::AppCrypto;
+use polkadot_sdk::*;
 use sc_executor::error::Result;
 use sp_consensus_babe::{
 	digests::{PreDigest, SecondaryPlainPreDigest},
@@ -48,7 +49,7 @@ pub const TEST_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"test");
 pub mod sr25519 {
 	mod app_sr25519 {
 		use super::super::TEST_KEY_TYPE_ID;
-		use sp_application_crypto::{app_crypto, sr25519};
+		use polkadot_sdk::sp_application_crypto::{app_crypto, sr25519};
 		app_crypto!(sr25519, TEST_KEY_TYPE_ID);
 	}
 
@@ -83,7 +84,7 @@ pub const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_ve
 pub type TestExternalities<H> = CoreTestExternalities<H>;
 
 pub fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
-	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH)
+	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None)
 }
 
 pub fn default_transfer_call() -> pallet_balances::Call<Runtime> {
diff --git a/substrate/bin/node/cli/tests/fees.rs b/substrate/bin/node/cli/tests/fees.rs
index 69c96bf63a6d8d7b7c24746cdf5c3c48b526c12e..9f82338b4fb03bbe36d09894add142027e419f7e 100644
--- a/substrate/bin/node/cli/tests/fees.rs
+++ b/substrate/bin/node/cli/tests/fees.rs
@@ -28,6 +28,7 @@ use kitchensink_runtime::{
 };
 use node_primitives::Balance;
 use node_testing::keyring::*;
+use polkadot_sdk::*;
 use sp_runtime::{traits::One, Perbill};
 
 pub mod common;
diff --git a/substrate/bin/node/cli/tests/res/default_genesis_config.json b/substrate/bin/node/cli/tests/res/default_genesis_config.json
index e21fbb47da8c4619e0923c85bf3470828cd80b23..d8713764ab21d516851fddff04734f37e03c9bfe 100644
--- a/substrate/bin/node/cli/tests/res/default_genesis_config.json
+++ b/substrate/bin/node/cli/tests/res/default_genesis_config.json
@@ -74,6 +74,7 @@
   "glutton": {
     "compute": "0",
     "storage": "0",
+    "blockLength": "0",
     "trashDataCount": 0
   },
   "assets": {
diff --git a/substrate/bin/node/cli/tests/submit_transaction.rs b/substrate/bin/node/cli/tests/submit_transaction.rs
index 5cbb0103d471b96902bb341bcd796e6cf09eac76..18826e7e90a784e2b644b88024a8d83e3e15f3c1 100644
--- a/substrate/bin/node/cli/tests/submit_transaction.rs
+++ b/substrate/bin/node/cli/tests/submit_transaction.rs
@@ -18,6 +18,7 @@
 use codec::Decode;
 use frame_system::offchain::{SendSignedTransaction, Signer, SubmitTransaction};
 use kitchensink_runtime::{Executive, Indices, Runtime, UncheckedExtrinsic};
+use polkadot_sdk::*;
 use sp_application_crypto::AppCrypto;
 use sp_core::offchain::{testing::TestTransactionPoolExt, TransactionPoolExt};
 use sp_keyring::sr25519::Keyring::Alice;
diff --git a/substrate/bin/node/inspect/Cargo.toml b/substrate/bin/node/inspect/Cargo.toml
index 5e4488903bf45fa32dd1f219bf9cf5766522e5bd..e23a4c4f37e59b8b0e6e37169dfb03e676b7f2d8 100644
--- a/substrate/bin/node/inspect/Cargo.toml
+++ b/substrate/bin/node/inspect/Cargo.toml
@@ -18,7 +18,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 clap = { version = "4.5.3", features = ["derive"] }
 codec = { package = "parity-scale-codec", version = "3.6.12" }
 thiserror = { workspace = true }
-sc-cli = { path = "../../../client/cli" }
+sc-cli = { path = "../../../client/cli", default-features = false }
 sc-client-api = { path = "../../../client/api" }
 sc-service = { path = "../../../client/service", default-features = false }
 sp-blockchain = { path = "../../../primitives/blockchain" }
diff --git a/substrate/bin/node/rpc/Cargo.toml b/substrate/bin/node/rpc/Cargo.toml
index 894dbf0da85ca56d412087adf01fa12c7983ae7a..6ae80eb578596490753d903d253c01af2660ef4f 100644
--- a/substrate/bin/node/rpc/Cargo.toml
+++ b/substrate/bin/node/rpc/Cargo.toml
@@ -26,6 +26,7 @@ sc-consensus-babe = { path = "../../../client/consensus/babe" }
 sc-consensus-babe-rpc = { path = "../../../client/consensus/babe/rpc" }
 sc-consensus-beefy = { path = "../../../client/consensus/beefy" }
 sc-consensus-beefy-rpc = { path = "../../../client/consensus/beefy/rpc" }
+sp-consensus-beefy = { path = "../../../primitives/consensus/beefy" }
 sc-consensus-grandpa = { path = "../../../client/consensus/grandpa" }
 sc-consensus-grandpa-rpc = { path = "../../../client/consensus/grandpa/rpc" }
 sc-mixnet = { path = "../../../client/mixnet" }
@@ -41,6 +42,7 @@ sp-consensus = { path = "../../../primitives/consensus/common" }
 sp-consensus-babe = { path = "../../../primitives/consensus/babe" }
 sp-keystore = { path = "../../../primitives/keystore" }
 sp-runtime = { path = "../../../primitives/runtime" }
+sp-application-crypto = { path = "../../../primitives/application-crypto" }
 sp-statement-store = { path = "../../../primitives/statement-store" }
 substrate-frame-rpc-system = { path = "../../../utils/frame/rpc/system" }
 substrate-state-trie-migration-rpc = { path = "../../../utils/frame/rpc/state-trie-migration-rpc" }
diff --git a/substrate/bin/node/rpc/src/lib.rs b/substrate/bin/node/rpc/src/lib.rs
index 4646524a25babfd7cb1276326d4704abdcc65622..52cd7f9561d2a9e8287e85e1fdc7dc80f4bf5a3f 100644
--- a/substrate/bin/node/rpc/src/lib.rs
+++ b/substrate/bin/node/rpc/src/lib.rs
@@ -47,10 +47,12 @@ pub use sc_rpc::SubscriptionTaskExecutor;
 pub use sc_rpc_api::DenyUnsafe;
 use sc_transaction_pool_api::TransactionPool;
 use sp_api::ProvideRuntimeApi;
+use sp_application_crypto::RuntimeAppPublic;
 use sp_block_builder::BlockBuilder;
 use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 use sp_consensus::SelectChain;
 use sp_consensus_babe::BabeApi;
+use sp_consensus_beefy::AuthorityIdBound;
 use sp_keystore::KeystorePtr;
 
 /// Extra dependencies for BABE.
@@ -76,9 +78,9 @@ pub struct GrandpaDeps<B> {
 }
 
 /// Dependencies for BEEFY
-pub struct BeefyDeps {
+pub struct BeefyDeps<AuthorityId: AuthorityIdBound> {
 	/// Receives notifications about finality proof events from BEEFY.
-	pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream<Block>,
+	pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream<Block, AuthorityId>,
 	/// Receives notifications about best block events from BEEFY.
 	pub beefy_best_block_stream: BeefyBestBlockStream<Block>,
 	/// Executor to drive the subscription manager in the BEEFY RPC handler.
@@ -86,7 +88,7 @@ pub struct BeefyDeps {
 }
 
 /// Full client dependencies.
-pub struct FullDeps<C, P, SC, B> {
+pub struct FullDeps<C, P, SC, B, AuthorityId: AuthorityIdBound> {
 	/// The client instance to use.
 	pub client: Arc<C>,
 	/// Transaction pool instance.
@@ -102,7 +104,7 @@ pub struct FullDeps<C, P, SC, B> {
 	/// GRANDPA specific dependencies.
 	pub grandpa: GrandpaDeps<B>,
 	/// BEEFY specific dependencies.
-	pub beefy: BeefyDeps,
+	pub beefy: BeefyDeps<AuthorityId>,
 	/// Shared statement store reference.
 	pub statement_store: Arc<dyn sp_statement_store::StatementStore>,
 	/// The backend used by the node.
@@ -112,7 +114,7 @@ pub struct FullDeps<C, P, SC, B> {
 }
 
 /// Instantiate all Full RPC extensions.
-pub fn create_full<C, P, SC, B>(
+pub fn create_full<C, P, SC, B, AuthorityId>(
 	FullDeps {
 		client,
 		pool,
@@ -125,7 +127,7 @@ pub fn create_full<C, P, SC, B>(
 		statement_store,
 		backend,
 		mixnet_api,
-	}: FullDeps<C, P, SC, B>,
+	}: FullDeps<C, P, SC, B, AuthorityId>,
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
 	C: ProvideRuntimeApi<Block>
@@ -145,6 +147,8 @@ where
 	SC: SelectChain<Block> + 'static,
 	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
 	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashingFor<Block>>,
+	AuthorityId: AuthorityIdBound,
+	<AuthorityId as RuntimeAppPublic>::Signature: Send + Sync,
 {
 	use mmr_rpc::{Mmr, MmrApiServer};
 	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
@@ -223,7 +227,7 @@ where
 	}
 
 	io.merge(
-		Beefy::<Block>::new(
+		Beefy::<Block, AuthorityId>::new(
 			beefy.beefy_finality_proof_stream,
 			beefy.beefy_best_block_stream,
 			beefy.subscription_executor,
diff --git a/substrate/bin/node/runtime/Cargo.toml b/substrate/bin/node/runtime/Cargo.toml
index 98b8c0ae6bf35a85e5cb2225d4a4b5101f3f73e3..e8cc7b3482b66ef8e850871670430b23f2923396 100644
--- a/substrate/bin/node/runtime/Cargo.toml
+++ b/substrate/bin/node/runtime/Cargo.toml
@@ -31,408 +31,45 @@ serde_json = { features = ["alloc", "arbitrary_precision"], workspace = true }
 # pallet-asset-conversion: turn on "num-traits" feature
 primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "num-traits", "scale-info"] }
 
-# primitives
-sp-authority-discovery = { path = "../../../primitives/authority-discovery", default-features = false, features = ["serde"] }
-sp-consensus-babe = { path = "../../../primitives/consensus/babe", default-features = false, features = ["serde"] }
-sp-consensus-beefy = { path = "../../../primitives/consensus/beefy", default-features = false }
-sp-consensus-grandpa = { path = "../../../primitives/consensus/grandpa", default-features = false, features = ["serde"] }
-sp-block-builder = { path = "../../../primitives/block-builder", default-features = false }
-sp-genesis-builder = { default-features = false, path = "../../../primitives/genesis-builder" }
-sp-inherents = { path = "../../../primitives/inherents", default-features = false }
+polkadot-sdk = { path = "../../../../umbrella", features = ["runtime", "tuples-96"], default-features = false }
+
+# shared code between runtime and node
 node-primitives = { path = "../primitives", default-features = false }
-sp-mixnet = { path = "../../../primitives/mixnet", default-features = false }
-sp-offchain = { path = "../../../primitives/offchain", default-features = false }
-sp-core = { path = "../../../primitives/core", default-features = false, features = ["serde"] }
-sp-std = { path = "../../../primitives/std", default-features = false }
-sp-api = { path = "../../../primitives/api", default-features = false }
-sp-runtime = { path = "../../../primitives/runtime", default-features = false, features = ["serde"] }
-sp-staking = { path = "../../../primitives/staking", default-features = false, features = ["serde"] }
-sp-storage = { path = "../../../primitives/storage", default-features = false }
-sp-session = { path = "../../../primitives/session", default-features = false }
-sp-transaction-pool = { path = "../../../primitives/transaction-pool", default-features = false }
-sp-statement-store = { path = "../../../primitives/statement-store", default-features = false, features = ["serde"] }
-sp-version = { path = "../../../primitives/version", default-features = false, features = ["serde"] }
-sp-io = { path = "../../../primitives/io", default-features = false }
 
-# frame dependencies
-frame-executive = { path = "../../../frame/executive", default-features = false }
-frame-benchmarking = { path = "../../../frame/benchmarking", default-features = false }
-frame-benchmarking-pallet-pov = { path = "../../../frame/benchmarking/pov", default-features = false }
-frame-support = { path = "../../../frame/support", default-features = false, features = ["experimental", "tuples-96"] }
-frame-system = { path = "../../../frame/system", default-features = false }
-frame-system-benchmarking = { path = "../../../frame/system/benchmarking", default-features = false, optional = true }
-frame-election-provider-support = { path = "../../../frame/election-provider-support", default-features = false }
-frame-system-rpc-runtime-api = { path = "../../../frame/system/rpc/runtime-api", default-features = false }
-frame-try-runtime = { path = "../../../frame/try-runtime", default-features = false, optional = true }
-pallet-alliance = { path = "../../../frame/alliance", default-features = false }
-pallet-asset-conversion = { path = "../../../frame/asset-conversion", default-features = false }
-pallet-asset-conversion-ops = { path = "../../../frame/asset-conversion/ops", default-features = false }
-pallet-asset-rate = { path = "../../../frame/asset-rate", default-features = false }
-pallet-assets = { path = "../../../frame/assets", default-features = false }
-pallet-authority-discovery = { path = "../../../frame/authority-discovery", default-features = false }
-pallet-authorship = { path = "../../../frame/authorship", default-features = false }
-pallet-babe = { path = "../../../frame/babe", default-features = false }
-pallet-bags-list = { path = "../../../frame/bags-list", default-features = false }
-pallet-balances = { path = "../../../frame/balances", default-features = false }
-pallet-beefy = { path = "../../../frame/beefy", default-features = false }
-pallet-beefy-mmr = { path = "../../../frame/beefy-mmr", default-features = false }
-pallet-bounties = { path = "../../../frame/bounties", default-features = false }
-pallet-broker = { path = "../../../frame/broker", default-features = false }
-pallet-child-bounties = { path = "../../../frame/child-bounties", default-features = false }
-pallet-collective = { path = "../../../frame/collective", default-features = false }
-pallet-contracts = { path = "../../../frame/contracts", default-features = false }
-pallet-conviction-voting = { path = "../../../frame/conviction-voting", default-features = false }
-pallet-core-fellowship = { path = "../../../frame/core-fellowship", default-features = false }
-pallet-democracy = { path = "../../../frame/democracy", default-features = false }
-pallet-election-provider-multi-phase = { path = "../../../frame/election-provider-multi-phase", default-features = false }
-pallet-election-provider-support-benchmarking = { path = "../../../frame/election-provider-support/benchmarking", default-features = false, optional = true }
-pallet-elections-phragmen = { path = "../../../frame/elections-phragmen", default-features = false }
-pallet-example-tasks = { path = "../../../frame/examples/tasks", default-features = false }
-pallet-fast-unstake = { path = "../../../frame/fast-unstake", default-features = false }
-pallet-migrations = { path = "../../../frame/migrations", default-features = false }
+# Example pallets that are not published:
 pallet-example-mbm = { path = "../../../frame/examples/multi-block-migrations", default-features = false }
-pallet-nis = { path = "../../../frame/nis", default-features = false }
-pallet-grandpa = { path = "../../../frame/grandpa", default-features = false }
-pallet-im-online = { path = "../../../frame/im-online", default-features = false }
-pallet-indices = { path = "../../../frame/indices", default-features = false }
-pallet-identity = { path = "../../../frame/identity", default-features = false }
-pallet-lottery = { path = "../../../frame/lottery", default-features = false }
-pallet-membership = { path = "../../../frame/membership", default-features = false }
-pallet-message-queue = { path = "../../../frame/message-queue", default-features = false }
-pallet-mixnet = { path = "../../../frame/mixnet", default-features = false }
-pallet-mmr = { path = "../../../frame/merkle-mountain-range", default-features = false }
-pallet-multisig = { path = "../../../frame/multisig", default-features = false }
-pallet-nfts = { path = "../../../frame/nfts", default-features = false }
-pallet-nfts-runtime-api = { path = "../../../frame/nfts/runtime-api", default-features = false }
-pallet-nft-fractionalization = { path = "../../../frame/nft-fractionalization", default-features = false }
-pallet-nomination-pools = { path = "../../../frame/nomination-pools", default-features = false }
-pallet-nomination-pools-benchmarking = { path = "../../../frame/nomination-pools/benchmarking", default-features = false, optional = true }
-pallet-nomination-pools-runtime-api = { path = "../../../frame/nomination-pools/runtime-api", default-features = false }
-pallet-offences = { path = "../../../frame/offences", default-features = false }
-pallet-offences-benchmarking = { path = "../../../frame/offences/benchmarking", default-features = false, optional = true }
-pallet-glutton = { path = "../../../frame/glutton", default-features = false }
-pallet-preimage = { path = "../../../frame/preimage", default-features = false }
-pallet-proxy = { path = "../../../frame/proxy", default-features = false }
-pallet-insecure-randomness-collective-flip = { path = "../../../frame/insecure-randomness-collective-flip", default-features = false }
-pallet-ranked-collective = { path = "../../../frame/ranked-collective", default-features = false }
-pallet-recovery = { path = "../../../frame/recovery", default-features = false }
-pallet-referenda = { path = "../../../frame/referenda", default-features = false }
-pallet-remark = { path = "../../../frame/remark", default-features = false }
-pallet-root-testing = { path = "../../../frame/root-testing", default-features = false }
-pallet-salary = { path = "../../../frame/salary", default-features = false }
-pallet-session = { path = "../../../frame/session", default-features = false, features = ["historical"] }
-pallet-session-benchmarking = { path = "../../../frame/session/benchmarking", default-features = false, optional = true }
-pallet-staking = { path = "../../../frame/staking", default-features = false }
-pallet-staking-reward-curve = { path = "../../../frame/staking/reward-curve", default-features = false }
-pallet-staking-runtime-api = { path = "../../../frame/staking/runtime-api", default-features = false }
-pallet-state-trie-migration = { path = "../../../frame/state-trie-migration", default-features = false }
-pallet-statement = { path = "../../../frame/statement", default-features = false }
-pallet-scheduler = { path = "../../../frame/scheduler", default-features = false }
-pallet-society = { path = "../../../frame/society", default-features = false }
-pallet-sudo = { path = "../../../frame/sudo", default-features = false }
-pallet-timestamp = { path = "../../../frame/timestamp", default-features = false }
-pallet-tips = { path = "../../../frame/tips", default-features = false }
-pallet-treasury = { path = "../../../frame/treasury", default-features = false }
-pallet-utility = { path = "../../../frame/utility", default-features = false }
-pallet-transaction-payment = { path = "../../../frame/transaction-payment", default-features = false }
-pallet-transaction-payment-rpc-runtime-api = { path = "../../../frame/transaction-payment/rpc/runtime-api", default-features = false }
-pallet-asset-conversion-tx-payment = { path = "../../../frame/transaction-payment/asset-conversion-tx-payment", default-features = false }
-pallet-asset-tx-payment = { path = "../../../frame/transaction-payment/asset-tx-payment", default-features = false }
-pallet-skip-feeless-payment = { path = "../../../frame/transaction-payment/skip-feeless-payment", default-features = false }
-pallet-transaction-storage = { path = "../../../frame/transaction-storage", default-features = false }
-pallet-uniques = { path = "../../../frame/uniques", default-features = false }
-pallet-vesting = { path = "../../../frame/vesting", default-features = false }
-pallet-whitelist = { path = "../../../frame/whitelist", default-features = false }
-pallet-tx-pause = { path = "../../../frame/tx-pause", default-features = false }
-pallet-safe-mode = { path = "../../../frame/safe-mode", default-features = false }
-pallet-parameters = { path = "../../../frame/parameters", default-features = false }
+pallet-example-tasks = { path = "../../../frame/examples/tasks", default-features = false }
 
 [build-dependencies]
 substrate-wasm-builder = { path = "../../../utils/wasm-builder", optional = true }
 
 [features]
 default = ["std"]
-with-tracing = ["frame-executive/with-tracing"]
+with-tracing = ["polkadot-sdk/with-tracing"]
 std = [
 	"codec/std",
-	"frame-benchmarking-pallet-pov/std",
-	"frame-benchmarking/std",
-	"frame-election-provider-support/std",
-	"frame-executive/std",
-	"frame-support/std",
-	"frame-system-benchmarking?/std",
-	"frame-system-rpc-runtime-api/std",
-	"frame-system/std",
-	"frame-try-runtime?/std",
 	"log/std",
 	"node-primitives/std",
-	"pallet-alliance/std",
-	"pallet-asset-conversion-ops/std",
-	"pallet-asset-conversion-tx-payment/std",
-	"pallet-asset-conversion/std",
-	"pallet-asset-rate/std",
-	"pallet-asset-tx-payment/std",
-	"pallet-assets/std",
-	"pallet-authority-discovery/std",
-	"pallet-authorship/std",
-	"pallet-babe/std",
-	"pallet-bags-list/std",
-	"pallet-balances/std",
-	"pallet-beefy-mmr/std",
-	"pallet-beefy/std",
-	"pallet-bounties/std",
-	"pallet-broker/std",
-	"pallet-child-bounties/std",
-	"pallet-collective/std",
-	"pallet-contracts/std",
-	"pallet-conviction-voting/std",
-	"pallet-core-fellowship/std",
-	"pallet-democracy/std",
-	"pallet-election-provider-multi-phase/std",
-	"pallet-election-provider-support-benchmarking?/std",
-	"pallet-elections-phragmen/std",
 	"pallet-example-mbm/std",
 	"pallet-example-tasks/std",
-	"pallet-fast-unstake/std",
-	"pallet-glutton/std",
-	"pallet-grandpa/std",
-	"pallet-identity/std",
-	"pallet-im-online/std",
-	"pallet-indices/std",
-	"pallet-insecure-randomness-collective-flip/std",
-	"pallet-lottery/std",
-	"pallet-membership/std",
-	"pallet-message-queue/std",
-	"pallet-migrations/std",
-	"pallet-mixnet/std",
-	"pallet-mmr/std",
-	"pallet-multisig/std",
-	"pallet-nft-fractionalization/std",
-	"pallet-nfts-runtime-api/std",
-	"pallet-nfts/std",
-	"pallet-nis/std",
-	"pallet-nomination-pools-benchmarking?/std",
-	"pallet-nomination-pools-runtime-api/std",
-	"pallet-nomination-pools/std",
-	"pallet-offences-benchmarking?/std",
-	"pallet-offences/std",
-	"pallet-parameters/std",
-	"pallet-preimage/std",
-	"pallet-proxy/std",
-	"pallet-ranked-collective/std",
-	"pallet-recovery/std",
-	"pallet-referenda/std",
-	"pallet-remark/std",
-	"pallet-root-testing/std",
-	"pallet-safe-mode/std",
-	"pallet-salary/std",
-	"pallet-scheduler/std",
-	"pallet-session-benchmarking?/std",
-	"pallet-session/std",
-	"pallet-skip-feeless-payment/std",
-	"pallet-society/std",
-	"pallet-staking-runtime-api/std",
-	"pallet-staking/std",
-	"pallet-state-trie-migration/std",
-	"pallet-statement/std",
-	"pallet-sudo/std",
-	"pallet-timestamp/std",
-	"pallet-tips/std",
-	"pallet-transaction-payment-rpc-runtime-api/std",
-	"pallet-transaction-payment/std",
-	"pallet-transaction-storage/std",
-	"pallet-treasury/std",
-	"pallet-tx-pause/std",
-	"pallet-uniques/std",
-	"pallet-utility/std",
-	"pallet-vesting/std",
-	"pallet-whitelist/std",
+	"polkadot-sdk/std",
 	"primitive-types/std",
 	"scale-info/std",
 	"serde_json/std",
-	"sp-api/std",
-	"sp-authority-discovery/std",
-	"sp-block-builder/std",
-	"sp-consensus-babe/std",
-	"sp-consensus-beefy/std",
-	"sp-consensus-grandpa/std",
-	"sp-core/std",
-	"sp-genesis-builder/std",
-	"sp-inherents/std",
-	"sp-io/std",
-	"sp-mixnet/std",
-	"sp-offchain/std",
-	"sp-runtime/std",
-	"sp-session/std",
-	"sp-staking/std",
-	"sp-statement-store/std",
-	"sp-std/std",
-	"sp-storage/std",
-	"sp-transaction-pool/std",
-	"sp-version/std",
 	"substrate-wasm-builder",
 ]
 runtime-benchmarks = [
-	"frame-benchmarking-pallet-pov/runtime-benchmarks",
-	"frame-benchmarking/runtime-benchmarks",
-	"frame-election-provider-support/runtime-benchmarks",
-	"frame-support/runtime-benchmarks",
-	"frame-system-benchmarking/runtime-benchmarks",
-	"frame-system/runtime-benchmarks",
-	"pallet-alliance/runtime-benchmarks",
-	"pallet-asset-conversion-ops/runtime-benchmarks",
-	"pallet-asset-conversion/runtime-benchmarks",
-	"pallet-asset-rate/runtime-benchmarks",
-	"pallet-asset-tx-payment/runtime-benchmarks",
-	"pallet-assets/runtime-benchmarks",
-	"pallet-babe/runtime-benchmarks",
-	"pallet-bags-list/runtime-benchmarks",
-	"pallet-balances/runtime-benchmarks",
-	"pallet-bounties/runtime-benchmarks",
-	"pallet-broker/runtime-benchmarks",
-	"pallet-child-bounties/runtime-benchmarks",
-	"pallet-collective/runtime-benchmarks",
-	"pallet-contracts/runtime-benchmarks",
-	"pallet-conviction-voting/runtime-benchmarks",
-	"pallet-core-fellowship/runtime-benchmarks",
-	"pallet-democracy/runtime-benchmarks",
-	"pallet-election-provider-multi-phase/runtime-benchmarks",
-	"pallet-election-provider-support-benchmarking/runtime-benchmarks",
-	"pallet-elections-phragmen/runtime-benchmarks",
 	"pallet-example-mbm/runtime-benchmarks",
 	"pallet-example-tasks/runtime-benchmarks",
-	"pallet-fast-unstake/runtime-benchmarks",
-	"pallet-glutton/runtime-benchmarks",
-	"pallet-grandpa/runtime-benchmarks",
-	"pallet-identity/runtime-benchmarks",
-	"pallet-im-online/runtime-benchmarks",
-	"pallet-indices/runtime-benchmarks",
-	"pallet-lottery/runtime-benchmarks",
-	"pallet-membership/runtime-benchmarks",
-	"pallet-message-queue/runtime-benchmarks",
-	"pallet-migrations/runtime-benchmarks",
-	"pallet-mixnet/runtime-benchmarks",
-	"pallet-mmr/runtime-benchmarks",
-	"pallet-multisig/runtime-benchmarks",
-	"pallet-nft-fractionalization/runtime-benchmarks",
-	"pallet-nfts/runtime-benchmarks",
-	"pallet-nis/runtime-benchmarks",
-	"pallet-nomination-pools-benchmarking/runtime-benchmarks",
-	"pallet-nomination-pools/runtime-benchmarks",
-	"pallet-offences-benchmarking/runtime-benchmarks",
-	"pallet-offences/runtime-benchmarks",
-	"pallet-parameters/runtime-benchmarks",
-	"pallet-preimage/runtime-benchmarks",
-	"pallet-proxy/runtime-benchmarks",
-	"pallet-ranked-collective/runtime-benchmarks",
-	"pallet-recovery/runtime-benchmarks",
-	"pallet-referenda/runtime-benchmarks",
-	"pallet-remark/runtime-benchmarks",
-	"pallet-safe-mode/runtime-benchmarks",
-	"pallet-salary/runtime-benchmarks",
-	"pallet-scheduler/runtime-benchmarks",
-	"pallet-session-benchmarking/runtime-benchmarks",
-	"pallet-skip-feeless-payment/runtime-benchmarks",
-	"pallet-society/runtime-benchmarks",
-	"pallet-staking/runtime-benchmarks",
-	"pallet-state-trie-migration/runtime-benchmarks",
-	"pallet-sudo/runtime-benchmarks",
-	"pallet-timestamp/runtime-benchmarks",
-	"pallet-tips/runtime-benchmarks",
-	"pallet-transaction-storage/runtime-benchmarks",
-	"pallet-treasury/runtime-benchmarks",
-	"pallet-tx-pause/runtime-benchmarks",
-	"pallet-uniques/runtime-benchmarks",
-	"pallet-utility/runtime-benchmarks",
-	"pallet-vesting/runtime-benchmarks",
-	"pallet-whitelist/runtime-benchmarks",
-	"sp-runtime/runtime-benchmarks",
-	"sp-staking/runtime-benchmarks",
+	"polkadot-sdk/runtime-benchmarks",
 ]
 try-runtime = [
-	"frame-benchmarking-pallet-pov/try-runtime",
-	"frame-election-provider-support/try-runtime",
-	"frame-executive/try-runtime",
-	"frame-support/try-runtime",
-	"frame-system/try-runtime",
-	"frame-try-runtime/try-runtime",
-	"pallet-alliance/try-runtime",
-	"pallet-asset-conversion-ops/try-runtime",
-	"pallet-asset-conversion-tx-payment/try-runtime",
-	"pallet-asset-conversion/try-runtime",
-	"pallet-asset-rate/try-runtime",
-	"pallet-asset-tx-payment/try-runtime",
-	"pallet-assets/try-runtime",
-	"pallet-authority-discovery/try-runtime",
-	"pallet-authorship/try-runtime",
-	"pallet-babe/try-runtime",
-	"pallet-bags-list/try-runtime",
-	"pallet-balances/try-runtime",
-	"pallet-beefy-mmr/try-runtime",
-	"pallet-beefy/try-runtime",
-	"pallet-bounties/try-runtime",
-	"pallet-broker/try-runtime",
-	"pallet-child-bounties/try-runtime",
-	"pallet-collective/try-runtime",
-	"pallet-contracts/try-runtime",
-	"pallet-conviction-voting/try-runtime",
-	"pallet-core-fellowship/try-runtime",
-	"pallet-democracy/try-runtime",
-	"pallet-election-provider-multi-phase/try-runtime",
-	"pallet-elections-phragmen/try-runtime",
 	"pallet-example-mbm/try-runtime",
 	"pallet-example-tasks/try-runtime",
-	"pallet-fast-unstake/try-runtime",
-	"pallet-glutton/try-runtime",
-	"pallet-grandpa/try-runtime",
-	"pallet-identity/try-runtime",
-	"pallet-im-online/try-runtime",
-	"pallet-indices/try-runtime",
-	"pallet-insecure-randomness-collective-flip/try-runtime",
-	"pallet-lottery/try-runtime",
-	"pallet-membership/try-runtime",
-	"pallet-message-queue/try-runtime",
-	"pallet-migrations/try-runtime",
-	"pallet-mixnet/try-runtime",
-	"pallet-mmr/try-runtime",
-	"pallet-multisig/try-runtime",
-	"pallet-nft-fractionalization/try-runtime",
-	"pallet-nfts/try-runtime",
-	"pallet-nis/try-runtime",
-	"pallet-nomination-pools/try-runtime",
-	"pallet-offences/try-runtime",
-	"pallet-parameters/try-runtime",
-	"pallet-preimage/try-runtime",
-	"pallet-proxy/try-runtime",
-	"pallet-ranked-collective/try-runtime",
-	"pallet-recovery/try-runtime",
-	"pallet-referenda/try-runtime",
-	"pallet-remark/try-runtime",
-	"pallet-root-testing/try-runtime",
-	"pallet-safe-mode/try-runtime",
-	"pallet-salary/try-runtime",
-	"pallet-scheduler/try-runtime",
-	"pallet-session/try-runtime",
-	"pallet-skip-feeless-payment/try-runtime",
-	"pallet-society/try-runtime",
-	"pallet-staking/try-runtime",
-	"pallet-state-trie-migration/try-runtime",
-	"pallet-statement/try-runtime",
-	"pallet-sudo/try-runtime",
-	"pallet-timestamp/try-runtime",
-	"pallet-tips/try-runtime",
-	"pallet-transaction-payment/try-runtime",
-	"pallet-transaction-storage/try-runtime",
-	"pallet-treasury/try-runtime",
-	"pallet-tx-pause/try-runtime",
-	"pallet-uniques/try-runtime",
-	"pallet-utility/try-runtime",
-	"pallet-vesting/try-runtime",
-	"pallet-whitelist/try-runtime",
-	"sp-runtime/try-runtime",
+	"polkadot-sdk/try-runtime",
 ]
 experimental = [
-	"frame-support/experimental",
-	"frame-system/experimental",
 	"pallet-example-tasks/experimental",
 ]
+
+metadata-hash = ["substrate-wasm-builder/metadata-hash"]
diff --git a/substrate/bin/node/runtime/build.rs b/substrate/bin/node/runtime/build.rs
index b7676a70dfe843e2cd47fc600ef599bbe7bff591..0e11c579f09ee04918c5d53d4f8779044b57ef30 100644
--- a/substrate/bin/node/runtime/build.rs
+++ b/substrate/bin/node/runtime/build.rs
@@ -15,13 +15,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#[cfg(all(feature = "std", not(feature = "metadata-hash")))]
 fn main() {
-	#[cfg(feature = "std")]
-	{
-		substrate_wasm_builder::WasmBuilder::new()
-			.with_current_project()
-			.export_heap_base()
-			.import_memory()
-			.build();
-	}
+	substrate_wasm_builder::WasmBuilder::build_using_defaults()
 }
+
+#[cfg(all(feature = "std", feature = "metadata-hash"))]
+fn main() {
+	substrate_wasm_builder::WasmBuilder::init_with_defaults()
+		.enable_metadata_hash("Test", 14)
+		.build()
+}
+
+#[cfg(not(feature = "std"))]
+fn main() {}
diff --git a/substrate/bin/node/runtime/src/assets_api.rs b/substrate/bin/node/runtime/src/assets_api.rs
index 792ed7c6576bd85485eae9abe84ea17d5749cd13..38ec56507113f561721887689a5f4540121e2403 100644
--- a/substrate/bin/node/runtime/src/assets_api.rs
+++ b/substrate/bin/node/runtime/src/assets_api.rs
@@ -18,6 +18,8 @@
 
 //! Runtime API definition for assets.
 
+use polkadot_sdk::*;
+
 use codec::Codec;
 use sp_std::vec::Vec;
 
diff --git a/substrate/bin/node/runtime/src/impls.rs b/substrate/bin/node/runtime/src/impls.rs
index 34f043b33a4edfe2d8cdbe154896e937826110ca..dbe562857c99fcdd4730edd0aa5d985ab2e6dd51 100644
--- a/substrate/bin/node/runtime/src/impls.rs
+++ b/substrate/bin/node/runtime/src/impls.rs
@@ -17,6 +17,8 @@
 
 //! Some configurable implementations as associated type for the substrate runtime.
 
+use polkadot_sdk::*;
+
 use frame_support::{
 	pallet_prelude::*,
 	traits::{
@@ -118,6 +120,7 @@ mod multiplier_tests {
 		weights::{Weight, WeightToFee},
 	};
 	use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment};
+	use polkadot_sdk::*;
 	use sp_runtime::{
 		assert_eq_error_rate,
 		traits::{Convert, One, Zero},
diff --git a/substrate/bin/node/runtime/src/lib.rs b/substrate/bin/node/runtime/src/lib.rs
index 49e5bce3922db33a4477606f438a79380e4451ef..d683c4e086ed0a427d660cee6300d574a0f6a877 100644
--- a/substrate/bin/node/runtime/src/lib.rs
+++ b/substrate/bin/node/runtime/src/lib.rs
@@ -22,6 +22,8 @@
 // `construct_runtime!` does a lot of recursion and requires us to increase the limits.
 #![recursion_limit = "1024"]
 
+use polkadot_sdk::*;
+
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_election_provider_support::{
 	bounds::{ElectionBounds, ElectionBoundsBuilder},
@@ -47,7 +49,7 @@ use frame_support::{
 		AsEnsureOriginWithArg, ConstBool, ConstU128, ConstU16, ConstU32, Contains, Currency,
 		EitherOfDiverse, EnsureOriginWithArg, EqualPrivilegeOnly, Imbalance, InsideBoth,
 		InstanceFilter, KeyOwnerProofSystem, LinearStoragePrice, LockIdentifier, Nothing,
-		OnUnbalanced, WithdrawReasons,
+		OnUnbalanced, VariantCountOf, WithdrawReasons,
 	},
 	weights::{
 		constants::{
@@ -540,7 +542,7 @@ impl pallet_balances::Config for Runtime {
 	type AccountStore = frame_system::Pallet<Runtime>;
 	type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
 	type FreezeIdentifier = RuntimeFreezeReason;
-	type MaxFreezes = ConstU32<1>;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
 }
 
 parameter_types! {
@@ -910,7 +912,7 @@ impl pallet_nomination_pools::Config for Runtime {
 	type RewardCounter = FixedU128;
 	type BalanceToU256 = BalanceToU256;
 	type U256ToBalance = U256ToBalance;
-	type Staking = Staking;
+	type StakeAdapter = pallet_nomination_pools::adapter::TransferStake<Self, Staking>;
 	type PostUnbondingPoolsWindow = PostUnbondPoolsWindow;
 	type MaxMetadataLen = ConstU32<256>;
 	type MaxUnbonding = ConstU32<8>;
@@ -1210,8 +1212,6 @@ impl pallet_membership::Config<pallet_membership::Instance1> for Runtime {
 }
 
 parameter_types! {
-	pub const ProposalBond: Permill = Permill::from_percent(5);
-	pub const ProposalBondMinimum: Balance = 1 * DOLLARS;
 	pub const SpendPeriod: BlockNumber = 1 * DAYS;
 	pub const Burn: Permill = Permill::from_percent(50);
 	pub const TipCountdown: BlockNumber = 1 * DAYS;
@@ -1238,9 +1238,6 @@ impl pallet_treasury::Config for Runtime {
 	>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = ();
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ProposalBondMinimum;
-	type ProposalBondMaximum = ();
 	type SpendPeriod = SpendPeriod;
 	type Burn = Burn;
 	type BurnDestination = ();
@@ -1437,6 +1434,7 @@ where
 					tip, None,
 				),
 			),
+			frame_metadata_hash_extension::CheckMetadataHash::new(false),
 		);
 		let raw_payload = SignedPayload::new(call, extra)
 			.map_err(|e| {
@@ -2142,7 +2140,7 @@ impl pallet_broker::Config for Runtime {
 	type WeightInfo = ();
 	type PalletId = BrokerPalletId;
 	type AdminOrigin = EnsureRoot<AccountId>;
-	type PriceAdapter = pallet_broker::Linear;
+	type PriceAdapter = pallet_broker::CenterTargetPrice<Balance>;
 }
 
 parameter_types! {
@@ -2228,6 +2226,8 @@ impl pallet_parameters::Config for Runtime {
 
 #[frame_support::runtime]
 mod runtime {
+	use super::*;
+
 	#[runtime::runtime]
 	#[runtime::derive(
 		RuntimeCall,
@@ -2514,6 +2514,7 @@ pub type SignedExtra = (
 		Runtime,
 		pallet_asset_conversion_tx_payment::ChargeAssetTxPayment<Runtime>,
 	>,
+	frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 
 /// Unchecked extrinsic type as expected by this runtime.
@@ -2569,7 +2570,7 @@ impl pallet_beefy::Config for Runtime {
 
 /// MMR helper types.
 mod mmr {
-	use super::Runtime;
+	use super::*;
 	pub use pallet_mmr::primitives::*;
 
 	pub type Leaf = <<Runtime as pallet_mmr::Config>::LeafData as LeafDataProvider>::LeafData;
@@ -2579,7 +2580,7 @@ mod mmr {
 
 #[cfg(feature = "runtime-benchmarks")]
 mod benches {
-	frame_benchmarking::define_benchmarks!(
+	polkadot_sdk::frame_benchmarking::define_benchmarks!(
 		[frame_benchmarking, BaselineBench::<Runtime>]
 		[frame_benchmarking_pallet_pov, Pov]
 		[pallet_alliance, Alliance]
@@ -2768,6 +2769,22 @@ impl_runtime_apis! {
 		fn balance_to_points(pool_id: pallet_nomination_pools::PoolId, new_funds: Balance) -> Balance {
 			NominationPools::api_balance_to_points(pool_id, new_funds)
 		}
+
+		fn pool_pending_slash(pool_id: pallet_nomination_pools::PoolId) -> Balance {
+			NominationPools::api_pool_pending_slash(pool_id)
+		}
+
+		fn member_pending_slash(member: AccountId) -> Balance {
+			NominationPools::api_member_pending_slash(member)
+		}
+
+		fn pool_needs_delegate_migration(pool_id: pallet_nomination_pools::PoolId) -> bool {
+			NominationPools::api_pool_needs_delegate_migration(pool_id)
+		}
+
+		fn member_needs_delegate_migration(member: AccountId) -> bool {
+			NominationPools::api_member_needs_delegate_migration(member)
+		}
 	}
 
 	impl pallet_staking_runtime_api::StakingApi<Block, Balance, AccountId> for Runtime {
diff --git a/substrate/bin/node/testing/Cargo.toml b/substrate/bin/node/testing/Cargo.toml
index 09db10563fb27e485c1f7ff5052896e7c2b6fb4f..3ba3f07510e006458cf23b246e293af4e288c624 100644
--- a/substrate/bin/node/testing/Cargo.toml
+++ b/substrate/bin/node/testing/Cargo.toml
@@ -21,6 +21,7 @@ fs_extra = "1"
 futures = "0.3.30"
 log = { workspace = true, default-features = true }
 tempfile = "3.1.0"
+frame-metadata-hash-extension = { path = "../../../frame/metadata-hash-extension" }
 frame-system = { path = "../../../frame/system" }
 node-cli = { package = "staging-node-cli", path = "../cli" }
 node-primitives = { path = "../primitives" }
diff --git a/substrate/bin/node/testing/src/bench.rs b/substrate/bin/node/testing/src/bench.rs
index e5c2563905e9ea59901db1564f2b0f34f6bd4aec..007d314684cf17faeda6adb4842513ea57030fdc 100644
--- a/substrate/bin/node/testing/src/bench.rs
+++ b/substrate/bin/node/testing/src/bench.rs
@@ -571,6 +571,8 @@ impl BenchKeyring {
 					tx_version,
 					genesis_hash,
 					genesis_hash,
+					// metadata_hash
+					None::<()>,
 				);
 				let key = self.accounts.get(&signed).expect("Account id not found in keyring");
 				let signature = payload.using_encoded(|b| {
diff --git a/substrate/bin/node/testing/src/keyring.rs b/substrate/bin/node/testing/src/keyring.rs
index f712191bed695031275cfb11c5e22c8fa2a26f78..eab088d9100ef266f26b600a501e78881e557efe 100644
--- a/substrate/bin/node/testing/src/keyring.rs
+++ b/substrate/bin/node/testing/src/keyring.rs
@@ -82,6 +82,7 @@ pub fn signed_extra(nonce: Nonce, extra_fee: Balance) -> SignedExtra {
 		pallet_skip_feeless_payment::SkipCheckIfFeeless::from(
 			pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::from(extra_fee, None),
 		),
+		frame_metadata_hash_extension::CheckMetadataHash::new(false),
 	)
 }
 
@@ -91,11 +92,19 @@ pub fn sign(
 	spec_version: u32,
 	tx_version: u32,
 	genesis_hash: [u8; 32],
+	metadata_hash: Option<[u8; 32]>,
 ) -> UncheckedExtrinsic {
 	match xt.signed {
 		Some((signed, extra)) => {
-			let payload =
-				(xt.function, extra.clone(), spec_version, tx_version, genesis_hash, genesis_hash);
+			let payload = (
+				xt.function,
+				extra.clone(),
+				spec_version,
+				tx_version,
+				genesis_hash,
+				genesis_hash,
+				metadata_hash,
+			);
 			let key = AccountKeyring::from_account_id(&signed).unwrap();
 			let signature =
 				payload
diff --git a/substrate/bin/utils/chain-spec-builder/Cargo.toml b/substrate/bin/utils/chain-spec-builder/Cargo.toml
index 5c8a3ab4e89a55e5e61c371a41878ab8457ec12b..88585649acfe015e2e1e7ca6285c1a3565ca6f78 100644
--- a/substrate/bin/utils/chain-spec-builder/Cargo.toml
+++ b/substrate/bin/utils/chain-spec-builder/Cargo.toml
@@ -1,13 +1,14 @@
 [package]
 name = "staging-chain-spec-builder"
-version = "3.0.0"
+version = "1.6.1"
 authors.workspace = true
 edition.workspace = true
 build = "build.rs"
 license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
 homepage = "https://substrate.io"
 repository.workspace = true
-publish = false
+publish = true
+description = "Utility for building chain-specification files for Substrate-based runtimes based on `sp-genesis-builder`"
 
 [lints]
 workspace = true
@@ -25,6 +26,6 @@ crate-type = ["rlib"]
 [dependencies]
 clap = { version = "4.5.3", features = ["derive"] }
 log = { workspace = true, default-features = true }
-sc-chain-spec = { path = "../../../client/chain-spec" }
+sc-chain-spec = { path = "../../../client/chain-spec", features = ["clap"] }
 serde_json = { workspace = true, default-features = true }
 sp-tracing = { path = "../../../primitives/tracing" }
diff --git a/substrate/bin/utils/chain-spec-builder/bin/main.rs b/substrate/bin/utils/chain-spec-builder/bin/main.rs
index 8d6425a46c770765cfe1f4cf60ba755b248f3a78..18da3c30691bd895c833454cb6cd9f6fda91531d 100644
--- a/substrate/bin/utils/chain-spec-builder/bin/main.rs
+++ b/substrate/bin/utils/chain-spec-builder/bin/main.rs
@@ -99,7 +99,7 @@ fn inner_main() -> Result<(), String> {
 					)
 				})
 				.collect();
-			println!("{presets:#?}");
+			println!("{}", serde_json::json!({"presets":presets}).to_string());
 		},
 		ChainSpecBuilderCmd::DisplayPreset(DisplayPresetCmd { runtime_wasm_path, preset_name }) => {
 			let code = fs::read(runtime_wasm_path.as_path())
diff --git a/substrate/bin/utils/chain-spec-builder/src/lib.rs b/substrate/bin/utils/chain-spec-builder/src/lib.rs
index 7982da76227aeb70cc4683cc1887440cb2c0ecc0..4c00bb3551b39fbe810db2ce324d69aea1092387 100644
--- a/substrate/bin/utils/chain-spec-builder/src/lib.rs
+++ b/substrate/bin/utils/chain-spec-builder/src/lib.rs
@@ -120,12 +120,12 @@
 use std::{fs, path::PathBuf};
 
 use clap::{Parser, Subcommand};
-use sc_chain_spec::{GenericChainSpec, GenesisConfigBuilderRuntimeCaller};
+use sc_chain_spec::{ChainType, GenericChainSpec, GenesisConfigBuilderRuntimeCaller};
 use serde_json::Value;
 
 /// A utility to easily create a chain spec definition.
 #[derive(Debug, Parser)]
-#[command(rename_all = "kebab-case")]
+#[command(rename_all = "kebab-case", version, about)]
 pub struct ChainSpecBuilder {
 	#[command(subcommand)]
 	pub command: ChainSpecBuilderCmd,
@@ -154,6 +154,9 @@ pub struct CreateCmd {
 	/// The chain id.
 	#[arg(long, short = 'i', default_value = "custom")]
 	chain_id: String,
+	/// The chain type.
+	#[arg(value_enum, short = 't', default_value = "live")]
+	chain_type: ChainType,
 	/// The path to runtime wasm blob.
 	#[arg(long, short)]
 	runtime_wasm_path: PathBuf,
@@ -206,9 +209,14 @@ struct NamedPresetCmd {
 ///
 /// The code field of the chain spec will be updated with the runtime provided in the
 /// command line. This operation supports both plain and raw formats.
+///
+/// This command does not update chain-spec file in-place. The result of this command will be stored
+/// in a file given as `-c/--chain-spec-path` command line argument.
 #[derive(Parser, Debug, Clone)]
 pub struct UpdateCodeCmd {
 	/// Chain spec to be updated.
+	///
+	/// Please note that the file will not be updated in-place.
 	pub input_chain_spec: PathBuf,
 	/// The path to new runtime wasm blob to be stored into chain-spec.
 	pub runtime_wasm_path: PathBuf,
@@ -256,10 +264,12 @@ pub fn generate_chain_spec_for_runtime(cmd: &CreateCmd) -> Result<String, String
 	let code = fs::read(cmd.runtime_wasm_path.as_path())
 		.map_err(|e| format!("wasm blob shall be readable {e}"))?;
 
+	let chain_type = &cmd.chain_type;
+
 	let builder = GenericChainSpec::<()>::builder(&code[..], Default::default())
 		.with_name(&cmd.chain_name[..])
 		.with_id(&cmd.chain_id[..])
-		.with_chain_type(sc_chain_spec::ChainType::Live);
+		.with_chain_type(chain_type.clone());
 
 	let builder = match cmd.action {
 		GenesisBuildAction::NamedPreset(NamedPresetCmd { ref preset_name }) =>
diff --git a/substrate/bin/utils/subkey/README.md b/substrate/bin/utils/subkey/README.md
index fc1053e232d70d746cf315d203a51dfd09e8447c..5c6dda37edf681b0425fa5e2c2072fd511200587 100644
--- a/substrate/bin/utils/subkey/README.md
+++ b/substrate/bin/utils/subkey/README.md
@@ -74,7 +74,7 @@ The output above shows a **secret phrase** (also called **mnemonic phrase**) and
 **Private Key**). Those 2 secrets are the pieces of information you MUST keep safe and secret. All the other information
 below can be derived from those secrets.
 
-The output above also show the **public key** and the **Account ID**. Those are the independent from the network where
+The output above also shows the **public key** and the **Account ID**. Those are the independent from the network where
 you will use the key.
 
 The **SS58 address** (or **Public Address**) of a new account is a representation of the public keys of an account for
@@ -152,7 +152,7 @@ subkey inspect "soup lyrics media market way crouch elevator put moon useful que
 
 which recovers the account `5Fe4sqj2K4fRuzEGvToi4KATqZfiDU7TqynjXG6PZE2dxwyh` and not
 `5He5pZpc7AJ8evPuab37vJF6KkFDqq9uDq2WXh877Qw6iaVC` as we expected. The additional user-defined **password**
-(`extra_secret` in our example) is now required to fully recover the account. Let's inspect the the previous mnemonic,
+(`extra_secret` in our example) is now required to fully recover the account. Let's inspect the previous mnemonic,
 this time passing also the required `password` as shown below:
 
 ```bash
diff --git a/substrate/client/api/src/client.rs b/substrate/client/api/src/client.rs
index 2de09840e4dfdc15e1f1d1acaa5f3e438de0caca..45cfafb258463a50c2ce0ce5b843346bd6cb9dcb 100644
--- a/substrate/client/api/src/client.rs
+++ b/substrate/client/api/src/client.rs
@@ -168,7 +168,7 @@ pub trait ProvideUncles<Block: BlockT> {
 }
 
 /// Client info
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ClientInfo<Block: BlockT> {
 	/// Best block hash.
 	pub chain: Info<Block>,
diff --git a/substrate/client/authority-discovery/src/error.rs b/substrate/client/authority-discovery/src/error.rs
index 6f791237c2f229c3f94996e2a91c0c0de8800d0d..3f395e47922e216e64e0853d866114000a53b00a 100644
--- a/substrate/client/authority-discovery/src/error.rs
+++ b/substrate/client/authority-discovery/src/error.rs
@@ -35,7 +35,7 @@ pub enum Error {
 	VerifyingDhtPayload,
 
 	#[error("Failed to hash the authority id to be used as a dht key.")]
-	HashingAuthorityId(#[from] sc_network::multiaddr::multihash::Error),
+	HashingAuthorityId(#[from] sc_network_types::multihash::Error),
 
 	#[error("Failed calling into the Substrate runtime: {0}")]
 	CallingRuntime(#[from] sp_blockchain::Error),
@@ -53,7 +53,7 @@ pub enum Error {
 	EncodingDecodingScale(#[from] codec::Error),
 
 	#[error("Failed to parse a libp2p multi address.")]
-	ParsingMultiaddress(#[from] sc_network::multiaddr::Error),
+	ParsingMultiaddress(#[from] sc_network::multiaddr::ParseError),
 
 	#[error("Failed to parse a libp2p key: {0}")]
 	ParsingLibp2pIdentity(String),
@@ -75,4 +75,10 @@ pub enum Error {
 
 	#[error("Unable to fetch best block.")]
 	BestBlockFetchingError,
+
+	#[error("Publisher not present.")]
+	MissingPublisher,
+
+	#[error("Unknown authority.")]
+	UnknownAuthority,
 }
diff --git a/substrate/client/authority-discovery/src/worker.rs b/substrate/client/authority-discovery/src/worker.rs
index 53418d2d38c4a0ce0ab2c2b938b288360d2fdbbc..f20cf6aa2121204063982bc7717bf094ac561c53 100644
--- a/substrate/client/authority-discovery/src/worker.rs
+++ b/substrate/client/authority-discovery/src/worker.rs
@@ -35,7 +35,6 @@ use addr_cache::AddrCache;
 use codec::{Decode, Encode};
 use ip_network::IpNetwork;
 use linked_hash_set::LinkedHashSet;
-use multihash::{Code, Multihash, MultihashDigest};
 
 use log::{debug, error, log_enabled};
 use prometheus_endpoint::{register, Counter, CounterVec, Gauge, Opts, U64};
@@ -46,7 +45,11 @@ use sc_network::{
 	event::DhtEvent, multiaddr, KademliaKey, Multiaddr, NetworkDHTProvider, NetworkSigner,
 	NetworkStateInfo,
 };
-use sc_network_types::PeerId;
+use sc_network_types::{
+	multihash::{Code, Multihash},
+	PeerId,
+};
+use schema::PeerSignature;
 use sp_api::{ApiError, ProvideRuntimeApi};
 use sp_authority_discovery::{
 	AuthorityDiscoveryApi, AuthorityId, AuthorityPair, AuthoritySignature,
@@ -109,7 +112,7 @@ pub enum Role {
 ///    network peerset.
 ///
 ///    5. Allow querying of the collected addresses via the [`crate::Service`].
-pub struct Worker<Client, Block, DhtEventStream> {
+pub struct Worker<Client, Block: BlockT, DhtEventStream> {
 	/// Channel receiver for messages send by a [`crate::Service`].
 	from_service: Fuse<mpsc::Receiver<ServicetoWorkerMsg>>,
 
@@ -150,6 +153,12 @@ pub struct Worker<Client, Block, DhtEventStream> {
 	/// Queue of throttled lookups pending to be passed to the network.
 	pending_lookups: Vec<AuthorityId>,
 
+	/// The list of all known authorities.
+	known_authorities: HashMap<KademliaKey, AuthorityId>,
+
+	/// The last time we requested the list of authorities.
+	authorities_queried_at: Option<Block::Hash>,
+
 	/// Set of in-flight lookups.
 	in_flight_lookups: HashMap<KademliaKey, AuthorityId>,
 
@@ -266,6 +275,8 @@ where
 			network,
 			dht_event_rx,
 			publish_interval,
+			known_authorities: Default::default(),
+			authorities_queried_at: None,
 			publish_if_changed_interval,
 			latest_published_keys: HashSet::new(),
 			latest_published_kad_keys: HashSet::new(),
@@ -480,6 +491,13 @@ where
 			.filter(|id| !local_keys.contains(id.as_ref()))
 			.collect::<Vec<_>>();
 
+		self.known_authorities = authorities
+			.clone()
+			.into_iter()
+			.map(|authority| (hash_authority_id(authority.as_ref()), authority))
+			.collect::<HashMap<_, _>>();
+		self.authorities_queried_at = Some(best_hash);
+
 		self.addr_cache.retain_ids(&authorities);
 
 		authorities.shuffle(&mut thread_rng());
@@ -579,9 +597,114 @@ where
 
 				debug!(target: LOG_TARGET, "Failed to put hash '{:?}' on Dht.", hash)
 			},
+			DhtEvent::PutRecordRequest(record_key, record_value, publisher, expires) => {
+				if let Err(e) = self
+					.handle_put_record_requested(record_key, record_value, publisher, expires)
+					.await
+				{
+					debug!(target: LOG_TARGET, "Failed to handle put record request: {}", e)
+				}
+
+				if let Some(metrics) = &self.metrics {
+					metrics.dht_event_received.with_label_values(&["put_record_req"]).inc();
+				}
+			},
 		}
 	}
 
+	async fn handle_put_record_requested(
+		&mut self,
+		record_key: KademliaKey,
+		record_value: Vec<u8>,
+		publisher: Option<PeerId>,
+		expires: Option<std::time::Instant>,
+	) -> Result<()> {
+		let publisher = publisher.ok_or(Error::MissingPublisher)?;
+
+		// Make sure we don't ever work with an outdated set of authorities
+		// and that we do not update known_authorithies too often.
+		let best_hash = self.client.best_hash().await?;
+		if !self.known_authorities.contains_key(&record_key) &&
+			self.authorities_queried_at
+				.map(|authorities_queried_at| authorities_queried_at != best_hash)
+				.unwrap_or(true)
+		{
+			let authorities = self
+				.client
+				.authorities(best_hash)
+				.await
+				.map_err(|e| Error::CallingRuntime(e.into()))?
+				.into_iter()
+				.collect::<Vec<_>>();
+
+			self.known_authorities = authorities
+				.into_iter()
+				.map(|authority| (hash_authority_id(authority.as_ref()), authority))
+				.collect::<HashMap<_, _>>();
+
+			self.authorities_queried_at = Some(best_hash);
+		}
+
+		let authority_id =
+			self.known_authorities.get(&record_key).ok_or(Error::UnknownAuthority)?;
+		let signed_record =
+			Self::check_record_signed_with_authority_id(record_value.as_slice(), authority_id)?;
+		self.check_record_signed_with_network_key(
+			&signed_record.record,
+			signed_record.peer_signature,
+			publisher,
+			authority_id,
+		)?;
+		self.network.store_record(record_key, record_value, Some(publisher), expires);
+		Ok(())
+	}
+
+	fn check_record_signed_with_authority_id(
+		record: &[u8],
+		authority_id: &AuthorityId,
+	) -> Result<schema::SignedAuthorityRecord> {
+		let signed_record: schema::SignedAuthorityRecord =
+			schema::SignedAuthorityRecord::decode(record).map_err(Error::DecodingProto)?;
+
+		let auth_signature = AuthoritySignature::decode(&mut &signed_record.auth_signature[..])
+			.map_err(Error::EncodingDecodingScale)?;
+
+		if !AuthorityPair::verify(&auth_signature, &signed_record.record, &authority_id) {
+			return Err(Error::VerifyingDhtPayload)
+		}
+
+		Ok(signed_record)
+	}
+
+	fn check_record_signed_with_network_key(
+		&self,
+		record: &Vec<u8>,
+		peer_signature: Option<PeerSignature>,
+		remote_peer_id: PeerId,
+		authority_id: &AuthorityId,
+	) -> Result<()> {
+		if let Some(peer_signature) = peer_signature {
+			match self.network.verify(
+				remote_peer_id.into(),
+				&peer_signature.public_key,
+				&peer_signature.signature,
+				record,
+			) {
+				Ok(true) => {},
+				Ok(false) => return Err(Error::VerifyingDhtPayload),
+				Err(error) => return Err(Error::ParsingLibp2pIdentity(error)),
+			}
+		} else if self.strict_record_validation {
+			return Err(Error::MissingPeerIdSignature)
+		} else {
+			debug!(
+				target: LOG_TARGET,
+				"Received unsigned authority discovery record from {}", authority_id
+			);
+		}
+		Ok(())
+	}
+
 	fn handle_dht_value_found_event(&mut self, values: Vec<(KademliaKey, Vec<u8>)>) -> Result<()> {
 		// Ensure `values` is not empty and all its keys equal.
 		let remote_key = single(values.iter().map(|(key, _)| key.clone()))
@@ -598,16 +721,8 @@ where
 		let remote_addresses: Vec<Multiaddr> = values
 			.into_iter()
 			.map(|(_k, v)| {
-				let schema::SignedAuthorityRecord { record, auth_signature, peer_signature } =
-					schema::SignedAuthorityRecord::decode(v.as_slice())
-						.map_err(Error::DecodingProto)?;
-
-				let auth_signature = AuthoritySignature::decode(&mut &auth_signature[..])
-					.map_err(Error::EncodingDecodingScale)?;
-
-				if !AuthorityPair::verify(&auth_signature, &record, &authority_id) {
-					return Err(Error::VerifyingDhtPayload)
-				}
+				let schema::SignedAuthorityRecord { record, peer_signature, .. } =
+					Self::check_record_signed_with_authority_id(&v, &authority_id)?;
 
 				let addresses: Vec<Multiaddr> = schema::AuthorityRecord::decode(record.as_slice())
 					.map(|a| a.addresses)
@@ -636,26 +751,12 @@ where
 				// At this point we know all the valid multiaddresses from the record, know that
 				// each of them belong to the same PeerId, we just need to check if the record is
 				// properly signed by the owner of the PeerId
-
-				if let Some(peer_signature) = peer_signature {
-					match self.network.verify(
-						remote_peer_id.into(),
-						&peer_signature.public_key,
-						&peer_signature.signature,
-						&record,
-					) {
-						Ok(true) => {},
-						Ok(false) => return Err(Error::VerifyingDhtPayload),
-						Err(error) => return Err(Error::ParsingLibp2pIdentity(error)),
-					}
-				} else if self.strict_record_validation {
-					return Err(Error::MissingPeerIdSignature)
-				} else {
-					debug!(
-						target: LOG_TARGET,
-						"Received unsigned authority discovery record from {}", authority_id
-					);
-				}
+				self.check_record_signed_with_network_key(
+					&record,
+					peer_signature,
+					remote_peer_id,
+					&authority_id,
+				)?;
 				Ok(addresses)
 			})
 			.collect::<Result<Vec<Vec<Multiaddr>>>>()?
@@ -868,7 +969,7 @@ impl Metrics {
 
 // Helper functions for unit testing.
 #[cfg(test)]
-impl<Block, Client, DhtEventStream> Worker<Client, Block, DhtEventStream> {
+impl<Block: BlockT, Client, DhtEventStream> Worker<Client, Block, DhtEventStream> {
 	pub(crate) fn inject_addresses(&mut self, authority: AuthorityId, addresses: Vec<Multiaddr>) {
 		self.addr_cache.insert(authority, addresses);
 	}
diff --git a/substrate/client/authority-discovery/src/worker/addr_cache.rs b/substrate/client/authority-discovery/src/worker/addr_cache.rs
index 6e3b3c8af20190f3711aac72fbd5e7cf3eb493c7..77cdfbd4f1502574cd5a1aa2434d3c0fd392fd51 100644
--- a/substrate/client/authority-discovery/src/worker/addr_cache.rs
+++ b/substrate/client/authority-discovery/src/worker/addr_cache.rs
@@ -176,8 +176,8 @@ fn addresses_to_peer_ids(addresses: &HashSet<Multiaddr>) -> HashSet<PeerId> {
 mod tests {
 	use super::*;
 
-	use multihash::{self, Multihash};
 	use quickcheck::{Arbitrary, Gen, QuickCheck, TestResult};
+	use sc_network_types::multihash::Multihash;
 
 	use sp_authority_discovery::{AuthorityId, AuthorityPair};
 	use sp_core::crypto::Pair;
diff --git a/substrate/client/authority-discovery/src/worker/tests.rs b/substrate/client/authority-discovery/src/worker/tests.rs
index caeac56c54073e53026ec3f8c52c8e7f88958f2b..de7443d634fa79e7761b39b3c2fab3e16adb4a0b 100644
--- a/substrate/client/authority-discovery/src/worker/tests.rs
+++ b/substrate/client/authority-discovery/src/worker/tests.rs
@@ -20,6 +20,7 @@ use std::{
 	collections::HashSet,
 	sync::{Arc, Mutex},
 	task::Poll,
+	time::Instant,
 };
 
 use futures::{
@@ -29,11 +30,15 @@ use futures::{
 	sink::SinkExt,
 	task::LocalSpawn,
 };
-use libp2p::{core::multiaddr, identity::SigningError, kad::record::Key as KademliaKey, PeerId};
+use libp2p::{identity::SigningError, kad::record::Key as KademliaKey};
 use prometheus_endpoint::prometheus::default_registry;
 
 use sc_client_api::HeaderBackend;
 use sc_network::{service::signature::Keypair, Signature};
+use sc_network_types::{
+	multiaddr::{Multiaddr, Protocol},
+	PeerId,
+};
 use sp_api::{ApiRef, ProvideRuntimeApi};
 use sp_keystore::{testing::MemoryKeystore, Keystore};
 use sp_runtime::traits::{Block as BlockT, NumberFor, Zero};
@@ -114,6 +119,7 @@ sp_api::mock_impl_runtime_apis! {
 pub enum TestNetworkEvent {
 	GetCalled(KademliaKey),
 	PutCalled(KademliaKey, Vec<u8>),
+	StoreRecordCalled(KademliaKey, Vec<u8>, Option<sc_network_types::PeerId>, Option<Instant>),
 }
 
 pub struct TestNetwork {
@@ -124,6 +130,9 @@ pub struct TestNetwork {
 	// vectors below.
 	pub put_value_call: Arc<Mutex<Vec<(KademliaKey, Vec<u8>)>>>,
 	pub get_value_call: Arc<Mutex<Vec<KademliaKey>>>,
+	pub store_value_call:
+		Arc<Mutex<Vec<(KademliaKey, Vec<u8>, Option<sc_network_types::PeerId>, Option<Instant>)>>>,
+
 	event_sender: mpsc::UnboundedSender<TestNetworkEvent>,
 	event_receiver: Option<mpsc::UnboundedReceiver<TestNetworkEvent>>,
 }
@@ -144,6 +153,7 @@ impl Default for TestNetwork {
 			external_addresses: vec!["/ip6/2001:db8::/tcp/30333".parse().unwrap()],
 			put_value_call: Default::default(),
 			get_value_call: Default::default(),
+			store_value_call: Default::default(),
 			event_sender: tx,
 			event_receiver: Some(rx),
 		}
@@ -168,7 +178,7 @@ impl NetworkSigner for TestNetwork {
 		let public_key = libp2p::identity::PublicKey::try_decode_protobuf(&public_key)
 			.map_err(|error| error.to_string())?;
 		let peer_id: PeerId = peer_id.into();
-		let remote: libp2p::PeerId = public_key.to_peer_id();
+		let remote: PeerId = public_key.to_peer_id().into();
 
 		Ok(peer_id == remote && public_key.verify(message, signature))
 	}
@@ -189,6 +199,25 @@ impl NetworkDHTProvider for TestNetwork {
 			.unbounded_send(TestNetworkEvent::GetCalled(key.clone()))
 			.unwrap();
 	}
+
+	fn store_record(
+		&self,
+		key: KademliaKey,
+		value: Vec<u8>,
+		publisher: Option<PeerId>,
+		expires: Option<Instant>,
+	) {
+		self.store_value_call.lock().unwrap().push((
+			key.clone(),
+			value.clone(),
+			publisher,
+			expires,
+		));
+		self.event_sender
+			.clone()
+			.unbounded_send(TestNetworkEvent::StoreRecordCalled(key, value, publisher, expires))
+			.unwrap();
+	}
 }
 
 impl NetworkStateInfo for TestNetwork {
@@ -435,7 +464,7 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() {
 		let peer_id = PeerId::random();
 		let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();
 
-		address.with(multiaddr::Protocol::P2p(peer_id.into()))
+		address.with(Protocol::P2p(peer_id.into()))
 	};
 	let remote_key_store = MemoryKeystore::new();
 	let remote_public_key: AuthorityId = remote_key_store
@@ -867,3 +896,106 @@ fn lookup_throttling() {
 		.boxed_local(),
 	);
 }
+
+#[test]
+fn test_handle_put_record_request() {
+	let network = TestNetwork::default();
+	let peer_id = network.peer_id;
+
+	let remote_multiaddr = {
+		let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap();
+
+		address.with(multiaddr::Protocol::P2p(peer_id.into()))
+	};
+	let remote_key_store = MemoryKeystore::new();
+	let remote_public_keys: Vec<AuthorityId> = (0..20)
+		.map(|_| {
+			remote_key_store
+				.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
+				.unwrap()
+				.into()
+		})
+		.collect();
+
+	let remote_non_authorithy_keys: Vec<AuthorityId> = (0..20)
+		.map(|_| {
+			remote_key_store
+				.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
+				.unwrap()
+				.into()
+		})
+		.collect();
+
+	let (_dht_event_tx, dht_event_rx) = channel(1);
+	let (_to_worker, from_service) = mpsc::channel(0);
+	let network = Arc::new(network);
+	let mut worker = Worker::new(
+		from_service,
+		Arc::new(TestApi { authorities: remote_public_keys.clone() }),
+		network.clone(),
+		dht_event_rx.boxed(),
+		Role::Discover,
+		Some(default_registry().clone()),
+		Default::default(),
+	);
+
+	let mut pool = LocalPool::new();
+
+	let valid_authorithy_key = remote_public_keys.first().unwrap().clone();
+
+	let kv_pairs = build_dht_event(
+		vec![remote_multiaddr],
+		valid_authorithy_key.into(),
+		&remote_key_store,
+		Some(&TestSigner { keypair: &network.identity }),
+	);
+
+	pool.run_until(
+		async {
+			// Invalid format should return an error.
+			for authority in remote_public_keys.iter() {
+				let key = hash_authority_id(authority.as_ref());
+				assert!(matches!(
+					worker.handle_put_record_requested(key, vec![0x0], Some(peer_id), None).await,
+					Err(Error::DecodingProto(_))
+				));
+			}
+			let prev_requested_authorithies = worker.authorities_queried_at;
+
+			// Unknown authority should return an error.
+			for authority in remote_non_authorithy_keys.iter() {
+				let key = hash_authority_id(authority.as_ref());
+				assert!(matches!(
+					worker.handle_put_record_requested(key, vec![0x0], Some(peer_id), None).await,
+					Err(Error::UnknownAuthority)
+				));
+				assert!(prev_requested_authorithies == worker.authorities_queried_at);
+			}
+			assert_eq!(network.store_value_call.lock().unwrap().len(), 0);
+
+			// Valid authority should return Ok.
+			for (key, value) in kv_pairs.clone() {
+				assert!(worker
+					.handle_put_record_requested(key, value, Some(peer_id), None)
+					.await
+					.is_ok());
+			}
+			assert_eq!(network.store_value_call.lock().unwrap().len(), 1);
+
+			let another_authorithy_id = remote_public_keys.get(3).unwrap().clone();
+			let key = hash_authority_id(another_authorithy_id.as_ref());
+
+			// Valid record signed with a different key should return error.
+			for (_, value) in kv_pairs {
+				assert!(matches!(
+					worker
+						.handle_put_record_requested(key.clone(), value, Some(peer_id), None)
+						.await,
+					Err(Error::VerifyingDhtPayload)
+				));
+			}
+			assert_eq!(network.store_value_call.lock().unwrap().len(), 1);
+		}
+		.boxed_local(),
+	);
+}
diff --git a/substrate/client/chain-spec/Cargo.toml b/substrate/client/chain-spec/Cargo.toml
index 84ef89783adc0facdbf5d826fc71468b932594d7..5b411b642a0e3aa410517621d99f4ab3cd245a74 100644
--- a/substrate/client/chain-spec/Cargo.toml
+++ b/substrate/client/chain-spec/Cargo.toml
@@ -16,6 +16,7 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
+clap = { version = "4.5.3", features = ["derive"], optional = true }
 codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 memmap2 = "0.9.3"
 serde = { features = ["derive"], workspace = true, default-features = true }
@@ -42,3 +43,4 @@ substrate-test-runtime = { path = "../../test-utils/runtime" }
 sp-keyring = { path = "../../primitives/keyring" }
 sp-application-crypto = { default-features = false, path = "../../primitives/application-crypto", features = ["serde"] }
 sp-consensus-babe = { default-features = false, path = "../../primitives/consensus/babe", features = ["serde"] }
+regex = "1.6.0"
diff --git a/substrate/client/chain-spec/derive/src/impls.rs b/substrate/client/chain-spec/derive/src/impls.rs
index c0624897c133e6ebd3ecda6556d628dccee3c53b..d8b20c5c2a8cca93bd2a6bc8da051ea3746c1e4e 100644
--- a/substrate/client/chain-spec/derive/src/impls.rs
+++ b/substrate/client/chain-spec/derive/src/impls.rs
@@ -19,7 +19,7 @@
 use proc_macro2::{Span, TokenStream};
 use proc_macro_crate::{crate_name, FoundCrate};
 use quote::quote;
-use syn::{DeriveInput, Error, Ident};
+use syn::{DeriveInput, Error, Ident, Path};
 
 const CRATE_NAME: &str = "sc-chain-spec";
 const ATTRIBUTE_NAME: &str = "forks";
@@ -143,7 +143,7 @@ pub fn group_derive(ast: &DeriveInput) -> proc_macro::TokenStream {
 pub fn derive(
 	ast: &DeriveInput,
 	derive: impl Fn(
-		&Ident,
+		&Path,
 		&Ident,
 		&syn::Generics,
 		Vec<&Ident>,
@@ -171,25 +171,28 @@ pub fn derive(
 	};
 
 	let name = &ast.ident;
-	let crate_name = match crate_name(CRATE_NAME) {
+	let crate_path = match crate_name(CRATE_NAME) {
 		Ok(FoundCrate::Itself) => CRATE_NAME.replace("-", "_"),
 		Ok(FoundCrate::Name(chain_spec_name)) => chain_spec_name,
-		Err(e) => {
-			let err = Error::new(Span::call_site(), &e).to_compile_error();
-			return quote!( #err ).into()
+		Err(e) => match crate_name("polkadot-sdk") {
+			Ok(FoundCrate::Name(sdk)) => format!("{sdk}::{CRATE_NAME}").replace("-", "_"),
+			_ => {
+				return Error::new(Span::call_site(), &e).to_compile_error().into();
+			},
 		},
 	};
-	let crate_name = Ident::new(&crate_name, Span::call_site());
+	let crate_path =
+		syn::parse_str::<Path>(&crate_path).expect("crate_name returns valid path; qed");
 	let field_names = fields.named.iter().flat_map(|x| x.ident.as_ref()).collect::<Vec<_>>();
 	let field_types = fields.named.iter().map(|x| &x.ty).collect::<Vec<_>>();
 
-	derive(&crate_name, name, &ast.generics, field_names, field_types, fields).into()
+	derive(&crate_path, name, &ast.generics, field_names, field_types, fields).into()
 }
 
-fn generate_fork_fields(crate_name: &Ident, names: &[&Ident], types: &[&syn::Type]) -> TokenStream {
-	let crate_name = std::iter::repeat(crate_name);
+fn generate_fork_fields(crate_path: &Path, names: &[&Ident], types: &[&syn::Type]) -> TokenStream {
+	let crate_path = std::iter::repeat(crate_path);
 	quote! {
-		#( pub #names: Option<<#types as #crate_name::Group>::Fork>, )*
+		#( pub #names: Option<<#types as #crate_path::Group>::Fork>, )*
 	}
 }
 
diff --git a/substrate/client/chain-spec/res/chain_spec_as_json_fails_with_invalid_config.err b/substrate/client/chain-spec/res/chain_spec_as_json_fails_with_invalid_config.err
deleted file mode 100644
index c545b53b2bafea88af090236f825bbafe2baf8f8..0000000000000000000000000000000000000000
--- a/substrate/client/chain-spec/res/chain_spec_as_json_fails_with_invalid_config.err
+++ /dev/null
@@ -1,114 +0,0 @@
-Invalid JSON blob: unknown field `babex`, expected one of `system`, `babe`, `substrateTest`, `balances` at line 3 column 9 for blob:
-{
-  "system": {},
-  "babex": {
-    "authorities": [
-      [
-        "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
-        1
-      ],
-      [
-        "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty",
-        1
-      ],
-      [
-        "5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y",
-        1
-      ]
-    ],
-    "epochConfig": {
-      "c": [
-        3,
-        10
-      ],
-      "allowed_slots": "PrimaryAndSecondaryPlainSlots"
-    }
-  },
-  "substrateTest": {
-    "authorities": [
-      "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
-      "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty",
-      "5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y"
-    ]
-  },
-  "balances": {
-    "balances": [
-      [
-        "5D34dL5prEUaGNQtPPZ3yN5Y6BnkfXunKXXz6fo7ZJbLwRRH",
-        100000000000000000
-      ],
-      [
-        "5GBNeWRhZc2jXu7D55rBimKYDk8PGk8itRYFTPfC8RJLKG5o",
-        100000000000000000
-      ],
-      [
-        "5Dfis6XL8J2P6JHUnUtArnFWndn62SydeP8ee8sG2ky9nfm9",
-        100000000000000000
-      ],
-      [
-        "5F4H97f7nQovyrbiq4ZetaaviNwThSVcFobcA5aGab6167dK",
-        100000000000000000
-      ],
-      [
-        "5DiDShBWa1fQx6gLzpf3SFBhMinCoyvHM1BWjPNsmXS8hkrW",
-        100000000000000000
-      ],
-      [
-        "5EFb84yH9tpcFuiKUcsmdoF7xeeY3ajG1ZLQimxQoFt9HMKR",
-        100000000000000000
-      ],
-      [
-        "5DZLHESsfGrJ5YzT3HuRPXsSNb589xQ4Unubh1mYLodzKdVY",
-        100000000000000000
-      ],
-      [
-        "5GHJzqvG6tXnngCpG7B12qjUvbo5e4e9z8Xjidk3CQZHxTPZ",
-        100000000000000000
-      ],
-      [
-        "5CUnSsgAyLND3bxxnfNhgWXSe9Wn676JzLpGLgyJv858qhoX",
-        100000000000000000
-      ],
-      [
-        "5CVKn7HAZW1Ky4r7Vkgsr7VEW88C2sHgUNDiwHY9Ct2hjU8q",
-        100000000000000000
-      ],
-      [
-        "5H673aukQ4PeDe1U2nuv1bi32xDEziimh3PZz7hDdYUB7TNz",
-        100000000000000000
-      ],
-      [
-        "5HTe9L15LJryjUAt1jZXZCBPnzbbGnpvFwbjE3NwCWaAqovf",
-        100000000000000000
-      ],
-      [
-        "5D7LFzGpMwHPyDBavkRbWSKWTtJhCaPPZ379wWLT23bJwXJz",
-        100000000000000000
-      ],
-      [
-        "5CLepMARnEgtVR1EkUuJVUvKh97gzergpSxUU3yKGx1v6EwC",
-        100000000000000000
-      ],
-      [
-        "5Chb2UhfvZpmjjEziHbFbotM4quX32ZscRV6QJBt1rUKzz51",
-        100000000000000000
-      ],
-      [
-        "5HmRp3i3ZZk7xsAvbi8hyXVP6whSMnBJGebVC4FsiZVhx52e",
-        100000000000000000
-      ],
-      [
-        "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
-        100000000000000000
-      ],
-      [
-        "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty",
-        100000000000000000
-      ],
-      [
-        "5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y",
-        100000000000000000
-      ]
-    ]
-  }
-}
\ No newline at end of file
diff --git a/substrate/client/chain-spec/src/chain_spec.rs b/substrate/client/chain-spec/src/chain_spec.rs
index a9cdce4bf95580f6c00cbf27b0330779e4f39a28..883cd19adfd1c7543ee919a6e436df1838c6efe2 100644
--- a/substrate/client/chain-spec/src/chain_spec.rs
+++ b/substrate/client/chain-spec/src/chain_spec.rs
@@ -20,7 +20,7 @@
 #![warn(missing_docs)]
 use crate::{
 	extension::GetExtension, genesis_config_builder::HostFunctions, ChainType,
-	GenesisConfigBuilderRuntimeCaller as RuntimeCaller, Properties, RuntimeGenesis,
+	GenesisConfigBuilderRuntimeCaller as RuntimeCaller, Properties,
 };
 use sc_network::config::MultiaddrWithPeerId;
 use sc_telemetry::TelemetryEndpoints;
@@ -37,7 +37,6 @@ use std::{
 	fs::File,
 	marker::PhantomData,
 	path::PathBuf,
-	sync::Arc,
 };
 
 #[derive(Serialize, Deserialize)]
@@ -58,37 +57,33 @@ impl<EHF> Clone for GenesisBuildAction<EHF> {
 	}
 }
 
-#[allow(deprecated)]
-enum GenesisSource<G, EHF> {
+enum GenesisSource<EHF> {
 	File(PathBuf),
 	Binary(Cow<'static, [u8]>),
 	/// factory function + code
-	//Factory and G type parameter shall be removed together with `ChainSpec::from_genesis`
-	Factory(Arc<dyn Fn() -> G + Send + Sync>, Vec<u8>),
 	Storage(Storage),
 	/// build action + code
 	GenesisBuilderApi(GenesisBuildAction<EHF>, Vec<u8>),
 }
 
-impl<G, EHF> Clone for GenesisSource<G, EHF> {
+impl<EHF> Clone for GenesisSource<EHF> {
 	fn clone(&self) -> Self {
 		match *self {
 			Self::File(ref path) => Self::File(path.clone()),
 			Self::Binary(ref d) => Self::Binary(d.clone()),
-			Self::Factory(ref f, ref c) => Self::Factory(f.clone(), c.clone()),
 			Self::Storage(ref s) => Self::Storage(s.clone()),
 			Self::GenesisBuilderApi(ref s, ref c) => Self::GenesisBuilderApi(s.clone(), c.clone()),
 		}
 	}
 }
 
-impl<G: RuntimeGenesis, EHF: HostFunctions> GenesisSource<G, EHF> {
-	fn resolve(&self) -> Result<Genesis<G>, String> {
+impl<EHF: HostFunctions> GenesisSource<EHF> {
+	fn resolve(&self) -> Result<Genesis, String> {
 		/// helper container for deserializing genesis from the JSON file (ChainSpec JSON file is
 		/// also supported here)
 		#[derive(Serialize, Deserialize)]
-		struct GenesisContainer<G> {
-			genesis: Genesis<G>,
+		struct GenesisContainer {
+			genesis: Genesis,
 		}
 
 		match self {
@@ -105,19 +100,15 @@ impl<G: RuntimeGenesis, EHF: HostFunctions> GenesisSource<G, EHF> {
 					})?
 				};
 
-				let genesis: GenesisContainer<G> = json::from_slice(&bytes)
+				let genesis: GenesisContainer = json::from_slice(&bytes)
 					.map_err(|e| format!("Error parsing spec file: {}", e))?;
 				Ok(genesis.genesis)
 			},
 			Self::Binary(buf) => {
-				let genesis: GenesisContainer<G> = json::from_reader(buf.as_ref())
+				let genesis: GenesisContainer = json::from_reader(buf.as_ref())
 					.map_err(|e| format!("Error parsing embedded file: {}", e))?;
 				Ok(genesis.genesis)
 			},
-			Self::Factory(f, code) => Ok(Genesis::RuntimeAndCode(RuntimeInnerWrapper {
-				runtime: f(),
-				code: code.clone(),
-			})),
 			Self::Storage(storage) => Ok(Genesis::Raw(RawGenesis::from(storage.clone()))),
 			Self::GenesisBuilderApi(GenesisBuildAction::Full(config), code) =>
 				Ok(Genesis::RuntimeGenesis(RuntimeGenesisInner {
@@ -140,24 +131,12 @@ impl<G: RuntimeGenesis, EHF: HostFunctions> GenesisSource<G, EHF> {
 	}
 }
 
-impl<G: RuntimeGenesis, E, EHF> BuildStorage for ChainSpec<G, E, EHF>
+impl<E, EHF> BuildStorage for ChainSpec<E, EHF>
 where
 	EHF: HostFunctions,
 {
 	fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> {
 		match self.genesis.resolve()? {
-			#[allow(deprecated)]
-			Genesis::Runtime(runtime_genesis_config) => {
-				runtime_genesis_config.assimilate_storage(storage)?;
-			},
-			#[allow(deprecated)]
-			Genesis::RuntimeAndCode(RuntimeInnerWrapper {
-				runtime: runtime_genesis_config,
-				code,
-			}) => {
-				runtime_genesis_config.assimilate_storage(storage)?;
-				storage.top.insert(sp_core::storage::well_known_keys::CODE.to_vec(), code);
-			},
 			Genesis::Raw(RawGenesis { top: map, children_default: children_map }) => {
 				storage.top.extend(map.into_iter().map(|(k, v)| (k.0, v.0)));
 				children_map.into_iter().for_each(|(k, v)| {
@@ -236,7 +215,7 @@ impl From<sp_core::storage::Storage> for RawGenesis {
 	}
 }
 
-/// Inner representation of [`Genesis<G>::RuntimeGenesis`] format
+/// Inner representation of [`Genesis::RuntimeGenesis`] format
 #[derive(Serialize, Deserialize, Debug)]
 struct RuntimeGenesisInner {
 	/// Runtime wasm code, expected to be hex-encoded in JSON.
@@ -249,7 +228,7 @@ struct RuntimeGenesisInner {
 }
 
 /// Represents two possible variants of the contained JSON blob for the
-/// [`Genesis<G>::RuntimeGenesis`] format.
+/// [`Genesis::RuntimeGenesis`] format.
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 enum RuntimeGenesisConfigJson {
@@ -265,31 +244,11 @@ enum RuntimeGenesisConfigJson {
 	Patch(json::Value),
 }
 
-/// Inner variant wrapper for deprecated runtime.
-#[derive(Serialize, Deserialize, Debug)]
-struct RuntimeInnerWrapper<G> {
-	/// The native `RuntimeGenesisConfig` struct.
-	runtime: G,
-	/// Runtime code.
-	#[serde(with = "sp_core::bytes")]
-	code: Vec<u8>,
-}
-
 /// Represents the different formats of the genesis state within chain spec JSON blob.
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[serde(deny_unknown_fields)]
-enum Genesis<G> {
-	/// (Deprecated) Contains the JSON representation of G (the native type representing the
-	/// runtime's  `RuntimeGenesisConfig` struct) (will be removed with `ChainSpec::from_genesis`)
-	/// without the runtime code. It is required to deserialize the legacy chainspecs generated
-	/// with `ChainsSpec::from_genesis` method.
-	Runtime(G),
-	/// (Deprecated) Contains the JSON representation of G (the native type representing the
-	/// runtime's  `RuntimeGenesisConfig` struct) (will be removed with `ChainSpec::from_genesis`)
-	/// and the runtime code. It is required to create and deserialize JSON chainspecs created with
-	/// deprecated `ChainSpec::from_genesis` method.
-	RuntimeAndCode(RuntimeInnerWrapper<G>),
+enum Genesis {
 	/// The genesis storage as raw data. Typically raw key-value entries in state.
 	Raw(RawGenesis),
 	/// State root hash of the genesis storage.
@@ -343,7 +302,7 @@ struct ClientSpec<E> {
 pub type NoExtension = Option<()>;
 
 /// Builder for creating [`ChainSpec`] instances.
-pub struct ChainSpecBuilder<G, E = NoExtension, EHF = ()> {
+pub struct ChainSpecBuilder<E = NoExtension, EHF = ()> {
 	code: Vec<u8>,
 	extensions: E,
 	name: String,
@@ -355,10 +314,9 @@ pub struct ChainSpecBuilder<G, E = NoExtension, EHF = ()> {
 	protocol_id: Option<String>,
 	fork_id: Option<String>,
 	properties: Option<Properties>,
-	_genesis: PhantomData<G>,
 }
 
-impl<G, E, EHF> ChainSpecBuilder<G, E, EHF> {
+impl<E, EHF> ChainSpecBuilder<E, EHF> {
 	/// Creates a new builder instance with no defaults.
 	pub fn new(code: &[u8], extensions: E) -> Self {
 		Self {
@@ -373,7 +331,6 @@ impl<G, E, EHF> ChainSpecBuilder<G, E, EHF> {
 			protocol_id: None,
 			fork_id: None,
 			properties: None,
-			_genesis: Default::default(),
 		}
 	}
 
@@ -457,7 +414,7 @@ impl<G, E, EHF> ChainSpecBuilder<G, E, EHF> {
 	}
 
 	/// Builds a [`ChainSpec`] instance using the provided settings.
-	pub fn build(self) -> ChainSpec<G, E, EHF> {
+	pub fn build(self) -> ChainSpec<E, EHF> {
 		let client_spec = ClientSpec {
 			name: self.name,
 			id: self.id,
@@ -486,13 +443,13 @@ impl<G, E, EHF> ChainSpecBuilder<G, E, EHF> {
 /// The chain spec is generic over the native `RuntimeGenesisConfig` struct (`G`). It is also
 /// possible to parametrize chain spec over the extended host functions (EHF). It should be use if
 /// runtime is using the non-standard host function during genesis state creation.
-pub struct ChainSpec<G, E = NoExtension, EHF = ()> {
+pub struct ChainSpec<E = NoExtension, EHF = ()> {
 	client_spec: ClientSpec<E>,
-	genesis: GenesisSource<G, EHF>,
+	genesis: GenesisSource<EHF>,
 	_host_functions: PhantomData<EHF>,
 }
 
-impl<G, E: Clone, EHF> Clone for ChainSpec<G, E, EHF> {
+impl<E: Clone, EHF> Clone for ChainSpec<E, EHF> {
 	fn clone(&self) -> Self {
 		ChainSpec {
 			client_spec: self.client_spec.clone(),
@@ -502,7 +459,7 @@ impl<G, E: Clone, EHF> Clone for ChainSpec<G, E, EHF> {
 	}
 }
 
-impl<G, E, EHF> ChainSpec<G, E, EHF> {
+impl<E, EHF> ChainSpec<E, EHF> {
 	/// A list of bootnode addresses.
 	pub fn boot_nodes(&self) -> &[MultiaddrWithPeerId] {
 		&self.client_spec.boot_nodes
@@ -555,58 +512,18 @@ impl<G, E, EHF> ChainSpec<G, E, EHF> {
 		&mut self.client_spec.extensions
 	}
 
-	/// Create hardcoded spec.
-	#[deprecated(
-		note = "`from_genesis` is planned to be removed in May 2024. Use `builder()` instead."
-	)]
-	// deprecated note: Genesis<G>::Runtime + GenesisSource::Factory shall also be removed
-	pub fn from_genesis<F: Fn() -> G + 'static + Send + Sync>(
-		name: &str,
-		id: &str,
-		chain_type: ChainType,
-		constructor: F,
-		boot_nodes: Vec<MultiaddrWithPeerId>,
-		telemetry_endpoints: Option<TelemetryEndpoints>,
-		protocol_id: Option<&str>,
-		fork_id: Option<&str>,
-		properties: Option<Properties>,
-		extensions: E,
-		code: &[u8],
-	) -> Self {
-		let client_spec = ClientSpec {
-			name: name.to_owned(),
-			id: id.to_owned(),
-			chain_type,
-			boot_nodes,
-			telemetry_endpoints,
-			protocol_id: protocol_id.map(str::to_owned),
-			fork_id: fork_id.map(str::to_owned),
-			properties,
-			extensions,
-			consensus_engine: (),
-			genesis: Default::default(),
-			code_substitutes: BTreeMap::new(),
-		};
-
-		ChainSpec {
-			client_spec,
-			genesis: GenesisSource::Factory(Arc::new(constructor), code.into()),
-			_host_functions: Default::default(),
-		}
-	}
-
 	/// Type of the chain.
 	fn chain_type(&self) -> ChainType {
 		self.client_spec.chain_type.clone()
 	}
 
 	/// Provides a `ChainSpec` builder.
-	pub fn builder(code: &[u8], extensions: E) -> ChainSpecBuilder<G, E, EHF> {
+	pub fn builder(code: &[u8], extensions: E) -> ChainSpecBuilder<E, EHF> {
 		ChainSpecBuilder::new(code, extensions)
 	}
 }
 
-impl<G: serde::de::DeserializeOwned, E: serde::de::DeserializeOwned, EHF> ChainSpec<G, E, EHF> {
+impl<E: serde::de::DeserializeOwned, EHF> ChainSpec<E, EHF> {
 	/// Parse json content into a `ChainSpec`
 	pub fn from_json_bytes(json: impl Into<Cow<'static, [u8]>>) -> Result<Self, String> {
 		let json = json.into();
@@ -649,17 +566,17 @@ impl<G: serde::de::DeserializeOwned, E: serde::de::DeserializeOwned, EHF> ChainS
 #[derive(Serialize, Deserialize)]
 // we cannot #[serde(deny_unknown_fields)]. Otherwise chain-spec-builder will fail on any
 // non-standard spec.
-struct ChainSpecJsonContainer<G, E> {
+struct ChainSpecJsonContainer<E> {
 	#[serde(flatten)]
 	client_spec: ClientSpec<E>,
-	genesis: Genesis<G>,
+	genesis: Genesis,
 }
 
-impl<G: RuntimeGenesis, E: serde::Serialize + Clone + 'static, EHF> ChainSpec<G, E, EHF>
+impl<E: serde::Serialize + Clone + 'static, EHF> ChainSpec<E, EHF>
 where
 	EHF: HostFunctions,
 {
-	fn json_container(&self, raw: bool) -> Result<ChainSpecJsonContainer<G, E>, String> {
+	fn json_container(&self, raw: bool) -> Result<ChainSpecJsonContainer<E>, String> {
 		let raw_genesis = match (raw, self.genesis.resolve()?) {
 			(
 				true,
@@ -685,20 +602,7 @@ where
 				storage.top.insert(sp_core::storage::well_known_keys::CODE.to_vec(), code);
 				RawGenesis::from(storage)
 			},
-
-			#[allow(deprecated)]
-			(true, Genesis::RuntimeAndCode(RuntimeInnerWrapper { runtime: g, code })) => {
-				let mut storage = g.build_storage()?;
-				storage.top.insert(sp_core::storage::well_known_keys::CODE.to_vec(), code);
-				RawGenesis::from(storage)
-			},
-			#[allow(deprecated)]
-			(true, Genesis::Runtime(g)) => {
-				let storage = g.build_storage()?;
-				RawGenesis::from(storage)
-			},
 			(true, Genesis::Raw(raw)) => raw,
-
 			(_, genesis) =>
 				return Ok(ChainSpecJsonContainer { client_spec: self.client_spec.clone(), genesis }),
 		};
@@ -716,9 +620,8 @@ where
 	}
 }
 
-impl<G, E, EHF> crate::ChainSpec for ChainSpec<G, E, EHF>
+impl<E, EHF> crate::ChainSpec for ChainSpec<E, EHF>
 where
-	G: RuntimeGenesis + 'static,
 	E: GetExtension + serde::Serialize + Clone + Send + Sync + 'static,
 	EHF: HostFunctions,
 {
@@ -831,8 +734,8 @@ fn json_contains_path(doc: &json::Value, path: &mut VecDeque<&str>) -> bool {
 
 /// This function updates the code in given chain spec.
 ///
-/// Function support updating the runtime code in provided JSON chain spec blob. `Genesis<G>::Raw`
-/// and `Genesis<G>::RuntimeGenesis` formats are supported.
+/// Function support updating the runtime code in provided JSON chain spec blob. `Genesis::Raw`
+/// and `Genesis::RuntimeGenesis` formats are supported.
 ///
 /// If update was successful `true` is returned, otherwise `false`. Chain spec JSON is modified in
 /// place.
@@ -871,19 +774,7 @@ mod tests {
 	use sp_core::storage::well_known_keys;
 	use sp_keyring::AccountKeyring;
 
-	#[derive(Debug, Serialize, Deserialize)]
-	struct Genesis(BTreeMap<String, String>);
-
-	impl BuildStorage for Genesis {
-		fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> {
-			storage.top.extend(
-				self.0.iter().map(|(a, b)| (a.clone().into_bytes(), b.clone().into_bytes())),
-			);
-			Ok(())
-		}
-	}
-
-	type TestSpec = ChainSpec<Genesis>;
+	type TestSpec = ChainSpec;
 
 	#[test]
 	fn should_deserialize_example_chain_spec() {
@@ -919,7 +810,7 @@ mod tests {
 		}
 	}
 
-	type TestSpec2 = ChainSpec<Genesis, Extension1>;
+	type TestSpec2 = ChainSpec<Extension1>;
 
 	#[test]
 	fn should_deserialize_chain_spec_with_extensions() {
@@ -1137,10 +1028,10 @@ mod tests {
 
 	#[test]
 	fn chain_spec_as_json_fails_with_invalid_config() {
-		let expected_error_message =
-			include_str!("../res/chain_spec_as_json_fails_with_invalid_config.err");
-		let j =
-			include_str!("../../../test-utils/runtime/res/default_genesis_config_invalid_2.json");
+		let invalid_genesis_config = from_str::<Value>(include_str!(
+			"../../../test-utils/runtime/res/default_genesis_config_invalid_2.json"
+		))
+		.unwrap();
 		let output = ChainSpec::<()>::builder(
 			substrate_test_runtime::wasm_binary_unwrap().into(),
 			Default::default(),
@@ -1148,12 +1039,25 @@ mod tests {
 		.with_name("TestName")
 		.with_id("test_id")
 		.with_chain_type(ChainType::Local)
-		.with_genesis_config(from_str(j).unwrap())
+		.with_genesis_config(invalid_genesis_config.clone())
 		.build();
 
-		let result = output.as_json(true);
+		let result = output.as_json(true).unwrap_err();
+		let mut result = result.lines();
 
-		assert_eq!(result.err().unwrap(), expected_error_message);
+		let result_header = result.next().unwrap();
+		let result_body = result.collect::<Vec<&str>>().join("\n");
+		let result_body: Value = serde_json::from_str(&result_body).unwrap();
+
+		let re = regex::Regex::new(concat!(
+			r"^Invalid JSON blob: unknown field `babex`, expected one of `system`, `babe`, ",
+			r"`substrateTest`, `balances` at line \d+ column \d+ for blob:$"
+		))
+		.unwrap();
+
+		assert_eq!(json!({"a":1,"b":2}), json!({"b":2,"a":1}));
+		assert!(re.is_match(result_header));
+		assert_eq!(invalid_genesis_config, result_body);
 	}
 
 	#[test]
@@ -1278,35 +1182,4 @@ mod tests {
 			&|v| { *v == "0x000102040506" }
 		));
 	}
-
-	#[test]
-	fn generate_from_genesis_is_still_supported() {
-		#[allow(deprecated)]
-		let chain_spec: ChainSpec<substrate_test_runtime::RuntimeGenesisConfig> = ChainSpec::from_genesis(
-			"TestName",
-			"test",
-			ChainType::Local,
-			|| Default::default(),
-			Vec::new(),
-			None,
-			None,
-			None,
-			None,
-			Default::default(),
-			&vec![0, 1, 2, 4, 5, 6],
-		);
-
-		let chain_spec_json = from_str::<Value>(&chain_spec.as_json(false).unwrap()).unwrap();
-		assert!(json_eval_value_at_key(
-			&chain_spec_json,
-			&mut json_path!["genesis", "runtimeAndCode", "code"],
-			&|v| { *v == "0x000102040506" }
-		));
-		let chain_spec_json = from_str::<Value>(&chain_spec.as_json(true).unwrap()).unwrap();
-		assert!(json_eval_value_at_key(
-			&chain_spec_json,
-			&mut json_path!["genesis", "raw", "top", "0x3a636f6465"],
-			&|v| { *v == "0x000102040506" }
-		));
-	}
 }
diff --git a/substrate/client/chain-spec/src/lib.rs b/substrate/client/chain-spec/src/lib.rs
index abe01dafd92483fbede02eb6d95205b29bddacb5..b59ad68610ecee8fc78ea15eb7cd717fe2bb4d40 100644
--- a/substrate/client/chain-spec/src/lib.rs
+++ b/substrate/client/chain-spec/src/lib.rs
@@ -123,7 +123,10 @@
 //! As the compiled WASM blob of the runtime code is stored in the chain's state, the initial
 //! runtime must also be provided within the chain specification.
 //!
-//! In essence, the most important formats of genesis initial state are:
+//! # `chain-spec` formats
+//!
+//! In essence, the most important formats of genesis initial state in chain specification files
+//! are:
 //!
 //! <table>
 //!   <thead>
@@ -135,14 +138,14 @@
 //!   <tbody>
 //!     <tr>
 //!       <td>
-//! 		<code>runtime / full config</code>
+//! 		<code>full config</code>
 //!       </td>
 //!       <td>A JSON object that provides an explicit and comprehensive representation of the
 //! <code>RuntimeGenesisConfig</code> struct, which is generated by <a
 //! href="../frame_support_procedural/macro.construct_runtime.html"
 //! ><code>polkadot_sdk_frame::runtime::prelude::construct_runtime</code></a> macro (<a
 //! href="../substrate_test_runtime/struct.RuntimeGenesisConfig.html#"
-//! >example of generated struct</a>). Must contain all the keys of
+//! >example of generated struct</a>). Must contain *all* the keys of
 //! the genesis config, no defaults will be used.
 //!
 //! This format explicitly provides the code of the runtime.
@@ -154,7 +157,8 @@
 //!       <td>A JSON object that offers a partial representation of the
 //!       <code>RuntimeGenesisConfig</code> provided by the runtime. It contains a patch, which is
 //! essentially a list of key-value pairs to customize in the default runtime's
-//! <code>RuntimeGenesisConfig</code>.
+//! <code>RuntimeGenesisConfig</code>: `full = default + patch`. Please note that `default`
+//! `RuntimeGenesisConfig` may not be functional.
 //! This format explicitly provides the code of the runtime.
 //! </td></tr>
 //!     <tr>
@@ -257,7 +261,7 @@
 //! 	pub known_blocks: HashMap<u64, String>,
 //! }
 //!
-//! pub type MyChainSpec<G> = GenericChainSpec<G, MyExtension>;
+//! pub type MyChainSpec = GenericChainSpec<MyExtension>;
 //! ```
 //! Some parameters may require different values depending on the current blockchain height (a.k.a.
 //! forks). You can use the [`ChainSpecGroup`](macro@ChainSpecGroup) macro and the provided [`Forks`]
@@ -286,10 +290,10 @@
 //! pub type BlockNumber = u64;
 //!
 //! /// A chain spec supporting forkable `ClientParams`.
-//! pub type MyChainSpec1<G> = GenericChainSpec<G, Forks<BlockNumber, ClientParams>>;
+//! pub type MyChainSpec1 = GenericChainSpec<Forks<BlockNumber, ClientParams>>;
 //!
 //! /// A chain spec supporting forkable `Extension`.
-//! pub type MyChainSpec2<G> = GenericChainSpec<G, Forks<BlockNumber, Extension>>;
+//! pub type MyChainSpec2 = GenericChainSpec<Forks<BlockNumber, Extension>>;
 //! ```
 //! It's also possible to have a set of parameters that are allowed to change with block numbers
 //! (i.e., they are forkable), and another set that is not subject to changes. This can also be
@@ -316,7 +320,7 @@
 //! 	pub pool: Forks<u64, PoolParams>,
 //! }
 //!
-//! pub type MyChainSpec<G> = GenericChainSpec<G, Extension>;
+//! pub type MyChainSpec = GenericChainSpec<Extension>;
 //! ```
 //! The chain spec can be extended with other fields that are opaque to the default chain spec.
 //! Specific node implementations will need to be able to deserialize these extensions.
@@ -344,7 +348,6 @@ pub use sc_chain_spec_derive::{ChainSpecExtension, ChainSpecGroup};
 
 use sc_network::config::MultiaddrWithPeerId;
 use sc_telemetry::TelemetryEndpoints;
-use serde::{de::DeserializeOwned, Serialize};
 use sp_core::storage::Storage;
 use sp_runtime::BuildStorage;
 
@@ -353,6 +356,7 @@ use sp_runtime::BuildStorage;
 /// This can be used by tools to determine the type of a chain for displaying
 /// additional information or enabling additional features.
 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Clone)]
+#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
 pub enum ChainType {
 	/// A development chain that runs mainly on one node.
 	Development,
@@ -361,6 +365,7 @@ pub enum ChainType {
 	/// A live chain.
 	Live,
 	/// Some custom chain type.
+	#[cfg_attr(feature = "clap", clap(skip))]
 	Custom(String),
 }
 
@@ -373,10 +378,6 @@ impl Default for ChainType {
 /// Arbitrary properties defined in chain spec as a JSON object
 pub type Properties = serde_json::map::Map<String, serde_json::Value>;
 
-/// A set of traits for the runtime genesis config.
-pub trait RuntimeGenesis: Serialize + DeserializeOwned + BuildStorage {}
-impl<T: Serialize + DeserializeOwned + BuildStorage> RuntimeGenesis for T {}
-
 /// Common interface of a chain specification.
 pub trait ChainSpec: BuildStorage + Send + Sync {
 	/// Spec name.
diff --git a/substrate/client/cli/Cargo.toml b/substrate/client/cli/Cargo.toml
index 1f3bce799b2c436565cf948f54d2017338344732..169ed72c96e489ee35dca02edc6e098c2426eadb 100644
--- a/substrate/client/cli/Cargo.toml
+++ b/substrate/client/cli/Cargo.toml
@@ -25,7 +25,7 @@ itertools = "0.11"
 libp2p-identity = { version = "0.1.3", features = ["ed25519", "peerid"] }
 log = { workspace = true, default-features = true }
 names = { version = "0.14.0", default-features = false }
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 rand = "0.8.5"
 regex = "1.6.0"
 rpassword = "7.0.0"
diff --git a/substrate/client/cli/src/commands/chain_info_cmd.rs b/substrate/client/cli/src/commands/chain_info_cmd.rs
index 002d7893d9f35b01f36078139f872694ef8ca848..8558c8a2d1cb8e90e2e83a363aea5219b55669dc 100644
--- a/substrate/client/cli/src/commands/chain_info_cmd.rs
+++ b/substrate/client/cli/src/commands/chain_info_cmd.rs
@@ -17,7 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::{CliConfiguration, DatabaseParams, PruningParams, Result as CliResult, SharedParams};
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use sc_client_api::{backend::Backend as BackendT, blockchain::HeaderBackend};
 use sp_blockchain::Info;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
diff --git a/substrate/client/cli/src/commands/insert_key.rs b/substrate/client/cli/src/commands/insert_key.rs
index 3d89610b28b1bd0a031ffad6e94fef7fd604e20d..66dbec794865c00bed9e508a44e760299b2bc3ea 100644
--- a/substrate/client/cli/src/commands/insert_key.rs
+++ b/substrate/client/cli/src/commands/insert_key.rs
@@ -126,8 +126,10 @@ mod tests {
 		}
 
 		fn load_spec(&self, _: &str) -> std::result::Result<Box<dyn ChainSpec>, String> {
+			let builder =
+				GenericChainSpec::<NoExtension, ()>::builder(Default::default(), NoExtension::None);
 			Ok(Box::new(
-				GenericChainSpec::<()>::builder(Default::default(), NoExtension::None)
+				builder
 					.with_name("test")
 					.with_id("test_id")
 					.with_chain_type(ChainType::Development)
diff --git a/substrate/client/cli/src/error.rs b/substrate/client/cli/src/error.rs
index 90ad048009ade90b5ccd4cfc264cc85e3b311843..90f936561512d716ae25c2e4d8115bd1d7c94e84 100644
--- a/substrate/client/cli/src/error.rs
+++ b/substrate/client/cli/src/error.rs
@@ -42,7 +42,7 @@ pub enum Error {
 	Client(#[from] sp_blockchain::Error),
 
 	#[error(transparent)]
-	Codec(#[from] parity_scale_codec::Error),
+	Codec(#[from] codec::Error),
 
 	#[error("Invalid input: {0}")]
 	Input(String),
diff --git a/substrate/client/cli/src/params/node_key_params.rs b/substrate/client/cli/src/params/node_key_params.rs
index 7058af19f1d4a5edc31a8e93d062f7f93c065f1e..0e12c7a2a2d3742ef3d9aa3681f900036e67a467 100644
--- a/substrate/client/cli/src/params/node_key_params.rs
+++ b/substrate/client/cli/src/params/node_key_params.rs
@@ -17,7 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use clap::Args;
-use sc_network::config::{identity::ed25519, NodeKeyConfig};
+use sc_network::config::{ed25519, NodeKeyConfig};
 use sc_service::Role;
 use sp_core::H256;
 use std::{path::PathBuf, str::FromStr};
@@ -148,7 +148,7 @@ fn parse_ed25519_secret(hex: &str) -> error::Result<sc_network::config::Ed25519S
 mod tests {
 	use super::*;
 	use clap::ValueEnum;
-	use libp2p_identity::ed25519;
+	use sc_network::config::ed25519;
 	use std::fs::{self, File};
 	use tempfile::TempDir;
 
@@ -194,11 +194,7 @@ mod tests {
 				.into_keypair()
 				.expect("Creates node key pair");
 
-			if let Ok(pair) = node_key.try_into_ed25519() {
-				if pair.secret().as_ref() != key.as_ref() {
-					panic!("Invalid key")
-				}
-			} else {
+			if node_key.secret().as_ref() != key.as_ref() {
 				panic!("Invalid key")
 			}
 		}
diff --git a/substrate/client/cli/src/params/pruning_params.rs b/substrate/client/cli/src/params/pruning_params.rs
index 25b17b53289818ba02e839e98b9738f380fc1067..6b7b0e7ffa9976e7121b7392fb25f0adaf493c45 100644
--- a/substrate/client/cli/src/params/pruning_params.rs
+++ b/substrate/client/cli/src/params/pruning_params.rs
@@ -29,11 +29,18 @@ pub struct PruningParams {
 	/// should be pruned (ie, removed) from the database.
 	/// This setting can only be set on the first creation of the database. Every subsequent run
 	/// will load the pruning mode from the database and will error if the stored mode doesn't
-	/// match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+	/// match this CLI value. It is fine to drop this CLI flag for subsequent runs. The only
+	/// exception is that `NUMBER` can change between subsequent runs (increasing it will not
+	/// lead to restoring pruned state).
+	///
 	/// Possible values:
-	///  - archive: Keep the state of all blocks.
-	///  - 'archive-canonical' Keep only the state of finalized blocks.
-	///  - number Keep the state of the last number of finalized blocks.
+	///
+	/// - archive: Keep the data of all blocks.
+	///
+	/// - archive-canonical: Keep only the data of finalized blocks.
+	///
+	/// - NUMBER: Keep the data of the last NUMBER of finalized blocks.
+	///
 	/// [default: 256]
 	#[arg(alias = "pruning", long, value_name = "PRUNING_MODE")]
 	pub state_pruning: Option<DatabasePruningMode>,
@@ -42,11 +49,14 @@ pub struct PruningParams {
 	///
 	/// This mode specifies when the block's body (including justifications)
 	/// should be pruned (ie, removed) from the database.
+	///
 	/// Possible values:
-	///  - 'archive' Keep all blocks.
-	///  - 'archive-canonical' Keep only finalized blocks.
-	///  - number
-	///  Keep the last `number` of finalized blocks.
+	///
+	/// - archive: Keep the data of all blocks.
+	///
+	/// - archive-canonical: Keep only the data of finalized blocks.
+	///
+	/// - NUMBER: Keep the data of the last NUMBER of finalized blocks.
 	#[arg(
 		alias = "keep-blocks",
 		long,
@@ -117,3 +127,39 @@ impl Into<BlocksPruning> for DatabasePruningMode {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use clap::Parser;
+
+	#[derive(Parser)]
+	struct Cli {
+		#[clap(flatten)]
+		pruning: PruningParams,
+	}
+
+	#[test]
+	fn pruning_params_parse_works() {
+		let Cli { pruning } =
+			Cli::parse_from(["", "--state-pruning=1000", "--blocks-pruning=1000"]);
+
+		assert!(matches!(pruning.state_pruning, Some(DatabasePruningMode::Custom(1000))));
+		assert!(matches!(pruning.blocks_pruning, DatabasePruningMode::Custom(1000)));
+
+		let Cli { pruning } =
+			Cli::parse_from(["", "--state-pruning=archive", "--blocks-pruning=archive"]);
+
+		assert!(matches!(dbg!(pruning.state_pruning), Some(DatabasePruningMode::Archive)));
+		assert!(matches!(pruning.blocks_pruning, DatabasePruningMode::Archive));
+
+		let Cli { pruning } = Cli::parse_from([
+			"",
+			"--state-pruning=archive-canonical",
+			"--blocks-pruning=archive-canonical",
+		]);
+
+		assert!(matches!(dbg!(pruning.state_pruning), Some(DatabasePruningMode::ArchiveCanonical)));
+		assert!(matches!(pruning.blocks_pruning, DatabasePruningMode::ArchiveCanonical));
+	}
+}
diff --git a/substrate/client/cli/src/runner.rs b/substrate/client/cli/src/runner.rs
index 3bf2768078401f8cfafaceab1b76c8a83e2548d5..6d986e38d2fb563abcbdf80fd1d79eecaef6ea4c 100644
--- a/substrate/client/cli/src/runner.rs
+++ b/substrate/client/cli/src/runner.rs
@@ -252,12 +252,15 @@ mod tests {
 				state_pruning: None,
 				blocks_pruning: sc_client_db::BlocksPruning::KeepAll,
 				chain_spec: Box::new(
-					GenericChainSpec::<()>::builder(Default::default(), NoExtension::None)
-						.with_name("test")
-						.with_id("test_id")
-						.with_chain_type(ChainType::Development)
-						.with_genesis_config_patch(Default::default())
-						.build(),
+					GenericChainSpec::<NoExtension, ()>::builder(
+						Default::default(),
+						NoExtension::None,
+					)
+					.with_name("test")
+					.with_id("test_id")
+					.with_chain_type(ChainType::Development)
+					.with_genesis_config_patch(Default::default())
+					.build(),
 				),
 				wasm_method: Default::default(),
 				wasm_runtime_overrides: None,
diff --git a/substrate/client/consensus/beefy/Cargo.toml b/substrate/client/consensus/beefy/Cargo.toml
index 193acbe52a1e8b3bc7752b984296bb9c1456d483..f5528ec5931dbc5d77321e903b57e4ef70349afc 100644
--- a/substrate/client/consensus/beefy/Cargo.toml
+++ b/substrate/client/consensus/beefy/Cargo.toml
@@ -22,7 +22,7 @@ log = { workspace = true, default-features = true }
 parking_lot = "0.12.1"
 thiserror = { workspace = true }
 wasm-timer = "0.2.5"
-prometheus = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" }
 sc-client-api = { path = "../../api" }
 sc-consensus = { path = "../common" }
 sc-network = { path = "../../network" }
@@ -42,7 +42,6 @@ sp-keystore = { path = "../../../primitives/keystore" }
 sp-runtime = { path = "../../../primitives/runtime" }
 tokio = "1.37"
 
-
 [dev-dependencies]
 serde = { workspace = true, default-features = true }
 tempfile = "3.1.0"
diff --git a/substrate/client/consensus/beefy/rpc/Cargo.toml b/substrate/client/consensus/beefy/rpc/Cargo.toml
index 07e46dbda156a79a77a60e8340e46a323e133fd2..84f90622b5c14f8b7cba19749c877a6ce53ec226 100644
--- a/substrate/client/consensus/beefy/rpc/Cargo.toml
+++ b/substrate/client/consensus/beefy/rpc/Cargo.toml
@@ -24,6 +24,7 @@ sp-consensus-beefy = { path = "../../../../primitives/consensus/beefy" }
 sc-rpc = { path = "../../../rpc" }
 sp-core = { path = "../../../../primitives/core" }
 sp-runtime = { path = "../../../../primitives/runtime" }
+sp-application-crypto = { path = "../../../../primitives/application-crypto" }
 
 [dev-dependencies]
 serde_json = { workspace = true, default-features = true }
diff --git a/substrate/client/consensus/beefy/rpc/src/lib.rs b/substrate/client/consensus/beefy/rpc/src/lib.rs
index f01baee2d6ece9a9d1dd36e1524a1d004e9b0401..66102eeb35c897a7bff4e50a12da1b90754eeeaa 100644
--- a/substrate/client/consensus/beefy/rpc/src/lib.rs
+++ b/substrate/client/consensus/beefy/rpc/src/lib.rs
@@ -21,9 +21,11 @@
 #![warn(missing_docs)]
 
 use parking_lot::RwLock;
+use sp_consensus_beefy::AuthorityIdBound;
 use std::sync::Arc;
 
 use sc_rpc::{utils::pipe_from_stream, SubscriptionTaskExecutor};
+use sp_application_crypto::RuntimeAppPublic;
 use sp_runtime::traits::Block as BlockT;
 
 use futures::{task::SpawnError, FutureExt, StreamExt};
@@ -98,19 +100,20 @@ pub trait BeefyApi<Notification, Hash> {
 }
 
 /// Implements the BeefyApi RPC trait for interacting with BEEFY.
-pub struct Beefy<Block: BlockT> {
-	finality_proof_stream: BeefyVersionedFinalityProofStream<Block>,
+pub struct Beefy<Block: BlockT, AuthorityId: AuthorityIdBound> {
+	finality_proof_stream: BeefyVersionedFinalityProofStream<Block, AuthorityId>,
 	beefy_best_block: Arc<RwLock<Option<Block::Hash>>>,
 	executor: SubscriptionTaskExecutor,
 }
 
-impl<Block> Beefy<Block>
+impl<Block, AuthorityId> Beefy<Block, AuthorityId>
 where
 	Block: BlockT,
+	AuthorityId: AuthorityIdBound,
 {
 	/// Creates a new Beefy Rpc handler instance.
 	pub fn new(
-		finality_proof_stream: BeefyVersionedFinalityProofStream<Block>,
+		finality_proof_stream: BeefyVersionedFinalityProofStream<Block, AuthorityId>,
 		best_block_stream: BeefyBestBlockStream<Block>,
 		executor: SubscriptionTaskExecutor,
 	) -> Result<Self, Error> {
@@ -129,16 +132,18 @@ where
 }
 
 #[async_trait]
-impl<Block> BeefyApiServer<notification::EncodedVersionedFinalityProof, Block::Hash>
-	for Beefy<Block>
+impl<Block, AuthorityId> BeefyApiServer<notification::EncodedVersionedFinalityProof, Block::Hash>
+	for Beefy<Block, AuthorityId>
 where
 	Block: BlockT,
+	AuthorityId: AuthorityIdBound,
+	<AuthorityId as RuntimeAppPublic>::Signature: Send + Sync,
 {
 	fn subscribe_justifications(&self, pending: PendingSubscriptionSink) {
 		let stream = self
 			.finality_proof_stream
 			.subscribe(100_000)
-			.map(|vfp| notification::EncodedVersionedFinalityProof::new::<Block>(vfp));
+			.map(|vfp| notification::EncodedVersionedFinalityProof::new::<Block, AuthorityId>(vfp));
 
 		sc_rpc::utils::spawn_subscription_task(&self.executor, pipe_from_stream(pending, stream));
 	}
@@ -158,20 +163,26 @@ mod tests {
 		communication::notification::BeefyVersionedFinalityProofSender,
 		justification::BeefyVersionedFinalityProof,
 	};
-	use sp_consensus_beefy::{known_payloads, Payload, SignedCommitment};
+	use sp_consensus_beefy::{ecdsa_crypto, known_payloads, Payload, SignedCommitment};
 	use sp_runtime::traits::{BlakeTwo256, Hash};
 	use substrate_test_runtime_client::runtime::Block;
 
-	fn setup_io_handler() -> (RpcModule<Beefy<Block>>, BeefyVersionedFinalityProofSender<Block>) {
+	fn setup_io_handler() -> (
+		RpcModule<Beefy<Block, ecdsa_crypto::AuthorityId>>,
+		BeefyVersionedFinalityProofSender<Block, ecdsa_crypto::AuthorityId>,
+	) {
 		let (_, stream) = BeefyBestBlockStream::<Block>::channel();
 		setup_io_handler_with_best_block_stream(stream)
 	}
 
 	fn setup_io_handler_with_best_block_stream(
 		best_block_stream: BeefyBestBlockStream<Block>,
-	) -> (RpcModule<Beefy<Block>>, BeefyVersionedFinalityProofSender<Block>) {
+	) -> (
+		RpcModule<Beefy<Block, ecdsa_crypto::AuthorityId>>,
+		BeefyVersionedFinalityProofSender<Block, ecdsa_crypto::AuthorityId>,
+	) {
 		let (finality_proof_sender, finality_proof_stream) =
-			BeefyVersionedFinalityProofStream::<Block>::channel();
+			BeefyVersionedFinalityProofStream::<Block, ecdsa_crypto::AuthorityId>::channel();
 
 		let handler =
 			Beefy::new(finality_proof_stream, best_block_stream, sc_rpc::testing::test_executor())
@@ -250,10 +261,10 @@ mod tests {
 		assert_eq!(response, expected);
 	}
 
-	fn create_finality_proof() -> BeefyVersionedFinalityProof<Block> {
+	fn create_finality_proof() -> BeefyVersionedFinalityProof<Block, ecdsa_crypto::AuthorityId> {
 		let payload =
 			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
-		BeefyVersionedFinalityProof::<Block>::V1(SignedCommitment {
+		BeefyVersionedFinalityProof::<Block, ecdsa_crypto::AuthorityId>::V1(SignedCommitment {
 			commitment: sp_consensus_beefy::Commitment {
 				payload,
 				block_number: 5,
@@ -280,7 +291,7 @@ mod tests {
 
 		// Inspect what we received
 		let (bytes, recv_sub_id) = sub.next::<sp_core::Bytes>().await.unwrap().unwrap();
-		let recv_finality_proof: BeefyVersionedFinalityProof<Block> =
+		let recv_finality_proof: BeefyVersionedFinalityProof<Block, ecdsa_crypto::AuthorityId> =
 			Decode::decode(&mut &bytes[..]).unwrap();
 		assert_eq!(&recv_sub_id, sub.subscription_id());
 		assert_eq!(recv_finality_proof, finality_proof);
diff --git a/substrate/client/consensus/beefy/rpc/src/notification.rs b/substrate/client/consensus/beefy/rpc/src/notification.rs
index 690c511b999ac1b89627cd1e67dc2ce8e2343862..d4339058a6940df75959fbd7b9ded13a318bd5db 100644
--- a/substrate/client/consensus/beefy/rpc/src/notification.rs
+++ b/substrate/client/consensus/beefy/rpc/src/notification.rs
@@ -19,6 +19,7 @@
 use codec::Encode;
 use serde::{Deserialize, Serialize};
 
+use sp_consensus_beefy::AuthorityIdBound;
 use sp_runtime::traits::Block as BlockT;
 
 /// An encoded finality proof proving that the given header has been finalized.
@@ -28,11 +29,15 @@ use sp_runtime::traits::Block as BlockT;
 pub struct EncodedVersionedFinalityProof(sp_core::Bytes);
 
 impl EncodedVersionedFinalityProof {
-	pub fn new<Block>(
-		finality_proof: sc_consensus_beefy::justification::BeefyVersionedFinalityProof<Block>,
+	pub fn new<Block, AuthorityId>(
+		finality_proof: sc_consensus_beefy::justification::BeefyVersionedFinalityProof<
+			Block,
+			AuthorityId,
+		>,
 	) -> Self
 	where
 		Block: BlockT,
+		AuthorityId: AuthorityIdBound,
 	{
 		EncodedVersionedFinalityProof(finality_proof.encode().into())
 	}
diff --git a/substrate/client/consensus/beefy/src/aux_schema.rs b/substrate/client/consensus/beefy/src/aux_schema.rs
index 534f668ae69c2996064bef086e2958b23f48caf0..1922494ad11207ae4f46931a5dcf673b3154001b 100644
--- a/substrate/client/consensus/beefy/src/aux_schema.rs
+++ b/substrate/client/consensus/beefy/src/aux_schema.rs
@@ -20,8 +20,10 @@
 
 use crate::{error::Error, worker::PersistedState, LOG_TARGET};
 use codec::{Decode, Encode};
-use log::{debug, trace};
+use log::{debug, trace, warn};
 use sc_client_api::{backend::AuxStore, Backend};
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
+use sp_consensus_beefy::AuthorityIdBound;
 use sp_runtime::traits::Block as BlockT;
 
 const VERSION_KEY: &[u8] = b"beefy_auxschema_version";
@@ -36,26 +38,27 @@ pub(crate) fn write_current_version<BE: AuxStore>(backend: &BE) -> Result<(), Er
 }
 
 /// Write voter state.
-pub(crate) fn write_voter_state<B: BlockT, BE: AuxStore>(
+pub(crate) fn write_voter_state<B: BlockT, BE: AuxStore, AuthorityId: AuthorityIdBound>(
 	backend: &BE,
-	state: &PersistedState<B>,
-) -> Result<(), Error> {
+	state: &PersistedState<B, AuthorityId>,
+) -> ClientResult<()> {
 	trace!(target: LOG_TARGET, "🥩 persisting {:?}", state);
 	AuxStore::insert_aux(backend, &[(WORKER_STATE_KEY, state.encode().as_slice())], &[])
-		.map_err(|e| Error::Backend(e.to_string()))
 }
 
-fn load_decode<BE: AuxStore, T: Decode>(backend: &BE, key: &[u8]) -> Result<Option<T>, Error> {
-	match backend.get_aux(key).map_err(|e| Error::Backend(e.to_string()))? {
+fn load_decode<BE: AuxStore, T: Decode>(backend: &BE, key: &[u8]) -> ClientResult<Option<T>> {
+	match backend.get_aux(key)? {
 		None => Ok(None),
 		Some(t) => T::decode(&mut &t[..])
-			.map_err(|e| Error::Backend(format!("BEEFY DB is corrupted: {}", e)))
+			.map_err(|e| ClientError::Backend(format!("BEEFY DB is corrupted: {}", e)))
 			.map(Some),
 	}
 }
 
 /// Load or initialize persistent data from backend.
-pub(crate) fn load_persistent<B, BE>(backend: &BE) -> Result<Option<PersistedState<B>>, Error>
+pub(crate) fn load_persistent<B, BE, AuthorityId: AuthorityIdBound>(
+	backend: &BE,
+) -> ClientResult<Option<PersistedState<B, AuthorityId>>>
 where
 	B: BlockT,
 	BE: Backend<B>,
@@ -64,9 +67,14 @@ where
 
 	match version {
 		None => (),
-		Some(1) | Some(2) | Some(3) => (), // versions 1, 2 & 3 are obsolete and should be ignored
-		Some(4) => return load_decode::<_, PersistedState<B>>(backend, WORKER_STATE_KEY),
-		other => return Err(Error::Backend(format!("Unsupported BEEFY DB version: {:?}", other))),
+
+		Some(v) if 1 <= v && v <= 3 =>
+		// versions 1, 2 & 3 are obsolete and should be ignored
+			warn!(target: LOG_TARGET,  "🥩 backend contains a BEEFY state of an obsolete version {v}. ignoring..."),
+		Some(4) =>
+			return load_decode::<_, PersistedState<B, AuthorityId>>(backend, WORKER_STATE_KEY),
+		other =>
+			return Err(ClientError::Backend(format!("Unsupported BEEFY DB version: {:?}", other))),
 	}
 
 	// No persistent state found in DB.
@@ -78,6 +86,7 @@ pub(crate) mod tests {
 	use super::*;
 	use crate::tests::BeefyTestNet;
 	use sc_network_test::TestNetFactory;
+	use sp_consensus_beefy::ecdsa_crypto;
 
 	// also used in tests.rs
 	pub fn verify_persisted_version<B: BlockT, BE: Backend<B>>(backend: &BE) -> bool {
@@ -91,7 +100,7 @@ pub(crate) mod tests {
 		let backend = net.peer(0).client().as_backend();
 
 		// version not available in db -> None
-		assert_eq!(load_persistent(&*backend).unwrap(), None);
+		assert_eq!(load_persistent::<_, _, ecdsa_crypto::AuthorityId>(&*backend).unwrap(), None);
 
 		// populate version in db
 		write_current_version(&*backend).unwrap();
@@ -99,7 +108,7 @@ pub(crate) mod tests {
 		assert_eq!(load_decode(&*backend, VERSION_KEY).unwrap(), Some(CURRENT_VERSION));
 
 		// version is available in db but state isn't -> None
-		assert_eq!(load_persistent(&*backend).unwrap(), None);
+		assert_eq!(load_persistent::<_, _, ecdsa_crypto::AuthorityId>(&*backend).unwrap(), None);
 
 		// full `PersistedState` load is tested in `tests.rs`.
 	}
diff --git a/substrate/client/consensus/beefy/src/communication/gossip.rs b/substrate/client/consensus/beefy/src/communication/gossip.rs
index 947fe13856f476042858b1a5698aa5333b1d287b..95cac250b7c595e7a1f8875096b1f37d061a367f 100644
--- a/substrate/client/consensus/beefy/src/communication/gossip.rs
+++ b/substrate/client/consensus/beefy/src/communication/gossip.rs
@@ -36,10 +36,8 @@ use crate::{
 	keystore::BeefyKeystore,
 	LOG_TARGET,
 };
-use sp_consensus_beefy::{
-	ecdsa_crypto::{AuthorityId, Signature},
-	ValidatorSet, ValidatorSetId, VoteMessage,
-};
+use sp_application_crypto::RuntimeAppPublic;
+use sp_consensus_beefy::{AuthorityIdBound, ValidatorSet, ValidatorSetId, VoteMessage};
 
 // Timeout for rebroadcasting messages.
 #[cfg(not(test))]
@@ -72,16 +70,19 @@ enum Consider {
 
 /// BEEFY gossip message type that gets encoded and sent on the network.
 #[derive(Debug, Encode, Decode)]
-pub(crate) enum GossipMessage<B: Block> {
+pub(crate) enum GossipMessage<B: Block, AuthorityId: AuthorityIdBound> {
 	/// BEEFY message with commitment and single signature.
-	Vote(VoteMessage<NumberFor<B>, AuthorityId, Signature>),
+	Vote(VoteMessage<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>),
 	/// BEEFY justification with commitment and signatures.
-	FinalityProof(BeefyVersionedFinalityProof<B>),
+	FinalityProof(BeefyVersionedFinalityProof<B, AuthorityId>),
 }
 
-impl<B: Block> GossipMessage<B> {
+impl<B: Block, AuthorityId: AuthorityIdBound> GossipMessage<B, AuthorityId> {
 	/// Return inner vote if this message is a Vote.
-	pub fn unwrap_vote(self) -> Option<VoteMessage<NumberFor<B>, AuthorityId, Signature>> {
+	pub fn unwrap_vote(
+		self,
+	) -> Option<VoteMessage<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>>
+	{
 		match self {
 			GossipMessage::Vote(vote) => Some(vote),
 			GossipMessage::FinalityProof(_) => None,
@@ -89,7 +90,7 @@ impl<B: Block> GossipMessage<B> {
 	}
 
 	/// Return inner finality proof if this message is a FinalityProof.
-	pub fn unwrap_finality_proof(self) -> Option<BeefyVersionedFinalityProof<B>> {
+	pub fn unwrap_finality_proof(self) -> Option<BeefyVersionedFinalityProof<B, AuthorityId>> {
 		match self {
 			GossipMessage::Vote(_) => None,
 			GossipMessage::FinalityProof(proof) => Some(proof),
@@ -114,33 +115,33 @@ where
 }
 
 #[derive(Clone, Debug)]
-pub(crate) struct GossipFilterCfg<'a, B: Block> {
+pub(crate) struct GossipFilterCfg<'a, B: Block, AuthorityId: AuthorityIdBound> {
 	pub start: NumberFor<B>,
 	pub end: NumberFor<B>,
 	pub validator_set: &'a ValidatorSet<AuthorityId>,
 }
 
 #[derive(Clone, Debug)]
-struct FilterInner<B: Block> {
+struct FilterInner<B: Block, AuthorityId: AuthorityIdBound> {
 	pub start: NumberFor<B>,
 	pub end: NumberFor<B>,
 	pub validator_set: ValidatorSet<AuthorityId>,
 }
 
-struct Filter<B: Block> {
+struct Filter<B: Block, AuthorityId: AuthorityIdBound> {
 	// specifies live rounds
-	inner: Option<FilterInner<B>>,
+	inner: Option<FilterInner<B, AuthorityId>>,
 	// cache of seen valid justifications in active rounds
 	rounds_with_valid_proofs: BTreeSet<NumberFor<B>>,
 }
 
-impl<B: Block> Filter<B> {
+impl<B: Block, AuthorityId: AuthorityIdBound> Filter<B, AuthorityId> {
 	pub fn new() -> Self {
 		Self { inner: None, rounds_with_valid_proofs: BTreeSet::new() }
 	}
 
 	/// Update filter to new `start` and `set_id`.
-	fn update(&mut self, cfg: GossipFilterCfg<B>) {
+	fn update(&mut self, cfg: GossipFilterCfg<B, AuthorityId>) {
 		self.rounds_with_valid_proofs
 			.retain(|&round| round >= cfg.start && round <= cfg.end);
 		// only clone+overwrite big validator_set if set_id changed
@@ -220,21 +221,22 @@ impl<B: Block> Filter<B> {
 /// rejected/expired.
 ///
 ///All messaging is handled in a single BEEFY global topic.
-pub(crate) struct GossipValidator<B, N>
+pub(crate) struct GossipValidator<B, N, AuthorityId: AuthorityIdBound>
 where
 	B: Block,
 {
 	votes_topic: B::Hash,
 	justifs_topic: B::Hash,
-	gossip_filter: RwLock<Filter<B>>,
+	gossip_filter: RwLock<Filter<B, AuthorityId>>,
 	next_rebroadcast: Mutex<Instant>,
 	known_peers: Arc<Mutex<KnownPeers<B>>>,
 	network: Arc<N>,
 }
 
-impl<B, N> GossipValidator<B, N>
+impl<B, N, AuthorityId> GossipValidator<B, N, AuthorityId>
 where
 	B: Block,
+	AuthorityId: AuthorityIdBound,
 {
 	pub(crate) fn new(known_peers: Arc<Mutex<KnownPeers<B>>>, network: Arc<N>) -> Self {
 		Self {
@@ -250,7 +252,7 @@ where
 	/// Update gossip validator filter.
 	///
 	/// Only votes for `set_id` and rounds `start <= round <= end` will be accepted.
-	pub(crate) fn update_filter(&self, filter: GossipFilterCfg<B>) {
+	pub(crate) fn update_filter(&self, filter: GossipFilterCfg<B, AuthorityId>) {
 		debug!(
 			target: LOG_TARGET,
 			"🥩 New gossip filter: start {:?}, end {:?}, validator set id {:?}",
@@ -260,10 +262,11 @@ where
 	}
 }
 
-impl<B, N> GossipValidator<B, N>
+impl<B, N, AuthorityId> GossipValidator<B, N, AuthorityId>
 where
 	B: Block,
 	N: NetworkPeers,
+	AuthorityId: AuthorityIdBound,
 {
 	fn report(&self, who: PeerId, cost_benefit: ReputationChange) {
 		self.network.report_peer(who, cost_benefit);
@@ -271,7 +274,7 @@ where
 
 	fn validate_vote(
 		&self,
-		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
+		vote: VoteMessage<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
 		sender: &PeerId,
 	) -> Action<B::Hash> {
 		let round = vote.commitment.block_number;
@@ -299,7 +302,7 @@ where
 				.unwrap_or(false)
 			{
 				debug!(target: LOG_TARGET, "Message from voter not in validator set: {}", vote.id);
-				return Action::Discard(cost::UNKNOWN_VOTER)
+				return Action::Discard(cost::UNKNOWN_VOTER);
 			}
 		}
 
@@ -316,10 +319,10 @@ where
 
 	fn validate_finality_proof(
 		&self,
-		proof: BeefyVersionedFinalityProof<B>,
+		proof: BeefyVersionedFinalityProof<B, AuthorityId>,
 		sender: &PeerId,
 	) -> Action<B::Hash> {
-		let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
+		let (round, set_id) = proof_block_num_and_set_id::<B, AuthorityId>(&proof);
 		self.known_peers.lock().note_vote_for(*sender, round);
 
 		let action = {
@@ -336,7 +339,7 @@ where
 			}
 
 			if guard.is_already_proven(round) {
-				return Action::Discard(benefit::NOT_INTERESTED)
+				return Action::Discard(benefit::NOT_INTERESTED);
 			}
 
 			// Verify justification signatures.
@@ -344,7 +347,7 @@ where
 				.validator_set()
 				.map(|validator_set| {
 					if let Err((_, signatures_checked)) =
-						verify_with_validator_set::<B>(round, validator_set, &proof)
+						verify_with_validator_set::<B, AuthorityId>(round, validator_set, &proof)
 					{
 						debug!(
 							target: LOG_TARGET,
@@ -369,9 +372,10 @@ where
 	}
 }
 
-impl<B, N> Validator<B> for GossipValidator<B, N>
+impl<B, N, AuthorityId> Validator<B> for GossipValidator<B, N, AuthorityId>
 where
 	B: Block,
+	AuthorityId: AuthorityIdBound,
 	N: NetworkPeers + Send + Sync,
 {
 	fn peer_disconnected(&self, _context: &mut dyn ValidatorContext<B>, who: &PeerId) {
@@ -385,7 +389,7 @@ where
 		mut data: &[u8],
 	) -> ValidationResult<B::Hash> {
 		let raw = data;
-		let action = match GossipMessage::<B>::decode_all(&mut data) {
+		let action = match GossipMessage::<B, AuthorityId>::decode_all(&mut data) {
 			Ok(GossipMessage::Vote(msg)) => self.validate_vote(msg, sender),
 			Ok(GossipMessage::FinalityProof(proof)) => self.validate_finality_proof(proof, sender),
 			Err(e) => {
@@ -414,26 +418,28 @@ where
 
 	fn message_expired<'a>(&'a self) -> Box<dyn FnMut(B::Hash, &[u8]) -> bool + 'a> {
 		let filter = self.gossip_filter.read();
-		Box::new(move |_topic, mut data| match GossipMessage::<B>::decode_all(&mut data) {
-			Ok(GossipMessage::Vote(msg)) => {
-				let round = msg.commitment.block_number;
-				let set_id = msg.commitment.validator_set_id;
-				let expired = filter.consider_vote(round, set_id) != Consider::Accept;
-				trace!(target: LOG_TARGET, "🥩 Vote for round #{} expired: {}", round, expired);
-				expired
-			},
-			Ok(GossipMessage::FinalityProof(proof)) => {
-				let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
-				let expired = filter.consider_finality_proof(round, set_id) != Consider::Accept;
-				trace!(
-					target: LOG_TARGET,
-					"🥩 Finality proof for round #{} expired: {}",
-					round,
+		Box::new(move |_topic, mut data| {
+			match GossipMessage::<B, AuthorityId>::decode_all(&mut data) {
+				Ok(GossipMessage::Vote(msg)) => {
+					let round = msg.commitment.block_number;
+					let set_id = msg.commitment.validator_set_id;
+					let expired = filter.consider_vote(round, set_id) != Consider::Accept;
+					trace!(target: LOG_TARGET, "🥩 Vote for round #{} expired: {}", round, expired);
 					expired
-				);
-				expired
-			},
-			Err(_) => true,
+				},
+				Ok(GossipMessage::FinalityProof(proof)) => {
+					let (round, set_id) = proof_block_num_and_set_id::<B, AuthorityId>(&proof);
+					let expired = filter.consider_finality_proof(round, set_id) != Consider::Accept;
+					trace!(
+						target: LOG_TARGET,
+						"🥩 Finality proof for round #{} expired: {}",
+						round,
+						expired
+					);
+					expired
+				},
+				Err(_) => true,
+			}
 		})
 	}
 
@@ -455,10 +461,10 @@ where
 		let filter = self.gossip_filter.read();
 		Box::new(move |_who, intent, _topic, mut data| {
 			if let MessageIntent::PeriodicRebroadcast = intent {
-				return do_rebroadcast
+				return do_rebroadcast;
 			}
 
-			match GossipMessage::<B>::decode_all(&mut data) {
+			match GossipMessage::<B, AuthorityId>::decode_all(&mut data) {
 				Ok(GossipMessage::Vote(msg)) => {
 					let round = msg.commitment.block_number;
 					let set_id = msg.commitment.validator_set_id;
@@ -467,7 +473,7 @@ where
 					allowed
 				},
 				Ok(GossipMessage::FinalityProof(proof)) => {
-					let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
+					let (round, set_id) = proof_block_num_and_set_id::<B, AuthorityId>(&proof);
 					let allowed = filter.consider_finality_proof(round, set_id) == Consider::Accept;
 					trace!(
 						target: LOG_TARGET,
@@ -490,8 +496,8 @@ pub(crate) mod tests {
 	use sc_network_test::Block;
 	use sp_application_crypto::key_types::BEEFY as BEEFY_KEY_TYPE;
 	use sp_consensus_beefy::{
-		ecdsa_crypto::Signature, known_payloads, test_utils::Keyring, Commitment, MmrRootHash,
-		Payload, SignedCommitment, VoteMessage,
+		ecdsa_crypto, known_payloads, test_utils::Keyring, Commitment, MmrRootHash, Payload,
+		SignedCommitment, VoteMessage,
 	};
 	use sp_keystore::{testing::MemoryKeystore, Keystore};
 
@@ -607,16 +613,18 @@ pub(crate) mod tests {
 	}
 
 	pub fn sign_commitment<BN: Encode>(
-		who: &Keyring<AuthorityId>,
+		who: &Keyring<ecdsa_crypto::AuthorityId>,
 		commitment: &Commitment<BN>,
-	) -> Signature {
+	) -> ecdsa_crypto::Signature {
 		let store = MemoryKeystore::new();
 		store.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&who.to_seed())).unwrap();
-		let beefy_keystore: BeefyKeystore<AuthorityId> = Some(store.into()).into();
+		let beefy_keystore: BeefyKeystore<ecdsa_crypto::AuthorityId> = Some(store.into()).into();
 		beefy_keystore.sign(&who.public(), &commitment.encode()).unwrap()
 	}
 
-	fn dummy_vote(block_number: u64) -> VoteMessage<u64, AuthorityId, Signature> {
+	fn dummy_vote(
+		block_number: u64,
+	) -> VoteMessage<u64, ecdsa_crypto::AuthorityId, ecdsa_crypto::Signature> {
 		let payload = Payload::from_single_entry(
 			known_payloads::MMR_ROOT_ID,
 			MmrRootHash::default().encode(),
@@ -629,8 +637,8 @@ pub(crate) mod tests {
 
 	pub fn dummy_proof(
 		block_number: u64,
-		validator_set: &ValidatorSet<AuthorityId>,
-	) -> BeefyVersionedFinalityProof<Block> {
+		validator_set: &ValidatorSet<ecdsa_crypto::AuthorityId>,
+	) -> BeefyVersionedFinalityProof<Block, ecdsa_crypto::AuthorityId> {
 		let payload = Payload::from_single_entry(
 			known_payloads::MMR_ROOT_ID,
 			MmrRootHash::default().encode(),
@@ -639,25 +647,29 @@ pub(crate) mod tests {
 		let signatures = validator_set
 			.validators()
 			.iter()
-			.map(|validator: &AuthorityId| {
+			.map(|validator: &ecdsa_crypto::AuthorityId| {
 				Some(sign_commitment(
-					&Keyring::<AuthorityId>::from_public(validator).unwrap(),
+					&Keyring::<ecdsa_crypto::AuthorityId>::from_public(validator).unwrap(),
 					&commitment,
 				))
 			})
 			.collect();
 
-		BeefyVersionedFinalityProof::<Block>::V1(SignedCommitment { commitment, signatures })
+		BeefyVersionedFinalityProof::<Block, ecdsa_crypto::AuthorityId>::V1(SignedCommitment {
+			commitment,
+			signatures,
+		})
 	}
 
 	#[test]
 	fn should_validate_messages() {
-		let keys = vec![Keyring::<AuthorityId>::Alice.public()];
-		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
+		let keys = vec![Keyring::<ecdsa_crypto::AuthorityId>::Alice.public()];
+		let validator_set =
+			ValidatorSet::<ecdsa_crypto::AuthorityId>::new(keys.clone(), 0).unwrap();
 
 		let (network, mut report_stream) = TestNetwork::new();
 
-		let gv = GossipValidator::<Block, _>::new(
+		let gv = GossipValidator::<Block, _, ecdsa_crypto::AuthorityId>::new(
 			Arc::new(Mutex::new(KnownPeers::new())),
 			Arc::new(network),
 		);
@@ -678,7 +690,8 @@ pub(crate) mod tests {
 		// verify votes validation
 
 		let vote = dummy_vote(3);
-		let encoded = GossipMessage::<Block>::Vote(vote.clone()).encode();
+		let encoded =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(vote.clone()).encode();
 
 		// filter not initialized
 		let res = gv.validate(&mut context, &sender, &encoded);
@@ -696,7 +709,7 @@ pub(crate) mod tests {
 		// reject vote, voter not in validator set
 		let mut bad_vote = vote.clone();
 		bad_vote.id = Keyring::Bob.public();
-		let bad_vote = GossipMessage::<Block>::Vote(bad_vote).encode();
+		let bad_vote = GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(bad_vote).encode();
 		let res = gv.validate(&mut context, &sender, &bad_vote);
 		assert!(matches!(res, ValidationResult::Discard));
 		expected_report.cost_benefit = cost::UNKNOWN_VOTER;
@@ -726,7 +739,8 @@ pub(crate) mod tests {
 
 		// reject old proof
 		let proof = dummy_proof(5, &validator_set);
-		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		let res = gv.validate(&mut context, &sender, &encoded_proof);
 		assert!(matches!(res, ValidationResult::Discard));
 		expected_report.cost_benefit = cost::OUTDATED_MESSAGE;
@@ -734,7 +748,8 @@ pub(crate) mod tests {
 
 		// accept next proof with good set_id
 		let proof = dummy_proof(7, &validator_set);
-		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		let res = gv.validate(&mut context, &sender, &encoded_proof);
 		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
 		expected_report.cost_benefit = benefit::VALIDATED_PROOF;
@@ -742,16 +757,18 @@ pub(crate) mod tests {
 
 		// accept future proof with good set_id
 		let proof = dummy_proof(20, &validator_set);
-		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		let res = gv.validate(&mut context, &sender, &encoded_proof);
 		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
 		expected_report.cost_benefit = benefit::VALIDATED_PROOF;
 		assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report);
 
 		// reject proof, future set_id
-		let bad_validator_set = ValidatorSet::<AuthorityId>::new(keys, 1).unwrap();
+		let bad_validator_set = ValidatorSet::<ecdsa_crypto::AuthorityId>::new(keys, 1).unwrap();
 		let proof = dummy_proof(20, &bad_validator_set);
-		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		let res = gv.validate(&mut context, &sender, &encoded_proof);
 		assert!(matches!(res, ValidationResult::Discard));
 		expected_report.cost_benefit = cost::FUTURE_MESSAGE;
@@ -759,9 +776,10 @@ pub(crate) mod tests {
 
 		// reject proof, bad signatures (Bob instead of Alice)
 		let bad_validator_set =
-			ValidatorSet::<AuthorityId>::new(vec![Keyring::Bob.public()], 0).unwrap();
+			ValidatorSet::<ecdsa_crypto::AuthorityId>::new(vec![Keyring::Bob.public()], 0).unwrap();
 		let proof = dummy_proof(21, &bad_validator_set);
-		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		let res = gv.validate(&mut context, &sender, &encoded_proof);
 		assert!(matches!(res, ValidationResult::Discard));
 		expected_report.cost_benefit = cost::INVALID_PROOF;
@@ -772,8 +790,9 @@ pub(crate) mod tests {
 	#[test]
 	fn messages_allowed_and_expired() {
 		let keys = vec![Keyring::Alice.public()];
-		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
-		let gv = GossipValidator::<Block, _>::new(
+		let validator_set =
+			ValidatorSet::<ecdsa_crypto::AuthorityId>::new(keys.clone(), 0).unwrap();
+		let gv = GossipValidator::<Block, _, ecdsa_crypto::AuthorityId>::new(
 			Arc::new(Mutex::new(KnownPeers::new())),
 			Arc::new(TestNetwork::new().0),
 		);
@@ -793,58 +812,70 @@ pub(crate) mod tests {
 
 		// inactive round 1 -> expired
 		let vote = dummy_vote(1);
-		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
+		let mut encoded_vote =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(vote).encode();
 		assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(expired(topic, &mut encoded_vote));
 		let proof = dummy_proof(1, &validator_set);
-		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let mut encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		assert!(!allowed(&sender, intent, &topic, &mut encoded_proof));
 		assert!(expired(topic, &mut encoded_proof));
 
 		// active round 2 -> !expired - concluded but still gossiped
 		let vote = dummy_vote(2);
-		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
+		let mut encoded_vote =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(vote).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(!expired(topic, &mut encoded_vote));
 		let proof = dummy_proof(2, &validator_set);
-		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let mut encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
 		assert!(!expired(topic, &mut encoded_proof));
 		// using wrong set_id -> !allowed, expired
-		let bad_validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 1).unwrap();
+		let bad_validator_set =
+			ValidatorSet::<ecdsa_crypto::AuthorityId>::new(keys.clone(), 1).unwrap();
 		let proof = dummy_proof(2, &bad_validator_set);
-		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let mut encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		assert!(!allowed(&sender, intent, &topic, &mut encoded_proof));
 		assert!(expired(topic, &mut encoded_proof));
 
 		// in progress round 3 -> !expired
 		let vote = dummy_vote(3);
-		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
+		let mut encoded_vote =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(vote).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(!expired(topic, &mut encoded_vote));
 		let proof = dummy_proof(3, &validator_set);
-		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let mut encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
 		assert!(!expired(topic, &mut encoded_proof));
 
 		// unseen round 4 -> !expired
 		let vote = dummy_vote(4);
-		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
+		let mut encoded_vote =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(vote).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(!expired(topic, &mut encoded_vote));
 		let proof = dummy_proof(4, &validator_set);
-		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let mut encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
 		assert!(!expired(topic, &mut encoded_proof));
 
 		// future round 11 -> expired
 		let vote = dummy_vote(11);
-		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
+		let mut encoded_vote =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(vote).encode();
 		assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(expired(topic, &mut encoded_vote));
 		// future proofs allowed while same set_id -> allowed
 		let proof = dummy_proof(11, &validator_set);
-		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let mut encoded_proof =
+			GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
 		assert!(!expired(topic, &mut encoded_proof));
 	}
@@ -852,8 +883,9 @@ pub(crate) mod tests {
 	#[test]
 	fn messages_rebroadcast() {
 		let keys = vec![Keyring::Alice.public()];
-		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
-		let gv = GossipValidator::<Block, _>::new(
+		let validator_set =
+			ValidatorSet::<ecdsa_crypto::AuthorityId>::new(keys.clone(), 0).unwrap();
+		let gv = GossipValidator::<Block, _, ecdsa_crypto::AuthorityId>::new(
 			Arc::new(Mutex::new(KnownPeers::new())),
 			Arc::new(TestNetwork::new().0),
 		);
diff --git a/substrate/client/consensus/beefy/src/communication/notification.rs b/substrate/client/consensus/beefy/src/communication/notification.rs
index a4486e523c301f6b64af3936a5bdba3456303ad2..8bb5d848b4faab9ee5a25032b32db0015324d4bc 100644
--- a/substrate/client/consensus/beefy/src/communication/notification.rs
+++ b/substrate/client/consensus/beefy/src/communication/notification.rs
@@ -32,13 +32,15 @@ pub type BeefyBestBlockStream<Block> =
 
 /// The sending half of the notifications channel(s) used to send notifications
 /// about versioned finality proof generated at the end of a BEEFY round.
-pub type BeefyVersionedFinalityProofSender<Block> =
-	NotificationSender<BeefyVersionedFinalityProof<Block>>;
+pub type BeefyVersionedFinalityProofSender<Block, AuthorityId> =
+	NotificationSender<BeefyVersionedFinalityProof<Block, AuthorityId>>;
 
 /// The receiving half of a notifications channel used to receive notifications
 /// about versioned finality proof generated at the end of a BEEFY round.
-pub type BeefyVersionedFinalityProofStream<Block> =
-	NotificationStream<BeefyVersionedFinalityProof<Block>, BeefyVersionedFinalityProofTracingKey>;
+pub type BeefyVersionedFinalityProofStream<Block, AuthorityId> = NotificationStream<
+	BeefyVersionedFinalityProof<Block, AuthorityId>,
+	BeefyVersionedFinalityProofTracingKey,
+>;
 
 /// Provides tracing key for BEEFY best block stream.
 #[derive(Clone)]
diff --git a/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs b/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs
index 7893066a01e06c967893bdedbd25ad3c2da9c3bd..c473c14bccc3d90beb6fc50e58b95d6d198fa8f2 100644
--- a/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs
+++ b/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs
@@ -87,9 +87,9 @@ impl<B: Block> IncomingRequest<B> {
 					sent_feedback: None,
 				};
 				if let Err(_) = pending_response.send(response) {
-					return Err(Error::DecodingErrorNoReputationChange(peer, err))
+					return Err(Error::DecodingErrorNoReputationChange(peer, err));
 				}
-				return Err(Error::DecodingError(peer, err))
+				return Err(Error::DecodingError(peer, err));
 			},
 		};
 		Ok(Self::new(peer, payload, pending_response))
@@ -144,7 +144,7 @@ where
 		genesis_hash: Hash,
 		fork_id: Option<&str>,
 		client: Arc<Client>,
-		prometheus_registry: Option<prometheus::Registry>,
+		prometheus_registry: Option<prometheus_endpoint::Registry>,
 	) -> (Self, Network::RequestResponseProtocolConfig) {
 		let (request_receiver, config): (_, Network::RequestResponseProtocolConfig) =
 			on_demand_justifications_protocol_config::<_, _, Network>(genesis_hash, fork_id);
diff --git a/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs b/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs
index 2ab072960900817155b42434f69f29236fcda54b..e127e5a895905b212fda73b109714618b76367d9 100644
--- a/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs
+++ b/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs
@@ -27,7 +27,7 @@ use sc_network::{
 	NetworkRequest, ProtocolName,
 };
 use sc_network_types::PeerId;
-use sp_consensus_beefy::{ecdsa_crypto::AuthorityId, ValidatorSet};
+use sp_consensus_beefy::{AuthorityIdBound, ValidatorSet};
 use sp_runtime::traits::{Block, NumberFor};
 use std::{collections::VecDeque, result::Result, sync::Arc};
 
@@ -49,43 +49,43 @@ type Response = Result<(Vec<u8>, ProtocolName), RequestFailure>;
 type ResponseReceiver = oneshot::Receiver<Response>;
 
 #[derive(Clone, Debug)]
-struct RequestInfo<B: Block> {
+struct RequestInfo<B: Block, AuthorityId: AuthorityIdBound> {
 	block: NumberFor<B>,
 	active_set: ValidatorSet<AuthorityId>,
 }
 
-enum State<B: Block> {
+enum State<B: Block, AuthorityId: AuthorityIdBound> {
 	Idle,
-	AwaitingResponse(PeerId, RequestInfo<B>, ResponseReceiver),
+	AwaitingResponse(PeerId, RequestInfo<B, AuthorityId>, ResponseReceiver),
 }
 
 /// Possible engine responses.
-pub(crate) enum ResponseInfo<B: Block> {
+pub(crate) enum ResponseInfo<B: Block, AuthorityId: AuthorityIdBound> {
 	/// No peer response available yet.
 	Pending,
 	/// Valid justification provided alongside peer reputation changes.
-	ValidProof(BeefyVersionedFinalityProof<B>, PeerReport),
+	ValidProof(BeefyVersionedFinalityProof<B, AuthorityId>, PeerReport),
 	/// No justification yet, only peer reputation changes.
 	PeerReport(PeerReport),
 }
 
-pub struct OnDemandJustificationsEngine<B: Block> {
+pub struct OnDemandJustificationsEngine<B: Block, AuthorityId: AuthorityIdBound> {
 	network: Arc<dyn NetworkRequest + Send + Sync>,
 	protocol_name: ProtocolName,
 
 	live_peers: Arc<Mutex<KnownPeers<B>>>,
 	peers_cache: VecDeque<PeerId>,
 
-	state: State<B>,
+	state: State<B, AuthorityId>,
 	metrics: Option<OnDemandOutgoingRequestsMetrics>,
 }
 
-impl<B: Block> OnDemandJustificationsEngine<B> {
+impl<B: Block, AuthorityId: AuthorityIdBound> OnDemandJustificationsEngine<B, AuthorityId> {
 	pub fn new(
 		network: Arc<dyn NetworkRequest + Send + Sync>,
 		protocol_name: ProtocolName,
 		live_peers: Arc<Mutex<KnownPeers<B>>>,
-		prometheus_registry: Option<prometheus::Registry>,
+		prometheus_registry: Option<prometheus_endpoint::Registry>,
 	) -> Self {
 		let metrics = register_metrics(prometheus_registry);
 		Self {
@@ -106,13 +106,13 @@ impl<B: Block> OnDemandJustificationsEngine<B> {
 		let live = self.live_peers.lock();
 		while let Some(peer) = self.peers_cache.pop_front() {
 			if live.contains(&peer) {
-				return Some(peer)
+				return Some(peer);
 			}
 		}
 		None
 	}
 
-	fn request_from_peer(&mut self, peer: PeerId, req_info: RequestInfo<B>) {
+	fn request_from_peer(&mut self, peer: PeerId, req_info: RequestInfo<B, AuthorityId>) {
 		debug!(
 			target: BEEFY_SYNC_LOG_TARGET,
 			"🥩 requesting justif #{:?} from peer {:?}", req_info.block, peer,
@@ -140,7 +140,7 @@ impl<B: Block> OnDemandJustificationsEngine<B> {
 	pub fn request(&mut self, block: NumberFor<B>, active_set: ValidatorSet<AuthorityId>) {
 		// ignore new requests while there's already one pending
 		if matches!(self.state, State::AwaitingResponse(_, _, _)) {
-			return
+			return;
 		}
 		self.reset_peers_cache_for_block(block);
 
@@ -174,9 +174,9 @@ impl<B: Block> OnDemandJustificationsEngine<B> {
 	fn process_response(
 		&mut self,
 		peer: &PeerId,
-		req_info: &RequestInfo<B>,
+		req_info: &RequestInfo<B, AuthorityId>,
 		response: Result<Response, Canceled>,
-	) -> Result<BeefyVersionedFinalityProof<B>, Error> {
+	) -> Result<BeefyVersionedFinalityProof<B, AuthorityId>, Error> {
 		response
 			.map_err(|e| {
 				debug!(
@@ -207,7 +207,7 @@ impl<B: Block> OnDemandJustificationsEngine<B> {
 				}
 			})
 			.and_then(|(encoded, _)| {
-				decode_and_verify_finality_proof::<B>(
+				decode_and_verify_finality_proof::<B, AuthorityId>(
 					&encoded[..],
 					req_info.block,
 					&req_info.active_set,
@@ -227,11 +227,11 @@ impl<B: Block> OnDemandJustificationsEngine<B> {
 			})
 	}
 
-	pub(crate) async fn next(&mut self) -> ResponseInfo<B> {
+	pub(crate) async fn next(&mut self) -> ResponseInfo<B, AuthorityId> {
 		let (peer, req_info, resp) = match &mut self.state {
 			State::Idle => {
 				futures::future::pending::<()>().await;
-				return ResponseInfo::Pending
+				return ResponseInfo::Pending;
 			},
 			State::AwaitingResponse(peer, req_info, receiver) => {
 				let resp = receiver.await;
diff --git a/substrate/client/consensus/beefy/src/error.rs b/substrate/client/consensus/beefy/src/error.rs
index b4773f940193e07d4f6f6962b69096c91805bbeb..9cd09cb99332a28f3f1ec731be3c5af6504c91e0 100644
--- a/substrate/client/consensus/beefy/src/error.rs
+++ b/substrate/client/consensus/beefy/src/error.rs
@@ -20,6 +20,7 @@
 //!
 //! Used for BEEFY gadget internal error handling only
 
+use sp_blockchain::Error as ClientError;
 use std::fmt::Debug;
 
 #[derive(Debug, thiserror::Error)]
@@ -48,6 +49,12 @@ pub enum Error {
 	VotesGossipStreamTerminated,
 }
 
+impl From<ClientError> for Error {
+	fn from(e: ClientError) -> Self {
+		Self::Backend(e.to_string())
+	}
+}
+
 #[cfg(test)]
 impl PartialEq for Error {
 	fn eq(&self, other: &Self) -> bool {
diff --git a/substrate/client/consensus/beefy/src/fisherman.rs b/substrate/client/consensus/beefy/src/fisherman.rs
index a2b4c8f945d1c224c45e522bc7e7b0461a3c00ce..073fee0bdbdbecb3ee6d869a3e727d3ec62b9c9b 100644
--- a/substrate/client/consensus/beefy/src/fisherman.rs
+++ b/substrate/client/consensus/beefy/src/fisherman.rs
@@ -20,11 +20,11 @@ use crate::{error::Error, keystore::BeefyKeystore, round::Rounds, LOG_TARGET};
 use log::{debug, error, warn};
 use sc_client_api::Backend;
 use sp_api::ProvideRuntimeApi;
+use sp_application_crypto::RuntimeAppPublic;
 use sp_blockchain::HeaderBackend;
 use sp_consensus_beefy::{
-	check_equivocation_proof,
-	ecdsa_crypto::{AuthorityId, Signature},
-	BeefyApi, BeefySignatureHasher, DoubleVotingProof, OpaqueKeyOwnershipProof, ValidatorSetId,
+	check_equivocation_proof, AuthorityIdBound, BeefyApi, BeefySignatureHasher, DoubleVotingProof,
+	OpaqueKeyOwnershipProof, ValidatorSetId,
 };
 use sp_runtime::{
 	generic::BlockId,
@@ -33,13 +33,13 @@ use sp_runtime::{
 use std::{marker::PhantomData, sync::Arc};
 
 /// Helper struct containing the id and the key ownership proof for a validator.
-pub struct ProvedValidator<'a> {
+pub struct ProvedValidator<'a, AuthorityId: AuthorityIdBound> {
 	pub id: &'a AuthorityId,
 	pub key_owner_proof: OpaqueKeyOwnershipProof,
 }
 
 /// Helper used to check and report equivocations.
-pub struct Fisherman<B, BE, RuntimeApi> {
+pub struct Fisherman<B, BE, RuntimeApi, AuthorityId: AuthorityIdBound> {
 	backend: Arc<BE>,
 	runtime: Arc<RuntimeApi>,
 	key_store: Arc<BeefyKeystore<AuthorityId>>,
@@ -47,9 +47,11 @@ pub struct Fisherman<B, BE, RuntimeApi> {
 	_phantom: PhantomData<B>,
 }
 
-impl<B: Block, BE: Backend<B>, RuntimeApi: ProvideRuntimeApi<B>> Fisherman<B, BE, RuntimeApi>
+impl<B: Block, BE: Backend<B>, RuntimeApi: ProvideRuntimeApi<B>, AuthorityId>
+	Fisherman<B, BE, RuntimeApi, AuthorityId>
 where
 	RuntimeApi::Api: BeefyApi<B, AuthorityId>,
+	AuthorityId: AuthorityIdBound,
 {
 	pub fn new(
 		backend: Arc<BE>,
@@ -64,7 +66,7 @@ where
 		at: BlockId<B>,
 		offender_ids: impl Iterator<Item = &'a AuthorityId>,
 		validator_set_id: ValidatorSetId,
-	) -> Result<Vec<ProvedValidator<'a>>, Error> {
+	) -> Result<Vec<ProvedValidator<'a, AuthorityId>>, Error> {
 		let hash = match at {
 			BlockId::Hash(hash) => hash,
 			BlockId::Number(number) => self
@@ -119,8 +121,12 @@ where
 	/// isn't necessarily the best block if there are pending authority set changes.
 	pub fn report_double_voting(
 		&self,
-		proof: DoubleVotingProof<NumberFor<B>, AuthorityId, Signature>,
-		active_rounds: &Rounds<B>,
+		proof: DoubleVotingProof<
+			NumberFor<B>,
+			AuthorityId,
+			<AuthorityId as RuntimeAppPublic>::Signature,
+		>,
+		active_rounds: &Rounds<B, AuthorityId>,
 	) -> Result<(), Error> {
 		let (validators, validator_set_id) =
 			(active_rounds.validators(), active_rounds.validator_set_id());
@@ -128,13 +134,13 @@ where
 
 		if !check_equivocation_proof::<_, _, BeefySignatureHasher>(&proof) {
 			debug!(target: LOG_TARGET, "🥩 Skipping report for bad equivocation {:?}", proof);
-			return Ok(())
+			return Ok(());
 		}
 
 		if let Some(local_id) = self.key_store.authority_id(validators) {
 			if offender_id == &local_id {
 				warn!(target: LOG_TARGET, "🥩 Skipping report for own equivocation");
-				return Ok(())
+				return Ok(());
 			}
 		}
 
diff --git a/substrate/client/consensus/beefy/src/import.rs b/substrate/client/consensus/beefy/src/import.rs
index ed8ed68c4e8d0d378728ba87d1ffe726f6c4c11a..c01fb3db4845eb9e413e0dbe781ae395a3b31217 100644
--- a/substrate/client/consensus/beefy/src/import.rs
+++ b/substrate/client/consensus/beefy/src/import.rs
@@ -22,7 +22,7 @@ use log::debug;
 
 use sp_api::ProvideRuntimeApi;
 use sp_consensus::Error as ConsensusError;
-use sp_consensus_beefy::{ecdsa_crypto::AuthorityId, BeefyApi, BEEFY_ENGINE_ID};
+use sp_consensus_beefy::{AuthorityIdBound, BeefyApi, BEEFY_ENGINE_ID};
 use sp_runtime::{
 	traits::{Block as BlockT, Header as HeaderT, NumberFor},
 	EncodedJustification,
@@ -45,15 +45,17 @@ use crate::{
 /// Wraps a `inner: BlockImport` and ultimately defers to it.
 ///
 /// When using BEEFY, the block import worker should be using this block import object.
-pub struct BeefyBlockImport<Block: BlockT, Backend, RuntimeApi, I> {
+pub struct BeefyBlockImport<Block: BlockT, Backend, RuntimeApi, I, AuthorityId: AuthorityIdBound> {
 	backend: Arc<Backend>,
 	runtime: Arc<RuntimeApi>,
 	inner: I,
-	justification_sender: BeefyVersionedFinalityProofSender<Block>,
+	justification_sender: BeefyVersionedFinalityProofSender<Block, AuthorityId>,
 	metrics: Option<BlockImportMetrics>,
 }
 
-impl<Block: BlockT, BE, Runtime, I: Clone> Clone for BeefyBlockImport<Block, BE, Runtime, I> {
+impl<Block: BlockT, BE, Runtime, I: Clone, AuthorityId: AuthorityIdBound> Clone
+	for BeefyBlockImport<Block, BE, Runtime, I, AuthorityId>
+{
 	fn clone(&self) -> Self {
 		BeefyBlockImport {
 			backend: self.backend.clone(),
@@ -65,32 +67,35 @@ impl<Block: BlockT, BE, Runtime, I: Clone> Clone for BeefyBlockImport<Block, BE,
 	}
 }
 
-impl<Block: BlockT, BE, Runtime, I> BeefyBlockImport<Block, BE, Runtime, I> {
+impl<Block: BlockT, BE, Runtime, I, AuthorityId: AuthorityIdBound>
+	BeefyBlockImport<Block, BE, Runtime, I, AuthorityId>
+{
 	/// Create a new BeefyBlockImport.
 	pub fn new(
 		backend: Arc<BE>,
 		runtime: Arc<Runtime>,
 		inner: I,
-		justification_sender: BeefyVersionedFinalityProofSender<Block>,
+		justification_sender: BeefyVersionedFinalityProofSender<Block, AuthorityId>,
 		metrics: Option<BlockImportMetrics>,
-	) -> BeefyBlockImport<Block, BE, Runtime, I> {
+	) -> BeefyBlockImport<Block, BE, Runtime, I, AuthorityId> {
 		BeefyBlockImport { backend, runtime, inner, justification_sender, metrics }
 	}
 }
 
-impl<Block, BE, Runtime, I> BeefyBlockImport<Block, BE, Runtime, I>
+impl<Block, BE, Runtime, I, AuthorityId> BeefyBlockImport<Block, BE, Runtime, I, AuthorityId>
 where
 	Block: BlockT,
 	BE: Backend<Block>,
 	Runtime: ProvideRuntimeApi<Block>,
 	Runtime::Api: BeefyApi<Block, AuthorityId> + Send,
+	AuthorityId: AuthorityIdBound,
 {
 	fn decode_and_verify(
 		&self,
 		encoded: &EncodedJustification,
 		number: NumberFor<Block>,
 		hash: <Block as BlockT>::Hash,
-	) -> Result<BeefyVersionedFinalityProof<Block>, ConsensusError> {
+	) -> Result<BeefyVersionedFinalityProof<Block, AuthorityId>, ConsensusError> {
 		use ConsensusError::ClientImport as ImportError;
 		let beefy_genesis = self
 			.runtime
@@ -99,7 +104,7 @@ where
 			.map_err(|e| ImportError(e.to_string()))?
 			.ok_or_else(|| ImportError("Unknown BEEFY genesis".to_string()))?;
 		if number < beefy_genesis {
-			return Err(ImportError("BEEFY genesis is set for future block".to_string()))
+			return Err(ImportError("BEEFY genesis is set for future block".to_string()));
 		}
 		let validator_set = self
 			.runtime
@@ -108,19 +113,21 @@ where
 			.map_err(|e| ImportError(e.to_string()))?
 			.ok_or_else(|| ImportError("Unknown validator set".to_string()))?;
 
-		decode_and_verify_finality_proof::<Block>(&encoded[..], number, &validator_set)
+		decode_and_verify_finality_proof::<Block, AuthorityId>(&encoded[..], number, &validator_set)
 			.map_err(|(err, _)| err)
 	}
 }
 
 #[async_trait::async_trait]
-impl<Block, BE, Runtime, I> BlockImport<Block> for BeefyBlockImport<Block, BE, Runtime, I>
+impl<Block, BE, Runtime, I, AuthorityId> BlockImport<Block>
+	for BeefyBlockImport<Block, BE, Runtime, I, AuthorityId>
 where
 	Block: BlockT,
 	BE: Backend<Block>,
 	I: BlockImport<Block, Error = ConsensusError> + Send + Sync,
 	Runtime: ProvideRuntimeApi<Block> + Send + Sync,
 	Runtime::Api: BeefyApi<Block, AuthorityId>,
+	AuthorityId: AuthorityIdBound,
 {
 	type Error = ConsensusError;
 
@@ -148,7 +155,7 @@ where
 				// The block is imported as part of some chain sync.
 				// The voter doesn't need to process it now.
 				// It will be detected and processed as part of the voter state init.
-				return Ok(inner_import_result)
+				return Ok(inner_import_result);
 			},
 		}
 
diff --git a/substrate/client/consensus/beefy/src/justification.rs b/substrate/client/consensus/beefy/src/justification.rs
index 886368c9d7cb096c0178819e1bad23f06c82f3fb..9ff7c3cf54f687c8f937ff0cecd9aea821c2ddaa 100644
--- a/substrate/client/consensus/beefy/src/justification.rs
+++ b/substrate/client/consensus/beefy/src/justification.rs
@@ -17,18 +17,20 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use codec::DecodeAll;
+use sp_application_crypto::RuntimeAppPublic;
 use sp_consensus::Error as ConsensusError;
 use sp_consensus_beefy::{
-	ecdsa_crypto::{AuthorityId, Signature},
-	BeefySignatureHasher, KnownSignature, ValidatorSet, ValidatorSetId, VersionedFinalityProof,
+	AuthorityIdBound, BeefySignatureHasher, KnownSignature, ValidatorSet, ValidatorSetId,
+	VersionedFinalityProof,
 };
 use sp_runtime::traits::{Block as BlockT, NumberFor};
 
 /// A finality proof with matching BEEFY authorities' signatures.
-pub type BeefyVersionedFinalityProof<Block> = VersionedFinalityProof<NumberFor<Block>, Signature>;
+pub type BeefyVersionedFinalityProof<Block, AuthorityId> =
+	VersionedFinalityProof<NumberFor<Block>, <AuthorityId as RuntimeAppPublic>::Signature>;
 
-pub(crate) fn proof_block_num_and_set_id<Block: BlockT>(
-	proof: &BeefyVersionedFinalityProof<Block>,
+pub(crate) fn proof_block_num_and_set_id<Block: BlockT, AuthorityId: AuthorityIdBound>(
+	proof: &BeefyVersionedFinalityProof<Block, AuthorityId>,
 ) -> (NumberFor<Block>, ValidatorSetId) {
 	match proof {
 		VersionedFinalityProof::V1(sc) =>
@@ -37,23 +39,26 @@ pub(crate) fn proof_block_num_and_set_id<Block: BlockT>(
 }
 
 /// Decode and verify a Beefy FinalityProof.
-pub(crate) fn decode_and_verify_finality_proof<Block: BlockT>(
+pub(crate) fn decode_and_verify_finality_proof<Block: BlockT, AuthorityId: AuthorityIdBound>(
 	encoded: &[u8],
 	target_number: NumberFor<Block>,
 	validator_set: &ValidatorSet<AuthorityId>,
-) -> Result<BeefyVersionedFinalityProof<Block>, (ConsensusError, u32)> {
-	let proof = <BeefyVersionedFinalityProof<Block>>::decode_all(&mut &*encoded)
+) -> Result<BeefyVersionedFinalityProof<Block, AuthorityId>, (ConsensusError, u32)> {
+	let proof = <BeefyVersionedFinalityProof<Block, AuthorityId>>::decode_all(&mut &*encoded)
 		.map_err(|_| (ConsensusError::InvalidJustification, 0))?;
-	verify_with_validator_set::<Block>(target_number, validator_set, &proof)?;
+	verify_with_validator_set::<Block, AuthorityId>(target_number, validator_set, &proof)?;
 	Ok(proof)
 }
 
 /// Verify the Beefy finality proof against the validator set at the block it was generated.
-pub(crate) fn verify_with_validator_set<'a, Block: BlockT>(
+pub(crate) fn verify_with_validator_set<'a, Block: BlockT, AuthorityId: AuthorityIdBound>(
 	target_number: NumberFor<Block>,
 	validator_set: &'a ValidatorSet<AuthorityId>,
-	proof: &'a BeefyVersionedFinalityProof<Block>,
-) -> Result<Vec<KnownSignature<&'a AuthorityId, &'a Signature>>, (ConsensusError, u32)> {
+	proof: &'a BeefyVersionedFinalityProof<Block, AuthorityId>,
+) -> Result<
+	Vec<KnownSignature<&'a AuthorityId, &'a <AuthorityId as RuntimeAppPublic>::Signature>>,
+	(ConsensusError, u32),
+> {
 	match proof {
 		VersionedFinalityProof::V1(signed_commitment) => {
 			let signatories = signed_commitment
@@ -78,7 +83,7 @@ pub(crate) fn verify_with_validator_set<'a, Block: BlockT>(
 pub(crate) mod tests {
 	use codec::Encode;
 	use sp_consensus_beefy::{
-		known_payloads, test_utils::Keyring, Commitment, Payload, SignedCommitment,
+		ecdsa_crypto, known_payloads, test_utils::Keyring, Commitment, Payload, SignedCommitment,
 		VersionedFinalityProof,
 	};
 	use substrate_test_runtime_client::runtime::Block;
@@ -88,9 +93,9 @@ pub(crate) mod tests {
 
 	pub(crate) fn new_finality_proof(
 		block_num: NumberFor<Block>,
-		validator_set: &ValidatorSet<AuthorityId>,
-		keys: &[Keyring<AuthorityId>],
-	) -> BeefyVersionedFinalityProof<Block> {
+		validator_set: &ValidatorSet<ecdsa_crypto::AuthorityId>,
+		keys: &[Keyring<ecdsa_crypto::AuthorityId>],
+	) -> BeefyVersionedFinalityProof<Block, ecdsa_crypto::AuthorityId> {
 		let commitment = Commitment {
 			payload: Payload::from_single_entry(known_payloads::MMR_ROOT_ID, vec![]),
 			block_number: block_num,
@@ -112,11 +117,20 @@ pub(crate) mod tests {
 
 		let good_proof = proof.clone().into();
 		// should verify successfully
-		verify_with_validator_set::<Block>(block_num, &validator_set, &good_proof).unwrap();
+		verify_with_validator_set::<Block, ecdsa_crypto::AuthorityId>(
+			block_num,
+			&validator_set,
+			&good_proof,
+		)
+		.unwrap();
 
 		// wrong block number -> should fail verification
 		let good_proof = proof.clone().into();
-		match verify_with_validator_set::<Block>(block_num + 1, &validator_set, &good_proof) {
+		match verify_with_validator_set::<Block, ecdsa_crypto::AuthorityId>(
+			block_num + 1,
+			&validator_set,
+			&good_proof,
+		) {
 			Err((ConsensusError::InvalidJustification, 0)) => (),
 			e => assert!(false, "Got unexpected {:?}", e),
 		};
@@ -124,7 +138,11 @@ pub(crate) mod tests {
 		// wrong validator set id -> should fail verification
 		let good_proof = proof.clone().into();
 		let other = ValidatorSet::new(make_beefy_ids(keys), 1).unwrap();
-		match verify_with_validator_set::<Block>(block_num, &other, &good_proof) {
+		match verify_with_validator_set::<Block, ecdsa_crypto::AuthorityId>(
+			block_num,
+			&other,
+			&good_proof,
+		) {
 			Err((ConsensusError::InvalidJustification, 0)) => (),
 			e => assert!(false, "Got unexpected {:?}", e),
 		};
@@ -136,7 +154,11 @@ pub(crate) mod tests {
 			VersionedFinalityProof::V1(ref mut sc) => sc,
 		};
 		bad_signed_commitment.signatures.pop().flatten().unwrap();
-		match verify_with_validator_set::<Block>(block_num + 1, &validator_set, &bad_proof.into()) {
+		match verify_with_validator_set::<Block, ecdsa_crypto::AuthorityId>(
+			block_num + 1,
+			&validator_set,
+			&bad_proof.into(),
+		) {
 			Err((ConsensusError::InvalidJustification, 0)) => (),
 			e => assert!(false, "Got unexpected {:?}", e),
 		};
@@ -148,7 +170,11 @@ pub(crate) mod tests {
 		};
 		// remove a signature (but same length)
 		*bad_signed_commitment.signatures.first_mut().unwrap() = None;
-		match verify_with_validator_set::<Block>(block_num, &validator_set, &bad_proof.into()) {
+		match verify_with_validator_set::<Block, ecdsa_crypto::AuthorityId>(
+			block_num,
+			&validator_set,
+			&bad_proof.into(),
+		) {
 			Err((ConsensusError::InvalidJustification, 2)) => (),
 			e => assert!(false, "Got unexpected {:?}", e),
 		};
@@ -159,9 +185,15 @@ pub(crate) mod tests {
 			VersionedFinalityProof::V1(ref mut sc) => sc,
 		};
 		// change a signature to a different key
-		*bad_signed_commitment.signatures.first_mut().unwrap() =
-			Some(Keyring::<AuthorityId>::Dave.sign(&bad_signed_commitment.commitment.encode()));
-		match verify_with_validator_set::<Block>(block_num, &validator_set, &bad_proof.into()) {
+		*bad_signed_commitment.signatures.first_mut().unwrap() = Some(
+			Keyring::<ecdsa_crypto::AuthorityId>::Dave
+				.sign(&bad_signed_commitment.commitment.encode()),
+		);
+		match verify_with_validator_set::<Block, ecdsa_crypto::AuthorityId>(
+			block_num,
+			&validator_set,
+			&bad_proof.into(),
+		) {
 			Err((ConsensusError::InvalidJustification, 3)) => (),
 			e => assert!(false, "Got unexpected {:?}", e),
 		};
@@ -175,12 +207,17 @@ pub(crate) mod tests {
 
 		// build valid justification
 		let proof = new_finality_proof(block_num, &validator_set, keys);
-		let versioned_proof: BeefyVersionedFinalityProof<Block> = proof.into();
+		let versioned_proof: BeefyVersionedFinalityProof<Block, ecdsa_crypto::AuthorityId> =
+			proof.into();
 		let encoded = versioned_proof.encode();
 
 		// should successfully decode and verify
-		let verified =
-			decode_and_verify_finality_proof::<Block>(&encoded, block_num, &validator_set).unwrap();
+		let verified = decode_and_verify_finality_proof::<Block, ecdsa_crypto::AuthorityId>(
+			&encoded,
+			block_num,
+			&validator_set,
+		)
+		.unwrap();
 		assert_eq!(verified, versioned_proof);
 	}
 }
diff --git a/substrate/client/consensus/beefy/src/keystore.rs b/substrate/client/consensus/beefy/src/keystore.rs
index 9582c2661c30b431a5934e2bcc592b4a56faf3b3..8daf3440c7d2c745cc0ef85bc3d7436a6d91e1f4 100644
--- a/substrate/client/consensus/beefy/src/keystore.rs
+++ b/substrate/client/consensus/beefy/src/keystore.rs
@@ -15,19 +15,19 @@
 
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
+use codec::Decode;
+use log::warn;
 
 use sp_application_crypto::{key_types::BEEFY as BEEFY_KEY_TYPE, AppCrypto, RuntimeAppPublic};
-use sp_consensus_beefy::{AuthorityIdBound, BeefyAuthorityId, BeefySignatureHasher};
-use sp_core::ecdsa;
 #[cfg(feature = "bls-experimental")]
 use sp_core::ecdsa_bls377;
-use sp_crypto_hashing::keccak_256;
-use sp_keystore::KeystorePtr;
+use sp_core::{ecdsa, keccak_256};
 
-use codec::Decode;
-use log::warn;
+use sp_keystore::KeystorePtr;
 use std::marker::PhantomData;
 
+use sp_consensus_beefy::{AuthorityIdBound, BeefyAuthorityId, BeefySignatureHasher};
+
 use crate::{error, LOG_TARGET};
 
 /// A BEEFY specific keystore implemented as a `Newtype`. This is basically a
@@ -175,10 +175,7 @@ impl<AuthorityId: AuthorityIdBound> BeefyKeystore<AuthorityId> {
 	}
 }
 
-impl<AuthorityId: AuthorityIdBound> From<Option<KeystorePtr>> for BeefyKeystore<AuthorityId>
-where
-	<AuthorityId as RuntimeAppPublic>::Signature: Send + Sync,
-{
+impl<AuthorityId: AuthorityIdBound> From<Option<KeystorePtr>> for BeefyKeystore<AuthorityId> {
 	fn from(store: Option<KeystorePtr>) -> BeefyKeystore<AuthorityId> {
 		BeefyKeystore(store, PhantomData)
 	}
diff --git a/substrate/client/consensus/beefy/src/lib.rs b/substrate/client/consensus/beefy/src/lib.rs
index 0e49839f0fd2dae76e26738823ea9e5af775acb7..a47bfe1dbe24056237a5aa87a3266270b54877ef 100644
--- a/substrate/client/consensus/beefy/src/lib.rs
+++ b/substrate/client/consensus/beefy/src/lib.rs
@@ -34,7 +34,7 @@ use crate::{
 use futures::{stream::Fuse, FutureExt, StreamExt};
 use log::{debug, error, info, warn};
 use parking_lot::Mutex;
-use prometheus::Registry;
+use prometheus_endpoint::Registry;
 use sc_client_api::{Backend, BlockBackend, BlockchainEvents, FinalityNotifications, Finalizer};
 use sc_consensus::BlockImport;
 use sc_network::{NetworkRequest, NotificationService, ProtocolName};
@@ -43,8 +43,7 @@ use sp_api::ProvideRuntimeApi;
 use sp_blockchain::{Backend as BlockchainBackend, HeaderBackend};
 use sp_consensus::{Error as ConsensusError, SyncOracle};
 use sp_consensus_beefy::{
-	ecdsa_crypto::AuthorityId, BeefyApi, ConsensusLog, PayloadProvider, ValidatorSet,
-	BEEFY_ENGINE_ID,
+	AuthorityIdBound, BeefyApi, ConsensusLog, PayloadProvider, ValidatorSet, BEEFY_ENGINE_ID,
 };
 use sp_keystore::KeystorePtr;
 use sp_runtime::traits::{Block, Header as HeaderT, NumberFor, Zero};
@@ -118,50 +117,55 @@ where
 /// Links between the block importer, the background voter and the RPC layer,
 /// to be used by the voter.
 #[derive(Clone)]
-pub struct BeefyVoterLinks<B: Block> {
+pub struct BeefyVoterLinks<B: Block, AuthorityId: AuthorityIdBound> {
 	// BlockImport -> Voter links
 	/// Stream of BEEFY signed commitments from block import to voter.
-	pub from_block_import_justif_stream: BeefyVersionedFinalityProofStream<B>,
+	pub from_block_import_justif_stream: BeefyVersionedFinalityProofStream<B, AuthorityId>,
 
 	// Voter -> RPC links
 	/// Sends BEEFY signed commitments from voter to RPC.
-	pub to_rpc_justif_sender: BeefyVersionedFinalityProofSender<B>,
+	pub to_rpc_justif_sender: BeefyVersionedFinalityProofSender<B, AuthorityId>,
 	/// Sends BEEFY best block hashes from voter to RPC.
 	pub to_rpc_best_block_sender: BeefyBestBlockSender<B>,
 }
 
 /// Links used by the BEEFY RPC layer, from the BEEFY background voter.
 #[derive(Clone)]
-pub struct BeefyRPCLinks<B: Block> {
+pub struct BeefyRPCLinks<B: Block, AuthorityId: AuthorityIdBound> {
 	/// Stream of signed commitments coming from the voter.
-	pub from_voter_justif_stream: BeefyVersionedFinalityProofStream<B>,
+	pub from_voter_justif_stream: BeefyVersionedFinalityProofStream<B, AuthorityId>,
 	/// Stream of BEEFY best block hashes coming from the voter.
 	pub from_voter_best_beefy_stream: BeefyBestBlockStream<B>,
 }
 
 /// Make block importer and link half necessary to tie the background voter to it.
-pub fn beefy_block_import_and_links<B, BE, RuntimeApi, I>(
+pub fn beefy_block_import_and_links<B, BE, RuntimeApi, I, AuthorityId: AuthorityIdBound>(
 	wrapped_block_import: I,
 	backend: Arc<BE>,
 	runtime: Arc<RuntimeApi>,
 	prometheus_registry: Option<Registry>,
-) -> (BeefyBlockImport<B, BE, RuntimeApi, I>, BeefyVoterLinks<B>, BeefyRPCLinks<B>)
+) -> (
+	BeefyBlockImport<B, BE, RuntimeApi, I, AuthorityId>,
+	BeefyVoterLinks<B, AuthorityId>,
+	BeefyRPCLinks<B, AuthorityId>,
+)
 where
 	B: Block,
 	BE: Backend<B>,
 	I: BlockImport<B, Error = ConsensusError> + Send + Sync,
 	RuntimeApi: ProvideRuntimeApi<B> + Send + Sync,
 	RuntimeApi::Api: BeefyApi<B, AuthorityId>,
+	AuthorityId: AuthorityIdBound,
 {
 	// Voter -> RPC links
 	let (to_rpc_justif_sender, from_voter_justif_stream) =
-		BeefyVersionedFinalityProofStream::<B>::channel();
+		BeefyVersionedFinalityProofStream::<B, AuthorityId>::channel();
 	let (to_rpc_best_block_sender, from_voter_best_beefy_stream) =
 		BeefyBestBlockStream::<B>::channel();
 
 	// BlockImport -> Voter links
 	let (to_voter_justif_sender, from_block_import_justif_stream) =
-		BeefyVersionedFinalityProofStream::<B>::channel();
+		BeefyVersionedFinalityProofStream::<B, AuthorityId>::channel();
 	let metrics = register_metrics(prometheus_registry);
 
 	// BlockImport
@@ -201,7 +205,7 @@ pub struct BeefyNetworkParams<B: Block, N, S> {
 }
 
 /// BEEFY gadget initialization parameters.
-pub struct BeefyParams<B: Block, BE, C, N, P, R, S> {
+pub struct BeefyParams<B: Block, BE, C, N, P, R, S, AuthorityId: AuthorityIdBound> {
 	/// BEEFY client
 	pub client: Arc<C>,
 	/// Client Backend
@@ -219,7 +223,7 @@ pub struct BeefyParams<B: Block, BE, C, N, P, R, S> {
 	/// Prometheus metric registry
 	pub prometheus_registry: Option<Registry>,
 	/// Links between the block importer, the background voter and the RPC layer.
-	pub links: BeefyVoterLinks<B>,
+	pub links: BeefyVoterLinks<B, AuthorityId>,
 	/// Handler for incoming BEEFY justifications requests from a remote peer.
 	pub on_demand_justifications_handler: BeefyJustifsRequestHandler<B, C>,
 	/// Whether running under "Authority" role.
@@ -228,10 +232,10 @@ pub struct BeefyParams<B: Block, BE, C, N, P, R, S> {
 /// Helper object holding BEEFY worker communication/gossip components.
 ///
 /// These are created once, but will be reused if worker is restarted/reinitialized.
-pub(crate) struct BeefyComms<B: Block, N> {
+pub(crate) struct BeefyComms<B: Block, N, AuthorityId: AuthorityIdBound> {
 	pub gossip_engine: GossipEngine<B>,
-	pub gossip_validator: Arc<GossipValidator<B, N>>,
-	pub on_demand_justifications: OnDemandJustificationsEngine<B>,
+	pub gossip_validator: Arc<GossipValidator<B, N, AuthorityId>>,
+	pub on_demand_justifications: OnDemandJustificationsEngine<B, AuthorityId>,
 }
 
 /// Helper builder object for building [worker::BeefyWorker].
@@ -240,22 +244,23 @@ pub(crate) struct BeefyComms<B: Block, N> {
 /// for certain chain and backend conditions, and while sleeping we still need to pump the
 /// GossipEngine. Once initialization is done, the GossipEngine (and other pieces) are added to get
 /// the complete [worker::BeefyWorker] object.
-pub(crate) struct BeefyWorkerBuilder<B: Block, BE, RuntimeApi> {
+pub(crate) struct BeefyWorkerBuilder<B: Block, BE, RuntimeApi, AuthorityId: AuthorityIdBound> {
 	// utilities
 	backend: Arc<BE>,
 	runtime: Arc<RuntimeApi>,
 	key_store: BeefyKeystore<AuthorityId>,
 	// voter metrics
 	metrics: Option<VoterMetrics>,
-	persisted_state: PersistedState<B>,
+	persisted_state: PersistedState<B, AuthorityId>,
 }
 
-impl<B, BE, R> BeefyWorkerBuilder<B, BE, R>
+impl<B, BE, R, AuthorityId> BeefyWorkerBuilder<B, BE, R, AuthorityId>
 where
 	B: Block + codec::Codec,
 	BE: Backend<B>,
 	R: ProvideRuntimeApi<B>,
 	R::Api: BeefyApi<B, AuthorityId>,
+	AuthorityId: AuthorityIdBound,
 {
 	/// This will wait for the chain to enable BEEFY (if not yet enabled) and also wait for the
 	/// backend to sync all headers required by the voter to build a contiguous chain of mandatory
@@ -269,7 +274,7 @@ where
 		key_store: BeefyKeystore<AuthorityId>,
 		metrics: Option<VoterMetrics>,
 		min_block_delta: u32,
-		gossip_validator: Arc<GossipValidator<B, N>>,
+		gossip_validator: Arc<GossipValidator<B, N, AuthorityId>>,
 		finality_notifications: &mut Fuse<FinalityNotifications<B>>,
 		is_authority: bool,
 	) -> Result<Self, Error> {
@@ -301,11 +306,11 @@ where
 		self,
 		payload_provider: P,
 		sync: Arc<S>,
-		comms: BeefyComms<B, N>,
-		links: BeefyVoterLinks<B>,
-		pending_justifications: BTreeMap<NumberFor<B>, BeefyVersionedFinalityProof<B>>,
+		comms: BeefyComms<B, N, AuthorityId>,
+		links: BeefyVoterLinks<B, AuthorityId>,
+		pending_justifications: BTreeMap<NumberFor<B>, BeefyVersionedFinalityProof<B, AuthorityId>>,
 		is_authority: bool,
-	) -> BeefyWorker<B, BE, P, R, S, N> {
+	) -> BeefyWorker<B, BE, P, R, S, N, AuthorityId> {
 		let key_store = Arc::new(self.key_store);
 		BeefyWorker {
 			backend: self.backend.clone(),
@@ -334,7 +339,7 @@ where
 		min_block_delta: u32,
 		backend: Arc<BE>,
 		runtime: Arc<R>,
-	) -> Result<PersistedState<B>, Error> {
+	) -> Result<PersistedState<B, AuthorityId>, Error> {
 		let blockchain = backend.blockchain();
 
 		let beefy_genesis = runtime
@@ -378,7 +383,7 @@ where
 					beefy_genesis,
 				)
 				.ok_or_else(|| Error::Backend("Invalid BEEFY chain".into()))?;
-				break state
+				break state;
 			}
 
 			if *header.number() == beefy_genesis {
@@ -401,10 +406,10 @@ where
 					min_block_delta,
 					beefy_genesis,
 				)
-				.ok_or_else(|| Error::Backend("Invalid BEEFY chain".into()))?
+				.ok_or_else(|| Error::Backend("Invalid BEEFY chain".into()))?;
 			}
 
-			if let Some(active) = find_authorities_change::<B>(&header) {
+			if let Some(active) = find_authorities_change::<B, AuthorityId>(&header) {
 				debug!(
 					target: LOG_TARGET,
 					"🥩 Marking block {:?} as BEEFY Mandatory.",
@@ -431,7 +436,7 @@ where
 		key_store: &BeefyKeystore<AuthorityId>,
 		metrics: &Option<VoterMetrics>,
 		is_authority: bool,
-	) -> Result<PersistedState<B>, Error> {
+	) -> Result<PersistedState<B, AuthorityId>, Error> {
 		// Initialize voter state from AUX DB if compatible.
 		if let Some(mut state) = crate::aux_schema::load_persistent(backend.as_ref())?
 			// Verify state pallet genesis matches runtime.
@@ -448,7 +453,7 @@ where
 			let mut header = best_grandpa.clone();
 			while *header.number() > state.best_beefy() {
 				if state.voting_oracle().can_add_session(*header.number()) {
-					if let Some(active) = find_authorities_change::<B>(&header) {
+					if let Some(active) = find_authorities_change::<B, AuthorityId>(&header) {
 						new_sessions.push((active, *header.number()));
 					}
 				}
@@ -471,7 +476,7 @@ where
 					is_authority,
 				);
 			}
-			return Ok(state)
+			return Ok(state);
 		}
 
 		// No valid voter-state persisted, re-initialize from pallet genesis.
@@ -482,8 +487,8 @@ where
 /// Start the BEEFY gadget.
 ///
 /// This is a thin shim around running and awaiting a BEEFY worker.
-pub async fn start_beefy_gadget<B, BE, C, N, P, R, S>(
-	beefy_params: BeefyParams<B, BE, C, N, P, R, S>,
+pub async fn start_beefy_gadget<B, BE, C, N, P, R, S, AuthorityId>(
+	beefy_params: BeefyParams<B, BE, C, N, P, R, S, AuthorityId>,
 ) where
 	B: Block,
 	BE: Backend<B>,
@@ -493,6 +498,7 @@ pub async fn start_beefy_gadget<B, BE, C, N, P, R, S>(
 	R::Api: BeefyApi<B, AuthorityId>,
 	N: GossipNetwork<B> + NetworkRequest + Send + Sync + 'static,
 	S: GossipSyncing<B> + SyncOracle + 'static,
+	AuthorityId: AuthorityIdBound,
 {
 	let BeefyParams {
 		client,
@@ -598,15 +604,17 @@ pub async fn start_beefy_gadget<B, BE, C, N, P, R, S>(
 			futures::future::Either::Left(((error::Error::ConsensusReset, reuse_comms), _)) => {
 				error!(target: LOG_TARGET, "🥩 Error: {:?}. Restarting voter.", error::Error::ConsensusReset);
 				beefy_comms = reuse_comms;
-				continue
+				continue;
 			},
 			// On other errors, bring down / finish the task.
-			futures::future::Either::Left(((worker_err, _), _)) =>
-				error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", worker_err),
-			futures::future::Either::Right((odj_handler_err, _)) =>
-				error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", odj_handler_err),
+			futures::future::Either::Left(((worker_err, _), _)) => {
+				error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", worker_err)
+			},
+			futures::future::Either::Right((odj_handler_err, _)) => {
+				error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", odj_handler_err)
+			},
 		};
-		return
+		return;
 	}
 }
 
@@ -651,7 +659,7 @@ where
 
 /// Wait for BEEFY runtime pallet to be available, return active validator set.
 /// Should be called only once during worker initialization.
-async fn wait_for_runtime_pallet<B, R>(
+async fn wait_for_runtime_pallet<B, R, AuthorityId: AuthorityIdBound>(
 	runtime: &R,
 	finality: &mut Fuse<FinalityNotifications<B>>,
 ) -> Result<(NumberFor<B>, <B as Block>::Header), Error>
@@ -676,7 +684,7 @@ where
 					"🥩 BEEFY pallet available: block {:?} beefy genesis {:?}",
 					notif.header.number(), start
 				);
-				return Ok((start, notif.header))
+				return Ok((start, notif.header));
 			}
 		}
 	}
@@ -687,7 +695,7 @@ where
 ///
 /// Note: function will `async::sleep()` when walking back the chain if some needed header hasn't
 /// been synced yet (as it happens when warp syncing when headers are synced in the background).
-async fn expect_validator_set<B, BE, R>(
+async fn expect_validator_set<B, BE, R, AuthorityId: AuthorityIdBound>(
 	runtime: &R,
 	backend: &BE,
 	at_header: &B::Header,
@@ -711,9 +719,9 @@ where
 	loop {
 		debug!(target: LOG_TARGET, "🥩 Looking for auth set change at block number: {:?}", *header.number());
 		if let Ok(Some(active)) = runtime.runtime_api().validator_set(header.hash()) {
-			return Ok(active)
+			return Ok(active);
 		} else {
-			match find_authorities_change::<B>(&header) {
+			match find_authorities_change::<B, AuthorityId>(&header) {
 				Some(active) => return Ok(active),
 				// Move up the chain. Ultimately we'll get it from chain genesis state, or error out
 				// there.
@@ -728,9 +736,12 @@ where
 
 /// Scan the `header` digest log for a BEEFY validator set change. Return either the new
 /// validator set or `None` in case no validator set change has been signaled.
-pub(crate) fn find_authorities_change<B>(header: &B::Header) -> Option<ValidatorSet<AuthorityId>>
+pub(crate) fn find_authorities_change<B, AuthorityId>(
+	header: &B::Header,
+) -> Option<ValidatorSet<AuthorityId>>
 where
 	B: Block,
+	AuthorityId: AuthorityIdBound,
 {
 	let id = OpaqueDigestItemId::Consensus(&BEEFY_ENGINE_ID);
 
diff --git a/substrate/client/consensus/beefy/src/metrics.rs b/substrate/client/consensus/beefy/src/metrics.rs
index ef3928d79faaaee7f0aacf0af583347e825a30bb..30180fe43ec43b4dcc0ef6fbd4500b4445900c0b 100644
--- a/substrate/client/consensus/beefy/src/metrics.rs
+++ b/substrate/client/consensus/beefy/src/metrics.rs
@@ -20,7 +20,7 @@
 
 use crate::LOG_TARGET;
 use log::{debug, error};
-use prometheus::{register, Counter, Gauge, PrometheusError, Registry, U64};
+use prometheus_endpoint::{register, Counter, Gauge, PrometheusError, Registry, U64};
 
 /// Helper trait for registering BEEFY metrics to Prometheus registry.
 pub(crate) trait PrometheusRegister<T: Sized = Self>: Sized {
@@ -282,7 +282,7 @@ impl PrometheusRegister for OnDemandOutgoingRequestsMetrics {
 }
 
 pub(crate) fn register_metrics<T: PrometheusRegister>(
-	prometheus_registry: Option<prometheus::Registry>,
+	prometheus_registry: Option<prometheus_endpoint::Registry>,
 ) -> Option<T> {
 	prometheus_registry.as_ref().map(T::register).and_then(|result| match result {
 		Ok(metrics) => {
diff --git a/substrate/client/consensus/beefy/src/round.rs b/substrate/client/consensus/beefy/src/round.rs
index 5dae80cb1830ddc2d6402625865af6e965046897..31cfe4c10c2e7d3e7112c353aff1c0572a7bd52b 100644
--- a/substrate/client/consensus/beefy/src/round.rs
+++ b/substrate/client/consensus/beefy/src/round.rs
@@ -20,9 +20,10 @@ use crate::LOG_TARGET;
 
 use codec::{Decode, Encode};
 use log::{debug, info};
+use sp_application_crypto::RuntimeAppPublic;
 use sp_consensus_beefy::{
-	ecdsa_crypto::{AuthorityId, Signature},
-	Commitment, DoubleVotingProof, SignedCommitment, ValidatorSet, ValidatorSetId, VoteMessage,
+	AuthorityIdBound, Commitment, DoubleVotingProof, SignedCommitment, ValidatorSet,
+	ValidatorSetId, VoteMessage,
 };
 use sp_runtime::traits::{Block, NumberFor};
 use std::collections::BTreeMap;
@@ -31,15 +32,24 @@ use std::collections::BTreeMap;
 /// whether the local `self` validator has voted/signed.
 ///
 /// Does not do any validation on votes or signatures, layers above need to handle that (gossip).
-#[derive(Debug, Decode, Default, Encode, PartialEq)]
-pub(crate) struct RoundTracker {
-	votes: BTreeMap<AuthorityId, Signature>,
+#[derive(Debug, Decode, Encode, PartialEq)]
+pub(crate) struct RoundTracker<AuthorityId: AuthorityIdBound> {
+	votes: BTreeMap<AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
+}
+
+impl<AuthorityId: AuthorityIdBound> Default for RoundTracker<AuthorityId> {
+	fn default() -> Self {
+		Self { votes: Default::default() }
+	}
 }
 
-impl RoundTracker {
-	fn add_vote(&mut self, vote: (AuthorityId, Signature)) -> bool {
+impl<AuthorityId: AuthorityIdBound> RoundTracker<AuthorityId> {
+	fn add_vote(
+		&mut self,
+		vote: (AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature),
+	) -> bool {
 		if self.votes.contains_key(&vote.0) {
-			return false
+			return false;
 		}
 
 		self.votes.insert(vote.0, vote.1);
@@ -58,10 +68,12 @@ pub fn threshold(authorities: usize) -> usize {
 }
 
 #[derive(Debug, PartialEq)]
-pub enum VoteImportResult<B: Block> {
+pub enum VoteImportResult<B: Block, AuthorityId: AuthorityIdBound> {
 	Ok,
-	RoundConcluded(SignedCommitment<NumberFor<B>, Signature>),
-	DoubleVoting(DoubleVotingProof<NumberFor<B>, AuthorityId, Signature>),
+	RoundConcluded(SignedCommitment<NumberFor<B>, <AuthorityId as RuntimeAppPublic>::Signature>),
+	DoubleVoting(
+		DoubleVotingProof<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
+	),
 	Invalid,
 	Stale,
 }
@@ -71,19 +83,22 @@ pub enum VoteImportResult<B: Block> {
 ///
 /// Does not do any validation on votes or signatures, layers above need to handle that (gossip).
 #[derive(Debug, Decode, Encode, PartialEq)]
-pub(crate) struct Rounds<B: Block> {
-	rounds: BTreeMap<Commitment<NumberFor<B>>, RoundTracker>,
-	previous_votes:
-		BTreeMap<(AuthorityId, NumberFor<B>), VoteMessage<NumberFor<B>, AuthorityId, Signature>>,
+pub(crate) struct Rounds<B: Block, AuthorityId: AuthorityIdBound> {
+	rounds: BTreeMap<Commitment<NumberFor<B>>, RoundTracker<AuthorityId>>,
+	previous_votes: BTreeMap<
+		(AuthorityId, NumberFor<B>),
+		VoteMessage<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
+	>,
 	session_start: NumberFor<B>,
 	validator_set: ValidatorSet<AuthorityId>,
 	mandatory_done: bool,
 	best_done: Option<NumberFor<B>>,
 }
 
-impl<B> Rounds<B>
+impl<B, AuthorityId> Rounds<B, AuthorityId>
 where
 	B: Block,
+	AuthorityId: AuthorityIdBound,
 {
 	pub(crate) fn new(
 		session_start: NumberFor<B>,
@@ -121,14 +136,14 @@ where
 
 	pub(crate) fn add_vote(
 		&mut self,
-		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
-	) -> VoteImportResult<B> {
+		vote: VoteMessage<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
+	) -> VoteImportResult<B, AuthorityId> {
 		let num = vote.commitment.block_number;
 		let vote_key = (vote.id.clone(), num);
 
 		if num < self.session_start || Some(num) <= self.best_done {
 			debug!(target: LOG_TARGET, "🥩 received vote for old stale round {:?}, ignoring", num);
-			return VoteImportResult::Stale
+			return VoteImportResult::Stale;
 		} else if vote.commitment.validator_set_id != self.validator_set_id() {
 			debug!(
 				target: LOG_TARGET,
@@ -136,14 +151,14 @@ where
 				self.validator_set_id(),
 				vote,
 			);
-			return VoteImportResult::Invalid
+			return VoteImportResult::Invalid;
 		} else if !self.validators().iter().any(|id| &vote.id == id) {
 			debug!(
 				target: LOG_TARGET,
 				"🥩 received vote {:?} from validator that is not in the validator set, ignoring",
 				vote
 			);
-			return VoteImportResult::Invalid
+			return VoteImportResult::Invalid;
 		}
 
 		if let Some(previous_vote) = self.previous_votes.get(&vote_key) {
@@ -156,7 +171,7 @@ where
 				return VoteImportResult::DoubleVoting(DoubleVotingProof {
 					first: previous_vote.clone(),
 					second: vote,
-				})
+				});
 			}
 		} else {
 			// this is the first vote sent by `id` for `num`, all good
@@ -169,7 +184,7 @@ where
 			round.is_done(threshold(self.validator_set.len()))
 		{
 			if let Some(round) = self.rounds.remove_entry(&vote.commitment) {
-				return VoteImportResult::RoundConcluded(self.signed_commitment(round))
+				return VoteImportResult::RoundConcluded(self.signed_commitment(round));
 			}
 		}
 		VoteImportResult::Ok
@@ -177,8 +192,8 @@ where
 
 	fn signed_commitment(
 		&mut self,
-		round: (Commitment<NumberFor<B>>, RoundTracker),
-	) -> SignedCommitment<NumberFor<B>, Signature> {
+		round: (Commitment<NumberFor<B>>, RoundTracker<AuthorityId>),
+	) -> SignedCommitment<NumberFor<B>, <AuthorityId as RuntimeAppPublic>::Signature> {
 		let votes = round.1.votes;
 		let signatures = self
 			.validators()
@@ -207,14 +222,14 @@ mod tests {
 	use sc_network_test::Block;
 
 	use sp_consensus_beefy::{
-		known_payloads::MMR_ROOT_ID, test_utils::Keyring, Commitment, DoubleVotingProof, Payload,
-		SignedCommitment, ValidatorSet, VoteMessage,
+		ecdsa_crypto, known_payloads::MMR_ROOT_ID, test_utils::Keyring, Commitment,
+		DoubleVotingProof, Payload, SignedCommitment, ValidatorSet, VoteMessage,
 	};
 
-	use super::{threshold, AuthorityId, Block as BlockT, RoundTracker, Rounds};
+	use super::{threshold, Block as BlockT, RoundTracker, Rounds};
 	use crate::round::VoteImportResult;
 
-	impl<B> Rounds<B>
+	impl<B> Rounds<B, ecdsa_crypto::AuthorityId>
 	where
 		B: BlockT,
 	{
@@ -225,8 +240,11 @@ mod tests {
 
 	#[test]
 	fn round_tracker() {
-		let mut rt = RoundTracker::default();
-		let bob_vote = (Keyring::Bob.public(), Keyring::<AuthorityId>::Bob.sign(b"I am committed"));
+		let mut rt = RoundTracker::<ecdsa_crypto::AuthorityId>::default();
+		let bob_vote = (
+			Keyring::<ecdsa_crypto::AuthorityId>::Bob.public(),
+			Keyring::<ecdsa_crypto::AuthorityId>::Bob.sign(b"I am committed"),
+		);
 		let threshold = 2;
 
 		// adding new vote allowed
@@ -237,8 +255,10 @@ mod tests {
 		// vote is not done
 		assert!(!rt.is_done(threshold));
 
-		let alice_vote =
-			(Keyring::Alice.public(), Keyring::<AuthorityId>::Alice.sign(b"I am committed"));
+		let alice_vote = (
+			Keyring::<ecdsa_crypto::AuthorityId>::Alice.public(),
+			Keyring::<ecdsa_crypto::AuthorityId>::Alice.sign(b"I am committed"),
+		);
 		// adding new vote (self vote this time) allowed
 		assert!(rt.add_vote(alice_vote));
 
@@ -260,22 +280,22 @@ mod tests {
 	fn new_rounds() {
 		sp_tracing::try_init_simple();
 
-		let validators = ValidatorSet::<AuthorityId>::new(
+		let validators = ValidatorSet::<ecdsa_crypto::AuthorityId>::new(
 			vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()],
 			42,
 		)
 		.unwrap();
 
 		let session_start = 1u64.into();
-		let rounds = Rounds::<Block>::new(session_start, validators);
+		let rounds = Rounds::<Block, ecdsa_crypto::AuthorityId>::new(session_start, validators);
 
 		assert_eq!(42, rounds.validator_set_id());
 		assert_eq!(1, rounds.session_start());
 		assert_eq!(
 			&vec![
-				Keyring::<AuthorityId>::Alice.public(),
-				Keyring::<AuthorityId>::Bob.public(),
-				Keyring::<AuthorityId>::Charlie.public()
+				Keyring::<ecdsa_crypto::AuthorityId>::Alice.public(),
+				Keyring::<ecdsa_crypto::AuthorityId>::Bob.public(),
+				Keyring::<ecdsa_crypto::AuthorityId>::Charlie.public()
 			],
 			rounds.validators()
 		);
@@ -285,7 +305,7 @@ mod tests {
 	fn add_and_conclude_votes() {
 		sp_tracing::try_init_simple();
 
-		let validators = ValidatorSet::<AuthorityId>::new(
+		let validators = ValidatorSet::<ecdsa_crypto::AuthorityId>::new(
 			vec![
 				Keyring::Alice.public(),
 				Keyring::Bob.public(),
@@ -298,7 +318,7 @@ mod tests {
 		let validator_set_id = validators.id();
 
 		let session_start = 1u64.into();
-		let mut rounds = Rounds::<Block>::new(session_start, validators);
+		let mut rounds = Rounds::<Block, ecdsa_crypto::AuthorityId>::new(session_start, validators);
 
 		let payload = Payload::from_single_entry(MMR_ROOT_ID, vec![]);
 		let block_number = 1;
@@ -306,7 +326,7 @@ mod tests {
 		let mut vote = VoteMessage {
 			id: Keyring::Alice.public(),
 			commitment: commitment.clone(),
-			signature: Keyring::<AuthorityId>::Alice.sign(b"I am committed"),
+			signature: Keyring::<ecdsa_crypto::AuthorityId>::Alice.sign(b"I am committed"),
 		};
 		// add 1st good vote
 		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok);
@@ -315,26 +335,26 @@ mod tests {
 		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok);
 
 		vote.id = Keyring::Dave.public();
-		vote.signature = Keyring::<AuthorityId>::Dave.sign(b"I am committed");
+		vote.signature = Keyring::<ecdsa_crypto::AuthorityId>::Dave.sign(b"I am committed");
 		// invalid vote (Dave is not a validator)
 		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Invalid);
 
 		vote.id = Keyring::Bob.public();
-		vote.signature = Keyring::<AuthorityId>::Bob.sign(b"I am committed");
+		vote.signature = Keyring::<ecdsa_crypto::AuthorityId>::Bob.sign(b"I am committed");
 		// add 2nd good vote
 		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok);
 
 		vote.id = Keyring::Charlie.public();
-		vote.signature = Keyring::<AuthorityId>::Charlie.sign(b"I am committed");
+		vote.signature = Keyring::<ecdsa_crypto::AuthorityId>::Charlie.sign(b"I am committed");
 		// add 3rd good vote -> round concluded -> signatures present
 		assert_eq!(
 			rounds.add_vote(vote.clone()),
 			VoteImportResult::RoundConcluded(SignedCommitment {
 				commitment,
 				signatures: vec![
-					Some(Keyring::<AuthorityId>::Alice.sign(b"I am committed")),
-					Some(Keyring::<AuthorityId>::Bob.sign(b"I am committed")),
-					Some(Keyring::<AuthorityId>::Charlie.sign(b"I am committed")),
+					Some(Keyring::<ecdsa_crypto::AuthorityId>::Alice.sign(b"I am committed")),
+					Some(Keyring::<ecdsa_crypto::AuthorityId>::Bob.sign(b"I am committed")),
+					Some(Keyring::<ecdsa_crypto::AuthorityId>::Charlie.sign(b"I am committed")),
 					None,
 				]
 			})
@@ -342,7 +362,7 @@ mod tests {
 		rounds.conclude(block_number);
 
 		vote.id = Keyring::Eve.public();
-		vote.signature = Keyring::<AuthorityId>::Eve.sign(b"I am committed");
+		vote.signature = Keyring::<ecdsa_crypto::AuthorityId>::Eve.sign(b"I am committed");
 		// Eve is a validator, but round was concluded, adding vote disallowed
 		assert_eq!(rounds.add_vote(vote), VoteImportResult::Stale);
 	}
@@ -351,7 +371,7 @@ mod tests {
 	fn old_rounds_not_accepted() {
 		sp_tracing::try_init_simple();
 
-		let validators = ValidatorSet::<AuthorityId>::new(
+		let validators = ValidatorSet::<ecdsa_crypto::AuthorityId>::new(
 			vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()],
 			42,
 		)
@@ -360,7 +380,7 @@ mod tests {
 
 		// active rounds starts at block 10
 		let session_start = 10u64.into();
-		let mut rounds = Rounds::<Block>::new(session_start, validators);
+		let mut rounds = Rounds::<Block, ecdsa_crypto::AuthorityId>::new(session_start, validators);
 
 		// vote on round 9
 		let block_number = 9;
@@ -369,7 +389,7 @@ mod tests {
 		let mut vote = VoteMessage {
 			id: Keyring::Alice.public(),
 			commitment,
-			signature: Keyring::<AuthorityId>::Alice.sign(b"I am committed"),
+			signature: Keyring::<ecdsa_crypto::AuthorityId>::Alice.sign(b"I am committed"),
 		};
 		// add vote for previous session, should fail
 		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Stale);
@@ -397,7 +417,7 @@ mod tests {
 	fn multiple_rounds() {
 		sp_tracing::try_init_simple();
 
-		let validators = ValidatorSet::<AuthorityId>::new(
+		let validators = ValidatorSet::<ecdsa_crypto::AuthorityId>::new(
 			vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()],
 			Default::default(),
 		)
@@ -405,29 +425,29 @@ mod tests {
 		let validator_set_id = validators.id();
 
 		let session_start = 1u64.into();
-		let mut rounds = Rounds::<Block>::new(session_start, validators);
+		let mut rounds = Rounds::<Block, ecdsa_crypto::AuthorityId>::new(session_start, validators);
 
 		let payload = Payload::from_single_entry(MMR_ROOT_ID, vec![]);
 		let commitment = Commitment { block_number: 1, payload, validator_set_id };
 		let mut alice_vote = VoteMessage {
 			id: Keyring::Alice.public(),
 			commitment: commitment.clone(),
-			signature: Keyring::<AuthorityId>::Alice.sign(b"I am committed"),
+			signature: Keyring::<ecdsa_crypto::AuthorityId>::Alice.sign(b"I am committed"),
 		};
 		let mut bob_vote = VoteMessage {
 			id: Keyring::Bob.public(),
 			commitment: commitment.clone(),
-			signature: Keyring::<AuthorityId>::Bob.sign(b"I am committed"),
+			signature: Keyring::<ecdsa_crypto::AuthorityId>::Bob.sign(b"I am committed"),
 		};
 		let mut charlie_vote = VoteMessage {
 			id: Keyring::Charlie.public(),
 			commitment,
-			signature: Keyring::<AuthorityId>::Charlie.sign(b"I am committed"),
+			signature: Keyring::<ecdsa_crypto::AuthorityId>::Charlie.sign(b"I am committed"),
 		};
 		let expected_signatures = vec![
-			Some(Keyring::<AuthorityId>::Alice.sign(b"I am committed")),
-			Some(Keyring::<AuthorityId>::Bob.sign(b"I am committed")),
-			Some(Keyring::<AuthorityId>::Charlie.sign(b"I am committed")),
+			Some(Keyring::<ecdsa_crypto::AuthorityId>::Alice.sign(b"I am committed")),
+			Some(Keyring::<ecdsa_crypto::AuthorityId>::Bob.sign(b"I am committed")),
+			Some(Keyring::<ecdsa_crypto::AuthorityId>::Charlie.sign(b"I am committed")),
 		];
 
 		// round 1 - only 2 out of 3 vote
@@ -472,14 +492,14 @@ mod tests {
 	fn should_provide_equivocation_proof() {
 		sp_tracing::try_init_simple();
 
-		let validators = ValidatorSet::<AuthorityId>::new(
+		let validators = ValidatorSet::<ecdsa_crypto::AuthorityId>::new(
 			vec![Keyring::Alice.public(), Keyring::Bob.public()],
 			Default::default(),
 		)
 		.unwrap();
 		let validator_set_id = validators.id();
 		let session_start = 1u64.into();
-		let mut rounds = Rounds::<Block>::new(session_start, validators);
+		let mut rounds = Rounds::<Block, ecdsa_crypto::AuthorityId>::new(session_start, validators);
 
 		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![1, 1, 1, 1]);
 		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![2, 2, 2, 2]);
@@ -489,7 +509,7 @@ mod tests {
 		let alice_vote1 = VoteMessage {
 			id: Keyring::Alice.public(),
 			commitment: commitment1,
-			signature: Keyring::<AuthorityId>::Alice.sign(b"I am committed"),
+			signature: Keyring::<ecdsa_crypto::AuthorityId>::Alice.sign(b"I am committed"),
 		};
 		let mut alice_vote2 = alice_vote1.clone();
 		alice_vote2.commitment = commitment2;
diff --git a/substrate/client/consensus/beefy/src/tests.rs b/substrate/client/consensus/beefy/src/tests.rs
index 2bb145d660df061561efd2196b2193b5ef70b1df..681e11a0c5310f7bfa67aab824e861ef447f3941 100644
--- a/substrate/client/consensus/beefy/src/tests.rs
+++ b/substrate/client/consensus/beefy/src/tests.rs
@@ -55,6 +55,7 @@ use sp_api::{ApiRef, ProvideRuntimeApi};
 use sp_application_crypto::key_types::BEEFY as BEEFY_KEY_TYPE;
 use sp_consensus::BlockOrigin;
 use sp_consensus_beefy::{
+	ecdsa_crypto,
 	ecdsa_crypto::{AuthorityId, Signature},
 	known_payloads,
 	mmr::{find_mmr_root_digest, MmrRootProvider},
@@ -89,6 +90,7 @@ type BeefyBlockImport = crate::BeefyBlockImport<
 	substrate_test_runtime_client::Backend,
 	TestApi,
 	BlockImportAdapter<PeersClient>,
+	AuthorityId,
 >;
 
 pub(crate) type BeefyValidatorSet = ValidatorSet<AuthorityId>;
@@ -107,8 +109,8 @@ impl BuildStorage for Genesis {
 
 #[derive(Default)]
 pub(crate) struct PeerData {
-	pub(crate) beefy_rpc_links: Mutex<Option<BeefyRPCLinks<Block>>>,
-	pub(crate) beefy_voter_links: Mutex<Option<BeefyVoterLinks<Block>>>,
+	pub(crate) beefy_rpc_links: Mutex<Option<BeefyRPCLinks<Block, AuthorityId>>>,
+	pub(crate) beefy_voter_links: Mutex<Option<BeefyVoterLinks<Block, AuthorityId>>>,
 	pub(crate) beefy_justif_req_handler:
 		Mutex<Option<BeefyJustifsRequestHandler<Block, PeersFullClient>>>,
 }
@@ -371,7 +373,7 @@ async fn voter_init_setup(
 	net: &mut BeefyTestNet,
 	finality: &mut futures::stream::Fuse<FinalityNotifications<Block>>,
 	api: &TestApi,
-) -> Result<PersistedState<Block>, Error> {
+) -> Result<PersistedState<Block, ecdsa_crypto::AuthorityId>, Error> {
 	let backend = net.peer(0).client().as_backend();
 	let (beefy_genesis, best_grandpa) = wait_for_runtime_pallet(api, finality).await.unwrap();
 	let key_store = None.into();
@@ -446,7 +448,7 @@ where
 			on_demand_justifications_handler: on_demand_justif_handler,
 			is_authority: true,
 		};
-		let task = crate::start_beefy_gadget::<_, _, _, _, _, _, _>(beefy_params);
+		let task = crate::start_beefy_gadget::<_, _, _, _, _, _, _, _>(beefy_params);
 
 		fn assert_send<T: Send>(_: &T) {}
 		assert_send(&task);
@@ -472,8 +474,10 @@ pub(crate) fn get_beefy_streams(
 	net: &mut BeefyTestNet,
 	// peer index and key
 	peers: impl Iterator<Item = (usize, BeefyKeyring<AuthorityId>)>,
-) -> (Vec<NotificationReceiver<H256>>, Vec<NotificationReceiver<BeefyVersionedFinalityProof<Block>>>)
-{
+) -> (
+	Vec<NotificationReceiver<H256>>,
+	Vec<NotificationReceiver<BeefyVersionedFinalityProof<Block, AuthorityId>>>,
+) {
 	let mut best_block_streams = Vec::new();
 	let mut versioned_finality_proof_streams = Vec::new();
 	peers.for_each(|(index, _)| {
@@ -511,7 +515,7 @@ async fn wait_for_best_beefy_blocks(
 }
 
 async fn wait_for_beefy_signed_commitments(
-	streams: Vec<NotificationReceiver<BeefyVersionedFinalityProof<Block>>>,
+	streams: Vec<NotificationReceiver<BeefyVersionedFinalityProof<Block, AuthorityId>>>,
 	net: &Arc<Mutex<BeefyTestNet>>,
 	expected_commitment_block_nums: &[u64],
 ) {
@@ -1417,7 +1421,7 @@ async fn beefy_reports_equivocations() {
 	for wait_ms in [250, 500, 1250, 3000] {
 		run_for(Duration::from_millis(wait_ms), &net).await;
 		if !api_alice.reported_equivocations.as_ref().unwrap().lock().is_empty() {
-			break
+			break;
 		}
 	}
 
@@ -1457,7 +1461,7 @@ async fn gossipped_finality_proofs() {
 	// Charlie will run just the gossip engine and not the full voter.
 	let gossip_validator = GossipValidator::new(known_peers, Arc::new(TestNetwork::new().0));
 	let charlie_gossip_validator = Arc::new(gossip_validator);
-	charlie_gossip_validator.update_filter(GossipFilterCfg::<Block> {
+	charlie_gossip_validator.update_filter(GossipFilterCfg::<Block, ecdsa_crypto::AuthorityId> {
 		start: 1,
 		end: 10,
 		validator_set: &validator_set,
@@ -1501,7 +1505,7 @@ async fn gossipped_finality_proofs() {
 	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
 	// Charlie gossips finality proof for #1 -> Alice and Bob also finalize.
 	let proof = crate::communication::gossip::tests::dummy_proof(1, &validator_set);
-	let gossip_proof = GossipMessage::<Block>::FinalityProof(proof);
+	let gossip_proof = GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof);
 	let encoded_proof = gossip_proof.encode();
 	charlie_gossip_engine.gossip_message(proofs_topic::<Block>(), encoded_proof, true);
 	// Expect #1 is finalized.
@@ -1526,7 +1530,8 @@ async fn gossipped_finality_proofs() {
 	let commitment = Commitment { payload, block_number, validator_set_id: validator_set.id() };
 	let signature = sign_commitment(&BeefyKeyring::Charlie, &commitment);
 	let vote_message = VoteMessage { commitment, id: BeefyKeyring::Charlie.public(), signature };
-	let encoded_vote = GossipMessage::<Block>::Vote(vote_message).encode();
+	let encoded_vote =
+		GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(vote_message).encode();
 	charlie_gossip_engine.gossip_message(votes_topic::<Block>(), encoded_vote, true);
 
 	// Expect #2 is finalized.
@@ -1538,12 +1543,15 @@ async fn gossipped_finality_proofs() {
 		charlie_gossip_engine
 			.messages_for(proofs_topic::<Block>())
 			.filter_map(|notification| async move {
-				GossipMessage::<Block>::decode(&mut &notification.message[..]).ok().and_then(
-					|message| match message {
-						GossipMessage::<Block>::Vote(_) => unreachable!(),
-						GossipMessage::<Block>::FinalityProof(proof) => Some(proof),
-					},
+				GossipMessage::<Block, ecdsa_crypto::AuthorityId>::decode(
+					&mut &notification.message[..],
 				)
+				.ok()
+				.and_then(|message| match message {
+					GossipMessage::<Block, ecdsa_crypto::AuthorityId>::Vote(_) => unreachable!(),
+					GossipMessage::<Block, ecdsa_crypto::AuthorityId>::FinalityProof(proof) =>
+						Some(proof),
+				})
 			})
 			.fuse(),
 	);
@@ -1561,7 +1569,7 @@ async fn gossipped_finality_proofs() {
 			// verify finality proof has been gossipped
 			proof = charlie_gossip_proofs.next() => {
 				let proof = proof.unwrap();
-				let (round, _) = proof_block_num_and_set_id::<Block>(&proof);
+				let (round, _) = proof_block_num_and_set_id::<Block, ecdsa_crypto::AuthorityId>(&proof);
 				match round {
 					1 => continue, // finality proof generated by Charlie in the previous round
 					2 => break,	// finality proof generated by Alice or Bob and gossiped to Charlie
diff --git a/substrate/client/consensus/beefy/src/worker.rs b/substrate/client/consensus/beefy/src/worker.rs
index cfbb3d63aea446d5b6a9a20a0eb9b2cf8c391e79..3ce4da7ecd56adea78b92a905546c4fa619403d7 100644
--- a/substrate/client/consensus/beefy/src/worker.rs
+++ b/substrate/client/consensus/beefy/src/worker.rs
@@ -31,6 +31,8 @@ use crate::{
 	round::{Rounds, VoteImportResult},
 	BeefyComms, BeefyVoterLinks, LOG_TARGET,
 };
+use sp_application_crypto::RuntimeAppPublic;
+
 use codec::{Codec, Decode, DecodeAll, Encode};
 use futures::{stream::Fuse, FutureExt, StreamExt};
 use log::{debug, error, info, trace, warn};
@@ -40,9 +42,8 @@ use sp_api::ProvideRuntimeApi;
 use sp_arithmetic::traits::{AtLeast32Bit, Saturating};
 use sp_consensus::SyncOracle;
 use sp_consensus_beefy::{
-	ecdsa_crypto::{AuthorityId, Signature},
-	BeefyApi, Commitment, DoubleVotingProof, PayloadProvider, ValidatorSet, VersionedFinalityProof,
-	VoteMessage, BEEFY_ENGINE_ID,
+	AuthorityIdBound, BeefyApi, Commitment, DoubleVotingProof, PayloadProvider, ValidatorSet,
+	VersionedFinalityProof, VoteMessage, BEEFY_ENGINE_ID,
 };
 use sp_runtime::{
 	generic::BlockId,
@@ -52,6 +53,7 @@ use sp_runtime::{
 use std::{
 	collections::{BTreeMap, VecDeque},
 	fmt::Debug,
+	marker::PhantomData,
 	sync::Arc,
 };
 
@@ -72,7 +74,7 @@ pub(crate) enum RoundAction {
 /// Note: this is part of `PersistedState` so any changes here should also bump
 /// aux-db schema version.
 #[derive(Debug, Decode, Encode, PartialEq)]
-pub(crate) struct VoterOracle<B: Block> {
+pub(crate) struct VoterOracle<B: Block, AuthorityId: AuthorityIdBound> {
 	/// Queue of known sessions. Keeps track of voting rounds (block numbers) within each session.
 	///
 	/// There are three voter states corresponding to three queue states:
@@ -82,19 +84,23 @@ pub(crate) struct VoterOracle<B: Block> {
 	/// 3. lagging behind GRANDPA: queue has [1, N] elements, where all `mandatory_done == false`.
 	///    In this state, every time a session gets its mandatory block BEEFY finalized, it's
 	///    popped off the queue, eventually getting to state `2. up-to-date`.
-	sessions: VecDeque<Rounds<B>>,
+	sessions: VecDeque<Rounds<B, AuthorityId>>,
 	/// Min delta in block numbers between two blocks, BEEFY should vote on.
 	min_block_delta: u32,
 	/// Best block we received a GRANDPA finality for.
 	best_grandpa_block_header: <B as Block>::Header,
 	/// Best block a BEEFY voting round has been concluded for.
 	best_beefy_block: NumberFor<B>,
+	_phantom: PhantomData<fn() -> AuthorityId>,
 }
 
-impl<B: Block> VoterOracle<B> {
+impl<B: Block, AuthorityId> VoterOracle<B, AuthorityId>
+where
+	AuthorityId: AuthorityIdBound,
+{
 	/// Verify provided `sessions` satisfies requirements, then build `VoterOracle`.
 	pub fn checked_new(
-		sessions: VecDeque<Rounds<B>>,
+		sessions: VecDeque<Rounds<B, AuthorityId>>,
 		min_block_delta: u32,
 		grandpa_header: <B as Block>::Header,
 		best_beefy: NumberFor<B>,
@@ -105,24 +111,24 @@ impl<B: Block> VoterOracle<B> {
 		let mut validate = || -> bool {
 			let best_grandpa = *grandpa_header.number();
 			if sessions.is_empty() || best_beefy > best_grandpa {
-				return false
+				return false;
 			}
 			for (idx, session) in sessions.iter().enumerate() {
 				let start = session.session_start();
 				if session.validators().is_empty() {
-					return false
+					return false;
 				}
 				if start > best_grandpa || start <= prev_start {
-					return false
+					return false;
 				}
 				#[cfg(not(test))]
 				if let Some(prev_id) = prev_validator_id {
 					if session.validator_set_id() <= prev_id {
-						return false
+						return false;
 					}
 				}
 				if idx != 0 && session.mandatory_done() {
-					return false
+					return false;
 				}
 				prev_start = session.session_start();
 				prev_validator_id = Some(session.validator_set_id());
@@ -136,6 +142,7 @@ impl<B: Block> VoterOracle<B> {
 				min_block_delta: min_block_delta.max(1),
 				best_grandpa_block_header: grandpa_header,
 				best_beefy_block: best_beefy,
+				_phantom: PhantomData,
 			})
 		} else {
 			error!(
@@ -151,13 +158,13 @@ impl<B: Block> VoterOracle<B> {
 
 	// Return reference to rounds pertaining to first session in the queue.
 	// Voting will always happen at the head of the queue.
-	fn active_rounds(&self) -> Result<&Rounds<B>, Error> {
+	fn active_rounds(&self) -> Result<&Rounds<B, AuthorityId>, Error> {
 		self.sessions.front().ok_or(Error::UninitSession)
 	}
 
 	// Return mutable reference to rounds pertaining to first session in the queue.
 	// Voting will always happen at the head of the queue.
-	fn active_rounds_mut(&mut self) -> Result<&mut Rounds<B>, Error> {
+	fn active_rounds_mut(&mut self) -> Result<&mut Rounds<B, AuthorityId>, Error> {
 		self.sessions.front_mut().ok_or(Error::UninitSession)
 	}
 
@@ -183,7 +190,7 @@ impl<B: Block> VoterOracle<B> {
 	}
 
 	/// Add new observed session to the Oracle.
-	pub fn add_session(&mut self, rounds: Rounds<B>) {
+	pub fn add_session(&mut self, rounds: Rounds<B, AuthorityId>) {
 		self.sessions.push_back(rounds);
 		// Once we add a new session we can drop/prune previous session if it's been finalized.
 		self.try_prune();
@@ -267,21 +274,21 @@ impl<B: Block> VoterOracle<B> {
 ///
 /// Note: Any changes here should also bump aux-db schema version.
 #[derive(Debug, Decode, Encode, PartialEq)]
-pub(crate) struct PersistedState<B: Block> {
+pub(crate) struct PersistedState<B: Block, AuthorityId: AuthorityIdBound> {
 	/// Best block we voted on.
 	best_voted: NumberFor<B>,
 	/// Chooses which incoming votes to accept and which votes to generate.
 	/// Keeps track of voting seen for current and future rounds.
-	voting_oracle: VoterOracle<B>,
+	voting_oracle: VoterOracle<B, AuthorityId>,
 	/// Pallet-beefy genesis block - block number when BEEFY consensus started for this chain.
 	pallet_genesis: NumberFor<B>,
 }
 
-impl<B: Block> PersistedState<B> {
+impl<B: Block, AuthorityId: AuthorityIdBound> PersistedState<B, AuthorityId> {
 	pub fn checked_new(
 		grandpa_header: <B as Block>::Header,
 		best_beefy: NumberFor<B>,
-		sessions: VecDeque<Rounds<B>>,
+		sessions: VecDeque<Rounds<B, AuthorityId>>,
 		min_block_delta: u32,
 		pallet_genesis: NumberFor<B>,
 	) -> Option<Self> {
@@ -314,11 +321,11 @@ impl<B: Block> PersistedState<B> {
 		self.voting_oracle.best_grandpa_block_header = best_grandpa;
 	}
 
-	pub fn voting_oracle(&self) -> &VoterOracle<B> {
+	pub fn voting_oracle(&self) -> &VoterOracle<B, AuthorityId> {
 		&self.voting_oracle
 	}
 
-	pub(crate) fn gossip_filter_config(&self) -> Result<GossipFilterCfg<B>, Error> {
+	pub(crate) fn gossip_filter_config(&self) -> Result<GossipFilterCfg<B, AuthorityId>, Error> {
 		let (start, end) = self.voting_oracle.accepted_interval()?;
 		let validator_set = self.voting_oracle.current_validator_set()?;
 		Ok(GossipFilterCfg { start, end, validator_set })
@@ -373,34 +380,34 @@ impl<B: Block> PersistedState<B> {
 }
 
 /// A BEEFY worker/voter that follows the BEEFY protocol
-pub(crate) struct BeefyWorker<B: Block, BE, P, RuntimeApi, S, N> {
+pub(crate) struct BeefyWorker<B: Block, BE, P, RuntimeApi, S, N, AuthorityId: AuthorityIdBound> {
 	// utilities
 	pub backend: Arc<BE>,
 	pub runtime: Arc<RuntimeApi>,
 	pub key_store: Arc<BeefyKeystore<AuthorityId>>,
 	pub payload_provider: P,
 	pub sync: Arc<S>,
-	pub fisherman: Arc<Fisherman<B, BE, RuntimeApi>>,
+	pub fisherman: Arc<Fisherman<B, BE, RuntimeApi, AuthorityId>>,
 
 	// communication (created once, but returned and reused if worker is restarted/reinitialized)
-	pub comms: BeefyComms<B, N>,
+	pub comms: BeefyComms<B, N, AuthorityId>,
 
 	// channels
 	/// Links between the block importer, the background voter and the RPC layer.
-	pub links: BeefyVoterLinks<B>,
+	pub links: BeefyVoterLinks<B, AuthorityId>,
 
 	// voter state
 	/// Buffer holding justifications for future processing.
-	pub pending_justifications: BTreeMap<NumberFor<B>, BeefyVersionedFinalityProof<B>>,
+	pub pending_justifications: BTreeMap<NumberFor<B>, BeefyVersionedFinalityProof<B, AuthorityId>>,
 	/// Persisted voter state.
-	pub persisted_state: PersistedState<B>,
+	pub persisted_state: PersistedState<B, AuthorityId>,
 	/// BEEFY voter metrics
 	pub metrics: Option<VoterMetrics>,
 	/// Node runs under "Authority" role.
 	pub is_authority: bool,
 }
 
-impl<B, BE, P, R, S, N> BeefyWorker<B, BE, P, R, S, N>
+impl<B, BE, P, R, S, N, AuthorityId> BeefyWorker<B, BE, P, R, S, N, AuthorityId>
 where
 	B: Block + Codec,
 	BE: Backend<B>,
@@ -408,17 +415,18 @@ where
 	S: SyncOracle,
 	R: ProvideRuntimeApi<B>,
 	R::Api: BeefyApi<B, AuthorityId>,
+	AuthorityId: AuthorityIdBound,
 {
 	fn best_grandpa_block(&self) -> NumberFor<B> {
 		*self.persisted_state.voting_oracle.best_grandpa_block_header.number()
 	}
 
-	fn voting_oracle(&self) -> &VoterOracle<B> {
+	fn voting_oracle(&self) -> &VoterOracle<B, AuthorityId> {
 		&self.persisted_state.voting_oracle
 	}
 
 	#[cfg(test)]
-	fn active_rounds(&mut self) -> Result<&Rounds<B>, Error> {
+	fn active_rounds(&mut self) -> Result<&Rounds<B, AuthorityId>, Error> {
 		self.persisted_state.voting_oracle.active_rounds()
 	}
 
@@ -476,7 +484,8 @@ where
 				})
 				.chain(std::iter::once(header.clone()))
 			{
-				if let Some(new_validator_set) = find_authorities_change::<B>(&header) {
+				if let Some(new_validator_set) = find_authorities_change::<B, AuthorityId>(&header)
+				{
 					self.init_session_at(new_validator_set, *header.number());
 					new_session_added = true;
 				}
@@ -503,13 +512,17 @@ where
 	/// Based on [VoterOracle] this vote is either processed here or discarded.
 	fn triage_incoming_vote(
 		&mut self,
-		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
-	) -> Result<(), Error> {
+		vote: VoteMessage<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
+	) -> Result<(), Error>
+	where
+		<AuthorityId as RuntimeAppPublic>::Signature: Encode + Decode,
+	{
 		let block_num = vote.commitment.block_number;
 		match self.voting_oracle().triage_round(block_num)? {
 			RoundAction::Process =>
 				if let Some(finality_proof) = self.handle_vote(vote)? {
-					let gossip_proof = GossipMessage::<B>::FinalityProof(finality_proof);
+					let gossip_proof =
+						GossipMessage::<B, AuthorityId>::FinalityProof(finality_proof);
 					let encoded_proof = gossip_proof.encode();
 					self.comms.gossip_engine.gossip_message(
 						proofs_topic::<B>(),
@@ -528,7 +541,7 @@ where
 	/// Expects `justification` to be valid.
 	fn triage_incoming_justif(
 		&mut self,
-		justification: BeefyVersionedFinalityProof<B>,
+		justification: BeefyVersionedFinalityProof<B, AuthorityId>,
 	) -> Result<(), Error> {
 		let signed_commitment = match justification {
 			VersionedFinalityProof::V1(ref sc) => sc,
@@ -560,8 +573,8 @@ where
 
 	fn handle_vote(
 		&mut self,
-		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
-	) -> Result<Option<BeefyVersionedFinalityProof<B>>, Error> {
+		vote: VoteMessage<NumberFor<B>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
+	) -> Result<Option<BeefyVersionedFinalityProof<B, AuthorityId>>, Error> {
 		let rounds = self.persisted_state.voting_oracle.active_rounds_mut()?;
 
 		let block_number = vote.commitment.block_number;
@@ -576,7 +589,7 @@ where
 				// New state is persisted after finalization.
 				self.finalize(finality_proof.clone())?;
 				metric_inc!(self.metrics, beefy_good_votes_processed);
-				return Ok(Some(finality_proof))
+				return Ok(Some(finality_proof));
 			},
 			VoteImportResult::Ok => {
 				// Persist state after handling mandatory block vote.
@@ -608,14 +621,17 @@ where
 	/// 4. Send best block hash and `finality_proof` to RPC worker.
 	///
 	/// Expects `finality proof` to be valid and for a block > current-best-beefy.
-	fn finalize(&mut self, finality_proof: BeefyVersionedFinalityProof<B>) -> Result<(), Error> {
+	fn finalize(
+		&mut self,
+		finality_proof: BeefyVersionedFinalityProof<B, AuthorityId>,
+	) -> Result<(), Error> {
 		let block_num = match finality_proof {
 			VersionedFinalityProof::V1(ref sc) => sc.commitment.block_number,
 		};
 
 		if block_num <= self.persisted_state.voting_oracle.best_beefy_block {
 			// we've already finalized this round before, short-circuit.
-			return Ok(())
+			return Ok(());
 		}
 
 		// Finalize inner round and update voting_oracle state.
@@ -740,7 +756,7 @@ where
 			hash
 		} else {
 			warn!(target: LOG_TARGET, "🥩 No MMR root digest found for: {:?}", target_hash);
-			return Ok(())
+			return Ok(());
 		};
 
 		let rounds = self.persisted_state.voting_oracle.active_rounds_mut()?;
@@ -754,7 +770,7 @@ where
 				target: LOG_TARGET,
 				"🥩 Missing validator id - can't vote for: {:?}", target_hash
 			);
-			return Ok(())
+			return Ok(());
 		};
 
 		let commitment = Commitment { payload, block_number: target_number, validator_set_id };
@@ -764,7 +780,7 @@ where
 			Ok(sig) => sig,
 			Err(err) => {
 				warn!(target: LOG_TARGET, "🥩 Error signing commitment: {:?}", err);
-				return Ok(())
+				return Ok(());
 			},
 		};
 
@@ -780,14 +796,15 @@ where
 			error!(target: LOG_TARGET, "🥩 Error handling self vote: {}", err);
 			err
 		})? {
-			let encoded_proof = GossipMessage::<B>::FinalityProof(finality_proof).encode();
+			let encoded_proof =
+				GossipMessage::<B, AuthorityId>::FinalityProof(finality_proof).encode();
 			self.comms
 				.gossip_engine
 				.gossip_message(proofs_topic::<B>(), encoded_proof, true);
 		} else {
 			metric_inc!(self.metrics, beefy_votes_sent);
 			debug!(target: LOG_TARGET, "🥩 Sent vote message: {:?}", vote);
-			let encoded_vote = GossipMessage::<B>::Vote(vote).encode();
+			let encoded_vote = GossipMessage::<B, AuthorityId>::Vote(vote).encode();
 			self.comms.gossip_engine.gossip_message(votes_topic::<B>(), encoded_vote, false);
 		}
 
@@ -825,9 +842,11 @@ where
 	/// Should never end, returns `Error` otherwise.
 	pub(crate) async fn run(
 		mut self,
-		block_import_justif: &mut Fuse<NotificationReceiver<BeefyVersionedFinalityProof<B>>>,
+		block_import_justif: &mut Fuse<
+			NotificationReceiver<BeefyVersionedFinalityProof<B, AuthorityId>>,
+		>,
 		finality_notifications: &mut Fuse<FinalityNotifications<B>>,
-	) -> (Error, BeefyComms<B, N>) {
+	) -> (Error, BeefyComms<B, N, AuthorityId>) {
 		info!(
 			target: LOG_TARGET,
 			"🥩 run BEEFY worker, best grandpa: #{:?}.",
@@ -839,9 +858,10 @@ where
 				.gossip_engine
 				.messages_for(votes_topic::<B>())
 				.filter_map(|notification| async move {
-					let vote = GossipMessage::<B>::decode_all(&mut &notification.message[..])
-						.ok()
-						.and_then(|message| message.unwrap_vote());
+					let vote =
+						GossipMessage::<B, AuthorityId>::decode_all(&mut &notification.message[..])
+							.ok()
+							.and_then(|message| message.unwrap_vote());
 					trace!(target: LOG_TARGET, "🥩 Got vote message: {:?}", vote);
 					vote
 				})
@@ -852,9 +872,10 @@ where
 				.gossip_engine
 				.messages_for(proofs_topic::<B>())
 				.filter_map(|notification| async move {
-					let proof = GossipMessage::<B>::decode_all(&mut &notification.message[..])
-						.ok()
-						.and_then(|message| message.unwrap_finality_proof());
+					let proof =
+						GossipMessage::<B, AuthorityId>::decode_all(&mut &notification.message[..])
+							.ok()
+							.and_then(|message| message.unwrap_finality_proof());
 					trace!(target: LOG_TARGET, "🥩 Got gossip proof message: {:?}", proof);
 					proof
 				})
@@ -945,7 +966,11 @@ where
 	/// Report the given equivocation to the BEEFY runtime module.
 	fn report_double_voting(
 		&self,
-		proof: DoubleVotingProof<NumberFor<B>, AuthorityId, Signature>,
+		proof: DoubleVotingProof<
+			NumberFor<B>,
+			AuthorityId,
+			<AuthorityId as RuntimeAppPublic>::Signature,
+		>,
 	) -> Result<(), Error> {
 		let rounds = self.persisted_state.voting_oracle.active_rounds()?;
 		self.fisherman.report_double_voting(proof, rounds)
@@ -1011,7 +1036,7 @@ pub(crate) mod tests {
 	use sc_network_test::TestNetFactory;
 	use sp_blockchain::Backend as BlockchainBackendT;
 	use sp_consensus_beefy::{
-		known_payloads,
+		ecdsa_crypto, known_payloads,
 		known_payloads::MMR_ROOT_ID,
 		mmr::MmrRootProvider,
 		test_utils::{generate_equivocation_proof, Keyring},
@@ -1023,8 +1048,8 @@ pub(crate) mod tests {
 		Backend,
 	};
 
-	impl<B: super::Block> PersistedState<B> {
-		pub fn active_round(&self) -> Result<&Rounds<B>, Error> {
+	impl<B: super::Block, AuthorityId: AuthorityIdBound> PersistedState<B, AuthorityId> {
+		pub fn active_round(&self) -> Result<&Rounds<B, AuthorityId>, Error> {
 			self.voting_oracle.active_rounds()
 		}
 
@@ -1033,17 +1058,17 @@ pub(crate) mod tests {
 		}
 	}
 
-	impl<B: super::Block> VoterOracle<B> {
-		pub fn sessions(&self) -> &VecDeque<Rounds<B>> {
+	impl<B: super::Block> VoterOracle<B, ecdsa_crypto::AuthorityId> {
+		pub fn sessions(&self) -> &VecDeque<Rounds<B, ecdsa_crypto::AuthorityId>> {
 			&self.sessions
 		}
 	}
 
 	fn create_beefy_worker(
 		peer: &mut BeefyPeer,
-		key: &Keyring<AuthorityId>,
+		key: &Keyring<ecdsa_crypto::AuthorityId>,
 		min_block_delta: u32,
-		genesis_validator_set: ValidatorSet<AuthorityId>,
+		genesis_validator_set: ValidatorSet<ecdsa_crypto::AuthorityId>,
 	) -> BeefyWorker<
 		Block,
 		Backend,
@@ -1051,15 +1076,16 @@ pub(crate) mod tests {
 		TestApi,
 		Arc<SyncingService<Block>>,
 		TestNetwork,
+		ecdsa_crypto::AuthorityId,
 	> {
 		let keystore = create_beefy_keystore(key);
 
 		let (to_rpc_justif_sender, from_voter_justif_stream) =
-			BeefyVersionedFinalityProofStream::<Block>::channel();
+			BeefyVersionedFinalityProofStream::<Block, ecdsa_crypto::AuthorityId>::channel();
 		let (to_rpc_best_block_sender, from_voter_best_beefy_stream) =
 			BeefyBestBlockStream::<Block>::channel();
 		let (_, from_block_import_justif_stream) =
-			BeefyVersionedFinalityProofStream::<Block>::channel();
+			BeefyVersionedFinalityProofStream::<Block, ecdsa_crypto::AuthorityId>::channel();
 
 		let beefy_rpc_links =
 			BeefyRPCLinks { from_voter_justif_stream, from_voter_best_beefy_stream };
@@ -1115,7 +1141,8 @@ pub(crate) mod tests {
 		.unwrap();
 		let payload_provider = MmrRootProvider::new(api.clone());
 		let comms = BeefyComms { gossip_engine, gossip_validator, on_demand_justifications };
-		let key_store: Arc<BeefyKeystore<AuthorityId>> = Arc::new(Some(keystore).into());
+		let key_store: Arc<BeefyKeystore<ecdsa_crypto::AuthorityId>> =
+			Arc::new(Some(keystore).into());
 		BeefyWorker {
 			backend: backend.clone(),
 			runtime: api.clone(),
@@ -1233,13 +1260,14 @@ pub(crate) mod tests {
 			Default::default(),
 			Digest::default(),
 		);
-		let mut oracle = VoterOracle::<Block> {
+		let mut oracle = VoterOracle::<Block, ecdsa_crypto::AuthorityId> {
 			best_beefy_block: 0,
 			best_grandpa_block_header: header,
 			min_block_delta: 1,
 			sessions: VecDeque::new(),
+			_phantom: PhantomData,
 		};
-		let voting_target_with = |oracle: &mut VoterOracle<Block>,
+		let voting_target_with = |oracle: &mut VoterOracle<Block, ecdsa_crypto::AuthorityId>,
 		                          best_beefy: NumberFor<Block>,
 		                          best_grandpa: NumberFor<Block>|
 		 -> Option<NumberFor<Block>> {
@@ -1295,18 +1323,20 @@ pub(crate) mod tests {
 			Default::default(),
 			Digest::default(),
 		);
-		let mut oracle = VoterOracle::<Block> {
+		let mut oracle = VoterOracle::<Block, ecdsa_crypto::AuthorityId> {
 			best_beefy_block: 0,
 			best_grandpa_block_header: header,
 			min_block_delta: 1,
 			sessions: VecDeque::new(),
+			_phantom: PhantomData,
 		};
-		let accepted_interval_with = |oracle: &mut VoterOracle<Block>,
-		                              best_grandpa: NumberFor<Block>|
-		 -> Result<(NumberFor<Block>, NumberFor<Block>), Error> {
-			oracle.best_grandpa_block_header.number = best_grandpa;
-			oracle.accepted_interval()
-		};
+		let accepted_interval_with =
+			|oracle: &mut VoterOracle<Block, ecdsa_crypto::AuthorityId>,
+			 best_grandpa: NumberFor<Block>|
+			 -> Result<(NumberFor<Block>, NumberFor<Block>), Error> {
+				oracle.best_grandpa_block_header.number = best_grandpa;
+				oracle.accepted_interval()
+			};
 
 		// rounds not initialized -> should accept votes: `None`
 		assert!(accepted_interval_with(&mut oracle, 1).is_err());
@@ -1377,18 +1407,19 @@ pub(crate) mod tests {
 		);
 
 		// verify empty digest shows nothing
-		assert!(find_authorities_change::<Block>(&header).is_none());
+		assert!(find_authorities_change::<Block, ecdsa_crypto::AuthorityId>(&header).is_none());
 
 		let peers = &[Keyring::One, Keyring::Two];
 		let id = 42;
 		let validator_set = ValidatorSet::new(make_beefy_ids(peers), id).unwrap();
 		header.digest_mut().push(DigestItem::Consensus(
 			BEEFY_ENGINE_ID,
-			ConsensusLog::<AuthorityId>::AuthoritiesChange(validator_set.clone()).encode(),
+			ConsensusLog::<ecdsa_crypto::AuthorityId>::AuthoritiesChange(validator_set.clone())
+				.encode(),
 		));
 
 		// verify validator set is correctly extracted from digest
-		let extracted = find_authorities_change::<Block>(&header);
+		let extracted = find_authorities_change::<Block, ecdsa_crypto::AuthorityId>(&header);
 		assert_eq!(extracted, Some(validator_set));
 	}
 
diff --git a/substrate/client/consensus/grandpa/Cargo.toml b/substrate/client/consensus/grandpa/Cargo.toml
index 9099761fbceb4a30624eef4f636982f3e3b9921b..b03a263ae0a37d3a304b54096ad71a06b89c99bd 100644
--- a/substrate/client/consensus/grandpa/Cargo.toml
+++ b/substrate/client/consensus/grandpa/Cargo.toml
@@ -25,7 +25,7 @@ finality-grandpa = { version = "0.16.2", features = ["derive-codec"] }
 futures = "0.3.30"
 futures-timer = "3.0.1"
 log = { workspace = true, default-features = true }
-parity-scale-codec = { version = "3.6.12", features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["derive"] }
 parking_lot = "0.12.1"
 rand = "0.8.5"
 serde_json = { workspace = true, default-features = true }
diff --git a/substrate/client/consensus/grandpa/rpc/Cargo.toml b/substrate/client/consensus/grandpa/rpc/Cargo.toml
index d4e72baef3e7df47baf948cba59e35b2687c76e1..a9437a9be07544060e2b05aff4a86e0edcc3dcc5 100644
--- a/substrate/client/consensus/grandpa/rpc/Cargo.toml
+++ b/substrate/client/consensus/grandpa/rpc/Cargo.toml
@@ -17,7 +17,7 @@ finality-grandpa = { version = "0.16.2", features = ["derive-codec"] }
 futures = "0.3.30"
 jsonrpsee = { version = "0.22.5", features = ["client-core", "macros", "server-core"] }
 log = { workspace = true, default-features = true }
-parity-scale-codec = { version = "3.6.12", features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["derive"] }
 serde = { features = ["derive"], workspace = true, default-features = true }
 thiserror = { workspace = true }
 sc-client-api = { path = "../../../api" }
diff --git a/substrate/client/consensus/grandpa/rpc/src/lib.rs b/substrate/client/consensus/grandpa/rpc/src/lib.rs
index 68de068c3058377a6be9c8907581498d3466aaba..430525019dfb9ad9fec903d5e93f5ab3e5cb1a88 100644
--- a/substrate/client/consensus/grandpa/rpc/src/lib.rs
+++ b/substrate/client/consensus/grandpa/rpc/src/lib.rs
@@ -127,8 +127,8 @@ mod tests {
 	use super::*;
 	use std::{collections::HashSet, sync::Arc};
 
+	use codec::{Decode, Encode};
 	use jsonrpsee::{core::EmptyServerParams as EmptyParams, types::SubscriptionId, RpcModule};
-	use parity_scale_codec::{Decode, Encode};
 	use sc_block_builder::BlockBuilderBuilder;
 	use sc_consensus_grandpa::{
 		report, AuthorityId, FinalityProof, GrandpaJustification, GrandpaJustificationSender,
diff --git a/substrate/client/consensus/grandpa/rpc/src/notification.rs b/substrate/client/consensus/grandpa/rpc/src/notification.rs
index 42b9123ed8c145a174ea8c7a11be3bfa740fce97..5bcf90f4d79d06a4e9b2e5bdfc5d83551e276423 100644
--- a/substrate/client/consensus/grandpa/rpc/src/notification.rs
+++ b/substrate/client/consensus/grandpa/rpc/src/notification.rs
@@ -16,7 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use parity_scale_codec::Encode;
+use codec::Encode;
 use sc_consensus_grandpa::GrandpaJustification;
 use serde::{Deserialize, Serialize};
 use sp_runtime::traits::Block as BlockT;
diff --git a/substrate/client/consensus/grandpa/src/authorities.rs b/substrate/client/consensus/grandpa/src/authorities.rs
index 623223e41eb8234d85b3aa51a35bd4c1116e8ee7..2ac15d761b2e2e7306207290db7bb8726ff68d2a 100644
--- a/substrate/client/consensus/grandpa/src/authorities.rs
+++ b/substrate/client/consensus/grandpa/src/authorities.rs
@@ -20,10 +20,10 @@
 
 use std::{cmp::Ord, fmt::Debug, ops::Add};
 
+use codec::{Decode, Encode};
 use finality_grandpa::voter_set::VoterSet;
 use fork_tree::{FilterAction, ForkTree};
 use log::debug;
-use parity_scale_codec::{Decode, Encode};
 use parking_lot::MappedMutexGuard;
 use sc_consensus::shared_data::{SharedData, SharedDataLocked};
 use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_INFO};
@@ -662,9 +662,7 @@ pub struct PendingChange<H, N> {
 }
 
 impl<H: Decode, N: Decode> Decode for PendingChange<H, N> {
-	fn decode<I: parity_scale_codec::Input>(
-		value: &mut I,
-	) -> Result<Self, parity_scale_codec::Error> {
+	fn decode<I: codec::Input>(value: &mut I) -> Result<Self, codec::Error> {
 		let next_authorities = Decode::decode(value)?;
 		let delay = Decode::decode(value)?;
 		let canon_height = Decode::decode(value)?;
diff --git a/substrate/client/consensus/grandpa/src/aux_schema.rs b/substrate/client/consensus/grandpa/src/aux_schema.rs
index 97a8bc660317ac36d551d6e0fb50f73a92fffe74..8ec882591be9a682456e55f41fd47becd803a6c4 100644
--- a/substrate/client/consensus/grandpa/src/aux_schema.rs
+++ b/substrate/client/consensus/grandpa/src/aux_schema.rs
@@ -20,9 +20,9 @@
 
 use std::fmt::Debug;
 
+use codec::{Decode, Encode};
 use finality_grandpa::round::State as RoundState;
 use log::{info, warn};
-use parity_scale_codec::{Decode, Encode};
 
 use fork_tree::ForkTree;
 use sc_client_api::backend::AuxStore;
diff --git a/substrate/client/consensus/grandpa/src/communication/gossip.rs b/substrate/client/consensus/grandpa/src/communication/gossip.rs
index c7fe5a46a5eb6db29501effde313cdc6c08894d9..a6aa063357cb8e9327bd2f22ac4cedb18e19d8e2 100644
--- a/substrate/client/consensus/grandpa/src/communication/gossip.rs
+++ b/substrate/client/consensus/grandpa/src/communication/gossip.rs
@@ -86,8 +86,8 @@
 //! We only send polite messages to peers,
 
 use ahash::{AHashMap, AHashSet};
+use codec::{Decode, DecodeAll, Encode};
 use log::{debug, trace};
-use parity_scale_codec::{Decode, DecodeAll, Encode};
 use prometheus_endpoint::{register, CounterVec, Opts, PrometheusError, Registry, U64};
 use rand::seq::SliceRandom;
 use sc_network::ReputationChange;
diff --git a/substrate/client/consensus/grandpa/src/communication/mod.rs b/substrate/client/consensus/grandpa/src/communication/mod.rs
index cf78e1d4cf089a1097d662756bcf05f5528b48e0..3b0ea2c5ee960ac289992ef52c7c16e27693df0e 100644
--- a/substrate/client/consensus/grandpa/src/communication/mod.rs
+++ b/substrate/client/consensus/grandpa/src/communication/mod.rs
@@ -40,12 +40,12 @@ use std::{
 	time::Duration,
 };
 
+use codec::{Decode, DecodeAll, Encode};
 use finality_grandpa::{
 	voter,
 	voter_set::VoterSet,
 	Message::{Precommit, Prevote, PrimaryPropose},
 };
-use parity_scale_codec::{Decode, DecodeAll, Encode};
 use sc_network::{NetworkBlock, NetworkSyncForkRequest, NotificationService, ReputationChange};
 use sc_network_gossip::{GossipEngine, Network as GossipNetwork};
 use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_INFO};
diff --git a/substrate/client/consensus/grandpa/src/communication/tests.rs b/substrate/client/consensus/grandpa/src/communication/tests.rs
index bc3023fc0281d150864cb3bb21214c3648a73c42..5d1562f05188185ca765781d4f5b1d0d5962513f 100644
--- a/substrate/client/consensus/grandpa/src/communication/tests.rs
+++ b/substrate/client/consensus/grandpa/src/communication/tests.rs
@@ -23,8 +23,8 @@ use super::{
 	Round, SetId, VoterSet,
 };
 use crate::{communication::grandpa_protocol_name, environment::SharedVoterSetState};
+use codec::{DecodeAll, Encode};
 use futures::prelude::*;
-use parity_scale_codec::{DecodeAll, Encode};
 use sc_network::{
 	config::{MultiaddrWithPeerId, Role},
 	event::Event as NetworkEvent,
@@ -706,25 +706,12 @@ fn peer_with_higher_view_leads_to_catch_up_request() {
 }
 
 fn local_chain_spec() -> Box<dyn sc_chain_spec::ChainSpec> {
-	use sc_chain_spec::{ChainSpec, GenericChainSpec};
-	use serde::{Deserialize, Serialize};
-	use sp_runtime::{BuildStorage, Storage};
-
-	#[derive(Debug, Serialize, Deserialize)]
-	struct Genesis(std::collections::BTreeMap<String, String>);
-	impl BuildStorage for Genesis {
-		fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> {
-			storage.top.extend(
-				self.0.iter().map(|(a, b)| (a.clone().into_bytes(), b.clone().into_bytes())),
-			);
-			Ok(())
-		}
-	}
-	let chain_spec = GenericChainSpec::<Genesis>::from_json_bytes(
-		&include_bytes!("../../../../chain-spec/res/chain_spec.json")[..],
-	)
-	.unwrap();
-	chain_spec.cloned_box()
+	let chain_spec =
+		sc_chain_spec::GenericChainSpec::<sc_chain_spec::NoExtension, ()>::from_json_bytes(
+			&include_bytes!("../../../../chain-spec/res/chain_spec.json")[..],
+		)
+		.unwrap();
+	sc_chain_spec::ChainSpec::cloned_box(&chain_spec)
 }
 
 #[test]
diff --git a/substrate/client/consensus/grandpa/src/environment.rs b/substrate/client/consensus/grandpa/src/environment.rs
index 31df038044a4904e49f8447c4ab05c4cd36a5142..6199e8a97d990388b518d5d5404bfca789142310 100644
--- a/substrate/client/consensus/grandpa/src/environment.rs
+++ b/substrate/client/consensus/grandpa/src/environment.rs
@@ -24,13 +24,13 @@ use std::{
 	time::Duration,
 };
 
+use codec::{Decode, Encode};
 use finality_grandpa::{
 	round::State as RoundState, voter, voter_set::VoterSet, BlockNumberOps, Error as GrandpaError,
 };
 use futures::prelude::*;
 use futures_timer::Delay;
 use log::{debug, warn};
-use parity_scale_codec::{Decode, Encode};
 use parking_lot::RwLock;
 use prometheus_endpoint::{register, Counter, Gauge, PrometheusError, U64};
 
@@ -104,12 +104,10 @@ impl<Block: BlockT> Encode for CompletedRounds<Block> {
 	}
 }
 
-impl<Block: BlockT> parity_scale_codec::EncodeLike for CompletedRounds<Block> {}
+impl<Block: BlockT> codec::EncodeLike for CompletedRounds<Block> {}
 
 impl<Block: BlockT> Decode for CompletedRounds<Block> {
-	fn decode<I: parity_scale_codec::Input>(
-		value: &mut I,
-	) -> Result<Self, parity_scale_codec::Error> {
+	fn decode<I: codec::Input>(value: &mut I) -> Result<Self, codec::Error> {
 		<(Vec<CompletedRound<Block>>, SetId, Vec<AuthorityId>)>::decode(value)
 			.map(|(rounds, set_id, voters)| CompletedRounds { rounds, set_id, voters })
 	}
diff --git a/substrate/client/consensus/grandpa/src/finality_proof.rs b/substrate/client/consensus/grandpa/src/finality_proof.rs
index 80b6249ade86ca9d44e9ed1284c0e6189731c86c..af965f2e4ae64737bc3626e51f8245328af12d71 100644
--- a/substrate/client/consensus/grandpa/src/finality_proof.rs
+++ b/substrate/client/consensus/grandpa/src/finality_proof.rs
@@ -39,7 +39,7 @@
 use log::{trace, warn};
 use std::sync::Arc;
 
-use parity_scale_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use sc_client_api::backend::Backend;
 use sp_blockchain::{Backend as BlockchainBackend, HeaderBackend};
 use sp_consensus_grandpa::GRANDPA_ENGINE_ID;
diff --git a/substrate/client/consensus/grandpa/src/import.rs b/substrate/client/consensus/grandpa/src/import.rs
index bc2983569c533bcefbac2d98cad908e5ee6bcd01..b594c0f678cea64efae7980ee17a9876ce6d5013 100644
--- a/substrate/client/consensus/grandpa/src/import.rs
+++ b/substrate/client/consensus/grandpa/src/import.rs
@@ -18,8 +18,8 @@
 
 use std::{collections::HashMap, marker::PhantomData, sync::Arc};
 
+use codec::Decode;
 use log::debug;
-use parity_scale_codec::Decode;
 
 use sc_client_api::{backend::Backend, utils::is_descendent_of};
 use sc_consensus::{
diff --git a/substrate/client/consensus/grandpa/src/justification.rs b/substrate/client/consensus/grandpa/src/justification.rs
index a38cb113b40a7ad1b73a5d9302468c09a3c926a9..934c0d695fdab754e3d82e93402f1188c9a81d8c 100644
--- a/substrate/client/consensus/grandpa/src/justification.rs
+++ b/substrate/client/consensus/grandpa/src/justification.rs
@@ -22,8 +22,8 @@ use std::{
 	sync::Arc,
 };
 
+use codec::{Decode, DecodeAll, Encode};
 use finality_grandpa::{voter_set::VoterSet, Error as GrandpaError};
-use parity_scale_codec::{Decode, DecodeAll, Encode};
 use sp_blockchain::{Error as ClientError, HeaderBackend};
 use sp_consensus_grandpa::AuthorityId;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
diff --git a/substrate/client/consensus/grandpa/src/lib.rs b/substrate/client/consensus/grandpa/src/lib.rs
index 03452bd07c757fa9dac9b130a149aa264eb04834..a07dc035de35ce85c5f1b1d052298fd77c834b30 100644
--- a/substrate/client/consensus/grandpa/src/lib.rs
+++ b/substrate/client/consensus/grandpa/src/lib.rs
@@ -56,9 +56,9 @@
 
 #![warn(missing_docs)]
 
+use codec::Decode;
 use futures::{prelude::*, StreamExt};
 use log::{debug, error, info};
-use parity_scale_codec::Decode;
 use parking_lot::RwLock;
 use prometheus_endpoint::{PrometheusError, Registry};
 use sc_client_api::{
diff --git a/substrate/client/consensus/grandpa/src/warp_proof.rs b/substrate/client/consensus/grandpa/src/warp_proof.rs
index 7169a424c14a7726efa9531b80ef13f829bc9529..c836ab09fd5d5ce1f0885e02da5420407853548b 100644
--- a/substrate/client/consensus/grandpa/src/warp_proof.rs
+++ b/substrate/client/consensus/grandpa/src/warp_proof.rs
@@ -16,7 +16,7 @@
 
 //! Utilities for generating and verifying GRANDPA warp sync proofs.
 
-use parity_scale_codec::{Decode, DecodeAll, Encode};
+use codec::{Decode, DecodeAll, Encode};
 
 use crate::{
 	best_justification, find_scheduled_change, AuthoritySetChanges, AuthoritySetHardFork,
@@ -38,7 +38,7 @@ use std::{collections::HashMap, sync::Arc};
 pub enum Error {
 	/// Decoding error.
 	#[error("Failed to decode block hash: {0}.")]
-	DecodeScale(#[from] parity_scale_codec::Error),
+	DecodeScale(#[from] codec::Error),
 	/// Client backend error.
 	#[error("{0}")]
 	Client(#[from] sp_blockchain::Error),
@@ -320,7 +320,7 @@ where
 mod tests {
 	use super::WarpSyncProof;
 	use crate::{AuthoritySetChanges, GrandpaJustification};
-	use parity_scale_codec::Encode;
+	use codec::Encode;
 	use rand::prelude::*;
 	use sc_block_builder::BlockBuilderBuilder;
 	use sp_blockchain::HeaderBackend;
diff --git a/substrate/client/db/src/lib.rs b/substrate/client/db/src/lib.rs
index 36f9aea817c9c7031ae69a588a9385e88e786b0c..8d8b7a2aff88f88a3f034845a3422bad51258e69 100644
--- a/substrate/client/db/src/lib.rs
+++ b/substrate/client/db/src/lib.rs
@@ -2547,7 +2547,7 @@ pub(crate) mod tests {
 		backend::{Backend as BTrait, BlockImportOperation as Op},
 		blockchain::Backend as BLBTrait,
 	};
-	use sp_blockchain::{lowest_common_ancestor, tree_route};
+	use sp_blockchain::{lowest_common_ancestor, lowest_common_ancestor_multiblock, tree_route};
 	use sp_core::H256;
 	use sp_runtime::{
 		testing::{Block as RawBlock, ExtrinsicWrapper, Header},
@@ -3108,6 +3108,125 @@ pub(crate) mod tests {
 		}
 	}
 
+	#[test]
+	fn lowest_common_ancestors_multiblock_works() {
+		let backend = Backend::<Block>::new_test(1000, 100);
+		let blockchain = backend.blockchain();
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+
+		// fork from genesis: 3 prong.
+		// block 0 -> a1 -> a2 -> a3
+		//    |
+		//     -> b1 -> b2 -> c1 -> c2
+		//           |
+		//           -> d1 -> d2
+		let a1 = insert_header(&backend, 1, block0, None, Default::default());
+		let a2 = insert_header(&backend, 2, a1, None, Default::default());
+		let a3 = insert_header(&backend, 3, a2, None, Default::default());
+
+		// fork from genesis: 2 prong.
+		let b1 = insert_header(&backend, 1, block0, None, H256::from([1; 32]));
+		let b2 = insert_header(&backend, 2, b1, None, Default::default());
+
+		// fork from b2.
+		let c1 = insert_header(&backend, 3, b2, None, H256::from([2; 32]));
+		let c2 = insert_header(&backend, 4, c1, None, Default::default());
+
+		// fork from b1.
+		let d1 = insert_header(&backend, 2, b1, None, H256::from([3; 32]));
+		let d2 = insert_header(&backend, 3, d1, None, Default::default());
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a3, b2]).unwrap().unwrap();
+
+			assert_eq!(lca.hash, block0);
+			assert_eq!(lca.number, 0);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a1, a3]).unwrap().unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a3, a1]).unwrap().unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a2, a3]).unwrap().unwrap();
+
+			assert_eq!(lca.hash, a2);
+			assert_eq!(lca.number, 2);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a2, a1]).unwrap().unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a2, a2]).unwrap().unwrap();
+
+			assert_eq!(lca.hash, a2);
+			assert_eq!(lca.number, 2);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a3, d2, c2])
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(lca.hash, block0);
+			assert_eq!(lca.number, 0);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![c2, d2, b2])
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(lca.hash, b1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a1, a2, a3])
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![b1, b2, d1])
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(lca.hash, b1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![]);
+
+			assert_eq!(true, matches!(lca, Ok(None)));
+		}
+
+		{
+			let lca = lowest_common_ancestor_multiblock(blockchain, vec![a1]).unwrap().unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+	}
+
 	#[test]
 	fn test_tree_route_regression() {
 		// NOTE: this is a test for a regression introduced in #3665, the result
diff --git a/substrate/client/executor/src/integration_tests/mod.rs b/substrate/client/executor/src/integration_tests/mod.rs
index 7f91b3ffe7644e37ebee0bc035faafbf38e21148..5d94ec6dcd38628be7858b8477e7e4892a45b210 100644
--- a/substrate/client/executor/src/integration_tests/mod.rs
+++ b/substrate/client/executor/src/integration_tests/mod.rs
@@ -178,7 +178,7 @@ fn storage_should_work(wasm_method: WasmExecutionMethod) {
 		assert_eq!(output, b"all ok!".to_vec().encode());
 	}
 
-	let expected = TestExternalities::new(sp_core::storage::Storage {
+	let mut expected = TestExternalities::new(sp_core::storage::Storage {
 		top: map![
 			b"input".to_vec() => value,
 			b"foo".to_vec() => b"bar".to_vec(),
@@ -186,7 +186,7 @@ fn storage_should_work(wasm_method: WasmExecutionMethod) {
 		],
 		children_default: map![],
 	});
-	assert_eq!(ext, expected);
+	assert!(ext.eq(&mut expected));
 }
 
 test_wasm_execution!(clear_prefix_should_work);
@@ -208,7 +208,7 @@ fn clear_prefix_should_work(wasm_method: WasmExecutionMethod) {
 		assert_eq!(output, b"all ok!".to_vec().encode());
 	}
 
-	let expected = TestExternalities::new(sp_core::storage::Storage {
+	let mut expected = TestExternalities::new(sp_core::storage::Storage {
 		top: map![
 			b"aaa".to_vec() => b"1".to_vec(),
 			b"aab".to_vec() => b"2".to_vec(),
@@ -216,7 +216,7 @@ fn clear_prefix_should_work(wasm_method: WasmExecutionMethod) {
 		],
 		children_default: map![],
 	});
-	assert_eq!(expected, ext);
+	assert!(expected.eq(&mut ext));
 }
 
 test_wasm_execution!(blake2_256_should_work);
diff --git a/substrate/client/executor/wasmtime/src/lib.rs b/substrate/client/executor/wasmtime/src/lib.rs
index 82e62b4a5dd3cd6d7b009e019f0c24c28551743a..8e8e92017df91260d7d79f8f237200c1ef9936c0 100644
--- a/substrate/client/executor/wasmtime/src/lib.rs
+++ b/substrate/client/executor/wasmtime/src/lib.rs
@@ -41,3 +41,7 @@ pub use runtime::{
 	prepare_runtime_artifact, Config, DeterministicStackLimit, InstantiationStrategy, Semantics,
 	WasmtimeRuntime,
 };
+pub use sc_executor_common::{
+	runtime_blob::RuntimeBlob,
+	wasm_runtime::{HeapAllocStrategy, WasmModule},
+};
diff --git a/substrate/client/mixnet/src/sync_with_runtime.rs b/substrate/client/mixnet/src/sync_with_runtime.rs
index 46c2334ceb46d8ef7966b666e480e83075a51703..0071ce13b33a3ff015569ce66530215f1d9ac5b6 100644
--- a/substrate/client/mixnet/src/sync_with_runtime.rs
+++ b/substrate/client/mixnet/src/sync_with_runtime.rs
@@ -25,8 +25,10 @@ use mixnet::core::{
 	Mixnet, Mixnode as CoreMixnode, MixnodesErr as CoreMixnodesErr, RelSessionIndex,
 	SessionPhase as CoreSessionPhase, SessionStatus as CoreSessionStatus,
 };
-use multiaddr::{multiaddr, Multiaddr, Protocol};
-use sc_network_types::PeerId;
+use sc_network_types::{
+	multiaddr::{multiaddr, Multiaddr, Protocol},
+	PeerId,
+};
 use sp_api::{ApiError, ApiRef};
 use sp_mixnet::{
 	runtime_api::MixnetApi,
@@ -196,7 +198,6 @@ where
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use multiaddr::multiaddr;
 
 	#[test]
 	fn fixup_empty_external_addresses() {
diff --git a/substrate/client/network/Cargo.toml b/substrate/client/network/Cargo.toml
index 5a469469539b2f22e2bcc11322b018aebce164ca..29b14a4511cac655096b3e3dded5013462ae7e9e 100644
--- a/substrate/client/network/Cargo.toml
+++ b/substrate/client/network/Cargo.toml
@@ -59,7 +59,7 @@ sp-blockchain = { path = "../../primitives/blockchain" }
 sp-core = { path = "../../primitives/core" }
 sp-runtime = { path = "../../primitives/runtime" }
 wasm-timer = "0.2"
-litep2p = { git = "https://github.com/paritytech/litep2p", rev = "e03a6023882db111beeb24d8c0ceaac0721d3f0f" }
+litep2p = "0.5.0"
 once_cell = "1.18.0"
 void = "1.0.2"
 schnellru = "0.2.1"
diff --git a/substrate/client/network/src/behaviour.rs b/substrate/client/network/src/behaviour.rs
index 833ff5d09e5eeac2fe6ba3ab74a2c499281a27e0..68deac0f47bc1e3b367fc56ba77e67ba63380648 100644
--- a/substrate/client/network/src/behaviour.rs
+++ b/substrate/client/network/src/behaviour.rs
@@ -37,7 +37,11 @@ use libp2p::{
 
 use parking_lot::Mutex;
 use sp_runtime::traits::Block as BlockT;
-use std::{collections::HashSet, sync::Arc, time::Duration};
+use std::{
+	collections::HashSet,
+	sync::Arc,
+	time::{Duration, Instant},
+};
 
 pub use crate::request_responses::{InboundFailure, OutboundFailure, ResponseFailure};
 
@@ -157,9 +161,10 @@ pub enum BehaviourOut {
 	/// We have learned about the existence of a node on the default set.
 	Discovered(PeerId),
 
-	/// Events generated by a DHT as a response to get_value or put_value requests as well as the
-	/// request duration.
-	Dht(DhtEvent, Duration),
+	/// Events generated by a DHT as a response to get_value or put_value requests with the
+	/// request duration. Or events generated by the DHT as a consequnce of receiving a record
+	/// to store from peers.
+	Dht(DhtEvent, Option<Duration>),
 
 	/// Ignored event generated by lower layers.
 	None,
@@ -279,6 +284,17 @@ impl<B: BlockT> Behaviour<B> {
 	pub fn put_value(&mut self, key: RecordKey, value: Vec<u8>) {
 		self.discovery.put_value(key, value);
 	}
+
+	/// Stores value in DHT
+	pub fn store_record(
+		&mut self,
+		record_key: RecordKey,
+		record_value: Vec<u8>,
+		publisher: Option<PeerId>,
+		expires: Option<Instant>,
+	) {
+		self.discovery.store_record(record_key, record_value, publisher, expires);
+	}
 }
 
 impl From<CustomMessageOutcome> for BehaviourOut {
@@ -344,13 +360,18 @@ impl From<DiscoveryOut> for BehaviourOut {
 			},
 			DiscoveryOut::Discovered(peer_id) => BehaviourOut::Discovered(peer_id),
 			DiscoveryOut::ValueFound(results, duration) =>
-				BehaviourOut::Dht(DhtEvent::ValueFound(results), duration),
+				BehaviourOut::Dht(DhtEvent::ValueFound(results), Some(duration)),
 			DiscoveryOut::ValueNotFound(key, duration) =>
-				BehaviourOut::Dht(DhtEvent::ValueNotFound(key), duration),
+				BehaviourOut::Dht(DhtEvent::ValueNotFound(key), Some(duration)),
 			DiscoveryOut::ValuePut(key, duration) =>
-				BehaviourOut::Dht(DhtEvent::ValuePut(key), duration),
+				BehaviourOut::Dht(DhtEvent::ValuePut(key), Some(duration)),
+			DiscoveryOut::PutRecordRequest(record_key, record_value, publisher, expires) =>
+				BehaviourOut::Dht(
+					DhtEvent::PutRecordRequest(record_key, record_value, publisher, expires),
+					None,
+				),
 			DiscoveryOut::ValuePutFailed(key, duration) =>
-				BehaviourOut::Dht(DhtEvent::ValuePutFailed(key), duration),
+				BehaviourOut::Dht(DhtEvent::ValuePutFailed(key), Some(duration)),
 			DiscoveryOut::RandomKademliaStarted => BehaviourOut::RandomKademliaStarted,
 		}
 	}
diff --git a/substrate/client/network/src/config.rs b/substrate/client/network/src/config.rs
index e6cc9de56942700940da2644b2c5b57c0abd144d..100a1e9dfb38ea23d4bb7d846aed0295f1cdaaea 100644
--- a/substrate/client/network/src/config.rs
+++ b/substrate/client/network/src/config.rs
@@ -35,12 +35,11 @@ pub use crate::{
 	types::ProtocolName,
 };
 
-pub use libp2p::{
-	build_multiaddr,
-	identity::{self, ed25519, Keypair},
-	multiaddr, Multiaddr,
+pub use sc_network_types::{build_multiaddr, ed25519};
+use sc_network_types::{
+	multiaddr::{self, Multiaddr},
+	PeerId,
 };
-use sc_network_types::PeerId;
 
 use crate::service::{ensure_addresses_consistent_with_transport, traits::NetworkBackend};
 use codec::Encode;
@@ -100,7 +99,7 @@ impl fmt::Debug for ProtocolId {
 /// # Example
 ///
 /// ```
-/// # use libp2p::{Multiaddr, PeerId};
+/// # use sc_network_types::{multiaddr::Multiaddr, PeerId};
 /// use sc_network::config::parse_str_addr;
 /// let (peer_id, addr) = parse_str_addr(
 /// 	"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
@@ -131,7 +130,7 @@ pub fn parse_addr(mut addr: Multiaddr) -> Result<(PeerId, Multiaddr), ParseErr>
 /// # Example
 ///
 /// ```
-/// # use libp2p::{Multiaddr, PeerId};
+/// # use sc_network_types::{multiaddr::Multiaddr, PeerId};
 /// use sc_network::config::MultiaddrWithPeerId;
 /// let addr: MultiaddrWithPeerId =
 /// 	"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".parse().unwrap();
@@ -187,7 +186,7 @@ impl TryFrom<String> for MultiaddrWithPeerId {
 #[derive(Debug)]
 pub enum ParseErr {
 	/// Error while parsing the multiaddress.
-	MultiaddrParse(multiaddr::Error),
+	MultiaddrParse(multiaddr::ParseError),
 	/// Multihash of the peer ID is invalid.
 	InvalidPeerId,
 	/// The peer ID is missing from the address.
@@ -214,8 +213,8 @@ impl std::error::Error for ParseErr {
 	}
 }
 
-impl From<multiaddr::Error> for ParseErr {
-	fn from(err: multiaddr::Error) -> ParseErr {
+impl From<multiaddr::ParseError> for ParseErr {
+	fn from(err: multiaddr::ParseError) -> ParseErr {
 		Self::MultiaddrParse(err)
 	}
 }
@@ -343,10 +342,10 @@ impl NodeKeyConfig {
 	///
 	///  * If the secret is configured to be new, it is generated and the corresponding keypair is
 	///    returned.
-	pub fn into_keypair(self) -> io::Result<Keypair> {
+	pub fn into_keypair(self) -> io::Result<ed25519::Keypair> {
 		use NodeKeyConfig::*;
 		match self {
-			Ed25519(Secret::New) => Ok(Keypair::generate_ed25519()),
+			Ed25519(Secret::New) => Ok(ed25519::Keypair::generate()),
 
 			Ed25519(Secret::Input(k)) => Ok(ed25519::Keypair::from(k).into()),
 
@@ -365,8 +364,7 @@ impl NodeKeyConfig {
 				ed25519::SecretKey::generate,
 				|b| b.as_ref().to_vec(),
 			)
-			.map(ed25519::Keypair::from)
-			.map(Keypair::from),
+			.map(ed25519::Keypair::from),
 		}
 	}
 }
@@ -887,7 +885,7 @@ impl<B: BlockT + 'static, H: ExHashT, N: NetworkBackend<B, H>> FullNetworkConfig
 				.find(|o| o.peer_id != bootnode.peer_id)
 			{
 				Err(crate::error::Error::DuplicateBootnode {
-					address: bootnode.multiaddr.clone(),
+					address: bootnode.multiaddr.clone().into(),
 					first_id: bootnode.peer_id.into(),
 					second_id: other.peer_id.into(),
 				})
@@ -947,14 +945,8 @@ mod tests {
 		tempfile::Builder::new().prefix(prefix).tempdir().unwrap()
 	}
 
-	fn secret_bytes(kp: Keypair) -> Vec<u8> {
-		kp.try_into_ed25519()
-			.expect("ed25519 keypair")
-			.secret()
-			.as_ref()
-			.iter()
-			.cloned()
-			.collect()
+	fn secret_bytes(kp: ed25519::Keypair) -> Vec<u8> {
+		kp.secret().to_bytes().into()
 	}
 
 	#[test]
diff --git a/substrate/client/network/src/discovery.rs b/substrate/client/network/src/discovery.rs
index 7d4481b0d06f947619b66ab60a5ab60b8fe15a99..2c788ec713f345ef18d421a07c279e9dfd9f7ba0 100644
--- a/substrate/client/network/src/discovery.rs
+++ b/substrate/client/network/src/discovery.rs
@@ -80,7 +80,7 @@ use std::{
 	collections::{hash_map::Entry, HashMap, HashSet, VecDeque},
 	num::NonZeroUsize,
 	task::{Context, Poll},
-	time::Duration,
+	time::{Duration, Instant},
 };
 
 /// Maximum number of known external addresses that we will cache.
@@ -222,6 +222,9 @@ impl DiscoveryConfig {
 			// https://github.com/paritytech/polkadot-sdk/issues/504
 			let kademlia_protocols = [kademlia_protocol.clone(), kademlia_legacy_protocol];
 			config.set_protocol_names(kademlia_protocols.into_iter().map(Into::into).collect());
+
+			config.set_record_filtering(libp2p::kad::KademliaStoreInserts::FilterBoth);
+
 			// By default Kademlia attempts to insert all peers into its routing table once a
 			// dialing attempt succeeds. In order to control which peer is added, disable the
 			// auto-insertion and instead add peers manually.
@@ -427,6 +430,30 @@ impl DiscoveryBehaviour {
 		}
 	}
 
+	/// Store a record in the Kademlia record store.
+	pub fn store_record(
+		&mut self,
+		record_key: RecordKey,
+		record_value: Vec<u8>,
+		publisher: Option<PeerId>,
+		expires: Option<Instant>,
+	) {
+		if let Some(k) = self.kademlia.as_mut() {
+			if let Err(err) = k.store_mut().put(Record {
+				key: record_key,
+				value: record_value,
+				publisher: publisher.map(|publisher| publisher.into()),
+				expires,
+			}) {
+				debug!(
+					target: "sub-libp2p",
+					"Failed to store record with key: {:?}",
+					err
+				);
+			}
+		}
+	}
+
 	/// Returns the number of nodes in each Kademlia kbucket for each Kademlia instance.
 	///
 	/// Identifies Kademlia instances by their [`ProtocolId`] and kbuckets by the base 2 logarithm
@@ -495,6 +522,14 @@ pub enum DiscoveryOut {
 	/// Returning the result grouped in (key, value) pairs as well as the request duration.
 	ValueFound(Vec<(RecordKey, Vec<u8>)>, Duration),
 
+	/// The DHT received a put record request.
+	PutRecordRequest(
+		RecordKey,
+		Vec<u8>,
+		Option<sc_network_types::PeerId>,
+		Option<std::time::Instant>,
+	),
+
 	/// The record requested was not found in the DHT.
 	///
 	/// Returning the corresponding key as well as the request duration.
@@ -764,10 +799,21 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 						let ev = DiscoveryOut::Discovered(peer);
 						return Poll::Ready(ToSwarm::GenerateEvent(ev))
 					},
-					KademliaEvent::PendingRoutablePeer { .. } |
-					KademliaEvent::InboundRequest { .. } => {
+					KademliaEvent::PendingRoutablePeer { .. } => {
 						// We are not interested in this event at the moment.
 					},
+					KademliaEvent::InboundRequest { request } => match request {
+						libp2p::kad::InboundRequest::PutRecord { record: Some(record), .. } =>
+							return Poll::Ready(ToSwarm::GenerateEvent(
+								DiscoveryOut::PutRecordRequest(
+									record.key,
+									record.value,
+									record.publisher.map(Into::into),
+									record.expires,
+								),
+							)),
+						_ => {},
+					},
 					KademliaEvent::OutboundQueryProgressed {
 						result: QueryResult::GetClosestPeers(res),
 						..
diff --git a/substrate/client/network/src/error.rs b/substrate/client/network/src/error.rs
index b776e3e1ad9de8f84118f293f28ad00c88969ba0..376b8461be4e57a72ad45c7f29763bba19e40ac9 100644
--- a/substrate/client/network/src/error.rs
+++ b/substrate/client/network/src/error.rs
@@ -20,7 +20,7 @@
 
 use crate::{config::TransportConfig, types::ProtocolName};
 
-use libp2p::{Multiaddr, PeerId};
+use sc_network_types::{multiaddr::Multiaddr, PeerId};
 
 use std::fmt;
 
diff --git a/substrate/client/network/src/event.rs b/substrate/client/network/src/event.rs
index dc4fd53a49aa9d198cc23c26dec3d68e239838bf..d0ccbd8622b885730864d29ac835441cd276d970 100644
--- a/substrate/client/network/src/event.rs
+++ b/substrate/client/network/src/event.rs
@@ -41,6 +41,9 @@ pub enum DhtEvent {
 
 	/// An error has occurred while putting a record into the DHT.
 	ValuePutFailed(Key),
+
+	/// The DHT received a put record request.
+	PutRecordRequest(Key, Vec<u8>, Option<sc_network_types::PeerId>, Option<std::time::Instant>),
 }
 
 /// Type for events generated by networking layer.
diff --git a/substrate/client/network/src/lib.rs b/substrate/client/network/src/lib.rs
index 8f479825c8d77c7684333981d1763099b8a537c9..99a972f914e261e60ef8692fc3fab7a53051d3df 100644
--- a/substrate/client/network/src/lib.rs
+++ b/substrate/client/network/src/lib.rs
@@ -272,6 +272,10 @@ pub use sc_network_common::{
 	role::{ObservedRole, Roles},
 	types::ReputationChange,
 };
+pub use sc_network_types::{
+	multiaddr::{self, Multiaddr},
+	PeerId,
+};
 pub use service::{
 	metrics::NotificationMetrics,
 	signature::Signature,
@@ -285,7 +289,7 @@ pub use service::{
 	DecodingError, Keypair, NetworkService, NetworkWorker, NotificationSender, OutboundFailure,
 	PublicKey,
 };
-pub use types::{multiaddr, Multiaddr, PeerId, ProtocolName};
+pub use types::ProtocolName;
 
 /// The maximum allowed number of established connections per peer.
 ///
diff --git a/substrate/client/network/src/litep2p/discovery.rs b/substrate/client/network/src/litep2p/discovery.rs
index 2120ea7c615d48237fd52e7645b7ac329010d91e..ff5f492df246a6e4165700132d080c183b91b79a 100644
--- a/substrate/client/network/src/litep2p/discovery.rs
+++ b/substrate/client/network/src/litep2p/discovery.rs
@@ -20,9 +20,7 @@
 
 use crate::{
 	config::{NetworkConfiguration, ProtocolId},
-	multiaddr::Protocol,
 	peer_store::PeerStoreProvider,
-	Multiaddr,
 };
 
 use array_bytes::bytes2hex;
@@ -36,12 +34,13 @@ use litep2p::{
 			identify::{Config as IdentifyConfig, IdentifyEvent},
 			kademlia::{
 				Config as KademliaConfig, ConfigBuilder as KademliaConfigBuilder, KademliaEvent,
-				KademliaHandle, QueryId, Quorum, Record, RecordKey,
+				KademliaHandle, QueryId, Quorum, Record, RecordKey, RecordsType,
 			},
 			ping::{Config as PingConfig, PingEvent},
 		},
 		mdns::{Config as MdnsConfig, MdnsEvent},
 	},
+	types::multiaddr::{Multiaddr, Protocol},
 	PeerId, ProtocolName,
 };
 use parking_lot::RwLock;
@@ -124,8 +123,8 @@ pub enum DiscoveryEvent {
 		/// Query ID.
 		query_id: QueryId,
 
-		/// Record.
-		record: Record,
+		/// Records.
+		records: RecordsType,
 	},
 
 	/// Record was successfully stored on the DHT.
@@ -227,7 +226,7 @@ impl Discovery {
 		let (identify_config, identify_event_stream) = IdentifyConfig::new(
 			"/substrate/1.0".to_string(),
 			Some(user_agent),
-			config.public_addresses.clone(),
+			config.public_addresses.clone().into_iter().map(Into::into).collect(),
 		);
 
 		let (mdns_config, mdns_event_stream) = match config.transport {
@@ -266,7 +265,7 @@ impl Discovery {
 				duration_to_next_find_query: Duration::from_secs(1),
 				address_confirmations: LruMap::new(ByLength::new(8)),
 				allow_non_global_addresses: config.allow_non_globals_in_dht,
-				public_addresses: config.public_addresses.iter().cloned().collect(),
+				public_addresses: config.public_addresses.iter().cloned().map(Into::into).collect(),
 				next_kad_query: Some(Delay::new(KADEMLIA_QUERY_INTERVAL)),
 				local_protocols: HashSet::from_iter([kademlia_protocol_name(
 					genesis_hash,
@@ -461,16 +460,13 @@ impl Stream for Discovery {
 					peers: peers.into_iter().collect(),
 				}))
 			},
-			Poll::Ready(Some(KademliaEvent::GetRecordSuccess { query_id, record })) => {
+			Poll::Ready(Some(KademliaEvent::GetRecordSuccess { query_id, records })) => {
 				log::trace!(
 					target: LOG_TARGET,
-					"`GET_RECORD` succeeded for {query_id:?}: {record:?}",
+					"`GET_RECORD` succeeded for {query_id:?}: {records:?}",
 				);
 
-				return Poll::Ready(Some(DiscoveryEvent::GetRecordSuccess {
-					query_id,
-					record: record.record,
-				}));
+				return Poll::Ready(Some(DiscoveryEvent::GetRecordSuccess { query_id, records }));
 			},
 			Poll::Ready(Some(KademliaEvent::PutRecordSucess { query_id, key: _ })) =>
 				return Poll::Ready(Some(DiscoveryEvent::PutRecordSuccess { query_id })),
diff --git a/substrate/client/network/src/litep2p/mod.rs b/substrate/client/network/src/litep2p/mod.rs
index 1137c73b56db8292fdee437ee3a656f38e789f51..ae287052b2d44934a8b4827e53c77cae0d707be9 100644
--- a/substrate/client/network/src/litep2p/mod.rs
+++ b/substrate/client/network/src/litep2p/mod.rs
@@ -38,7 +38,6 @@ use crate::{
 			request_response::{RequestResponseConfig, RequestResponseProtocol},
 		},
 	},
-	multiaddr::{Multiaddr, Protocol},
 	peer_store::PeerStoreProvider,
 	protocol,
 	service::{
@@ -54,17 +53,23 @@ use futures::StreamExt;
 use libp2p::kad::RecordKey;
 use litep2p::{
 	config::ConfigBuilder,
-	crypto::ed25519::{Keypair, SecretKey},
+	crypto::ed25519::Keypair,
 	executor::Executor,
 	protocol::{
-		libp2p::{bitswap::Config as BitswapConfig, kademlia::QueryId},
+		libp2p::{
+			bitswap::Config as BitswapConfig,
+			kademlia::{QueryId, RecordsType},
+		},
 		request_response::ConfigBuilder as RequestResponseConfigBuilder,
 	},
 	transport::{
 		tcp::config::Config as TcpTransportConfig,
 		websocket::config::Config as WebSocketTransportConfig, Endpoint,
 	},
-	types::ConnectionId,
+	types::{
+		multiaddr::{Multiaddr, Protocol},
+		ConnectionId,
+	},
 	Error as Litep2pError, Litep2p, Litep2pEvent, ProtocolName as Litep2pProtocolName,
 };
 use parking_lot::RwLock;
@@ -81,7 +86,7 @@ use std::{
 	collections::{hash_map::Entry, HashMap, HashSet},
 	fs,
 	future::Future,
-	io, iter,
+	iter,
 	pin::Pin,
 	sync::{
 		atomic::{AtomicUsize, Ordering},
@@ -200,12 +205,12 @@ impl Litep2pNetworkBackend {
 					Protocol::Ip4(_),
 				) => match address.iter().find(|protocol| std::matches!(protocol, Protocol::P2p(_)))
 				{
-					Some(Protocol::P2p(multihash)) => PeerId::from_multihash(multihash)
+					Some(Protocol::P2p(multihash)) => PeerId::from_multihash(multihash.into())
 						.map_or(None, |peer| Some((peer, Some(address)))),
 					_ => None,
 				},
 				Some(Protocol::P2p(multihash)) =>
-					PeerId::from_multihash(multihash).map_or(None, |peer| Some((peer, None))),
+					PeerId::from_multihash(multihash.into()).map_or(None, |peer| Some((peer, None))),
 				_ => None,
 			})
 			.fold(HashMap::new(), |mut acc, (peer, maybe_address)| {
@@ -244,16 +249,9 @@ impl Litep2pNetworkBackend {
 impl Litep2pNetworkBackend {
 	/// Get `litep2p` keypair from `NodeKeyConfig`.
 	fn get_keypair(node_key: &NodeKeyConfig) -> Result<(Keypair, litep2p::PeerId), Error> {
-		let secret = libp2p::identity::Keypair::try_into_ed25519(node_key.clone().into_keypair()?)
-			.map_err(|error| {
-				log::error!(target: LOG_TARGET, "failed to convert to ed25519: {error:?}");
-				Error::Io(io::ErrorKind::InvalidInput.into())
-			})?
-			.secret();
-
-		let mut secret = secret.as_ref().iter().cloned().collect::<Vec<_>>();
-		let secret = SecretKey::from_bytes(&mut secret)
-			.map_err(|_| Error::Io(io::ErrorKind::InvalidInput.into()))?;
+		let secret: litep2p::crypto::ed25519::SecretKey =
+			node_key.clone().into_keypair()?.secret().into();
+
 		let local_identity = Keypair::from(secret);
 		let local_public = local_identity.public();
 		let local_peer_id = local_public.to_peer_id();
@@ -327,6 +325,8 @@ impl Litep2pNetworkBackend {
 			.listen_addresses
 			.iter()
 			.filter_map(|address| {
+				use sc_network_types::multiaddr::Protocol;
+
 				let mut iter = address.iter();
 
 				match iter.next() {
@@ -367,12 +367,12 @@ impl Litep2pNetworkBackend {
 
 		config_builder
 			.with_websocket(WebSocketTransportConfig {
-				listen_addresses: websocket.into_iter().flatten().collect(),
+				listen_addresses: websocket.into_iter().flatten().map(Into::into).collect(),
 				yamux_config: yamux_config.clone(),
 				..Default::default()
 			})
 			.with_tcp(TcpTransportConfig {
-				listen_addresses: tcp.into_iter().flatten().collect(),
+				listen_addresses: tcp.into_iter().flatten().map(Into::into).collect(),
 				yamux_config,
 				..Default::default()
 			})
@@ -522,6 +522,8 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkBackend<B, H> for Litep2pNetworkBac
 		// collect known addresses
 		let known_addresses: HashMap<litep2p::PeerId, Vec<Multiaddr>> =
 			known_addresses.into_iter().fold(HashMap::new(), |mut acc, (peer, address)| {
+				use sc_network_types::multiaddr::Protocol;
+
 				let address = match address.iter().last() {
 					Some(Protocol::Ws(_) | Protocol::Wss(_) | Protocol::Tcp(_)) =>
 						address.with(Protocol::P2p(peer.into())),
@@ -529,7 +531,7 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkBackend<B, H> for Litep2pNetworkBac
 					_ => return acc,
 				};
 
-				acc.entry(peer.into()).or_default().push(address);
+				acc.entry(peer.into()).or_default().push(address.into());
 				peer_store_handle.add_known_peer(peer);
 
 				acc
@@ -567,7 +569,7 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkBackend<B, H> for Litep2pNetworkBac
 			Litep2p::new(config_builder.build()).map_err(|error| Error::Litep2p(error))?;
 
 		let external_addresses: Arc<RwLock<HashSet<Multiaddr>>> = Arc::new(RwLock::new(
-			HashSet::from_iter(network_config.public_addresses.iter().cloned()),
+			HashSet::from_iter(network_config.public_addresses.iter().cloned().map(Into::into)),
 		));
 		litep2p.listen_addresses().for_each(|address| {
 			log::debug!(target: LOG_TARGET, "listening on: {address}");
@@ -713,7 +715,7 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkBackend<B, H> for Litep2pNetworkBac
 							protocol,
 							peers,
 						} => {
-							let peers = self.add_addresses(peers.into_iter());
+							let peers = self.add_addresses(peers.into_iter().map(Into::into));
 
 							match self.peerset_handles.get(&protocol) {
 								Some(handle) => {
@@ -722,9 +724,11 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkBackend<B, H> for Litep2pNetworkBac
 								None => log::warn!(target: LOG_TARGET, "protocol {protocol} doens't exist"),
 							};
 						}
-						NetworkServiceCommand::AddKnownAddress { peer, mut address } => {
+						NetworkServiceCommand::AddKnownAddress { peer, address } => {
+							let mut address: Multiaddr = address.into();
+
 							if !address.iter().any(|protocol| std::matches!(protocol, Protocol::P2p(_))) {
-								address.push(Protocol::P2p(peer.into()));
+								address.push(Protocol::P2p(litep2p::PeerId::from(peer).into()));
 							}
 
 							if self.litep2p.add_known_address(peer.into(), iter::once(address.clone())) == 0usize {
@@ -735,7 +739,7 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkBackend<B, H> for Litep2pNetworkBac
 							}
 						},
 						NetworkServiceCommand::SetReservedPeers { protocol, peers } => {
-							let peers = self.add_addresses(peers.into_iter());
+							let peers = self.add_addresses(peers.into_iter().map(Into::into));
 
 							match self.peerset_handles.get(&protocol) {
 								Some(handle) => {
@@ -795,23 +799,30 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkBackend<B, H> for Litep2pNetworkBac
 							self.peerstore_handle.add_known_peer(peer.into());
 						}
 					}
-					Some(DiscoveryEvent::GetRecordSuccess { query_id, record }) => {
+					Some(DiscoveryEvent::GetRecordSuccess { query_id, records }) => {
 						match self.pending_get_values.remove(&query_id) {
 							None => log::warn!(
 								target: LOG_TARGET,
 								"`GET_VALUE` succeeded for a non-existent query",
 							),
-							Some((_key, started)) => {
+							Some((key, started)) => {
 								log::trace!(
 									target: LOG_TARGET,
 									"`GET_VALUE` for {:?} ({query_id:?}) succeeded",
-									record.key,
+									key,
 								);
 
-								self.event_streams.send(Event::Dht(
-									DhtEvent::ValueFound(vec![
+								let value_found = match records {
+									RecordsType::LocalStore(record) => vec![
 										(libp2p::kad::RecordKey::new(&record.key), record.value)
-									])
+									],
+									RecordsType::Network(records) => records.into_iter().map(|peer_record| {
+										(libp2p::kad::RecordKey::new(&peer_record.record.key), peer_record.record.value)
+									}).collect(),
+								};
+
+								self.event_streams.send(Event::Dht(
+									DhtEvent::ValueFound(value_found)
 								));
 
 								if let Some(ref metrics) = self.metrics {
diff --git a/substrate/client/network/src/litep2p/service.rs b/substrate/client/network/src/litep2p/service.rs
index 86f11aa6e142e2a1bdc161e7a92e34f5833cd1bb..8f36b0828bd39d7f159111cea4713c8d1b04e54c 100644
--- a/substrate/client/network/src/litep2p/service.rs
+++ b/substrate/client/network/src/litep2p/service.rs
@@ -24,7 +24,6 @@ use crate::{
 		notification::{config::ProtocolControlHandle, peerset::PeersetCommand},
 		request_response::OutboundRequest,
 	},
-	multiaddr::Protocol,
 	network_state::NetworkState,
 	peer_store::PeerStoreProvider,
 	service::out_events,
@@ -35,20 +34,24 @@ use crate::{
 
 use codec::DecodeAll;
 use futures::{channel::oneshot, stream::BoxStream};
-use libp2p::{identity::SigningError, kad::record::Key as KademliaKey, Multiaddr};
-use litep2p::crypto::ed25519::Keypair;
+use libp2p::{identity::SigningError, kad::record::Key as KademliaKey};
+use litep2p::{crypto::ed25519::Keypair, types::multiaddr::Multiaddr as LiteP2pMultiaddr};
 use parking_lot::RwLock;
 
 use sc_network_common::{
 	role::{ObservedRole, Roles},
 	types::ReputationChange,
 };
-use sc_network_types::PeerId;
+use sc_network_types::{
+	multiaddr::{Multiaddr, Protocol},
+	PeerId,
+};
 use sc_utils::mpsc::TracingUnboundedSender;
 
 use std::{
 	collections::{HashMap, HashSet},
 	sync::{atomic::Ordering, Arc},
+	time::Instant,
 };
 
 /// Logging target for the file.
@@ -165,10 +168,10 @@ pub struct Litep2pNetworkService {
 	request_response_protocols: HashMap<ProtocolName, TracingUnboundedSender<OutboundRequest>>,
 
 	/// Listen addresses.
-	listen_addresses: Arc<RwLock<HashSet<Multiaddr>>>,
+	listen_addresses: Arc<RwLock<HashSet<LiteP2pMultiaddr>>>,
 
 	/// External addresses.
-	external_addresses: Arc<RwLock<HashSet<Multiaddr>>>,
+	external_addresses: Arc<RwLock<HashSet<LiteP2pMultiaddr>>>,
 }
 
 impl Litep2pNetworkService {
@@ -181,8 +184,8 @@ impl Litep2pNetworkService {
 		peerset_handles: HashMap<ProtocolName, ProtocolControlHandle>,
 		block_announce_protocol: ProtocolName,
 		request_response_protocols: HashMap<ProtocolName, TracingUnboundedSender<OutboundRequest>>,
-		listen_addresses: Arc<RwLock<HashSet<Multiaddr>>>,
-		external_addresses: Arc<RwLock<HashSet<Multiaddr>>>,
+		listen_addresses: Arc<RwLock<HashSet<LiteP2pMultiaddr>>>,
+		external_addresses: Arc<RwLock<HashSet<LiteP2pMultiaddr>>>,
 	) -> Self {
 		Self {
 			local_peer_id,
@@ -234,6 +237,17 @@ impl NetworkDHTProvider for Litep2pNetworkService {
 	fn put_value(&self, key: KademliaKey, value: Vec<u8>) {
 		let _ = self.cmd_tx.unbounded_send(NetworkServiceCommand::PutValue { key, value });
 	}
+
+	fn store_record(
+		&self,
+		_key: KademliaKey,
+		_value: Vec<u8>,
+		_publisher: Option<PeerId>,
+		_expires: Option<Instant>,
+	) {
+		// Will be added once litep2p is released with: https://github.com/paritytech/litep2p/pull/135
+		log::warn!(target: LOG_TARGET, "Store record is not implemented for litep2p");
+	}
 }
 
 #[async_trait::async_trait]
@@ -322,7 +336,7 @@ impl NetworkPeers for Litep2pNetworkService {
 	fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String> {
 		let _ = self.cmd_tx.unbounded_send(NetworkServiceCommand::AddPeersToReservedSet {
 			protocol: self.block_announce_protocol.clone(),
-			peers: HashSet::from_iter([peer.concat()]),
+			peers: HashSet::from_iter([peer.concat().into()]),
 		});
 
 		Ok(())
@@ -415,11 +429,11 @@ impl NetworkEventStream for Litep2pNetworkService {
 
 impl NetworkStateInfo for Litep2pNetworkService {
 	fn external_addresses(&self) -> Vec<Multiaddr> {
-		self.external_addresses.read().iter().cloned().collect()
+		self.external_addresses.read().iter().cloned().map(Into::into).collect()
 	}
 
 	fn listen_addresses(&self) -> Vec<Multiaddr> {
-		self.listen_addresses.read().iter().cloned().collect()
+		self.listen_addresses.read().iter().cloned().map(Into::into).collect()
 	}
 
 	fn local_peer_id(&self) -> PeerId {
diff --git a/substrate/client/network/src/peer_store.rs b/substrate/client/network/src/peer_store.rs
index a4c739f1448e685aad34819b627333e4c250d957..987405500dc9b22e8a19d667cc4e1fe26f18c16d 100644
--- a/substrate/client/network/src/peer_store.rs
+++ b/substrate/client/network/src/peer_store.rs
@@ -19,8 +19,9 @@
 //! [`PeerStore`] manages peer reputations and provides connection candidates to
 //! [`crate::protocol_controller::ProtocolController`].
 
-use crate::{service::traits::PeerStore as PeerStoreT, PeerId};
+use crate::service::traits::PeerStore as PeerStoreT;
 
+use libp2p::PeerId;
 use log::trace;
 use parking_lot::Mutex;
 use partial_sort::PartialSort;
diff --git a/substrate/client/network/src/protocol/notifications/service/mod.rs b/substrate/client/network/src/protocol/notifications/service/mod.rs
index 15d289d170ee83e52476d4b5a1c5a10bde3274c8..4f6d32ae3b356f8813bb38cab5b80050f600931d 100644
--- a/substrate/client/network/src/protocol/notifications/service/mod.rs
+++ b/substrate/client/network/src/protocol/notifications/service/mod.rs
@@ -28,13 +28,13 @@ use crate::{
 		},
 	},
 	types::ProtocolName,
-	PeerId,
 };
 
 use futures::{
 	stream::{FuturesUnordered, Stream},
 	StreamExt,
 };
+use libp2p::PeerId;
 use parking_lot::Mutex;
 use tokio::sync::{mpsc, oneshot};
 use tokio_stream::wrappers::ReceiverStream;
diff --git a/substrate/client/network/src/protocol/notifications/service/tests.rs b/substrate/client/network/src/protocol/notifications/service/tests.rs
index f0157f6d28dd10d7382427b7464e4f478d912c03..32ccb3348adfbce266561645c75fea466023ed72 100644
--- a/substrate/client/network/src/protocol/notifications/service/tests.rs
+++ b/substrate/client/network/src/protocol/notifications/service/tests.rs
@@ -200,7 +200,7 @@ async fn send_async_notification_to_non_existent_peer() {
 	if let Err(error::Error::PeerDoesntExist(peer_id)) =
 		notif.send_async_notification(&peer.into(), vec![1, 3, 3, 7]).await
 	{
-		assert_eq!(peer, peer_id);
+		assert_eq!(peer, peer_id.into());
 	} else {
 		panic!("invalid error received from `send_async_notification()`");
 	}
diff --git a/substrate/client/network/src/protocol_controller.rs b/substrate/client/network/src/protocol_controller.rs
index 2c3e6744e328f3900790e747a3a8d998f4e6964e..da51a7a4f9f43f4ac68632a7701d62983f08ec26 100644
--- a/substrate/client/network/src/protocol_controller.rs
+++ b/substrate/client/network/src/protocol_controller.rs
@@ -41,12 +41,10 @@
 //! Even though this does not guarantee that `ProtocolController` and `Notifications` have the same
 //! view of the peers' states at any given moment, the eventual consistency is maintained.
 
-use crate::{
-	peer_store::{PeerStoreProvider, ProtocolHandle as ProtocolHandleT},
-	PeerId,
-};
+use crate::peer_store::{PeerStoreProvider, ProtocolHandle as ProtocolHandleT};
 
 use futures::{channel::oneshot, future::Either, FutureExt, StreamExt};
+use libp2p::PeerId;
 use log::{debug, error, trace, warn};
 use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
 use sp_arithmetic::traits::SaturatedConversion;
@@ -860,8 +858,9 @@ mod tests {
 	use super::*;
 	use crate::{
 		peer_store::{PeerStoreProvider, ProtocolHandle as ProtocolHandleT},
-		PeerId, ReputationChange,
+		ReputationChange,
 	};
+	use libp2p::PeerId;
 	use sc_network_common::role::ObservedRole;
 	use sc_utils::mpsc::{tracing_unbounded, TryRecvError};
 	use std::collections::HashSet;
diff --git a/substrate/client/network/src/service.rs b/substrate/client/network/src/service.rs
index 807c5b5a80afa682ef07b9ba2326a528b5d1c8f5..2cf4564e312c689a83b3d4ace09059e6e21547db 100644
--- a/substrate/client/network/src/service.rs
+++ b/substrate/client/network/src/service.rs
@@ -55,24 +55,26 @@ use crate::{
 	},
 	transport,
 	types::ProtocolName,
-	Multiaddr, NotificationService, PeerId, ReputationChange,
+	NotificationService, ReputationChange,
 };
 
 use codec::DecodeAll;
 use either::Either;
 use futures::{channel::oneshot, prelude::*};
+use libp2p::identity::ed25519;
 #[allow(deprecated)]
 use libp2p::{
 	connection_limits::Exceeded,
 	core::{upgrade, ConnectedPoint, Endpoint},
 	identify::Info as IdentifyInfo,
 	kad::record::Key as KademliaKey,
-	multiaddr,
+	multiaddr::{self, Multiaddr},
 	ping::Failure as PingFailure,
 	swarm::{
 		AddressScore, ConnectionError, ConnectionId, ConnectionLimits, DialError, Executor,
 		ListenError, NetworkBehaviour, Swarm, SwarmBuilder, SwarmEvent, THandlerErr,
 	},
+	PeerId,
 };
 use log::{debug, error, info, trace, warn};
 use metrics::{Histogram, MetricSources, Metrics};
@@ -87,6 +89,10 @@ use sc_network_common::{
 use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
 use sp_runtime::traits::Block as BlockT;
 
+pub use behaviour::{InboundFailure, OutboundFailure, ResponseFailure};
+pub use libp2p::identity::{DecodingError, Keypair, PublicKey};
+pub use metrics::NotificationMetrics;
+pub use protocol::NotificationsSink;
 use std::{
 	cmp,
 	collections::{HashMap, HashSet},
@@ -99,14 +105,9 @@ use std::{
 		atomic::{AtomicUsize, Ordering},
 		Arc,
 	},
-	time::Duration,
+	time::{Duration, Instant},
 };
 
-pub use behaviour::{InboundFailure, OutboundFailure, ResponseFailure};
-pub use libp2p::identity::{DecodingError, Keypair, PublicKey};
-pub use metrics::NotificationMetrics;
-pub use protocol::NotificationsSink;
-
 pub(crate) mod metrics;
 pub(crate) mod out_events;
 
@@ -269,6 +270,15 @@ where
 		let local_public = local_identity.public();
 		let local_peer_id = local_public.to_peer_id();
 
+		// Convert to libp2p types.
+		let local_identity: ed25519::Keypair = local_identity.into();
+		let local_public: ed25519::PublicKey = local_public.into();
+		let local_peer_id: PeerId = local_peer_id.into();
+		let listen_addresses: Vec<Multiaddr> =
+			network_config.listen_addresses.iter().cloned().map(Into::into).collect();
+		let public_addresses: Vec<Multiaddr> =
+			network_config.public_addresses.iter().cloned().map(Into::into).collect();
+
 		network_config.boot_nodes = network_config
 			.boot_nodes
 			.into_iter()
@@ -370,7 +380,7 @@ where
 			};
 
 			transport::build_transport(
-				local_identity.clone(),
+				local_identity.clone().into(),
 				config_mem,
 				network_config.yamux_window_size,
 				yamux_maximum_buffer_size,
@@ -462,7 +472,7 @@ where
 				.find(|o| o.peer_id != bootnode.peer_id)
 			{
 				Err(Error::DuplicateBootnode {
-					address: bootnode.multiaddr.clone(),
+					address: bootnode.multiaddr.clone().into(),
 					first_id: bootnode.peer_id.into(),
 					second_id: other.peer_id.into(),
 				})
@@ -478,7 +488,7 @@ where
 			boot_node_ids
 				.entry(bootnode.peer_id.into())
 				.or_default()
-				.push(bootnode.multiaddr.clone());
+				.push(bootnode.multiaddr.clone().into());
 		}
 
 		let boot_node_ids = Arc::new(boot_node_ids);
@@ -502,11 +512,11 @@ where
 				format!("{} ({})", network_config.client_version, network_config.node_name);
 
 			let discovery_config = {
-				let mut config = DiscoveryConfig::new(local_public.to_peer_id());
+				let mut config = DiscoveryConfig::new(local_peer_id);
 				config.with_permanent_addresses(
 					known_addresses
 						.iter()
-						.map(|(peer, address)| (peer.into(), address.clone()))
+						.map(|(peer, address)| (peer.into(), address.clone().into()))
 						.collect::<Vec<_>>(),
 				);
 				config.discovery_limit(u64::from(network_config.default_peers_set.out_peers) + 15);
@@ -544,7 +554,7 @@ where
 				let result = Behaviour::new(
 					protocol,
 					user_agent,
-					local_public,
+					local_public.into(),
 					discovery_config,
 					request_response_protocols,
 					Arc::clone(&peer_store_handle),
@@ -581,7 +591,7 @@ where
 							crate::MAX_CONNECTIONS_ESTABLISHED_INCOMING,
 						)),
 				)
-				.substream_upgrade_protocol_override(upgrade::Version::V1Lazy)
+				.substream_upgrade_protocol_override(upgrade::Version::V1)
 				.notify_handler_buffer_size(NonZeroUsize::new(32).expect("32 != 0; qed"))
 				// NOTE: 24 is somewhat arbitrary and should be tuned in the future if necessary.
 				// See <https://github.com/paritytech/substrate/pull/6080>
@@ -604,14 +614,14 @@ where
 		};
 
 		// Listen on multiaddresses.
-		for addr in &network_config.listen_addresses {
+		for addr in &listen_addresses {
 			if let Err(err) = Swarm::<Behaviour<B>>::listen_on(&mut swarm, addr.clone()) {
 				warn!(target: "sub-libp2p", "Can't listen on {} because: {:?}", addr, err)
 			}
 		}
 
 		// Add external addresses.
-		for addr in &network_config.public_addresses {
+		for addr in &public_addresses {
 			Swarm::<Behaviour<B>>::add_external_address(
 				&mut swarm,
 				addr.clone(),
@@ -619,15 +629,15 @@ where
 			);
 		}
 
-		let listen_addresses = Arc::new(Mutex::new(HashSet::new()));
+		let listen_addresses_set = Arc::new(Mutex::new(HashSet::new()));
 
 		let service = Arc::new(NetworkService {
 			bandwidth,
 			external_addresses,
-			listen_addresses: listen_addresses.clone(),
+			listen_addresses: listen_addresses_set.clone(),
 			num_connected: num_connected.clone(),
 			local_peer_id,
-			local_identity,
+			local_identity: local_identity.into(),
 			to_worker,
 			notification_protocol_ids,
 			protocol_handles,
@@ -638,7 +648,7 @@ where
 		});
 
 		Ok(NetworkWorker {
-			listen_addresses,
+			listen_addresses: listen_addresses_set,
 			num_connected,
 			network_service: swarm,
 			service,
@@ -880,13 +890,13 @@ where
 	H: ExHashT,
 {
 	/// Returns the local external addresses.
-	fn external_addresses(&self) -> Vec<Multiaddr> {
-		self.external_addresses.lock().iter().cloned().collect()
+	fn external_addresses(&self) -> Vec<sc_network_types::multiaddr::Multiaddr> {
+		self.external_addresses.lock().iter().cloned().map(Into::into).collect()
 	}
 
 	/// Returns the listener addresses (without trailing `/p2p/` with our `PeerId`).
-	fn listen_addresses(&self) -> Vec<Multiaddr> {
-		self.listen_addresses.lock().iter().cloned().collect()
+	fn listen_addresses(&self) -> Vec<sc_network_types::multiaddr::Multiaddr> {
+		self.listen_addresses.lock().iter().cloned().map(Into::into).collect()
 	}
 
 	/// Returns the local Peer ID.
@@ -946,6 +956,21 @@ where
 	fn put_value(&self, key: KademliaKey, value: Vec<u8>) {
 		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::PutValue(key, value));
 	}
+
+	fn store_record(
+		&self,
+		key: KademliaKey,
+		value: Vec<u8>,
+		publisher: Option<sc_network_types::PeerId>,
+		expires: Option<Instant>,
+	) {
+		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::StoreRecord(
+			key,
+			value,
+			publisher.map(Into::into),
+			expires,
+		));
+	}
 }
 
 #[async_trait::async_trait]
@@ -998,10 +1023,14 @@ where
 		self.sync_protocol_handle.set_reserved_only(reserved_only);
 	}
 
-	fn add_known_address(&self, peer_id: sc_network_types::PeerId, addr: Multiaddr) {
+	fn add_known_address(
+		&self,
+		peer_id: sc_network_types::PeerId,
+		addr: sc_network_types::multiaddr::Multiaddr,
+	) {
 		let _ = self
 			.to_worker
-			.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(peer_id.into(), addr));
+			.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(peer_id.into(), addr.into()));
 	}
 
 	fn report_peer(&self, peer_id: sc_network_types::PeerId, cost_benefit: ReputationChange) {
@@ -1034,7 +1063,7 @@ where
 
 		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(
 			peer.peer_id.into(),
-			peer.multiaddr,
+			peer.multiaddr.into(),
 		));
 		self.sync_protocol_handle.add_reserved_peer(peer.peer_id.into());
 
@@ -1048,16 +1077,16 @@ where
 	fn set_reserved_peers(
 		&self,
 		protocol: ProtocolName,
-		peers: HashSet<Multiaddr>,
+		peers: HashSet<sc_network_types::multiaddr::Multiaddr>,
 	) -> Result<(), String> {
 		let Some(set_id) = self.notification_protocol_ids.get(&protocol) else {
 			return Err(format!("Cannot set reserved peers for unknown protocol: {}", protocol))
 		};
 
+		let peers: HashSet<Multiaddr> = peers.into_iter().map(Into::into).collect();
 		let peers_addrs = self.split_multiaddr_and_peer_id(peers)?;
 
-		let mut peers: HashSet<sc_network_types::PeerId> =
-			HashSet::with_capacity(peers_addrs.len());
+		let mut peers: HashSet<PeerId> = HashSet::with_capacity(peers_addrs.len());
 
 		for (peer_id, addr) in peers_addrs.into_iter() {
 			// Make sure the local peer ID is never added to the PSM.
@@ -1074,8 +1103,7 @@ where
 			}
 		}
 
-		self.protocol_handles[usize::from(*set_id)]
-			.set_reserved_peers(peers.iter().map(|peer| (*peer).into()).collect());
+		self.protocol_handles[usize::from(*set_id)].set_reserved_peers(peers);
 
 		Ok(())
 	}
@@ -1083,7 +1111,7 @@ where
 	fn add_peers_to_reserved_set(
 		&self,
 		protocol: ProtocolName,
-		peers: HashSet<Multiaddr>,
+		peers: HashSet<sc_network_types::multiaddr::Multiaddr>,
 	) -> Result<(), String> {
 		let Some(set_id) = self.notification_protocol_ids.get(&protocol) else {
 			return Err(format!(
@@ -1092,6 +1120,7 @@ where
 			))
 		};
 
+		let peers: HashSet<Multiaddr> = peers.into_iter().map(Into::into).collect();
 		let peers = self.split_multiaddr_and_peer_id(peers)?;
 
 		for (peer_id, addr) in peers.into_iter() {
@@ -1296,6 +1325,7 @@ impl<'a> NotificationSenderReadyT for NotificationSenderReady<'a> {
 enum ServiceToWorkerMsg {
 	GetValue(KademliaKey),
 	PutValue(KademliaKey, Vec<u8>),
+	StoreRecord(KademliaKey, Vec<u8>, Option<PeerId>, Option<Instant>),
 	AddKnownAddress(PeerId, Multiaddr),
 	EventStream(out_events::Sender),
 	Request {
@@ -1423,6 +1453,10 @@ where
 				self.network_service.behaviour_mut().get_value(key),
 			ServiceToWorkerMsg::PutValue(key, value) =>
 				self.network_service.behaviour_mut().put_value(key, value),
+			ServiceToWorkerMsg::StoreRecord(key, value, publisher, expires) => self
+				.network_service
+				.behaviour_mut()
+				.store_record(key, value, publisher, expires),
 			ServiceToWorkerMsg::AddKnownAddress(peer_id, addr) =>
 				self.network_service.behaviour_mut().add_known_address(peer_id, addr),
 			ServiceToWorkerMsg::EventStream(sender) => self.event_streams.push(sender),
@@ -1624,17 +1658,21 @@ where
 					.report_notification_received(remote, notification);
 			},
 			SwarmEvent::Behaviour(BehaviourOut::Dht(event, duration)) => {
-				if let Some(metrics) = self.metrics.as_ref() {
-					let query_type = match event {
-						DhtEvent::ValueFound(_) => "value-found",
-						DhtEvent::ValueNotFound(_) => "value-not-found",
-						DhtEvent::ValuePut(_) => "value-put",
-						DhtEvent::ValuePutFailed(_) => "value-put-failed",
-					};
-					metrics
-						.kademlia_query_duration
-						.with_label_values(&[query_type])
-						.observe(duration.as_secs_f64());
+				match (self.metrics.as_ref(), duration) {
+					(Some(metrics), Some(duration)) => {
+						let query_type = match event {
+							DhtEvent::ValueFound(_) => "value-found",
+							DhtEvent::ValueNotFound(_) => "value-not-found",
+							DhtEvent::ValuePut(_) => "value-put",
+							DhtEvent::ValuePutFailed(_) => "value-put-failed",
+							DhtEvent::PutRecordRequest(_, _, _, _) => "put-record-request",
+						};
+						metrics
+							.kademlia_query_duration
+							.with_label_values(&[query_type])
+							.observe(duration.as_secs_f64());
+					},
+					_ => {},
 				}
 
 				self.event_streams.send(Event::Dht(event));
@@ -1723,8 +1761,8 @@ where
 					{
 						if let DialError::WrongPeerId { obtained, endpoint } = &error {
 							if let ConnectedPoint::Dialer { address, role_override: _ } = endpoint {
-								let address_without_peer_id = parse_addr(address.clone())
-									.map_or_else(|_| address.clone(), |r| r.1);
+								let address_without_peer_id = parse_addr(address.clone().into())
+									.map_or_else(|_| address.clone(), |r| r.1.into());
 
 								// Only report for address of boot node that was added at startup of
 								// the node and not for any address that the node learned of the
@@ -1860,14 +1898,14 @@ where
 }
 
 pub(crate) fn ensure_addresses_consistent_with_transport<'a>(
-	addresses: impl Iterator<Item = &'a Multiaddr>,
+	addresses: impl Iterator<Item = &'a sc_network_types::multiaddr::Multiaddr>,
 	transport: &TransportConfig,
 ) -> Result<(), Error> {
+	use sc_network_types::multiaddr::Protocol;
+
 	if matches!(transport, TransportConfig::MemoryOnly) {
 		let addresses: Vec<_> = addresses
-			.filter(|x| {
-				x.iter().any(|y| !matches!(y, libp2p::core::multiaddr::Protocol::Memory(_)))
-			})
+			.filter(|x| x.iter().any(|y| !matches!(y, Protocol::Memory(_))))
 			.cloned()
 			.collect();
 
@@ -1879,7 +1917,7 @@ pub(crate) fn ensure_addresses_consistent_with_transport<'a>(
 		}
 	} else {
 		let addresses: Vec<_> = addresses
-			.filter(|x| x.iter().any(|y| matches!(y, libp2p::core::multiaddr::Protocol::Memory(_))))
+			.filter(|x| x.iter().any(|y| matches!(y, Protocol::Memory(_))))
 			.cloned()
 			.collect();
 
diff --git a/substrate/client/network/src/service/traits.rs b/substrate/client/network/src/service/traits.rs
index 9bbaeb1026f9304d43d347893de5795fd0bb93b4..fe06141f7e3b8cb29407c944847940e7fe2c8fb7 100644
--- a/substrate/client/network/src/service/traits.rs
+++ b/substrate/client/network/src/service/traits.rs
@@ -28,7 +28,7 @@ use crate::{
 	request_responses::{IfDisconnected, RequestFailure},
 	service::{metrics::NotificationMetrics, signature::Signature, PeerStoreProvider},
 	types::ProtocolName,
-	Multiaddr, ReputationChange,
+	ReputationChange,
 };
 
 use futures::{channel::oneshot, Stream};
@@ -36,10 +36,17 @@ use prometheus_endpoint::Registry;
 
 use sc_client_api::BlockBackend;
 use sc_network_common::{role::ObservedRole, ExHashT};
-use sc_network_types::PeerId;
+use sc_network_types::{multiaddr::Multiaddr, PeerId};
 use sp_runtime::traits::Block as BlockT;
 
-use std::{collections::HashSet, fmt::Debug, future::Future, pin::Pin, sync::Arc, time::Duration};
+use std::{
+	collections::HashSet,
+	fmt::Debug,
+	future::Future,
+	pin::Pin,
+	sync::Arc,
+	time::{Duration, Instant},
+};
 
 pub use libp2p::{identity::SigningError, kad::record::Key as KademliaKey};
 
@@ -209,6 +216,15 @@ pub trait NetworkDHTProvider {
 
 	/// Start putting a value in the DHT.
 	fn put_value(&self, key: KademliaKey, value: Vec<u8>);
+
+	/// Store a record in the DHT memory store.
+	fn store_record(
+		&self,
+		key: KademliaKey,
+		value: Vec<u8>,
+		publisher: Option<PeerId>,
+		expires: Option<Instant>,
+	);
 }
 
 impl<T> NetworkDHTProvider for Arc<T>
@@ -223,6 +239,16 @@ where
 	fn put_value(&self, key: KademliaKey, value: Vec<u8>) {
 		T::put_value(self, key, value)
 	}
+
+	fn store_record(
+		&self,
+		key: KademliaKey,
+		value: Vec<u8>,
+		publisher: Option<PeerId>,
+		expires: Option<Instant>,
+	) {
+		T::store_record(self, key, value, publisher, expires)
+	}
 }
 
 /// Provides an ability to set a fork sync request for a particular block.
diff --git a/substrate/client/network/sync/src/service/mock.rs b/substrate/client/network/sync/src/service/mock.rs
index 2e7e12af53d5373f4335361a108cd3980c7c3dcb..141edc7c884144455e43f5b7c5b2b62ae246bbab 100644
--- a/substrate/client/network/sync/src/service/mock.rs
+++ b/substrate/client/network/sync/src/service/mock.rs
@@ -23,10 +23,10 @@ use sc_network::{
 	config::MultiaddrWithPeerId,
 	request_responses::{IfDisconnected, RequestFailure},
 	types::ProtocolName,
-	Multiaddr, NetworkPeers, NetworkRequest, NetworkSyncForkRequest, ReputationChange,
+	NetworkPeers, NetworkRequest, NetworkSyncForkRequest, ReputationChange,
 };
 use sc_network_common::role::ObservedRole;
-use sc_network_types::PeerId;
+use sc_network_types::{multiaddr::Multiaddr, PeerId};
 use sp_runtime::traits::{Block as BlockT, NumberFor};
 
 use std::collections::HashSet;
diff --git a/substrate/client/network/test/src/fuzz.rs b/substrate/client/network/test/src/fuzz.rs
index 69d08d47d26a9ea4368ffdfea456711345d15d8b..b0cd6dcf999391a0fedd5a29a38b89d370e25771 100644
--- a/substrate/client/network/test/src/fuzz.rs
+++ b/substrate/client/network/test/src/fuzz.rs
@@ -20,6 +20,7 @@
 //! and `PeerStore` to discover possible inconsistencies in peer management.
 
 use futures::prelude::*;
+use libp2p::PeerId;
 use rand::{
 	distributions::{Distribution, Uniform, WeightedIndex},
 	seq::IteratorRandom,
@@ -27,7 +28,7 @@ use rand::{
 use sc_network::{
 	peer_store::{PeerStore, PeerStoreProvider},
 	protocol_controller::{IncomingIndex, Message, ProtoSetConfig, ProtocolController, SetId},
-	PeerId, ReputationChange,
+	ReputationChange,
 };
 use sc_utils::mpsc::tracing_unbounded;
 use std::{
diff --git a/substrate/client/network/test/src/lib.rs b/substrate/client/network/test/src/lib.rs
index 48a4b3d6e6e16a4281c6e504d1c0d9511d2eb677..8a8f9608051af0bcb523b405585ad7c0b81b4ae2 100644
--- a/substrate/client/network/test/src/lib.rs
+++ b/substrate/client/network/test/src/lib.rs
@@ -35,7 +35,7 @@ use std::{
 };
 
 use futures::{channel::oneshot, future::BoxFuture, pin_mut, prelude::*};
-use libp2p::{build_multiaddr, PeerId};
+use libp2p::PeerId;
 use log::trace;
 use parking_lot::Mutex;
 use sc_block_builder::{BlockBuilder, BlockBuilderBuilder};
@@ -57,8 +57,8 @@ use sc_network::{
 	peer_store::PeerStore,
 	request_responses::ProtocolConfig as RequestResponseConfig,
 	types::ProtocolName,
-	Multiaddr, NetworkBlock, NetworkService, NetworkStateInfo, NetworkSyncForkRequest,
-	NetworkWorker, NotificationMetrics, NotificationService,
+	NetworkBlock, NetworkService, NetworkStateInfo, NetworkSyncForkRequest, NetworkWorker,
+	NotificationMetrics, NotificationService,
 };
 use sc_network_common::role::Roles;
 use sc_network_light::light_client_requests::handler::LightClientRequestHandler;
@@ -71,6 +71,7 @@ use sc_network_sync::{
 	},
 	warp_request_handler,
 };
+use sc_network_types::{build_multiaddr, multiaddr::Multiaddr};
 use sc_service::client::Client;
 use sp_blockchain::{
 	Backend as BlockchainBackend, HeaderBackend, Info as BlockchainInfo, Result as ClientResult,
@@ -985,7 +986,7 @@ pub trait TestNetFactory: Default + Sized + Send {
 			for peer in peers.iter_mut() {
 				peer.network.add_known_address(
 					network.service().local_peer_id().into(),
-					listen_addr.clone(),
+					listen_addr.clone().into(),
 				);
 			}
 
diff --git a/substrate/client/network/types/Cargo.toml b/substrate/client/network/types/Cargo.toml
index 8815ccdca3c02c07815dcc699258cac90429c260..a9334aaa1705987a35322921616188113f011ed8 100644
--- a/substrate/client/network/types/Cargo.toml
+++ b/substrate/client/network/types/Cargo.toml
@@ -11,9 +11,14 @@ documentation = "https://docs.rs/sc-network-types"
 
 [dependencies]
 bs58 = "0.5.0"
+ed25519-dalek = "2.1"
 libp2p-identity = { version = "0.1.3", features = ["ed25519", "peerid"] }
-litep2p = { git = "https://github.com/paritytech/litep2p", rev = "e03a6023882db111beeb24d8c0ceaac0721d3f0f" }
+litep2p = "0.5.0"
 multiaddr = "0.17.0"
 multihash = { version = "0.17.0", default-features = false, features = ["identity", "multihash-impl", "sha2", "std"] }
 rand = "0.8.5"
 thiserror = "1.0.48"
+zeroize = { version = "1.7.0", default-features = false }
+
+[dev-dependencies]
+quickcheck = "1.0.3"
diff --git a/substrate/client/network/types/src/ed25519.rs b/substrate/client/network/types/src/ed25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e85f405b13066b8be1eed82f8ca783aa62c777d9
--- /dev/null
+++ b/substrate/client/network/types/src/ed25519.rs
@@ -0,0 +1,551 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+//! Ed25519 keys.
+
+use crate::PeerId;
+use core::{cmp, fmt, hash};
+use ed25519_dalek::{self as ed25519, Signer as _, Verifier as _};
+use libp2p_identity::ed25519 as libp2p_ed25519;
+use litep2p::crypto::ed25519 as litep2p_ed25519;
+use zeroize::Zeroize;
+
+/// An Ed25519 keypair.
+#[derive(Clone)]
+pub struct Keypair(ed25519::SigningKey);
+
+impl Keypair {
+	/// Generate a new random Ed25519 keypair.
+	pub fn generate() -> Keypair {
+		Keypair::from(SecretKey::generate())
+	}
+
+	/// Convert the keypair into a byte array by concatenating the bytes
+	/// of the secret scalar and the compressed public point,
+	/// an informal standard for encoding Ed25519 keypairs.
+	pub fn to_bytes(&self) -> [u8; 64] {
+		self.0.to_keypair_bytes()
+	}
+
+	/// Try to parse a keypair from the [binary format](https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.5)
+	/// produced by [`Keypair::to_bytes`], zeroing the input on success.
+	///
+	/// Note that this binary format is the same as `ed25519_dalek`'s and `ed25519_zebra`'s.
+	pub fn try_from_bytes(kp: &mut [u8]) -> Result<Keypair, DecodingError> {
+		let bytes = <[u8; 64]>::try_from(&*kp)
+			.map_err(|e| DecodingError::KeypairParseError(Box::new(e)))?;
+
+		ed25519::SigningKey::from_keypair_bytes(&bytes)
+			.map(|k| {
+				kp.zeroize();
+				Keypair(k)
+			})
+			.map_err(|e| DecodingError::KeypairParseError(Box::new(e)))
+	}
+
+	/// Sign a message using the private key of this keypair.
+	pub fn sign(&self, msg: &[u8]) -> Vec<u8> {
+		self.0.sign(msg).to_bytes().to_vec()
+	}
+
+	/// Get the public key of this keypair.
+	pub fn public(&self) -> PublicKey {
+		PublicKey(self.0.verifying_key())
+	}
+
+	/// Get the secret key of this keypair.
+	pub fn secret(&self) -> SecretKey {
+		SecretKey(self.0.to_bytes())
+	}
+}
+
+impl fmt::Debug for Keypair {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("Keypair").field("public", &self.0.verifying_key()).finish()
+	}
+}
+
+impl From<litep2p_ed25519::Keypair> for Keypair {
+	fn from(kp: litep2p_ed25519::Keypair) -> Self {
+		Self::try_from_bytes(&mut kp.encode())
+			.expect("ed25519_dalek in substrate & litep2p to use the same format")
+	}
+}
+
+impl From<Keypair> for litep2p_ed25519::Keypair {
+	fn from(kp: Keypair) -> Self {
+		Self::decode(&mut kp.to_bytes())
+			.expect("ed25519_dalek in substrate & litep2p to use the same format")
+	}
+}
+
+impl From<libp2p_ed25519::Keypair> for Keypair {
+	fn from(kp: libp2p_ed25519::Keypair) -> Self {
+		Self::try_from_bytes(&mut kp.to_bytes())
+			.expect("ed25519_dalek in substrate & libp2p to use the same format")
+	}
+}
+
+impl From<Keypair> for libp2p_ed25519::Keypair {
+	fn from(kp: Keypair) -> Self {
+		Self::try_from_bytes(&mut kp.to_bytes())
+			.expect("ed25519_dalek in substrate & libp2p to use the same format")
+	}
+}
+
+/// Demote an Ed25519 keypair to a secret key.
+impl From<Keypair> for SecretKey {
+	fn from(kp: Keypair) -> SecretKey {
+		SecretKey(kp.0.to_bytes())
+	}
+}
+
+/// Promote an Ed25519 secret key into a keypair.
+impl From<SecretKey> for Keypair {
+	fn from(sk: SecretKey) -> Keypair {
+		let signing = ed25519::SigningKey::from_bytes(&sk.0);
+		Keypair(signing)
+	}
+}
+
+/// An Ed25519 public key.
+#[derive(Eq, Clone)]
+pub struct PublicKey(ed25519::VerifyingKey);
+
+impl fmt::Debug for PublicKey {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.write_str("PublicKey(compressed): ")?;
+		for byte in self.0.as_bytes() {
+			write!(f, "{byte:x}")?;
+		}
+		Ok(())
+	}
+}
+
+impl cmp::PartialEq for PublicKey {
+	fn eq(&self, other: &Self) -> bool {
+		self.0.as_bytes().eq(other.0.as_bytes())
+	}
+}
+
+impl hash::Hash for PublicKey {
+	fn hash<H: hash::Hasher>(&self, state: &mut H) {
+		self.0.as_bytes().hash(state);
+	}
+}
+
+impl cmp::PartialOrd for PublicKey {
+	fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl cmp::Ord for PublicKey {
+	fn cmp(&self, other: &Self) -> cmp::Ordering {
+		self.0.as_bytes().cmp(other.0.as_bytes())
+	}
+}
+
+impl PublicKey {
+	/// Verify the Ed25519 signature on a message using the public key.
+	pub fn verify(&self, msg: &[u8], sig: &[u8]) -> bool {
+		ed25519::Signature::try_from(sig).and_then(|s| self.0.verify(msg, &s)).is_ok()
+	}
+
+	/// Convert the public key to a byte array in compressed form, i.e.
+	/// where one coordinate is represented by a single bit.
+	pub fn to_bytes(&self) -> [u8; 32] {
+		self.0.to_bytes()
+	}
+
+	/// Try to parse a public key from a byte array containing the actual key as produced by
+	/// `to_bytes`.
+	pub fn try_from_bytes(k: &[u8]) -> Result<PublicKey, DecodingError> {
+		let k =
+			<[u8; 32]>::try_from(k).map_err(|e| DecodingError::PublicKeyParseError(Box::new(e)))?;
+		ed25519::VerifyingKey::from_bytes(&k)
+			.map_err(|e| DecodingError::PublicKeyParseError(Box::new(e)))
+			.map(PublicKey)
+	}
+
+	/// Convert public key to `PeerId`.
+	pub fn to_peer_id(&self) -> PeerId {
+		litep2p::PeerId::from(litep2p::crypto::PublicKey::Ed25519(self.clone().into())).into()
+	}
+}
+
+impl From<litep2p_ed25519::PublicKey> for PublicKey {
+	fn from(k: litep2p_ed25519::PublicKey) -> Self {
+		Self::try_from_bytes(&k.encode())
+			.expect("ed25519_dalek in substrate & litep2p to use the same format")
+	}
+}
+
+impl From<PublicKey> for litep2p_ed25519::PublicKey {
+	fn from(k: PublicKey) -> Self {
+		Self::decode(&k.to_bytes())
+			.expect("ed25519_dalek in substrate & litep2p to use the same format")
+	}
+}
+
+impl From<libp2p_ed25519::PublicKey> for PublicKey {
+	fn from(k: libp2p_ed25519::PublicKey) -> Self {
+		Self::try_from_bytes(&k.to_bytes())
+			.expect("ed25519_dalek in substrate & libp2p to use the same format")
+	}
+}
+
+impl From<PublicKey> for libp2p_ed25519::PublicKey {
+	fn from(k: PublicKey) -> Self {
+		Self::try_from_bytes(&k.to_bytes())
+			.expect("ed25519_dalek in substrate & libp2p to use the same format")
+	}
+}
+
+/// An Ed25519 secret key.
+#[derive(Clone)]
+pub struct SecretKey(ed25519::SecretKey);
+
+/// View the bytes of the secret key.
+impl AsRef<[u8]> for SecretKey {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl fmt::Debug for SecretKey {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "SecretKey")
+	}
+}
+
+impl SecretKey {
+	/// Generate a new Ed25519 secret key.
+	pub fn generate() -> SecretKey {
+		let signing = ed25519::SigningKey::generate(&mut rand::rngs::OsRng);
+		SecretKey(signing.to_bytes())
+	}
+
+	/// Try to parse an Ed25519 secret key from a byte slice
+	/// containing the actual key, zeroing the input on success.
+	/// If the bytes do not constitute a valid Ed25519 secret key, an error is
+	/// returned.
+	pub fn try_from_bytes(mut sk_bytes: impl AsMut<[u8]>) -> Result<SecretKey, DecodingError> {
+		let sk_bytes = sk_bytes.as_mut();
+		let secret = <[u8; 32]>::try_from(&*sk_bytes)
+			.map_err(|e| DecodingError::SecretKeyParseError(Box::new(e)))?;
+		sk_bytes.zeroize();
+		Ok(SecretKey(secret))
+	}
+
+	pub fn to_bytes(&self) -> [u8; 32] {
+		self.0
+	}
+}
+
+impl Drop for SecretKey {
+	fn drop(&mut self) {
+		self.0.zeroize();
+	}
+}
+
+impl From<litep2p_ed25519::SecretKey> for SecretKey {
+	fn from(sk: litep2p_ed25519::SecretKey) -> Self {
+		Self::try_from_bytes(&mut sk.to_bytes()).expect("Ed25519 key to be 32 bytes length")
+	}
+}
+
+impl From<SecretKey> for litep2p_ed25519::SecretKey {
+	fn from(sk: SecretKey) -> Self {
+		Self::from_bytes(&mut sk.to_bytes())
+			.expect("litep2p `SecretKey` to accept 32 bytes as Ed25519 key")
+	}
+}
+
+impl From<libp2p_ed25519::SecretKey> for SecretKey {
+	fn from(sk: libp2p_ed25519::SecretKey) -> Self {
+		Self::try_from_bytes(&mut sk.as_ref().to_owned())
+			.expect("Ed25519 key to be 32 bytes length")
+	}
+}
+
+impl From<SecretKey> for libp2p_ed25519::SecretKey {
+	fn from(sk: SecretKey) -> Self {
+		Self::try_from_bytes(&mut sk.to_bytes())
+			.expect("libp2p `SecretKey` to accept 32 bytes as Ed25519 key")
+	}
+}
+
+/// Error when decoding `ed25519`-related types.
+#[derive(Debug, thiserror::Error)]
+pub enum DecodingError {
+	#[error("failed to parse Ed25519 keypair: {0}")]
+	KeypairParseError(Box<dyn std::error::Error + Send + Sync>),
+	#[error("failed to parse Ed25519 secret key: {0}")]
+	SecretKeyParseError(Box<dyn std::error::Error + Send + Sync>),
+	#[error("failed to parse Ed25519 public key: {0}")]
+	PublicKeyParseError(Box<dyn std::error::Error + Send + Sync>),
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use quickcheck::*;
+
+	fn eq_keypairs(kp1: &Keypair, kp2: &Keypair) -> bool {
+		kp1.public() == kp2.public() && kp1.0.to_bytes() == kp2.0.to_bytes()
+	}
+
+	#[test]
+	fn ed25519_keypair_encode_decode() {
+		fn prop() -> bool {
+			let kp1 = Keypair::generate();
+			let mut kp1_enc = kp1.to_bytes();
+			let kp2 = Keypair::try_from_bytes(&mut kp1_enc).unwrap();
+			eq_keypairs(&kp1, &kp2) && kp1_enc.iter().all(|b| *b == 0)
+		}
+		QuickCheck::new().tests(10).quickcheck(prop as fn() -> _);
+	}
+
+	#[test]
+	fn ed25519_keypair_from_secret() {
+		fn prop() -> bool {
+			let kp1 = Keypair::generate();
+			let mut sk = kp1.0.to_bytes();
+			let kp2 = Keypair::from(SecretKey::try_from_bytes(&mut sk).unwrap());
+			eq_keypairs(&kp1, &kp2) && sk == [0u8; 32]
+		}
+		QuickCheck::new().tests(10).quickcheck(prop as fn() -> _);
+	}
+
+	#[test]
+	fn ed25519_signature() {
+		let kp = Keypair::generate();
+		let pk = kp.public();
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+		assert!(pk.verify(msg, &sig));
+
+		let mut invalid_sig = sig.clone();
+		invalid_sig[3..6].copy_from_slice(&[10, 23, 42]);
+		assert!(!pk.verify(msg, &invalid_sig));
+
+		let invalid_msg = "h3ll0 w0rld".as_bytes();
+		assert!(!pk.verify(invalid_msg, &sig));
+	}
+
+	#[test]
+	fn substrate_kp_to_libs() {
+		let kp = Keypair::generate();
+		let kp_bytes = kp.to_bytes();
+		let kp1: libp2p_ed25519::Keypair = kp.clone().into();
+		let kp2: litep2p_ed25519::Keypair = kp.clone().into();
+		let kp3 = libp2p_ed25519::Keypair::try_from_bytes(&mut kp_bytes.clone()).unwrap();
+		let kp4 = litep2p_ed25519::Keypair::decode(&mut kp_bytes.clone()).unwrap();
+
+		assert_eq!(kp_bytes, kp1.to_bytes());
+		assert_eq!(kp_bytes, kp2.encode());
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+		let sig1 = kp1.sign(msg);
+		let sig2 = kp2.sign(msg);
+		let sig3 = kp3.sign(msg);
+		let sig4 = kp4.sign(msg);
+
+		assert_eq!(sig, sig1);
+		assert_eq!(sig, sig2);
+		assert_eq!(sig, sig3);
+		assert_eq!(sig, sig4);
+
+		let pk1 = kp1.public();
+		let pk2 = kp2.public();
+		let pk3 = kp3.public();
+		let pk4 = kp4.public();
+
+		assert!(pk1.verify(msg, &sig));
+		assert!(pk2.verify(msg, &sig));
+		assert!(pk3.verify(msg, &sig));
+		assert!(pk4.verify(msg, &sig));
+	}
+
+	#[test]
+	fn litep2p_kp_to_substrate_kp() {
+		let kp = litep2p_ed25519::Keypair::generate();
+		let kp1: Keypair = kp.clone().into();
+		let kp2 = Keypair::try_from_bytes(&mut kp.encode()).unwrap();
+
+		assert_eq!(kp.encode(), kp1.to_bytes());
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+		let sig1 = kp1.sign(msg);
+		let sig2 = kp2.sign(msg);
+
+		assert_eq!(sig, sig1);
+		assert_eq!(sig, sig2);
+
+		let pk1 = kp1.public();
+		let pk2 = kp2.public();
+
+		assert!(pk1.verify(msg, &sig));
+		assert!(pk2.verify(msg, &sig));
+	}
+
+	#[test]
+	fn libp2p_kp_to_substrate_kp() {
+		let kp = libp2p_ed25519::Keypair::generate();
+		let kp1: Keypair = kp.clone().into();
+		let kp2 = Keypair::try_from_bytes(&mut kp.to_bytes()).unwrap();
+
+		assert_eq!(kp.to_bytes(), kp1.to_bytes());
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+		let sig1 = kp1.sign(msg);
+		let sig2 = kp2.sign(msg);
+
+		assert_eq!(sig, sig1);
+		assert_eq!(sig, sig2);
+
+		let pk1 = kp1.public();
+		let pk2 = kp2.public();
+
+		assert!(pk1.verify(msg, &sig));
+		assert!(pk2.verify(msg, &sig));
+	}
+
+	#[test]
+	fn substrate_pk_to_libs() {
+		let kp = Keypair::generate();
+		let pk = kp.public();
+		let pk_bytes = pk.to_bytes();
+		let pk1: libp2p_ed25519::PublicKey = pk.clone().into();
+		let pk2: litep2p_ed25519::PublicKey = pk.clone().into();
+		let pk3 = libp2p_ed25519::PublicKey::try_from_bytes(&pk_bytes).unwrap();
+		let pk4 = litep2p_ed25519::PublicKey::decode(&pk_bytes).unwrap();
+
+		assert_eq!(pk_bytes, pk1.to_bytes());
+		assert_eq!(pk_bytes, pk2.encode());
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+
+		assert!(pk.verify(msg, &sig));
+		assert!(pk1.verify(msg, &sig));
+		assert!(pk2.verify(msg, &sig));
+		assert!(pk3.verify(msg, &sig));
+		assert!(pk4.verify(msg, &sig));
+	}
+
+	#[test]
+	fn litep2p_pk_to_substrate_pk() {
+		let kp = litep2p_ed25519::Keypair::generate();
+		let pk = kp.public();
+		let pk_bytes = pk.clone().encode();
+		let pk1: PublicKey = pk.clone().into();
+		let pk2 = PublicKey::try_from_bytes(&pk_bytes).unwrap();
+
+		assert_eq!(pk_bytes, pk1.to_bytes());
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+
+		assert!(pk.verify(msg, &sig));
+		assert!(pk1.verify(msg, &sig));
+		assert!(pk2.verify(msg, &sig));
+	}
+
+	#[test]
+	fn libp2p_pk_to_substrate_pk() {
+		let kp = libp2p_ed25519::Keypair::generate();
+		let pk = kp.public();
+		let pk_bytes = pk.clone().to_bytes();
+		let pk1: PublicKey = pk.clone().into();
+		let pk2 = PublicKey::try_from_bytes(&pk_bytes).unwrap();
+
+		assert_eq!(pk_bytes, pk1.to_bytes());
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+
+		assert!(pk.verify(msg, &sig));
+		assert!(pk1.verify(msg, &sig));
+		assert!(pk2.verify(msg, &sig));
+	}
+
+	#[test]
+	fn substrate_sk_to_libs() {
+		let sk = SecretKey::generate();
+		let sk_bytes = sk.to_bytes();
+		let sk1: libp2p_ed25519::SecretKey = sk.clone().into();
+		let sk2: litep2p_ed25519::SecretKey = sk.clone().into();
+		let sk3 = libp2p_ed25519::SecretKey::try_from_bytes(&mut sk_bytes.clone()).unwrap();
+		let sk4 = litep2p_ed25519::SecretKey::from_bytes(&mut sk_bytes.clone()).unwrap();
+
+		let kp: Keypair = sk.into();
+		let kp1: libp2p_ed25519::Keypair = sk1.into();
+		let kp2: litep2p_ed25519::Keypair = sk2.into();
+		let kp3: libp2p_ed25519::Keypair = sk3.into();
+		let kp4: litep2p_ed25519::Keypair = sk4.into();
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+
+		assert_eq!(sig, kp1.sign(msg));
+		assert_eq!(sig, kp2.sign(msg));
+		assert_eq!(sig, kp3.sign(msg));
+		assert_eq!(sig, kp4.sign(msg));
+	}
+
+	#[test]
+	fn litep2p_sk_to_substrate_sk() {
+		let sk = litep2p_ed25519::SecretKey::generate();
+		let sk1: SecretKey = sk.clone().into();
+		let sk2 = SecretKey::try_from_bytes(&mut sk.to_bytes()).unwrap();
+
+		let kp: litep2p_ed25519::Keypair = sk.into();
+		let kp1: Keypair = sk1.into();
+		let kp2: Keypair = sk2.into();
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+
+		assert_eq!(sig, kp1.sign(msg));
+		assert_eq!(sig, kp2.sign(msg));
+	}
+
+	#[test]
+	fn libp2p_sk_to_substrate_sk() {
+		let sk = libp2p_ed25519::SecretKey::generate();
+		let sk_bytes = sk.as_ref().to_owned();
+		let sk1: SecretKey = sk.clone().into();
+		let sk2 = SecretKey::try_from_bytes(sk_bytes).unwrap();
+
+		let kp: libp2p_ed25519::Keypair = sk.into();
+		let kp1: Keypair = sk1.into();
+		let kp2: Keypair = sk2.into();
+
+		let msg = "hello world".as_bytes();
+		let sig = kp.sign(msg);
+
+		assert_eq!(sig, kp1.sign(msg));
+		assert_eq!(sig, kp2.sign(msg));
+	}
+}
diff --git a/substrate/client/network/types/src/lib.rs b/substrate/client/network/types/src/lib.rs
index 9a126c48c7eab66ab39dd55a081a3a938aa16b92..5684e38ab2e8474e171a24260a63c22fcc30694c 100644
--- a/substrate/client/network/types/src/lib.rs
+++ b/substrate/client/network/types/src/lib.rs
@@ -13,6 +13,12 @@
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU General Public License for more details.
 
-mod peer_id;
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+pub mod ed25519;
+pub mod multiaddr;
+pub mod multihash;
 
+mod peer_id;
 pub use peer_id::PeerId;
diff --git a/substrate/client/network/types/src/multiaddr.rs b/substrate/client/network/types/src/multiaddr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..de317e2aa1cf969558480943c5059eb940f50c2c
--- /dev/null
+++ b/substrate/client/network/types/src/multiaddr.rs
@@ -0,0 +1,273 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use litep2p::types::multiaddr::{
+	Error as LiteP2pError, Iter as LiteP2pIter, Multiaddr as LiteP2pMultiaddr,
+	Protocol as LiteP2pProtocol,
+};
+use std::{
+	fmt::{self, Debug, Display},
+	net::{IpAddr, Ipv4Addr, Ipv6Addr},
+	str::FromStr,
+};
+
+mod protocol;
+pub use protocol::Protocol;
+
+// Re-export the macro under shorter name under `multiaddr`.
+pub use crate::build_multiaddr as multiaddr;
+
+/// [`Multiaddr`] type used in Substrate. Converted to libp2p's `Multiaddr`
+/// or litep2p's `Multiaddr` when passed to the corresponding network backend.
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Hash)]
+pub struct Multiaddr {
+	multiaddr: LiteP2pMultiaddr,
+}
+
+impl Multiaddr {
+	/// Create a new, empty multiaddress.
+	pub fn empty() -> Self {
+		Self { multiaddr: LiteP2pMultiaddr::empty() }
+	}
+
+	/// Adds an address component to the end of this multiaddr.
+	pub fn push(&mut self, p: Protocol<'_>) {
+		self.multiaddr.push(p.into())
+	}
+
+	/// Pops the last `Protocol` of this multiaddr, or `None` if the multiaddr is empty.
+	pub fn pop<'a>(&mut self) -> Option<Protocol<'a>> {
+		self.multiaddr.pop().map(Into::into)
+	}
+
+	/// Like [`Multiaddr::push`] but consumes `self`.
+	pub fn with(self, p: Protocol<'_>) -> Self {
+		self.multiaddr.with(p.into()).into()
+	}
+
+	/// Returns the components of this multiaddress.
+	pub fn iter(&self) -> Iter<'_> {
+		self.multiaddr.iter().into()
+	}
+
+	/// Return a copy of this [`Multiaddr`]'s byte representation.
+	pub fn to_vec(&self) -> Vec<u8> {
+		self.multiaddr.to_vec()
+	}
+}
+
+impl Display for Multiaddr {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		Display::fmt(&self.multiaddr, f)
+	}
+}
+
+/// Remove an extra layer of nestedness by deferring to the wrapped value's [`Debug`].
+impl Debug for Multiaddr {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		Debug::fmt(&self.multiaddr, f)
+	}
+}
+
+impl AsRef<[u8]> for Multiaddr {
+	fn as_ref(&self) -> &[u8] {
+		self.multiaddr.as_ref()
+	}
+}
+
+impl From<LiteP2pMultiaddr> for Multiaddr {
+	fn from(multiaddr: LiteP2pMultiaddr) -> Self {
+		Self { multiaddr }
+	}
+}
+
+impl From<Multiaddr> for LiteP2pMultiaddr {
+	fn from(multiaddr: Multiaddr) -> Self {
+		multiaddr.multiaddr
+	}
+}
+
+impl From<IpAddr> for Multiaddr {
+	fn from(v: IpAddr) -> Multiaddr {
+		match v {
+			IpAddr::V4(a) => a.into(),
+			IpAddr::V6(a) => a.into(),
+		}
+	}
+}
+
+impl From<Ipv4Addr> for Multiaddr {
+	fn from(v: Ipv4Addr) -> Multiaddr {
+		Protocol::Ip4(v).into()
+	}
+}
+
+impl From<Ipv6Addr> for Multiaddr {
+	fn from(v: Ipv6Addr) -> Multiaddr {
+		Protocol::Ip6(v).into()
+	}
+}
+
+impl TryFrom<Vec<u8>> for Multiaddr {
+	type Error = ParseError;
+
+	fn try_from(v: Vec<u8>) -> Result<Self, ParseError> {
+		let multiaddr = LiteP2pMultiaddr::try_from(v)?;
+		Ok(Self { multiaddr })
+	}
+}
+
+/// Error when parsing a [`Multiaddr`] from string.
+#[derive(Debug, thiserror::Error)]
+pub enum ParseError {
+	/// Less data provided than indicated by length.
+	#[error("less data than indicated by length")]
+	DataLessThanLen,
+	/// Invalid multiaddress.
+	#[error("invalid multiaddress")]
+	InvalidMultiaddr,
+	/// Invalid protocol specification.
+	#[error("invalid protocol string")]
+	InvalidProtocolString,
+	/// Unknown protocol string identifier.
+	#[error("unknown protocol '{0}'")]
+	UnknownProtocolString(String),
+	/// Unknown protocol numeric id.
+	#[error("unknown protocol id {0}")]
+	UnknownProtocolId(u32),
+	/// Failed to decode unsigned varint.
+	#[error("failed to decode unsigned varint: {0}")]
+	InvalidUvar(Box<dyn std::error::Error + Send + Sync>),
+	/// Other error emitted when parsing into the wrapped type.
+	#[error("multiaddr parsing error: {0}")]
+	ParsingError(Box<dyn std::error::Error + Send + Sync>),
+}
+
+impl From<LiteP2pError> for ParseError {
+	fn from(error: LiteP2pError) -> Self {
+		match error {
+			LiteP2pError::DataLessThanLen => ParseError::DataLessThanLen,
+			LiteP2pError::InvalidMultiaddr => ParseError::InvalidMultiaddr,
+			LiteP2pError::InvalidProtocolString => ParseError::InvalidProtocolString,
+			LiteP2pError::UnknownProtocolString(s) => ParseError::UnknownProtocolString(s),
+			LiteP2pError::UnknownProtocolId(n) => ParseError::UnknownProtocolId(n),
+			LiteP2pError::InvalidUvar(e) => ParseError::InvalidUvar(Box::new(e)),
+			LiteP2pError::ParsingError(e) => ParseError::ParsingError(e),
+			error => ParseError::ParsingError(Box::new(error)),
+		}
+	}
+}
+
+impl FromStr for Multiaddr {
+	type Err = ParseError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let multiaddr = LiteP2pMultiaddr::from_str(s)?;
+		Ok(Self { multiaddr })
+	}
+}
+
+impl TryFrom<String> for Multiaddr {
+	type Error = ParseError;
+
+	fn try_from(s: String) -> Result<Multiaddr, Self::Error> {
+		Self::from_str(&s)
+	}
+}
+
+impl<'a> TryFrom<&'a str> for Multiaddr {
+	type Error = ParseError;
+
+	fn try_from(s: &'a str) -> Result<Multiaddr, Self::Error> {
+		Self::from_str(s)
+	}
+}
+
+/// Iterator over `Multiaddr` [`Protocol`]s.
+pub struct Iter<'a>(LiteP2pIter<'a>);
+
+impl<'a> Iterator for Iter<'a> {
+	type Item = Protocol<'a>;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.0.next().map(Into::into)
+	}
+}
+
+impl<'a> From<LiteP2pIter<'a>> for Iter<'a> {
+	fn from(iter: LiteP2pIter<'a>) -> Self {
+		Self(iter)
+	}
+}
+
+impl<'a> IntoIterator for &'a Multiaddr {
+	type Item = Protocol<'a>;
+	type IntoIter = Iter<'a>;
+
+	fn into_iter(self) -> Iter<'a> {
+		self.multiaddr.into_iter().into()
+	}
+}
+
+impl<'a> FromIterator<Protocol<'a>> for Multiaddr {
+	fn from_iter<T>(iter: T) -> Self
+	where
+		T: IntoIterator<Item = Protocol<'a>>,
+	{
+		LiteP2pMultiaddr::from_iter(iter.into_iter().map(Into::into)).into()
+	}
+}
+
+impl<'a> From<Protocol<'a>> for Multiaddr {
+	fn from(p: Protocol<'a>) -> Multiaddr {
+		let protocol: LiteP2pProtocol = p.into();
+		let multiaddr: LiteP2pMultiaddr = protocol.into();
+		multiaddr.into()
+	}
+}
+
+/// Easy way for a user to create a `Multiaddr`.
+///
+/// Example:
+///
+/// ```rust
+/// use sc_network_types::build_multiaddr;
+/// let addr = build_multiaddr!(Ip4([127, 0, 0, 1]), Tcp(10500u16));
+/// ```
+///
+/// Each element passed to `multiaddr!` should be a variant of the `Protocol` enum. The
+/// optional parameter is turned into the proper type with the `Into` trait.
+///
+/// For example, `Ip4([127, 0, 0, 1])` works because `Ipv4Addr` implements `From<[u8; 4]>`.
+#[macro_export]
+macro_rules! build_multiaddr {
+    ($($comp:ident $(($param:expr))*),+) => {
+        {
+            use std::iter;
+            let elem = iter::empty::<$crate::multiaddr::Protocol>();
+            $(
+                let elem = {
+                    let cmp = $crate::multiaddr::Protocol::$comp $(( $param.into() ))*;
+                    elem.chain(iter::once(cmp))
+                };
+            )+
+            elem.collect::<$crate::multiaddr::Multiaddr>()
+        }
+    }
+}
diff --git a/substrate/client/network/types/src/multiaddr/protocol.rs b/substrate/client/network/types/src/multiaddr/protocol.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a3b59e6a68235a43fef6113712af54836fc40ea
--- /dev/null
+++ b/substrate/client/network/types/src/multiaddr/protocol.rs
@@ -0,0 +1,162 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use crate::multihash::Multihash;
+use litep2p::types::multiaddr::Protocol as LiteP2pProtocol;
+use std::{
+	borrow::Cow,
+	net::{IpAddr, Ipv4Addr, Ipv6Addr},
+};
+
+/// [`Protocol`] describes all possible multiaddress protocols.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub enum Protocol<'a> {
+	Dccp(u16),
+	Dns(Cow<'a, str>),
+	Dns4(Cow<'a, str>),
+	Dns6(Cow<'a, str>),
+	Dnsaddr(Cow<'a, str>),
+	Http,
+	Https,
+	Ip4(Ipv4Addr),
+	Ip6(Ipv6Addr),
+	P2pWebRtcDirect,
+	P2pWebRtcStar,
+	WebRTC,
+	Certhash(Multihash),
+	P2pWebSocketStar,
+	/// Contains the "port" to contact. Similar to TCP or UDP, 0 means "assign me a port".
+	Memory(u64),
+	Onion(Cow<'a, [u8; 10]>, u16),
+	Onion3(Cow<'a, [u8; 35]>, u16),
+	P2p(Multihash),
+	P2pCircuit,
+	Quic,
+	QuicV1,
+	Sctp(u16),
+	Tcp(u16),
+	Tls,
+	Noise,
+	Udp(u16),
+	Udt,
+	Unix(Cow<'a, str>),
+	Utp,
+	Ws(Cow<'a, str>),
+	Wss(Cow<'a, str>),
+}
+
+impl<'a> From<IpAddr> for Protocol<'a> {
+	#[inline]
+	fn from(addr: IpAddr) -> Self {
+		match addr {
+			IpAddr::V4(addr) => Protocol::Ip4(addr),
+			IpAddr::V6(addr) => Protocol::Ip6(addr),
+		}
+	}
+}
+
+impl<'a> From<Ipv4Addr> for Protocol<'a> {
+	#[inline]
+	fn from(addr: Ipv4Addr) -> Self {
+		Protocol::Ip4(addr)
+	}
+}
+
+impl<'a> From<Ipv6Addr> for Protocol<'a> {
+	#[inline]
+	fn from(addr: Ipv6Addr) -> Self {
+		Protocol::Ip6(addr)
+	}
+}
+
+impl<'a> From<LiteP2pProtocol<'a>> for Protocol<'a> {
+	fn from(protocol: LiteP2pProtocol<'a>) -> Self {
+		match protocol {
+			LiteP2pProtocol::Dccp(port) => Protocol::Dccp(port),
+			LiteP2pProtocol::Dns(str) => Protocol::Dns(str),
+			LiteP2pProtocol::Dns4(str) => Protocol::Dns4(str),
+			LiteP2pProtocol::Dns6(str) => Protocol::Dns6(str),
+			LiteP2pProtocol::Dnsaddr(str) => Protocol::Dnsaddr(str),
+			LiteP2pProtocol::Http => Protocol::Http,
+			LiteP2pProtocol::Https => Protocol::Https,
+			LiteP2pProtocol::Ip4(ipv4_addr) => Protocol::Ip4(ipv4_addr),
+			LiteP2pProtocol::Ip6(ipv6_addr) => Protocol::Ip6(ipv6_addr),
+			LiteP2pProtocol::P2pWebRtcDirect => Protocol::P2pWebRtcDirect,
+			LiteP2pProtocol::P2pWebRtcStar => Protocol::P2pWebRtcStar,
+			LiteP2pProtocol::WebRTC => Protocol::WebRTC,
+			LiteP2pProtocol::Certhash(multihash) => Protocol::Certhash(multihash.into()),
+			LiteP2pProtocol::P2pWebSocketStar => Protocol::P2pWebSocketStar,
+			LiteP2pProtocol::Memory(port) => Protocol::Memory(port),
+			LiteP2pProtocol::Onion(str, port) => Protocol::Onion(str, port),
+			LiteP2pProtocol::Onion3(addr) =>
+				Protocol::Onion3(Cow::Owned(*addr.hash()), addr.port()),
+			LiteP2pProtocol::P2p(multihash) => Protocol::P2p(multihash.into()),
+			LiteP2pProtocol::P2pCircuit => Protocol::P2pCircuit,
+			LiteP2pProtocol::Quic => Protocol::Quic,
+			LiteP2pProtocol::QuicV1 => Protocol::QuicV1,
+			LiteP2pProtocol::Sctp(port) => Protocol::Sctp(port),
+			LiteP2pProtocol::Tcp(port) => Protocol::Tcp(port),
+			LiteP2pProtocol::Tls => Protocol::Tls,
+			LiteP2pProtocol::Noise => Protocol::Noise,
+			LiteP2pProtocol::Udp(port) => Protocol::Udp(port),
+			LiteP2pProtocol::Udt => Protocol::Udt,
+			LiteP2pProtocol::Unix(str) => Protocol::Unix(str),
+			LiteP2pProtocol::Utp => Protocol::Utp,
+			LiteP2pProtocol::Ws(str) => Protocol::Ws(str),
+			LiteP2pProtocol::Wss(str) => Protocol::Wss(str),
+		}
+	}
+}
+
+impl<'a> From<Protocol<'a>> for LiteP2pProtocol<'a> {
+	fn from(protocol: Protocol<'a>) -> Self {
+		match protocol {
+			Protocol::Dccp(port) => LiteP2pProtocol::Dccp(port),
+			Protocol::Dns(str) => LiteP2pProtocol::Dns(str),
+			Protocol::Dns4(str) => LiteP2pProtocol::Dns4(str),
+			Protocol::Dns6(str) => LiteP2pProtocol::Dns6(str),
+			Protocol::Dnsaddr(str) => LiteP2pProtocol::Dnsaddr(str),
+			Protocol::Http => LiteP2pProtocol::Http,
+			Protocol::Https => LiteP2pProtocol::Https,
+			Protocol::Ip4(ipv4_addr) => LiteP2pProtocol::Ip4(ipv4_addr),
+			Protocol::Ip6(ipv6_addr) => LiteP2pProtocol::Ip6(ipv6_addr),
+			Protocol::P2pWebRtcDirect => LiteP2pProtocol::P2pWebRtcDirect,
+			Protocol::P2pWebRtcStar => LiteP2pProtocol::P2pWebRtcStar,
+			Protocol::WebRTC => LiteP2pProtocol::WebRTC,
+			Protocol::Certhash(multihash) => LiteP2pProtocol::Certhash(multihash.into()),
+			Protocol::P2pWebSocketStar => LiteP2pProtocol::P2pWebSocketStar,
+			Protocol::Memory(port) => LiteP2pProtocol::Memory(port),
+			Protocol::Onion(str, port) => LiteP2pProtocol::Onion(str, port),
+			Protocol::Onion3(str, port) => LiteP2pProtocol::Onion3((str.into_owned(), port).into()),
+			Protocol::P2p(multihash) => LiteP2pProtocol::P2p(multihash.into()),
+			Protocol::P2pCircuit => LiteP2pProtocol::P2pCircuit,
+			Protocol::Quic => LiteP2pProtocol::Quic,
+			Protocol::QuicV1 => LiteP2pProtocol::QuicV1,
+			Protocol::Sctp(port) => LiteP2pProtocol::Sctp(port),
+			Protocol::Tcp(port) => LiteP2pProtocol::Tcp(port),
+			Protocol::Tls => LiteP2pProtocol::Tls,
+			Protocol::Noise => LiteP2pProtocol::Noise,
+			Protocol::Udp(port) => LiteP2pProtocol::Udp(port),
+			Protocol::Udt => LiteP2pProtocol::Udt,
+			Protocol::Unix(str) => LiteP2pProtocol::Unix(str),
+			Protocol::Utp => LiteP2pProtocol::Utp,
+			Protocol::Ws(str) => LiteP2pProtocol::Ws(str),
+			Protocol::Wss(str) => LiteP2pProtocol::Wss(str),
+		}
+	}
+}
diff --git a/substrate/client/network/types/src/multihash.rs b/substrate/client/network/types/src/multihash.rs
new file mode 100644
index 0000000000000000000000000000000000000000..91f5b6353a7187e72fb49b1731ed1be6d8319bff
--- /dev/null
+++ b/substrate/client/network/types/src/multihash.rs
@@ -0,0 +1,192 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+//! [`Multihash`] implemenattion used by substrate. Currently it's a wrapper over
+//! multihash used by litep2p, but it can be switched to other implementation if needed.
+
+use litep2p::types::multihash::{
+	Code as LiteP2pCode, Error as LiteP2pError, Multihash as LiteP2pMultihash, MultihashDigest as _,
+};
+use std::fmt::{self, Debug};
+
+/// Default [`Multihash`] implementations. Only hashes used by substrate are defined.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Code {
+	/// Identity hasher.
+	Identity,
+	/// SHA-256 (32-byte hash size).
+	Sha2_256,
+}
+
+impl Code {
+	/// Calculate digest using this [`Code`]'s hashing algorithm.
+	pub fn digest(&self, input: &[u8]) -> Multihash {
+		LiteP2pCode::from(*self).digest(input).into()
+	}
+}
+
+/// Error generated when converting to [`Code`].
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Invalid multihash size.
+	#[error("invalid multihash size '{0}'")]
+	InvalidSize(u64),
+	/// The multihash code is not supported.
+	#[error("unsupported multihash code '{0:x}'")]
+	UnsupportedCode(u64),
+	/// Catch-all for other errors emitted when converting `u64` code to enum or parsing multihash
+	/// from bytes. Never generated as of multihash-0.17.0.
+	#[error("other error: {0}")]
+	Other(Box<dyn std::error::Error + Send + Sync>),
+}
+
+impl From<LiteP2pError> for Error {
+	fn from(error: LiteP2pError) -> Self {
+		match error {
+			LiteP2pError::InvalidSize(s) => Self::InvalidSize(s),
+			LiteP2pError::UnsupportedCode(c) => Self::UnsupportedCode(c),
+			e => Self::Other(Box::new(e)),
+		}
+	}
+}
+
+impl From<Code> for LiteP2pCode {
+	fn from(code: Code) -> Self {
+		match code {
+			Code::Identity => LiteP2pCode::Identity,
+			Code::Sha2_256 => LiteP2pCode::Sha2_256,
+		}
+	}
+}
+
+impl TryFrom<LiteP2pCode> for Code {
+	type Error = Error;
+
+	fn try_from(code: LiteP2pCode) -> Result<Self, Self::Error> {
+		match code {
+			LiteP2pCode::Identity => Ok(Code::Identity),
+			LiteP2pCode::Sha2_256 => Ok(Code::Sha2_256),
+			_ => Err(Error::UnsupportedCode(code.into())),
+		}
+	}
+}
+
+impl TryFrom<u64> for Code {
+	type Error = Error;
+
+	fn try_from(code: u64) -> Result<Self, Self::Error> {
+		match LiteP2pCode::try_from(code) {
+			Ok(code) => code.try_into(),
+			Err(e) => Err(e.into()),
+		}
+	}
+}
+
+impl From<Code> for u64 {
+	fn from(code: Code) -> Self {
+		LiteP2pCode::from(code).into()
+	}
+}
+
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Ord, PartialOrd)]
+pub struct Multihash {
+	multihash: LiteP2pMultihash,
+}
+
+impl Multihash {
+	/// Multihash code.
+	pub fn code(&self) -> u64 {
+		self.multihash.code()
+	}
+
+	/// Multihash digest.
+	pub fn digest(&self) -> &[u8] {
+		self.multihash.digest()
+	}
+
+	/// Wraps the digest in a multihash.
+	pub fn wrap(code: u64, input_digest: &[u8]) -> Result<Self, Error> {
+		LiteP2pMultihash::wrap(code, input_digest).map(Into::into).map_err(Into::into)
+	}
+
+	/// Parses a multihash from bytes.
+	///
+	/// You need to make sure the passed in bytes have the length of 64.
+	pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
+		LiteP2pMultihash::from_bytes(bytes).map(Into::into).map_err(Into::into)
+	}
+
+	/// Returns the bytes of a multihash.
+	pub fn to_bytes(&self) -> Vec<u8> {
+		self.multihash.to_bytes()
+	}
+}
+
+/// Remove extra layer of nestedness by deferring to the wrapped value's [`Debug`].
+impl Debug for Multihash {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		Debug::fmt(&self.multihash, f)
+	}
+}
+
+impl From<LiteP2pMultihash> for Multihash {
+	fn from(multihash: LiteP2pMultihash) -> Self {
+		Multihash { multihash }
+	}
+}
+
+impl From<Multihash> for LiteP2pMultihash {
+	fn from(multihash: Multihash) -> Self {
+		multihash.multihash
+	}
+}
+
+// TODO: uncomment this after upgrading `multihash` crate to v0.19.1.
+//
+// impl From<multihash::Multihash<64>> for Multihash {
+// 	fn from(generic: multihash::MultihashGeneric<64>) -> Self {
+// 		LiteP2pMultihash::wrap(generic.code(), generic.digest())
+// 			.expect("both have size 64; qed")
+// 			.into()
+// 	}
+// }
+//
+// impl From<Multihash> for multihash::Multihash<64> {
+// 	fn from(multihash: Multihash) -> Self {
+// 		multihash::Multihash::<64>::wrap(multihash.code(), multihash.digest())
+// 			.expect("both have size 64; qed")
+// 	}
+// }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn code_from_u64() {
+		assert_eq!(Code::try_from(0x00).unwrap(), Code::Identity);
+		assert_eq!(Code::try_from(0x12).unwrap(), Code::Sha2_256);
+		assert!(matches!(Code::try_from(0x01).unwrap_err(), Error::UnsupportedCode(0x01)));
+	}
+
+	#[test]
+	fn code_into_u64() {
+		assert_eq!(u64::from(Code::Identity), 0x00);
+		assert_eq!(u64::from(Code::Sha2_256), 0x12);
+	}
+}
diff --git a/substrate/client/network/types/src/peer_id.rs b/substrate/client/network/types/src/peer_id.rs
index 14ac4a1e9aae8028e6197327a9fe7eec633e40b4..076be0a66c7b79ae09b4a31738a1869035181b86 100644
--- a/substrate/client/network/types/src/peer_id.rs
+++ b/substrate/client/network/types/src/peer_id.rs
@@ -16,8 +16,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use multiaddr::{Multiaddr, Protocol};
-use multihash::{Code, Error, Multihash};
+use crate::{
+	multiaddr::{Multiaddr, Protocol},
+	multihash::{Code, Error, Multihash},
+};
 use rand::Rng;
 
 use std::{fmt, hash::Hash, str::FromStr};
@@ -185,7 +187,7 @@ pub enum ParseError {
 	#[error("unsupported multihash code '{0}'")]
 	UnsupportedCode(u64),
 	#[error("invalid multihash")]
-	InvalidMultihash(#[from] multihash::Error),
+	InvalidMultihash(#[from] crate::multihash::Error),
 }
 
 impl FromStr for PeerId {
diff --git a/substrate/client/rpc-servers/Cargo.toml b/substrate/client/rpc-servers/Cargo.toml
index 7837c852a1c9b73992b9a24f911ce7bba937cdab..19369e295fc4185bd72e1c35264b9a879dfb291f 100644
--- a/substrate/client/rpc-servers/Cargo.toml
+++ b/substrate/client/rpc-servers/Cargo.toml
@@ -25,6 +25,7 @@ ip_network = "0.4.1"
 jsonrpsee = { version = "0.22", features = ["server"] }
 log = { workspace = true, default-features = true }
 prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../utils/prometheus" }
+serde = { workspace = true }
 serde_json = { workspace = true, default-features = true }
 tokio = { version = "1.22.0", features = ["parking_lot"] }
 tower = { version = "0.4.13", features = ["util"] }
diff --git a/substrate/client/rpc-servers/src/lib.rs b/substrate/client/rpc-servers/src/lib.rs
index ba1fcf5e36771008e139bc69ff492eb645e2bcae..647a7ca7e43514ed1765db0c0e86711d2dad58fc 100644
--- a/substrate/client/rpc-servers/src/lib.rs
+++ b/substrate/client/rpc-servers/src/lib.rs
@@ -32,12 +32,10 @@ use hyper::{
 	service::{make_service_fn, service_fn},
 };
 use jsonrpsee::{
-	server::{
-		middleware::http::ProxyGetRequestLayer, stop_channel, ws, PingConfig, StopHandle,
-		TowerServiceBuilder,
-	},
+	server::{stop_channel, ws, PingConfig, StopHandle, TowerServiceBuilder},
 	Methods, RpcModule,
 };
+use middleware::NodeHealthProxyLayer;
 use tokio::net::TcpListener;
 use tower::Service;
 use utils::{build_rpc_api, format_cors, get_proxy_ip, host_filtering, try_into_cors};
@@ -132,8 +130,8 @@ where
 
 	let http_middleware = tower::ServiceBuilder::new()
 		.option_layer(host_filter)
-		// Proxy `GET /health` requests to internal `system_health` method.
-		.layer(ProxyGetRequestLayer::new("/health", "system_health")?)
+		// Proxy `GET /health, /health/readiness` requests to the internal `system_health` method.
+		.layer(NodeHealthProxyLayer::default())
 		.layer(try_into_cors(cors)?);
 
 	let mut builder = jsonrpsee::server::Server::builder()
diff --git a/substrate/client/rpc-servers/src/middleware/mod.rs b/substrate/client/rpc-servers/src/middleware/mod.rs
index 88ed8b2f433580fa2d87f1a70eacc32019027f2a..0a14be4dacf59f2c3dcae90d64653461fe48eb37 100644
--- a/substrate/client/rpc-servers/src/middleware/mod.rs
+++ b/substrate/client/rpc-servers/src/middleware/mod.rs
@@ -32,9 +32,11 @@ use jsonrpsee::{
 };
 
 mod metrics;
+mod node_health;
 mod rate_limit;
 
 pub use metrics::*;
+pub use node_health::*;
 pub use rate_limit::*;
 
 const MAX_JITTER: Duration = Duration::from_millis(50);
diff --git a/substrate/client/rpc-servers/src/middleware/node_health.rs b/substrate/client/rpc-servers/src/middleware/node_health.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d68ec14cb8fef1a2311e188abd5ba10904d0b060
--- /dev/null
+++ b/substrate/client/rpc-servers/src/middleware/node_health.rs
@@ -0,0 +1,199 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+//! Middleware for handling `/health` and `/health/readiness` endpoints.
+
+use std::{
+	error::Error,
+	future::Future,
+	pin::Pin,
+	task::{Context, Poll},
+};
+
+use futures::future::FutureExt;
+use http::{HeaderValue, Method, StatusCode, Uri};
+use hyper::Body;
+use jsonrpsee::types::{Response as RpcResponse, ResponseSuccess as RpcResponseSuccess};
+use tower::Service;
+
+const RPC_SYSTEM_HEALTH_CALL: &str = r#"{"jsonrpc":"2.0","method":"system_health","id":0}"#;
+const HEADER_VALUE_JSON: HeaderValue = HeaderValue::from_static("application/json; charset=utf-8");
+
+/// Layer that applies [`NodeHealthProxy`] which
+/// proxies `/health` and `/health/readiness` endpoints.
+#[derive(Debug, Clone, Default)]
+pub struct NodeHealthProxyLayer;
+
+impl<S> tower::Layer<S> for NodeHealthProxyLayer {
+	type Service = NodeHealthProxy<S>;
+
+	fn layer(&self, service: S) -> Self::Service {
+		NodeHealthProxy::new(service)
+	}
+}
+
+/// Middleware that proxies `/health` and `/health/readiness` endpoints.
+pub struct NodeHealthProxy<S>(S);
+
+impl<S> NodeHealthProxy<S> {
+	/// Creates a new [`NodeHealthProxy`].
+	pub fn new(service: S) -> Self {
+		Self(service)
+	}
+}
+
+impl<S> tower::Service<http::Request<Body>> for NodeHealthProxy<S>
+where
+	S: Service<http::Request<Body>, Response = http::Response<Body>>,
+	S::Response: 'static,
+	S::Error: Into<Box<dyn Error + Send + Sync>> + 'static,
+	S::Future: Send + 'static,
+{
+	type Response = S::Response;
+	type Error = Box<dyn Error + Send + Sync + 'static>;
+	type Future =
+		Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send + 'static>>;
+
+	fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+		self.0.poll_ready(cx).map_err(Into::into)
+	}
+
+	fn call(&mut self, mut req: http::Request<Body>) -> Self::Future {
+		let maybe_intercept = InterceptRequest::from_http(&req);
+
+		// Modify the request and proxy it to `system_health`
+		if let InterceptRequest::Health | InterceptRequest::Readiness = maybe_intercept {
+			// RPC methods are accessed with `POST`.
+			*req.method_mut() = Method::POST;
+			// Precautionary remove the URI.
+			*req.uri_mut() = Uri::from_static("/");
+
+			// Requests must have the following headers:
+			req.headers_mut().insert(http::header::CONTENT_TYPE, HEADER_VALUE_JSON);
+			req.headers_mut().insert(http::header::ACCEPT, HEADER_VALUE_JSON);
+
+			// Adjust the body to reflect the method call.
+			req = req.map(|_| Body::from(RPC_SYSTEM_HEALTH_CALL));
+		}
+
+		// Call the inner service and get a future that resolves to the response.
+		let fut = self.0.call(req);
+
+		async move {
+			let res = fut.await.map_err(|err| err.into())?;
+
+			Ok(match maybe_intercept {
+				InterceptRequest::Deny =>
+					http_response(StatusCode::METHOD_NOT_ALLOWED, Body::empty()),
+				InterceptRequest::No => res,
+				InterceptRequest::Health => {
+					let health = parse_rpc_response(res.into_body()).await?;
+					http_ok_response(serde_json::to_string(&health)?)
+				},
+				InterceptRequest::Readiness => {
+					let health = parse_rpc_response(res.into_body()).await?;
+					if (!health.is_syncing && health.peers > 0) || !health.should_have_peers {
+						http_ok_response(Body::empty())
+					} else {
+						http_internal_error()
+					}
+				},
+			})
+		}
+		.boxed()
+	}
+}
+
+// NOTE: This is duplicated here to avoid dependency to the `RPC API`.
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Health {
+	/// Number of connected peers
+	pub peers: usize,
+	/// Is the node syncing
+	pub is_syncing: bool,
+	/// Should this node have any peers
+	///
+	/// Might be false for local chains or when running without discovery.
+	pub should_have_peers: bool,
+}
+
+fn http_ok_response<S: Into<hyper::Body>>(body: S) -> hyper::Response<hyper::Body> {
+	http_response(StatusCode::OK, body)
+}
+
+fn http_response<S: Into<hyper::Body>>(
+	status_code: StatusCode,
+	body: S,
+) -> hyper::Response<hyper::Body> {
+	hyper::Response::builder()
+		.status(status_code)
+		.header(http::header::CONTENT_TYPE, HEADER_VALUE_JSON)
+		.body(body.into())
+		.expect("Header is valid; qed")
+}
+
+fn http_internal_error() -> hyper::Response<hyper::Body> {
+	http_response(hyper::StatusCode::INTERNAL_SERVER_ERROR, Body::empty())
+}
+
+async fn parse_rpc_response(body: Body) -> Result<Health, Box<dyn Error + Send + Sync + 'static>> {
+	let bytes = hyper::body::to_bytes(body).await?;
+
+	let raw_rp = serde_json::from_slice::<RpcResponse<Health>>(&bytes)?;
+	let rp = RpcResponseSuccess::<Health>::try_from(raw_rp)?;
+
+	Ok(rp.result)
+}
+
+/// Whether the request should be treated as ordinary RPC call or be modified.
+enum InterceptRequest {
+	/// Proxy `/health` to `system_health`.
+	Health,
+	/// Checks if node has at least one peer and is not doing major syncing.
+	///
+	/// Returns HTTP status code 200 on success otherwise HTTP status code 500 is returned.
+	Readiness,
+	/// Treat as a ordinary RPC call and don't modify the request or response.
+	No,
+	/// Deny health or readiness calls that is not HTTP GET request.
+	///
+	/// Returns HTTP status code 405.
+	Deny,
+}
+
+impl InterceptRequest {
+	fn from_http(req: &http::Request<Body>) -> InterceptRequest {
+		match req.uri().path() {
+			"/health" =>
+				if req.method() == http::Method::GET {
+					InterceptRequest::Health
+				} else {
+					InterceptRequest::Deny
+				},
+			"/health/readiness" =>
+				if req.method() == http::Method::GET {
+					InterceptRequest::Readiness
+				} else {
+					InterceptRequest::Deny
+				},
+			// Forward all other requests to the RPC server.
+			_ => InterceptRequest::No,
+		}
+	}
+}
diff --git a/substrate/client/rpc/src/utils.rs b/substrate/client/rpc/src/utils.rs
index 6ec48efef846c719db4e009b3a14926db0577d5f..3b5372615e733dba860faa453063548189fc6354 100644
--- a/substrate/client/rpc/src/utils.rs
+++ b/substrate/client/rpc/src/utils.rs
@@ -143,7 +143,7 @@ async fn inner_pipe_from_stream<S, T>(
 			//
 			// Process remaining items and terminate.
 			Either::Right((Either::Right((None, pending_fut)), _)) => {
-				if pending_fut.await.is_err() {
+				if !pending_fut.is_terminated() && pending_fut.await.is_err() {
 					return;
 				}
 
@@ -231,4 +231,28 @@ mod tests {
 		_ = rx.next().await.unwrap();
 		assert!(sub.next::<usize>().await.is_none());
 	}
+
+	#[tokio::test]
+	async fn subscription_is_dropped_when_stream_is_empty() {
+		let notify_rx = std::sync::Arc::new(tokio::sync::Notify::new());
+		let notify_tx = notify_rx.clone();
+
+		let mut module = RpcModule::new(notify_tx);
+		module
+			.register_subscription("sub", "my_sub", "unsub", |_, pending, notify_tx| async move {
+				// emulate empty stream for simplicity: otherwise we need some mechanism
+				// to sync buffer and channel send operations
+				let stream = futures::stream::empty::<()>();
+				// this should exit immediately
+				pipe_from_stream(pending, stream).await;
+				// notify that the `pipe_from_stream` has returned
+				notify_tx.notify_one();
+				Ok(())
+			})
+			.unwrap();
+		module.subscribe("sub", EmptyServerParams::new(), 1).await.unwrap();
+
+		// it should fire once `pipe_from_stream` returns
+		notify_rx.notified().await;
+	}
 }
diff --git a/substrate/client/service/src/client/call_executor.rs b/substrate/client/service/src/client/call_executor.rs
index 9da4d2192576909f95428933623a1e3160e1f9ad..1341aa0e72051f89bcd51d2feab3c24051fc124e 100644
--- a/substrate/client/service/src/client/call_executor.rs
+++ b/substrate/client/service/src/client/call_executor.rs
@@ -16,19 +16,19 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use super::{client::ClientConfig, wasm_override::WasmOverride, wasm_substitutes::WasmSubstitutes};
+use super::{code_provider::CodeProvider, ClientConfig};
 use sc_client_api::{
 	backend, call_executor::CallExecutor, execution_extensions::ExecutionExtensions, HeaderBackend,
 };
 use sc_executor::{RuntimeVersion, RuntimeVersionOf};
 use sp_api::ProofRecorder;
-use sp_core::traits::{CallContext, CodeExecutor, RuntimeCode};
+use sp_core::traits::{CallContext, CodeExecutor};
 use sp_externalities::Extensions;
 use sp_runtime::{
 	generic::BlockId,
 	traits::{Block as BlockT, HashingFor},
 };
-use sp_state_machine::{backend::AsTrieBackend, Ext, OverlayedChanges, StateMachine, StorageProof};
+use sp_state_machine::{backend::AsTrieBackend, OverlayedChanges, StateMachine, StorageProof};
 use std::{cell::RefCell, sync::Arc};
 
 /// Call executor that executes methods locally, querying all required
@@ -36,8 +36,7 @@ use std::{cell::RefCell, sync::Arc};
 pub struct LocalCallExecutor<Block: BlockT, B, E> {
 	backend: Arc<B>,
 	executor: E,
-	wasm_override: Arc<Option<WasmOverride>>,
-	wasm_substitutes: WasmSubstitutes<Block, E, B>,
+	code_provider: CodeProvider<Block, B, E>,
 	execution_extensions: Arc<ExecutionExtensions<Block>>,
 }
 
@@ -53,81 +52,15 @@ where
 		client_config: ClientConfig<Block>,
 		execution_extensions: ExecutionExtensions<Block>,
 	) -> sp_blockchain::Result<Self> {
-		let wasm_override = client_config
-			.wasm_runtime_overrides
-			.as_ref()
-			.map(|p| WasmOverride::new(p.clone(), &executor))
-			.transpose()?;
-
-		let wasm_substitutes = WasmSubstitutes::new(
-			client_config.wasm_runtime_substitutes,
-			executor.clone(),
-			backend.clone(),
-		)?;
+		let code_provider = CodeProvider::new(&client_config, executor.clone(), backend.clone())?;
 
 		Ok(LocalCallExecutor {
 			backend,
 			executor,
-			wasm_override: Arc::new(wasm_override),
-			wasm_substitutes,
+			code_provider,
 			execution_extensions: Arc::new(execution_extensions),
 		})
 	}
-
-	/// Check if local runtime code overrides are enabled and one is available
-	/// for the given `BlockId`. If yes, return it; otherwise return the same
-	/// `RuntimeCode` instance that was passed.
-	fn check_override<'a>(
-		&'a self,
-		onchain_code: RuntimeCode<'a>,
-		state: &B::State,
-		hash: Block::Hash,
-	) -> sp_blockchain::Result<(RuntimeCode<'a>, RuntimeVersion)>
-	where
-		Block: BlockT,
-		B: backend::Backend<Block>,
-	{
-		let on_chain_version = self.on_chain_runtime_version(&onchain_code, state)?;
-		let code_and_version = if let Some(d) = self.wasm_override.as_ref().as_ref().and_then(|o| {
-			o.get(
-				&on_chain_version.spec_version,
-				onchain_code.heap_pages,
-				&on_chain_version.spec_name,
-			)
-		}) {
-			log::debug!(target: "wasm_overrides", "using WASM override for block {}", hash);
-			d
-		} else if let Some(s) =
-			self.wasm_substitutes
-				.get(on_chain_version.spec_version, onchain_code.heap_pages, hash)
-		{
-			log::debug!(target: "wasm_substitutes", "Using WASM substitute for block {:?}", hash);
-			s
-		} else {
-			log::debug!(
-				target: "wasm_overrides",
-				"Neither WASM override nor substitute available for block {hash}, using onchain code",
-			);
-			(onchain_code, on_chain_version)
-		};
-
-		Ok(code_and_version)
-	}
-
-	/// Returns the on chain runtime version.
-	fn on_chain_runtime_version(
-		&self,
-		code: &RuntimeCode,
-		state: &B::State,
-	) -> sp_blockchain::Result<RuntimeVersion> {
-		let mut overlay = OverlayedChanges::default();
-
-		let mut ext = Ext::new(&mut overlay, state, None);
-
-		self.executor
-			.runtime_version(&mut ext, code)
-			.map_err(|e| sp_blockchain::Error::VersionInvalid(e.to_string()))
-	}
 }
 
 impl<Block: BlockT, B, E> Clone for LocalCallExecutor<Block, B, E>
@@ -138,8 +71,7 @@ where
 		LocalCallExecutor {
 			backend: self.backend.clone(),
 			executor: self.executor.clone(),
-			wasm_override: self.wasm_override.clone(),
-			wasm_substitutes: self.wasm_substitutes.clone(),
+			code_provider: self.code_provider.clone(),
 			execution_extensions: self.execution_extensions.clone(),
 		}
 	}
@@ -175,7 +107,7 @@ where
 		let runtime_code =
 			state_runtime_code.runtime_code().map_err(sp_blockchain::Error::RuntimeCode)?;
 
-		let runtime_code = self.check_override(runtime_code, &state, at_hash)?.0;
+		let runtime_code = self.code_provider.maybe_override_code(runtime_code, &state, at_hash)?.0;
 
 		let mut extensions = self.execution_extensions.extensions(at_hash, at_number);
 
@@ -215,7 +147,7 @@ where
 
 		let runtime_code =
 			state_runtime_code.runtime_code().map_err(sp_blockchain::Error::RuntimeCode)?;
-		let runtime_code = self.check_override(runtime_code, &state, at_hash)?.0;
+		let runtime_code = self.code_provider.maybe_override_code(runtime_code, &state, at_hash)?.0;
 		let mut extensions = extensions.borrow_mut();
 
 		match recorder {
@@ -263,7 +195,9 @@ where
 
 		let runtime_code =
 			state_runtime_code.runtime_code().map_err(sp_blockchain::Error::RuntimeCode)?;
-		self.check_override(runtime_code, &state, at_hash).map(|(_, v)| v)
+		self.code_provider
+			.maybe_override_code(runtime_code, &state, at_hash)
+			.map(|(_, v)| v)
 	}
 
 	fn prove_execution(
@@ -281,7 +215,7 @@ where
 		let state_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(trie_backend);
 		let runtime_code =
 			state_runtime_code.runtime_code().map_err(sp_blockchain::Error::RuntimeCode)?;
-		let runtime_code = self.check_override(runtime_code, &state, at_hash)?.0;
+		let runtime_code = self.code_provider.maybe_override_code(runtime_code, &state, at_hash)?.0;
 
 		sp_state_machine::prove_execution_on_trie_backend(
 			trie_backend,
@@ -331,133 +265,3 @@ where
 		self.executor.native_version()
 	}
 }
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use backend::Backend;
-	use sc_client_api::in_mem;
-	use sc_executor::WasmExecutor;
-	use sp_core::{
-		testing::TaskExecutor,
-		traits::{FetchRuntimeCode, WrappedRuntimeCode},
-	};
-	use std::collections::HashMap;
-	use substrate_test_runtime_client::{runtime, GenesisInit};
-
-	#[test]
-	fn should_get_override_if_exists() {
-		let executor = WasmExecutor::default();
-
-		let overrides = crate::client::wasm_override::dummy_overrides();
-		let onchain_code = WrappedRuntimeCode(substrate_test_runtime::wasm_binary_unwrap().into());
-		let onchain_code = RuntimeCode {
-			code_fetcher: &onchain_code,
-			heap_pages: Some(128),
-			hash: vec![0, 0, 0, 0],
-		};
-
-		let backend = Arc::new(in_mem::Backend::<runtime::Block>::new());
-
-		// wasm_runtime_overrides is `None` here because we construct the
-		// LocalCallExecutor directly later on
-		let client_config = ClientConfig::default();
-
-		let genesis_block_builder = crate::GenesisBlockBuilder::new(
-			&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
-			!client_config.no_genesis,
-			backend.clone(),
-			executor.clone(),
-		)
-		.expect("Creates genesis block builder");
-
-		// client is used for the convenience of creating and inserting the genesis block.
-		let _client =
-			crate::client::new_with_backend::<_, _, runtime::Block, _, runtime::RuntimeApi>(
-				backend.clone(),
-				executor.clone(),
-				genesis_block_builder,
-				Box::new(TaskExecutor::new()),
-				None,
-				None,
-				client_config,
-			)
-			.expect("Creates a client");
-
-		let call_executor = LocalCallExecutor {
-			backend: backend.clone(),
-			executor: executor.clone(),
-			wasm_override: Arc::new(Some(overrides)),
-			wasm_substitutes: WasmSubstitutes::new(
-				Default::default(),
-				executor.clone(),
-				backend.clone(),
-			)
-			.unwrap(),
-			execution_extensions: Arc::new(ExecutionExtensions::new(
-				None,
-				Arc::new(executor.clone()),
-			)),
-		};
-
-		let check = call_executor
-			.check_override(
-				onchain_code,
-				&backend.state_at(backend.blockchain().info().genesis_hash).unwrap(),
-				backend.blockchain().info().genesis_hash,
-			)
-			.expect("RuntimeCode override")
-			.0;
-
-		assert_eq!(Some(vec![2, 2, 2, 2, 2, 2, 2, 2]), check.fetch_runtime_code().map(Into::into));
-	}
-
-	#[test]
-	fn returns_runtime_version_from_substitute() {
-		const SUBSTITUTE_SPEC_NAME: &str = "substitute-spec-name-cool";
-
-		let executor = WasmExecutor::default();
-
-		let backend = Arc::new(in_mem::Backend::<runtime::Block>::new());
-
-		// Let's only override the `spec_name` for our testing purposes.
-		let substitute = sp_version::embed::embed_runtime_version(
-			&substrate_test_runtime::WASM_BINARY_BLOATY.unwrap(),
-			sp_version::RuntimeVersion {
-				spec_name: SUBSTITUTE_SPEC_NAME.into(),
-				..substrate_test_runtime::VERSION
-			},
-		)
-		.unwrap();
-
-		let client_config = crate::client::ClientConfig {
-			wasm_runtime_substitutes: vec![(0, substitute)].into_iter().collect::<HashMap<_, _>>(),
-			..Default::default()
-		};
-
-		let genesis_block_builder = crate::GenesisBlockBuilder::new(
-			&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
-			!client_config.no_genesis,
-			backend.clone(),
-			executor.clone(),
-		)
-		.expect("Creates genesis block builder");
-
-		// client is used for the convenience of creating and inserting the genesis block.
-		let client =
-			crate::client::new_with_backend::<_, _, runtime::Block, _, runtime::RuntimeApi>(
-				backend.clone(),
-				executor.clone(),
-				genesis_block_builder,
-				Box::new(TaskExecutor::new()),
-				None,
-				None,
-				client_config,
-			)
-			.expect("Creates a client");
-
-		let version = client.runtime_version_at(client.chain_info().genesis_hash).unwrap();
-
-		assert_eq!(SUBSTITUTE_SPEC_NAME, &*version.spec_name);
-	}
-}
diff --git a/substrate/client/service/src/client/client.rs b/substrate/client/service/src/client/client.rs
index 3c25c233775bea6ed8297d144bcadf823b918e7e..2fbcc3ba4f7569863124f55e3712a88af1109fff 100644
--- a/substrate/client/service/src/client/client.rs
+++ b/substrate/client/service/src/client/client.rs
@@ -18,7 +18,10 @@
 
 //! Substrate Client
 
-use super::block_rules::{BlockRules, LookupResult as BlockLookupResult};
+use super::{
+	block_rules::{BlockRules, LookupResult as BlockLookupResult},
+	CodeProvider,
+};
 use crate::client::notification_pinning::NotificationPinningWorker;
 use log::{debug, info, trace, warn};
 use parking_lot::{Mutex, RwLock};
@@ -57,10 +60,7 @@ use sp_consensus::{BlockOrigin, BlockStatus, Error as ConsensusError};
 
 use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
 use sp_core::{
-	storage::{
-		well_known_keys, ChildInfo, ChildType, PrefixedStorageKey, StorageChild, StorageData,
-		StorageKey,
-	},
+	storage::{ChildInfo, ChildType, PrefixedStorageKey, StorageChild, StorageData, StorageKey},
 	traits::{CallContext, SpawnNamed},
 };
 use sp_runtime::{
@@ -115,6 +115,7 @@ where
 	config: ClientConfig<Block>,
 	telemetry: Option<TelemetryHandle>,
 	unpin_worker_sender: TracingUnboundedSender<UnpinWorkerMessage<Block>>,
+	code_provider: CodeProvider<Block, B, E>,
 	_phantom: PhantomData<RA>,
 }
 
@@ -410,6 +411,7 @@ where
 			Block,
 			BlockImportOperation = <B as backend::Backend<Block>>::BlockImportOperation,
 		>,
+		E: Clone,
 		B: 'static,
 	{
 		let info = backend.blockchain().info();
@@ -438,6 +440,7 @@ where
 		);
 		let unpin_worker = NotificationPinningWorker::new(rx, backend.clone());
 		spawn_handle.spawn("notification-pinning-worker", None, Box::pin(unpin_worker.run()));
+		let code_provider = CodeProvider::new(&config, executor.clone(), backend.clone())?;
 
 		Ok(Client {
 			backend,
@@ -453,6 +456,7 @@ where
 			config,
 			telemetry,
 			unpin_worker_sender,
+			code_provider,
 			_phantom: Default::default(),
 		})
 	}
@@ -475,13 +479,10 @@ where
 	}
 
 	/// Get the code at a given block.
+	///
+	/// This takes any potential substitutes into account, but ignores overrides.
 	pub fn code_at(&self, hash: Block::Hash) -> sp_blockchain::Result<Vec<u8>> {
-		Ok(StorageProvider::storage(self, hash, &StorageKey(well_known_keys::CODE.to_vec()))?
-			.expect(
-				"None is returned if there's no value stored for the given key;\
-				':code' key is always defined; qed",
-			)
-			.0)
+		self.code_provider.code_at_ignoring_overrides(hash)
 	}
 
 	/// Get the RuntimeVersion at a given block.
diff --git a/substrate/client/service/src/client/code_provider.rs b/substrate/client/service/src/client/code_provider.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8ba7766ea65b5ba0a723aaa151d7121e2bbc4c53
--- /dev/null
+++ b/substrate/client/service/src/client/code_provider.rs
@@ -0,0 +1,348 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use super::{client::ClientConfig, wasm_override::WasmOverride, wasm_substitutes::WasmSubstitutes};
+use sc_client_api::backend;
+use sc_executor::{RuntimeVersion, RuntimeVersionOf};
+use sp_core::traits::{FetchRuntimeCode, RuntimeCode};
+use sp_runtime::traits::Block as BlockT;
+use sp_state_machine::{Ext, OverlayedChanges};
+use std::sync::Arc;
+
+/// Provider for fetching `:code` of a block.
+///
+/// As a node can run with code overrides or substitutes, this will ensure that these are taken into
+/// account before returning the actual `code` for a block.
+pub struct CodeProvider<Block: BlockT, Backend, Executor> {
+	backend: Arc<Backend>,
+	executor: Arc<Executor>,
+	wasm_override: Arc<Option<WasmOverride>>,
+	wasm_substitutes: WasmSubstitutes<Block, Executor, Backend>,
+}
+
+impl<Block: BlockT, Backend, Executor: Clone> Clone for CodeProvider<Block, Backend, Executor> {
+	fn clone(&self) -> Self {
+		Self {
+			backend: self.backend.clone(),
+			executor: self.executor.clone(),
+			wasm_override: self.wasm_override.clone(),
+			wasm_substitutes: self.wasm_substitutes.clone(),
+		}
+	}
+}
+
+impl<Block, Backend, Executor> CodeProvider<Block, Backend, Executor>
+where
+	Block: BlockT,
+	Backend: backend::Backend<Block>,
+	Executor: RuntimeVersionOf,
+{
+	/// Create a new instance.
+	pub fn new(
+		client_config: &ClientConfig<Block>,
+		executor: Executor,
+		backend: Arc<Backend>,
+	) -> sp_blockchain::Result<Self> {
+		let wasm_override = client_config
+			.wasm_runtime_overrides
+			.as_ref()
+			.map(|p| WasmOverride::new(p.clone(), &executor))
+			.transpose()?;
+
+		let executor = Arc::new(executor);
+
+		let wasm_substitutes = WasmSubstitutes::new(
+			client_config.wasm_runtime_substitutes.clone(),
+			executor.clone(),
+			backend.clone(),
+		)?;
+
+		Ok(Self { backend, executor, wasm_override: Arc::new(wasm_override), wasm_substitutes })
+	}
+
+	/// Returns the `:code` for the given `block`.
+	///
+	/// This takes into account potential overrides/substitutes.
+	pub fn code_at_ignoring_overrides(&self, block: Block::Hash) -> sp_blockchain::Result<Vec<u8>> {
+		let state = self.backend.state_at(block)?;
+
+		let state_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(&state);
+		let runtime_code =
+			state_runtime_code.runtime_code().map_err(sp_blockchain::Error::RuntimeCode)?;
+
+		self.maybe_override_code_internal(runtime_code, &state, block, true)
+			.and_then(|r| {
+				r.0.fetch_runtime_code().map(Into::into).ok_or_else(|| {
+					sp_blockchain::Error::Backend("Could not find `:code` in backend.".into())
+				})
+			})
+	}
+
+	/// Maybe override the given `onchain_code`.
+	///
+	/// This takes into account potential overrides/substitutes.
+	pub fn maybe_override_code<'a>(
+		&'a self,
+		onchain_code: RuntimeCode<'a>,
+		state: &Backend::State,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<(RuntimeCode<'a>, RuntimeVersion)> {
+		self.maybe_override_code_internal(onchain_code, state, hash, false)
+	}
+
+	/// Maybe override the given `onchain_code`.
+	///
+	/// This takes into account potential overrides(depending on `ignore_overrides`)/substitutes.
+	fn maybe_override_code_internal<'a>(
+		&'a self,
+		onchain_code: RuntimeCode<'a>,
+		state: &Backend::State,
+		hash: Block::Hash,
+		ignore_overrides: bool,
+	) -> sp_blockchain::Result<(RuntimeCode<'a>, RuntimeVersion)> {
+		let on_chain_version = self.on_chain_runtime_version(&onchain_code, state)?;
+		let code_and_version = if let Some(d) = self.wasm_override.as_ref().as_ref().and_then(|o| {
+			if ignore_overrides {
+				return None
+			}
+
+			o.get(
+				&on_chain_version.spec_version,
+				onchain_code.heap_pages,
+				&on_chain_version.spec_name,
+			)
+		}) {
+			tracing::debug!(target: "code-provider::overrides", block = ?hash, "using WASM override");
+			d
+		} else if let Some(s) =
+			self.wasm_substitutes
+				.get(on_chain_version.spec_version, onchain_code.heap_pages, hash)
+		{
+			tracing::debug!(target: "code-provider::substitutes", block = ?hash, "Using WASM substitute");
+			s
+		} else {
+			tracing::debug!(
+				target: "code-provider",
+				block = ?hash,
+				"Neither WASM override nor substitute available, using onchain code",
+			);
+			(onchain_code, on_chain_version)
+		};
+
+		Ok(code_and_version)
+	}
+
+	/// Returns the on chain runtime version.
+	fn on_chain_runtime_version(
+		&self,
+		code: &RuntimeCode,
+		state: &Backend::State,
+	) -> sp_blockchain::Result<RuntimeVersion> {
+		let mut overlay = OverlayedChanges::default();
+
+		let mut ext = Ext::new(&mut overlay, state, None);
+
+		self.executor
+			.runtime_version(&mut ext, code)
+			.map_err(|e| sp_blockchain::Error::VersionInvalid(e.to_string()))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use backend::Backend;
+	use sc_client_api::{in_mem, HeaderBackend};
+	use sc_executor::WasmExecutor;
+	use sp_core::{
+		testing::TaskExecutor,
+		traits::{FetchRuntimeCode, WrappedRuntimeCode},
+	};
+	use std::collections::HashMap;
+	use substrate_test_runtime_client::{runtime, GenesisInit};
+
+	#[test]
+	fn no_override_no_substitutes_work() {
+		let executor = WasmExecutor::default();
+
+		let code_fetcher = WrappedRuntimeCode(substrate_test_runtime::wasm_binary_unwrap().into());
+		let onchain_code = RuntimeCode {
+			code_fetcher: &code_fetcher,
+			heap_pages: Some(128),
+			hash: vec![0, 0, 0, 0],
+		};
+
+		let backend = Arc::new(in_mem::Backend::<runtime::Block>::new());
+
+		// wasm_runtime_overrides is `None` here because we construct the
+		// LocalCallExecutor directly later on
+		let client_config = ClientConfig::default();
+
+		let genesis_block_builder = crate::GenesisBlockBuilder::new(
+			&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
+			!client_config.no_genesis,
+			backend.clone(),
+			executor.clone(),
+		)
+		.expect("Creates genesis block builder");
+
+		// client is used for the convenience of creating and inserting the genesis block.
+		let _client =
+			crate::client::new_with_backend::<_, _, runtime::Block, _, runtime::RuntimeApi>(
+				backend.clone(),
+				executor.clone(),
+				genesis_block_builder,
+				Box::new(TaskExecutor::new()),
+				None,
+				None,
+				client_config.clone(),
+			)
+			.expect("Creates a client");
+
+		let executor = Arc::new(executor);
+
+		let code_provider = CodeProvider {
+			backend: backend.clone(),
+			executor: executor.clone(),
+			wasm_override: Arc::new(None),
+			wasm_substitutes: WasmSubstitutes::new(Default::default(), executor, backend.clone())
+				.unwrap(),
+		};
+
+		let check = code_provider
+			.maybe_override_code(
+				onchain_code,
+				&backend.state_at(backend.blockchain().info().genesis_hash).unwrap(),
+				backend.blockchain().info().genesis_hash,
+			)
+			.expect("RuntimeCode override")
+			.0;
+
+		assert_eq!(code_fetcher.fetch_runtime_code(), check.fetch_runtime_code());
+	}
+
+	#[test]
+	fn should_get_override_if_exists() {
+		let executor = WasmExecutor::default();
+
+		let overrides = crate::client::wasm_override::dummy_overrides();
+		let onchain_code = WrappedRuntimeCode(substrate_test_runtime::wasm_binary_unwrap().into());
+		let onchain_code = RuntimeCode {
+			code_fetcher: &onchain_code,
+			heap_pages: Some(128),
+			hash: vec![0, 0, 0, 0],
+		};
+
+		let backend = Arc::new(in_mem::Backend::<runtime::Block>::new());
+
+		// wasm_runtime_overrides is `None` here because we construct the
+		// LocalCallExecutor directly later on
+		let client_config = ClientConfig::default();
+
+		let genesis_block_builder = crate::GenesisBlockBuilder::new(
+			&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
+			!client_config.no_genesis,
+			backend.clone(),
+			executor.clone(),
+		)
+		.expect("Creates genesis block builder");
+
+		// client is used for the convenience of creating and inserting the genesis block.
+		let _client =
+			crate::client::new_with_backend::<_, _, runtime::Block, _, runtime::RuntimeApi>(
+				backend.clone(),
+				executor.clone(),
+				genesis_block_builder,
+				Box::new(TaskExecutor::new()),
+				None,
+				None,
+				client_config.clone(),
+			)
+			.expect("Creates a client");
+
+		let executor = Arc::new(executor);
+
+		let code_provider = CodeProvider {
+			backend: backend.clone(),
+			executor: executor.clone(),
+			wasm_override: Arc::new(Some(overrides)),
+			wasm_substitutes: WasmSubstitutes::new(Default::default(), executor, backend.clone())
+				.unwrap(),
+		};
+
+		let check = code_provider
+			.maybe_override_code(
+				onchain_code,
+				&backend.state_at(backend.blockchain().info().genesis_hash).unwrap(),
+				backend.blockchain().info().genesis_hash,
+			)
+			.expect("RuntimeCode override")
+			.0;
+
+		assert_eq!(Some(vec![2, 2, 2, 2, 2, 2, 2, 2]), check.fetch_runtime_code().map(Into::into));
+	}
+
+	#[test]
+	fn returns_runtime_version_from_substitute() {
+		const SUBSTITUTE_SPEC_NAME: &str = "substitute-spec-name-cool";
+
+		let executor = WasmExecutor::default();
+
+		let backend = Arc::new(in_mem::Backend::<runtime::Block>::new());
+
+		// Let's only override the `spec_name` for our testing purposes.
+		let substitute = sp_version::embed::embed_runtime_version(
+			&substrate_test_runtime::WASM_BINARY_BLOATY.unwrap(),
+			sp_version::RuntimeVersion {
+				spec_name: SUBSTITUTE_SPEC_NAME.into(),
+				..substrate_test_runtime::VERSION
+			},
+		)
+		.unwrap();
+
+		let client_config = crate::client::ClientConfig {
+			wasm_runtime_substitutes: vec![(0, substitute)].into_iter().collect::<HashMap<_, _>>(),
+			..Default::default()
+		};
+
+		let genesis_block_builder = crate::GenesisBlockBuilder::new(
+			&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
+			!client_config.no_genesis,
+			backend.clone(),
+			executor.clone(),
+		)
+		.expect("Creates genesis block builder");
+
+		// client is used for the convenience of creating and inserting the genesis block.
+		let client =
+			crate::client::new_with_backend::<_, _, runtime::Block, _, runtime::RuntimeApi>(
+				backend.clone(),
+				executor.clone(),
+				genesis_block_builder,
+				Box::new(TaskExecutor::new()),
+				None,
+				None,
+				client_config,
+			)
+			.expect("Creates a client");
+
+		let version = client.runtime_version_at(client.chain_info().genesis_hash).unwrap();
+
+		assert_eq!(SUBSTITUTE_SPEC_NAME, &*version.spec_name);
+	}
+}
diff --git a/substrate/client/service/src/client/mod.rs b/substrate/client/service/src/client/mod.rs
index 0703cc2b47d144d4e67418cfb9966cd1cd209392..ec77a92f162f0c2927a8d5fb6537e4e2ebb861a8 100644
--- a/substrate/client/service/src/client/mod.rs
+++ b/substrate/client/service/src/client/mod.rs
@@ -47,14 +47,14 @@
 mod block_rules;
 mod call_executor;
 mod client;
+mod code_provider;
 mod notification_pinning;
 mod wasm_override;
 mod wasm_substitutes;
 
-pub use self::{
-	call_executor::LocalCallExecutor,
-	client::{Client, ClientConfig},
-};
+pub use call_executor::LocalCallExecutor;
+pub use client::{Client, ClientConfig};
+pub(crate) use code_provider::CodeProvider;
 
 #[cfg(feature = "test-helpers")]
 pub use self::client::{new_in_mem, new_with_backend};
diff --git a/substrate/client/service/src/client/wasm_substitutes.rs b/substrate/client/service/src/client/wasm_substitutes.rs
index 70db0ef20f5a83907536f67d8ef36500a8065b48..07ca6c96062831f37ecf35ef70847f47ec9b20d8 100644
--- a/substrate/client/service/src/client/wasm_substitutes.rs
+++ b/substrate/client/service/src/client/wasm_substitutes.rs
@@ -94,7 +94,7 @@ impl From<WasmSubstituteError> for sp_blockchain::Error {
 pub struct WasmSubstitutes<Block: BlockT, Executor, Backend> {
 	/// spec_version -> WasmSubstitute
 	substitutes: Arc<HashMap<u32, WasmSubstitute<Block>>>,
-	executor: Executor,
+	executor: Arc<Executor>,
 	backend: Arc<Backend>,
 }
 
@@ -110,14 +110,14 @@ impl<Block: BlockT, Executor: Clone, Backend> Clone for WasmSubstitutes<Block, E
 
 impl<Executor, Backend, Block> WasmSubstitutes<Block, Executor, Backend>
 where
-	Executor: RuntimeVersionOf + Clone + 'static,
+	Executor: RuntimeVersionOf,
 	Backend: backend::Backend<Block>,
 	Block: BlockT,
 {
 	/// Create a new instance.
 	pub fn new(
 		substitutes: HashMap<NumberFor<Block>, Vec<u8>>,
-		executor: Executor,
+		executor: Arc<Executor>,
 		backend: Arc<Backend>,
 	) -> Result<Self> {
 		let substitutes = substitutes
diff --git a/substrate/client/service/src/config.rs b/substrate/client/service/src/config.rs
index 187e18aa3cace20c9fe9ffe2e9f3fdcbb6658bbd..e4788f1f3376cc24d2436fd0282bd9b2c1a28844 100644
--- a/substrate/client/service/src/config.rs
+++ b/substrate/client/service/src/config.rs
@@ -280,7 +280,7 @@ impl Default for RpcMethods {
 static mut BASE_PATH_TEMP: Option<TempDir> = None;
 
 /// The base path that is used for everything that needs to be written on disk to run a node.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct BasePath {
 	path: PathBuf,
 }
diff --git a/substrate/client/service/src/lib.rs b/substrate/client/service/src/lib.rs
index d251fd2b58fa7252f2b7a797da0228af1d89cafe..a51bb4012d5d8ac0a4fb39e73c5a872a33e5fa7d 100644
--- a/substrate/client/service/src/lib.rs
+++ b/substrate/client/service/src/lib.rs
@@ -76,7 +76,7 @@ pub use config::{
 };
 pub use sc_chain_spec::{
 	ChainSpec, ChainType, Extension as ChainSpecExtension, GenericChainSpec, NoExtension,
-	Properties, RuntimeGenesis,
+	Properties,
 };
 
 pub use sc_consensus::ImportQueue;
diff --git a/substrate/client/service/test/Cargo.toml b/substrate/client/service/test/Cargo.toml
index e95e06cee267e68ca4b87f7179c8c66b9de40f61..3c754231395273838b02f8020d646aebd9ea54a2 100644
--- a/substrate/client/service/test/Cargo.toml
+++ b/substrate/client/service/test/Cargo.toml
@@ -20,7 +20,7 @@ array-bytes = "6.2.2"
 fdlimit = "0.3.0"
 futures = "0.3.30"
 log = { workspace = true, default-features = true }
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 parking_lot = "0.12.1"
 tempfile = "3.1.0"
 tokio = { version = "1.22.0", features = ["time"] }
diff --git a/substrate/client/service/test/src/client/mod.rs b/substrate/client/service/test/src/client/mod.rs
index 6542830c998b3a4f29df2f6a32f9d71c0aee688a..bd48fae634445eafe61b591e47a6883ba57056e2 100644
--- a/substrate/client/service/test/src/client/mod.rs
+++ b/substrate/client/service/test/src/client/mod.rs
@@ -17,8 +17,8 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use async_channel::TryRecvError;
+use codec::{Decode, Encode, Joiner};
 use futures::executor::block_on;
-use parity_scale_codec::{Decode, Encode, Joiner};
 use sc_block_builder::BlockBuilderBuilder;
 use sc_client_api::{
 	in_mem, BlockBackend, BlockchainEvents, ExecutorProvider, FinalityNotifications, HeaderBackend,
diff --git a/substrate/client/service/test/src/lib.rs b/substrate/client/service/test/src/lib.rs
index f19b5a19739e2b9c90f5848e2332e487d0ccd5fe..e60bd9410c6453594469c21661875334d1501c68 100644
--- a/substrate/client/service/test/src/lib.rs
+++ b/substrate/client/service/test/src/lib.rs
@@ -31,7 +31,7 @@ use sc_service::{
 	client::Client,
 	config::{BasePath, DatabaseSource, KeystoreConfig, RpcBatchRequestConfig},
 	BlocksPruning, ChainSpecExtension, Configuration, Error, GenericChainSpec, Role,
-	RuntimeGenesis, SpawnTaskHandle, TaskManager,
+	SpawnTaskHandle, TaskManager,
 };
 use sc_transaction_pool_api::TransactionPool;
 use sp_blockchain::HeaderBackend;
@@ -46,16 +46,16 @@ mod client;
 /// Maximum duration of single wait call.
 const MAX_WAIT_TIME: Duration = Duration::from_secs(60 * 3);
 
-struct TestNet<G, E, F, U> {
+struct TestNet<E, F, U> {
 	runtime: Runtime,
 	authority_nodes: Vec<(usize, F, U, MultiaddrWithPeerId)>,
 	full_nodes: Vec<(usize, F, U, MultiaddrWithPeerId)>,
-	chain_spec: GenericChainSpec<G, E>,
+	chain_spec: GenericChainSpec<E>,
 	base_port: u16,
 	nodes: usize,
 }
 
-impl<G, E, F, U> Drop for TestNet<G, E, F, U> {
+impl<E, F, U> Drop for TestNet<E, F, U> {
 	fn drop(&mut self) {
 		// Drop the nodes before dropping the runtime, as the runtime otherwise waits for all
 		// futures to be ended and we run into a dead lock.
@@ -162,7 +162,7 @@ where
 	}
 }
 
-impl<G, E, F, U> TestNet<G, E, F, U>
+impl<E, F, U> TestNet<E, F, U>
 where
 	F: Clone + Send + 'static,
 	U: Clone + Send + 'static,
@@ -193,12 +193,9 @@ where
 	}
 }
 
-fn node_config<
-	G: RuntimeGenesis + 'static,
-	E: ChainSpecExtension + Clone + 'static + Send + Sync,
->(
+fn node_config<E: ChainSpecExtension + Clone + 'static + Send + Sync>(
 	index: usize,
-	spec: &GenericChainSpec<G, E>,
+	spec: &GenericChainSpec<E>,
 	role: Role,
 	tokio_handle: tokio::runtime::Handle,
 	key_seed: Option<String>,
@@ -272,19 +269,18 @@ fn node_config<
 	}
 }
 
-impl<G, E, F, U> TestNet<G, E, F, U>
+impl<E, F, U> TestNet<E, F, U>
 where
 	F: TestNetNode,
 	E: ChainSpecExtension + Clone + 'static + Send + Sync,
-	G: RuntimeGenesis + 'static,
 {
 	fn new(
 		temp: &TempDir,
-		spec: GenericChainSpec<G, E>,
+		spec: GenericChainSpec<E>,
 		full: impl Iterator<Item = impl FnOnce(Configuration) -> Result<(F, U), Error>>,
 		authorities: impl Iterator<Item = (String, impl FnOnce(Configuration) -> Result<(F, U), Error>)>,
 		base_port: u16,
-	) -> TestNet<G, E, F, U> {
+	) -> TestNet<E, F, U> {
 		sp_tracing::try_init_simple();
 		fdlimit::raise_fd_limit().unwrap();
 		let runtime = Runtime::new().expect("Error creating tokio runtime");
@@ -365,10 +361,9 @@ fn tempdir_with_prefix(prefix: &str) -> TempDir {
 		.expect("Error creating test dir")
 }
 
-pub fn connectivity<G, E, Fb, F>(spec: GenericChainSpec<G, E>, full_builder: Fb)
+pub fn connectivity<E, Fb, F>(spec: GenericChainSpec<E>, full_builder: Fb)
 where
 	E: ChainSpecExtension + Clone + 'static + Send + Sync,
-	G: RuntimeGenesis + 'static,
 	Fb: Fn(Configuration) -> Result<F, Error>,
 	F: TestNetNode,
 {
@@ -442,8 +437,8 @@ where
 	}
 }
 
-pub fn sync<G, E, Fb, F, B, ExF, U>(
-	spec: GenericChainSpec<G, E>,
+pub fn sync<E, Fb, F, B, ExF, U>(
+	spec: GenericChainSpec<E>,
 	full_builder: Fb,
 	mut make_block_and_import: B,
 	mut extrinsic_factory: ExF,
@@ -454,7 +449,6 @@ pub fn sync<G, E, Fb, F, B, ExF, U>(
 	ExF: FnMut(&F, &U) -> <F::Block as BlockT>::Extrinsic,
 	U: Clone + Send + 'static,
 	E: ChainSpecExtension + Clone + 'static + Send + Sync,
-	G: RuntimeGenesis + 'static,
 {
 	const NUM_FULL_NODES: usize = 10;
 	const NUM_BLOCKS: usize = 512;
@@ -513,15 +507,14 @@ pub fn sync<G, E, Fb, F, B, ExF, U>(
 	network.run_until_all_full(|_index, service| service.transaction_pool().ready().count() == 1);
 }
 
-pub fn consensus<G, E, Fb, F>(
-	spec: GenericChainSpec<G, E>,
+pub fn consensus<E, Fb, F>(
+	spec: GenericChainSpec<E>,
 	full_builder: Fb,
 	authorities: impl IntoIterator<Item = String>,
 ) where
 	Fb: Fn(Configuration) -> Result<F, Error>,
 	F: TestNetNode,
 	E: ChainSpecExtension + Clone + 'static + Send + Sync,
-	G: RuntimeGenesis + 'static,
 {
 	const NUM_FULL_NODES: usize = 10;
 	const NUM_BLOCKS: usize = 10; // 10 * 2 sec block production time = ~20 seconds
diff --git a/substrate/client/telemetry/src/endpoints.rs b/substrate/client/telemetry/src/endpoints.rs
index c7a60726a5656108dfb588d96c8ede33bb4de391..c49b114152ae1473a22bd3ef76e808ddfaef6bbd 100644
--- a/substrate/client/telemetry/src/endpoints.rs
+++ b/substrate/client/telemetry/src/endpoints.rs
@@ -16,7 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use sc_network::{multiaddr, Multiaddr};
+use libp2p::multiaddr::{self, Multiaddr};
 use serde::{Deserialize, Deserializer, Serialize};
 
 /// List of telemetry servers we want to talk to. Contains the URL of the server, and the
diff --git a/substrate/client/telemetry/src/lib.rs b/substrate/client/telemetry/src/lib.rs
index f8a201e7611c2fa50a871e663e5f6c21f76ba07a..7e3a4ee8639308bd4678288db583e31c5085af5b 100644
--- a/substrate/client/telemetry/src/lib.rs
+++ b/substrate/client/telemetry/src/lib.rs
@@ -37,9 +37,9 @@
 #![warn(missing_docs)]
 
 use futures::{channel::mpsc, prelude::*};
+use libp2p::Multiaddr;
 use log::{error, warn};
 use parking_lot::Mutex;
-use sc_network::Multiaddr;
 use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
 use serde::Serialize;
 use std::{
diff --git a/substrate/client/telemetry/src/node.rs b/substrate/client/telemetry/src/node.rs
index 9b2443799d3deb23967973aa6670c6d92ea0bbfd..0bbdbfb622ef1ba478b62174d277e49ac836ff64 100644
--- a/substrate/client/telemetry/src/node.rs
+++ b/substrate/client/telemetry/src/node.rs
@@ -18,9 +18,8 @@
 
 use crate::TelemetryPayload;
 use futures::{channel::mpsc, prelude::*};
-use libp2p::core::transport::Transport;
+use libp2p::{core::transport::Transport, Multiaddr};
 use rand::Rng as _;
-use sc_network::Multiaddr;
 use std::{
 	fmt, mem,
 	pin::Pin,
diff --git a/substrate/client/tracing/src/logging/mod.rs b/substrate/client/tracing/src/logging/mod.rs
index 46fd4efb339a363a69929dba7091bc9bb685a5bd..05ec9fcf6ef08bc06a77a9f543322d57dc091400 100644
--- a/substrate/client/tracing/src/logging/mod.rs
+++ b/substrate/client/tracing/src/logging/mod.rs
@@ -142,9 +142,13 @@ where
 			parse_default_directive("libp2p_mdns::behaviour::iface=off")
 				.expect("provided directive is valid"),
 		)
+		// Disable annoying log messages from rustls
 		.add_directive(
 			parse_default_directive("rustls::common_state=off")
 				.expect("provided directive is valid"),
+		)
+		.add_directive(
+			parse_default_directive("rustls::conn=off").expect("provided directive is valid"),
 		);
 
 	if let Ok(lvl) = std::env::var("RUST_LOG") {
diff --git a/substrate/client/transaction-pool/README.md b/substrate/client/transaction-pool/README.md
index 7a53727d576103800375a99d0544b3b67efad79e..30a3a8118b5233cd76856f0cf1c2eab6e94a22ed 100644
--- a/substrate/client/transaction-pool/README.md
+++ b/substrate/client/transaction-pool/README.md
@@ -49,7 +49,7 @@ pool, it's broadcasting status, block inclusion, finality, etc.
 
 ## Transaction Validity details
 
-Information retrieved from the the runtime are encapsulated in the `TransactionValidity`
+Information retrieved from the runtime are encapsulated in the `TransactionValidity`
 type.
 
 ```rust
diff --git a/substrate/frame/Cargo.toml b/substrate/frame/Cargo.toml
index 3942f06ce6eec966dd2883e679e3cfe570251b35..a3b3d1900e6e6b536a876705a443d810fbe09f4d 100644
--- a/substrate/frame/Cargo.toml
+++ b/substrate/frame/Cargo.toml
@@ -18,7 +18,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 # external deps
-parity-scale-codec = { version = "3.6.12", default-features = false, features = [
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
 	"derive",
 ] }
 scale-info = { version = "2.11.1", default-features = false, features = [
@@ -83,6 +83,7 @@ runtime = [
 	"frame-system-rpc-runtime-api",
 ]
 std = [
+	"codec/std",
 	"frame-benchmarking?/std",
 	"frame-executive?/std",
 	"frame-support/std",
@@ -91,7 +92,6 @@ std = [
 	"frame-system/std",
 	"frame-try-runtime?/std",
 	"log/std",
-	"parity-scale-codec/std",
 	"scale-info/std",
 	"sp-api?/std",
 	"sp-arithmetic/std",
diff --git a/substrate/frame/alliance/src/mock.rs b/substrate/frame/alliance/src/mock.rs
index 7116e69efa17ec88134699570b2235b8b0973d7c..1a0a899bcccb4b8a7f194f0770de03bf7fab7451 100644
--- a/substrate/frame/alliance/src/mock.rs
+++ b/substrate/frame/alliance/src/mock.rs
@@ -42,7 +42,6 @@ type BlockNumber = u64;
 type AccountId = u64;
 
 parameter_types! {
-	pub const BlockHashCount: BlockNumber = 250;
 	pub BlockWeights: frame_system::limits::BlockWeights =
 		frame_system::limits::BlockWeights::simple_max(Weight::MAX);
 }
@@ -53,24 +52,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
-parameter_types! {
-	pub const ExistentialDeposit: u64 = 1;
-	pub const MaxLocks: u32 = 10;
-}
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = MaxLocks;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 const MOTION_DURATION_IN_BLOCKS: BlockNumber = 3;
diff --git a/substrate/frame/asset-conversion/ops/src/mock.rs b/substrate/frame/asset-conversion/ops/src/mock.rs
index 9454b3a9ad448af4b47d9fd974e6ec8ad5ed4e59..91c18b2e79494eb39812c0aca9f33dfdf6710d60 100644
--- a/substrate/frame/asset-conversion/ops/src/mock.rs
+++ b/substrate/frame/asset-conversion/ops/src/mock.rs
@@ -52,7 +52,7 @@ construct_runtime!(
   }
 );
 
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<u64>;
@@ -60,7 +60,6 @@ impl frame_system::Config for Test {
 
 #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type ReserveIdentifier = [u8; 8];
 	type AccountStore = System;
 }
 
diff --git a/substrate/frame/asset-conversion/src/mock.rs b/substrate/frame/asset-conversion/src/mock.rs
index 477866e0051bc43207d1fb728380e5f84258964f..d8832d70488af7d38507c83a964bc1c2c07815d0 100644
--- a/substrate/frame/asset-conversion/src/mock.rs
+++ b/substrate/frame/asset-conversion/src/mock.rs
@@ -61,20 +61,11 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u128>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
 	type Balance = u128;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ConstU128<100>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_assets::Config<Instance1> for Test {
diff --git a/substrate/frame/asset-rate/src/mock.rs b/substrate/frame/asset-rate/src/mock.rs
index d01996dab193d6d6e21a14efed7f14ff2ef8c931..c829d78afa886ad50546196322e37921c7240ed7 100644
--- a/substrate/frame/asset-rate/src/mock.rs
+++ b/substrate/frame/asset-rate/src/mock.rs
@@ -18,7 +18,7 @@
 //! The crate's mock.
 
 use crate as pallet_asset_rate;
-use frame_support::{derive_impl, traits::ConstU64};
+use frame_support::derive_impl;
 use sp_runtime::BuildStorage;
 
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -38,20 +38,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
 }
 
 impl pallet_asset_rate::Config for Test {
diff --git a/substrate/frame/assets-freezer/Cargo.toml b/substrate/frame/assets-freezer/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d7b5d2d40c4ecf1beea0583dd0fe6da918c9edaf
--- /dev/null
+++ b/substrate/frame/assets-freezer/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "pallet-assets-freezer"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository.workspace = true
+description = "Provides freezing features to `pallet-assets`"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { workspace = true }
+scale-info = { version = "2.10.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { path = "../benchmarking", default-features = false, optional = true }
+frame-support = { path = "../support", default-features = false }
+frame-system = { path = "../system", default-features = false }
+pallet-assets = { path = "../assets", default-features = false }
+sp-runtime = { path = "../../primitives/runtime", default-features = false }
+
+[dev-dependencies]
+sp-io = { path = "../../primitives/io", default-features = false }
+sp-core = { path = "../../primitives/core", default-features = false }
+pallet-balances = { path = "../balances", default-features = false }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-assets/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-assets/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-assets/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/assets-freezer/src/impls.rs b/substrate/frame/assets-freezer/src/impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cd383f1c3cd1e68f7cc0bcf0bb2841f0acf52119
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/impls.rs
@@ -0,0 +1,158 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::*;
+
+use frame_support::traits::{
+	fungibles::{Inspect, InspectFreeze, MutateFreeze},
+	tokens::{DepositConsequence, Fortitude, Preservation, Provenance, WithdrawConsequence},
+};
+use pallet_assets::FrozenBalance;
+use sp_runtime::traits::Zero;
+
+// Implements [`FrozenBalance`] from [`pallet-assets`], so it can understand how much of an
+// account balance is frozen, and is able to signal to this pallet when to clear the state of an
+// account.
+impl<T: Config<I>, I: 'static> FrozenBalance<T::AssetId, T::AccountId, T::Balance>
+	for Pallet<T, I>
+{
+	fn frozen_balance(asset: T::AssetId, who: &T::AccountId) -> Option<T::Balance> {
+		FrozenBalances::<T, I>::get(asset, who)
+	}
+
+	fn died(asset: T::AssetId, who: &T::AccountId) {
+		FrozenBalances::<T, I>::remove(asset.clone(), who);
+		Freezes::<T, I>::remove(asset, who);
+	}
+}
+
+// Implement [`fungibles::Inspect`](frame_support::traits::fungibles::Inspect) as it is bound by
+// [`fungibles::InspectFreeze`](frame_support::traits::fungibles::InspectFreeze) and
+// [`fungibles::MutateFreeze`](frame_support::traits::fungibles::MutateFreeze). To do so, we'll
+// re-export all of `pallet-assets` implementation of the same trait.
+impl<T: Config<I>, I: 'static> Inspect<T::AccountId> for Pallet<T, I> {
+	type AssetId = T::AssetId;
+	type Balance = T::Balance;
+
+	fn total_issuance(asset: Self::AssetId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::total_issuance(asset)
+	}
+
+	fn minimum_balance(asset: Self::AssetId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::minimum_balance(asset)
+	}
+
+	fn total_balance(asset: Self::AssetId, who: &T::AccountId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::total_balance(asset, who)
+	}
+
+	fn balance(asset: Self::AssetId, who: &T::AccountId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::balance(asset, who)
+	}
+
+	fn reducible_balance(
+		asset: Self::AssetId,
+		who: &T::AccountId,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::reducible_balance(asset, who, preservation, force)
+	}
+
+	fn can_deposit(
+		asset: Self::AssetId,
+		who: &T::AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence {
+		pallet_assets::Pallet::<T, I>::can_deposit(asset, who, amount, provenance)
+	}
+
+	fn can_withdraw(
+		asset: Self::AssetId,
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance> {
+		pallet_assets::Pallet::<T, I>::can_withdraw(asset, who, amount)
+	}
+
+	fn asset_exists(asset: Self::AssetId) -> bool {
+		pallet_assets::Pallet::<T, I>::asset_exists(asset)
+	}
+}
+
+impl<T: Config<I>, I: 'static> InspectFreeze<T::AccountId> for Pallet<T, I> {
+	type Id = T::RuntimeFreezeReason;
+
+	fn balance_frozen(asset: Self::AssetId, id: &Self::Id, who: &T::AccountId) -> Self::Balance {
+		let freezes = Freezes::<T, I>::get(asset, who);
+		freezes.into_iter().find(|l| &l.id == id).map_or(Zero::zero(), |l| l.amount)
+	}
+
+	fn can_freeze(asset: Self::AssetId, id: &Self::Id, who: &T::AccountId) -> bool {
+		let freezes = Freezes::<T, I>::get(asset, who);
+		!freezes.is_full() || freezes.into_iter().any(|i| i.id == *id)
+	}
+}
+
+impl<T: Config<I>, I: 'static> MutateFreeze<T::AccountId> for Pallet<T, I> {
+	fn set_freeze(
+		asset: Self::AssetId,
+		id: &Self::Id,
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> sp_runtime::DispatchResult {
+		if amount.is_zero() {
+			return Self::thaw(asset, id, who);
+		}
+		let mut freezes = Freezes::<T, I>::get(asset.clone(), who);
+		if let Some(i) = freezes.iter_mut().find(|i| &i.id == id) {
+			i.amount = amount;
+		} else {
+			freezes
+				.try_push(IdAmount { id: *id, amount })
+				.map_err(|_| Error::<T, I>::TooManyFreezes)?;
+		}
+		Self::update_freezes(asset, who, freezes.as_bounded_slice())
+	}
+
+	fn extend_freeze(
+		asset: Self::AssetId,
+		id: &Self::Id,
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> sp_runtime::DispatchResult {
+		if amount.is_zero() {
+			return Ok(());
+		}
+		let mut freezes = Freezes::<T, I>::get(asset.clone(), who);
+		if let Some(i) = freezes.iter_mut().find(|x| &x.id == id) {
+			i.amount = i.amount.max(amount);
+		} else {
+			freezes
+				.try_push(IdAmount { id: *id, amount })
+				.map_err(|_| Error::<T, I>::TooManyFreezes)?;
+		}
+		Self::update_freezes(asset, who, freezes.as_bounded_slice())
+	}
+
+	fn thaw(asset: Self::AssetId, id: &Self::Id, who: &T::AccountId) -> sp_runtime::DispatchResult {
+		let mut freezes = Freezes::<T, I>::get(asset.clone(), who);
+		freezes.retain(|f| &f.id != id);
+		Self::update_freezes(asset, who, freezes.as_bounded_slice())
+	}
+}
diff --git a/substrate/frame/assets-freezer/src/lib.rs b/substrate/frame/assets-freezer/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b42d41ac1d9255c0046de37ddf5cf1222173be7f
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/lib.rs
@@ -0,0 +1,176 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! # Assets Freezer Pallet
+//!
+//! A pallet capable of freezing fungibles from `pallet-assets`. This is an extension of
+//! `pallet-assets`, wrapping [`fungibles::Inspect`](`frame_support::traits::fungibles::Inspect`).
+//! It implements both
+//! [`fungibles::freeze::Inspect`](frame_support::traits::fungibles::freeze::Inspect) and
+//! [`fungibles::freeze::Mutate`](frame_support::traits::fungibles::freeze::Mutate). The complexity
+//! of the operations is `O(n)`. where `n` is the variant count of `RuntimeFreezeReason`.
+//!
+//! ## Pallet API
+//!
+//! See the [`pallet`] module for more information about the interfaces this pallet exposes,
+//! including its configuration trait, dispatchables, storage items, events and errors.
+//!
+//! ## Overview
+//!
+//! This pallet provides the following functionality:
+//!
+//! - Pallet hooks allowing [`pallet-assets`] to know the frozen balance for an account on a given
+//!   asset (see [`pallet_assets::FrozenBalance`]).
+//! - An implementation of
+//!   [`fungibles::freeze::Inspect`](frame_support::traits::fungibles::freeze::Inspect) and
+//!   [`fungibles::freeze::Mutate`](frame_support::traits::fungibles::freeze::Mutate), allowing
+//!   other pallets to manage freezes for the `pallet-assets` assets.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{
+	pallet_prelude::*,
+	traits::{tokens::IdAmount, VariantCount, VariantCountOf},
+	BoundedVec,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	BoundedSlice,
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+mod impls;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::config(with_default)]
+	pub trait Config<I: 'static = ()>: frame_system::Config + pallet_assets::Config<I> {
+		/// The overarching freeze reason.
+		#[pallet::no_default_bounds]
+		type RuntimeFreezeReason: Parameter + Member + MaxEncodedLen + Copy + VariantCount;
+
+		/// The overarching event type.
+		#[pallet::no_default_bounds]
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Number of freezes on an account would exceed `MaxFreezes`.
+		TooManyFreezes,
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		// `who`s frozen balance was increased by `amount`.
+		Frozen { who: T::AccountId, asset_id: T::AssetId, amount: T::Balance },
+		// `who`s frozen balance was decreased by `amount`.
+		Thawed { who: T::AccountId, asset_id: T::AssetId, amount: T::Balance },
+	}
+
+	/// A map that stores freezes applied on an account for a given AssetId.
+	#[pallet::storage]
+	pub(super) type Freezes<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::AssetId,
+		Blake2_128Concat,
+		T::AccountId,
+		BoundedVec<
+			IdAmount<T::RuntimeFreezeReason, T::Balance>,
+			VariantCountOf<T::RuntimeFreezeReason>,
+		>,
+		ValueQuery,
+	>;
+
+	/// A map that stores the current total frozen balance for every account on a given AssetId.
+	#[pallet::storage]
+	pub(super) type FrozenBalances<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::AssetId,
+		Blake2_128Concat,
+		T::AccountId,
+		T::Balance,
+	>;
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
+			Self::do_try_state()
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	fn update_freezes(
+		asset: T::AssetId,
+		who: &T::AccountId,
+		freezes: BoundedSlice<
+			IdAmount<T::RuntimeFreezeReason, T::Balance>,
+			VariantCountOf<T::RuntimeFreezeReason>,
+		>,
+	) -> DispatchResult {
+		let prev_frozen = FrozenBalances::<T, I>::get(asset.clone(), who).unwrap_or_default();
+		let after_frozen = freezes.into_iter().map(|f| f.amount).max().unwrap_or_else(Zero::zero);
+		FrozenBalances::<T, I>::set(asset.clone(), who, Some(after_frozen));
+		if freezes.is_empty() {
+			Freezes::<T, I>::remove(asset.clone(), who);
+			FrozenBalances::<T, I>::remove(asset.clone(), who);
+		} else {
+			Freezes::<T, I>::insert(asset.clone(), who, freezes);
+		}
+		if prev_frozen > after_frozen {
+			let amount = prev_frozen.saturating_sub(after_frozen);
+			Self::deposit_event(Event::Thawed { asset_id: asset, who: who.clone(), amount });
+		} else if after_frozen > prev_frozen {
+			let amount = after_frozen.saturating_sub(prev_frozen);
+			Self::deposit_event(Event::Frozen { asset_id: asset, who: who.clone(), amount });
+		}
+		Ok(())
+	}
+
+	#[cfg(any(test, feature = "try-runtime"))]
+	fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> {
+		for (asset, who, _) in FrozenBalances::<T, I>::iter() {
+			let max_frozen_amount =
+				Freezes::<T, I>::get(asset.clone(), who.clone()).iter().map(|l| l.amount).max();
+
+			frame_support::ensure!(
+				FrozenBalances::<T, I>::get(asset, who) == max_frozen_amount,
+				"The `FrozenAmount` is not equal to the maximum amount in `Freezes` for (`asset`, `who`)"
+			);
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/assets-freezer/src/mock.rs b/substrate/frame/assets-freezer/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b4e8c857fba49cf5dd9b6fc194d9a06d596dcae3
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/mock.rs
@@ -0,0 +1,154 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests mock for `pallet-assets-freezer`.
+
+use crate as pallet_assets_freezer;
+pub use crate::*;
+use codec::{Compact, Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	derive_impl,
+	traits::{AsEnsureOriginWithArg, ConstU64},
+};
+use scale_info::TypeInfo;
+use sp_core::{ConstU32, H256};
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+pub type AccountId = u64;
+pub type Balance = u64;
+pub type AssetId = u32;
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Assets: pallet_assets,
+		AssetsFreezer: pallet_assets_freezer,
+		Balances: pallet_balances,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_balances::Config for Test {
+	type MaxLocks = ();
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
+	type Balance = Balance;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = ConstU64<1>;
+	type AccountStore = System;
+	type WeightInfo = ();
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type RuntimeFreezeReason = ();
+}
+
+impl pallet_assets::Config for Test {
+	type AssetId = AssetId;
+	type AssetIdParameter = Compact<AssetId>;
+	type AssetDeposit = ConstU64<1>;
+	type Balance = Balance;
+	type AssetAccountDeposit = ConstU64<1>;
+	type MetadataDepositBase = ();
+	type MetadataDepositPerByte = ();
+	type ApprovalDeposit = ();
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<u64>>;
+	type ForceOrigin = frame_system::EnsureRoot<u64>;
+	type StringLimit = ConstU32<32>;
+	type Extra = ();
+	type RemoveItemsLimit = ConstU32<10>;
+	type CallbackHandle = ();
+	type Currency = Balances;
+	type Freezer = AssetsFreezer;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+#[derive(
+	Decode, Encode, MaxEncodedLen, PartialEq, Eq, Ord, PartialOrd, TypeInfo, Debug, Clone, Copy,
+)]
+pub enum DummyFreezeReason {
+	Governance,
+	Staking,
+	Other,
+}
+
+impl VariantCount for DummyFreezeReason {
+	// Intentionally set below the actual count of variants, to allow testing for `can_freeze`
+	const VARIANT_COUNT: u32 = 2;
+}
+
+impl Config for Test {
+	type RuntimeFreezeReason = DummyFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
+pub fn new_test_ext(execute: impl FnOnce()) -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig {
+		assets: pallet_assets::GenesisConfig {
+			assets: vec![(1, 0, true, 1)],
+			metadata: vec![],
+			accounts: vec![(1, 1, 100)],
+		},
+		system: Default::default(),
+		balances: Default::default(),
+	}
+	.build_storage()
+	.unwrap();
+	let mut ext: sp_io::TestExternalities = t.into();
+	ext.execute_with(|| {
+		System::set_block_number(1);
+		execute();
+		frame_support::assert_ok!(AssetsFreezer::do_try_state());
+	});
+
+	ext
+}
diff --git a/substrate/frame/assets-freezer/src/tests.rs b/substrate/frame/assets-freezer/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4f2dea79c705a9ecacba4ec427f2f8553920f9a1
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/tests.rs
@@ -0,0 +1,304 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests for pallet-assets-freezer.
+
+use crate::mock::*;
+
+use codec::Compact;
+use frame_support::{
+	assert_ok, assert_storage_noop,
+	traits::{
+		fungibles::{Inspect, InspectFreeze, MutateFreeze},
+		tokens::{Fortitude, Preservation},
+	},
+};
+use pallet_assets::FrozenBalance;
+
+const WHO: AccountId = 1;
+const ASSET_ID: AssetId = 1;
+
+fn test_set_freeze(id: DummyFreezeReason, amount: Balance) {
+	let mut freezes = Freezes::<Test>::get(ASSET_ID, WHO);
+
+	if let Some(i) = freezes.iter_mut().find(|l| l.id == id) {
+		i.amount = amount;
+	} else {
+		freezes
+			.try_push(IdAmount { id, amount })
+			.expect("freeze is added without exceeding bounds; qed");
+	}
+
+	assert_ok!(AssetsFreezer::update_freezes(ASSET_ID, &WHO, freezes.as_bounded_slice()));
+}
+
+fn test_thaw(id: DummyFreezeReason) {
+	let mut freezes = Freezes::<Test>::get(ASSET_ID, WHO);
+	freezes.retain(|l| l.id != id);
+
+	assert_ok!(AssetsFreezer::update_freezes(ASSET_ID, &WHO, freezes.as_bounded_slice()));
+}
+
+mod impl_frozen_balance {
+	use super::*;
+
+	#[test]
+	fn frozen_balance_works() {
+		new_test_ext(|| {
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), None);
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(1u64));
+			test_set_freeze(DummyFreezeReason::Staking, 3);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(3u64));
+			test_set_freeze(DummyFreezeReason::Governance, 2);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(3u64));
+			// also test thawing works to reduce a balance, and finally thawing everything resets to
+			// None
+			test_thaw(DummyFreezeReason::Governance);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(3u64));
+			test_thaw(DummyFreezeReason::Staking);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), None);
+		});
+	}
+
+	#[test]
+	fn died_works() {
+		new_test_ext(|| {
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			AssetsFreezer::died(ASSET_ID, &WHO);
+			assert!(FrozenBalances::<Test>::get(ASSET_ID, WHO).is_none());
+			assert!(Freezes::<Test>::get(ASSET_ID, WHO).is_empty());
+		});
+	}
+}
+
+mod impl_inspect_freeze {
+	use super::*;
+
+	#[test]
+	fn balance_frozen_works() {
+		new_test_ext(|| {
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Governance, &WHO),
+				0u64
+			);
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Governance, &WHO),
+				1u64
+			);
+			test_set_freeze(DummyFreezeReason::Staking, 3);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Staking, &WHO),
+				3u64
+			);
+			test_set_freeze(DummyFreezeReason::Staking, 2);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Staking, &WHO),
+				2u64
+			);
+			// also test thawing works to reduce a balance, and finally thawing everything resets to
+			// 0
+			test_thaw(DummyFreezeReason::Governance);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Governance, &WHO),
+				0u64
+			);
+			test_thaw(DummyFreezeReason::Staking);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Staking, &WHO),
+				0u64
+			);
+		});
+	}
+
+	/// This tests it's not possible to freeze once the freezes [`BoundedVec`] is full. This is,
+	/// the lenght of the vec is equal to [`Config::MaxFreezes`].
+	/// This test assumes a mock configuration where this parameter is set to `2`.
+	#[test]
+	fn can_freeze_works() {
+		new_test_ext(|| {
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			assert!(AssetsFreezer::can_freeze(ASSET_ID, &DummyFreezeReason::Staking, &WHO));
+			test_set_freeze(DummyFreezeReason::Staking, 1);
+			assert!(!AssetsFreezer::can_freeze(ASSET_ID, &DummyFreezeReason::Other, &WHO));
+		});
+	}
+}
+
+mod impl_mutate_freeze {
+	use super::*;
+
+	#[test]
+	fn set_freeze_works() {
+		new_test_ext(|| {
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				99
+			);
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				10
+			));
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				89
+			);
+			System::assert_last_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				8
+			));
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				91
+			);
+			System::assert_last_event(
+				Event::<Test>::Thawed { asset_id: ASSET_ID, who: WHO, amount: 2 }.into(),
+			);
+		});
+	}
+
+	#[test]
+	fn extend_freeze_works() {
+		new_test_ext(|| {
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				10
+			));
+			assert_storage_noop!(assert_ok!(AssetsFreezer::extend_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				8
+			)));
+			System::assert_last_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				89
+			);
+			assert_ok!(AssetsFreezer::extend_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				11
+			));
+			System::assert_last_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 1 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				88
+			);
+		});
+	}
+
+	#[test]
+	fn thaw_works() {
+		new_test_ext(|| {
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				10
+			));
+			System::assert_has_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				89
+			);
+			assert_ok!(AssetsFreezer::thaw(ASSET_ID, &DummyFreezeReason::Governance, &WHO));
+			System::assert_has_event(
+				Event::<Test>::Thawed { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				99
+			);
+		});
+	}
+}
+
+mod with_pallet_assets {
+	use frame_support::assert_noop;
+
+	use super::*;
+
+	#[test]
+	fn frozen_balance_affects_balance_transferring() {
+		new_test_ext(|| {
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				20
+			));
+			assert_noop!(
+				Assets::transfer(RuntimeOrigin::signed(WHO), Compact(ASSET_ID), 2, 80),
+				pallet_assets::Error::<Test>::BalanceLow,
+			);
+			assert_ok!(Assets::transfer(RuntimeOrigin::signed(WHO), Compact(ASSET_ID), 2, 79));
+		});
+	}
+}
diff --git a/substrate/frame/assets/src/mock.rs b/substrate/frame/assets/src/mock.rs
index f6173a451fffaee41f66dc6f697a40cd68e3648b..694ef234dffb4e3e9ec79560f351b1462fa0afc0 100644
--- a/substrate/frame/assets/src/mock.rs
+++ b/substrate/frame/assets/src/mock.rs
@@ -23,7 +23,7 @@ use crate as pallet_assets;
 use codec::Encode;
 use frame_support::{
 	construct_runtime, derive_impl, parameter_types,
-	traits::{AsEnsureOriginWithArg, ConstU32, ConstU64},
+	traits::{AsEnsureOriginWithArg, ConstU32},
 };
 use sp_io::storage;
 use sp_runtime::BuildStorage;
@@ -49,20 +49,9 @@ impl frame_system::Config for Test {
 	type MaxConsumers = ConstU32<3>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
 }
 
 pub struct AssetsCallbackHandle;
diff --git a/substrate/frame/atomic-swap/src/tests.rs b/substrate/frame/atomic-swap/src/tests.rs
index 9f51f04208aaccca281398b0382718f2165d8a0e..47ebe6a8f0acf26021a84f37bf76d703aeba1374 100644
--- a/substrate/frame/atomic-swap/src/tests.rs
+++ b/substrate/frame/atomic-swap/src/tests.rs
@@ -20,10 +20,7 @@
 use super::*;
 use crate as pallet_atomic_swap;
 
-use frame_support::{
-	derive_impl,
-	traits::{ConstU32, ConstU64},
-};
+use frame_support::{derive_impl, traits::ConstU32};
 use sp_runtime::BuildStorage;
 
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -43,20 +40,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl Config for Test {
diff --git a/substrate/frame/babe/src/mock.rs b/substrate/frame/babe/src/mock.rs
index 395a86e6528807ff21ee2667d1446016b6826a1e..be38e3e7e5db5c0438688c584a81cc7ad3dc1913 100644
--- a/substrate/frame/babe/src/mock.rs
+++ b/substrate/frame/babe/src/mock.rs
@@ -28,7 +28,6 @@ use frame_support::{
 	traits::{ConstU128, ConstU32, ConstU64, KeyOwnerProofSystem, OnInitialize},
 };
 use pallet_session::historical as pallet_session_historical;
-use pallet_staking::FixedNominationsQuota;
 use sp_consensus_babe::{AuthorityId, AuthorityPair, Randomness, Slot, VrfSignature};
 use sp_core::{
 	crypto::{KeyTypeId, Pair, VrfSecret},
@@ -112,20 +111,11 @@ impl pallet_timestamp::Config for Test {
 	type WeightInfo = ();
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = u128;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ConstU128<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 pallet_staking_reward_curve::build! {
@@ -142,7 +132,6 @@ pallet_staking_reward_curve::build! {
 parameter_types! {
 	pub const SessionsPerEra: SessionIndex = 3;
 	pub const BondingDuration: EraIndex = 3;
-	pub const SlashDeferDuration: EraIndex = 0;
 	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
 	pub static ElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
 }
@@ -157,35 +146,20 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type Bounds = ElectionsBounds;
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Test {
-	type RewardRemainder = ();
-	type CurrencyToVote = ();
-	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
-	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
-	type Slash = ();
-	type Reward = ();
 	type SessionsPerEra = SessionsPerEra;
 	type BondingDuration = BondingDuration;
-	type SlashDeferDuration = SlashDeferDuration;
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type SessionInterface = Self;
 	type UnixTime = pallet_timestamp::Pallet<Test>;
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
-	type MaxExposurePageSize = ConstU32<64>;
 	type NextNewSession = Session;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type HistoryDepth = ConstU32<84>;
-	type EventListeners = ();
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
 
 impl pallet_offences::Config for Test {
diff --git a/substrate/frame/balances/src/lib.rs b/substrate/frame/balances/src/lib.rs
index 56eb81b49e2db695abbb8d705db7cef21f599416..d01884293c0902ea66636877d1b3d65fbd74f5a1 100644
--- a/substrate/frame/balances/src/lib.rs
+++ b/substrate/frame/balances/src/lib.rs
@@ -158,6 +158,7 @@ use frame_support::{
 		tokens::{
 			fungible, BalanceStatus as Status, DepositConsequence,
 			Fortitude::{self, Force, Polite},
+			IdAmount,
 			Preservation::{Expendable, Preserve, Protect},
 			WithdrawConsequence,
 		},
@@ -177,8 +178,7 @@ use sp_runtime::{
 };
 use sp_std::{cmp, fmt::Debug, mem, prelude::*, result};
 pub use types::{
-	AccountData, AdjustmentDirection, BalanceLock, DustCleaner, ExtraFlags, IdAmount, Reasons,
-	ReserveData,
+	AccountData, AdjustmentDirection, BalanceLock, DustCleaner, ExtraFlags, Reasons, ReserveData,
 };
 pub use weights::WeightInfo;
 
@@ -222,13 +222,13 @@ pub mod pallet {
 			type ExistentialDeposit = ConstU64<1>;
 
 			type ReserveIdentifier = ();
-			type FreezeIdentifier = ();
+			type FreezeIdentifier = Self::RuntimeFreezeReason;
 
 			type DustRemoval = ();
 
 			type MaxLocks = ConstU32<100>;
 			type MaxReserves = ConstU32<100>;
-			type MaxFreezes = ConstU32<100>;
+			type MaxFreezes = VariantCountOf<Self::RuntimeFreezeReason>;
 
 			type WeightInfo = ();
 		}
diff --git a/substrate/frame/balances/src/tests/dispatchable_tests.rs b/substrate/frame/balances/src/tests/dispatchable_tests.rs
index 4bc96f6b43d97444252f42e4820d97168ed50e1e..ebc9f1b1a3695cb446e64018acc2bca772169b29 100644
--- a/substrate/frame/balances/src/tests/dispatchable_tests.rs
+++ b/substrate/frame/balances/src/tests/dispatchable_tests.rs
@@ -281,7 +281,7 @@ fn force_adjust_total_issuance_saturates() {
 	ExtBuilder::default().build_and_execute_with(|| {
 		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1337, 64));
 		let ti = Balances::total_issuance();
-		let max = Balance::max_value();
+		let max = <Test as Config>::Balance::max_value();
 		assert_eq!(ti, 64);
 
 		// Increment saturates:
diff --git a/substrate/frame/balances/src/tests/fungible_tests.rs b/substrate/frame/balances/src/tests/fungible_tests.rs
index 52fbe10bedec0f7131fe35fa7e6f809968741d42..1a09303a6590d54b3bb94ffb1d870d5c1e687b24 100644
--- a/substrate/frame/balances/src/tests/fungible_tests.rs
+++ b/substrate/frame/balances/src/tests/fungible_tests.rs
@@ -18,13 +18,20 @@
 //! Tests regarding the functionality of the `fungible` trait set implementations.
 
 use super::*;
-use frame_support::traits::tokens::{
-	Fortitude::{Force, Polite},
-	Precision::{BestEffort, Exact},
-	Preservation::{Expendable, Preserve, Protect},
-	Restriction::Free,
+use frame_support::traits::{
+	tokens::{
+		Fortitude::{Force, Polite},
+		Precision::{BestEffort, Exact},
+		Preservation::{Expendable, Preserve, Protect},
+		Restriction::Free,
+	},
+	Consideration, Footprint, LinearStoragePrice,
 };
-use fungible::{Inspect, InspectFreeze, InspectHold, Mutate, MutateFreeze, MutateHold, Unbalanced};
+use fungible::{
+	FreezeConsideration, HoldConsideration, Inspect, InspectFreeze, InspectHold,
+	LoneFreezeConsideration, LoneHoldConsideration, Mutate, MutateFreeze, MutateHold, Unbalanced,
+};
+use sp_core::ConstU64;
 
 #[test]
 fn inspect_trait_reducible_balance_basic_works() {
@@ -493,3 +500,161 @@ fn withdraw_precision_exact_works() {
 			);
 		});
 }
+
+#[test]
+fn freeze_consideration_works() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			type Consideration = FreezeConsideration<
+				u64,
+				Balances,
+				FooReason,
+				LinearStoragePrice<ConstU64<0>, ConstU64<1>, u64>,
+				Footprint,
+			>;
+
+			let who = 4;
+			// freeze amount taken somewhere outside of our (Consideration) scope.
+			let extend_freeze = 15;
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 0);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 10);
+
+			let ticket = ticket.update(&who, Footprint::from_parts(4, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 4);
+
+			assert_ok!(Balances::increase_frozen(&TestId::Foo, &who, extend_freeze));
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 4 + extend_freeze);
+
+			let ticket = ticket.update(&who, Footprint::from_parts(8, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 8 + extend_freeze);
+
+			assert_eq!(ticket.update(&who, Footprint::from_parts(0, 0)).unwrap(), None);
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 0 + extend_freeze);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 10 + extend_freeze);
+
+			let _ = ticket.drop(&who).unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 0 + extend_freeze);
+		});
+}
+
+#[test]
+fn hold_consideration_works() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			type Consideration = HoldConsideration<
+				u64,
+				Balances,
+				FooReason,
+				LinearStoragePrice<ConstU64<0>, ConstU64<1>, u64>,
+				Footprint,
+			>;
+
+			let who = 4;
+			// hold amount taken somewhere outside of our (Consideration) scope.
+			let extend_hold = 15;
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 0);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 10);
+
+			let ticket = ticket.update(&who, Footprint::from_parts(4, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 4);
+
+			assert_ok!(Balances::hold(&TestId::Foo, &who, extend_hold));
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 4 + extend_hold);
+
+			let ticket = ticket.update(&who, Footprint::from_parts(8, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 8 + extend_hold);
+
+			assert_eq!(ticket.update(&who, Footprint::from_parts(0, 0)).unwrap(), None);
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 0 + extend_hold);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 10 + extend_hold);
+
+			let _ = ticket.drop(&who).unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 0 + extend_hold);
+		});
+}
+
+#[test]
+fn lone_freeze_consideration_works() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			type Consideration = LoneFreezeConsideration<
+				u64,
+				Balances,
+				FooReason,
+				LinearStoragePrice<ConstU64<0>, ConstU64<1>, u64>,
+				Footprint,
+			>;
+
+			let who = 4;
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 0);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 10);
+
+			assert_ok!(Balances::increase_frozen(&TestId::Foo, &who, 5));
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 15);
+
+			let ticket = ticket.update(&who, Footprint::from_parts(4, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 4);
+
+			assert_eq!(ticket.update(&who, Footprint::from_parts(0, 0)).unwrap(), None);
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 0);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 10);
+
+			let _ = ticket.drop(&who).unwrap();
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &who), 0);
+		});
+}
+
+#[test]
+fn lone_hold_consideration_works() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			type Consideration = LoneHoldConsideration<
+				u64,
+				Balances,
+				FooReason,
+				LinearStoragePrice<ConstU64<0>, ConstU64<1>, u64>,
+				Footprint,
+			>;
+
+			let who = 4;
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 0);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 10);
+
+			assert_ok!(Balances::hold(&TestId::Foo, &who, 5));
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 15);
+
+			let ticket = ticket.update(&who, Footprint::from_parts(4, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 4);
+
+			assert_eq!(ticket.update(&who, Footprint::from_parts(0, 0)).unwrap(), None);
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 0);
+
+			let ticket = Consideration::new(&who, Footprint::from_parts(10, 1)).unwrap().unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 10);
+
+			let _ = ticket.drop(&who).unwrap();
+			assert_eq!(Balances::balance_on_hold(&TestId::Foo, &who), 0);
+		});
+}
diff --git a/substrate/frame/balances/src/tests/mod.rs b/substrate/frame/balances/src/tests/mod.rs
index 0abf2251290fee6881f0346aaab7df37ff2f0efb..ba0cdabdabbbdc8459fcb551ae3a1b704d479262 100644
--- a/substrate/frame/balances/src/tests/mod.rs
+++ b/substrate/frame/balances/src/tests/mod.rs
@@ -27,7 +27,7 @@ use frame_support::{
 	parameter_types,
 	traits::{
 		fungible, ConstU32, ConstU8, Imbalance as ImbalanceT, OnUnbalanced, StorageMapShim,
-		StoredMap, VariantCount, WhitelistedStorageKeys,
+		StoredMap, VariantCount, VariantCountOf, WhitelistedStorageKeys,
 	},
 	weights::{IdentityFee, Weight},
 };
@@ -107,22 +107,21 @@ impl pallet_transaction_payment::Config for Test {
 	type FeeMultiplierUpdate = ();
 }
 
-pub(crate) type Balance = u64;
+parameter_types! {
+	pub FooReason: TestId = TestId::Foo;
+}
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl Config for Test {
-	type Balance = Balance;
 	type DustRemoval = DustTrap;
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = TestAccountStore;
-	type MaxLocks = ConstU32<50>;
 	type MaxReserves = ConstU32<2>;
 	type ReserveIdentifier = TestId;
-	type WeightInfo = ();
 	type RuntimeHoldReason = TestId;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeFreezeReason = TestId;
 	type FreezeIdentifier = TestId;
-	type MaxFreezes = ConstU32<2>;
+	type MaxFreezes = VariantCountOf<TestId>;
 }
 
 #[derive(Clone)]
diff --git a/substrate/frame/balances/src/types.rs b/substrate/frame/balances/src/types.rs
index 3e36a83575c892812d687e5882784b023754fe44..917b7507d7c941156a080163bf029f468c75b097 100644
--- a/substrate/frame/balances/src/types.rs
+++ b/substrate/frame/balances/src/types.rs
@@ -78,15 +78,6 @@ pub struct ReserveData<ReserveIdentifier, Balance> {
 	pub amount: Balance,
 }
 
-/// An identifier and balance.
-#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
-pub struct IdAmount<Id, Balance> {
-	/// An identifier for this item.
-	pub id: Id,
-	/// Some amount for this item.
-	pub amount: Balance,
-}
-
 /// All balance information for an account.
 #[derive(Encode, Decode, Clone, PartialEq, Eq, Default, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 pub struct AccountData<Balance> {
diff --git a/substrate/frame/beefy/src/mock.rs b/substrate/frame/beefy/src/mock.rs
index 0b87de6bf5d79a3884d96f6f7cf79fc96ab3568b..35bf172d60632c7d56aef4acd196946256abb629 100644
--- a/substrate/frame/beefy/src/mock.rs
+++ b/substrate/frame/beefy/src/mock.rs
@@ -120,20 +120,11 @@ impl pallet_authorship::Config for Test {
 	type EventHandler = ();
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = u128;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ConstU128<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
 }
 
 impl pallet_timestamp::Config for Test {
@@ -171,35 +162,19 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type Bounds = ElectionsBoundsOnChain;
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Test {
-	type RewardRemainder = ();
-	type CurrencyToVote = ();
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
-	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
-	type Slash = ();
-	type Reward = ();
-	type SessionsPerEra = SessionsPerEra;
-	type BondingDuration = BondingDuration;
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type SessionInterface = Self;
 	type UnixTime = pallet_timestamp::Pallet<Test>;
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
-	type MaxExposurePageSize = ConstU32<64>;
 	type NextNewSession = Session;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type HistoryDepth = ConstU32<84>;
-	type EventListeners = ();
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
 
 impl pallet_offences::Config for Test {
diff --git a/substrate/frame/bounties/src/tests.rs b/substrate/frame/bounties/src/tests.rs
index a89f4ff9fbf301a8d03d9ad040a1b4009e7b18f6..205765e9286e2bd86c6d11b4db2fd20d7851c984 100644
--- a/substrate/frame/bounties/src/tests.rs
+++ b/substrate/frame/bounties/src/tests.rs
@@ -66,23 +66,11 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 parameter_types! {
-	pub const ProposalBond: Permill = Permill::from_percent(5);
 	pub static Burn: Permill = Permill::from_percent(50);
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
 	pub const TreasuryPalletId2: PalletId = PalletId(*b"py/trsr2");
@@ -99,9 +87,6 @@ impl pallet_treasury::Config for Test {
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = ();
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ConstU64<1>;
-	type ProposalBondMaximum = ();
 	type SpendPeriod = ConstU64<2>;
 	type Burn = Burn;
 	type BurnDestination = (); // Just gets burned.
@@ -126,9 +111,6 @@ impl pallet_treasury::Config<Instance1> for Test {
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = ();
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ConstU64<1>;
-	type ProposalBondMaximum = ();
 	type SpendPeriod = ConstU64<2>;
 	type Burn = Burn;
 	type BurnDestination = (); // Just gets burned.
@@ -227,56 +209,12 @@ fn minting_works() {
 	});
 }
 
-#[test]
-fn spend_proposal_takes_min_deposit() {
-	new_test_ext().execute_with(|| {
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 1, 3)
-		});
-		assert_eq!(Balances::free_balance(0), 99);
-		assert_eq!(Balances::reserved_balance(0), 1);
-	});
-}
-
-#[test]
-fn spend_proposal_takes_proportional_deposit() {
-	new_test_ext().execute_with(|| {
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_eq!(Balances::free_balance(0), 95);
-		assert_eq!(Balances::reserved_balance(0), 5);
-	});
-}
-
-#[test]
-fn spend_proposal_fails_when_proposer_poor() {
-	new_test_ext().execute_with(|| {
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::propose_spend(RuntimeOrigin::signed(2), 100, 3)
-			},
-			TreasuryError::InsufficientProposersBalance,
-		);
-	});
-}
-
 #[test]
 fn accepted_spend_proposal_ignored_outside_spend_period() {
 	new_test_ext().execute_with(|| {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!({ Treasury::spend_local(RuntimeOrigin::root(), 100, 3) });
 
 		<Treasury as OnInitialize<u64>>::on_initialize(1);
 		assert_eq!(Balances::free_balance(3), 0);
@@ -297,112 +235,13 @@ fn unused_pot_should_diminish() {
 	});
 }
 
-#[test]
-fn rejected_spend_proposal_ignored_on_spend_period() {
-	new_test_ext().execute_with(|| {
-		Balances::make_free_balance_be(&Treasury::account_id(), 101);
-
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-		});
-
-		<Treasury as OnInitialize<u64>>::on_initialize(2);
-		assert_eq!(Balances::free_balance(3), 0);
-		assert_eq!(Treasury::pot(), 50);
-	});
-}
-
-#[test]
-fn reject_already_rejected_spend_proposal_fails() {
-	new_test_ext().execute_with(|| {
-		Balances::make_free_balance_be(&Treasury::account_id(), 101);
-
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-		});
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-			},
-			TreasuryError::InvalidIndex
-		);
-	});
-}
-
-#[test]
-fn reject_non_existent_spend_proposal_fails() {
-	new_test_ext().execute_with(|| {
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-			},
-			pallet_treasury::Error::<Test>::InvalidIndex
-		);
-	});
-}
-
-#[test]
-fn accept_non_existent_spend_proposal_fails() {
-	new_test_ext().execute_with(|| {
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-			},
-			TreasuryError::InvalidIndex
-		);
-	});
-}
-
-#[test]
-fn accept_already_rejected_spend_proposal_fails() {
-	new_test_ext().execute_with(|| {
-		Balances::make_free_balance_be(&Treasury::account_id(), 101);
-
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-		});
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-			},
-			TreasuryError::InvalidIndex
-		);
-	});
-}
-
 #[test]
 fn accepted_spend_proposal_enacted_on_spend_period() {
 	new_test_ext().execute_with(|| {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_eq!(Treasury::pot(), 100);
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!({ Treasury::spend_local(RuntimeOrigin::root(), 100, 3) });
 
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Balances::free_balance(3), 100);
@@ -416,14 +255,7 @@ fn pot_underflow_should_not_diminish() {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_eq!(Treasury::pot(), 100);
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 150, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!({ Treasury::spend_local(RuntimeOrigin::root(), 150, 3) });
 
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Treasury::pot(), 100); // Pot hasn't changed
@@ -444,26 +276,12 @@ fn treasury_account_doesnt_get_deleted() {
 		assert_eq!(Treasury::pot(), 100);
 		let treasury_balance = Balances::free_balance(&Treasury::account_id());
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), treasury_balance, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!({ Treasury::spend_local(RuntimeOrigin::root(), treasury_balance, 3) });
 
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Treasury::pot(), 100); // Pot hasn't changed
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), Treasury::pot(), 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 1)
-		});
+		assert_ok!({ Treasury::spend_local(RuntimeOrigin::root(), Treasury::pot(), 3) });
 
 		<Treasury as OnInitialize<u64>>::on_initialize(4);
 		assert_eq!(Treasury::pot(), 0); // Pot is emptied
@@ -486,22 +304,8 @@ fn inexistent_account_works() {
 		assert_eq!(Balances::free_balance(Treasury::account_id()), 0); // Account does not exist
 		assert_eq!(Treasury::pot(), 0); // Pot is empty
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 99, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 1, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 1)
-		});
+		assert_ok!({ Treasury::spend_local(RuntimeOrigin::root(), 99, 3) });
+		assert_ok!({ Treasury::spend_local(RuntimeOrigin::root(), 1, 3) });
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Treasury::pot(), 0); // Pot hasn't changed
 		assert_eq!(Balances::free_balance(3), 0); // Balance of `3` hasn't changed
diff --git a/substrate/frame/broker/Cargo.toml b/substrate/frame/broker/Cargo.toml
index 8f3f30ec58ebc2ff868cee03037939d0e9aac884..8a84fbfdfb701c87cde1dfb935ad1dcb6cf56e04 100644
--- a/substrate/frame/broker/Cargo.toml
+++ b/substrate/frame/broker/Cargo.toml
@@ -30,6 +30,7 @@ frame-system = { path = "../system", default-features = false }
 
 [dev-dependencies]
 sp-io = { path = "../../primitives/io" }
+sp-tracing = { path = "../../primitives/tracing" }
 pretty_assertions = "1.3.0"
 
 [features]
diff --git a/substrate/frame/broker/src/adapt_price.rs b/substrate/frame/broker/src/adapt_price.rs
index fbcd7afdf0da059fb7023de3422f15b2344d5407..9b2e1dd8997bd68adfe8aef71bdad74f8c0ff529 100644
--- a/substrate/frame/broker/src/adapt_price.rs
+++ b/substrate/frame/broker/src/adapt_price.rs
@@ -17,59 +17,122 @@
 
 #![deny(missing_docs)]
 
-use crate::CoreIndex;
+use crate::{CoreIndex, SaleInfoRecord};
 use sp_arithmetic::{traits::One, FixedU64};
-use sp_runtime::Saturating;
+use sp_runtime::{FixedPointNumber, FixedPointOperand, Saturating};
+
+/// Performance of a past sale.
+#[derive(Copy, Clone)]
+pub struct SalePerformance<Balance> {
+	/// The price at which the last core was sold.
+	///
+	/// Will be `None` if no cores have been offered.
+	pub sellout_price: Option<Balance>,
+
+	/// The minimum price that was achieved in this sale.
+	pub end_price: Balance,
+
+	/// The number of cores we want to sell, ideally.
+	pub ideal_cores_sold: CoreIndex,
+
+	/// Number of cores which are/have been offered for sale.
+	pub cores_offered: CoreIndex,
+
+	/// Number of cores which have been sold; never more than cores_offered.
+	pub cores_sold: CoreIndex,
+}
+
+/// Result of `AdaptPrice::adapt_price`.
+#[derive(Copy, Clone)]
+pub struct AdaptedPrices<Balance> {
+	/// New minimum price to use.
+	pub end_price: Balance,
+
+	/// Price the controller is optimizing for.
+	///
+	/// This is the price "expected" by the controller based on the previous sale. We assume that
+	/// sales in this period will be around this price, assuming stable market conditions.
+	///
+	/// Think of it as the expected market price. This can be used for determining what to charge
+	/// for renewals, that don't yet have any price information for example. E.g. for expired
+	/// legacy leases.
+	pub target_price: Balance,
+}
+
+impl<Balance: Copy> SalePerformance<Balance> {
+	/// Construct performance via data from a `SaleInfoRecord`.
+	pub fn from_sale<BlockNumber>(record: &SaleInfoRecord<Balance, BlockNumber>) -> Self {
+		Self {
+			sellout_price: record.sellout_price,
+			end_price: record.end_price,
+			ideal_cores_sold: record.ideal_cores_sold,
+			cores_offered: record.cores_offered,
+			cores_sold: record.cores_sold,
+		}
+	}
+
+	#[cfg(test)]
+	fn new(sellout_price: Option<Balance>, end_price: Balance) -> Self {
+		Self { sellout_price, end_price, ideal_cores_sold: 0, cores_offered: 0, cores_sold: 0 }
+	}
+}
 
 /// Type for determining how to set price.
-pub trait AdaptPrice {
+pub trait AdaptPrice<Balance> {
 	/// Return the factor by which the regular price must be multiplied during the leadin period.
 	///
 	/// - `when`: The amount through the leadin period; between zero and one.
 	fn leadin_factor_at(when: FixedU64) -> FixedU64;
-	/// Return the correction factor by which the regular price must be multiplied based on market
-	/// performance.
+
+	/// Return adapted prices for next sale.
 	///
-	/// - `sold`: The number of cores sold.
-	/// - `target`: The target number of cores to be sold (must be larger than zero).
-	/// - `limit`: The maximum number of cores to be sold.
-	fn adapt_price(sold: CoreIndex, target: CoreIndex, limit: CoreIndex) -> FixedU64;
+	/// Based on the previous sale's performance.
+	fn adapt_price(performance: SalePerformance<Balance>) -> AdaptedPrices<Balance>;
 }
 
-impl AdaptPrice for () {
+impl<Balance: Copy> AdaptPrice<Balance> for () {
 	fn leadin_factor_at(_: FixedU64) -> FixedU64 {
 		FixedU64::one()
 	}
-	fn adapt_price(_: CoreIndex, _: CoreIndex, _: CoreIndex) -> FixedU64 {
-		FixedU64::one()
+	fn adapt_price(performance: SalePerformance<Balance>) -> AdaptedPrices<Balance> {
+		let price = performance.sellout_price.unwrap_or(performance.end_price);
+		AdaptedPrices { end_price: price, target_price: price }
 	}
 }
 
-/// Simple implementation of `AdaptPrice` giving a monotonic leadin and a linear price change based
-/// on cores sold.
-pub struct Linear;
-impl AdaptPrice for Linear {
+/// Simple implementation of `AdaptPrice` with two linear phases.
+///
+/// One steep one downwards to the target price, which is 1/10 of the maximum price and a more flat
+/// one down to the minimum price, which is 1/100 of the maximum price.
+pub struct CenterTargetPrice<Balance>(core::marker::PhantomData<Balance>);
+
+impl<Balance: FixedPointOperand> AdaptPrice<Balance> for CenterTargetPrice<Balance> {
 	fn leadin_factor_at(when: FixedU64) -> FixedU64 {
-		FixedU64::from(2).saturating_sub(when)
-	}
-	fn adapt_price(sold: CoreIndex, target: CoreIndex, limit: CoreIndex) -> FixedU64 {
-		if sold <= target {
-			// Range of [0.5, 1.0].
-			FixedU64::from_rational(1, 2).saturating_add(FixedU64::from_rational(
-				sold.into(),
-				target.saturating_mul(2).into(),
-			))
+		if when <= FixedU64::from_rational(1, 2) {
+			FixedU64::from(100).saturating_sub(when.saturating_mul(180.into()))
 		} else {
-			// Range of (1.0, 2].
-
-			// Unchecked math: In this branch we know that sold > target. The limit must be >= sold
-			// by construction, and thus target must be < limit.
-			FixedU64::one().saturating_add(FixedU64::from_rational(
-				(sold - target).into(),
-				(limit - target).into(),
-			))
+			FixedU64::from(19).saturating_sub(when.saturating_mul(18.into()))
 		}
 	}
+
+	fn adapt_price(performance: SalePerformance<Balance>) -> AdaptedPrices<Balance> {
+		let Some(sellout_price) = performance.sellout_price else {
+			return AdaptedPrices {
+				end_price: performance.end_price,
+				target_price: FixedU64::from(10).saturating_mul_int(performance.end_price),
+			}
+		};
+
+		let price = FixedU64::from_rational(1, 10).saturating_mul_int(sellout_price);
+		let price = if price == Balance::zero() {
+			// We could not recover from a price equal 0 ever.
+			sellout_price
+		} else {
+			price
+		};
+
+		AdaptedPrices { end_price: price, target_price: sellout_price }
+	}
 }
 
 #[cfg(test)]
@@ -78,37 +141,103 @@ mod tests {
 
 	#[test]
 	fn linear_no_panic() {
-		for limit in 0..10 {
-			for target in 1..10 {
-				for sold in 0..=limit {
-					let price = Linear::adapt_price(sold, target, limit);
-
-					if sold > target {
-						assert!(price > FixedU64::one());
-					} else {
-						assert!(price <= FixedU64::one());
-					}
-				}
+		for sellout in 0..11 {
+			for price in 0..10 {
+				let sellout_price = if sellout == 11 { None } else { Some(sellout) };
+				CenterTargetPrice::adapt_price(SalePerformance::new(sellout_price, price));
 			}
 		}
 	}
 
 	#[test]
-	fn linear_bound_check() {
-		// Using constraints from pallet implementation i.e. `limit >= sold`.
-		// Check extremes
-		let limit = 10;
-		let target = 5;
-
-		// Maximally sold: `sold == limit`
-		assert_eq!(Linear::adapt_price(limit, target, limit), FixedU64::from_float(2.0));
-		// Ideally sold: `sold == target`
-		assert_eq!(Linear::adapt_price(target, target, limit), FixedU64::one());
-		// Minimally sold: `sold == 0`
-		assert_eq!(Linear::adapt_price(0, target, limit), FixedU64::from_float(0.5));
-		// Optimistic target: `target == limit`
-		assert_eq!(Linear::adapt_price(limit, limit, limit), FixedU64::one());
-		// Pessimistic target: `target == 0`
-		assert_eq!(Linear::adapt_price(limit, 0, limit), FixedU64::from_float(2.0));
+	fn leadin_price_bound_check() {
+		assert_eq!(
+			CenterTargetPrice::<u64>::leadin_factor_at(FixedU64::from(0)),
+			FixedU64::from(100)
+		);
+		assert_eq!(
+			CenterTargetPrice::<u64>::leadin_factor_at(FixedU64::from_rational(1, 4)),
+			FixedU64::from(55)
+		);
+
+		assert_eq!(
+			CenterTargetPrice::<u64>::leadin_factor_at(FixedU64::from_float(0.5)),
+			FixedU64::from(10)
+		);
+
+		assert_eq!(
+			CenterTargetPrice::<u64>::leadin_factor_at(FixedU64::from_rational(3, 4)),
+			FixedU64::from_float(5.5)
+		);
+		assert_eq!(CenterTargetPrice::<u64>::leadin_factor_at(FixedU64::one()), FixedU64::one());
+	}
+
+	#[test]
+	fn no_op_sale_is_good() {
+		let prices = CenterTargetPrice::adapt_price(SalePerformance::new(None, 1));
+		assert_eq!(prices.target_price, 10);
+		assert_eq!(prices.end_price, 1);
+	}
+
+	#[test]
+	fn price_stays_stable_on_optimal_sale() {
+		// Check price stays stable if sold at the optimal price:
+		let mut performance = SalePerformance::new(Some(1000), 100);
+		for _ in 0..10 {
+			let prices = CenterTargetPrice::adapt_price(performance);
+			performance.sellout_price = Some(1000);
+			performance.end_price = prices.end_price;
+
+			assert!(prices.end_price <= 101);
+			assert!(prices.end_price >= 99);
+			assert!(prices.target_price <= 1001);
+			assert!(prices.target_price >= 999);
+		}
+	}
+
+	#[test]
+	fn price_adjusts_correctly_upwards() {
+		let performance = SalePerformance::new(Some(10_000), 100);
+		let prices = CenterTargetPrice::adapt_price(performance);
+		assert_eq!(prices.target_price, 10_000);
+		assert_eq!(prices.end_price, 1000);
+	}
+
+	#[test]
+	fn price_adjusts_correctly_downwards() {
+		let performance = SalePerformance::new(Some(100), 100);
+		let prices = CenterTargetPrice::adapt_price(performance);
+		assert_eq!(prices.target_price, 100);
+		assert_eq!(prices.end_price, 10);
+	}
+
+	#[test]
+	fn price_never_goes_to_zero_and_recovers() {
+		// Check price stays stable if sold at the optimal price:
+		let sellout_price = 1;
+		let mut performance = SalePerformance::new(Some(sellout_price), 1);
+		for _ in 0..11 {
+			let prices = CenterTargetPrice::adapt_price(performance);
+			performance.sellout_price = Some(sellout_price);
+			performance.end_price = prices.end_price;
+
+			assert!(prices.end_price <= sellout_price);
+			assert!(prices.end_price > 0);
+		}
+	}
+
+	#[test]
+	fn renewal_price_is_correct_on_no_sale() {
+		let performance = SalePerformance::new(None, 100);
+		let prices = CenterTargetPrice::adapt_price(performance);
+		assert_eq!(prices.target_price, 1000);
+		assert_eq!(prices.end_price, 100);
+	}
+
+	#[test]
+	fn renewal_price_is_sell_out() {
+		let performance = SalePerformance::new(Some(1000), 100);
+		let prices = CenterTargetPrice::adapt_price(performance);
+		assert_eq!(prices.target_price, 1000);
 	}
 }
diff --git a/substrate/frame/broker/src/benchmarking.rs b/substrate/frame/broker/src/benchmarking.rs
index 7533e3dc68c41fa54d39b7bb234ecaafe4e56fab..9cb5ad096c83b74e50a77993c2c3e0049ec2c876 100644
--- a/substrate/frame/broker/src/benchmarking.rs
+++ b/substrate/frame/broker/src/benchmarking.rs
@@ -214,8 +214,8 @@ mod benches {
 			Event::SaleInitialized {
 				sale_start: 2u32.into(),
 				leadin_length: 1u32.into(),
-				start_price: 20u32.into(),
-				regular_price: 10u32.into(),
+				start_price: 1000u32.into(),
+				end_price: 10u32.into(),
 				region_begin: latest_region_begin + config.region_length,
 				region_end: latest_region_begin + config.region_length * 2,
 				ideal_cores_sold: 0,
@@ -288,8 +288,8 @@ mod benches {
 		#[extrinsic_call]
 		_(RawOrigin::Signed(caller), region.core);
 
-		let id = AllowedRenewalId { core: region.core, when: region.begin + region_len * 2 };
-		assert!(AllowedRenewals::<T>::get(id).is_some());
+		let id = PotentialRenewalId { core: region.core, when: region.begin + region_len * 2 };
+		assert!(PotentialRenewals::<T>::get(id).is_some());
 
 		Ok(())
 	}
@@ -670,20 +670,20 @@ mod benches {
 			(T::TimeslicePeriod::get() * (region_len * 3).into()).try_into().ok().unwrap(),
 		);
 
-		let id = AllowedRenewalId { core, when };
-		let record = AllowedRenewalRecord {
+		let id = PotentialRenewalId { core, when };
+		let record = PotentialRenewalRecord {
 			price: 1u32.into(),
 			completion: CompletionStatus::Complete(new_schedule()),
 		};
-		AllowedRenewals::<T>::insert(id, record);
+		PotentialRenewals::<T>::insert(id, record);
 
 		let caller: T::AccountId = whitelisted_caller();
 
 		#[extrinsic_call]
 		_(RawOrigin::Signed(caller), core, when);
 
-		assert!(AllowedRenewals::<T>::get(id).is_none());
-		assert_last_event::<T>(Event::AllowedRenewalDropped { core, when }.into());
+		assert!(PotentialRenewals::<T>::get(id).is_none());
+		assert_last_event::<T>(Event::PotentialRenewalDropped { core, when }.into());
 
 		Ok(())
 	}
@@ -776,12 +776,12 @@ mod benches {
 		let config = new_config_record::<T>();
 
 		let now = frame_system::Pallet::<T>::block_number();
-		let price = 10u32.into();
+		let end_price = 10u32.into();
 		let commit_timeslice = Broker::<T>::latest_timeslice_ready_to_commit(&config);
 		let sale = SaleInfoRecordOf::<T> {
 			sale_start: now,
 			leadin_length: Zero::zero(),
-			price,
+			end_price,
 			sellout_price: None,
 			region_begin: commit_timeslice,
 			region_end: commit_timeslice.saturating_add(config.region_length),
@@ -815,8 +815,8 @@ mod benches {
 			Event::SaleInitialized {
 				sale_start: 2u32.into(),
 				leadin_length: 1u32.into(),
-				start_price: 20u32.into(),
-				regular_price: 10u32.into(),
+				start_price: 1000u32.into(),
+				end_price: 10u32.into(),
 				region_begin: sale.region_begin + config.region_length,
 				region_end: sale.region_end + config.region_length,
 				ideal_cores_sold: 0,
diff --git a/substrate/frame/broker/src/dispatchable_impls.rs b/substrate/frame/broker/src/dispatchable_impls.rs
index 45a0a514c307adaeb8be65f514e6c46251210d06..79c1a1f79796330a7377f06ef5f1a62045eb2848 100644
--- a/substrate/frame/broker/src/dispatchable_impls.rs
+++ b/substrate/frame/broker/src/dispatchable_impls.rs
@@ -70,7 +70,10 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
-	pub(crate) fn do_start_sales(price: BalanceOf<T>, extra_cores: CoreIndex) -> DispatchResult {
+	pub(crate) fn do_start_sales(
+		end_price: BalanceOf<T>,
+		extra_cores: CoreIndex,
+	) -> DispatchResult {
 		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
 
 		// Determine the core count
@@ -93,7 +96,7 @@ impl<T: Config> Pallet<T> {
 		let old_sale = SaleInfoRecord {
 			sale_start: now,
 			leadin_length: Zero::zero(),
-			price,
+			end_price,
 			sellout_price: None,
 			region_begin: commit_timeslice,
 			region_end: commit_timeslice.saturating_add(config.region_length),
@@ -102,7 +105,7 @@ impl<T: Config> Pallet<T> {
 			cores_offered: 0,
 			cores_sold: 0,
 		};
-		Self::deposit_event(Event::<T>::SalesStarted { price, core_count });
+		Self::deposit_event(Event::<T>::SalesStarted { price: end_price, core_count });
 		Self::rotate_sale(old_sale, &config, &status);
 		Status::<T>::put(&status);
 		Ok(())
@@ -121,12 +124,8 @@ impl<T: Config> Pallet<T> {
 		let price = Self::sale_price(&sale, now);
 		ensure!(price_limit >= price, Error::<T>::Overpriced);
 
-		Self::charge(&who, price)?;
-		let core = sale.first_core.saturating_add(sale.cores_sold);
-		sale.cores_sold.saturating_inc();
-		if sale.cores_sold <= sale.ideal_cores_sold || sale.sellout_price.is_none() {
-			sale.sellout_price = Some(price);
-		}
+		let core = Self::purchase_core(&who, price, &mut sale)?;
+
 		SaleInfo::<T>::put(&sale);
 		let id =
 			Self::issue(core, sale.region_begin, sale.region_end, Some(who.clone()), Some(price));
@@ -135,7 +134,7 @@ impl<T: Config> Pallet<T> {
 		Ok(id)
 	}
 
-	/// Must be called on a core in `AllowedRenewals` whose value is a timeslice equal to the
+	/// Must be called on a core in `PotentialRenewals` whose value is a timeslice equal to the
 	/// current sale status's `region_end`.
 	pub(crate) fn do_renew(who: T::AccountId, core: CoreIndex) -> Result<CoreIndex, DispatchError> {
 		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
@@ -143,14 +142,15 @@ impl<T: Config> Pallet<T> {
 		let mut sale = SaleInfo::<T>::get().ok_or(Error::<T>::NoSales)?;
 		Self::ensure_cores_for_sale(&status, &sale)?;
 
-		let renewal_id = AllowedRenewalId { core, when: sale.region_begin };
-		let record = AllowedRenewals::<T>::get(renewal_id).ok_or(Error::<T>::NotAllowed)?;
+		let renewal_id = PotentialRenewalId { core, when: sale.region_begin };
+		let record = PotentialRenewals::<T>::get(renewal_id).ok_or(Error::<T>::NotAllowed)?;
 		let workload =
 			record.completion.drain_complete().ok_or(Error::<T>::IncompleteAssignment)?;
 
 		let old_core = core;
-		let core = sale.first_core.saturating_add(sale.cores_sold);
-		Self::charge(&who, record.price)?;
+
+		let core = Self::purchase_core(&who, record.price, &mut sale)?;
+
 		Self::deposit_event(Event::Renewed {
 			who,
 			old_core,
@@ -161,19 +161,24 @@ impl<T: Config> Pallet<T> {
 			workload: workload.clone(),
 		});
 
-		sale.cores_sold.saturating_inc();
-
 		Workplan::<T>::insert((sale.region_begin, core), &workload);
 
 		let begin = sale.region_end;
 		let price_cap = record.price + config.renewal_bump * record.price;
 		let now = frame_system::Pallet::<T>::block_number();
 		let price = Self::sale_price(&sale, now).min(price_cap);
-		let new_record = AllowedRenewalRecord { price, completion: Complete(workload) };
-		AllowedRenewals::<T>::remove(renewal_id);
-		AllowedRenewals::<T>::insert(AllowedRenewalId { core, when: begin }, &new_record);
+		log::debug!(
+			"Renew with: sale price: {:?}, price cap: {:?}, old price: {:?}",
+			price,
+			price_cap,
+			record.price
+		);
+		let new_record = PotentialRenewalRecord { price, completion: Complete(workload) };
+		PotentialRenewals::<T>::remove(renewal_id);
+		PotentialRenewals::<T>::insert(PotentialRenewalId { core, when: begin }, &new_record);
 		SaleInfo::<T>::put(&sale);
 		if let Some(workload) = new_record.completion.drain_complete() {
+			log::debug!("Recording renewable price for next run: {:?}", price);
 			Self::deposit_event(Event::Renewable { core, price, begin, workload });
 		}
 		Ok(core)
@@ -281,17 +286,19 @@ impl<T: Config> Pallet<T> {
 			let duration = region.end.saturating_sub(region_id.begin);
 			if duration == config.region_length && finality == Finality::Final {
 				if let Some(price) = region.paid {
-					let renewal_id = AllowedRenewalId { core: region_id.core, when: region.end };
-					let assigned = match AllowedRenewals::<T>::get(renewal_id) {
-						Some(AllowedRenewalRecord { completion: Partial(w), price: p })
+					let renewal_id = PotentialRenewalId { core: region_id.core, when: region.end };
+					let assigned = match PotentialRenewals::<T>::get(renewal_id) {
+						Some(PotentialRenewalRecord { completion: Partial(w), price: p })
 							if price == p =>
 							w,
 						_ => CoreMask::void(),
 					} | region_id.mask;
 					let workload =
 						if assigned.is_complete() { Complete(workplan) } else { Partial(assigned) };
-					let record = AllowedRenewalRecord { price, completion: workload };
-					AllowedRenewals::<T>::insert(&renewal_id, &record);
+					let record = PotentialRenewalRecord { price, completion: workload };
+					// Note: This entry alone does not yet actually allow renewals (the completion
+					// status has to be complete for `do_renew` to accept it).
+					PotentialRenewals::<T>::insert(&renewal_id, &record);
 					if let Some(workload) = record.completion.drain_complete() {
 						Self::deposit_event(Event::Renewable {
 							core: region_id.core,
@@ -444,10 +451,10 @@ impl<T: Config> Pallet<T> {
 	pub(crate) fn do_drop_renewal(core: CoreIndex, when: Timeslice) -> DispatchResult {
 		let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
 		ensure!(status.last_committed_timeslice >= when, Error::<T>::StillValid);
-		let id = AllowedRenewalId { core, when };
-		ensure!(AllowedRenewals::<T>::contains_key(id), Error::<T>::UnknownRenewal);
-		AllowedRenewals::<T>::remove(id);
-		Self::deposit_event(Event::AllowedRenewalDropped { core, when });
+		let id = PotentialRenewalId { core, when };
+		ensure!(PotentialRenewals::<T>::contains_key(id), Error::<T>::UnknownRenewal);
+		PotentialRenewals::<T>::remove(id);
+		Self::deposit_event(Event::PotentialRenewalDropped { core, when });
 		Ok(())
 	}
 
diff --git a/substrate/frame/broker/src/lib.rs b/substrate/frame/broker/src/lib.rs
index d59c4c9c6b24e4e576580715378a32b48f61eb91..0774c02e1cf10e7360c89dfc6c1dc11f28b563ac 100644
--- a/substrate/frame/broker/src/lib.rs
+++ b/substrate/frame/broker/src/lib.rs
@@ -65,7 +65,7 @@ pub mod pallet {
 	use sp_runtime::traits::{Convert, ConvertBack};
 	use sp_std::vec::Vec;
 
-	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
 
 	#[pallet::pallet]
 	#[pallet::storage_version(STORAGE_VERSION)]
@@ -92,7 +92,7 @@ pub mod pallet {
 		type Coretime: CoretimeInterface;
 
 		/// The algorithm to determine the next price on the basis of market performance.
-		type PriceAdapter: AdaptPrice;
+		type PriceAdapter: AdaptPrice<BalanceOf<Self>>;
 
 		/// Reversible conversion from local balance to Relay-chain balance. This will typically be
 		/// the `Identity`, but provided just in case the chains use different representations.
@@ -136,10 +136,12 @@ pub mod pallet {
 	#[pallet::storage]
 	pub type SaleInfo<T> = StorageValue<_, SaleInfoRecordOf<T>, OptionQuery>;
 
-	/// Records of allowed renewals.
+	/// Records of potential renewals.
+	///
+	/// Renewals will only actually be allowed if `CompletionStatus` is actually `Complete`.
 	#[pallet::storage]
-	pub type AllowedRenewals<T> =
-		StorageMap<_, Twox64Concat, AllowedRenewalId, AllowedRenewalRecordOf<T>, OptionQuery>;
+	pub type PotentialRenewals<T> =
+		StorageMap<_, Twox64Concat, PotentialRenewalId, PotentialRenewalRecordOf<T>, OptionQuery>;
 
 	/// The current (unassigned or provisionally assigend) Regions.
 	#[pallet::storage]
@@ -290,14 +292,13 @@ pub mod pallet {
 			/// The price of Bulk Coretime at the beginning of the Leadin Period.
 			start_price: BalanceOf<T>,
 			/// The price of Bulk Coretime after the Leadin Period.
-			regular_price: BalanceOf<T>,
+			end_price: BalanceOf<T>,
 			/// The first timeslice of the Regions which are being sold in this sale.
 			region_begin: Timeslice,
 			/// The timeslice on which the Regions which are being sold in the sale terminate.
 			/// (i.e. One after the last timeslice which the Regions control.)
 			region_end: Timeslice,
-			/// The number of cores we want to sell, ideally. Selling this amount would result in
-			/// no change to the price for the next sale.
+			/// The number of cores we want to sell, ideally.
 			ideal_cores_sold: CoreIndex,
 			/// Number of cores which are/have been offered for sale.
 			cores_offered: CoreIndex,
@@ -413,7 +414,7 @@ pub mod pallet {
 			assignment: Vec<(CoreAssignment, PartsOf57600)>,
 		},
 		/// Some historical Instantaneous Core Pool payment record has been dropped.
-		AllowedRenewalDropped {
+		PotentialRenewalDropped {
 			/// The timeslice whose renewal is no longer available.
 			when: Timeslice,
 			/// The core whose workload is no longer available to be renewed for `when`.
@@ -558,7 +559,7 @@ pub mod pallet {
 		/// Begin the Bulk Coretime sales rotation.
 		///
 		/// - `origin`: Must be Root or pass `AdminOrigin`.
-		/// - `initial_price`: The price of Bulk Coretime in the first sale.
+		/// - `end_price`: The price after the leadin period of Bulk Coretime in the first sale.
 		/// - `extra_cores`: Number of extra cores that should be requested on top of the cores
 		///   required for `Reservations` and `Leases`.
 		///
@@ -570,11 +571,11 @@ pub mod pallet {
 		))]
 		pub fn start_sales(
 			origin: OriginFor<T>,
-			initial_price: BalanceOf<T>,
+			end_price: BalanceOf<T>,
 			extra_cores: CoreIndex,
 		) -> DispatchResultWithPostInfo {
 			T::AdminOrigin::ensure_origin_or_root(origin)?;
-			Self::do_start_sales(initial_price, extra_cores)?;
+			Self::do_start_sales(end_price, extra_cores)?;
 			Ok(Pays::No.into())
 		}
 
diff --git a/substrate/frame/broker/src/migration.rs b/substrate/frame/broker/src/migration.rs
index 95aa28250a628e8352f6e4852a5588cbdad2a5e8..f354e447fe84eba4df56d02e82c69519ba67cf7d 100644
--- a/substrate/frame/broker/src/migration.rs
+++ b/substrate/frame/broker/src/migration.rs
@@ -77,6 +77,57 @@ mod v1 {
 	}
 }
 
+mod v2 {
+	use super::*;
+	use frame_support::{
+		pallet_prelude::{OptionQuery, Twox64Concat},
+		storage_alias,
+	};
+
+	#[storage_alias]
+	pub type AllowedRenewals<T: Config> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		PotentialRenewalId,
+		PotentialRenewalRecordOf<T>,
+		OptionQuery,
+	>;
+
+	pub struct MigrateToV2Impl<T>(PhantomData<T>);
+
+	impl<T: Config> UncheckedOnRuntimeUpgrade for MigrateToV2Impl<T> {
+		fn on_runtime_upgrade() -> frame_support::weights::Weight {
+			let mut count = 0;
+			for (renewal_id, renewal) in AllowedRenewals::<T>::drain() {
+				PotentialRenewals::<T>::insert(renewal_id, renewal);
+				count += 1;
+			}
+
+			log::info!(
+				target: LOG_TARGET,
+				"Storage migration v2 for pallet-broker finished.",
+			);
+
+			// calculate and return migration weights
+			T::DbWeight::get().reads_writes(count as u64 + 1, count as u64 + 1)
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+			Ok((AllowedRenewals::<T>::iter_keys().count() as u32).encode())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+			let old_count = u32::decode(&mut &state[..]).expect("Known good");
+			let new_count = PotentialRenewals::<T>::iter_values().count() as u32;
+
+			ensure!(old_count == new_count, "Renewal count should not change");
+			Ok(())
+		}
+	}
+}
+
 /// Migrate the pallet storage from `0` to `1`.
 pub type MigrateV0ToV1<T> = frame_support::migrations::VersionedMigration<
 	0,
@@ -85,3 +136,11 @@ pub type MigrateV0ToV1<T> = frame_support::migrations::VersionedMigration<
 	Pallet<T>,
 	<T as frame_system::Config>::DbWeight,
 >;
+
+pub type MigrateV1ToV2<T> = frame_support::migrations::VersionedMigration<
+	1,
+	2,
+	v2::MigrateToV2Impl<T>,
+	Pallet<T>,
+	<T as frame_system::Config>::DbWeight,
+>;
diff --git a/substrate/frame/broker/src/mock.rs b/substrate/frame/broker/src/mock.rs
index 6219b4eff1b457294c9f3656e4be145c3639e2e0..6fff6aa10080c5a888ba35b4c3aeb1d180f9361b 100644
--- a/substrate/frame/broker/src/mock.rs
+++ b/substrate/frame/broker/src/mock.rs
@@ -199,7 +199,7 @@ impl crate::Config for Test {
 	type WeightInfo = ();
 	type PalletId = TestBrokerId;
 	type AdminOrigin = EnsureOneOrRoot;
-	type PriceAdapter = Linear;
+	type PriceAdapter = CenterTargetPrice<BalanceOf<Self>>;
 }
 
 pub fn advance_to(b: u64) {
@@ -255,6 +255,10 @@ impl TestExt {
 		Self(new_config())
 	}
 
+	pub fn new_with_config(config: ConfigRecordOf<Test>) -> Self {
+		Self(config)
+	}
+
 	pub fn advance_notice(mut self, advance_notice: Timeslice) -> Self {
 		self.0.advance_notice = advance_notice as u64;
 		self
diff --git a/substrate/frame/broker/src/tests.rs b/substrate/frame/broker/src/tests.rs
index f929f0d50dcfaf3d8e7e77d07e260d54c75b1a27..e953afd6dc3c8818338d810d0c9d9d37c0b742af 100644
--- a/substrate/frame/broker/src/tests.rs
+++ b/substrate/frame/broker/src/tests.rs
@@ -25,7 +25,7 @@ use frame_support::{
 };
 use frame_system::RawOrigin::Root;
 use pretty_assertions::assert_eq;
-use sp_runtime::{traits::Get, TokenError};
+use sp_runtime::{traits::Get, Perbill, TokenError};
 use CoreAssignment::*;
 use CoretimeTraceItem::*;
 use Finality::*;
@@ -78,9 +78,9 @@ fn drop_renewal_works() {
 		let e = Error::<Test>::StillValid;
 		assert_noop!(Broker::do_drop_renewal(region.core, region.begin + 3), e);
 		advance_to(12);
-		assert_eq!(AllowedRenewals::<Test>::iter().count(), 1);
+		assert_eq!(PotentialRenewals::<Test>::iter().count(), 1);
 		assert_ok!(Broker::do_drop_renewal(region.core, region.begin + 3));
-		assert_eq!(AllowedRenewals::<Test>::iter().count(), 0);
+		assert_eq!(PotentialRenewals::<Test>::iter().count(), 0);
 		let e = Error::<Test>::UnknownRenewal;
 		assert_noop!(Broker::do_drop_renewal(region.core, region.begin + 3), e);
 	});
@@ -361,22 +361,91 @@ fn migration_works() {
 
 #[test]
 fn renewal_works() {
-	TestExt::new().endow(1, 1000).execute_with(|| {
+	let b = 100_000;
+	TestExt::new().endow(1, b).execute_with(move || {
 		assert_ok!(Broker::do_start_sales(100, 1));
 		advance_to(2);
 		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
-		assert_eq!(balance(1), 900);
+		assert_eq!(balance(1), 99_900);
 		assert_ok!(Broker::do_assign(region, None, 1001, Final));
 		// Should now be renewable.
 		advance_to(6);
 		assert_noop!(Broker::do_purchase(1, u64::max_value()), Error::<Test>::TooEarly);
 		let core = Broker::do_renew(1, region.core).unwrap();
-		assert_eq!(balance(1), 800);
+		assert_eq!(balance(1), 99_800);
 		advance_to(8);
 		assert_noop!(Broker::do_purchase(1, u64::max_value()), Error::<Test>::SoldOut);
 		advance_to(12);
 		assert_ok!(Broker::do_renew(1, core));
-		assert_eq!(balance(1), 690);
+		assert_eq!(balance(1), 99_690);
+	});
+}
+
+#[test]
+/// Renewals have to affect price as well. Otherwise a market where everything is a renewal would
+/// not work. Renewals happening in the leadin or after are effectively competing with the open
+/// market and it makes sense to adjust the price to what was paid here. Assuming all renewals were
+/// done in the interlude and only normal sales happen in the leadin, renewals will have no effect
+/// on price. If there are no cores left for sale on the open markent, renewals will affect price
+/// even in the interlude, making sure renewal prices stay in the range of the open market.
+fn renewals_affect_price() {
+	sp_tracing::try_init_simple();
+	let b = 100_000;
+	let config = ConfigRecord {
+		advance_notice: 2,
+		interlude_length: 10,
+		leadin_length: 20,
+		ideal_bulk_proportion: Perbill::from_percent(100),
+		limit_cores_offered: None,
+		// Region length is in time slices (2 blocks):
+		region_length: 20,
+		renewal_bump: Perbill::from_percent(10),
+		contribution_timeout: 5,
+	};
+	TestExt::new_with_config(config).endow(1, b).execute_with(|| {
+		let price = 910;
+		assert_ok!(Broker::do_start_sales(10, 1));
+		advance_to(11);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		// Price is lower, because already one block in:
+		let b = b - price;
+		assert_eq!(balance(1), b);
+		assert_ok!(Broker::do_assign(region, None, 1001, Final));
+		advance_to(40);
+		assert_noop!(Broker::do_purchase(1, u64::max_value()), Error::<Test>::TooEarly);
+		let core = Broker::do_renew(1, region.core).unwrap();
+		// First renewal has same price as initial purchase.
+		let b = b - price;
+		assert_eq!(balance(1), b);
+		advance_to(51);
+		assert_noop!(Broker::do_purchase(1, u64::max_value()), Error::<Test>::SoldOut);
+		advance_to(81);
+		assert_ok!(Broker::do_renew(1, core));
+		// Renewal bump in effect
+		let price = price + Perbill::from_percent(10) * price;
+		let b = b - price;
+		assert_eq!(balance(1), b);
+
+		// Move after interlude and leadin - should reduce price.
+		advance_to(159);
+		Broker::do_renew(1, region.core).unwrap();
+		let price = price + Perbill::from_percent(10) * price;
+		let b = b - price;
+		assert_eq!(balance(1), b);
+
+		advance_to(161);
+		// Should have the reduced price now:
+		Broker::do_renew(1, region.core).unwrap();
+		let price = 100;
+		let b = b - price;
+		assert_eq!(balance(1), b);
+
+		// Price should be bumped normally again:
+		advance_to(201);
+		Broker::do_renew(1, region.core).unwrap();
+		let price = 110;
+		let b = b - price;
+		assert_eq!(balance(1), b);
 	});
 }
 
@@ -916,7 +985,8 @@ fn short_leases_are_cleaned() {
 
 #[test]
 fn leases_can_be_renewed() {
-	TestExt::new().endow(1, 1000).execute_with(|| {
+	let initial_balance = 100_000;
+	TestExt::new().endow(1, initial_balance).execute_with(|| {
 		// Timeslice period is 2.
 		//
 		// Sale 1 starts at block 7, Sale 2 starts at 13.
@@ -927,13 +997,13 @@ fn leases_can_be_renewed() {
 		// Start the sales with only one core for this lease.
 		assert_ok!(Broker::do_start_sales(100, 0));
 
-		// Advance to sale period 1, we should get an AllowedRenewal for task 2001 for the next
+		// Advance to sale period 1, we should get an PotentialRenewal for task 2001 for the next
 		// sale.
 		advance_sale_period();
 		assert_eq!(
-			AllowedRenewals::<Test>::get(AllowedRenewalId { core: 0, when: 10 }),
-			Some(AllowedRenewalRecord {
-				price: 100,
+			PotentialRenewals::<Test>::get(PotentialRenewalId { core: 0, when: 10 }),
+			Some(PotentialRenewalRecord {
+				price: 1000,
 				completion: CompletionStatus::Complete(
 					vec![ScheduleItem { mask: CoreMask::complete(), assignment: Task(2001) }]
 						.try_into()
@@ -947,8 +1017,8 @@ fn leases_can_be_renewed() {
 		// Advance to sale period 2, where we can renew.
 		advance_sale_period();
 		assert_ok!(Broker::do_renew(1, 0));
-		// We renew for the base price of the previous sale period.
-		assert_eq!(balance(1), 900);
+		// We renew for the price of the previous sale period.
+		assert_eq!(balance(1), initial_balance - 1000);
 
 		// We just renewed for this period.
 		advance_sale_period();
@@ -1023,14 +1093,14 @@ fn short_leases_cannot_be_renewed() {
 		// The lease is removed.
 		assert_eq!(Leases::<Test>::get().len(), 0);
 
-		// We should have got an entry in AllowedRenewals, but we don't because rotate_sale
+		// We should have got an entry in PotentialRenewals, but we don't because rotate_sale
 		// schedules leases a period in advance. This renewal should be in the period after next
 		// because while bootstrapping our way into the sale periods, we give everything a lease for
 		// period 1, so they can renew for period 2. So we have a core until the end of period 1,
 		// but we are not marked as able to renew because we expired before sale period 1 starts.
 		//
 		// This should be fixed.
-		assert_eq!(AllowedRenewals::<Test>::get(AllowedRenewalId { core: 0, when: 10 }), None);
+		assert_eq!(PotentialRenewals::<Test>::get(PotentialRenewalId { core: 0, when: 10 }), None);
 		// And the lease has been removed from storage.
 		assert_eq!(Leases::<Test>::get().len(), 0);
 
@@ -1102,7 +1172,7 @@ fn purchase_requires_valid_status_and_sale_info() {
 		let mut dummy_sale = SaleInfoRecord {
 			sale_start: 0,
 			leadin_length: 0,
-			price: 200,
+			end_price: 200,
 			sellout_price: None,
 			region_begin: 0,
 			region_end: 3,
@@ -1144,7 +1214,7 @@ fn renewal_requires_valid_status_and_sale_info() {
 		let mut dummy_sale = SaleInfoRecord {
 			sale_start: 0,
 			leadin_length: 0,
-			price: 200,
+			end_price: 200,
 			sellout_price: None,
 			region_begin: 0,
 			region_end: 3,
@@ -1163,11 +1233,11 @@ fn renewal_requires_valid_status_and_sale_info() {
 		assert_ok!(Broker::do_start_sales(200, 1));
 		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::NotAllowed);
 
-		let record = AllowedRenewalRecord {
+		let record = PotentialRenewalRecord {
 			price: 100,
 			completion: CompletionStatus::Partial(CoreMask::from_chunk(0, 20)),
 		};
-		AllowedRenewals::<Test>::insert(AllowedRenewalId { core: 1, when: 4 }, &record);
+		PotentialRenewals::<Test>::insert(PotentialRenewalId { core: 1, when: 4 }, &record);
 		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::IncompleteAssignment);
 	});
 }
@@ -1274,7 +1344,7 @@ fn config_works() {
 /// Ensure that a lease that ended before `start_sales` was called can be renewed.
 #[test]
 fn renewal_works_leases_ended_before_start_sales() {
-	TestExt::new().endow(1, 1000).execute_with(|| {
+	TestExt::new().endow(1, 100_000).execute_with(|| {
 		let config = Configuration::<Test>::get().unwrap();
 
 		// This lease is ended before `start_stales` was called.
@@ -1304,7 +1374,7 @@ fn renewal_works_leases_ended_before_start_sales() {
 		let new_core = Broker::do_renew(1, 0).unwrap();
 		// Renewing the active lease doesn't work.
 		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::SoldOut);
-		assert_eq!(balance(1), 900);
+		assert_eq!(balance(1), 99000);
 
 		// This intializes the third sale and the period 2.
 		advance_sale_period();
@@ -1312,7 +1382,7 @@ fn renewal_works_leases_ended_before_start_sales() {
 
 		// Renewing the active lease doesn't work.
 		assert_noop!(Broker::do_renew(1, 0), Error::<Test>::SoldOut);
-		assert_eq!(balance(1), 800);
+		assert_eq!(balance(1), 98900);
 
 		// All leases should have ended
 		assert!(Leases::<Test>::get().is_empty());
@@ -1324,7 +1394,7 @@ fn renewal_works_leases_ended_before_start_sales() {
 		assert_eq!(0, Broker::do_renew(1, new_core).unwrap());
 		// Renew the task 2.
 		assert_eq!(1, Broker::do_renew(1, 0).unwrap());
-		assert_eq!(balance(1), 600);
+		assert_eq!(balance(1), 98790);
 
 		// This intializes the fifth sale and the period 4.
 		advance_sale_period();
diff --git a/substrate/frame/broker/src/tick_impls.rs b/substrate/frame/broker/src/tick_impls.rs
index 04e9a65bf8f67b11ef66edf7268eda74e336e65d..20637cf7b903cf73fb5d9bfe08e70013303bcb1a 100644
--- a/substrate/frame/broker/src/tick_impls.rs
+++ b/substrate/frame/broker/src/tick_impls.rs
@@ -17,10 +17,7 @@
 
 use super::*;
 use frame_support::{pallet_prelude::*, weights::WeightMeter};
-use sp_arithmetic::{
-	traits::{One, SaturatedConversion, Saturating, Zero},
-	FixedPointNumber,
-};
+use sp_arithmetic::traits::{One, SaturatedConversion, Saturating, Zero};
 use sp_runtime::traits::ConvertBack;
 use sp_std::{vec, vec::Vec};
 use CompletionStatus::Complete;
@@ -163,31 +160,13 @@ impl<T: Config> Pallet<T> {
 		InstaPoolIo::<T>::mutate(old_sale.region_end, |r| r.system.saturating_reduce(old_pooled));
 
 		// Calculate the start price for the upcoming sale.
-		let price = {
-			let offered = old_sale.cores_offered;
-			let ideal = old_sale.ideal_cores_sold;
-			let sold = old_sale.cores_sold;
-
-			let maybe_purchase_price = if offered == 0 {
-				// No cores offered for sale - no purchase price.
-				None
-			} else if sold >= ideal {
-				// Sold more than the ideal amount. We should look for the last purchase price
-				// before the sell-out. If there was no purchase at all, then we avoid having a
-				// price here so that we make no alterations to it (since otherwise we would
-				// increase it).
-				old_sale.sellout_price
-			} else {
-				// Sold less than the ideal - we fall back to the regular price.
-				Some(old_sale.price)
-			};
-			if let Some(purchase_price) = maybe_purchase_price {
-				T::PriceAdapter::adapt_price(sold.min(offered), ideal, offered)
-					.saturating_mul_int(purchase_price)
-			} else {
-				old_sale.price
-			}
-		};
+		let new_prices = T::PriceAdapter::adapt_price(SalePerformance::from_sale(&old_sale));
+
+		log::debug!(
+			"Rotated sale, new prices: {:?}, {:?}",
+			new_prices.end_price,
+			new_prices.target_price
+		);
 
 		// Set workload for the reserved (system, probably) workloads.
 		let region_begin = old_sale.region_end;
@@ -220,12 +199,15 @@ impl<T: Config> Pallet<T> {
 			let expire = until < region_end;
 			if expire {
 				// last time for this one - make it renewable in the next sale.
-				let renewal_id = AllowedRenewalId { core: first_core, when: region_end };
-				let record = AllowedRenewalRecord { price, completion: Complete(schedule) };
-				AllowedRenewals::<T>::insert(renewal_id, &record);
+				let renewal_id = PotentialRenewalId { core: first_core, when: region_end };
+				let record = PotentialRenewalRecord {
+					price: new_prices.target_price,
+					completion: Complete(schedule),
+				};
+				PotentialRenewals::<T>::insert(renewal_id, &record);
 				Self::deposit_event(Event::Renewable {
 					core: first_core,
-					price,
+					price: new_prices.target_price,
 					begin: region_end,
 					workload: record.completion.drain_complete().unwrap_or_default(),
 				});
@@ -244,12 +226,19 @@ impl<T: Config> Pallet<T> {
 		let sale_start = now.saturating_add(config.interlude_length);
 		let leadin_length = config.leadin_length;
 		let ideal_cores_sold = (config.ideal_bulk_proportion * cores_offered as u32) as u16;
+		let sellout_price = if cores_offered > 0 {
+			// No core sold -> price was too high -> we have to adjust downwards.
+			Some(new_prices.end_price)
+		} else {
+			None
+		};
+
 		// Update SaleInfo
 		let new_sale = SaleInfoRecord {
 			sale_start,
 			leadin_length,
-			price,
-			sellout_price: None,
+			end_price: new_prices.end_price,
+			sellout_price,
 			region_begin,
 			region_end,
 			first_core,
@@ -257,12 +246,13 @@ impl<T: Config> Pallet<T> {
 			cores_offered,
 			cores_sold: 0,
 		};
+
 		SaleInfo::<T>::put(&new_sale);
 		Self::deposit_event(Event::SaleInitialized {
 			sale_start,
 			leadin_length,
 			start_price: Self::sale_price(&new_sale, now),
-			regular_price: price,
+			end_price: new_prices.end_price,
 			region_begin,
 			region_end,
 			ideal_cores_sold,
diff --git a/substrate/frame/broker/src/types.rs b/substrate/frame/broker/src/types.rs
index f2cae9a41ad480b1e4608a4d556b10d166282c1d..885cac9a5c23d47add53ce4e2eff02da49d3cdc9 100644
--- a/substrate/frame/broker/src/types.rs
+++ b/substrate/frame/broker/src/types.rs
@@ -152,25 +152,28 @@ impl CompletionStatus {
 	}
 }
 
-/// The identity of a possible Core workload renewal.
+/// The identity of a possibly renewable Core workload.
 #[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
-pub struct AllowedRenewalId {
+pub struct PotentialRenewalId {
 	/// The core whose workload at the sale ending with `when` may be renewed to begin at `when`.
 	pub core: CoreIndex,
 	/// The point in time that the renewable workload on `core` ends and a fresh renewal may begin.
 	pub when: Timeslice,
 }
 
-/// A record of an allowed renewal.
+/// A record of a potential renewal.
+///
+/// The renewal will only actually be allowed if `CompletionStatus` is `Complete` at the time of
+/// renewal.
 #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
-pub struct AllowedRenewalRecord<Balance> {
+pub struct PotentialRenewalRecord<Balance> {
 	/// The price for which the next renewal can be made.
 	pub price: Balance,
 	/// The workload which will be scheduled on the Core in the case a renewal is made, or if
 	/// incomplete, then the parts of the core which have been scheduled.
 	pub completion: CompletionStatus,
 }
-pub type AllowedRenewalRecordOf<T> = AllowedRenewalRecord<BalanceOf<T>>;
+pub type PotentialRenewalRecordOf<T> = PotentialRenewalRecord<BalanceOf<T>>;
 
 /// General status of the system.
 #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
@@ -211,7 +214,7 @@ pub struct SaleInfoRecord<Balance, BlockNumber> {
 	/// The length in blocks of the Leadin Period (where the price is decreasing).
 	pub leadin_length: BlockNumber,
 	/// The price of Bulk Coretime after the Leadin Period.
-	pub price: Balance,
+	pub end_price: Balance,
 	/// The first timeslice of the Regions which are being sold in this sale.
 	pub region_begin: Timeslice,
 	/// The timeslice on which the Regions which are being sold in the sale terminate. (i.e. One
@@ -225,8 +228,9 @@ pub struct SaleInfoRecord<Balance, BlockNumber> {
 	/// The index of the first core which is for sale. Core of Regions which are sold have
 	/// incrementing indices from this.
 	pub first_core: CoreIndex,
-	/// The latest price at which Bulk Coretime was purchased until surpassing the ideal number of
-	/// cores were sold.
+	/// The price at which cores have been sold out.
+	///
+	/// Will only be `None` if no core was offered for sale.
 	pub sellout_price: Option<Balance>,
 	/// Number of cores which have been sold; never more than cores_offered.
 	pub cores_sold: CoreIndex,
@@ -263,8 +267,11 @@ pub struct ConfigRecord<BlockNumber, RelayBlockNumber> {
 	pub leadin_length: BlockNumber,
 	/// The length in timeslices of Regions which are up for sale in forthcoming sales.
 	pub region_length: Timeslice,
-	/// The proportion of cores available for sale which should be sold in order for the price
-	/// to remain the same in the next sale.
+	/// The proportion of cores available for sale which should be sold.
+	///
+	/// If more cores are sold than this, then further sales will no longer be considered in
+	/// determining the sellout price. In other words the sellout price will be the last price
+	/// paid, without going over this limit.
 	pub ideal_bulk_proportion: Perbill,
 	/// An artificial limit to the number of cores which are allowed to be sold. If `Some` then
 	/// no more cores will be sold than this.
diff --git a/substrate/frame/broker/src/utility_impls.rs b/substrate/frame/broker/src/utility_impls.rs
index 4163817a8b584bd949210aff383398ff50b95d58..9cceb7f970a9f55bf8a9420937b1f8d2c7826479 100644
--- a/substrate/frame/broker/src/utility_impls.rs
+++ b/substrate/frame/broker/src/utility_impls.rs
@@ -63,7 +63,7 @@ impl<T: Config> Pallet<T> {
 	pub fn sale_price(sale: &SaleInfoRecordOf<T>, now: BlockNumberFor<T>) -> BalanceOf<T> {
 		let num = now.saturating_sub(sale.sale_start).min(sale.leadin_length).saturated_into();
 		let through = FixedU64::from_rational(num, sale.leadin_length.saturated_into());
-		T::PriceAdapter::leadin_factor_at(through).saturating_mul_int(sale.price)
+		T::PriceAdapter::leadin_factor_at(through).saturating_mul_int(sale.end_price)
 	}
 
 	pub(crate) fn charge(who: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {
@@ -72,6 +72,25 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
+	/// Buy a core at the specified price (price is to be determined by the caller).
+	///
+	/// Note: It is the responsibility of the caller to write back the changed `SaleInfoRecordOf` to
+	/// storage.
+	pub(crate) fn purchase_core(
+		who: &T::AccountId,
+		price: BalanceOf<T>,
+		sale: &mut SaleInfoRecordOf<T>,
+	) -> Result<CoreIndex, DispatchError> {
+		Self::charge(who, price)?;
+		log::debug!("Purchased core at: {:?}", price);
+		let core = sale.first_core.saturating_add(sale.cores_sold);
+		sale.cores_sold.saturating_inc();
+		if sale.cores_sold <= sale.ideal_cores_sold || sale.sellout_price.is_none() {
+			sale.sellout_price = Some(price);
+		}
+		Ok(core)
+	}
+
 	pub fn issue(
 		core: CoreIndex,
 		begin: Timeslice,
diff --git a/substrate/frame/broker/src/weights.rs b/substrate/frame/broker/src/weights.rs
index 2aa1c282a41d8a98e6a0a824e5eaa150922b2356..d9d9d348e47e9db76731b41fd65086c689fc86f0 100644
--- a/substrate/frame/broker/src/weights.rs
+++ b/substrate/frame/broker/src/weights.rs
@@ -18,27 +18,25 @@
 //! Autogenerated weights for `pallet_broker`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
-//! DATE: 2024-04-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2024-05-29, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-anb7yjbi-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-vicqj8em-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
 
 // Executed Command:
-// ./target/production/substrate-node
+// target/production/substrate-node
 // benchmark
 // pallet
-// --chain=dev
 // --steps=50
 // --repeat=20
-// --pallet=pallet_broker
-// --no-storage-info
-// --no-median-slopes
-// --no-min-squares
 // --extrinsic=*
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --output=./substrate/frame/broker/src/weights.rs
+// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json
+// --pallet=pallet_broker
+// --chain=dev
 // --header=./substrate/HEADER-APACHE2
+// --output=./substrate/frame/broker/src/weights.rs
 // --template=./substrate/.maintain/frame-weight-template.hbs
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
@@ -90,8 +88,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_624_000 picoseconds.
-		Weight::from_parts(2_804_000, 0)
+		// Minimum execution time: 1_945_000 picoseconds.
+		Weight::from_parts(2_142_000, 0)
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Reservations` (r:1 w:1)
@@ -100,8 +98,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `5016`
 		//  Estimated: `7496`
-		// Minimum execution time: 18_451_000 picoseconds.
-		Weight::from_parts(18_853_000, 7496)
+		// Minimum execution time: 16_274_000 picoseconds.
+		Weight::from_parts(16_828_000, 7496)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -111,8 +109,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `6218`
 		//  Estimated: `7496`
-		// Minimum execution time: 16_899_000 picoseconds.
-		Weight::from_parts(17_645_000, 7496)
+		// Minimum execution time: 15_080_000 picoseconds.
+		Weight::from_parts(15_874_000, 7496)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -122,19 +120,19 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `239`
 		//  Estimated: `1526`
-		// Minimum execution time: 10_239_000 picoseconds.
-		Weight::from_parts(10_754_000, 1526)
+		// Minimum execution time: 8_761_000 picoseconds.
+		Weight::from_parts(9_203_000, 1526)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Configuration` (r:1 w:0)
 	/// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::InstaPoolIo` (r:3 w:3)
-	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::Reservations` (r:1 w:0)
-	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Leases` (r:1 w:1)
 	/// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(41), added: 536, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::Reservations` (r:1 w:0)
+	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolIo` (r:3 w:3)
+	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::SaleInfo` (r:0 w:1)
 	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Status` (r:0 w:1)
@@ -146,12 +144,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `6330`
 		//  Estimated: `8499`
-		// Minimum execution time: 51_250_000 picoseconds.
-		Weight::from_parts(54_643_012, 8499)
-			// Standard Error: 147
-			.saturating_add(Weight::from_parts(18, 0).saturating_mul(n.into()))
+		// Minimum execution time: 26_057_000 picoseconds.
+		Weight::from_parts(46_673_357, 8499)
+			// Standard Error: 456
+			.saturating_add(Weight::from_parts(2_677, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(6_u64))
-			.saturating_add(T::DbWeight::get().writes(16_u64))
+			.saturating_add(T::DbWeight::get().writes(15_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
@@ -162,13 +160,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `System::Digest` (r:1 w:0)
 	/// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `Broker::Regions` (r:0 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn purchase() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `635`
-		//  Estimated: `2120`
-		// Minimum execution time: 43_660_000 picoseconds.
-		Weight::from_parts(45_543_000, 2120)
+		//  Measured:  `651`
+		//  Estimated: `2136`
+		// Minimum execution time: 40_907_000 picoseconds.
+		Weight::from_parts(42_566_000, 2136)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -178,8 +176,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::SaleInfo` (r:1 w:1)
 	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:2)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:2)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	/// Storage: `Authorship::Author` (r:1 w:0)
 	/// Proof: `Authorship::Author` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
 	/// Storage: `System::Digest` (r:1 w:0)
@@ -188,43 +186,43 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	fn renew() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `753`
+		//  Measured:  `769`
 		//  Estimated: `4698`
-		// Minimum execution time: 63_122_000 picoseconds.
-		Weight::from_parts(64_366_000, 4698)
+		// Minimum execution time: 65_209_000 picoseconds.
+		Weight::from_parts(68_604_000, 4698)
 			.saturating_add(T::DbWeight::get().reads(6_u64))
 			.saturating_add(T::DbWeight::get().writes(4_u64))
 	}
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `495`
-		//  Estimated: `3550`
-		// Minimum execution time: 17_552_000 picoseconds.
-		Weight::from_parts(18_251_000, 3550)
+		//  Measured:  `496`
+		//  Estimated: `3551`
+		// Minimum execution time: 15_860_000 picoseconds.
+		Weight::from_parts(16_393_000, 3551)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Regions` (r:1 w:2)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn partition() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `495`
-		//  Estimated: `3550`
-		// Minimum execution time: 18_551_000 picoseconds.
-		Weight::from_parts(19_727_000, 3550)
+		//  Measured:  `496`
+		//  Estimated: `3551`
+		// Minimum execution time: 17_651_000 picoseconds.
+		Weight::from_parts(18_088_000, 3551)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Broker::Regions` (r:1 w:3)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn interlace() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `495`
-		//  Estimated: `3550`
-		// Minimum execution time: 20_636_000 picoseconds.
-		Weight::from_parts(21_060_000, 3550)
+		//  Measured:  `496`
+		//  Estimated: `3551`
+		// Minimum execution time: 18_576_000 picoseconds.
+		Weight::from_parts(19_810_000, 3551)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
@@ -233,22 +231,22 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Workplan` (r:1 w:1)
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	fn assign() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `740`
+		//  Measured:  `741`
 		//  Estimated: `4681`
-		// Minimum execution time: 32_394_000 picoseconds.
-		Weight::from_parts(33_324_000, 4681)
+		// Minimum execution time: 31_015_000 picoseconds.
+		Weight::from_parts(31_932_000, 4681)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Workplan` (r:1 w:1)
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::InstaPoolIo` (r:2 w:2)
@@ -257,10 +255,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn pool() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `775`
+		//  Measured:  `776`
 		//  Estimated: `5996`
-		// Minimum execution time: 38_128_000 picoseconds.
-		Weight::from_parts(39_274_000, 5996)
+		// Minimum execution time: 36_473_000 picoseconds.
+		Weight::from_parts(37_382_000, 5996)
 			.saturating_add(T::DbWeight::get().reads(5_u64))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
@@ -275,10 +273,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `859`
 		//  Estimated: `6196 + m * (2520 ±0)`
-		// Minimum execution time: 70_453_000 picoseconds.
-		Weight::from_parts(70_652_822, 6196)
-			// Standard Error: 75_524
-			.saturating_add(Weight::from_parts(2_335_289, 0).saturating_mul(m.into()))
+		// Minimum execution time: 64_957_000 picoseconds.
+		Weight::from_parts(66_024_232, 6196)
+			// Standard Error: 50_170
+			.saturating_add(Weight::from_parts(1_290_632, 0).saturating_mul(m.into()))
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(m.into())))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
@@ -290,21 +288,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `103`
 		//  Estimated: `3593`
-		// Minimum execution time: 43_945_000 picoseconds.
-		Weight::from_parts(45_249_000, 3593)
+		// Minimum execution time: 39_939_000 picoseconds.
+		Weight::from_parts(40_788_000, 3593)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn drop_region() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `603`
-		//  Estimated: `3550`
-		// Minimum execution time: 30_680_000 picoseconds.
-		Weight::from_parts(32_995_000, 3550)
+		//  Measured:  `604`
+		//  Estimated: `3551`
+		// Minimum execution time: 31_709_000 picoseconds.
+		Weight::from_parts(37_559_000, 3551)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -318,8 +316,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `601`
 		//  Estimated: `3533`
-		// Minimum execution time: 48_053_000 picoseconds.
-		Weight::from_parts(51_364_000, 3533)
+		// Minimum execution time: 42_895_000 picoseconds.
+		Weight::from_parts(53_945_000, 3533)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -335,21 +333,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `995`
 		//  Estimated: `3593`
-		// Minimum execution time: 57_372_000 picoseconds.
-		Weight::from_parts(59_466_000, 3593)
+		// Minimum execution time: 50_770_000 picoseconds.
+		Weight::from_parts(63_117_000, 3593)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:1)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:1)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	fn drop_renewal() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `661`
 		//  Estimated: `4698`
-		// Minimum execution time: 27_768_000 picoseconds.
-		Weight::from_parts(29_000_000, 4698)
+		// Minimum execution time: 33_396_000 picoseconds.
+		Weight::from_parts(36_247_000, 4698)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -358,20 +356,18 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 4_588_000 picoseconds.
-		Weight::from_parts(5_201_705, 0)
+		// Minimum execution time: 3_625_000 picoseconds.
+		Weight::from_parts(4_011_396, 0)
 	}
 	/// Storage: `Broker::CoreCountInbox` (r:1 w:1)
 	/// Proof: `Broker::CoreCountInbox` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`)
 	/// The range of component `n` is `[0, 1000]`.
-	fn process_core_count(n: u32, ) -> Weight {
+	fn process_core_count(_n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `404`
 		//  Estimated: `1487`
-		// Minimum execution time: 6_889_000 picoseconds.
-		Weight::from_parts(7_380_363, 1487)
-			// Standard Error: 21
-			.saturating_add(Weight::from_parts(63, 0).saturating_mul(n.into()))
+		// Minimum execution time: 6_217_000 picoseconds.
+		Weight::from_parts(6_608_394, 1487)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -389,8 +385,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `972`
 		//  Estimated: `4437`
-		// Minimum execution time: 50_156_000 picoseconds.
-		Weight::from_parts(51_610_000, 4437)
+		// Minimum execution time: 46_853_000 picoseconds.
+		Weight::from_parts(47_740_000, 4437)
 			.saturating_add(T::DbWeight::get().reads(5_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
@@ -405,14 +401,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Storage: `Broker::Workplan` (r:0 w:10)
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	/// The range of component `n` is `[0, 1000]`.
-	fn rotate_sale(n: u32, ) -> Weight {
+	fn rotate_sale(_n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `6281`
 		//  Estimated: `8499`
-		// Minimum execution time: 38_246_000 picoseconds.
-		Weight::from_parts(40_008_850, 8499)
-			// Standard Error: 94
-			.saturating_add(Weight::from_parts(964, 0).saturating_mul(n.into()))
+		// Minimum execution time: 34_240_000 picoseconds.
+		Weight::from_parts(35_910_175, 8499)
 			.saturating_add(T::DbWeight::get().reads(5_u64))
 			.saturating_add(T::DbWeight::get().writes(15_u64))
 	}
@@ -424,8 +418,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `180`
 		//  Estimated: `3493`
-		// Minimum execution time: 7_962_000 picoseconds.
-		Weight::from_parts(8_313_000, 3493)
+		// Minimum execution time: 7_083_000 picoseconds.
+		Weight::from_parts(7_336_000, 3493)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -437,8 +431,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `1423`
 		//  Estimated: `4681`
-		// Minimum execution time: 17_457_000 picoseconds.
-		Weight::from_parts(18_387_000, 4681)
+		// Minimum execution time: 15_029_000 picoseconds.
+		Weight::from_parts(15_567_000, 4681)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -446,8 +440,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 133_000 picoseconds.
-		Weight::from_parts(149_000, 0)
+		// Minimum execution time: 123_000 picoseconds.
+		Weight::from_parts(136_000, 0)
 	}
 	/// Storage: `Broker::CoreCountInbox` (r:0 w:1)
 	/// Proof: `Broker::CoreCountInbox` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`)
@@ -455,8 +449,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_407_000 picoseconds.
-		Weight::from_parts(2_634_000, 0)
+		// Minimum execution time: 1_775_000 picoseconds.
+		Weight::from_parts(1_911_000, 0)
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:1)
@@ -471,8 +465,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `603`
 		//  Estimated: `4068`
-		// Minimum execution time: 13_043_000 picoseconds.
-		Weight::from_parts(13_541_000, 4068)
+		// Minimum execution time: 11_859_000 picoseconds.
+		Weight::from_parts(12_214_000, 4068)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -482,8 +476,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `239`
 		//  Estimated: `1526`
-		// Minimum execution time: 6_606_000 picoseconds.
-		Weight::from_parts(6_964_000, 1526)
+		// Minimum execution time: 5_864_000 picoseconds.
+		Weight::from_parts(6_231_000, 1526)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -497,8 +491,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_624_000 picoseconds.
-		Weight::from_parts(2_804_000, 0)
+		// Minimum execution time: 1_945_000 picoseconds.
+		Weight::from_parts(2_142_000, 0)
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Reservations` (r:1 w:1)
@@ -507,8 +501,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `5016`
 		//  Estimated: `7496`
-		// Minimum execution time: 18_451_000 picoseconds.
-		Weight::from_parts(18_853_000, 7496)
+		// Minimum execution time: 16_274_000 picoseconds.
+		Weight::from_parts(16_828_000, 7496)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -518,8 +512,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `6218`
 		//  Estimated: `7496`
-		// Minimum execution time: 16_899_000 picoseconds.
-		Weight::from_parts(17_645_000, 7496)
+		// Minimum execution time: 15_080_000 picoseconds.
+		Weight::from_parts(15_874_000, 7496)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -529,19 +523,19 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `239`
 		//  Estimated: `1526`
-		// Minimum execution time: 10_239_000 picoseconds.
-		Weight::from_parts(10_754_000, 1526)
+		// Minimum execution time: 8_761_000 picoseconds.
+		Weight::from_parts(9_203_000, 1526)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Configuration` (r:1 w:0)
 	/// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::InstaPoolIo` (r:3 w:3)
-	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::Reservations` (r:1 w:0)
-	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Leases` (r:1 w:1)
 	/// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(41), added: 536, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::Reservations` (r:1 w:0)
+	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolIo` (r:3 w:3)
+	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::SaleInfo` (r:0 w:1)
 	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Status` (r:0 w:1)
@@ -553,12 +547,12 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `6330`
 		//  Estimated: `8499`
-		// Minimum execution time: 51_250_000 picoseconds.
-		Weight::from_parts(54_643_012, 8499)
-			// Standard Error: 147
-			.saturating_add(Weight::from_parts(18, 0).saturating_mul(n.into()))
+		// Minimum execution time: 26_057_000 picoseconds.
+		Weight::from_parts(46_673_357, 8499)
+			// Standard Error: 456
+			.saturating_add(Weight::from_parts(2_677, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(6_u64))
-			.saturating_add(RocksDbWeight::get().writes(16_u64))
+			.saturating_add(RocksDbWeight::get().writes(15_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
@@ -569,13 +563,13 @@ impl WeightInfo for () {
 	/// Storage: `System::Digest` (r:1 w:0)
 	/// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
 	/// Storage: `Broker::Regions` (r:0 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn purchase() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `635`
-		//  Estimated: `2120`
-		// Minimum execution time: 43_660_000 picoseconds.
-		Weight::from_parts(45_543_000, 2120)
+		//  Measured:  `651`
+		//  Estimated: `2136`
+		// Minimum execution time: 40_907_000 picoseconds.
+		Weight::from_parts(42_566_000, 2136)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -585,8 +579,8 @@ impl WeightInfo for () {
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::SaleInfo` (r:1 w:1)
 	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:2)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:2)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	/// Storage: `Authorship::Author` (r:1 w:0)
 	/// Proof: `Authorship::Author` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
 	/// Storage: `System::Digest` (r:1 w:0)
@@ -595,43 +589,43 @@ impl WeightInfo for () {
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	fn renew() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `753`
+		//  Measured:  `769`
 		//  Estimated: `4698`
-		// Minimum execution time: 63_122_000 picoseconds.
-		Weight::from_parts(64_366_000, 4698)
+		// Minimum execution time: 65_209_000 picoseconds.
+		Weight::from_parts(68_604_000, 4698)
 			.saturating_add(RocksDbWeight::get().reads(6_u64))
 			.saturating_add(RocksDbWeight::get().writes(4_u64))
 	}
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `495`
-		//  Estimated: `3550`
-		// Minimum execution time: 17_552_000 picoseconds.
-		Weight::from_parts(18_251_000, 3550)
+		//  Measured:  `496`
+		//  Estimated: `3551`
+		// Minimum execution time: 15_860_000 picoseconds.
+		Weight::from_parts(16_393_000, 3551)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Regions` (r:1 w:2)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn partition() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `495`
-		//  Estimated: `3550`
-		// Minimum execution time: 18_551_000 picoseconds.
-		Weight::from_parts(19_727_000, 3550)
+		//  Measured:  `496`
+		//  Estimated: `3551`
+		// Minimum execution time: 17_651_000 picoseconds.
+		Weight::from_parts(18_088_000, 3551)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Broker::Regions` (r:1 w:3)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn interlace() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `495`
-		//  Estimated: `3550`
-		// Minimum execution time: 20_636_000 picoseconds.
-		Weight::from_parts(21_060_000, 3550)
+		//  Measured:  `496`
+		//  Estimated: `3551`
+		// Minimum execution time: 18_576_000 picoseconds.
+		Weight::from_parts(19_810_000, 3551)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
@@ -640,22 +634,22 @@ impl WeightInfo for () {
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Workplan` (r:1 w:1)
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	fn assign() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `740`
+		//  Measured:  `741`
 		//  Estimated: `4681`
-		// Minimum execution time: 32_394_000 picoseconds.
-		Weight::from_parts(33_324_000, 4681)
+		// Minimum execution time: 31_015_000 picoseconds.
+		Weight::from_parts(31_932_000, 4681)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Workplan` (r:1 w:1)
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::InstaPoolIo` (r:2 w:2)
@@ -664,10 +658,10 @@ impl WeightInfo for () {
 	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
 	fn pool() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `775`
+		//  Measured:  `776`
 		//  Estimated: `5996`
-		// Minimum execution time: 38_128_000 picoseconds.
-		Weight::from_parts(39_274_000, 5996)
+		// Minimum execution time: 36_473_000 picoseconds.
+		Weight::from_parts(37_382_000, 5996)
 			.saturating_add(RocksDbWeight::get().reads(5_u64))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
@@ -682,10 +676,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `859`
 		//  Estimated: `6196 + m * (2520 ±0)`
-		// Minimum execution time: 70_453_000 picoseconds.
-		Weight::from_parts(70_652_822, 6196)
-			// Standard Error: 75_524
-			.saturating_add(Weight::from_parts(2_335_289, 0).saturating_mul(m.into()))
+		// Minimum execution time: 64_957_000 picoseconds.
+		Weight::from_parts(66_024_232, 6196)
+			// Standard Error: 50_170
+			.saturating_add(Weight::from_parts(1_290_632, 0).saturating_mul(m.into()))
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(m.into())))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
@@ -697,21 +691,21 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `103`
 		//  Estimated: `3593`
-		// Minimum execution time: 43_945_000 picoseconds.
-		Weight::from_parts(45_249_000, 3593)
+		// Minimum execution time: 39_939_000 picoseconds.
+		Weight::from_parts(40_788_000, 3593)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
 	/// Storage: `Broker::Regions` (r:1 w:1)
-	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`)
 	fn drop_region() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `603`
-		//  Estimated: `3550`
-		// Minimum execution time: 30_680_000 picoseconds.
-		Weight::from_parts(32_995_000, 3550)
+		//  Measured:  `604`
+		//  Estimated: `3551`
+		// Minimum execution time: 31_709_000 picoseconds.
+		Weight::from_parts(37_559_000, 3551)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -725,8 +719,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `601`
 		//  Estimated: `3533`
-		// Minimum execution time: 48_053_000 picoseconds.
-		Weight::from_parts(51_364_000, 3533)
+		// Minimum execution time: 42_895_000 picoseconds.
+		Weight::from_parts(53_945_000, 3533)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -742,21 +736,21 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `995`
 		//  Estimated: `3593`
-		// Minimum execution time: 57_372_000 picoseconds.
-		Weight::from_parts(59_466_000, 3593)
+		// Minimum execution time: 50_770_000 picoseconds.
+		Weight::from_parts(63_117_000, 3593)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:0)
 	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
-	/// Storage: `Broker::AllowedRenewals` (r:1 w:1)
-	/// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::PotentialRenewals` (r:1 w:1)
+	/// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`)
 	fn drop_renewal() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `661`
 		//  Estimated: `4698`
-		// Minimum execution time: 27_768_000 picoseconds.
-		Weight::from_parts(29_000_000, 4698)
+		// Minimum execution time: 33_396_000 picoseconds.
+		Weight::from_parts(36_247_000, 4698)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -765,20 +759,18 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 4_588_000 picoseconds.
-		Weight::from_parts(5_201_705, 0)
+		// Minimum execution time: 3_625_000 picoseconds.
+		Weight::from_parts(4_011_396, 0)
 	}
 	/// Storage: `Broker::CoreCountInbox` (r:1 w:1)
 	/// Proof: `Broker::CoreCountInbox` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`)
 	/// The range of component `n` is `[0, 1000]`.
-	fn process_core_count(n: u32, ) -> Weight {
+	fn process_core_count(_n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `404`
 		//  Estimated: `1487`
-		// Minimum execution time: 6_889_000 picoseconds.
-		Weight::from_parts(7_380_363, 1487)
-			// Standard Error: 21
-			.saturating_add(Weight::from_parts(63, 0).saturating_mul(n.into()))
+		// Minimum execution time: 6_217_000 picoseconds.
+		Weight::from_parts(6_608_394, 1487)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -796,8 +788,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `972`
 		//  Estimated: `4437`
-		// Minimum execution time: 50_156_000 picoseconds.
-		Weight::from_parts(51_610_000, 4437)
+		// Minimum execution time: 46_853_000 picoseconds.
+		Weight::from_parts(47_740_000, 4437)
 			.saturating_add(RocksDbWeight::get().reads(5_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
@@ -812,14 +804,12 @@ impl WeightInfo for () {
 	/// Storage: `Broker::Workplan` (r:0 w:10)
 	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
 	/// The range of component `n` is `[0, 1000]`.
-	fn rotate_sale(n: u32, ) -> Weight {
+	fn rotate_sale(_n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `6281`
 		//  Estimated: `8499`
-		// Minimum execution time: 38_246_000 picoseconds.
-		Weight::from_parts(40_008_850, 8499)
-			// Standard Error: 94
-			.saturating_add(Weight::from_parts(964, 0).saturating_mul(n.into()))
+		// Minimum execution time: 34_240_000 picoseconds.
+		Weight::from_parts(35_910_175, 8499)
 			.saturating_add(RocksDbWeight::get().reads(5_u64))
 			.saturating_add(RocksDbWeight::get().writes(15_u64))
 	}
@@ -831,8 +821,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `180`
 		//  Estimated: `3493`
-		// Minimum execution time: 7_962_000 picoseconds.
-		Weight::from_parts(8_313_000, 3493)
+		// Minimum execution time: 7_083_000 picoseconds.
+		Weight::from_parts(7_336_000, 3493)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -844,8 +834,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `1423`
 		//  Estimated: `4681`
-		// Minimum execution time: 17_457_000 picoseconds.
-		Weight::from_parts(18_387_000, 4681)
+		// Minimum execution time: 15_029_000 picoseconds.
+		Weight::from_parts(15_567_000, 4681)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -853,8 +843,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 133_000 picoseconds.
-		Weight::from_parts(149_000, 0)
+		// Minimum execution time: 123_000 picoseconds.
+		Weight::from_parts(136_000, 0)
 	}
 	/// Storage: `Broker::CoreCountInbox` (r:0 w:1)
 	/// Proof: `Broker::CoreCountInbox` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`)
@@ -862,8 +852,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 2_407_000 picoseconds.
-		Weight::from_parts(2_634_000, 0)
+		// Minimum execution time: 1_775_000 picoseconds.
+		Weight::from_parts(1_911_000, 0)
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
 	/// Storage: `Broker::Status` (r:1 w:1)
@@ -878,8 +868,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `603`
 		//  Estimated: `4068`
-		// Minimum execution time: 13_043_000 picoseconds.
-		Weight::from_parts(13_541_000, 4068)
+		// Minimum execution time: 11_859_000 picoseconds.
+		Weight::from_parts(12_214_000, 4068)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -889,8 +879,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `239`
 		//  Estimated: `1526`
-		// Minimum execution time: 6_606_000 picoseconds.
-		Weight::from_parts(6_964_000, 1526)
+		// Minimum execution time: 5_864_000 picoseconds.
+		Weight::from_parts(6_231_000, 1526)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
diff --git a/substrate/frame/child-bounties/src/tests.rs b/substrate/frame/child-bounties/src/tests.rs
index d9405d3d28977c2cac3b42a034eb5fcfe8e56e8f..be6fd62bb4c56c677eab1eb575118889a043d1ca 100644
--- a/substrate/frame/child-bounties/src/tests.rs
+++ b/substrate/frame/child-bounties/src/tests.rs
@@ -69,23 +69,11 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 parameter_types! {
-	pub const ProposalBond: Permill = Permill::from_percent(5);
 	pub const Burn: Permill = Permill::from_percent(50);
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
 	pub TreasuryAccount: u128 = Treasury::account_id();
@@ -99,9 +87,6 @@ impl pallet_treasury::Config for Test {
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = ();
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ConstU64<1>;
-	type ProposalBondMaximum = ();
 	type SpendPeriod = ConstU64<2>;
 	type Burn = Burn;
 	type BurnDestination = ();
diff --git a/substrate/frame/contracts/Cargo.toml b/substrate/frame/contracts/Cargo.toml
index bd4ded1a1170c9356730eaef9ffbc28e0b6a356a..70363562f6af3c52846cb7103e5834c617ac0ae8 100644
--- a/substrate/frame/contracts/Cargo.toml
+++ b/substrate/frame/contracts/Cargo.toml
@@ -30,7 +30,7 @@ serde = { optional = true, features = ["derive"], workspace = true, default-feat
 smallvec = { version = "1", default-features = false, features = [
 	"const_generics",
 ] }
-wasmi = { version = "0.31", default-features = false }
+wasmi = { version = "0.32.3", default-features = false }
 impl-trait-for-tuples = "0.2"
 
 # Only used in benchmarking to generate contract code
diff --git a/substrate/frame/contracts/README.md b/substrate/frame/contracts/README.md
index 09dc770300ca8491af062bbde9e820deccdd1341..6440f14b9eced560971304b5f809dc0b64cde50a 100644
--- a/substrate/frame/contracts/README.md
+++ b/substrate/frame/contracts/README.md
@@ -34,19 +34,6 @@ calls are reverted. Assuming correct error handling by contract A, A's other cal
 
 One `ref_time` `Weight` is defined as one picosecond of execution time on the runtime's reference machine.
 
-#### Schedule
-
-The `Schedule` is where, among other things, the cost of every action a contract can do is defined. These costs are derived
-from the benchmarks of this pallet. Instead of looking at the raw benchmark results it is advised to look at the `Schedule`
-if one wants to manually inspect the performance characteristics. The `Schedule` can be printed like this:
-
-```sh
-RUST_LOG=runtime::contracts=info cargo run --features runtime-benchmarks --bin substrate-node -- benchmark pallet --extra -p pallet_contracts -e print_schedule
-```
-
-Please note that the `Schedule` will be printed multiple times. This is because we are (ab)using a benchmark to print
-the struct.
-
 ### Revert Behaviour
 
 Contract call failures are not cascading. When failures occur in a sub-call, they do not "bubble up", and the call will
@@ -125,7 +112,7 @@ Contracts can emit messages to the client when called as RPC through the
 API. This is exposed in [ink!](https://use.ink) via
 [`ink_env::debug_message()`](https://paritytech.github.io/ink/ink_env/fn.debug_message.html).
 
-Those messages are gathered into an internal buffer and sent to the RPC client. It is up the the individual client if
+Those messages are gathered into an internal buffer and sent to the RPC client. It is up to the individual client if
 and how those messages are presented to the user.
 
 This buffer is also printed as a debug message. In order to see these messages on the node console the log level for the
diff --git a/substrate/frame/contracts/fixtures/contracts/call_with_flags_and_value.rs b/substrate/frame/contracts/fixtures/contracts/call_with_flags_and_value.rs
new file mode 100644
index 0000000000000000000000000000000000000000..16a85eff398956cf094289a5119c3a0ad1c057ab
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/contracts/call_with_flags_and_value.rs
@@ -0,0 +1,51 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! This fixture calls the account_id with the flags and value.
+#![no_std]
+#![no_main]
+
+use common::input;
+use uapi::{HostFn, HostFnImpl as api};
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn deploy() {}
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn call() {
+	input!(
+		256,
+		callee_addr: [u8; 32],
+		flags: u32,
+		value: u64,
+		forwarded_input: [u8],
+	);
+
+	api::call_v2(
+		uapi::CallFlags::from_bits(flags).unwrap(),
+		callee_addr,
+		0u64,                 // How much ref_time to devote for the execution. 0 = all.
+		0u64,                 // How much proof_size to devote for the execution. 0 = all.
+		None,                 // No deposit limit.
+		&value.to_le_bytes(), // Value transferred to the contract.
+		forwarded_input,
+		None,
+	)
+	.unwrap();
+}
diff --git a/substrate/frame/contracts/fixtures/contracts/read_only_call.rs b/substrate/frame/contracts/fixtures/contracts/read_only_call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..524fe50b6d068c1af8b0b9a05370380a41fe2823
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/contracts/read_only_call.rs
@@ -0,0 +1,50 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This fixture tests if read-only call works as expected.
+#![no_std]
+#![no_main]
+
+use common::input;
+use uapi::{HostFn, HostFnImpl as api};
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn deploy() {}
+
+#[no_mangle]
+#[polkavm_derive::polkavm_export]
+pub extern "C" fn call() {
+	input!(
+		256,
+		callee_addr: [u8; 32],
+		callee_input: [u8],
+	);
+
+	// Call the callee
+	api::call_v2(
+		uapi::CallFlags::READ_ONLY,
+		callee_addr,
+		0u64,                // How much ref_time to devote for the execution. 0 = all.
+		0u64,                // How much proof_size to devote for the execution. 0 = all.
+		None,                // No deposit limit.
+		&0u64.to_le_bytes(), // Value transferred to the contract.
+		callee_input,
+		None,
+	)
+	.unwrap();
+}
diff --git a/substrate/frame/contracts/mock-network/src/parachain.rs b/substrate/frame/contracts/mock-network/src/parachain.rs
index b46d7df6c2bcf1f99a48540d5f1c5ef104d09206..f35846ba32c31e0b260ffe428f459f0a14b9256b 100644
--- a/substrate/frame/contracts/mock-network/src/parachain.rs
+++ b/substrate/frame/contracts/mock-network/src/parachain.rs
@@ -49,10 +49,6 @@ use xcm_executor::{traits::JustTry, Config, XcmExecutor};
 pub type SovereignAccountOf =
 	(AccountId32Aliases<RelayNetwork, AccountId>, ParentIsPreset<AccountId>);
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-}
-
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type RuntimeOrigin = RuntimeOrigin;
@@ -64,7 +60,6 @@ impl frame_system::Config for Runtime {
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type BlockWeights = ();
 	type BlockLength = ();
 	type Version = ();
diff --git a/substrate/frame/contracts/mock-network/src/relay_chain.rs b/substrate/frame/contracts/mock-network/src/relay_chain.rs
index 36a7de499ba99311889980ba2c02d8502602b945..8829fff3d0436d95b3e44d87b2258d13c167efc1 100644
--- a/substrate/frame/contracts/mock-network/src/relay_chain.rs
+++ b/substrate/frame/contracts/mock-network/src/relay_chain.rs
@@ -43,10 +43,6 @@ use super::{
 	primitives::{AccountId, Balance},
 };
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-}
-
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type RuntimeOrigin = RuntimeOrigin;
@@ -58,7 +54,6 @@ impl frame_system::Config for Runtime {
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
 	type BlockWeights = ();
 	type BlockLength = ();
 	type Version = ();
diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs
index 1794d09d5ad28e08bf9579bed4f311f469be832c..f91f8660cd315b4971eb60921d185f99c76ba9e3 100644
--- a/substrate/frame/contracts/proc-macro/src/lib.rs
+++ b/substrate/frame/contracts/proc-macro/src/lib.rs
@@ -132,6 +132,7 @@ struct HostFn {
 	alias_to: Option<String>,
 	/// Formulating the predicate inverted makes the expression using it simpler.
 	not_deprecated: bool,
+	cfg: Option<syn::Attribute>,
 }
 
 enum HostFnReturn {
@@ -149,7 +150,7 @@ impl HostFnReturn {
 			Self::U64 => quote! { ::core::primitive::u64 },
 		};
 		quote! {
-			::core::result::Result<#ok, ::wasmi::core::Trap>
+			::core::result::Result<#ok, ::wasmi::Error>
 		}
 	}
 }
@@ -163,13 +164,13 @@ impl ToTokens for HostFn {
 impl HostFn {
 	pub fn try_from(mut item: syn::ItemFn) -> syn::Result<Self> {
 		let err = |span, msg| {
-			let msg = format!("Invalid host function definition. {}", msg);
+			let msg = format!("Invalid host function definition.\n{}", msg);
 			syn::Error::new(span, msg)
 		};
 
 		// process attributes
 		let msg =
-			"only #[version(<u8>)], #[unstable], #[prefixed_alias] and #[deprecated] attributes are allowed.";
+			"Only #[version(<u8>)], #[unstable], #[prefixed_alias], #[cfg], #[mutating] and #[deprecated] attributes are allowed.";
 		let span = item.span();
 		let mut attrs = item.attrs.clone();
 		attrs.retain(|a| !a.path().is_ident("doc"));
@@ -177,6 +178,8 @@ impl HostFn {
 		let mut is_stable = true;
 		let mut alias_to = None;
 		let mut not_deprecated = true;
+		let mut mutating = false;
+		let mut cfg = None;
 		while let Some(attr) = attrs.pop() {
 			let ident = attr.path().get_ident().ok_or(err(span, msg))?.to_string();
 			match ident.as_str() {
@@ -206,9 +209,31 @@ impl HostFn {
 					}
 					not_deprecated = false;
 				},
-				_ => return Err(err(span, msg)),
+				"mutating" => {
+					if mutating {
+						return Err(err(span, "#[mutating] can only be specified once"))
+					}
+					mutating = true;
+				},
+				"cfg" => {
+					if cfg.is_some() {
+						return Err(err(span, "#[cfg] can only be specified once"))
+					}
+					cfg = Some(attr);
+				},
+				id => return Err(err(span, &format!("Unsupported attribute \"{id}\". {msg}"))),
 			}
 		}
+
+		if mutating {
+			let stmt = syn::parse_quote! {
+				if ctx.ext().is_read_only() {
+					return Err(Error::<E::T>::StateChangeDenied.into());
+				}
+			};
+			item.block.stmts.insert(0, stmt);
+		}
+
 		let name = item.sig.ident.to_string();
 
 		if !(is_stable || not_deprecated) {
@@ -311,6 +336,7 @@ impl HostFn {
 							is_stable,
 							alias_to,
 							not_deprecated,
+							cfg,
 						})
 					},
 					_ => Err(err(span, &msg)),
@@ -528,8 +554,9 @@ fn expand_env(def: &EnvDef, docs: bool) -> TokenStream2 {
 ///   - real implementation, to register it in the contract execution environment;
 ///   - dummy implementation, to be used as mocks for contract validation step.
 fn expand_impls(def: &EnvDef) -> TokenStream2 {
-	let impls = expand_functions(def, true, quote! { crate::wasm::Runtime<E> });
-	let dummy_impls = expand_functions(def, false, quote! { () });
+	let impls = expand_functions(def, ExpandMode::Impl);
+	let dummy_impls = expand_functions(def, ExpandMode::MockImpl);
+	let bench_impls = expand_functions(def, ExpandMode::BenchImpl);
 
 	quote! {
 		impl<'a, E: Ext> crate::wasm::Environment<crate::wasm::runtime::Runtime<'a, E>> for Env
@@ -545,6 +572,14 @@ fn expand_impls(def: &EnvDef) -> TokenStream2 {
 			}
 		}
 
+		#[cfg(feature = "runtime-benchmarks")]
+		pub struct BenchEnv<E>(::core::marker::PhantomData<E>);
+
+		#[cfg(feature = "runtime-benchmarks")]
+		impl<E: Ext> BenchEnv<E> {
+			#bench_impls
+		}
+
 		impl crate::wasm::Environment<()> for Env
 		{
 			fn define(
@@ -560,18 +595,38 @@ fn expand_impls(def: &EnvDef) -> TokenStream2 {
 	}
 }
 
-fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2) -> TokenStream2 {
+enum ExpandMode {
+	Impl,
+	BenchImpl,
+	MockImpl,
+}
+
+impl ExpandMode {
+	fn expand_blocks(&self) -> bool {
+		match *self {
+			ExpandMode::Impl | ExpandMode::BenchImpl => true,
+			ExpandMode::MockImpl => false,
+		}
+	}
+
+	fn host_state(&self) -> TokenStream2 {
+		match *self {
+			ExpandMode::Impl | ExpandMode::BenchImpl => quote! { crate::wasm::runtime::Runtime<E> },
+			ExpandMode::MockImpl => quote! { () },
+		}
+	}
+}
+
+fn expand_functions(def: &EnvDef, expand_mode: ExpandMode) -> TokenStream2 {
 	let impls = def.host_funcs.iter().map(|f| {
 		// skip the context and memory argument
 		let params = f.item.sig.inputs.iter().skip(2);
-
-		let (module, name, body, wasm_output, output) = (
-			f.module(),
-			&f.name,
-			&f.item.block,
-			f.returns.to_wasm_sig(),
-			&f.item.sig.output
-		);
+		let module = f.module();
+		let cfg = &f.cfg;
+		let name = &f.name;
+		let body = &f.item.block;
+		let wasm_output = f.returns.to_wasm_sig();
+		let output = &f.item.sig.output;
 		let is_stable = f.is_stable;
 		let not_deprecated = f.not_deprecated;
 
@@ -608,27 +663,38 @@ fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2)
 		// - We replace any code by unreachable!
 		// - Allow unused variables as the code that uses is not expanded
 		// - We don't need to map the error as we simply panic if they code would ever be executed
-		let inner = if expand_blocks {
-			quote! { || #output {
-				let (memory, ctx) = __caller__
-					.data()
-					.memory()
-					.expect("Memory must be set when setting up host data; qed")
-					.data_and_store_mut(&mut __caller__);
-				#wrapped_body_with_trace
-			} }
-		} else {
-			quote! { || -> #wasm_output {
-				// This is part of the implementation for `Environment<()>` which is not
-				// meant to be actually executed. It is only for validation which will
-				// never call host functions.
-				::core::unreachable!()
-			} }
+		let expand_blocks = expand_mode.expand_blocks();
+		let inner = match expand_mode {
+			ExpandMode::Impl => {
+				quote! { || #output {
+					let (memory, ctx) = __caller__
+						.data()
+						.memory()
+						.expect("Memory must be set when setting up host data; qed")
+						.data_and_store_mut(&mut __caller__);
+					#wrapped_body_with_trace
+				} }
+			},
+			ExpandMode::BenchImpl => {
+				let body = &body.stmts;
+				quote!{
+					#(#body)*
+				}
+			},
+			ExpandMode::MockImpl => {
+				quote! { || -> #wasm_output {
+					// This is part of the implementation for `Environment<()>` which is not
+					// meant to be actually executed. It is only for validation which will
+					// never call host functions.
+					::core::unreachable!()
+				} }
+			},
 		};
+
 		let into_host = if expand_blocks {
 			quote! {
 				|reason| {
-					::wasmi::core::Trap::from(reason)
+					::wasmi::Error::host(reason)
 				}
 			}
 		} else {
@@ -645,16 +711,21 @@ fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2)
 			quote! {
 				// Write gas from wasmi into pallet-contracts before entering the host function.
 				let __gas_left_before__ = {
-					let executor_total =
-						__caller__.fuel_consumed().expect("Fuel metering is enabled; qed");
+					let fuel =
+						__caller__.get_fuel().expect("Fuel metering is enabled; qed");
 					__caller__
 						.data_mut()
 						.ext()
 						.gas_meter_mut()
-						.sync_from_executor(executor_total)
+						.sync_from_executor(fuel)
 						.map_err(TrapReason::from)
 						.map_err(#into_host)?
 				};
+
+				// Charge gas for host function execution.
+				__caller__.data_mut().charge_gas(crate::wasm::RuntimeCosts::HostFn)
+						.map_err(TrapReason::from)
+						.map_err(#into_host)?;
 			}
 		} else {
 			quote! { }
@@ -662,43 +733,68 @@ fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2)
 		// Write gas from pallet-contracts into wasmi after leaving the host function.
 		let sync_gas_after = if expand_blocks {
 			quote! {
-				let fuel_consumed = __caller__
+				let fuel = __caller__
 					.data_mut()
 					.ext()
 					.gas_meter_mut()
 					.sync_to_executor(__gas_left_before__)
-					.map_err(TrapReason::from)?;
+					.map_err(|err| {
+						let err = TrapReason::from(err);
+						wasmi::Error::host(err)
+					})?;
 				 __caller__
-					 .consume_fuel(fuel_consumed.into())
-					 .map_err(|_| TrapReason::from(Error::<E::T>::OutOfGas))?;
+					 .set_fuel(fuel.into())
+					 .expect("Fuel metering is enabled; qed");
 			}
 		} else {
 			quote! { }
 		};
 
-		quote! {
-			// We need to allow all interfaces when runtime benchmarks are performed because
-			// we generate the weights even when those interfaces are not enabled. This
-			// is necessary as the decision whether we allow unstable or deprecated functions
-			// is a decision made at runtime. Generation of the weights happens statically.
-			if ::core::cfg!(feature = "runtime-benchmarks") ||
-				((#is_stable || __allow_unstable__) && (#not_deprecated || __allow_deprecated__))
-			{
-				#allow_unused
-				linker.define(#module, #name, ::wasmi::Func::wrap(&mut*store, |mut __caller__: ::wasmi::Caller<#host_state>, #( #params, )*| -> #wasm_output {
- 					#sync_gas_before
-					let mut func = #inner;
-					let result = func().map_err(#into_host).map(::core::convert::Into::into);
-					#sync_gas_after
-					result
-				}))?;
-			}
+		match expand_mode {
+			ExpandMode::BenchImpl => {
+				let name = Ident::new(&format!("{module}_{name}"), Span::call_site());
+				quote! {
+					pub fn #name(ctx: &mut crate::wasm::Runtime<E>, memory: &mut [u8], #(#params),*) #output {
+						#inner
+					}
+				}
+			},
+			_ => {
+				let host_state = expand_mode.host_state();
+				quote! {
+					// We need to allow all interfaces when runtime benchmarks are performed because
+					// we generate the weights even when those interfaces are not enabled. This
+					// is necessary as the decision whether we allow unstable or deprecated functions
+					// is a decision made at runtime. Generation of the weights happens statically.
+					#cfg
+					if ::core::cfg!(feature = "runtime-benchmarks") ||
+						((#is_stable || __allow_unstable__) && (#not_deprecated || __allow_deprecated__))
+					{
+						#allow_unused
+						linker.define(#module, #name, ::wasmi::Func::wrap(&mut*store, |mut __caller__: ::wasmi::Caller<#host_state>, #( #params, )*| -> #wasm_output {
+							#sync_gas_before
+							let mut func = #inner;
+							let result = func().map_err(#into_host).map(::core::convert::Into::into);
+							#sync_gas_after
+							result
+						}))?;
+					}
+				}
+			},
 		}
 	});
-	quote! {
-		let __allow_unstable__ = matches!(allow_unstable, AllowUnstableInterface::Yes);
-		let __allow_deprecated__ = matches!(allow_deprecated, AllowDeprecatedInterface::Yes);
-		#( #impls )*
+
+	match expand_mode {
+		ExpandMode::BenchImpl => {
+			quote! {
+			 #( #impls )*
+			}
+		},
+		_ => quote! {
+			let __allow_unstable__ = matches!(allow_unstable, AllowUnstableInterface::Yes);
+			let __allow_deprecated__ = matches!(allow_deprecated, AllowDeprecatedInterface::Yes);
+			#( #impls )*
+		},
 	}
 }
 
diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs
index 285fe0052b4d95a200eaebd0a86fb77d729aacfd..5d73d825fca9a76d15742c7a44b32b11a95fed51 100644
--- a/substrate/frame/contracts/src/benchmarking/call_builder.rs
+++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs
@@ -25,6 +25,7 @@ use crate::{
 };
 use codec::{Encode, HasCompact};
 use core::fmt::Debug;
+use frame_benchmarking::benchmarking;
 use sp_core::Get;
 use sp_std::prelude::*;
 
@@ -57,6 +58,16 @@ pub struct CallSetup<T: Config> {
 	data: Vec<u8>,
 }
 
+impl<T> Default for CallSetup<T>
+where
+	T: Config + pallet_balances::Config,
+	<BalanceOf<T> as HasCompact>::Type: Clone + Eq + PartialEq + Debug + TypeInfo + Encode,
+{
+	fn default() -> Self {
+		Self::new(WasmModule::dummy())
+	}
+}
+
 impl<T> CallSetup<T>
 where
 	T: Config + pallet_balances::Config,
@@ -70,6 +81,17 @@ where
 
 		let storage_meter = Meter::new(&origin, None, 0u32.into()).unwrap();
 
+		// Whitelist contract account, as it is already accounted for in the call benchmark
+		benchmarking::add_to_whitelist(
+			frame_system::Account::<T>::hashed_key_for(&contract.account_id).into(),
+		);
+
+		// Whitelist the contract's contractInfo as it is already accounted for in the call
+		// benchmark
+		benchmarking::add_to_whitelist(
+			crate::ContractInfoOf::<T>::hashed_key_for(&contract.account_id).into(),
+		);
+
 		Self {
 			contract,
 			dest,
@@ -150,21 +172,29 @@ where
 }
 
 #[macro_export]
-macro_rules! call_builder(
-	($func: ident, $module:expr) => {
-		$crate::call_builder!($func, _contract, $module);
+macro_rules! memory(
+	($($bytes:expr,)*) => {
+		 vec![]
+		    .into_iter()
+		    $(.chain($bytes))*
+		    .collect::<Vec<_>>()
 	};
-	($func: ident, $contract: ident, $module:expr) => {
-		let mut setup = CallSetup::<T>::new($module);
-		$crate::call_builder!($func, $contract, setup: setup);
+);
+
+#[macro_export]
+macro_rules! build_runtime(
+	($runtime:ident, $memory:ident: [$($segment:expr,)*]) => {
+		$crate::build_runtime!($runtime, _contract, $memory: [$($segment,)*]);
 	};
-    ($func:ident, setup: $setup: ident) => {
-		$crate::call_builder!($func, _contract, setup: $setup);
+	($runtime:ident, $contract:ident, $memory:ident: [$($bytes:expr,)*]) => {
+		$crate::build_runtime!($runtime, $contract);
+		let mut $memory = $crate::memory!($($bytes,)*);
 	};
-    ($func:ident, $contract: ident, setup: $setup: ident) => {
-		let data = $setup.data();
-		let $contract = $setup.contract();
-		let (mut ext, module) = $setup.ext();
-		let $func = CallSetup::<T>::prepare_call(&mut ext, module, data);
+	($runtime:ident, $contract:ident) => {
+		let mut setup = CallSetup::<T>::default();
+		let $contract = setup.contract();
+		let input = setup.data();
+		let (mut ext, _) = setup.ext();
+		let mut $runtime = crate::wasm::Runtime::new(&mut ext, input);
 	};
 );
diff --git a/substrate/frame/contracts/src/benchmarking/code.rs b/substrate/frame/contracts/src/benchmarking/code.rs
index b97cf168e26d4562e4f4a3b7f07ad243174e7a98..65bcf30683c05e83515815ae33ffe5d9c4aadb70 100644
--- a/substrate/frame/contracts/src/benchmarking/code.rs
+++ b/substrate/frame/contracts/src/benchmarking/code.rs
@@ -288,17 +288,15 @@ impl<T: Config> WasmModule<T> {
 		module.into()
 	}
 
-	/// Creates a wasm module that calls the imported function named `getter_name` `repeat`
-	/// times. The imported function is expected to have the "getter signature" of
-	/// (out_ptr: u32, len_ptr: u32) -> ().
-	pub fn getter(module_name: &'static str, getter_name: &'static str, repeat: u32) -> Self {
+	/// Creates a wasm module that calls the imported function `noop` `repeat` times.
+	pub fn noop(repeat: u32) -> Self {
 		let pages = max_pages::<T>();
 		ModuleDefinition {
 			memory: Some(ImportedMemory::max::<T>()),
 			imported_functions: vec![ImportedFunction {
-				module: module_name,
-				name: getter_name,
-				params: vec![ValueType::I32, ValueType::I32],
+				module: "seal0",
+				name: "noop",
+				params: vec![],
 				return_type: None,
 			}],
 			// Write the output buffer size. The output size will be overwritten by the
@@ -312,35 +310,7 @@ impl<T: Config> WasmModule<T> {
 			call_body: Some(body::repeated(
 				repeat,
 				&[
-					Instruction::I32Const(4), // ptr where to store output
-					Instruction::I32Const(0), // ptr to length
-					Instruction::Call(0),     // call the imported function
-				],
-			)),
-			..Default::default()
-		}
-		.into()
-	}
-
-	/// Creates a wasm module that calls the imported hash function named `name` `repeat` times
-	/// with an input of size `data_size`. Hash functions have the signature
-	/// (input_ptr: u32, input_len: u32, output_ptr: u32) -> ()
-	pub fn hasher(name: &'static str, repeat: u32, data_size: u32) -> Self {
-		ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name,
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			call_body: Some(body::repeated(
-				repeat,
-				&[
-					Instruction::I32Const(0),                // input_ptr
-					Instruction::I32Const(data_size as i32), // input_len
-					Instruction::I32Const(0),                // output_ptr
-					Instruction::Call(0),
+					Instruction::Call(0), // call the imported function
 				],
 			)),
 			..Default::default()
@@ -353,21 +323,6 @@ impl<T: Config> WasmModule<T> {
 pub mod body {
 	use super::*;
 
-	/// When generating contract code by repeating a Wasm sequence, it's sometimes necessary
-	/// to change those instructions on each repetition. The variants of this enum describe
-	/// various ways in which this can happen.
-	pub enum DynInstr {
-		/// Insert the associated instruction.
-		Regular(Instruction),
-		/// Insert a I32Const with incrementing value for each insertion.
-		/// (start_at, increment_by)
-		Counter(u32, u32),
-	}
-
-	pub fn plain(instructions: Vec<Instruction>) -> FuncBody {
-		FuncBody::new(Vec::new(), Instructions::new(instructions))
-	}
-
 	pub fn repeated(repetitions: u32, instructions: &[Instruction]) -> FuncBody {
 		repeated_with_locals(&[], repetitions, instructions)
 	}
@@ -401,24 +356,6 @@ pub mod body {
 		instructions.push(Instruction::End);
 		FuncBody::new(locals.to_vec(), Instructions::new(instructions))
 	}
-
-	pub fn repeated_dyn(repetitions: u32, mut instructions: Vec<DynInstr>) -> FuncBody {
-		// We need to iterate over indices because we cannot cycle over mutable references
-		let body = (0..instructions.len())
-			.cycle()
-			.take(instructions.len() * usize::try_from(repetitions).unwrap())
-			.flat_map(|idx| match &mut instructions[idx] {
-				DynInstr::Regular(instruction) => vec![instruction.clone()],
-				DynInstr::Counter(offset, increment_by) => {
-					let current = *offset;
-					*offset += *increment_by;
-					vec![Instruction::I32Const(current as i32)]
-				},
-			})
-			.chain(sp_std::iter::once(Instruction::End))
-			.collect();
-		FuncBody::new(Vec::new(), Instructions::new(body))
-	}
 }
 
 /// The maximum amount of pages any contract is allowed to have according to the current `Schedule`.
diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs
index 952ef180be21860b4a13a26fdf07bf03251f00a2..80c7e863d2994020e5f79dc3364cddb25dc72890 100644
--- a/substrate/frame/contracts/src/benchmarking/mod.rs
+++ b/substrate/frame/contracts/src/benchmarking/mod.rs
@@ -23,33 +23,31 @@ mod code;
 mod sandbox;
 use self::{
 	call_builder::CallSetup,
-	code::{
-		body::{self, DynInstr::*},
-		DataSegment, ImportedFunction, ImportedMemory, Location, ModuleDefinition, WasmModule,
-	},
+	code::{body, ImportedMemory, Location, ModuleDefinition, WasmModule},
 	sandbox::Sandbox,
 };
 use crate::{
-	exec::Key,
+	exec::{Key, SeedOf},
 	migration::{
 		codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, v14, v15, v16, MigrationStep,
 	},
+	wasm::BenchEnv,
 	Pallet as Contracts, *,
 };
 use codec::{Encode, MaxEncodedLen};
 use frame_benchmarking::v2::*;
 use frame_support::{
-	self,
+	self, assert_ok,
 	pallet_prelude::StorageVersion,
 	traits::{fungible::InspectHold, Currency},
 	weights::{Weight, WeightMeter},
 };
 use frame_system::RawOrigin;
 use pallet_balances;
-use pallet_contracts_uapi::CallFlags;
+use pallet_contracts_uapi::{CallFlags, ReturnErrorCode};
 use sp_runtime::traits::{Bounded, Hash};
 use sp_std::prelude::*;
-use wasm_instrument::parity_wasm::elements::{BlockType, Instruction, Local, ValueType};
+use wasm_instrument::parity_wasm::elements::{Instruction, Local, ValueType};
 
 /// How many runs we do per API benchmark.
 ///
@@ -442,13 +440,6 @@ mod benchmarks {
 		Ok(())
 	}
 
-	// This constructs a contract that is maximal expensive to instrument.
-	// It creates a maximum number of metering blocks per byte.
-	// The size of the salt influences the runtime because is is hashed in order to
-	// determine the contract address. All code is generated to the `call` function so that
-	// we don't benchmark the actual execution of this code but merely what it takes to load
-	// a code of that size into the sandbox.
-	//
 	// `c`: Size of the code in bytes.
 	// `i`: Size of the input in bytes.
 	// `s`: Size of the salt in bytes.
@@ -482,7 +473,6 @@ mod benchmarks {
 		assert_eq!(T::Currency::balance(&addr), value + Pallet::<T>::min_balance());
 	}
 
-	// Instantiate uses a dummy contract constructor to measure the overhead of the instantiate.
 	// `i`: Size of the input in bytes.
 	// `s`: Size of the salt in bytes.
 	#[benchmark(pov_mode = Measured)]
@@ -621,507 +611,306 @@ mod benchmarks {
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_caller(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_caller", r));
-
-		let res;
+	fn noop_host_fn(r: Linear<0, API_BENCHMARK_RUNS>) {
+		let mut setup = CallSetup::<T>::new(WasmModule::noop(r));
+		let (mut ext, module) = setup.ext();
+		let func = CallSetup::<T>::prepare_call(&mut ext, module, vec![]);
 		#[block]
 		{
-			res = func.call();
+			func.call();
 		}
-		assert_eq!(res.did_revert(), false);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_is_contract(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let accounts = (0..r).map(|n| account::<T::AccountId>("account", n, 0)).collect::<Vec<_>>();
-		let account_len = accounts.get(0).map(|i| i.encode().len()).unwrap_or(0);
-		let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::<Vec<_>>();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_is_contract",
-				params: vec![ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: accounts_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, account_len as u32), // address_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
-		let info = instance.info().unwrap();
-		// every account would be a contract (worst case)
-		for acc in accounts.iter() {
-			<ContractInfoOf<T>>::insert(acc, info.clone());
-		}
+	fn seal_caller() {
+		let len = <T::AccountId as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_caller(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
+		assert_eq!(
+			&<T::AccountId as Decode>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().caller().account_id().unwrap()
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_code_hash(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let accounts = (0..r).map(|n| account::<T::AccountId>("account", n, 0)).collect::<Vec<_>>();
-		let account_len = accounts.get(0).map(|i| i.encode().len()).unwrap_or(0);
-		let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::<Vec<_>>();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_code_hash",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment {
-					offset: 0,
-					value: 32u32.to_le_bytes().to_vec(), // output length
-				},
-				DataSegment { offset: 36, value: accounts_bytes },
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(36, account_len as u32),   // address_ptr
-					Regular(Instruction::I32Const(4)), // ptr to output data
-					Regular(Instruction::I32Const(0)), // ptr to output length
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
-		let info = instance.info().unwrap();
-		// every account would be a contract (worst case)
-		for acc in accounts.iter() {
-			<ContractInfoOf<T>>::insert(acc, info.clone());
-		}
+	fn seal_is_contract() {
+		let Contract { account_id, .. } =
+			Contract::<T>::with_index(1, WasmModule::dummy(), vec![]).unwrap();
 
-		let res;
+		build_runtime!(runtime, memory: [account_id.encode(), ]);
+
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_is_contract(&mut runtime, &mut memory, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_eq!(result.unwrap(), 1);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_own_code_hash(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_own_code_hash", r));
+	fn seal_code_hash() {
+		let contract = Contract::<T>::with_index(1, WasmModule::dummy(), vec![]).unwrap();
+		let len = <CodeHash<T> as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], contract.account_id.encode(), ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_code_hash(&mut runtime, &mut memory, 4 + len, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
+		assert_eq!(
+			<CodeHash<T> as Decode>::decode(&mut &memory[4..]).unwrap(),
+			contract.info().unwrap().code_hash
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_caller_is_origin(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_caller_is_origin",
-				params: vec![],
-				return_type: Some(ValueType::I32),
-			}],
-			call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])),
-			..Default::default()
-		});
-		call_builder!(func, code);
-
-		let res;
+	fn seal_own_code_hash() {
+		let len = <CodeHash<T> as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, contract, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_own_code_hash(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
+		assert_eq!(
+			<CodeHash<T> as Decode>::decode(&mut &memory[4..]).unwrap(),
+			contract.info().unwrap().code_hash
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_caller_is_root(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "caller_is_root",
-				params: vec![],
-				return_type: Some(ValueType::I32),
-			}],
-			call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
-		setup.set_origin(Origin::Root);
-		call_builder!(func, setup: setup);
+	fn seal_caller_is_origin() {
+		build_runtime!(runtime, memory: []);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_caller_is_origin(&mut runtime, &mut memory);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_eq!(result.unwrap(), 1u32);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_address(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_address", r));
+	fn seal_caller_is_root() {
+		let mut setup = CallSetup::<T>::default();
+		setup.set_origin(Origin::Root);
+		let (mut ext, _) = setup.ext();
+		let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_caller_is_root(&mut runtime, &mut [0u8; 0]);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_eq!(result.unwrap(), 1u32);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_gas_left(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal1", "gas_left", r));
+	fn seal_address() {
+		let len = <AccountIdOf<T> as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_address(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(
+			&<T::AccountId as Decode>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().address()
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_balance(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_balance", r));
+	fn seal_gas_left() {
+		// use correct max_encoded_len when new version of parity-scale-codec is released
+		let len = 18u32;
+		assert!(<Weight as MaxEncodedLen>::max_encoded_len() as u32 != len);
+		build_runtime!(runtime, memory: [32u32.to_le_bytes(), vec![0u8; len as _], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal1_gas_left(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(
+			<Weight as Decode>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().gas_meter().gas_left()
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_value_transferred(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_value_transferred", r));
-
-		let res;
+	fn seal_balance() {
+		let len = <T::Balance as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_seal_balance(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(
+			<T::Balance as Decode>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().balance().into()
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_minimum_balance(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_minimum_balance", r));
-
-		let res;
+	fn seal_value_transferred() {
+		let len = <T::Balance as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_value_transferred(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(
+			<T::Balance as Decode>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().value_transferred().into()
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_block_number(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_block_number", r));
-
-		let res;
+	fn seal_minimum_balance() {
+		let len = <T::Balance as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_minimum_balance(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(
+			<T::Balance as Decode>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().minimum_balance().into()
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_now(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::getter("seal0", "seal_now", r));
-
-		let res;
+	fn seal_block_number() {
+		let len = <BlockNumberFor<T> as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_seal_block_number(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(
+			<BlockNumberFor<T>>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().block_number()
+		);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_weight_to_fee(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let pages = code::max_pages::<T>();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "weight_to_fee",
-				params: vec![ValueType::I64, ValueType::I64, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			data_segments: vec![DataSegment {
-				offset: 0,
-				value: (pages * 64 * 1024 - 4).to_le_bytes().to_vec(),
-			}],
-			call_body: Some(body::repeated(
-				r,
-				&[
-					Instruction::I64Const(500_000),
-					Instruction::I64Const(300_000),
-					Instruction::I32Const(4),
-					Instruction::I32Const(0),
-					Instruction::Call(0),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
-
-		let res;
+	fn seal_now() {
+		let len = <MomentOf<T> as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_seal_now(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(<MomentOf<T>>::decode(&mut &memory[4..]).unwrap(), *runtime.ext().now());
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_input(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_input",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: 0u32.to_le_bytes().to_vec() }],
-			call_body: Some(body::repeated(
-				r,
-				&[
-					Instruction::I32Const(4), // ptr where to store output
-					Instruction::I32Const(0), // ptr to length
-					Instruction::Call(0),
-				],
-			)),
-			..Default::default()
-		});
-
-		call_builder!(func, code);
-
-		let res;
+	fn seal_weight_to_fee() {
+		let len = <T::Balance as MaxEncodedLen>::max_encoded_len() as u32;
+		build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]);
+		let weight = Weight::from_parts(500_000, 300_000);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal1_weight_to_fee(
+				&mut runtime,
+				&mut memory,
+				weight.ref_time(),
+				weight.proof_size(),
+				4,
+				0,
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-	}
-
-	#[benchmark(pov_mode = Measured)]
-	fn seal_input_per_byte(
-		n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>,
-	) -> Result<(), BenchmarkError> {
-		let buffer_size = code::max_pages::<T>() * 64 * 1024 - 4;
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_input",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			data_segments: vec![DataSegment {
-				offset: 0,
-				value: buffer_size.to_le_bytes().to_vec(),
-			}],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(4), // ptr where to store output
-				Instruction::I32Const(0), // ptr to length
-				Instruction::Call(0),
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		let instance = Contract::<T>::new(code, vec![])?;
-		let data = vec![42u8; n.min(buffer_size) as usize];
-		let origin = RawOrigin::Signed(instance.caller.clone());
-		#[extrinsic_call]
-		call(origin, instance.addr, 0u32.into(), Weight::MAX, None, data);
-		Ok(())
+		assert_ok!(result);
+		assert_eq!(
+			<BalanceOf<T>>::decode(&mut &memory[4..]).unwrap(),
+			runtime.ext().get_weight_price(weight)
+		);
 	}
 
-	// We cannot call `seal_return` multiple times. Therefore our weight determination is not
-	// as precise as with other APIs. Because this function can only be called once per
-	// contract it cannot be used as an attack vector.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_return(r: Linear<0, 1>) {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_return",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			call_body: Some(body::repeated(
-				r,
-				&[
-					Instruction::I32Const(0), // flags
-					Instruction::I32Const(0), // data_ptr
-					Instruction::I32Const(0), // data_len
-					Instruction::Call(0),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
-
-		let res;
+	fn seal_input(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 - 4 }>) {
+		let mut setup = CallSetup::<T>::default();
+		let (mut ext, _) = setup.ext();
+		let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![42u8; n as usize]);
+		let mut memory = memory!(n.to_le_bytes(), vec![0u8; n as usize],);
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_input(&mut runtime, &mut memory, 4, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert_eq!(&memory[4..], &vec![42u8; n as usize]);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_return_per_byte(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_return",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),        // flags
-				Instruction::I32Const(0),        // data_ptr
-				Instruction::I32Const(n as i32), // data_len
-				Instruction::Call(0),
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		call_builder!(func, code);
+	fn seal_return(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 - 4 }>) {
+		build_runtime!(runtime, memory: [n.to_le_bytes(), vec![42u8; n as usize], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_seal_return(&mut runtime, &mut memory, 0, 0, n);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert!(matches!(
+			result,
+			Err(crate::wasm::TrapReason::Return(crate::wasm::ReturnData { .. }))
+		));
 	}
 
-	// The same argument as for `seal_return` is true here.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_terminate(r: Linear<0, 1>) -> Result<(), BenchmarkError> {
+	fn seal_terminate(
+		n: Linear<0, { T::MaxDelegateDependencies::get() }>,
+	) -> Result<(), BenchmarkError> {
 		let beneficiary = account::<T::AccountId>("beneficiary", 0, 0);
-		let beneficiary_bytes = beneficiary.encode();
-		let beneficiary_len = beneficiary_bytes.len();
 		let caller = whitelisted_caller();
 
+		build_runtime!(runtime, memory: [beneficiary.encode(),]);
+
 		T::Currency::set_balance(&caller, caller_funding::<T>());
 
-		// Maximize the delegate_dependencies to account for the worst-case scenario.
-		let code_hashes = (0..T::MaxDelegateDependencies::get())
-			.map(|i| {
-				let new_code = WasmModule::<T>::dummy_with_bytes(65 + i);
-				Contracts::<T>::store_code_raw(new_code.code, caller.clone())?;
-				Ok(new_code.hash)
-			})
-			.collect::<Result<Vec<_>, &'static str>>()?;
-		let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0);
-		let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::<Vec<_>>();
-
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![
-				ImportedFunction {
-					module: "seal0",
-					name: "seal_terminate",
-					params: vec![ValueType::I32, ValueType::I32],
-					return_type: None,
-				},
-				ImportedFunction {
-					module: "seal0",
-					name: "lock_delegate_dependency",
-					params: vec![ValueType::I32],
-					return_type: None,
-				},
-			],
-			data_segments: vec![
-				DataSegment { offset: 0, value: beneficiary_bytes },
-				DataSegment { offset: beneficiary_len as u32, value: code_hashes_bytes },
-			],
-			deploy_body: Some(body::repeated_dyn(
-				T::MaxDelegateDependencies::get(),
-				vec![
-					Counter(beneficiary_len as u32, code_hash_len as u32), // code_hash_ptr
-					Regular(Instruction::Call(1)),
-				],
-			)),
-			call_body: Some(body::repeated(
-				r,
-				&[
-					Instruction::I32Const(0),                      // beneficiary_ptr
-					Instruction::I32Const(beneficiary_len as i32), // beneficiary_len
-					Instruction::Call(0),
-				],
-			)),
-			..Default::default()
+		(0..n).for_each(|i| {
+			let new_code = WasmModule::<T>::dummy_with_bytes(65 + i);
+			Contracts::<T>::store_code_raw(new_code.code, caller.clone()).unwrap();
+			runtime.ext().lock_delegate_dependency(new_code.hash).unwrap();
 		});
-		let instance = Contract::<T>::new(code, vec![])?;
-		let origin = RawOrigin::Signed(instance.caller.clone());
-		assert_eq!(T::Currency::total_balance(&beneficiary), 0u32.into());
-		assert_eq!(
-			T::Currency::balance(&instance.account_id),
-			Pallet::<T>::min_balance() * 2u32.into()
-		);
-		assert_ne!(
-			T::Currency::balance_on_hold(
-				&HoldReason::StorageDepositReserve.into(),
-				&instance.account_id
-			),
-			0u32.into()
-		);
-		assert_eq!(
-			ContractInfoOf::<T>::get(&instance.account_id)
-				.unwrap()
-				.delegate_dependencies_count() as u32,
-			T::MaxDelegateDependencies::get()
-		);
-		#[extrinsic_call]
-		call(origin, instance.addr.clone(), 0u32.into(), Weight::MAX, None, vec![]);
-
-		if r > 0 {
-			assert_eq!(T::Currency::total_balance(&instance.account_id), 0u32.into());
-			assert_eq!(
-				T::Currency::balance_on_hold(
-					&HoldReason::StorageDepositReserve.into(),
-					&instance.account_id
-				),
-				0u32.into()
-			);
-			assert_eq!(
-				T::Currency::total_balance(&beneficiary),
-				Pallet::<T>::min_balance() * 2u32.into()
-			);
+
+		let result;
+		#[block]
+		{
+			result = BenchEnv::seal1_terminate(&mut runtime, &mut memory, 0);
 		}
+
+		assert!(matches!(result, Err(crate::wasm::TrapReason::Termination)));
+
 		Ok(())
 	}
 
@@ -1129,161 +918,77 @@ mod benchmarks {
 	// number (< 1 KB). Therefore we are not overcharging too much in case a smaller subject is
 	// used.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_random(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let pages = code::max_pages::<T>();
+	fn seal_random() {
 		let subject_len = T::Schedule::get().limits.subject_len;
 		assert!(subject_len < 1024);
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_random",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			data_segments: vec![DataSegment {
-				offset: 0,
-				value: (pages * 64 * 1024 - subject_len - 4).to_le_bytes().to_vec(),
-			}],
-			call_body: Some(body::repeated(
-				r,
-				&[
-					Instruction::I32Const(4),                        // subject_ptr
-					Instruction::I32Const(subject_len as i32),       // subject_len
-					Instruction::I32Const((subject_len + 4) as i32), // out_ptr
-					Instruction::I32Const(0),                        // out_len_ptr
-					Instruction::Call(0),
-				],
-			)),
-			..Default::default()
-		});
 
-		call_builder!(func, code);
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-	}
-
-	// Overhead of calling the function without any topic.
-	// We benchmark for the worst case (largest event).
-	#[benchmark(pov_mode = Measured)]
-	fn seal_deposit_event(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_deposit_event",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			call_body: Some(body::repeated(
-				r,
-				&[
-					Instruction::I32Const(0), // topics_ptr
-					Instruction::I32Const(0), // topics_len
-					Instruction::I32Const(0), // data_ptr
-					Instruction::I32Const(0), // data_len
-					Instruction::Call(0),
-				],
-			)),
-			..Default::default()
-		});
+		let output_len =
+			<(SeedOf<T>, BlockNumberFor<T>) as MaxEncodedLen>::max_encoded_len() as u32;
 
-		call_builder!(func, code);
+		build_runtime!(runtime, memory: [
+			output_len.to_le_bytes(),
+			vec![42u8; subject_len as _],
+			vec![0u8; output_len as _],
+		]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_random(
+				&mut runtime,
+				&mut memory,
+				4,               // subject_ptr
+				subject_len,     // subject_len
+				subject_len + 4, // output_ptr
+				0,               // output_len_ptr
+			);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
+		assert_ok!(<(SeedOf<T>, BlockNumberFor<T>)>::decode(&mut &memory[subject_len as _..]));
 	}
 
 	// Benchmark the overhead that topics generate.
 	// `t`: Number of topics
 	// `n`: Size of event payload in bytes
 	#[benchmark(pov_mode = Measured)]
-	fn seal_deposit_event_per_topic_and_byte(
+	fn seal_deposit_event(
 		t: Linear<0, { T::Schedule::get().limits.event_topics }>,
 		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
 	) {
 		let topics = (0..t).map(|i| T::Hashing::hash_of(&i)).collect::<Vec<_>>().encode();
-		let topics_len = topics.len();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_deposit_event",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: topics }],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),                 // topics_ptr
-				Instruction::I32Const(topics_len as i32), // topics_len
-				Instruction::I32Const(0),                 // data_ptr
-				Instruction::I32Const(n as i32),          // data_len
-				Instruction::Call(0),
-				Instruction::End,
-			])),
-			..Default::default()
-		});
+		let topics_len = topics.len() as u32;
 
-		call_builder!(func, code);
+		build_runtime!(runtime, memory: [
+			n.to_le_bytes(),
+			topics,
+			vec![0u8; n as _],
+		]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_deposit_event(
+				&mut runtime,
+				&mut memory,
+				4,              // topics_ptr
+				topics_len,     // topics_len
+				4 + topics_len, // data_ptr
+				0,              // data_len
+			);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
 	}
 
-	// Benchmark debug_message call with zero input data.
+	// Benchmark debug_message call
 	// Whereas this function is used in RPC mode only, it still should be secured
 	// against an excessive use.
-	#[benchmark(pov_mode = Measured)]
-	fn seal_debug_message(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory { min_pages: 1, max_pages: 1 }),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_debug_message",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			call_body: Some(body::repeated(
-				r,
-				&[
-					Instruction::I32Const(0), // value_ptr
-					Instruction::I32Const(0), // value_len
-					Instruction::Call(0),
-					Instruction::Drop,
-				],
-			)),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
-		setup.enable_debug_message();
-		call_builder!(func, setup: setup);
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
-
-	// Vary size of input in bytes up to maximum allowed contract memory
-	// or maximum allowed debug buffer size, whichever is less.
+	//
+	// i: size of input in bytes up to maximum allowed contract memory or maximum allowed debug
+	// buffer size, whichever is less.
 	#[benchmark]
-	fn seal_debug_message_per_byte(
+	fn seal_debug_message(
 		i: Linear<
 			0,
 			{
@@ -1291,1619 +996,586 @@ mod benchmarks {
 					.min(T::MaxDebugBufferLen::get())
 			},
 		>,
-	) -> Result<(), BenchmarkError> {
-		// We benchmark versus messages containing printable ASCII codes.
-		// About 1Kb goes to the contract code instructions,
-		// whereas all the space left we use for the initialization of the debug messages data.
-		let message = (0..T::MaxCodeLen::get() - 1024)
-			.zip((32..127).cycle())
-			.map(|i| i.1)
-			.collect::<Vec<_>>();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory {
-				min_pages: T::Schedule::get().limits.memory_pages,
-				max_pages: T::Schedule::get().limits.memory_pages,
-			}),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_debug_message",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: message }],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),        // value_ptr
-				Instruction::I32Const(i as i32), // value_len
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
+	) {
+		let mut setup = CallSetup::<T>::default();
 		setup.enable_debug_message();
-		call_builder!(func, setup: setup);
+		let (mut ext, _) = setup.ext();
+		let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]);
+		// Fill memory with printable ASCII bytes.
+		let mut memory = (0..i).zip((32..127).cycle()).map(|i| i.1).collect::<Vec<_>>();
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_debug_message(&mut runtime, &mut memory, 0, i);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
 		assert_eq!(setup.debug_message().unwrap().len() as u32, i);
-		Ok(())
 	}
 
-	// Only the overhead of calling the function itself with minimal arguments.
-	// The contract is a bit more complex because it needs to use different keys in order
-	// to generate unique storage accesses. However, it is still dominated by the storage
-	// accesses. We store something at all the keys that we are about to write to
-	// because re-writing at an existing key is always more expensive than writing
-	// to an key with no data behind it.
-	//
-	// # Note
-	//
-	// We need to use a smaller `r` because the keys are big and writing them all into the wasm
-	// might exceed the code size.
+	// n: new byte size
+	// o: old byte size
 	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_set_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> {
-		let max_key_len = T::MaxStorageKeyLen::get();
-		let keys = (0..r)
-			.map(|n| {
-				let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
-				h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]);
-				h
-			})
-			.collect::<Vec<_>>();
-		let keys_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal2",
-				name: "set_storage",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: keys_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, max_key_len as u32),                     // key_ptr
-					Regular(Instruction::I32Const(max_key_len as i32)), // key_len
-					Regular(Instruction::I32Const(0)),                  // value_ptr
-					Regular(Instruction::I32Const(0)),                  // value_len
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-
-		call_builder!(func, instance, code);
-		let info = instance.info()?;
-		for key in keys {
-			info.write(
-				&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-				Some(vec![]),
-				None,
-				false,
-			)
-			.map_err(|_| "Failed to write to storage during setup.")?;
-		}
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
-
-	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_set_storage_per_new_byte(
+	fn seal_set_storage(
 		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
+		o: Linear<0, { T::Schedule::get().limits.payload_len }>,
 	) -> Result<(), BenchmarkError> {
 		let max_key_len = T::MaxStorageKeyLen::get();
-		let key = vec![0u8; max_key_len as usize];
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal2",
-				name: "set_storage",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: key.clone() }],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),                  // key_ptr
-				Instruction::I32Const(max_key_len as i32), // key_len
-				Instruction::I32Const(0),                  // value_ptr
-				Instruction::I32Const(n as i32),           // value_len
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
-		let info = instance.info()?;
-		info.write(
-			&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-			Some(vec![]),
-			None,
-			false,
-		)
-		.map_err(|_| "Failed to write to storage during setup.")?;
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
+		let key = Key::<T>::try_from_var(vec![0u8; max_key_len as usize])
+			.map_err(|_| "Key has wrong length")?;
+		let value = vec![1u8; n as usize];
 
-	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_set_storage_per_old_byte(
-		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
-	) -> Result<(), BenchmarkError> {
-		let max_key_len = T::MaxStorageKeyLen::get();
-		let key = vec![0u8; max_key_len as usize];
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal2",
-				name: "set_storage",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: key.clone() }],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),                  // key_ptr
-				Instruction::I32Const(max_key_len as i32), // key_len
-				Instruction::I32Const(0),                  // value_ptr
-				Instruction::I32Const(0),                  /* value_len is 0 as testing vs
-				                                            * pre-existing value len */
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
+		build_runtime!(runtime, instance, memory: [ key.to_vec(), value.clone(), ]);
 		let info = instance.info()?;
-		info.write(
-			&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-			Some(vec![42u8; n as usize]),
-			None,
-			false,
-		)
-		.map_err(|_| "Failed to write to storage during setup.")?;
 
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
-
-	// Similar to seal_set_storage. We store all the keys that we are about to
-	// delete beforehand in order to prevent any optimizations that could occur when
-	// deleting a non existing key. We generate keys of a maximum length, and have to
-	// the amount of runs in order to make resulting contract code size less than MaxCodeLen.
-	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_clear_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> {
-		let max_key_len = T::MaxStorageKeyLen::get();
-		let keys = (0..r)
-			.map(|n| {
-				let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
-				h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]);
-				h
-			})
-			.collect::<Vec<_>>();
-		let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "clear_storage",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: key_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, max_key_len as u32),                     // key_ptr
-					Regular(Instruction::I32Const(max_key_len as i32)), // key_len
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
-		let info = instance.info()?;
-		for key in keys {
-			info.write(
-				&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-				Some(vec![]),
-				None,
-				false,
-			)
+		info.write(&key, Some(vec![42u8; o as usize]), None, false)
 			.map_err(|_| "Failed to write to storage during setup.")?;
-		}
-		<ContractInfoOf<T>>::insert(&instance.account_id, info);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal2_set_storage(
+				&mut runtime,
+				&mut memory,
+				0,           // key_ptr
+				max_key_len, // key_len
+				max_key_len, // value_ptr
+				n,           // value_len
+			);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
+		assert_eq!(info.read(&key).unwrap(), value);
 		Ok(())
 	}
 
 	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_clear_storage_per_byte(
+	fn seal_clear_storage(
 		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
 	) -> Result<(), BenchmarkError> {
 		let max_key_len = T::MaxStorageKeyLen::get();
-		let key = vec![0u8; max_key_len as usize];
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "clear_storage",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: key.clone() }],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),                  // key_ptr
-				Instruction::I32Const(max_key_len as i32), // key_len
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
+		let key = Key::<T>::try_from_var(vec![0u8; max_key_len as usize])
+			.map_err(|_| "Key has wrong length")?;
+		build_runtime!(runtime, instance, memory: [ key.to_vec(), ]);
 		let info = instance.info()?;
-		info.write(
-			&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-			Some(vec![42u8; n as usize]),
-			None,
-			false,
-		)
-		.map_err(|_| "Failed to write to storage during setup.")?;
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
 
-	// We make sure that all storage accesses are to unique keys.
-	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_get_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> {
-		let max_key_len = T::MaxStorageKeyLen::get();
-		let keys = (0..r)
-			.map(|n| {
-				let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
-				h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]);
-				h
-			})
-			.collect::<Vec<_>>();
-		let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
-		let key_bytes_len = key_bytes.len();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "get_storage",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: key_bytes },
-				DataSegment {
-					offset: key_bytes_len as u32,
-					value: T::Schedule::get().limits.payload_len.to_le_bytes().into(),
-				},
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, max_key_len),                                    // key_ptr
-					Regular(Instruction::I32Const(max_key_len as i32)),         // key_len
-					Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr
-					Regular(Instruction::I32Const(key_bytes_len as i32)),       // out_len_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
-		let info = instance.info()?;
-		for key in keys {
-			info.write(
-				&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-				Some(vec![]),
-				None,
-				false,
-			)
+		info.write(&key, Some(vec![42u8; n as usize]), None, false)
 			.map_err(|_| "Failed to write to storage during setup.")?;
-		}
-		<ContractInfoOf<T>>::insert(&instance.account_id, info);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal1_clear_storage(&mut runtime, &mut memory, 0, max_key_len);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
+		assert!(info.read(&key).is_none());
 		Ok(())
 	}
 
 	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_get_storage_per_byte(
+	fn seal_get_storage(
 		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
 	) -> Result<(), BenchmarkError> {
 		let max_key_len = T::MaxStorageKeyLen::get();
-		let key = vec![0u8; max_key_len as usize];
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "get_storage",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: key.clone() },
-				DataSegment {
-					offset: max_key_len,
-					value: T::Schedule::get().limits.payload_len.to_le_bytes().into(),
-				},
-			],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),                        // key_ptr
-				Instruction::I32Const(max_key_len as i32),       // key_len
-				Instruction::I32Const((max_key_len + 4) as i32), // out_ptr
-				Instruction::I32Const(max_key_len as i32),       // out_len_ptr
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
+		let key = Key::<T>::try_from_var(vec![0u8; max_key_len as usize])
+			.map_err(|_| "Key has wrong length")?;
+		build_runtime!(runtime, instance, memory: [ key.to_vec(), n.to_le_bytes(), vec![0u8; n as _], ]);
 		let info = instance.info()?;
-		info.write(
-			&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-			Some(vec![42u8; n as usize]),
-			None,
-			false,
-		)
-		.map_err(|_| "Failed to write to storage during setup.")?;
-		<ContractInfoOf<T>>::insert(&instance.account_id, info);
 
-		let res;
+		info.write(&key, Some(vec![42u8; n as usize]), None, false)
+			.map_err(|_| "Failed to write to storage during setup.")?;
+
+		let out_ptr = max_key_len + 4;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal1_get_storage(
+				&mut runtime,
+				&mut memory,
+				0,           // key_ptr
+				max_key_len, // key_len
+				out_ptr,     // out_ptr
+				max_key_len, // out_len_ptr
+			);
 		}
-		assert_eq!(res.did_revert(), false);
 
+		assert_ok!(result);
+		assert_eq!(&info.read(&key).unwrap(), &memory[out_ptr as usize..]);
 		Ok(())
 	}
 
-	// We make sure that all storage accesses are to unique keys.
 	#[benchmark(skip_meta, pov_mode = Measured)]
 	fn seal_contains_storage(
-		r: Linear<0, { API_BENCHMARK_RUNS / 2 }>,
+		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
 	) -> Result<(), BenchmarkError> {
 		let max_key_len = T::MaxStorageKeyLen::get();
-		let keys = (0..r)
-			.map(|n| {
-				let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
-				h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]);
-				h
-			})
-			.collect::<Vec<_>>();
-		let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "contains_storage",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: key_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, max_key_len as u32),                     // key_ptr
-					Regular(Instruction::I32Const(max_key_len as i32)), // key_len
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
+		let key = Key::<T>::try_from_var(vec![0u8; max_key_len as usize])
+			.map_err(|_| "Key has wrong length")?;
+		build_runtime!(runtime, instance, memory: [ key.to_vec(), ]);
 		let info = instance.info()?;
-		for key in keys {
-			info.write(
-				&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-				Some(vec![]),
-				None,
-				false,
-			)
+
+		info.write(&key, Some(vec![42u8; n as usize]), None, false)
 			.map_err(|_| "Failed to write to storage during setup.")?;
-		}
-		<ContractInfoOf<T>>::insert(&instance.account_id, info);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal1_contains_storage(&mut runtime, &mut memory, 0, max_key_len);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_eq!(result.unwrap(), n);
 		Ok(())
 	}
 
 	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_contains_storage_per_byte(
+	fn seal_take_storage(
 		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
 	) -> Result<(), BenchmarkError> {
 		let max_key_len = T::MaxStorageKeyLen::get();
-		let key = vec![0u8; max_key_len as usize];
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "contains_storage",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: key.clone() }],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),                  // key_ptr
-				Instruction::I32Const(max_key_len as i32), // key_len
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
+		let key = Key::<T>::try_from_var(vec![0u8; max_key_len as usize])
+			.map_err(|_| "Key has wrong length")?;
+		build_runtime!(runtime, instance, memory: [ key.to_vec(), n.to_le_bytes(), vec![0u8; n as _], ]);
 		let info = instance.info()?;
-		info.write(
-			&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-			Some(vec![42u8; n as usize]),
-			None,
-			false,
-		)
-		.map_err(|_| "Failed to write to storage during setup.")?;
-		<ContractInfoOf<T>>::insert(&instance.account_id, info);
 
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
-
-	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_take_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> {
-		let max_key_len = T::MaxStorageKeyLen::get();
-		let keys = (0..r)
-			.map(|n| {
-				let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
-				h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]);
-				h
-			})
-			.collect::<Vec<_>>();
-		let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
-		let key_bytes_len = key_bytes.len();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "take_storage",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: key_bytes },
-				DataSegment {
-					offset: key_bytes_len as u32,
-					value: T::Schedule::get().limits.payload_len.to_le_bytes().into(),
-				},
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, max_key_len as u32),                             // key_ptr
-					Regular(Instruction::I32Const(max_key_len as i32)),         // key_len
-					Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr
-					Regular(Instruction::I32Const(key_bytes_len as i32)),       // out_len_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
-		let info = instance.info()?;
-		for key in keys {
-			info.write(
-				&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-				Some(vec![]),
-				None,
-				false,
-			)
+		let value = vec![42u8; n as usize];
+		info.write(&key, Some(value.clone()), None, false)
 			.map_err(|_| "Failed to write to storage during setup.")?;
-		}
-		<ContractInfoOf<T>>::insert(&instance.account_id, info);
 
-		let res;
+		let out_ptr = max_key_len + 4;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_take_storage(
+				&mut runtime,
+				&mut memory,
+				0,           // key_ptr
+				max_key_len, // key_len
+				out_ptr,     // out_ptr
+				max_key_len, // out_len_ptr
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
 
-	#[benchmark(skip_meta, pov_mode = Measured)]
-	fn seal_take_storage_per_byte(
-		n: Linear<0, { T::Schedule::get().limits.payload_len }>,
-	) -> Result<(), BenchmarkError> {
-		let max_key_len = T::MaxStorageKeyLen::get();
-		let key = vec![0u8; max_key_len as usize];
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "take_storage",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: key.clone() },
-				DataSegment {
-					offset: max_key_len,
-					value: T::Schedule::get().limits.payload_len.to_le_bytes().into(),
-				},
-			],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),                        // key_ptr
-				Instruction::I32Const(max_key_len as i32),       // key_len
-				Instruction::I32Const((max_key_len + 4) as i32), // out_ptr
-				Instruction::I32Const(max_key_len as i32),       // out_len_ptr
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		call_builder!(func, instance, code);
-		let info = instance.info()?;
-		info.write(
-			&Key::<T>::try_from_var(key).map_err(|_| "Key has wrong length")?,
-			Some(vec![42u8; n as usize]),
-			None,
-			false,
-		)
-		.map_err(|_| "Failed to write to storage during setup.")?;
-		<ContractInfoOf<T>>::insert(&instance.account_id, info);
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert!(&info.read(&key).is_none());
+		assert_eq!(&value, &memory[out_ptr as usize..]);
 		Ok(())
 	}
 
 	// We transfer to unique accounts.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_transfer(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> {
-		let accounts =
-			(0..r).map(|i| account::<T::AccountId>("receiver", i, 0)).collect::<Vec<_>>();
-		let account_len = accounts.get(0).map(|i| i.encode().len()).unwrap_or(0);
-		let account_bytes = accounts.iter().flat_map(|x| x.encode()).collect();
+	fn seal_transfer() {
+		let account = account::<T::AccountId>("receiver", 0, 0);
 		let value = Pallet::<T>::min_balance();
 		assert!(value > 0u32.into());
-		let value_bytes = value.encode();
-		let value_len = value_bytes.len();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_transfer",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: value_bytes },
-				DataSegment { offset: value_len as u32, value: account_bytes },
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(value_len as u32, account_len as u32), // account_ptr
-					Regular(Instruction::I32Const(account_len as i32)), // account_len
-					Regular(Instruction::I32Const(0)),             // value_ptr
-					Regular(Instruction::I32Const(value_len as i32)), // value_len
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
-		setup.set_balance(value * (r + 1).into());
-		call_builder!(func, setup: setup);
 
-		for account in &accounts {
-			assert_eq!(T::Currency::total_balance(account), 0u32.into());
-		}
+		let mut setup = CallSetup::<T>::default();
+		setup.set_balance(value);
+		let (mut ext, _) = setup.ext();
+		let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]);
 
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-
-		for account in &accounts {
-			assert_eq!(T::Currency::total_balance(account), value);
-		}
-		Ok(())
-	}
-
-	// We call unique accounts.
-	//
-	// This is a slow call: We reduce the number of runs.
-	#[benchmark(pov_mode = Measured)]
-	fn seal_call(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> {
-		let dummy_code = WasmModule::<T>::dummy_with_bytes(0);
-		let callees = (0..r)
-			.map(|i| Contract::with_index(i + 1, dummy_code.clone(), vec![]))
-			.collect::<Result<Vec<_>, _>>()?;
-		let callee_len = callees.get(0).map(|i| i.account_id.encode().len()).unwrap_or(0);
-		let callee_bytes = callees.iter().flat_map(|x| x.account_id.encode()).collect();
-		let value: BalanceOf<T> = 0u32.into();
+		let account_bytes = account.encode();
+		let account_len = account_bytes.len() as u32;
 		let value_bytes = value.encode();
-		let value_len = BalanceOf::<T>::max_encoded_len() as u32;
-		// Set an own limit every 2nd call
-		let own_limit = (u32::MAX - 100).into();
-		let deposits = (0..r)
-			.map(|i| if i % 2 == 0 { 0u32.into() } else { own_limit })
-			.collect::<Vec<BalanceOf<T>>>();
-		let deposits_bytes: Vec<u8> = deposits.iter().flat_map(|i| i.encode()).collect();
-		let deposits_len = deposits_bytes.len() as u32;
-		let deposit_len = value_len;
-		let callee_offset = value_len + deposits_len;
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal2",
-				name: "call",
-				params: vec![
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I64,
-					ValueType::I64,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-				],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: value_bytes },
-				DataSegment { offset: value_len, value: deposits_bytes },
-				DataSegment { offset: callee_offset, value: callee_bytes },
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Regular(Instruction::I32Const(0)),               // flags
-					Counter(callee_offset, callee_len as u32),       // callee_ptr
-					Regular(Instruction::I64Const(0)),               // ref_time weight
-					Regular(Instruction::I64Const(0)),               // proof_size weight
-					Counter(value_len, deposit_len as u32),          // deposit_limit_ptr
-					Regular(Instruction::I32Const(0)),               // value_ptr
-					Regular(Instruction::I32Const(0)),               // input_data_ptr
-					Regular(Instruction::I32Const(0)),               // input_data_len
-					Regular(Instruction::I32Const(SENTINEL as i32)), // output_ptr
-					Regular(Instruction::I32Const(0)),               // output_len_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
-		setup.set_storage_deposit_limit(BalanceOf::<T>::from(u32::MAX.into()));
-		call_builder!(func, setup: setup);
+		let value_len = value_bytes.len() as u32;
+		let mut memory = memory!(account_bytes, value_bytes,);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_transfer(
+				&mut runtime,
+				&mut memory,
+				0, // account_ptr
+				account_len,
+				account_len,
+				value_len,
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
 
-	// This is a slow call: We reduce the number of runs.
-	#[benchmark(pov_mode = Measured)]
-	fn seal_delegate_call(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> {
-		let hashes = (0..r)
-			.map(|i| {
-				let code = WasmModule::<T>::dummy_with_bytes(i);
-				let caller = whitelisted_caller();
-				T::Currency::set_balance(&caller, caller_funding::<T>());
-				Contracts::<T>::store_code_raw(code.code, caller)?;
-				Ok(code.hash)
-			})
-			.collect::<Result<Vec<_>, &'static str>>()?;
-		let hash_len = hashes.get(0).map(|x| x.encode().len()).unwrap_or(0);
-		let hashes_bytes = hashes.iter().flat_map(|x| x.encode()).collect::<Vec<_>>();
-		let hashes_offset = 0;
-
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_delegate_call",
-				params: vec![
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-				],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: hashes_offset as u32, value: hashes_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Regular(Instruction::I32Const(0)),                       // flags
-					Counter(hashes_offset as u32, hash_len as u32),          // code_hash_ptr
-					Regular(Instruction::I32Const(0)),                       // input_data_ptr
-					Regular(Instruction::I32Const(0)),                       // input_data_len
-					Regular(Instruction::I32Const(u32::max_value() as i32)), // output_ptr
-					Regular(Instruction::I32Const(0)),                       // output_len_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
+		assert_ok!(result);
 	}
 
+	// t: with or without some value to transfer
+	// i: size of the input data
 	#[benchmark(pov_mode = Measured)]
-	fn seal_call_per_transfer_clone_byte(
-		t: Linear<0, { 1 }>,
-		c: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>,
-	) -> Result<(), BenchmarkError> {
-		let callee = Contract::with_index(5, <WasmModule<T>>::dummy(), vec![])?;
+	fn seal_call(t: Linear<0, 1>, i: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
+		let Contract { account_id: callee, .. } =
+			Contract::<T>::with_index(1, WasmModule::dummy(), vec![]).unwrap();
+		let callee_bytes = callee.encode();
+		let callee_len = callee_bytes.len() as u32;
+
 		let value: BalanceOf<T> = t.into();
 		let value_bytes = value.encode();
-		let value_len = value_bytes.len();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "seal_call",
-				params: vec![
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I64,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-				],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: value_bytes },
-				DataSegment { offset: value_len as u32, value: callee.account_id.encode() },
-			],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(CallFlags::CLONE_INPUT.bits() as i32), // flags
-				Instruction::I32Const(value_len as i32),                     // callee_ptr
-				Instruction::I64Const(0),                                    // gas
-				Instruction::I32Const(0),                                    // value_ptr
-				Instruction::I32Const(0),                                    // input_data_ptr
-				Instruction::I32Const(0),                                    // input_data_len
-				Instruction::I32Const(SENTINEL as i32),                      // output_ptr
-				Instruction::I32Const(0),                                    // output_len_ptr
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
-		setup.set_data(vec![42; c as usize]);
-		call_builder!(func, setup: setup);
 
-		let res;
-		#[block]
-		{
-			res = func.call();
+		let deposit: BalanceOf<T> = (u32::MAX - 100).into();
+		let deposit_bytes = deposit.encode();
+		let deposit_len = deposit_bytes.len() as u32;
+
+		let mut setup = CallSetup::<T>::default();
+		setup.set_storage_deposit_limit(deposit);
+		setup.set_data(vec![42; i as usize]);
+		setup.set_origin(Origin::from_account_id(setup.contract().account_id.clone()));
+
+		let (mut ext, _) = setup.ext();
+		let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]);
+		let mut memory = memory!(callee_bytes, deposit_bytes, value_bytes,);
+
+		let result;
+		#[block]
+		{
+			result = BenchEnv::seal2_call(
+				&mut runtime,
+				&mut memory,
+				CallFlags::CLONE_INPUT.bits(), // flags
+				0,                             // callee_ptr
+				0,                             // ref_time_limit
+				0,                             // proof_size_limit
+				callee_len,                    // deposit_ptr
+				callee_len + deposit_len,      // value_ptr
+				0,                             // input_data_ptr
+				0,                             // input_data_len
+				SENTINEL,                      // output_ptr
+				0,                             // output_len_ptr
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
+
+		assert_ok!(result);
 	}
 
-	// We assume that every instantiate sends at least the minimum balance.
-	// This is a slow call: we reduce the number of runs.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_instantiate(r: Linear<1, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> {
-		let hashes = (0..r)
-			.map(|i| {
-				let code = WasmModule::<T>::from(ModuleDefinition {
-					memory: Some(ImportedMemory::max::<T>()),
-					call_body: Some(body::plain(vec![
-						// We need to add this in order to make contracts unique,
-						// so that they can be deployed from the same sender.
-						Instruction::I32Const(i as i32),
-						Instruction::Drop,
-						Instruction::End,
-					])),
-					..Default::default()
-				});
-				let caller = whitelisted_caller();
-				T::Currency::set_balance(&caller, caller_funding::<T>());
-				Contracts::<T>::store_code_raw(code.code, caller)?;
-				Ok(code.hash)
-			})
-			.collect::<Result<Vec<_>, &'static str>>()?;
-		let hash_len = hashes.get(0).map(|x| x.encode().len()).unwrap_or(0);
-		let hashes_bytes = hashes.iter().flat_map(|x| x.encode()).collect::<Vec<_>>();
-		let hashes_len = &hashes_bytes.len();
-		let value = Pallet::<T>::min_balance();
-		assert!(value > 0u32.into());
-		let value_bytes = value.encode();
-		let value_len = BalanceOf::<T>::max_encoded_len();
-		let addr_len = T::AccountId::max_encoded_len();
-		// Offsets where to place static data in contract memory.
-		let hashes_offset = value_len;
-		let addr_len_offset = hashes_offset + hashes_len;
-		let addr_offset = addr_len_offset + addr_len;
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal2",
-				name: "instantiate",
-				params: vec![
-					ValueType::I32,
-					ValueType::I64,
-					ValueType::I64,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-				],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: value_bytes },
-				DataSegment { offset: hashes_offset as u32, value: hashes_bytes },
-				DataSegment {
-					offset: addr_len_offset as u32,
-					value: addr_len.to_le_bytes().into(),
-				},
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(hashes_offset as u32, hash_len as u32), // code_hash_ptr
-					Regular(Instruction::I64Const(0)),              // ref_time weight
-					Regular(Instruction::I64Const(0)),              // proof_size weight
-					Regular(Instruction::I32Const(SENTINEL as i32)), /* deposit limit ptr: use
-					                                                 * parent's limit */
-					Regular(Instruction::I32Const(0)),                      // value_ptr
-					Regular(Instruction::I32Const(0)),                      // input_data_ptr
-					Regular(Instruction::I32Const(0)),                      // input_data_len
-					Regular(Instruction::I32Const(addr_offset as i32)),     // address_ptr
-					Regular(Instruction::I32Const(addr_len_offset as i32)), // address_len_ptr
-					Regular(Instruction::I32Const(SENTINEL as i32)),        // output_ptr
-					Regular(Instruction::I32Const(0)),                      // output_len_ptr
-					Regular(Instruction::I32Const(0)),                      // salt_ptr
-					Regular(Instruction::I32Const(0)),                      // salt_len_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
-		setup.set_balance((value + Pallet::<T>::min_balance()) * (r + 1).into());
-		call_builder!(func, instance, setup: setup);
-		let addresses = hashes
-			.iter()
-			.map(|hash| Contracts::<T>::contract_address(&instance.account_id, hash, &[], &[]))
-			.collect::<Vec<_>>();
-
-		for addr in &addresses {
-			if ContractInfoOf::<T>::get(&addr).is_some() {
-				return Err("Expected that contract does not exist at this point.".into());
-			}
-		}
+	fn seal_delegate_call() -> Result<(), BenchmarkError> {
+		let hash = Contract::<T>::with_index(1, WasmModule::dummy(), vec![])?.info()?.code_hash;
+
+		let mut setup = CallSetup::<T>::default();
+		setup.set_origin(Origin::from_account_id(setup.contract().account_id.clone()));
 
-		let res;
+		let (mut ext, _) = setup.ext();
+		let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]);
+		let mut memory = memory!(hash.encode(),);
+
+		let result;
 		#[block]
 		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		for addr in &addresses {
-			ContractInfoOf::<T>::get(&addr).ok_or("Contract should have been instantiated")?;
+			result = BenchEnv::seal0_delegate_call(
+				&mut runtime,
+				&mut memory,
+				0,        // flags
+				0,        // code_hash_ptr
+				0,        // input_data_ptr
+				0,        // input_data_len
+				SENTINEL, // output_ptr
+				0,
+			);
 		}
+
+		assert_ok!(result);
 		Ok(())
 	}
 
+	// t: value to transfer
+	// i: size of input in bytes
+	// s: size of salt in bytes
 	#[benchmark(pov_mode = Measured)]
-	fn seal_instantiate_per_transfer_input_salt_byte(
-		t: Linear<0, 1>,
+	fn seal_instantiate(
 		i: Linear<0, { (code::max_pages::<T>() - 1) * 64 * 1024 }>,
 		s: Linear<0, { (code::max_pages::<T>() - 1) * 64 * 1024 }>,
 	) -> Result<(), BenchmarkError> {
-		let callee_code = WasmModule::<T>::dummy();
-		let hash_bytes = callee_code.hash.encode();
-		let hash_len = hash_bytes.len();
-		let caller = whitelisted_caller();
-		T::Currency::set_balance(&caller, caller_funding::<T>());
-		Contracts::<T>::store_code_raw(callee_code.code, caller)?;
-		let value: BalanceOf<T> = t.into();
+		let hash = Contract::<T>::with_index(1, WasmModule::dummy(), vec![])?.info()?.code_hash;
+		let hash_bytes = hash.encode();
+		let hash_len = hash_bytes.len() as u32;
+
+		let value: BalanceOf<T> = 1u32.into();
 		let value_bytes = value.encode();
+		let value_len = value_bytes.len() as u32;
 
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal1",
-				name: "seal_instantiate",
-				params: vec![
-					ValueType::I32,
-					ValueType::I64,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-					ValueType::I32,
-				],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: hash_bytes },
-				DataSegment { offset: hash_len as u32, value: value_bytes },
-			],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0 as i32),        // code_hash_ptr
-				Instruction::I64Const(0),               // gas
-				Instruction::I32Const(hash_len as i32), // value_ptr
-				Instruction::I32Const(0 as i32),        // input_data_ptr
-				Instruction::I32Const(i as i32),        // input_data_len
-				Instruction::I32Const(SENTINEL as i32), // address_ptr
-				Instruction::I32Const(0),               // address_len_ptr
-				Instruction::I32Const(SENTINEL as i32), // output_ptr
-				Instruction::I32Const(0),               // output_len_ptr
-				Instruction::I32Const(0 as i32),        // salt_ptr
-				Instruction::I32Const(s as i32),        // salt_len
-				Instruction::Call(0),
-				Instruction::I32Eqz,
-				Instruction::If(BlockType::NoResult),
-				Instruction::Nop,
-				Instruction::Else,
-				Instruction::Unreachable,
-				Instruction::End,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-		let mut setup = CallSetup::<T>::new(code);
+		let deposit: BalanceOf<T> = 0u32.into();
+		let deposit_bytes = deposit.encode();
+		let deposit_len = deposit_bytes.len() as u32;
+
+		let mut setup = CallSetup::<T>::default();
+		setup.set_origin(Origin::from_account_id(setup.contract().account_id.clone()));
 		setup.set_balance(value + (Pallet::<T>::min_balance() * 2u32.into()));
-		call_builder!(func,  setup: setup);
 
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
+		let account_id = &setup.contract().account_id.clone();
+		let (mut ext, _) = setup.ext();
+		let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]);
 
-	// Only the overhead of calling the function itself with minimal arguments.
-	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_sha2_256(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_sha2_256", r, 0));
+		let input = vec![42u8; i as _];
+		let salt = vec![42u8; s as _];
+		let addr = Contracts::<T>::contract_address(&account_id, &hash, &input, &salt);
+		let mut memory = memory!(hash_bytes, deposit_bytes, value_bytes, input, salt,);
 
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-	}
-
-	// `n`: Input to hash in bytes
-	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_sha2_256_per_byte(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_sha2_256", 1, n));
-
-		let res;
-		#[block]
-		{
-			res = func.call();
+		let mut offset = {
+			let mut current = 0u32;
+			move |after: u32| {
+				current += after;
+				current
+			}
+		};
+
+		assert!(ContractInfoOf::<T>::get(&addr).is_none());
+
+		let result;
+		#[block]
+		{
+			result = BenchEnv::seal2_instantiate(
+				&mut runtime,
+				&mut memory,
+				0,                   // code_hash_ptr
+				0,                   // ref_time_limit
+				0,                   // proof_size_limit
+				offset(hash_len),    // deposit_ptr
+				offset(deposit_len), // value_ptr
+				offset(value_len),   // input_data_ptr
+				i,                   // input_data_len
+				SENTINEL,            // address_ptr
+				0,                   // address_len_ptr
+				SENTINEL,            // output_ptr
+				0,                   // output_len_ptr
+				offset(i),           // salt_ptr
+				s,                   // salt_len
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-	}
 
-	// Only the overhead of calling the function itself with minimal arguments.
-	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_keccak_256(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_keccak_256", r, 0));
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
+		assert_ok!(result);
+		assert!(ContractInfoOf::<T>::get(&addr).is_some());
+		assert_eq!(T::Currency::balance(&addr), Pallet::<T>::min_balance() + value);
+		Ok(())
 	}
 
 	// `n`: Input to hash in bytes
 	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_keccak_256_per_byte(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_keccak_256", 1, n));
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-	}
-
-	// Only the overhead of calling the function itself with minimal arguments.
-	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_blake2_256(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_blake2_256", r, 0));
+	fn seal_hash_sha2_256(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
+		build_runtime!(runtime, memory: [[0u8; 32], vec![0u8; n as usize], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_hash_sha2_256(&mut runtime, &mut memory, 32, n, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_eq!(sp_io::hashing::sha2_256(&memory[32..]), &memory[0..32]);
+		assert_ok!(result);
 	}
 
 	// `n`: Input to hash in bytes
 	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_blake2_256_per_byte(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_blake2_256", 1, n));
+	fn seal_hash_keccak_256(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
+		build_runtime!(runtime, memory: [[0u8; 32], vec![0u8; n as usize], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_hash_keccak_256(&mut runtime, &mut memory, 32, n, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_eq!(sp_io::hashing::keccak_256(&memory[32..]), &memory[0..32]);
+		assert_ok!(result);
 	}
 
-	// Only the overhead of calling the function itself with minimal arguments.
+	// `n`: Input to hash in bytes
 	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_blake2_128(r: Linear<0, API_BENCHMARK_RUNS>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_blake2_128", r, 0));
+	fn seal_hash_blake2_256(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
+		build_runtime!(runtime, memory: [[0u8; 32], vec![0u8; n as usize], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_hash_blake2_256(&mut runtime, &mut memory, 32, n, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_eq!(sp_io::hashing::blake2_256(&memory[32..]), &memory[0..32]);
+		assert_ok!(result);
 	}
 
 	// `n`: Input to hash in bytes
 	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_blake2_128_per_byte(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
-		call_builder!(func, WasmModule::hasher("seal_hash_blake2_128", 1, n));
+	fn seal_hash_blake2_128(n: Linear<0, { code::max_pages::<T>() * 64 * 1024 }>) {
+		build_runtime!(runtime, memory: [[0u8; 16], vec![0u8; n as usize], ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_hash_blake2_128(&mut runtime, &mut memory, 16, n, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+		assert_eq!(sp_io::hashing::blake2_128(&memory[16..]), &memory[0..16]);
+		assert_ok!(result);
 	}
 
 	// `n`: Message input length to verify in bytes.
 	// need some buffer so the code size does not exceed the max code size.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_sr25519_verify_per_byte(
-		n: Linear<0, { T::MaxCodeLen::get() - 255 }>,
-	) -> Result<(), BenchmarkError> {
+	fn seal_sr25519_verify(n: Linear<0, { T::MaxCodeLen::get() - 255 }>) {
 		let message = (0..n).zip((32u8..127u8).cycle()).map(|(_, c)| c).collect::<Vec<_>>();
-		let message_len = message.len() as i32;
+		let message_len = message.len() as u32;
 
 		let key_type = sp_core::crypto::KeyTypeId(*b"code");
 		let pub_key = sp_io::crypto::sr25519_generate(key_type, None);
 		let sig =
 			sp_io::crypto::sr25519_sign(key_type, &pub_key, &message).expect("Generates signature");
 		let sig = AsRef::<[u8; 64]>::as_ref(&sig).to_vec();
+		let sig_len = sig.len() as u32;
 
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "sr25519_verify",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: sig },
-				DataSegment { offset: 64, value: pub_key.to_vec() },
-				DataSegment { offset: 96, value: message },
-			],
-			call_body: Some(body::plain(vec![
-				Instruction::I32Const(0),           // signature_ptr
-				Instruction::I32Const(64),          // pub_key_ptr
-				Instruction::I32Const(message_len), // message_len
-				Instruction::I32Const(96),          // message_ptr
-				Instruction::Call(0),
-				Instruction::Drop,
-				Instruction::End,
-			])),
-			..Default::default()
-		});
-
-		call_builder!(func, code);
+		build_runtime!(runtime, memory: [sig, pub_key.to_vec(), message, ]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_sr25519_verify(
+				&mut runtime,
+				&mut memory,
+				0,                              // signature_ptr
+				sig_len,                        // pub_key_ptr
+				message_len,                    // message_len
+				sig_len + pub_key.len() as u32, // message_ptr
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
-	}
 
-	// Only calling the function itself with valid arguments.
-	// It generates different private keys and signatures for the message "Hello world".
-	// This is a slow call: We reduce the number of runs.
-	#[benchmark(pov_mode = Measured)]
-	fn seal_sr25519_verify(
-		r: Linear<0, { API_BENCHMARK_RUNS / 10 }>,
-	) -> Result<(), BenchmarkError> {
-		let message = b"Hello world".to_vec();
-		let message_len = message.len() as i32;
-		let key_type = sp_core::crypto::KeyTypeId(*b"code");
-		let sig_params = (0..r)
-			.flat_map(|_| {
-				let pub_key = sp_io::crypto::sr25519_generate(key_type, None);
-				let sig = sp_io::crypto::sr25519_sign(key_type, &pub_key, &message)
-					.expect("Generates signature");
-				let data: [u8; 96] = [AsRef::<[u8]>::as_ref(&sig), AsRef::<[u8]>::as_ref(&pub_key)]
-					.concat()
-					.try_into()
-					.unwrap();
-				data
-			})
-			.collect::<Vec<_>>();
-		let sig_params_len = sig_params.len() as i32;
-
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "sr25519_verify",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: sig_params },
-				DataSegment { offset: sig_params_len as u32, value: message },
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, 96),                                 // signature_ptr
-					Counter(64, 96),                                // pub_key_ptr
-					Regular(Instruction::I32Const(message_len)),    // message_len
-					Regular(Instruction::I32Const(sig_params_len)), // message_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
-
-		let res;
-		#[block]
-		{
-			res = func.call();
-		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
+		assert_eq!(result.unwrap(), ReturnErrorCode::Success);
 	}
 
-	// Only calling the function itself with valid arguments.
-	// It generates different private keys and signatures for the message "Hello world".
-	// This is a slow call: We reduce the number of runs.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_ecdsa_recover(r: Linear<0, { API_BENCHMARK_RUNS / 10 }>) -> Result<(), BenchmarkError> {
+	fn seal_ecdsa_recover() {
 		let message_hash = sp_io::hashing::blake2_256("Hello world".as_bytes());
 		let key_type = sp_core::crypto::KeyTypeId(*b"code");
-		let signatures = (0..r)
-			.map(|_| {
-				let pub_key = sp_io::crypto::ecdsa_generate(key_type, None);
-				let sig = sp_io::crypto::ecdsa_sign_prehashed(key_type, &pub_key, &message_hash)
-					.expect("Generates signature");
-				AsRef::<[u8; 65]>::as_ref(&sig).to_vec()
-			})
-			.collect::<Vec<_>>();
-		let signatures = signatures.iter().flatten().cloned().collect::<Vec<_>>();
-		let signatures_bytes_len = signatures.len() as i32;
-
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_ecdsa_recover",
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![
-				DataSegment { offset: 0, value: message_hash[..].to_vec() },
-				DataSegment { offset: 32, value: signatures },
-			],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(32, 65),                                           // signature_ptr
-					Regular(Instruction::I32Const(0)),                         // message_hash_ptr
-					Regular(Instruction::I32Const(signatures_bytes_len + 32)), // output_len_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
+		let signature = {
+			let pub_key = sp_io::crypto::ecdsa_generate(key_type, None);
+			let sig = sp_io::crypto::ecdsa_sign_prehashed(key_type, &pub_key, &message_hash)
+				.expect("Generates signature");
+			AsRef::<[u8; 65]>::as_ref(&sig).to_vec()
+		};
 
-		let res;
+		build_runtime!(runtime, memory: [signature, message_hash, [0u8; 33], ]);
+
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_ecdsa_recover(
+				&mut runtime,
+				&mut memory,
+				0,       // signature_ptr
+				65,      // message_hash_ptr
+				65 + 32, // output_ptr
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
+
+		assert_eq!(result.unwrap(), ReturnErrorCode::Success);
 	}
 
 	// Only calling the function itself for the list of
 	// generated different ECDSA keys.
 	// This is a slow call: We reduce the number of runs.
 	#[benchmark(pov_mode = Measured)]
-	fn seal_ecdsa_to_eth_address(
-		r: Linear<0, { API_BENCHMARK_RUNS / 10 }>,
-	) -> Result<(), BenchmarkError> {
+	fn seal_ecdsa_to_eth_address() {
 		let key_type = sp_core::crypto::KeyTypeId(*b"code");
-		let pub_keys_bytes = (0..r)
-			.flat_map(|_| sp_io::crypto::ecdsa_generate(key_type, None).0)
-			.collect::<Vec<_>>();
-		let pub_keys_bytes_len = pub_keys_bytes.len() as i32;
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_ecdsa_to_eth_address",
-				params: vec![ValueType::I32, ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: pub_keys_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, 33),                                     // pub_key_ptr
-					Regular(Instruction::I32Const(pub_keys_bytes_len)), // out_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
+		let pub_key_bytes = sp_io::crypto::ecdsa_generate(key_type, None).0;
+		build_runtime!(runtime, memory: [[0u8; 20], pub_key_bytes,]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_ecdsa_to_eth_address(
+				&mut runtime,
+				&mut memory,
+				20, // key_ptr
+				0,  // output_ptr
+			);
 		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
+
+		assert_ok!(result);
+		assert_eq!(&memory[..20], runtime.ext().ecdsa_to_eth_address(&pub_key_bytes).unwrap());
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_set_code_hash(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> {
-		let code_hashes = (0..r)
-			.map(|i| {
-				let new_code = WasmModule::<T>::dummy_with_bytes(i);
-				let caller = whitelisted_caller();
-				T::Currency::set_balance(&caller, caller_funding::<T>());
-				Contracts::<T>::store_code_raw(new_code.code, caller)?;
-				Ok(new_code.hash)
-			})
-			.collect::<Result<Vec<_>, &'static str>>()?;
-		let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0);
-		let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::<Vec<_>>();
-
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "seal_set_code_hash",
-				params: vec![ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: code_hashes_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, code_hash_len as u32), // code_hash_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
+	fn seal_set_code_hash() -> Result<(), BenchmarkError> {
+		let code_hash =
+			Contract::<T>::with_index(1, WasmModule::dummy(), vec![])?.info()?.code_hash;
+
+		build_runtime!(runtime, memory: [ code_hash.encode(),]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_set_code_hash(&mut runtime, &mut memory, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
 		Ok(())
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn lock_delegate_dependency(
-		r: Linear<0, { T::MaxDelegateDependencies::get() }>,
-	) -> Result<(), BenchmarkError> {
-		let code_hashes = (0..r)
-			.map(|i| {
-				let new_code = WasmModule::<T>::dummy_with_bytes(65 + i);
-				let caller = whitelisted_caller();
-				T::Currency::set_balance(&caller, caller_funding::<T>());
-				Contracts::<T>::store_code_raw(new_code.code, caller)?;
-				Ok(new_code.hash)
-			})
-			.collect::<Result<Vec<_>, &'static str>>()?;
-		let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0);
-		let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::<Vec<_>>();
-
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "lock_delegate_dependency",
-				params: vec![ValueType::I32],
-				return_type: None,
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: code_hashes_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, code_hash_len as u32), // code_hash_ptr
-					Regular(Instruction::Call(0)),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
+	fn lock_delegate_dependency() -> Result<(), BenchmarkError> {
+		let code_hash = Contract::<T>::with_index(1, WasmModule::dummy_with_bytes(1), vec![])?
+			.info()?
+			.code_hash;
 
-		let res;
+		build_runtime!(runtime, memory: [ code_hash.encode(),]);
+
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_lock_delegate_dependency(&mut runtime, &mut memory, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
 		Ok(())
 	}
 
 	#[benchmark]
-	fn unlock_delegate_dependency(
-		r: Linear<0, { T::MaxDelegateDependencies::get() }>,
-	) -> Result<(), BenchmarkError> {
-		let code_hashes = (0..r)
-			.map(|i| {
-				let new_code = WasmModule::<T>::dummy_with_bytes(65 + i);
-				let caller = whitelisted_caller();
-				T::Currency::set_balance(&caller, caller_funding::<T>());
-				Contracts::<T>::store_code_raw(new_code.code, caller)?;
-				Ok(new_code.hash)
-			})
-			.collect::<Result<Vec<_>, &'static str>>()?;
+	fn unlock_delegate_dependency() -> Result<(), BenchmarkError> {
+		let code_hash = Contract::<T>::with_index(1, WasmModule::dummy_with_bytes(1), vec![])?
+			.info()?
+			.code_hash;
 
-		let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0);
-		let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::<Vec<_>>();
-
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![
-				ImportedFunction {
-					module: "seal0",
-					name: "unlock_delegate_dependency",
-					params: vec![ValueType::I32],
-					return_type: None,
-				},
-				ImportedFunction {
-					module: "seal0",
-					name: "lock_delegate_dependency",
-					params: vec![ValueType::I32],
-					return_type: None,
-				},
-			],
-			data_segments: vec![DataSegment { offset: 0, value: code_hashes_bytes }],
-			deploy_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, code_hash_len as u32), // code_hash_ptr
-					Regular(Instruction::Call(1)),
-				],
-			)),
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, code_hash_len as u32), // code_hash_ptr
-					Regular(Instruction::Call(0)),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
+		build_runtime!(runtime, memory: [ code_hash.encode(),]);
+		BenchEnv::seal0_lock_delegate_dependency(&mut runtime, &mut memory, 0).unwrap();
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_unlock_delegate_dependency(&mut runtime, &mut memory, 0);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_ok!(result);
 		Ok(())
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_reentrance_count(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "reentrance_count",
-				params: vec![],
-				return_type: Some(ValueType::I32),
-			}],
-			call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])),
-			..Default::default()
-		});
-		let instance = Contract::<T>::new(code, vec![])?;
-		let origin = RawOrigin::Signed(instance.caller.clone());
-		#[extrinsic_call]
-		call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]);
-		Ok(())
+	fn seal_reentrance_count() {
+		build_runtime!(runtime, memory: []);
+		let result;
+		#[block]
+		{
+			result = BenchEnv::seal0_reentrance_count(&mut runtime, &mut memory)
+		}
+
+		assert_eq!(result.unwrap(), 0);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_account_reentrance_count(
-		r: Linear<0, API_BENCHMARK_RUNS>,
-	) -> Result<(), BenchmarkError> {
-		let dummy_code = WasmModule::<T>::dummy_with_bytes(0);
-		let accounts = (0..r)
-			.map(|i| Contract::with_index(i + 1, dummy_code.clone(), vec![]))
-			.collect::<Result<Vec<_>, _>>()?;
-		let account_id_len = accounts.get(0).map(|i| i.account_id.encode().len()).unwrap_or(0);
-		let account_id_bytes = accounts.iter().flat_map(|x| x.account_id.encode()).collect();
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "account_reentrance_count",
-				params: vec![ValueType::I32],
-				return_type: Some(ValueType::I32),
-			}],
-			data_segments: vec![DataSegment { offset: 0, value: account_id_bytes }],
-			call_body: Some(body::repeated_dyn(
-				r,
-				vec![
-					Counter(0, account_id_len as u32), // account_ptr
-					Regular(Instruction::Call(0)),
-					Regular(Instruction::Drop),
-				],
-			)),
-			..Default::default()
-		});
-		call_builder!(func, code);
+	fn seal_account_reentrance_count() {
+		let Contract { account_id, .. } =
+			Contract::<T>::with_index(1, WasmModule::dummy(), vec![]).unwrap();
+		build_runtime!(runtime, memory: [account_id.encode(),]);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_account_reentrance_count(&mut runtime, &mut memory, 0);
 		}
-		assert_eq!(res.did_revert(), false);
-		Ok(())
+
+		assert_eq!(result.unwrap(), 0);
 	}
 
 	#[benchmark(pov_mode = Measured)]
-	fn seal_instantiation_nonce(r: Linear<0, API_BENCHMARK_RUNS>) {
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "instantiation_nonce",
-				params: vec![],
-				return_type: Some(ValueType::I64),
-			}],
-			call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])),
-			..Default::default()
-		});
-		call_builder!(func, code);
+	fn seal_instantiation_nonce() {
+		build_runtime!(runtime, memory: []);
 
-		let res;
+		let result;
 		#[block]
 		{
-			res = func.call();
+			result = BenchEnv::seal0_instantiation_nonce(&mut runtime, &mut memory);
 		}
-		assert_eq!(res.did_revert(), false);
+
+		assert_eq!(result.unwrap(), 1);
 	}
 
 	// We load `i64` values from random linear memory locations and store the loaded
diff --git a/substrate/frame/contracts/src/benchmarking/sandbox.rs b/substrate/frame/contracts/src/benchmarking/sandbox.rs
index 308bf6873e49f9da09cbda151a0409cdcc2da08e..1bcf0c401f41e3c0d0f38eac6cf4dcfbbf7fdde1 100644
--- a/substrate/frame/contracts/src/benchmarking/sandbox.rs
+++ b/substrate/frame/contracts/src/benchmarking/sandbox.rs
@@ -24,7 +24,7 @@ use crate::wasm::{
 	LoadingMode, WasmBlob,
 };
 use sp_core::Get;
-use wasmi::{errors::LinkerError, Func, Linker, StackLimits, Store};
+use wasmi::{errors::LinkerError, CompilationMode, Func, Linker, StackLimits, Store};
 
 /// Minimal execution environment without any imported functions.
 pub struct Sandbox {
@@ -48,6 +48,7 @@ impl<T: Config> From<&WasmModule<T>> for Sandbox {
 			Determinism::Relaxed,
 			Some(StackLimits::default()),
 			LoadingMode::Checked,
+			CompilationMode::Eager,
 		)
 		.expect("Failed to load Wasm module");
 
@@ -62,7 +63,7 @@ impl<T: Config> From<&WasmModule<T>> for Sandbox {
 
 		// Set fuel for wasmi execution.
 		store
-			.add_fuel(u64::MAX)
+			.set_fuel(u64::MAX)
 			.expect("We've set up engine to fuel consuming mode; qed");
 
 		let entry_point = instance
diff --git a/substrate/frame/contracts/src/chain_extension.rs b/substrate/frame/contracts/src/chain_extension.rs
index 8a7243d6bb371192a92cd7e7b51b868728f7ee67..f3a67fcb09a086cd44a890e749ca6f209a47db80 100644
--- a/substrate/frame/contracts/src/chain_extension.rs
+++ b/substrate/frame/contracts/src/chain_extension.rs
@@ -112,6 +112,12 @@ pub trait ChainExtension<C: Config> {
 	/// In case of `Err` the contract execution is immediately suspended and the passed error
 	/// is returned to the caller. Otherwise the value of [`RetVal`] determines the exit
 	/// behaviour.
+	///
+	/// # Note
+	///
+	/// The [`Self::call`] can be invoked within a read-only context, where any state-changing calls
+	/// are disallowed. This information can be obtained using `env.ext().is_read_only()`. It is
+	/// crucial for the implementer to handle this scenario appropriately.
 	fn call<E: Ext<T = C>>(&mut self, env: Environment<E, InitState>) -> Result<RetVal>;
 
 	/// Determines whether chain extensions are enabled for this chain.
diff --git a/substrate/frame/contracts/src/exec.rs b/substrate/frame/contracts/src/exec.rs
index 21ebb1e8c5f3afa4bc0ff15750bb585ad72d9922..84a3f7dc2a1405626011fb1b4127ab834088e09c 100644
--- a/substrate/frame/contracts/src/exec.rs
+++ b/substrate/frame/contracts/src/exec.rs
@@ -149,6 +149,7 @@ pub trait Ext: sealing::Sealed {
 		value: BalanceOf<Self::T>,
 		input_data: Vec<u8>,
 		allows_reentry: bool,
+		read_only: bool,
 	) -> Result<ExecReturnValue, ExecError>;
 
 	/// Execute code in the current frame.
@@ -182,7 +183,7 @@ pub trait Ext: sealing::Sealed {
 	///
 	/// This function will fail if the same contract is present on the contract
 	/// call stack.
-	fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> Result<(), DispatchError>;
+	fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> DispatchResult;
 
 	/// Transfer some amount of funds into the specified account.
 	fn transfer(&mut self, to: &AccountIdOf<Self::T>, value: BalanceOf<Self::T>) -> DispatchResult;
@@ -303,11 +304,11 @@ pub trait Ext: sealing::Sealed {
 	fn ecdsa_to_eth_address(&self, pk: &[u8; 33]) -> Result<[u8; 20], ()>;
 
 	/// Tests sometimes need to modify and inspect the contract info directly.
-	#[cfg(test)]
+	#[cfg(any(test, feature = "runtime-benchmarks"))]
 	fn contract_info(&mut self) -> &mut ContractInfo<Self::T>;
 
 	/// Sets new code hash for existing contract.
-	fn set_code_hash(&mut self, hash: CodeHash<Self::T>) -> Result<(), DispatchError>;
+	fn set_code_hash(&mut self, hash: CodeHash<Self::T>) -> DispatchResult;
 
 	/// Returns the number of times the currently executing contract exists on the call stack in
 	/// addition to the calling instance. A value of 0 means no reentrancy.
@@ -327,7 +328,7 @@ pub trait Ext: sealing::Sealed {
 	///
 	/// [`Error::CodeNotFound`] is returned if no stored code found having the specified
 	/// `code_hash`.
-	fn increment_refcount(code_hash: CodeHash<Self::T>) -> Result<(), DispatchError>;
+	fn increment_refcount(code_hash: CodeHash<Self::T>) -> DispatchResult;
 
 	/// Decrement the reference count of a stored code by one.
 	///
@@ -345,13 +346,10 @@ pub trait Ext: sealing::Sealed {
 	///
 	/// # Errors
 	///
-	/// - [`Error::<T>::MaxDelegateDependenciesReached`]
-	/// - [`Error::<T>::CannotAddSelfAsDelegateDependency`]
-	/// - [`Error::<T>::DelegateDependencyAlreadyExists`]
-	fn lock_delegate_dependency(
-		&mut self,
-		code_hash: CodeHash<Self::T>,
-	) -> Result<(), DispatchError>;
+	/// - [`Error::MaxDelegateDependenciesReached`]
+	/// - [`Error::CannotAddSelfAsDelegateDependency`]
+	/// - [`Error::DelegateDependencyAlreadyExists`]
+	fn lock_delegate_dependency(&mut self, code_hash: CodeHash<Self::T>) -> DispatchResult;
 
 	/// Removes a delegate dependency from [`ContractInfo`]'s `delegate_dependencies` field.
 	///
@@ -360,11 +358,16 @@ pub trait Ext: sealing::Sealed {
 	///
 	/// # Errors
 	///
-	/// - [`Error::<T>::DelegateDependencyNotFound`]
-	fn unlock_delegate_dependency(
-		&mut self,
-		code_hash: &CodeHash<Self::T>,
-	) -> Result<(), DispatchError>;
+	/// - [`Error::DelegateDependencyNotFound`]
+	fn unlock_delegate_dependency(&mut self, code_hash: &CodeHash<Self::T>) -> DispatchResult;
+
+	/// Returns the number of locked delegate dependencies.
+	///
+	/// Note: Requires &mut self to access the contract info.
+	fn locked_delegate_dependencies_count(&mut self) -> usize;
+
+	/// Check if running in read-only context.
+	fn is_read_only(&self) -> bool;
 }
 
 /// Describes the different functions that can be exported by an [`Executable`].
@@ -498,6 +501,8 @@ pub struct Frame<T: Config> {
 	nested_storage: storage::meter::NestedMeter<T>,
 	/// If `false` the contract enabled its defense against reentrance attacks.
 	allows_reentry: bool,
+	/// If `true` subsequent calls cannot modify storage.
+	read_only: bool,
 	/// The caller of the currently executing frame which was spawned by `delegate_call`.
 	delegate_caller: Option<Origin<T>>,
 }
@@ -776,6 +781,7 @@ where
 			storage_meter,
 			BalanceOf::<T>::zero(),
 			determinism,
+			false,
 		)?;
 
 		let stack = Self {
@@ -808,6 +814,7 @@ where
 		storage_meter: &mut storage::meter::GenericMeter<T, S>,
 		deposit_limit: BalanceOf<T>,
 		determinism: Determinism,
+		read_only: bool,
 	) -> Result<(Frame<T>, E, Option<u64>), ExecError> {
 		let (account_id, contract_info, executable, delegate_caller, entry_point, nonce) =
 			match frame_args {
@@ -864,6 +871,7 @@ where
 			nested_gas: gas_meter.nested(gas_limit),
 			nested_storage: storage_meter.nested(deposit_limit),
 			allows_reentry: true,
+			read_only,
 		};
 
 		Ok((frame, executable, nonce))
@@ -876,6 +884,7 @@ where
 		value_transferred: BalanceOf<T>,
 		gas_limit: Weight,
 		deposit_limit: BalanceOf<T>,
+		read_only: bool,
 	) -> Result<E, ExecError> {
 		if self.frames.len() == T::CallStack::size() {
 			return Err(Error::<T>::MaxCallDepthReached.into())
@@ -903,6 +912,7 @@ where
 			nested_storage,
 			deposit_limit,
 			self.determinism,
+			read_only,
 		)?;
 		self.frames.push(frame);
 		Ok(executable)
@@ -1217,6 +1227,7 @@ where
 		value: BalanceOf<T>,
 		input_data: Vec<u8>,
 		allows_reentry: bool,
+		read_only: bool,
 	) -> Result<ExecReturnValue, ExecError> {
 		// Before pushing the new frame: Protect the caller contract against reentrancy attacks.
 		// It is important to do this before calling `allows_reentry` so that a direct recursion
@@ -1227,6 +1238,7 @@ where
 			if !self.allows_reentry(&to) {
 				return Err(<Error<T>>::ReentranceDenied.into())
 			}
+
 			// We ignore instantiate frames in our search for a cached contract.
 			// Otherwise it would be possible to recursively call a contract from its own
 			// constructor: We disallow calling not fully constructed contracts.
@@ -1242,6 +1254,8 @@ where
 				value,
 				gas_limit,
 				deposit_limit,
+				// Enable read-only access if requested; cannot disable it if already set.
+				read_only || self.is_read_only(),
 			)?;
 			self.run(executable, input_data)
 		};
@@ -1274,6 +1288,7 @@ where
 			value,
 			Weight::zero(),
 			BalanceOf::<T>::zero(),
+			self.is_read_only(),
 		)?;
 		self.run(executable, input_data)
 	}
@@ -1300,12 +1315,13 @@ where
 			value,
 			gas_limit,
 			deposit_limit,
+			self.is_read_only(),
 		)?;
 		let account_id = self.top_frame().account_id.clone();
 		self.run(executable, input_data).map(|ret| (account_id, ret))
 	}
 
-	fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> Result<(), DispatchError> {
+	fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> DispatchResult {
 		if self.is_recursive() {
 			return Err(Error::<T>::TerminatedWhileReentrant.into())
 		}
@@ -1497,12 +1513,12 @@ where
 		ECDSAPublic::from(*pk).to_eth_address()
 	}
 
-	#[cfg(test)]
+	#[cfg(any(test, feature = "runtime-benchmarks"))]
 	fn contract_info(&mut self) -> &mut ContractInfo<Self::T> {
 		self.top_frame_mut().contract_info()
 	}
 
-	fn set_code_hash(&mut self, hash: CodeHash<Self::T>) -> Result<(), DispatchError> {
+	fn set_code_hash(&mut self, hash: CodeHash<Self::T>) -> DispatchResult {
 		let frame = top_frame_mut!(self);
 		if !E::from_storage(hash, &mut frame.nested_gas)?.is_deterministic() {
 			return Err(<Error<T>>::Indeterministic.into())
@@ -1553,7 +1569,7 @@ where
 		}
 	}
 
-	fn increment_refcount(code_hash: CodeHash<Self::T>) -> Result<(), DispatchError> {
+	fn increment_refcount(code_hash: CodeHash<Self::T>) -> DispatchResult {
 		<CodeInfoOf<Self::T>>::mutate(code_hash, |existing| -> Result<(), DispatchError> {
 			if let Some(info) = existing {
 				*info.refcount_mut() = info.refcount().saturating_add(1);
@@ -1572,10 +1588,7 @@ where
 		});
 	}
 
-	fn lock_delegate_dependency(
-		&mut self,
-		code_hash: CodeHash<Self::T>,
-	) -> Result<(), DispatchError> {
+	fn lock_delegate_dependency(&mut self, code_hash: CodeHash<Self::T>) -> DispatchResult {
 		let frame = self.top_frame_mut();
 		let info = frame.contract_info.get(&frame.account_id);
 		ensure!(code_hash != info.code_hash, Error::<T>::CannotAddSelfAsDelegateDependency);
@@ -1591,10 +1604,7 @@ where
 		Ok(())
 	}
 
-	fn unlock_delegate_dependency(
-		&mut self,
-		code_hash: &CodeHash<Self::T>,
-	) -> Result<(), DispatchError> {
+	fn unlock_delegate_dependency(&mut self, code_hash: &CodeHash<Self::T>) -> DispatchResult {
 		let frame = self.top_frame_mut();
 		let info = frame.contract_info.get(&frame.account_id);
 
@@ -1605,6 +1615,14 @@ where
 			.charge_deposit(frame.account_id.clone(), StorageDeposit::Refund(deposit));
 		Ok(())
 	}
+
+	fn locked_delegate_dependencies_count(&mut self) -> usize {
+		self.top_frame_mut().contract_info().delegate_dependencies_count()
+	}
+
+	fn is_read_only(&self) -> bool {
+		self.top_frame().read_only
+	}
 }
 
 mod sealing {
@@ -2116,7 +2134,15 @@ mod tests {
 		let value = Default::default();
 		let recurse_ch = MockLoader::insert(Call, |ctx, _| {
 			// Try to call into yourself.
-			let r = ctx.ext.call(Weight::zero(), BalanceOf::<Test>::zero(), BOB, 0, vec![], true);
+			let r = ctx.ext.call(
+				Weight::zero(),
+				BalanceOf::<Test>::zero(),
+				BOB,
+				0,
+				vec![],
+				true,
+				false,
+			);
 
 			ReachedBottom::mutate(|reached_bottom| {
 				if !*reached_bottom {
@@ -2175,8 +2201,15 @@ mod tests {
 
 			// Call into CHARLIE contract.
 			assert_matches!(
-				ctx.ext
-					.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true),
+				ctx.ext.call(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					CHARLIE,
+					0,
+					vec![],
+					true,
+					false
+				),
 				Ok(_)
 			);
 			exec_success()
@@ -2323,7 +2356,7 @@ mod tests {
 			assert!(ctx.ext.caller_is_origin());
 			// BOB calls CHARLIE
 			ctx.ext
-				.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true)
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true, false)
 		});
 
 		ExtBuilder::default().build().execute_with(|| {
@@ -2422,7 +2455,7 @@ mod tests {
 			assert!(ctx.ext.caller_is_root());
 			// BOB calls CHARLIE.
 			ctx.ext
-				.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true)
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true, false)
 		});
 
 		ExtBuilder::default().build().execute_with(|| {
@@ -2456,8 +2489,15 @@ mod tests {
 
 			// Call into charlie contract.
 			assert_matches!(
-				ctx.ext
-					.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true),
+				ctx.ext.call(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					CHARLIE,
+					0,
+					vec![],
+					true,
+					false
+				),
 				Ok(_)
 			);
 			exec_success()
@@ -2825,7 +2865,8 @@ mod tests {
 						CHARLIE,
 						0,
 						vec![],
-						true
+						true,
+						false
 					),
 					exec_trapped()
 				);
@@ -2836,7 +2877,7 @@ mod tests {
 		let code_charlie = MockLoader::insert(Call, |ctx, _| {
 			assert!(ctx
 				.ext
-				.call(Weight::zero(), BalanceOf::<Test>::zero(), BOB, 0, vec![99], true)
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), BOB, 0, vec![99], true, false)
 				.is_ok());
 			exec_trapped()
 		});
@@ -2869,7 +2910,7 @@ mod tests {
 	fn recursive_call_during_constructor_fails() {
 		let code = MockLoader::insert(Constructor, |ctx, _| {
 			assert_matches!(
-				ctx.ext.call(Weight::zero(), BalanceOf::<Test>::zero(), ctx.ext.address().clone(), 0, vec![], true),
+				ctx.ext.call(Weight::zero(), BalanceOf::<Test>::zero(), ctx.ext.address().clone(), 0, vec![], true, false),
 				Err(ExecError{error, ..}) if error == <Error<Test>>::ContractNotFound.into()
 			);
 			exec_success()
@@ -3019,7 +3060,8 @@ mod tests {
 		// call the contract passed as input with disabled reentry
 		let code_bob = MockLoader::insert(Call, |ctx, _| {
 			let dest = Decode::decode(&mut ctx.input_data.as_ref()).unwrap();
-			ctx.ext.call(Weight::zero(), BalanceOf::<Test>::zero(), dest, 0, vec![], false)
+			ctx.ext
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), dest, 0, vec![], false, false)
 		});
 
 		let code_charlie = MockLoader::insert(Call, |_, _| exec_success());
@@ -3068,8 +3110,15 @@ mod tests {
 	fn call_deny_reentry() {
 		let code_bob = MockLoader::insert(Call, |ctx, _| {
 			if ctx.input_data[0] == 0 {
-				ctx.ext
-					.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], false)
+				ctx.ext.call(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					CHARLIE,
+					0,
+					vec![],
+					false,
+					false,
+				)
 			} else {
 				exec_success()
 			}
@@ -3077,7 +3126,8 @@ mod tests {
 
 		// call BOB with input set to '1'
 		let code_charlie = MockLoader::insert(Call, |ctx, _| {
-			ctx.ext.call(Weight::zero(), BalanceOf::<Test>::zero(), BOB, 0, vec![1], true)
+			ctx.ext
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), BOB, 0, vec![1], true, false)
 		});
 
 		ExtBuilder::default().build().execute_with(|| {
@@ -3297,7 +3347,15 @@ mod tests {
 
 			// a plain call should not influence the account counter
 			ctx.ext
-				.call(Weight::zero(), BalanceOf::<Test>::zero(), account_id, 0, vec![], false)
+				.call(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					account_id,
+					0,
+					vec![],
+					false,
+					false,
+				)
 				.unwrap();
 
 			exec_success()
diff --git a/substrate/frame/contracts/src/gas.rs b/substrate/frame/contracts/src/gas.rs
index 32fad2140f1463b454a3b8df1cb49b53e79e0c7b..f8c97e251f3dd708c9a06a0a913d56c7d94020c0 100644
--- a/substrate/frame/contracts/src/gas.rs
+++ b/substrate/frame/contracts/src/gas.rs
@@ -23,7 +23,7 @@ use frame_support::{
 	DefaultNoBound,
 };
 use sp_core::Get;
-use sp_runtime::{traits::Zero, DispatchError, Saturating};
+use sp_runtime::{traits::Zero, DispatchError};
 
 #[cfg(test)]
 use std::{any::Any, fmt::Debug};
@@ -37,6 +37,45 @@ impl ChargedAmount {
 	}
 }
 
+/// Meter for syncing the gas between the executor and the gas meter.
+#[derive(DefaultNoBound)]
+struct EngineMeter<T: Config> {
+	fuel: u64,
+	_phantom: PhantomData<T>,
+}
+
+impl<T: Config> EngineMeter<T> {
+	/// Create a meter with the given fuel limit.
+	fn new(limit: Weight) -> Self {
+		Self {
+			fuel: limit.ref_time().saturating_div(T::Schedule::get().ref_time_by_fuel()),
+			_phantom: PhantomData,
+		}
+	}
+
+	/// Set the fuel left to the given value.
+	/// Returns the amount of Weight consumed since the last update.
+	fn set_fuel(&mut self, fuel: u64) -> Weight {
+		let consumed = self
+			.fuel
+			.saturating_sub(fuel)
+			.saturating_mul(T::Schedule::get().ref_time_by_fuel());
+		self.fuel = fuel;
+		Weight::from_parts(consumed, 0)
+	}
+
+	/// Charge the given amount of gas.
+	/// Returns the amount of fuel left.
+	fn charge_ref_time(&mut self, ref_time: u64) -> Result<Syncable, DispatchError> {
+		let amount = ref_time
+			.checked_div(T::Schedule::get().ref_time_by_fuel())
+			.ok_or(Error::<T>::InvalidSchedule)?;
+
+		self.fuel.checked_sub(amount).ok_or_else(|| Error::<T>::OutOfGas)?;
+		Ok(Syncable(self.fuel))
+	}
+}
+
 /// Used to capture the gas left before entering a host function.
 ///
 /// Has to be consumed in order to sync back the gas after leaving the host function.
@@ -103,12 +142,9 @@ pub struct GasMeter<T: Config> {
 	/// Due to `adjust_gas` and `nested` the `gas_left` can temporarily dip below its final value.
 	gas_left_lowest: Weight,
 	/// The amount of resources that was consumed by the execution engine.
-	///
-	/// This should be equivalent to `self.gas_consumed().ref_time()` but expressed in whatever
-	/// unit the execution engine uses to track resource consumption. We have to track it
-	/// separately in order to avoid the loss of precision that happens when converting from
-	/// ref_time to the execution engine unit.
-	executor_consumed: u64,
+	/// We have to track it separately in order to avoid the loss of precision that happens when
+	/// converting from ref_time to the execution engine unit.
+	engine_meter: EngineMeter<T>,
 	_phantom: PhantomData<T>,
 	#[cfg(test)]
 	tokens: Vec<ErasedToken>,
@@ -120,7 +156,7 @@ impl<T: Config> GasMeter<T> {
 			gas_limit,
 			gas_left: gas_limit,
 			gas_left_lowest: gas_limit,
-			executor_consumed: 0,
+			engine_meter: EngineMeter::new(gas_limit),
 			_phantom: PhantomData,
 			#[cfg(test)]
 			tokens: Vec::new(),
@@ -200,16 +236,10 @@ impl<T: Config> GasMeter<T> {
 	/// Needs to be called when entering a host function to update this meter with the
 	/// gas that was tracked by the executor. It tracks the latest seen total value
 	/// in order to compute the delta that needs to be charged.
-	pub fn sync_from_executor(
-		&mut self,
-		executor_total: u64,
-	) -> Result<RefTimeLeft, DispatchError> {
-		let chargable_reftime = executor_total
-			.saturating_sub(self.executor_consumed)
-			.saturating_mul(u64::from(T::Schedule::get().instruction_weights.base));
-		self.executor_consumed = executor_total;
+	pub fn sync_from_executor(&mut self, engine_fuel: u64) -> Result<RefTimeLeft, DispatchError> {
+		let weight_consumed = self.engine_meter.set_fuel(engine_fuel);
 		self.gas_left
-			.checked_reduce(Weight::from_parts(chargable_reftime, 0))
+			.checked_reduce(weight_consumed)
 			.ok_or_else(|| Error::<T>::OutOfGas)?;
 		Ok(RefTimeLeft(self.gas_left.ref_time()))
 	}
@@ -223,13 +253,8 @@ impl<T: Config> GasMeter<T> {
 	/// It is important that this does **not** actually sync with the executor. That has
 	/// to be done by the caller.
 	pub fn sync_to_executor(&mut self, before: RefTimeLeft) -> Result<Syncable, DispatchError> {
-		let chargable_executor_resource = before
-			.0
-			.saturating_sub(self.gas_left().ref_time())
-			.checked_div(u64::from(T::Schedule::get().instruction_weights.base))
-			.ok_or(Error::<T>::InvalidSchedule)?;
-		self.executor_consumed.saturating_accrue(chargable_executor_resource);
-		Ok(Syncable(chargable_executor_resource))
+		let ref_time_consumed = before.0.saturating_sub(self.gas_left().ref_time());
+		self.engine_meter.charge_ref_time(ref_time_consumed)
 	}
 
 	/// Returns the amount of gas that is required to run the same call.
diff --git a/substrate/frame/contracts/src/lib.rs b/substrate/frame/contracts/src/lib.rs
index d20f3c15fb5663d32edb8a5e4c746cced008c1e8..47772e0a5a0bc34ff3662cdb1bc5211b44032e40 100644
--- a/substrate/frame/contracts/src/lib.rs
+++ b/substrate/frame/contracts/src/lib.rs
@@ -146,7 +146,7 @@ pub use crate::{
 	exec::Frame,
 	migration::{MigrateSequence, Migration, NoopMigration},
 	pallet::*,
-	schedule::{HostFnWeights, InstructionWeights, Limits, Schedule},
+	schedule::{InstructionWeights, Limits, Schedule},
 	wasm::Determinism,
 };
 pub use weights::WeightInfo;
@@ -223,7 +223,7 @@ pub struct Environment<T: Config> {
 pub struct ApiVersion(u16);
 impl Default for ApiVersion {
 	fn default() -> Self {
-		Self(3)
+		Self(4)
 	}
 }
 
@@ -529,7 +529,7 @@ pub mod pallet {
 			}
 		}
 
-		#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig, no_aggregated_types)]
+		#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]
 		impl frame_system::DefaultConfig for TestDefaultConfig {}
 
 		#[frame_support::register_default_impl(TestDefaultConfig)]
@@ -1199,6 +1199,8 @@ pub mod pallet {
 		/// into `pallet-contracts`. This would make the whole pallet reentrant with regard to
 		/// contract code execution which is not supported.
 		ReentranceDenied,
+		/// A contract attempted to invoke a state modifying API while being in read-only mode.
+		StateChangeDenied,
 		/// Origin doesn't have enough balance to pay the required storage deposits.
 		StorageDepositNotEnoughFunds,
 		/// More storage was created than allowed by the storage deposit limit.
diff --git a/substrate/frame/contracts/src/schedule.rs b/substrate/frame/contracts/src/schedule.rs
index 06a7c2005aa5e46e814d6eff192775ca63881fae..60c9520677eb35faca50f62a9379228fc5c3caf4 100644
--- a/substrate/frame/contracts/src/schedule.rs
+++ b/substrate/frame/contracts/src/schedule.rs
@@ -22,7 +22,7 @@ use crate::{weights::WeightInfo, Config};
 
 use codec::{Decode, Encode};
 use core::marker::PhantomData;
-use frame_support::{weights::Weight, DefaultNoBound};
+use frame_support::DefaultNoBound;
 use scale_info::TypeInfo;
 #[cfg(feature = "std")]
 use serde::{Deserialize, Serialize};
@@ -60,9 +60,13 @@ pub struct Schedule<T: Config> {
 
 	/// The weights for individual wasm instructions.
 	pub instruction_weights: InstructionWeights<T>,
+}
 
-	/// The weights for each imported function a contract is allowed to call.
-	pub host_fn_weights: HostFnWeights<T>,
+impl<T: Config> Schedule<T> {
+	/// Returns the reference time per engine fuel.
+	pub fn ref_time_by_fuel(&self) -> u64 {
+		self.instruction_weights.base as u64
+	}
 }
 
 /// Describes the upper limits on various metrics.
@@ -109,230 +113,6 @@ pub struct InstructionWeights<T: Config> {
 	pub _phantom: PhantomData<T>,
 }
 
-/// Describes the weight for each imported function that a contract is allowed to call.
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "runtime-benchmarks", derive(pallet_contracts_proc_macro::WeightDebug))]
-#[derive(Clone, Encode, Decode, PartialEq, Eq, TypeInfo)]
-#[scale_info(skip_type_params(T))]
-pub struct HostFnWeights<T: Config> {
-	/// Weight of calling `seal_caller`.
-	pub caller: Weight,
-
-	/// Weight of calling `seal_is_contract`.
-	pub is_contract: Weight,
-
-	/// Weight of calling `seal_code_hash`.
-	pub code_hash: Weight,
-
-	/// Weight of calling `seal_own_code_hash`.
-	pub own_code_hash: Weight,
-
-	/// Weight of calling `seal_caller_is_origin`.
-	pub caller_is_origin: Weight,
-
-	/// Weight of calling `seal_caller_is_root`.
-	pub caller_is_root: Weight,
-
-	/// Weight of calling `seal_address`.
-	pub address: Weight,
-
-	/// Weight of calling `seal_gas_left`.
-	pub gas_left: Weight,
-
-	/// Weight of calling `seal_balance`.
-	pub balance: Weight,
-
-	/// Weight of calling `seal_value_transferred`.
-	pub value_transferred: Weight,
-
-	/// Weight of calling `seal_minimum_balance`.
-	pub minimum_balance: Weight,
-
-	/// Weight of calling `seal_block_number`.
-	pub block_number: Weight,
-
-	/// Weight of calling `seal_now`.
-	pub now: Weight,
-
-	/// Weight of calling `seal_weight_to_fee`.
-	pub weight_to_fee: Weight,
-
-	/// Weight of calling `seal_input`.
-	pub input: Weight,
-
-	/// Weight per input byte copied to contract memory by `seal_input`.
-	pub input_per_byte: Weight,
-
-	/// Weight of calling `seal_return`.
-	pub r#return: Weight,
-
-	/// Weight per byte returned through `seal_return`.
-	pub return_per_byte: Weight,
-
-	/// Weight of calling `seal_terminate`.
-	pub terminate: Weight,
-
-	/// Weight of calling `seal_random`.
-	pub random: Weight,
-
-	/// Weight of calling `seal_reposit_event`.
-	pub deposit_event: Weight,
-
-	/// Weight per topic supplied to `seal_deposit_event`.
-	pub deposit_event_per_topic: Weight,
-
-	/// Weight per byte of an event deposited through `seal_deposit_event`.
-	pub deposit_event_per_byte: Weight,
-
-	/// Weight of calling `seal_debug_message`.
-	pub debug_message: Weight,
-
-	/// Weight of calling `seal_debug_message` per byte of the message.
-	pub debug_message_per_byte: Weight,
-
-	/// Weight of calling `seal_set_storage`.
-	pub set_storage: Weight,
-
-	/// Weight per written byte of an item stored with `seal_set_storage`.
-	pub set_storage_per_new_byte: Weight,
-
-	/// Weight per overwritten byte of an item stored with `seal_set_storage`.
-	pub set_storage_per_old_byte: Weight,
-
-	/// Weight of calling `seal_set_code_hash`.
-	pub set_code_hash: Weight,
-
-	/// Weight of calling `seal_clear_storage`.
-	pub clear_storage: Weight,
-
-	/// Weight of calling `seal_clear_storage` per byte of the stored item.
-	pub clear_storage_per_byte: Weight,
-
-	/// Weight of calling `seal_contains_storage`.
-	pub contains_storage: Weight,
-
-	/// Weight of calling `seal_contains_storage` per byte of the stored item.
-	pub contains_storage_per_byte: Weight,
-
-	/// Weight of calling `seal_get_storage`.
-	pub get_storage: Weight,
-
-	/// Weight per byte of an item received via `seal_get_storage`.
-	pub get_storage_per_byte: Weight,
-
-	/// Weight of calling `seal_take_storage`.
-	pub take_storage: Weight,
-
-	/// Weight per byte of an item received via `seal_take_storage`.
-	pub take_storage_per_byte: Weight,
-
-	/// Weight of calling `seal_transfer`.
-	pub transfer: Weight,
-
-	/// Weight of calling `seal_call`.
-	pub call: Weight,
-
-	/// Weight of calling `seal_delegate_call`.
-	pub delegate_call: Weight,
-
-	/// Weight surcharge that is claimed if `seal_call` does a balance transfer.
-	pub call_transfer_surcharge: Weight,
-
-	/// Weight per byte that is cloned by supplying the `CLONE_INPUT` flag.
-	pub call_per_cloned_byte: Weight,
-
-	/// Weight of calling `seal_instantiate`.
-	pub instantiate: Weight,
-
-	/// Weight surcharge that is claimed if `seal_instantiate` does a balance transfer.
-	pub instantiate_transfer_surcharge: Weight,
-
-	/// Weight per input byte supplied to `seal_instantiate`.
-	pub instantiate_per_input_byte: Weight,
-
-	/// Weight per salt byte supplied to `seal_instantiate`.
-	pub instantiate_per_salt_byte: Weight,
-
-	/// Weight of calling `seal_hash_sha_256`.
-	pub hash_sha2_256: Weight,
-
-	/// Weight per byte hashed by `seal_hash_sha_256`.
-	pub hash_sha2_256_per_byte: Weight,
-
-	/// Weight of calling `seal_hash_keccak_256`.
-	pub hash_keccak_256: Weight,
-
-	/// Weight per byte hashed by `seal_hash_keccak_256`.
-	pub hash_keccak_256_per_byte: Weight,
-
-	/// Weight of calling `seal_hash_blake2_256`.
-	pub hash_blake2_256: Weight,
-
-	/// Weight per byte hashed by `seal_hash_blake2_256`.
-	pub hash_blake2_256_per_byte: Weight,
-
-	/// Weight of calling `seal_hash_blake2_128`.
-	pub hash_blake2_128: Weight,
-
-	/// Weight per byte hashed by `seal_hash_blake2_128`.
-	pub hash_blake2_128_per_byte: Weight,
-
-	/// Weight of calling `seal_ecdsa_recover`.
-	pub ecdsa_recover: Weight,
-
-	/// Weight of calling `seal_ecdsa_to_eth_address`.
-	pub ecdsa_to_eth_address: Weight,
-
-	/// Weight of calling `sr25519_verify`.
-	pub sr25519_verify: Weight,
-
-	/// Weight per byte of calling `sr25519_verify`.
-	pub sr25519_verify_per_byte: Weight,
-
-	/// Weight of calling `reentrance_count`.
-	pub reentrance_count: Weight,
-
-	/// Weight of calling `account_reentrance_count`.
-	pub account_reentrance_count: Weight,
-
-	/// Weight of calling `instantiation_nonce`.
-	pub instantiation_nonce: Weight,
-
-	/// Weight of calling `lock_delegate_dependency`.
-	pub lock_delegate_dependency: Weight,
-
-	/// Weight of calling `unlock_delegate_dependency`.
-	pub unlock_delegate_dependency: Weight,
-
-	/// The type parameter is used in the default implementation.
-	#[codec(skip)]
-	pub _phantom: PhantomData<T>,
-}
-
-macro_rules! replace_token {
-	($_in:tt $replacement:tt) => {
-		$replacement
-	};
-}
-
-macro_rules! call_zero {
-	($name:ident, $( $arg:expr ),*) => {
-		T::WeightInfo::$name($( replace_token!($arg 0) ),*)
-	};
-}
-
-macro_rules! cost_args {
-	($name:ident, $( $arg: expr ),+) => {
-		(T::WeightInfo::$name($( $arg ),+).saturating_sub(call_zero!($name, $( $arg ),+)))
-	}
-}
-
-macro_rules! cost {
-	($name:ident) => {
-		cost_args!($name, 1)
-	};
-}
-
 impl Default for Limits {
 	fn default() -> Self {
 		Self {
@@ -350,94 +130,10 @@ impl<T: Config> Default for InstructionWeights<T> {
 	/// computed gas costs by 6 to have a rough estimate as to how expensive each
 	/// single executed instruction is going to be.
 	fn default() -> Self {
-		let instr_cost = cost!(instr_i64_load_store).ref_time() as u32;
+		let instr_cost = T::WeightInfo::instr_i64_load_store(1)
+			.saturating_sub(T::WeightInfo::instr_i64_load_store(0))
+			.ref_time() as u32;
 		let base = instr_cost / 6;
 		Self { base, _phantom: PhantomData }
 	}
 }
-
-impl<T: Config> Default for HostFnWeights<T> {
-	fn default() -> Self {
-		Self {
-			caller: cost!(seal_caller),
-			is_contract: cost!(seal_is_contract),
-			code_hash: cost!(seal_code_hash),
-			own_code_hash: cost!(seal_own_code_hash),
-			caller_is_origin: cost!(seal_caller_is_origin),
-			caller_is_root: cost!(seal_caller_is_root),
-			address: cost!(seal_address),
-			gas_left: cost!(seal_gas_left),
-			balance: cost!(seal_balance),
-			value_transferred: cost!(seal_value_transferred),
-			minimum_balance: cost!(seal_minimum_balance),
-			block_number: cost!(seal_block_number),
-			now: cost!(seal_now),
-			weight_to_fee: cost!(seal_weight_to_fee),
-			input: cost!(seal_input),
-			input_per_byte: cost!(seal_input_per_byte),
-			r#return: cost!(seal_return),
-			return_per_byte: cost!(seal_return_per_byte),
-			terminate: cost!(seal_terminate),
-			random: cost!(seal_random),
-			deposit_event: cost!(seal_deposit_event),
-			deposit_event_per_topic: cost_args!(seal_deposit_event_per_topic_and_byte, 1, 0),
-			deposit_event_per_byte: cost_args!(seal_deposit_event_per_topic_and_byte, 0, 1),
-			debug_message: cost!(seal_debug_message),
-			debug_message_per_byte: cost!(seal_debug_message_per_byte),
-			set_storage: cost!(seal_set_storage),
-			set_code_hash: cost!(seal_set_code_hash),
-			set_storage_per_new_byte: cost!(seal_set_storage_per_new_byte),
-			set_storage_per_old_byte: cost!(seal_set_storage_per_old_byte),
-			clear_storage: cost!(seal_clear_storage),
-			clear_storage_per_byte: cost!(seal_clear_storage_per_byte),
-			contains_storage: cost!(seal_contains_storage),
-			contains_storage_per_byte: cost!(seal_contains_storage_per_byte),
-			get_storage: cost!(seal_get_storage),
-			get_storage_per_byte: cost!(seal_get_storage_per_byte),
-			take_storage: cost!(seal_take_storage),
-			take_storage_per_byte: cost!(seal_take_storage_per_byte),
-			transfer: cost!(seal_transfer),
-			call: cost!(seal_call),
-			delegate_call: cost!(seal_delegate_call),
-			call_transfer_surcharge: cost_args!(seal_call_per_transfer_clone_byte, 1, 0),
-			call_per_cloned_byte: cost_args!(seal_call_per_transfer_clone_byte, 0, 1),
-			instantiate: cost!(seal_instantiate),
-			instantiate_transfer_surcharge: cost_args!(
-				seal_instantiate_per_transfer_input_salt_byte,
-				1,
-				0,
-				0
-			),
-			instantiate_per_input_byte: cost_args!(
-				seal_instantiate_per_transfer_input_salt_byte,
-				0,
-				1,
-				0
-			),
-			instantiate_per_salt_byte: cost_args!(
-				seal_instantiate_per_transfer_input_salt_byte,
-				0,
-				0,
-				1
-			),
-			hash_sha2_256: cost!(seal_hash_sha2_256),
-			hash_sha2_256_per_byte: cost!(seal_hash_sha2_256_per_byte),
-			hash_keccak_256: cost!(seal_hash_keccak_256),
-			hash_keccak_256_per_byte: cost!(seal_hash_keccak_256_per_byte),
-			hash_blake2_256: cost!(seal_hash_blake2_256),
-			hash_blake2_256_per_byte: cost!(seal_hash_blake2_256_per_byte),
-			hash_blake2_128: cost!(seal_hash_blake2_128),
-			hash_blake2_128_per_byte: cost!(seal_hash_blake2_128_per_byte),
-			ecdsa_recover: cost!(seal_ecdsa_recover),
-			sr25519_verify: cost!(seal_sr25519_verify),
-			sr25519_verify_per_byte: cost!(seal_sr25519_verify_per_byte),
-			ecdsa_to_eth_address: cost!(seal_ecdsa_to_eth_address),
-			reentrance_count: cost!(seal_reentrance_count),
-			account_reentrance_count: cost!(seal_account_reentrance_count),
-			instantiation_nonce: cost!(seal_instantiation_nonce),
-			lock_delegate_dependency: cost!(lock_delegate_dependency),
-			unlock_delegate_dependency: cost!(unlock_delegate_dependency),
-			_phantom: PhantomData,
-		}
-	}
-}
diff --git a/substrate/frame/contracts/src/tests.rs b/substrate/frame/contracts/src/tests.rs
index 251c037d317d59767c75e3a3e04c2dacf346e90c..c20577a3f6458ef66886b6c1f29346ad31fb049c 100644
--- a/substrate/frame/contracts/src/tests.rs
+++ b/substrate/frame/contracts/src/tests.rs
@@ -871,8 +871,7 @@ fn gas_syncs_work() {
 		let result = builder::bare_call(addr.clone()).data(1u32.encode()).build();
 		assert_ok!(result.result);
 		let gas_consumed_once = result.gas_consumed.ref_time();
-		let host_consumed_once =
-			<Test as Config>::Schedule::get().host_fn_weights.caller_is_origin.ref_time();
+		let host_consumed_once = <Test as Config>::WeightInfo::seal_caller_is_origin().ref_time();
 		let engine_consumed_once = gas_consumed_once - host_consumed_once - engine_consumed_noop;
 
 		let result = builder::bare_call(addr).data(2u32.encode()).build();
@@ -4237,3 +4236,99 @@ fn gas_consumed_is_linear_for_nested_calls() {
 		assert_eq!(gas_max, gas_0 + gas_per_recursion * max_call_depth as u64);
 	});
 }
+
+#[test]
+fn read_only_call_cannot_store() {
+	let (wasm_caller, _code_hash_caller) = compile_module::<Test>("read_only_call").unwrap();
+	let (wasm_callee, _code_hash_callee) = compile_module::<Test>("store_call").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Create both contracts: Constructors do nothing.
+		let addr_caller =
+			builder::bare_instantiate(Code::Upload(wasm_caller)).build_and_unwrap_account_id();
+		let addr_callee =
+			builder::bare_instantiate(Code::Upload(wasm_callee)).build_and_unwrap_account_id();
+
+		// Read-only call fails when modifying storage.
+		assert_err_ignore_postinfo!(
+			builder::call(addr_caller).data((&addr_callee, 100u32).encode()).build(),
+			<Error<Test>>::ContractTrapped
+		);
+	});
+}
+
+#[test]
+fn read_only_call_cannot_transfer() {
+	let (wasm_caller, _code_hash_caller) =
+		compile_module::<Test>("call_with_flags_and_value").unwrap();
+	let (wasm_callee, _code_hash_callee) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Create both contracts: Constructors do nothing.
+		let addr_caller =
+			builder::bare_instantiate(Code::Upload(wasm_caller)).build_and_unwrap_account_id();
+		let addr_callee =
+			builder::bare_instantiate(Code::Upload(wasm_callee)).build_and_unwrap_account_id();
+
+		// Read-only call fails when a non-zero value is set.
+		assert_err_ignore_postinfo!(
+			builder::call(addr_caller)
+				.data(
+					(addr_callee, pallet_contracts_uapi::CallFlags::READ_ONLY.bits(), 100u64)
+						.encode()
+				)
+				.build(),
+			<Error<Test>>::StateChangeDenied
+		);
+	});
+}
+
+#[test]
+fn read_only_subsequent_call_cannot_store() {
+	let (wasm_read_only_caller, _code_hash_caller) =
+		compile_module::<Test>("read_only_call").unwrap();
+	let (wasm_caller, _code_hash_caller) =
+		compile_module::<Test>("call_with_flags_and_value").unwrap();
+	let (wasm_callee, _code_hash_callee) = compile_module::<Test>("store_call").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Create contracts: Constructors do nothing.
+		let addr_caller = builder::bare_instantiate(Code::Upload(wasm_read_only_caller))
+			.build_and_unwrap_account_id();
+		let addr_subsequent_caller =
+			builder::bare_instantiate(Code::Upload(wasm_caller)).build_and_unwrap_account_id();
+		let addr_callee =
+			builder::bare_instantiate(Code::Upload(wasm_callee)).build_and_unwrap_account_id();
+
+		// Subsequent call input.
+		let input = (&addr_callee, pallet_contracts_uapi::CallFlags::empty().bits(), 0u64, 100u32);
+
+		// Read-only call fails when modifying storage.
+		assert_err_ignore_postinfo!(
+			builder::call(addr_caller)
+				.data((&addr_subsequent_caller, input).encode())
+				.build(),
+			<Error<Test>>::ContractTrapped
+		);
+	});
+}
+
+#[test]
+fn read_only_call_works() {
+	let (wasm_caller, _code_hash_caller) = compile_module::<Test>("read_only_call").unwrap();
+	let (wasm_callee, _code_hash_callee) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Create both contracts: Constructors do nothing.
+		let addr_caller =
+			builder::bare_instantiate(Code::Upload(wasm_caller)).build_and_unwrap_account_id();
+		let addr_callee =
+			builder::bare_instantiate(Code::Upload(wasm_callee)).build_and_unwrap_account_id();
+
+		assert_ok!(builder::call(addr_caller.clone()).data(addr_callee.encode()).build());
+	});
+}
diff --git a/substrate/frame/contracts/src/wasm/mod.rs b/substrate/frame/contracts/src/wasm/mod.rs
index b40eb699db9e96dc6dfcd412050039f1cad960da..0d65d696758d0f3af8a12df0623b853f73b193f2 100644
--- a/substrate/frame/contracts/src/wasm/mod.rs
+++ b/substrate/frame/contracts/src/wasm/mod.rs
@@ -31,6 +31,9 @@ pub use {
 	tests::MockExt,
 };
 
+#[cfg(feature = "runtime-benchmarks")]
+pub use crate::wasm::runtime::{BenchEnv, ReturnData, TrapReason};
+
 pub use crate::wasm::{
 	prepare::{LoadedModule, LoadingMode},
 	runtime::{
@@ -54,7 +57,7 @@ use frame_support::{
 use sp_core::Get;
 use sp_runtime::{DispatchError, RuntimeDebug};
 use sp_std::prelude::*;
-use wasmi::{InstancePre, Linker, Memory, MemoryType, StackLimits, Store};
+use wasmi::{CompilationMode, InstancePre, Linker, Memory, MemoryType, StackLimits, Store};
 
 const BYTES_PER_PAGE: usize = 64 * 1024;
 
@@ -139,11 +142,6 @@ struct CodeLoadToken(u32);
 
 impl<T: Config> Token<T> for CodeLoadToken {
 	fn weight(&self) -> Weight {
-		// When loading the contract, we already covered the general costs of
-		// calling the storage but still need to account for the actual size of the
-		// contract code. This is why we subtract `T::*::(0)`. We need to do this at this
-		// point because when charging the general weight for calling the contract we don't know the
-		// size of the contract.
 		T::WeightInfo::call_with_code_per_byte(self.0)
 			.saturating_sub(T::WeightInfo::call_with_code_per_byte(0))
 	}
@@ -348,9 +346,9 @@ impl<T: Config> WasmBlob<T> {
 		mut store: Store<Runtime<E>>,
 		result: Result<(), wasmi::Error>,
 	) -> ExecResult {
-		let engine_consumed_total = store.fuel_consumed().expect("Fuel metering is enabled; qed");
+		let engine_fuel = store.get_fuel().expect("Fuel metering is enabled; qed");
 		let gas_meter = store.data_mut().ext().gas_meter_mut();
-		let _ = gas_meter.sync_from_executor(engine_consumed_total)?;
+		let _ = gas_meter.sync_from_executor(engine_fuel)?;
 		store.into_data().to_execution_result(result)
 	}
 
@@ -361,8 +359,13 @@ impl<T: Config> WasmBlob<T> {
 		input_data: Vec<u8>,
 	) -> (Func, Store<Runtime<E>>) {
 		use InstanceOrExecReturn::*;
-		match Self::prepare_execute(self, Runtime::new(ext, input_data), &ExportedFunction::Call)
-			.expect("Benchmark should provide valid module")
+		match Self::prepare_execute(
+			self,
+			Runtime::new(ext, input_data),
+			&ExportedFunction::Call,
+			CompilationMode::Eager,
+		)
+		.expect("Benchmark should provide valid module")
 		{
 			Instance((func, store)) => (func, store),
 			ExecReturn(_) => panic!("Expected Instance"),
@@ -373,6 +376,7 @@ impl<T: Config> WasmBlob<T> {
 		self,
 		runtime: Runtime<'a, E>,
 		function: &'a ExportedFunction,
+		compilation_mode: CompilationMode,
 	) -> PreExecResult<'a, E> {
 		let code = self.code.as_slice();
 		// Instantiate the Wasm module to the engine.
@@ -383,6 +387,7 @@ impl<T: Config> WasmBlob<T> {
 			self.code_info.determinism,
 			Some(StackLimits::default()),
 			LoadingMode::Unchecked,
+			compilation_mode,
 		)
 		.map_err(|err| {
 			log::debug!(target: LOG_TARGET, "failed to create wasmi module: {err:?}");
@@ -412,10 +417,10 @@ impl<T: Config> WasmBlob<T> {
 			.gas_meter_mut()
 			.gas_left()
 			.ref_time()
-			.checked_div(T::Schedule::get().instruction_weights.base as u64)
+			.checked_div(T::Schedule::get().ref_time_by_fuel())
 			.ok_or(Error::<T>::InvalidSchedule)?;
 		store
-			.add_fuel(fuel_limit)
+			.set_fuel(fuel_limit)
 			.expect("We've set up engine to fuel consuming mode; qed");
 
 		// Start function should already see the correct refcount in case it will be ever inspected.
@@ -461,7 +466,12 @@ impl<T: Config> Executable<T> for WasmBlob<T> {
 		input_data: Vec<u8>,
 	) -> ExecResult {
 		use InstanceOrExecReturn::*;
-		match Self::prepare_execute(self, Runtime::new(ext, input_data), function)? {
+		match Self::prepare_execute(
+			self,
+			Runtime::new(ext, input_data),
+			function,
+			CompilationMode::Lazy,
+		)? {
 			Instance((func, mut store)) => {
 				let result = func.call(&mut store, &[], &mut []);
 				Self::process_result(store, result)
@@ -542,6 +552,7 @@ mod tests {
 		value: u64,
 		data: Vec<u8>,
 		allows_reentry: bool,
+		read_only: bool,
 	}
 
 	#[derive(Debug, PartialEq, Eq)]
@@ -609,8 +620,9 @@ mod tests {
 			value: u64,
 			data: Vec<u8>,
 			allows_reentry: bool,
+			read_only: bool,
 		) -> Result<ExecReturnValue, ExecError> {
-			self.calls.push(CallEntry { to, value, data, allows_reentry });
+			self.calls.push(CallEntry { to, value, data, allows_reentry, read_only });
 			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: call_return_data() })
 		}
 		fn delegate_call(
@@ -642,15 +654,15 @@ mod tests {
 				ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() },
 			))
 		}
-		fn set_code_hash(&mut self, hash: CodeHash<Self::T>) -> Result<(), DispatchError> {
+		fn set_code_hash(&mut self, hash: CodeHash<Self::T>) -> DispatchResult {
 			self.code_hashes.push(hash);
 			Ok(())
 		}
-		fn transfer(&mut self, to: &AccountIdOf<Self::T>, value: u64) -> Result<(), DispatchError> {
+		fn transfer(&mut self, to: &AccountIdOf<Self::T>, value: u64) -> DispatchResult {
 			self.transfers.push(TransferEntry { to: to.clone(), value });
 			Ok(())
 		}
-		fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> Result<(), DispatchError> {
+		fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> DispatchResult {
 			self.terminations.push(TerminationEntry { beneficiary: beneficiary.clone() });
 			Ok(())
 		}
@@ -784,24 +796,26 @@ mod tests {
 		fn nonce(&mut self) -> u64 {
 			995
 		}
-		fn increment_refcount(_code_hash: CodeHash<Self::T>) -> Result<(), DispatchError> {
+		fn increment_refcount(_code_hash: CodeHash<Self::T>) -> DispatchResult {
 			Ok(())
 		}
 		fn decrement_refcount(_code_hash: CodeHash<Self::T>) {}
-		fn lock_delegate_dependency(
-			&mut self,
-			code: CodeHash<Self::T>,
-		) -> Result<(), DispatchError> {
+		fn lock_delegate_dependency(&mut self, code: CodeHash<Self::T>) -> DispatchResult {
 			self.delegate_dependencies.borrow_mut().insert(code);
 			Ok(())
 		}
-		fn unlock_delegate_dependency(
-			&mut self,
-			code: &CodeHash<Self::T>,
-		) -> Result<(), DispatchError> {
+		fn unlock_delegate_dependency(&mut self, code: &CodeHash<Self::T>) -> DispatchResult {
 			self.delegate_dependencies.borrow_mut().remove(code);
 			Ok(())
 		}
+
+		fn locked_delegate_dependencies_count(&mut self) -> usize {
+			self.delegate_dependencies.borrow().len()
+		}
+
+		fn is_read_only(&self) -> bool {
+			false
+		}
 	}
 
 	/// Execute the supplied code.
@@ -983,7 +997,13 @@ mod tests {
 
 		assert_eq!(
 			&mock_ext.calls,
-			&[CallEntry { to: ALICE, value: 6, data: vec![1, 2, 3, 4], allows_reentry: true }]
+			&[CallEntry {
+				to: ALICE,
+				value: 6,
+				data: vec![1, 2, 3, 4],
+				allows_reentry: true,
+				read_only: false
+			}]
 		);
 	}
 
@@ -1080,7 +1100,13 @@ mod tests {
 
 		assert_eq!(
 			&mock_ext.calls,
-			&[CallEntry { to: ALICE, value: 0x2a, data: input, allows_reentry: false }]
+			&[CallEntry {
+				to: ALICE,
+				value: 0x2a,
+				data: input,
+				allows_reentry: false,
+				read_only: false
+			}]
 		);
 	}
 
@@ -1135,7 +1161,13 @@ mod tests {
 		assert_eq!(result.data, input);
 		assert_eq!(
 			&mock_ext.calls,
-			&[CallEntry { to: ALICE, value: 0x2a, data: input, allows_reentry: true }]
+			&[CallEntry {
+				to: ALICE,
+				value: 0x2a,
+				data: input,
+				allows_reentry: true,
+				read_only: false
+			}]
 		);
 	}
 
@@ -1182,7 +1214,13 @@ mod tests {
 		assert_eq!(result.data, call_return_data());
 		assert_eq!(
 			&mock_ext.calls,
-			&[CallEntry { to: ALICE, value: 0x2a, data: input, allows_reentry: false }]
+			&[CallEntry {
+				to: ALICE,
+				value: 0x2a,
+				data: input,
+				allows_reentry: false,
+				read_only: false
+			}]
 		);
 	}
 
@@ -1423,7 +1461,13 @@ mod tests {
 
 		assert_eq!(
 			&mock_ext.calls,
-			&[CallEntry { to: ALICE, value: 6, data: vec![1, 2, 3, 4], allows_reentry: true }]
+			&[CallEntry {
+				to: ALICE,
+				value: 6,
+				data: vec![1, 2, 3, 4],
+				allows_reentry: true,
+				read_only: false
+			}]
 		);
 	}
 
diff --git a/substrate/frame/contracts/src/wasm/prepare.rs b/substrate/frame/contracts/src/wasm/prepare.rs
index 0d9a12d8ae837b88a2be0b34d84129564b442562..50eb6d625321abc0961ce4c1c0b66001dd00b1fa 100644
--- a/substrate/frame/contracts/src/wasm/prepare.rs
+++ b/substrate/frame/contracts/src/wasm/prepare.rs
@@ -33,8 +33,8 @@ use sp_runtime::{traits::Hash, DispatchError};
 #[cfg(any(test, feature = "runtime-benchmarks"))]
 use sp_std::prelude::Vec;
 use wasmi::{
-	core::ValueType as WasmiValueType, Config as WasmiConfig, Engine, ExternType,
-	FuelConsumptionMode, Module, StackLimits,
+	core::ValType as WasmiValueType, CompilationMode, Config as WasmiConfig, Engine, ExternType,
+	Module, StackLimits,
 };
 
 /// Imported memory must be located inside this module. The reason for hardcoding is that current
@@ -71,7 +71,8 @@ impl LoadedModule {
 		code: &[u8],
 		determinism: Determinism,
 		stack_limits: Option<StackLimits>,
-		_mode: LoadingMode,
+		loading_mode: LoadingMode,
+		compilation_mode: CompilationMode,
 	) -> Result<Self, &'static str> {
 		// NOTE: wasmi does not support unstable WebAssembly features. The module is implicitly
 		// checked for not having those ones when creating `wasmi::Module` below.
@@ -86,8 +87,8 @@ impl LoadedModule {
 			.wasm_extended_const(false)
 			.wasm_saturating_float_to_int(false)
 			.floats(matches!(determinism, Determinism::Relaxed))
-			.consume_fuel(true)
-			.fuel_consumption_mode(FuelConsumptionMode::Eager);
+			.compilation_mode(compilation_mode)
+			.consume_fuel(true);
 
 		if let Some(stack_limits) = stack_limits {
 			config.set_stack_limits(stack_limits);
@@ -95,14 +96,18 @@ impl LoadedModule {
 
 		let engine = Engine::new(&config);
 
-		// TODO use Module::new_unchecked when validate_module is true once we are on wasmi@0.32
-		let module = Module::new(&engine, code).map_err(|err| {
+		let module = match loading_mode {
+			LoadingMode::Checked => Module::new(&engine, code),
+			// Safety: The code has been validated, Therefore we know that it's a valid binary.
+			LoadingMode::Unchecked => unsafe { Module::new_unchecked(&engine, code) },
+		}
+		.map_err(|err| {
 			log::debug!(target: LOG_TARGET, "Module creation failed: {:?}", err);
 			"Can't load the module into wasmi!"
 		})?;
 
 		#[cfg(test)]
-		tracker::LOADED_MODULE.with(|t| t.borrow_mut().push(_mode));
+		tracker::LOADED_MODULE.with(|t| t.borrow_mut().push(loading_mode));
 
 		// Return a `LoadedModule` instance with
 		// __valid__ module.
@@ -263,17 +268,25 @@ where
 					Determinism::Enforced,
 					stack_limits,
 					LoadingMode::Checked,
+					CompilationMode::Eager,
 				) {
 					*determinism = Determinism::Enforced;
 					module
 				} else {
-					LoadedModule::new::<T>(code, Determinism::Relaxed, None, LoadingMode::Checked)?
+					LoadedModule::new::<T>(
+						code,
+						Determinism::Relaxed,
+						None,
+						LoadingMode::Checked,
+						CompilationMode::Eager,
+					)?
 				},
 			Determinism::Enforced => LoadedModule::new::<T>(
 				code,
 				Determinism::Enforced,
 				stack_limits,
 				LoadingMode::Checked,
+				CompilationMode::Eager,
 			)?,
 		};
 
@@ -348,8 +361,13 @@ pub mod benchmarking {
 		owner: AccountIdOf<T>,
 	) -> Result<WasmBlob<T>, DispatchError> {
 		let determinism = Determinism::Enforced;
-		let contract_module =
-			LoadedModule::new::<T>(&code, determinism, None, LoadingMode::Checked)?;
+		let contract_module = LoadedModule::new::<T>(
+			&code,
+			determinism,
+			None,
+			LoadingMode::Checked,
+			CompilationMode::Eager,
+		)?;
 		let _ = contract_module.scan_imports::<T>(schedule)?;
 		let code: CodeVec<T> = code.try_into().map_err(|_| <Error<T>>::CodeTooLarge)?;
 		let code_info = CodeInfo {
diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs
index 3212aff31269a91d66ce0043f60c8130b2d4bc9a..5f50dbf391a2822d66a8930eac12bea4a45ccdd4 100644
--- a/substrate/frame/contracts/src/wasm/runtime.rs
+++ b/substrate/frame/contracts/src/wasm/runtime.rs
@@ -21,6 +21,7 @@ use crate::{
 	exec::{ExecError, ExecResult, Ext, Key, TopicOf},
 	gas::{ChargedAmount, Token},
 	primitives::ExecReturnValue,
+	weights::WeightInfo,
 	BalanceOf, CodeHash, Config, DebugBufferVec, Error, SENTINEL,
 };
 use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen};
@@ -145,6 +146,8 @@ impl HostError for TrapReason {}
 #[cfg_attr(test, derive(Debug, PartialEq, Eq))]
 #[derive(Copy, Clone)]
 pub enum RuntimeCosts {
+	/// Base Weight of calling a host function.
+	HostFn,
 	/// Weight charged for copying data from the sandbox.
 	CopyFromContract(u32),
 	/// Weight charged for copying data to the sandbox.
@@ -177,12 +180,8 @@ pub enum RuntimeCosts {
 	Now,
 	/// Weight of calling `seal_weight_to_fee`.
 	WeightToFee,
-	/// Weight of calling `seal_input` without the weight of copying the input.
-	InputBase,
-	/// Weight of calling `seal_return` for the given output size.
-	Return(u32),
-	/// Weight of calling `seal_terminate`.
-	Terminate,
+	/// Weight of calling `seal_terminate`, passing the number of locked dependencies.
+	Terminate(u32),
 	/// Weight of calling `seal_random`. It includes the weight for copying the subject.
 	Random,
 	/// Weight of calling `seal_deposit_event` with the given number of topics and event size.
@@ -206,13 +205,11 @@ pub enum RuntimeCosts {
 	/// Weight of calling `seal_delegate_call` for the given input size.
 	DelegateCallBase,
 	/// Weight of the transfer performed during a call.
-	CallSurchargeTransfer,
+	CallTransferSurcharge,
 	/// Weight per byte that is cloned by supplying the `CLONE_INPUT` flag.
 	CallInputCloned(u32),
 	/// Weight of calling `seal_instantiate` for the given input length and salt.
-	InstantiateBase { input_data_len: u32, salt_len: u32 },
-	/// Weight of the transfer performed during an instantiate.
-	InstantiateSurchargeTransfer,
+	Instantiate { input_data_len: u32, salt_len: u32 },
 	/// Weight of calling `seal_hash_sha_256` for the given input size.
 	HashSha256(u32),
 	/// Weight of calling `seal_hash_keccak_256` for the given input size.
@@ -236,9 +233,9 @@ pub enum RuntimeCosts {
 	/// Weight of calling `ecdsa_to_eth_address`
 	EcdsaToEthAddress,
 	/// Weight of calling `reentrance_count`
-	ReentrantCount,
+	ReentranceCount,
 	/// Weight of calling `account_reentrance_count`
-	AccountEntranceCount,
+	AccountReentranceCount,
 	/// Weight of calling `instantiation_nonce`
 	InstantiationNonce,
 	/// Weight of calling `lock_delegate_dependency`
@@ -247,6 +244,19 @@ pub enum RuntimeCosts {
 	UnlockDelegateDependency,
 }
 
+macro_rules! cost_args {
+	// cost_args!(name, a, b, c) -> T::WeightInfo::name(a, b, c).saturating_sub(T::WeightInfo::name(0, 0, 0))
+	($name:ident, $( $arg: expr ),+) => {
+		(T::WeightInfo::$name($( $arg ),+).saturating_sub(cost_args!(@call_zero $name, $( $arg ),+)))
+	};
+	// Transform T::WeightInfo::name(a, b, c) into T::WeightInfo::name(0, 0, 0)
+	(@call_zero $name:ident, $( $arg:expr ),*) => {
+		T::WeightInfo::$name($( cost_args!(@replace_token $arg) ),*)
+	};
+	// Replace the token with 0.
+	(@replace_token $_in:tt) => { 0 };
+}
+
 impl<T: Config> Token<T> for RuntimeCosts {
 	fn influence_lowest_gas_limit(&self) -> bool {
 		match self {
@@ -256,85 +266,56 @@ impl<T: Config> Token<T> for RuntimeCosts {
 	}
 
 	fn weight(&self) -> Weight {
-		let s = T::Schedule::get().host_fn_weights;
 		use self::RuntimeCosts::*;
 		match *self {
-			CopyFromContract(len) => s.return_per_byte.saturating_mul(len.into()),
-			CopyToContract(len) => s.input_per_byte.saturating_mul(len.into()),
-			Caller => s.caller,
-			IsContract => s.is_contract,
-			CodeHash => s.code_hash,
-			OwnCodeHash => s.own_code_hash,
-			CallerIsOrigin => s.caller_is_origin,
-			CallerIsRoot => s.caller_is_root,
-			Address => s.address,
-			GasLeft => s.gas_left,
-			Balance => s.balance,
-			ValueTransferred => s.value_transferred,
-			MinimumBalance => s.minimum_balance,
-			BlockNumber => s.block_number,
-			Now => s.now,
-			WeightToFee => s.weight_to_fee,
-			InputBase => s.input,
-			Return(len) => s.r#return.saturating_add(s.return_per_byte.saturating_mul(len.into())),
-			Terminate => s.terminate,
-			Random => s.random,
-			DepositEvent { num_topic, len } => s
-				.deposit_event
-				.saturating_add(s.deposit_event_per_topic.saturating_mul(num_topic.into()))
-				.saturating_add(s.deposit_event_per_byte.saturating_mul(len.into())),
-			DebugMessage(len) => s
-				.debug_message
-				.saturating_add(s.deposit_event_per_byte.saturating_mul(len.into())),
-			SetStorage { new_bytes, old_bytes } => s
-				.set_storage
-				.saturating_add(s.set_storage_per_new_byte.saturating_mul(new_bytes.into()))
-				.saturating_add(s.set_storage_per_old_byte.saturating_mul(old_bytes.into())),
-			ClearStorage(len) => s
-				.clear_storage
-				.saturating_add(s.clear_storage_per_byte.saturating_mul(len.into())),
-			ContainsStorage(len) => s
-				.contains_storage
-				.saturating_add(s.contains_storage_per_byte.saturating_mul(len.into())),
-			GetStorage(len) =>
-				s.get_storage.saturating_add(s.get_storage_per_byte.saturating_mul(len.into())),
-			TakeStorage(len) => s
-				.take_storage
-				.saturating_add(s.take_storage_per_byte.saturating_mul(len.into())),
-			Transfer => s.transfer,
-			CallBase => s.call,
-			DelegateCallBase => s.delegate_call,
-			CallSurchargeTransfer => s.call_transfer_surcharge,
-			CallInputCloned(len) => s.call_per_cloned_byte.saturating_mul(len.into()),
-			InstantiateBase { input_data_len, salt_len } => s
-				.instantiate
-				.saturating_add(s.instantiate_per_input_byte.saturating_mul(input_data_len.into()))
-				.saturating_add(s.instantiate_per_salt_byte.saturating_mul(salt_len.into())),
-			InstantiateSurchargeTransfer => s.instantiate_transfer_surcharge,
-			HashSha256(len) => s
-				.hash_sha2_256
-				.saturating_add(s.hash_sha2_256_per_byte.saturating_mul(len.into())),
-			HashKeccak256(len) => s
-				.hash_keccak_256
-				.saturating_add(s.hash_keccak_256_per_byte.saturating_mul(len.into())),
-			HashBlake256(len) => s
-				.hash_blake2_256
-				.saturating_add(s.hash_blake2_256_per_byte.saturating_mul(len.into())),
-			HashBlake128(len) => s
-				.hash_blake2_128
-				.saturating_add(s.hash_blake2_128_per_byte.saturating_mul(len.into())),
-			EcdsaRecovery => s.ecdsa_recover,
-			Sr25519Verify(len) => s
-				.sr25519_verify
-				.saturating_add(s.sr25519_verify_per_byte.saturating_mul(len.into())),
+			HostFn => cost_args!(noop_host_fn, 1),
+			CopyToContract(len) => T::WeightInfo::seal_input(len),
+			CopyFromContract(len) => T::WeightInfo::seal_return(len),
+			Caller => T::WeightInfo::seal_caller(),
+			IsContract => T::WeightInfo::seal_is_contract(),
+			CodeHash => T::WeightInfo::seal_code_hash(),
+			OwnCodeHash => T::WeightInfo::seal_own_code_hash(),
+			CallerIsOrigin => T::WeightInfo::seal_caller_is_origin(),
+			CallerIsRoot => T::WeightInfo::seal_caller_is_root(),
+			Address => T::WeightInfo::seal_address(),
+			GasLeft => T::WeightInfo::seal_gas_left(),
+			Balance => T::WeightInfo::seal_balance(),
+			ValueTransferred => T::WeightInfo::seal_value_transferred(),
+			MinimumBalance => T::WeightInfo::seal_minimum_balance(),
+			BlockNumber => T::WeightInfo::seal_block_number(),
+			Now => T::WeightInfo::seal_now(),
+			WeightToFee => T::WeightInfo::seal_weight_to_fee(),
+			Terminate(locked_dependencies) => T::WeightInfo::seal_terminate(locked_dependencies),
+			Random => T::WeightInfo::seal_random(),
+			DepositEvent { num_topic, len } => T::WeightInfo::seal_deposit_event(num_topic, len),
+			DebugMessage(len) => T::WeightInfo::seal_debug_message(len),
+			SetStorage { new_bytes, old_bytes } =>
+				T::WeightInfo::seal_set_storage(new_bytes, old_bytes),
+			ClearStorage(len) => T::WeightInfo::seal_clear_storage(len),
+			ContainsStorage(len) => T::WeightInfo::seal_contains_storage(len),
+			GetStorage(len) => T::WeightInfo::seal_get_storage(len),
+			TakeStorage(len) => T::WeightInfo::seal_take_storage(len),
+			Transfer => T::WeightInfo::seal_transfer(),
+			CallBase => T::WeightInfo::seal_call(0, 0),
+			DelegateCallBase => T::WeightInfo::seal_delegate_call(),
+			CallTransferSurcharge => cost_args!(seal_call, 1, 0),
+			CallInputCloned(len) => cost_args!(seal_call, 0, len),
+			Instantiate { input_data_len, salt_len } =>
+				T::WeightInfo::seal_instantiate(input_data_len, salt_len),
+			HashSha256(len) => T::WeightInfo::seal_hash_sha2_256(len),
+			HashKeccak256(len) => T::WeightInfo::seal_hash_keccak_256(len),
+			HashBlake256(len) => T::WeightInfo::seal_hash_blake2_256(len),
+			HashBlake128(len) => T::WeightInfo::seal_hash_blake2_128(len),
+			EcdsaRecovery => T::WeightInfo::seal_ecdsa_recover(),
+			Sr25519Verify(len) => T::WeightInfo::seal_sr25519_verify(len),
 			ChainExtension(weight) | CallRuntime(weight) | CallXcmExecute(weight) => weight,
-			SetCodeHash => s.set_code_hash,
-			EcdsaToEthAddress => s.ecdsa_to_eth_address,
-			ReentrantCount => s.reentrance_count,
-			AccountEntranceCount => s.account_reentrance_count,
-			InstantiationNonce => s.instantiation_nonce,
-			LockDelegateDependency => s.lock_delegate_dependency,
-			UnlockDelegateDependency => s.unlock_delegate_dependency,
+			SetCodeHash => T::WeightInfo::seal_set_code_hash(),
+			EcdsaToEthAddress => T::WeightInfo::seal_ecdsa_to_eth_address(),
+			ReentranceCount => T::WeightInfo::seal_reentrance_count(),
+			AccountReentranceCount => T::WeightInfo::seal_account_reentrance_count(),
+			InstantiationNonce => T::WeightInfo::seal_instantiation_nonce(),
+			LockDelegateDependency => T::WeightInfo::lock_delegate_dependency(),
+			UnlockDelegateDependency => T::WeightInfo::unlock_delegate_dependency(),
 		}
 	}
 }
@@ -401,49 +382,55 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 
 	/// Converts the sandbox result and the runtime state into the execution outcome.
 	pub fn to_execution_result(self, sandbox_result: Result<(), wasmi::Error>) -> ExecResult {
-		use wasmi::core::TrapCode::OutOfFuel;
+		use wasmi::{
+			core::TrapCode,
+			errors::{ErrorKind, FuelError},
+		};
 		use TrapReason::*;
 
-		match sandbox_result {
+		let Err(error) = sandbox_result else {
 			// Contract returned from main function -> no data was returned.
-			Ok(_) => Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }),
+			return Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() })
+		};
+		if let ErrorKind::Fuel(FuelError::OutOfFuel) = error.kind() {
 			// `OutOfGas` when host asks engine to consume more than left in the _store_.
 			// We should never get this case, as gas meter is being charged (and hence raises error)
 			// first.
-			Err(wasmi::Error::Store(_)) => Err(Error::<E::T>::OutOfGas.into()),
-			// Contract either trapped or some host function aborted the execution.
-			Err(wasmi::Error::Trap(trap)) => {
-				if let Some(OutOfFuel) = trap.trap_code() {
-					// `OutOfGas` during engine execution.
-					return Err(Error::<E::T>::OutOfGas.into())
-				}
-				// If we encoded a reason then it is some abort generated by a host function.
-				if let Some(reason) = &trap.downcast_ref::<TrapReason>() {
-					match &reason {
-						Return(ReturnData { flags, data }) => {
-							let flags = ReturnFlags::from_bits(*flags)
-								.ok_or(Error::<E::T>::InvalidCallFlags)?;
-							return Ok(ExecReturnValue { flags, data: data.to_vec() })
-						},
-						Termination =>
-							return Ok(ExecReturnValue {
-								flags: ReturnFlags::empty(),
-								data: Vec::new(),
-							}),
-						SupervisorError(error) => return Err((*error).into()),
-					}
-				}
+			return Err(Error::<E::T>::OutOfGas.into())
+		}
+		match error.as_trap_code() {
+			Some(TrapCode::OutOfFuel) => {
+				// `OutOfGas` during engine execution.
+				return Err(Error::<E::T>::OutOfGas.into())
+			},
+			Some(_trap_code) => {
 				// Otherwise the trap came from the contract itself.
-				Err(Error::<E::T>::ContractTrapped.into())
+				return Err(Error::<E::T>::ContractTrapped.into())
 			},
-			// Any other error is returned only if instantiation or linking failed (i.e.
-			// wasm binary tried to import a function that is not provided by the host).
-			// This shouldn't happen because validation process ought to reject such binaries.
-			//
-			// Because panics are really undesirable in the runtime code, we treat this as
-			// a trap for now. Eventually, we might want to revisit this.
-			Err(_) => Err(Error::<E::T>::CodeRejected.into()),
+			None => {},
+		}
+		// If we encoded a reason then it is some abort generated by a host function.
+		if let Some(reason) = &error.downcast_ref::<TrapReason>() {
+			match &reason {
+				Return(ReturnData { flags, data }) => {
+					let flags =
+						ReturnFlags::from_bits(*flags).ok_or(Error::<E::T>::InvalidCallFlags)?;
+					return Ok(ExecReturnValue { flags, data: data.to_vec() })
+				},
+				Termination =>
+					return Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }),
+				SupervisorError(error) => return Err((*error).into()),
+			}
 		}
+
+		// Any other error is returned only if instantiation or linking failed (i.e.
+		// wasm binary tried to import a function that is not provided by the host).
+		// This shouldn't happen because validation process ought to reject such binaries.
+		//
+		// Because panics are really undesirable in the runtime code, we treat this as
+		// a trap for now. Eventually, we might want to revisit this.
+		log::debug!("Code rejected: {:?}", error);
+		Err(Error::<E::T>::CodeRejected.into())
 	}
 
 	/// Get a mutable reference to the inner `Ext`.
@@ -819,6 +806,7 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 		output_len_ptr: u32,
 	) -> Result<ReturnErrorCode, TrapReason> {
 		self.charge_gas(call_type.cost())?;
+
 		let input_data = if flags.contains(CallFlags::CLONE_INPUT) {
 			let input = self.input_data.as_ref().ok_or(Error::<E::T>::InputForwarded)?;
 			charge_gas!(self, RuntimeCosts::CallInputCloned(input.len() as u32))?;
@@ -839,10 +827,16 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 				} else {
 					self.read_sandbox_memory_as(memory, deposit_ptr)?
 				};
+				let read_only = flags.contains(CallFlags::READ_ONLY);
 				let value: BalanceOf<<E as Ext>::T> =
 					self.read_sandbox_memory_as(memory, value_ptr)?;
 				if value > 0u32.into() {
-					self.charge_gas(RuntimeCosts::CallSurchargeTransfer)?;
+					// If the call value is non-zero and state change is not allowed, issue an
+					// error.
+					if read_only || self.ext.is_read_only() {
+						return Err(Error::<E::T>::StateChangeDenied.into());
+					}
+					self.charge_gas(RuntimeCosts::CallTransferSurcharge)?;
 				}
 				self.ext.call(
 					weight,
@@ -851,10 +845,11 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 					value,
 					input_data,
 					flags.contains(CallFlags::ALLOW_REENTRY),
+					read_only,
 				)
 			},
 			CallType::DelegateCall { code_hash_ptr } => {
-				if flags.contains(CallFlags::ALLOW_REENTRY) {
+				if flags.intersects(CallFlags::ALLOW_REENTRY | CallFlags::READ_ONLY) {
 					return Err(Error::<E::T>::InvalidCallFlags.into())
 				}
 				let code_hash = self.read_sandbox_memory_as(memory, code_hash_ptr)?;
@@ -902,16 +897,13 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 		salt_ptr: u32,
 		salt_len: u32,
 	) -> Result<ReturnErrorCode, TrapReason> {
-		self.charge_gas(RuntimeCosts::InstantiateBase { input_data_len, salt_len })?;
+		self.charge_gas(RuntimeCosts::Instantiate { input_data_len, salt_len })?;
 		let deposit_limit: BalanceOf<<E as Ext>::T> = if deposit_ptr == SENTINEL {
 			BalanceOf::<<E as Ext>::T>::zero()
 		} else {
 			self.read_sandbox_memory_as(memory, deposit_ptr)?
 		};
 		let value: BalanceOf<<E as Ext>::T> = self.read_sandbox_memory_as(memory, value_ptr)?;
-		if value > 0u32.into() {
-			self.charge_gas(RuntimeCosts::InstantiateSurchargeTransfer)?;
-		}
 		let code_hash: CodeHash<<E as Ext>::T> =
 			self.read_sandbox_memory_as(memory, code_hash_ptr)?;
 		let input_data = self.read_sandbox_memory(memory, input_data_ptr, input_data_len)?;
@@ -942,7 +934,9 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 	}
 
 	fn terminate(&mut self, memory: &[u8], beneficiary_ptr: u32) -> Result<(), TrapReason> {
-		self.charge_gas(RuntimeCosts::Terminate)?;
+		let count = self.ext.locked_delegate_dependencies_count() as _;
+		self.charge_gas(RuntimeCosts::Terminate(count))?;
+
 		let beneficiary: <<E as Ext>::T as frame_system::Config>::AccountId =
 			self.read_sandbox_memory_as(memory, beneficiary_ptr)?;
 		self.ext.terminate(&beneficiary)?;
@@ -959,9 +953,18 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 // for every function.
 #[define_env(doc)]
 pub mod env {
+
+	/// Noop function used to benchmark the time it takes to execute an empty function.
+	#[cfg(feature = "runtime-benchmarks")]
+	#[unstable]
+	fn noop(ctx: _, memory: _) -> Result<(), TrapReason> {
+		Ok(())
+	}
+
 	/// Set the value at the given key in the contract storage.
 	/// See [`pallet_contracts_uapi::HostFn::set_storage`]
 	#[prefixed_alias]
+	#[mutating]
 	fn set_storage(
 		ctx: _,
 		memory: _,
@@ -976,6 +979,7 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::set_storage_v1`]
 	#[version(1)]
 	#[prefixed_alias]
+	#[mutating]
 	fn set_storage(
 		ctx: _,
 		memory: _,
@@ -990,6 +994,7 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::set_storage_v2`]
 	#[version(2)]
 	#[prefixed_alias]
+	#[mutating]
 	fn set_storage(
 		ctx: _,
 		memory: _,
@@ -1004,6 +1009,7 @@ pub mod env {
 	/// Clear the value at the given key in the contract storage.
 	/// See [`pallet_contracts_uapi::HostFn::clear_storage`]
 	#[prefixed_alias]
+	#[mutating]
 	fn clear_storage(ctx: _, memory: _, key_ptr: u32) -> Result<(), TrapReason> {
 		ctx.clear_storage(memory, KeyType::Fix, key_ptr).map(|_| ())
 	}
@@ -1012,6 +1018,7 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::clear_storage_v1`]
 	#[version(1)]
 	#[prefixed_alias]
+	#[mutating]
 	fn clear_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
 		ctx.clear_storage(memory, KeyType::Var(key_len), key_ptr)
 	}
@@ -1062,6 +1069,7 @@ pub mod env {
 	/// Retrieve and remove the value under the given key from storage.
 	/// See [`pallet_contracts_uapi::HostFn::take_storage`]
 	#[prefixed_alias]
+	#[mutating]
 	fn take_storage(
 		ctx: _,
 		memory: _,
@@ -1093,6 +1101,7 @@ pub mod env {
 	/// Transfer some value to another account.
 	/// See [`pallet_contracts_uapi::HostFn::transfer`].
 	#[prefixed_alias]
+	#[mutating]
 	fn transfer(
 		ctx: _,
 		memory: _,
@@ -1250,6 +1259,7 @@ pub mod env {
 	/// of those types are fixed through [`codec::MaxEncodedLen`]. The fields exist
 	/// for backwards compatibility. Consider switching to the newest version of this function.
 	#[prefixed_alias]
+	#[mutating]
 	fn instantiate(
 		ctx: _,
 		memory: _,
@@ -1288,6 +1298,7 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::instantiate_v1`].
 	#[version(1)]
 	#[prefixed_alias]
+	#[mutating]
 	fn instantiate(
 		ctx: _,
 		memory: _,
@@ -1323,6 +1334,7 @@ pub mod env {
 	/// Instantiate a contract with the specified code hash.
 	/// See [`pallet_contracts_uapi::HostFn::instantiate_v2`].
 	#[version(2)]
+	#[mutating]
 	fn instantiate(
 		ctx: _,
 		memory: _,
@@ -1366,6 +1378,7 @@ pub mod env {
 	/// this type is fixed through `[`MaxEncodedLen`]. The field exist for backwards
 	/// compatibility. Consider switching to the newest version of this function.
 	#[prefixed_alias]
+	#[mutating]
 	fn terminate(
 		ctx: _,
 		memory: _,
@@ -1379,6 +1392,7 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::terminate_v1`].
 	#[version(1)]
 	#[prefixed_alias]
+	#[mutating]
 	fn terminate(ctx: _, memory: _, beneficiary_ptr: u32) -> Result<(), TrapReason> {
 		ctx.terminate(memory, beneficiary_ptr)
 	}
@@ -1387,7 +1401,6 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::input`].
 	#[prefixed_alias]
 	fn input(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
-		ctx.charge_gas(RuntimeCosts::InputBase)?;
 		if let Some(input) = ctx.input_data.take() {
 			ctx.write_sandbox_output(memory, out_ptr, out_len_ptr, &input, false, |len| {
 				Some(RuntimeCosts::CopyToContract(len))
@@ -1408,7 +1421,7 @@ pub mod env {
 		data_ptr: u32,
 		data_len: u32,
 	) -> Result<(), TrapReason> {
-		ctx.charge_gas(RuntimeCosts::Return(data_len))?;
+		ctx.charge_gas(RuntimeCosts::CopyFromContract(data_len))?;
 		Err(TrapReason::Return(ReturnData {
 			flags,
 			data: ctx.read_sandbox_memory(memory, data_ptr, data_len)?,
@@ -1877,6 +1890,7 @@ pub mod env {
 	/// Deposit a contract event with the data buffer and optional list of topics.
 	/// See [pallet_contracts_uapi::HostFn::deposit_event]
 	#[prefixed_alias]
+	#[mutating]
 	fn deposit_event(
 		ctx: _,
 		memory: _,
@@ -2057,6 +2071,7 @@ pub mod env {
 
 	/// Call some dispatchable of the runtime.
 	/// See [`frame_support::traits::call_runtime`].
+	#[mutating]
 	fn call_runtime(
 		ctx: _,
 		memory: _,
@@ -2076,6 +2091,7 @@ pub mod env {
 
 	/// Execute an XCM program locally, using the contract's address as the origin.
 	/// See [`pallet_contracts_uapi::HostFn::execute_xcm`].
+	#[mutating]
 	fn xcm_execute(
 		ctx: _,
 		memory: _,
@@ -2113,6 +2129,7 @@ pub mod env {
 
 	/// Send an XCM program from the contract to the specified destination.
 	/// See [`pallet_contracts_uapi::HostFn::send_xcm`].
+	#[mutating]
 	fn xcm_send(
 		ctx: _,
 		memory: _,
@@ -2209,6 +2226,7 @@ pub mod env {
 	/// Replace the contract code at the specified address with new code.
 	/// See [`pallet_contracts_uapi::HostFn::set_code_hash`].
 	#[prefixed_alias]
+	#[mutating]
 	fn set_code_hash(ctx: _, memory: _, code_hash_ptr: u32) -> Result<ReturnErrorCode, TrapReason> {
 		ctx.charge_gas(RuntimeCosts::SetCodeHash)?;
 		let code_hash: CodeHash<<E as Ext>::T> =
@@ -2249,7 +2267,7 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::reentrance_count`].
 	#[unstable]
 	fn reentrance_count(ctx: _, memory: _) -> Result<u32, TrapReason> {
-		ctx.charge_gas(RuntimeCosts::ReentrantCount)?;
+		ctx.charge_gas(RuntimeCosts::ReentranceCount)?;
 		Ok(ctx.ext.reentrance_count())
 	}
 
@@ -2258,7 +2276,7 @@ pub mod env {
 	/// See [`pallet_contracts_uapi::HostFn::account_reentrance_count`].
 	#[unstable]
 	fn account_reentrance_count(ctx: _, memory: _, account_ptr: u32) -> Result<u32, TrapReason> {
-		ctx.charge_gas(RuntimeCosts::AccountEntranceCount)?;
+		ctx.charge_gas(RuntimeCosts::AccountReentranceCount)?;
 		let account_id: <<E as Ext>::T as frame_system::Config>::AccountId =
 			ctx.read_sandbox_memory_as(memory, account_ptr)?;
 		Ok(ctx.ext.account_reentrance_count(&account_id))
@@ -2273,6 +2291,7 @@ pub mod env {
 
 	/// Adds a new delegate dependency to the contract.
 	/// See [`pallet_contracts_uapi::HostFn::lock_delegate_dependency`].
+	#[mutating]
 	fn lock_delegate_dependency(ctx: _, memory: _, code_hash_ptr: u32) -> Result<(), TrapReason> {
 		ctx.charge_gas(RuntimeCosts::LockDelegateDependency)?;
 		let code_hash = ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
@@ -2282,6 +2301,7 @@ pub mod env {
 
 	/// Removes the delegate dependency from the contract.
 	/// see [`pallet_contracts_uapi::HostFn::unlock_delegate_dependency`].
+	#[mutating]
 	fn unlock_delegate_dependency(ctx: _, memory: _, code_hash_ptr: u32) -> Result<(), TrapReason> {
 		ctx.charge_gas(RuntimeCosts::UnlockDelegateDependency)?;
 		let code_hash = ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs
index 950476698cd1836d4a677b0f1c1f26c1e8284895..0404a9d3d8e5011c68c5cd86724287ddd678199d 100644
--- a/substrate/frame/contracts/src/weights.rs
+++ b/substrate/frame/contracts/src/weights.rs
@@ -18,9 +18,9 @@
 //! Autogenerated weights for `pallet_contracts`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
-//! DATE: 2024-05-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2024-06-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-1pho9goo-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
 
 // Executed Command:
@@ -72,65 +72,49 @@ pub trait WeightInfo {
 	fn upload_code_determinism_relaxed(c: u32, ) -> Weight;
 	fn remove_code() -> Weight;
 	fn set_code() -> Weight;
-	fn seal_caller(r: u32, ) -> Weight;
-	fn seal_is_contract(r: u32, ) -> Weight;
-	fn seal_code_hash(r: u32, ) -> Weight;
-	fn seal_own_code_hash(r: u32, ) -> Weight;
-	fn seal_caller_is_origin(r: u32, ) -> Weight;
-	fn seal_caller_is_root(r: u32, ) -> Weight;
-	fn seal_address(r: u32, ) -> Weight;
-	fn seal_gas_left(r: u32, ) -> Weight;
-	fn seal_balance(r: u32, ) -> Weight;
-	fn seal_value_transferred(r: u32, ) -> Weight;
-	fn seal_minimum_balance(r: u32, ) -> Weight;
-	fn seal_block_number(r: u32, ) -> Weight;
-	fn seal_now(r: u32, ) -> Weight;
-	fn seal_weight_to_fee(r: u32, ) -> Weight;
-	fn seal_input(r: u32, ) -> Weight;
-	fn seal_input_per_byte(n: u32, ) -> Weight;
-	fn seal_return(r: u32, ) -> Weight;
-	fn seal_return_per_byte(n: u32, ) -> Weight;
-	fn seal_terminate(r: u32, ) -> Weight;
-	fn seal_random(r: u32, ) -> Weight;
-	fn seal_deposit_event(r: u32, ) -> Weight;
-	fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight;
-	fn seal_debug_message(r: u32, ) -> Weight;
-	fn seal_debug_message_per_byte(i: u32, ) -> Weight;
-	fn seal_set_storage(r: u32, ) -> Weight;
-	fn seal_set_storage_per_new_byte(n: u32, ) -> Weight;
-	fn seal_set_storage_per_old_byte(n: u32, ) -> Weight;
-	fn seal_clear_storage(r: u32, ) -> Weight;
-	fn seal_clear_storage_per_byte(n: u32, ) -> Weight;
-	fn seal_get_storage(r: u32, ) -> Weight;
-	fn seal_get_storage_per_byte(n: u32, ) -> Weight;
-	fn seal_contains_storage(r: u32, ) -> Weight;
-	fn seal_contains_storage_per_byte(n: u32, ) -> Weight;
-	fn seal_take_storage(r: u32, ) -> Weight;
-	fn seal_take_storage_per_byte(n: u32, ) -> Weight;
-	fn seal_transfer(r: u32, ) -> Weight;
-	fn seal_call(r: u32, ) -> Weight;
-	fn seal_delegate_call(r: u32, ) -> Weight;
-	fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight;
-	fn seal_instantiate(r: u32, ) -> Weight;
-	fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight;
-	fn seal_hash_sha2_256(r: u32, ) -> Weight;
-	fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight;
-	fn seal_hash_keccak_256(r: u32, ) -> Weight;
-	fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight;
-	fn seal_hash_blake2_256(r: u32, ) -> Weight;
-	fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight;
-	fn seal_hash_blake2_128(r: u32, ) -> Weight;
-	fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight;
-	fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight;
-	fn seal_sr25519_verify(r: u32, ) -> Weight;
-	fn seal_ecdsa_recover(r: u32, ) -> Weight;
-	fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight;
-	fn seal_set_code_hash(r: u32, ) -> Weight;
-	fn lock_delegate_dependency(r: u32, ) -> Weight;
-	fn unlock_delegate_dependency(r: u32, ) -> Weight;
-	fn seal_reentrance_count(r: u32, ) -> Weight;
-	fn seal_account_reentrance_count(r: u32, ) -> Weight;
-	fn seal_instantiation_nonce(r: u32, ) -> Weight;
+	fn noop_host_fn(r: u32, ) -> Weight;
+	fn seal_caller() -> Weight;
+	fn seal_is_contract() -> Weight;
+	fn seal_code_hash() -> Weight;
+	fn seal_own_code_hash() -> Weight;
+	fn seal_caller_is_origin() -> Weight;
+	fn seal_caller_is_root() -> Weight;
+	fn seal_address() -> Weight;
+	fn seal_gas_left() -> Weight;
+	fn seal_balance() -> Weight;
+	fn seal_value_transferred() -> Weight;
+	fn seal_minimum_balance() -> Weight;
+	fn seal_block_number() -> Weight;
+	fn seal_now() -> Weight;
+	fn seal_weight_to_fee() -> Weight;
+	fn seal_input(n: u32, ) -> Weight;
+	fn seal_return(n: u32, ) -> Weight;
+	fn seal_terminate(n: u32, ) -> Weight;
+	fn seal_random() -> Weight;
+	fn seal_deposit_event(t: u32, n: u32, ) -> Weight;
+	fn seal_debug_message(i: u32, ) -> Weight;
+	fn seal_set_storage(n: u32, o: u32, ) -> Weight;
+	fn seal_clear_storage(n: u32, ) -> Weight;
+	fn seal_get_storage(n: u32, ) -> Weight;
+	fn seal_contains_storage(n: u32, ) -> Weight;
+	fn seal_take_storage(n: u32, ) -> Weight;
+	fn seal_transfer() -> Weight;
+	fn seal_call(t: u32, i: u32, ) -> Weight;
+	fn seal_delegate_call() -> Weight;
+	fn seal_instantiate(i: u32, s: u32, ) -> Weight;
+	fn seal_hash_sha2_256(n: u32, ) -> Weight;
+	fn seal_hash_keccak_256(n: u32, ) -> Weight;
+	fn seal_hash_blake2_256(n: u32, ) -> Weight;
+	fn seal_hash_blake2_128(n: u32, ) -> Weight;
+	fn seal_sr25519_verify(n: u32, ) -> Weight;
+	fn seal_ecdsa_recover() -> Weight;
+	fn seal_ecdsa_to_eth_address() -> Weight;
+	fn seal_set_code_hash() -> Weight;
+	fn lock_delegate_dependency() -> Weight;
+	fn unlock_delegate_dependency() -> Weight;
+	fn seal_reentrance_count() -> Weight;
+	fn seal_account_reentrance_count() -> Weight;
+	fn seal_instantiation_nonce() -> Weight;
 	fn instr_i64_load_store(r: u32, ) -> Weight;
 }
 
@@ -143,8 +127,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `1627`
-		// Minimum execution time: 2_002_000 picoseconds.
-		Weight::from_parts(2_193_000, 1627)
+		// Minimum execution time: 1_896_000 picoseconds.
+		Weight::from_parts(1_990_000, 1627)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -154,10 +138,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `452 + k * (69 ±0)`
 		//  Estimated: `442 + k * (70 ±0)`
-		// Minimum execution time: 12_339_000 picoseconds.
-		Weight::from_parts(12_682_000, 442)
-			// Standard Error: 1_302
-			.saturating_add(Weight::from_parts(1_163_234, 0).saturating_mul(k.into()))
+		// Minimum execution time: 11_142_000 picoseconds.
+		Weight::from_parts(11_578_000, 442)
+			// Standard Error: 1_557
+			.saturating_add(Weight::from_parts(1_165_198, 0).saturating_mul(k.into()))
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into())))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
@@ -171,10 +155,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `211 + c * (1 ±0)`
 		//  Estimated: `6149 + c * (1 ±0)`
-		// Minimum execution time: 8_145_000 picoseconds.
-		Weight::from_parts(8_747_247, 6149)
-			// Standard Error: 1
-			.saturating_add(Weight::from_parts(1_154, 0).saturating_mul(c.into()))
+		// Minimum execution time: 7_649_000 picoseconds.
+		Weight::from_parts(4_827_445, 6149)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(1_630, 0).saturating_mul(c.into()))
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
@@ -187,8 +171,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `510`
 		//  Estimated: `6450`
-		// Minimum execution time: 16_950_000 picoseconds.
-		Weight::from_parts(17_498_000, 6450)
+		// Minimum execution time: 16_096_000 picoseconds.
+		Weight::from_parts(16_937_000, 6450)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -201,10 +185,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `171 + k * (1 ±0)`
 		//  Estimated: `3635 + k * (1 ±0)`
-		// Minimum execution time: 3_431_000 picoseconds.
-		Weight::from_parts(2_161_027, 3635)
-			// Standard Error: 949
-			.saturating_add(Weight::from_parts(1_219_406, 0).saturating_mul(k.into()))
+		// Minimum execution time: 3_131_000 picoseconds.
+		Weight::from_parts(3_209_000, 3635)
+			// Standard Error: 481
+			.saturating_add(Weight::from_parts(1_087_506, 0).saturating_mul(k.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into())))
@@ -223,10 +207,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `325 + c * (1 ±0)`
 		//  Estimated: `6263 + c * (1 ±0)`
-		// Minimum execution time: 16_384_000 picoseconds.
-		Weight::from_parts(16_741_331, 6263)
+		// Minimum execution time: 15_289_000 picoseconds.
+		Weight::from_parts(16_157_168, 6263)
 			// Standard Error: 1
-			.saturating_add(Weight::from_parts(375, 0).saturating_mul(c.into()))
+			.saturating_add(Weight::from_parts(395, 0).saturating_mul(c.into()))
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
@@ -237,8 +221,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `440`
 		//  Estimated: `6380`
-		// Minimum execution time: 12_529_000 picoseconds.
-		Weight::from_parts(13_319_000, 6380)
+		// Minimum execution time: 12_312_000 picoseconds.
+		Weight::from_parts(12_650_000, 6380)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -252,8 +236,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `352`
 		//  Estimated: `6292`
-		// Minimum execution time: 47_462_000 picoseconds.
-		Weight::from_parts(48_784_000, 6292)
+		// Minimum execution time: 47_239_000 picoseconds.
+		Weight::from_parts(48_617_000, 6292)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -265,8 +249,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `594`
 		//  Estimated: `6534`
-		// Minimum execution time: 55_712_000 picoseconds.
-		Weight::from_parts(58_629_000, 6534)
+		// Minimum execution time: 52_084_000 picoseconds.
+		Weight::from_parts(53_838_000, 6534)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -276,8 +260,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `409`
 		//  Estimated: `6349`
-		// Minimum execution time: 11_992_000 picoseconds.
-		Weight::from_parts(12_686_000, 6349)
+		// Minimum execution time: 11_785_000 picoseconds.
+		Weight::from_parts(12_284_000, 6349)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -287,8 +271,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `1627`
-		// Minimum execution time: 2_498_000 picoseconds.
-		Weight::from_parts(2_594_000, 1627)
+		// Minimum execution time: 2_136_000 picoseconds.
+		Weight::from_parts(2_233_000, 1627)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -300,8 +284,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `166`
 		//  Estimated: `3631`
-		// Minimum execution time: 12_179_000 picoseconds.
-		Weight::from_parts(12_805_000, 3631)
+		// Minimum execution time: 10_957_000 picoseconds.
+		Weight::from_parts(11_314_000, 3631)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -311,8 +295,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 4_695_000 picoseconds.
-		Weight::from_parts(5_105_000, 3607)
+		// Minimum execution time: 4_354_000 picoseconds.
+		Weight::from_parts(4_613_000, 3607)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
 	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
@@ -323,8 +307,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `167`
 		//  Estimated: `3632`
-		// Minimum execution time: 6_223_000 picoseconds.
-		Weight::from_parts(6_509_000, 3632)
+		// Minimum execution time: 5_541_000 picoseconds.
+		Weight::from_parts(5_790_000, 3632)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 	}
 	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
@@ -335,8 +319,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 6_073_000 picoseconds.
-		Weight::from_parts(6_524_000, 3607)
+		// Minimum execution time: 5_502_000 picoseconds.
+		Weight::from_parts(5_701_000, 3607)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -352,19 +336,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `c` is `[0, 125952]`.
 	fn call_with_code_per_byte(c: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `801 + c * (1 ±0)`
-		//  Estimated: `6739 + c * (1 ±0)`
-		// Minimum execution time: 289_627_000 picoseconds.
-		Weight::from_parts(281_167_857, 6739)
-			// Standard Error: 68
-			.saturating_add(Weight::from_parts(33_442, 0).saturating_mul(c.into()))
-			.saturating_add(T::DbWeight::get().reads(8_u64))
-			.saturating_add(T::DbWeight::get().writes(4_u64))
+		//  Estimated: `4264 + c * (1 ±0)`
+		// Minimum execution time: 247_884_000 picoseconds.
+		Weight::from_parts(265_795_781, 4264)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(724, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
@@ -373,8 +355,6 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:2 w:2)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:3 w:3)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::Nonce` (r:1 w:1)
 	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
@@ -391,17 +371,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `323`
-		//  Estimated: `8737`
-		// Minimum execution time: 3_829_638_000 picoseconds.
-		Weight::from_parts(744_994_885, 8737)
-			// Standard Error: 165
-			.saturating_add(Weight::from_parts(68_083, 0).saturating_mul(c.into()))
-			// Standard Error: 19
-			.saturating_add(Weight::from_parts(1_484, 0).saturating_mul(i.into()))
-			// Standard Error: 19
-			.saturating_add(Weight::from_parts(1_581, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(11_u64))
-			.saturating_add(T::DbWeight::get().writes(10_u64))
+		//  Estimated: `6262`
+		// Minimum execution time: 4_500_184_000 picoseconds.
+		Weight::from_parts(160_729_258, 6262)
+			// Standard Error: 143
+			.saturating_add(Weight::from_parts(52_809, 0).saturating_mul(c.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(2_173, 0).saturating_mul(i.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(2_165, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -417,8 +397,6 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
 	/// The range of component `i` is `[0, 1048576]`.
@@ -426,15 +404,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	fn instantiate(i: u32, s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `560`
-		//  Estimated: `6504`
-		// Minimum execution time: 1_960_218_000 picoseconds.
-		Weight::from_parts(1_976_273_000, 6504)
-			// Standard Error: 25
-			.saturating_add(Weight::from_parts(866, 0).saturating_mul(i.into()))
-			// Standard Error: 25
-			.saturating_add(Weight::from_parts(824, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(10_u64))
-			.saturating_add(T::DbWeight::get().writes(7_u64))
+		//  Estimated: `4029`
+		// Minimum execution time: 2_219_163_000 picoseconds.
+		Weight::from_parts(2_236_918_000, 4029)
+			// Standard Error: 32
+			.saturating_add(Weight::from_parts(937, 0).saturating_mul(i.into()))
+			// Standard Error: 32
+			.saturating_add(Weight::from_parts(938, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -448,16 +426,14 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	fn call() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `826`
-		//  Estimated: `6766`
-		// Minimum execution time: 200_542_000 picoseconds.
-		Weight::from_parts(209_713_000, 6766)
-			.saturating_add(T::DbWeight::get().reads(8_u64))
-			.saturating_add(T::DbWeight::get().writes(4_u64))
+		//  Estimated: `4291`
+		// Minimum execution time: 164_801_000 picoseconds.
+		Weight::from_parts(167_250_000, 4291)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -465,8 +441,6 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1 w:1)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:0 w:1)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	/// The range of component `c` is `[0, 125952]`.
@@ -474,12 +448,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 258_375_000 picoseconds.
-		Weight::from_parts(271_214_455, 3607)
-			// Standard Error: 61
-			.saturating_add(Weight::from_parts(32_587, 0).saturating_mul(c.into()))
-			.saturating_add(T::DbWeight::get().reads(4_u64))
-			.saturating_add(T::DbWeight::get().writes(4_u64))
+		// Minimum execution time: 225_207_000 picoseconds.
+		Weight::from_parts(263_665_658, 3607)
+			// Standard Error: 47
+			.saturating_add(Weight::from_parts(50_732, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -487,8 +461,6 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1 w:1)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:0 w:1)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	/// The range of component `c` is `[0, 125952]`.
@@ -496,12 +468,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 279_363_000 picoseconds.
-		Weight::from_parts(257_721_413, 3607)
-			// Standard Error: 81
-			.saturating_add(Weight::from_parts(33_850, 0).saturating_mul(c.into()))
-			.saturating_add(T::DbWeight::get().reads(4_u64))
-			.saturating_add(T::DbWeight::get().writes(4_u64))
+		// Minimum execution time: 230_718_000 picoseconds.
+		Weight::from_parts(258_359_271, 3607)
+			// Standard Error: 47
+			.saturating_add(Weight::from_parts(51_014, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -509,18 +481,16 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1 w:1)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:0 w:1)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	fn remove_code() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `315`
 		//  Estimated: `3780`
-		// Minimum execution time: 45_096_000 picoseconds.
-		Weight::from_parts(46_661_000, 3780)
-			.saturating_add(T::DbWeight::get().reads(4_u64))
-			.saturating_add(T::DbWeight::get().writes(4_u64))
+		// Minimum execution time: 39_668_000 picoseconds.
+		Weight::from_parts(41_031_000, 3780)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -528,598 +498,331 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
 	/// Storage: `Contracts::CodeInfoOf` (r:2 w:2)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:3 w:3)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	fn set_code() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `552`
-		//  Estimated: `8967`
-		// Minimum execution time: 34_260_000 picoseconds.
-		Weight::from_parts(35_761_000, 8967)
-			.saturating_add(T::DbWeight::get().reads(7_u64))
-			.saturating_add(T::DbWeight::get().writes(6_u64))
+		//  Estimated: `6492`
+		// Minimum execution time: 25_890_000 picoseconds.
+		Weight::from_parts(26_603_000, 6492)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
 	/// The range of component `r` is `[0, 1600]`.
-	fn seal_caller(r: u32, ) -> Weight {
+	fn noop_host_fn(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_269_000 picoseconds.
+		Weight::from_parts(9_227_069, 0)
+			// Standard Error: 74
+			.saturating_add(Weight::from_parts(51_396, 0).saturating_mul(r.into()))
+	}
+	fn seal_caller() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_265_000 picoseconds.
-		Weight::from_parts(10_174_088, 0)
-			// Standard Error: 275
-			.saturating_add(Weight::from_parts(271_791, 0).saturating_mul(r.into()))
+		// Minimum execution time: 602_000 picoseconds.
+		Weight::from_parts(664_000, 0)
 	}
-	/// Storage: `Contracts::ContractInfoOf` (r:1600 w:0)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_is_contract(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `509 + r * (77 ±0)`
-		//  Estimated: `1467 + r * (2552 ±0)`
-		// Minimum execution time: 10_498_000 picoseconds.
-		Weight::from_parts(10_551_000, 1467)
-			// Standard Error: 5_538
-			.saturating_add(Weight::from_parts(3_269_462, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2552).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::ContractInfoOf` (r:1600 w:0)
+	fn seal_is_contract() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `354`
+		//  Estimated: `3819`
+		// Minimum execution time: 6_131_000 picoseconds.
+		Weight::from_parts(6_468_000, 3819)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_code_hash(r: u32, ) -> Weight {
+	fn seal_code_hash() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `517 + r * (170 ±0)`
-		//  Estimated: `1468 + r * (2645 ±0)`
-		// Minimum execution time: 10_289_000 picoseconds.
-		Weight::from_parts(10_469_000, 1468)
-			// Standard Error: 5_674
-			.saturating_add(Weight::from_parts(4_105_274, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2645).saturating_mul(r.into()))
+		//  Measured:  `447`
+		//  Estimated: `3912`
+		// Minimum execution time: 7_557_000 picoseconds.
+		Weight::from_parts(7_704_000, 3912)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_own_code_hash(r: u32, ) -> Weight {
+	fn seal_own_code_hash() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_769_000 picoseconds.
-		Weight::from_parts(10_389_944, 0)
-			// Standard Error: 240
-			.saturating_add(Weight::from_parts(350_466, 0).saturating_mul(r.into()))
+		// Minimum execution time: 783_000 picoseconds.
+		Weight::from_parts(848_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_caller_is_origin(r: u32, ) -> Weight {
+	fn seal_caller_is_origin() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_443_000 picoseconds.
-		Weight::from_parts(11_651_820, 0)
-			// Standard Error: 91
-			.saturating_add(Weight::from_parts(100_579, 0).saturating_mul(r.into()))
+		// Minimum execution time: 397_000 picoseconds.
+		Weight::from_parts(435_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_caller_is_root(r: u32, ) -> Weight {
+	fn seal_caller_is_root() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_474_000 picoseconds.
-		Weight::from_parts(11_313_654, 0)
-			// Standard Error: 103
-			.saturating_add(Weight::from_parts(85_902, 0).saturating_mul(r.into()))
+		// Minimum execution time: 351_000 picoseconds.
+		Weight::from_parts(372_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_address(r: u32, ) -> Weight {
+	fn seal_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_360_000 picoseconds.
-		Weight::from_parts(11_283_384, 0)
-			// Standard Error: 163
-			.saturating_add(Weight::from_parts(253_111, 0).saturating_mul(r.into()))
+		// Minimum execution time: 608_000 picoseconds.
+		Weight::from_parts(645_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_gas_left(r: u32, ) -> Weight {
+	fn seal_gas_left() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_289_000 picoseconds.
-		Weight::from_parts(10_747_872, 0)
-			// Standard Error: 197
-			.saturating_add(Weight::from_parts(299_097, 0).saturating_mul(r.into()))
+		// Minimum execution time: 661_000 picoseconds.
+		Weight::from_parts(729_000, 0)
 	}
-	/// Storage: `System::Account` (r:1 w:0)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_balance(r: u32, ) -> Weight {
+	fn seal_balance() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `140`
-		//  Estimated: `3599`
-		// Minimum execution time: 10_368_000 picoseconds.
-		Weight::from_parts(29_685_372, 3599)
-			// Standard Error: 1_202
-			.saturating_add(Weight::from_parts(1_517_645, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		//  Estimated: `0`
+		// Minimum execution time: 4_545_000 picoseconds.
+		Weight::from_parts(4_663_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_value_transferred(r: u32, ) -> Weight {
+	fn seal_value_transferred() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_528_000 picoseconds.
-		Weight::from_parts(11_653_603, 0)
-			// Standard Error: 203
-			.saturating_add(Weight::from_parts(241_937, 0).saturating_mul(r.into()))
+		// Minimum execution time: 614_000 picoseconds.
+		Weight::from_parts(641_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_minimum_balance(r: u32, ) -> Weight {
+	fn seal_minimum_balance() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_385_000 picoseconds.
-		Weight::from_parts(11_483_212, 0)
-			// Standard Error: 227
-			.saturating_add(Weight::from_parts(248_076, 0).saturating_mul(r.into()))
+		// Minimum execution time: 583_000 picoseconds.
+		Weight::from_parts(618_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_block_number(r: u32, ) -> Weight {
+	fn seal_block_number() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_341_000 picoseconds.
-		Weight::from_parts(12_055_382, 0)
-			// Standard Error: 1_231
-			.saturating_add(Weight::from_parts(249_662, 0).saturating_mul(r.into()))
+		// Minimum execution time: 583_000 picoseconds.
+		Weight::from_parts(617_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_now(r: u32, ) -> Weight {
+	fn seal_now() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_467_000 picoseconds.
-		Weight::from_parts(10_579_667, 0)
-			// Standard Error: 247
-			.saturating_add(Weight::from_parts(246_711, 0).saturating_mul(r.into()))
+		// Minimum execution time: 607_000 picoseconds.
+		Weight::from_parts(638_000, 0)
 	}
 	/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
 	/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_weight_to_fee(r: u32, ) -> Weight {
+	fn seal_weight_to_fee() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `67`
 		//  Estimated: `1552`
-		// Minimum execution time: 10_293_000 picoseconds.
-		Weight::from_parts(18_229_738, 1552)
-			// Standard Error: 452
-			.saturating_add(Weight::from_parts(655_277, 0).saturating_mul(r.into()))
+		// Minimum execution time: 4_172_000 picoseconds.
+		Weight::from_parts(4_408_000, 1552)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_input(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_355_000 picoseconds.
-		Weight::from_parts(11_641_920, 0)
-			// Standard Error: 166
-			.saturating_add(Weight::from_parts(168_271, 0).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
-	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
-	/// Storage: `System::Account` (r:1 w:0)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Timestamp::Now` (r:1 w:0)
-	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_input_per_byte(n: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `869`
-		//  Estimated: `6809`
-		// Minimum execution time: 268_424_000 picoseconds.
-		Weight::from_parts(136_261_773, 6809)
-			// Standard Error: 16
-			.saturating_add(Weight::from_parts(1_373, 0).saturating_mul(n.into()))
-			.saturating_add(T::DbWeight::get().reads(8_u64))
-			.saturating_add(T::DbWeight::get().writes(3_u64))
-	}
-	/// The range of component `r` is `[0, 1]`.
-	fn seal_return(r: u32, ) -> Weight {
+	/// The range of component `n` is `[0, 1048572]`.
+	fn seal_input(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_044_000 picoseconds.
-		Weight::from_parts(10_550_491, 0)
-			// Standard Error: 20_456
-			.saturating_add(Weight::from_parts(925_808, 0).saturating_mul(r.into()))
+		// Minimum execution time: 475_000 picoseconds.
+		Weight::from_parts(515_000, 0)
+			// Standard Error: 3
+			.saturating_add(Weight::from_parts(298, 0).saturating_mul(n.into()))
 	}
-	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_return_per_byte(n: u32, ) -> Weight {
+	/// The range of component `n` is `[0, 1048572]`.
+	fn seal_return(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_361_000 picoseconds.
-		Weight::from_parts(11_935_556, 0)
-			// Standard Error: 0
-			.saturating_add(Weight::from_parts(315, 0).saturating_mul(n.into()))
+		// Minimum execution time: 289_000 picoseconds.
+		Weight::from_parts(357_000, 0)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(405, 0).saturating_mul(n.into()))
 	}
-	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
-	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
-	/// Storage: `System::Account` (r:3 w:3)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `Contracts::CodeInfoOf` (r:33 w:33)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Timestamp::Now` (r:1 w:0)
-	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1)
 	/// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:4 w:4)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:33 w:33)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Contracts::DeletionQueue` (r:0 w:1)
 	/// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`)
-	/// The range of component `r` is `[0, 1]`.
-	fn seal_terminate(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `4802 + r * (2121 ±0)`
-		//  Estimated: `10742 + r * (81321 ±0)`
-		// Minimum execution time: 293_793_000 picoseconds.
-		Weight::from_parts(314_285_185, 10742)
-			// Standard Error: 808_383
-			.saturating_add(Weight::from_parts(256_215_014, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads(8_u64))
-			.saturating_add(T::DbWeight::get().reads((38_u64).saturating_mul(r.into())))
+	/// The range of component `n` is `[0, 32]`.
+	fn seal_terminate(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `319 + n * (78 ±0)`
+		//  Estimated: `3784 + n * (2553 ±0)`
+		// Minimum execution time: 13_316_000 picoseconds.
+		Weight::from_parts(15_855_821, 3784)
+			// Standard Error: 7_274
+			.saturating_add(Weight::from_parts(3_447_246, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
-			.saturating_add(T::DbWeight::get().writes((41_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 81321).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2553).saturating_mul(n.into()))
 	}
 	/// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0)
 	/// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_random(r: u32, ) -> Weight {
+	fn seal_random() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `76`
 		//  Estimated: `1561`
-		// Minimum execution time: 10_323_000 picoseconds.
-		Weight::from_parts(10_996_645, 1561)
-			// Standard Error: 566
-			.saturating_add(Weight::from_parts(1_133_870, 0).saturating_mul(r.into()))
+		// Minimum execution time: 3_468_000 picoseconds.
+		Weight::from_parts(3_608_000, 1561)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_deposit_event(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_122_000 picoseconds.
-		Weight::from_parts(17_368_451, 0)
-			// Standard Error: 679
-			.saturating_add(Weight::from_parts(1_660_129, 0).saturating_mul(r.into()))
-	}
 	/// Storage: `System::EventTopics` (r:4 w:4)
 	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `t` is `[0, 4]`.
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight {
+	fn seal_deposit_event(t: u32, n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `990 + t * (2475 ±0)`
-		// Minimum execution time: 24_515_000 picoseconds.
-		Weight::from_parts(16_807_493, 990)
-			// Standard Error: 13_923
-			.saturating_add(Weight::from_parts(2_315_122, 0).saturating_mul(t.into()))
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(573, 0).saturating_mul(n.into()))
+		// Minimum execution time: 3_777_000 picoseconds.
+		Weight::from_parts(4_028_191, 990)
+			// Standard Error: 5_907
+			.saturating_add(Weight::from_parts(2_183_733, 0).saturating_mul(t.into()))
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(18, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into())))
 			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into())))
 			.saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into()))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_debug_message(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 9_596_000 picoseconds.
-		Weight::from_parts(9_113_960, 0)
-			// Standard Error: 139
-			.saturating_add(Weight::from_parts(112_197, 0).saturating_mul(r.into()))
-	}
 	/// The range of component `i` is `[0, 1048576]`.
-	fn seal_debug_message_per_byte(i: u32, ) -> Weight {
+	fn seal_debug_message(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_260_000 picoseconds.
-		Weight::from_parts(11_341_000, 0)
-			// Standard Error: 8
-			.saturating_add(Weight::from_parts(984, 0).saturating_mul(i.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_set_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_660_000 picoseconds.
-		Weight::from_parts(10_762_000, 105)
-			// Standard Error: 7_920
-			.saturating_add(Weight::from_parts(5_122_380, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
+		// Minimum execution time: 400_000 picoseconds.
+		Weight::from_parts(423_000, 0)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(1_209, 0).saturating_mul(i.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_set_storage_per_new_byte(n: u32, ) -> Weight {
+	/// The range of component `o` is `[0, 16384]`.
+	fn seal_set_storage(n: u32, o: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `245`
-		//  Estimated: `245`
-		// Minimum execution time: 19_446_000 picoseconds.
-		Weight::from_parts(20_166_940, 245)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(287, 0).saturating_mul(n.into()))
+		//  Measured:  `250 + o * (1 ±0)`
+		//  Estimated: `249 + o * (1 ±0)`
+		// Minimum execution time: 9_033_000 picoseconds.
+		Weight::from_parts(8_797_934, 249)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(257, 0).saturating_mul(n.into()))
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(51, 0).saturating_mul(o.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_set_storage_per_old_byte(n: u32, ) -> Weight {
+	fn seal_clear_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 19_249_000 picoseconds.
-		Weight::from_parts(20_875_560, 248)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(73, 0).saturating_mul(n.into()))
+		// Minimum execution time: 7_167_000 picoseconds.
+		Weight::from_parts(8_012_194, 248)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(90, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_clear_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_477_000 picoseconds.
-		Weight::from_parts(10_633_000, 105)
-			// Standard Error: 8_552
-			.saturating_add(Weight::from_parts(5_159_505, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_clear_storage_per_byte(n: u32, ) -> Weight {
+	fn seal_get_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 19_265_000 picoseconds.
-		Weight::from_parts(20_699_861, 248)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into()))
+		// Minimum execution time: 6_868_000 picoseconds.
+		Weight::from_parts(7_801_811, 248)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(605, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
-			.saturating_add(T::DbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_get_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_336_000 picoseconds.
-		Weight::from_parts(10_466_000, 105)
-			// Standard Error: 7_699
-			.saturating_add(Weight::from_parts(4_542_224, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_get_storage_per_byte(n: u32, ) -> Weight {
+	fn seal_contains_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 18_513_000 picoseconds.
-		Weight::from_parts(20_357_236, 248)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(588, 0).saturating_mul(n.into()))
+		// Minimum execution time: 6_322_000 picoseconds.
+		Weight::from_parts(7_103_552, 248)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(79, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_contains_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_432_000 picoseconds.
-		Weight::from_parts(10_658_000, 105)
-			// Standard Error: 7_129
-			.saturating_add(Weight::from_parts(4_423_298, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_contains_storage_per_byte(n: u32, ) -> Weight {
+	fn seal_take_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 17_663_000 picoseconds.
-		Weight::from_parts(19_107_828, 248)
+		// Minimum execution time: 7_702_000 picoseconds.
+		Weight::from_parts(8_746_305, 248)
 			// Standard Error: 2
-			.saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
-			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_take_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_254_000 picoseconds.
-		Weight::from_parts(10_332_000, 105)
-			// Standard Error: 9_485
-			.saturating_add(Weight::from_parts(5_242_433, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `n` is `[0, 16384]`.
-	fn seal_take_storage_per_byte(n: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `248 + n * (1 ±0)`
-		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 19_410_000 picoseconds.
-		Weight::from_parts(21_347_311, 248)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(607, 0).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(604, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
-	/// Storage: `System::Account` (r:1601 w:1601)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_transfer(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `770`
-		//  Estimated: `4221 + r * (2475 ±0)`
-		// Minimum execution time: 10_365_000 picoseconds.
-		Weight::from_parts(10_514_000, 4221)
-			// Standard Error: 18_360
-			.saturating_add(Weight::from_parts(33_433_850, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes(1_u64))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2475).saturating_mul(r.into()))
+	fn seal_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `140`
+		//  Estimated: `0`
+		// Minimum execution time: 8_851_000 picoseconds.
+		Weight::from_parts(9_083_000, 0)
 	}
-	/// Storage: `Contracts::ContractInfoOf` (r:800 w:801)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
 	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:1 w:0)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:801 w:801)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_call(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `517 + r * (170 ±0)`
-		//  Estimated: `3985 + r * (2646 ±0)`
-		// Minimum execution time: 10_332_000 picoseconds.
-		Weight::from_parts(10_424_000, 3985)
-			// Standard Error: 117_754
-			.saturating_add(Weight::from_parts(242_191_645, 0).saturating_mul(r.into()))
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// The range of component `t` is `[0, 1]`.
+	/// The range of component `i` is `[0, 1048576]`.
+	fn seal_call(t: u32, i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `620 + t * (280 ±0)`
+		//  Estimated: `4085 + t * (2182 ±0)`
+		// Minimum execution time: 121_148_000 picoseconds.
+		Weight::from_parts(119_605_377, 4085)
+			// Standard Error: 208_337
+			.saturating_add(Weight::from_parts(43_153_338, 0).saturating_mul(t.into()))
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(5, 0).saturating_mul(i.into()))
 			.saturating_add(T::DbWeight::get().reads(3_u64))
-			.saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes(2_u64))
-			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2646).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 2182).saturating_mul(t.into()))
 	}
-	/// Storage: `Contracts::CodeInfoOf` (r:735 w:0)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:735 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:736 w:736)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:0 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_delegate_call(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0 + r * (527 ±0)`
-		//  Estimated: `6444 + r * (2583 ±10)`
-		// Minimum execution time: 10_550_000 picoseconds.
-		Weight::from_parts(10_667_000, 6444)
-			// Standard Error: 147_918
-			.saturating_add(Weight::from_parts(242_824_174, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2583).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:2)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
 	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:1 w:0)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::Account` (r:2 w:2)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `t` is `[0, 1]`.
-	/// The range of component `c` is `[0, 1048576]`.
-	fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `696 + t * (277 ±0)`
-		//  Estimated: `6636 + t * (3457 ±0)`
-		// Minimum execution time: 213_206_000 picoseconds.
-		Weight::from_parts(120_511_970, 6636)
-			// Standard Error: 2_501_856
-			.saturating_add(Weight::from_parts(40_016_645, 0).saturating_mul(t.into()))
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(420, 0).saturating_mul(c.into()))
-			.saturating_add(T::DbWeight::get().reads(5_u64))
-			.saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into())))
-			.saturating_add(T::DbWeight::get().writes(4_u64))
-			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(t.into())))
-			.saturating_add(Weight::from_parts(0, 3457).saturating_mul(t.into()))
-	}
-	/// Storage: `Contracts::CodeInfoOf` (r:800 w:800)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:800 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Contracts::Nonce` (r:1 w:0)
-	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:800 w:801)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `System::Account` (r:802 w:802)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:801 w:801)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[1, 800]`.
-	fn seal_instantiate(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `1094 + r * (188 ±0)`
-		//  Estimated: `6987 + r * (2664 ±0)`
-		// Minimum execution time: 334_708_000 picoseconds.
-		Weight::from_parts(346_676_000, 6987)
-			// Standard Error: 236_074
-			.saturating_add(Weight::from_parts(330_734_734, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads(4_u64))
-			.saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes(4_u64))
-			.saturating_add(T::DbWeight::get().writes((4_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2664).saturating_mul(r.into()))
+	fn seal_delegate_call() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `430`
+		//  Estimated: `3895`
+		// Minimum execution time: 108_159_000 picoseconds.
+		Weight::from_parts(110_027_000, 3895)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 	}
 	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
@@ -1127,261 +830,157 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	/// Storage: `Contracts::Nonce` (r:1 w:0)
 	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:2)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `System::Account` (r:3 w:3)
+	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `t` is `[0, 1]`.
 	/// The range of component `i` is `[0, 983040]`.
 	/// The range of component `s` is `[0, 983040]`.
-	fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `757 + t * (104 ±0)`
-		//  Estimated: `6716 + t * (2549 ±1)`
-		// Minimum execution time: 1_854_462_000 picoseconds.
-		Weight::from_parts(855_253_052, 6716)
-			// Standard Error: 13_502_046
-			.saturating_add(Weight::from_parts(20_015_409, 0).saturating_mul(t.into()))
-			// Standard Error: 21
-			.saturating_add(Weight::from_parts(1_060, 0).saturating_mul(i.into()))
-			// Standard Error: 21
-			.saturating_add(Weight::from_parts(1_201, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(8_u64))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into())))
-			.saturating_add(T::DbWeight::get().writes(7_u64))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into())))
-			.saturating_add(Weight::from_parts(0, 2549).saturating_mul(t.into()))
+	fn seal_instantiate(i: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `676`
+		//  Estimated: `4127`
+		// Minimum execution time: 1_861_874_000 picoseconds.
+		Weight::from_parts(1_872_926_000, 4127)
+			// Standard Error: 23
+			.saturating_add(Weight::from_parts(557, 0).saturating_mul(i.into()))
+			// Standard Error: 23
+			.saturating_add(Weight::from_parts(920, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_sha2_256(r: u32, ) -> Weight {
+	/// The range of component `n` is `[0, 1048576]`.
+	fn seal_hash_sha2_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_384_000 picoseconds.
-		Weight::from_parts(10_319_961, 0)
-			// Standard Error: 293
-			.saturating_add(Weight::from_parts(267_788, 0).saturating_mul(r.into()))
+		// Minimum execution time: 878_000 picoseconds.
+		Weight::from_parts(10_993_950, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_325, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight {
+	fn seal_hash_keccak_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_991_000 picoseconds.
-		Weight::from_parts(792_256, 0)
-			// Standard Error: 1
-			.saturating_add(Weight::from_parts(1_071, 0).saturating_mul(n.into()))
+		// Minimum execution time: 1_261_000 picoseconds.
+		Weight::from_parts(9_759_497, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(3_594, 0).saturating_mul(n.into()))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_keccak_256(r: u32, ) -> Weight {
+	/// The range of component `n` is `[0, 1048576]`.
+	fn seal_hash_blake2_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_210_000 picoseconds.
-		Weight::from_parts(8_251_750, 0)
-			// Standard Error: 584
-			.saturating_add(Weight::from_parts(662_961, 0).saturating_mul(r.into()))
+		// Minimum execution time: 726_000 picoseconds.
+		Weight::from_parts(9_795_728, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_455, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight {
+	fn seal_hash_blake2_128(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_994_000 picoseconds.
-		Weight::from_parts(6_532_799, 0)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(3_351, 0).saturating_mul(n.into()))
+		// Minimum execution time: 739_000 picoseconds.
+		Weight::from_parts(9_701_202, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_459, 0).saturating_mul(n.into()))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_blake2_256(r: u32, ) -> Weight {
+	/// The range of component `n` is `[0, 125697]`.
+	fn seal_sr25519_verify(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_209_000 picoseconds.
-		Weight::from_parts(10_895_450, 0)
-			// Standard Error: 195
-			.saturating_add(Weight::from_parts(328_195, 0).saturating_mul(r.into()))
+		// Minimum execution time: 43_309_000 picoseconds.
+		Weight::from_parts(41_405_949, 0)
+			// Standard Error: 8
+			.saturating_add(Weight::from_parts(5_336, 0).saturating_mul(n.into()))
 	}
-	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight {
+	fn seal_ecdsa_recover() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_493_000 picoseconds.
-		Weight::from_parts(4_721_812, 0)
-			// Standard Error: 0
-			.saturating_add(Weight::from_parts(1_195, 0).saturating_mul(n.into()))
+		// Minimum execution time: 47_880_000 picoseconds.
+		Weight::from_parts(49_025_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_blake2_128(r: u32, ) -> Weight {
+	fn seal_ecdsa_to_eth_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_134_000 picoseconds.
-		Weight::from_parts(11_712_472, 0)
-			// Standard Error: 316
-			.saturating_add(Weight::from_parts(335_912, 0).saturating_mul(r.into()))
+		// Minimum execution time: 13_462_000 picoseconds.
+		Weight::from_parts(13_631_000, 0)
 	}
-	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight {
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:1 w:0)
+	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
+	fn seal_set_code_hash() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 11_448_000 picoseconds.
-		Weight::from_parts(1_407_440, 0)
-			// Standard Error: 1
-			.saturating_add(Weight::from_parts(1_205, 0).saturating_mul(n.into()))
+		//  Measured:  `430`
+		//  Estimated: `3895`
+		// Minimum execution time: 17_978_000 picoseconds.
+		Weight::from_parts(18_578_000, 3895)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// The range of component `n` is `[0, 125697]`.
-	fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight {
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	fn lock_delegate_dependency() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 54_644_000 picoseconds.
-		Weight::from_parts(55_793_413, 0)
-			// Standard Error: 11
-			.saturating_add(Weight::from_parts(4_511, 0).saturating_mul(n.into()))
+		//  Measured:  `355`
+		//  Estimated: `3820`
+		// Minimum execution time: 8_384_000 picoseconds.
+		Weight::from_parts(8_687_000, 3820)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`)
+	fn unlock_delegate_dependency() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `355`
+		//  Estimated: `3558`
+		// Minimum execution time: 7_547_000 picoseconds.
+		Weight::from_parts(7_935_000, 3558)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// The range of component `r` is `[0, 160]`.
-	fn seal_sr25519_verify(r: u32, ) -> Weight {
+	fn seal_reentrance_count() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_378_000 picoseconds.
-		Weight::from_parts(25_185_485, 0)
-			// Standard Error: 8_828
-			.saturating_add(Weight::from_parts(41_091_818, 0).saturating_mul(r.into()))
+		// Minimum execution time: 331_000 picoseconds.
+		Weight::from_parts(363_000, 0)
 	}
-	/// The range of component `r` is `[0, 160]`.
-	fn seal_ecdsa_recover(r: u32, ) -> Weight {
+	fn seal_account_reentrance_count() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_371_000 picoseconds.
-		Weight::from_parts(35_350_533, 0)
-			// Standard Error: 9_805
-			.saturating_add(Weight::from_parts(45_466_060, 0).saturating_mul(r.into()))
+		// Minimum execution time: 349_000 picoseconds.
+		Weight::from_parts(365_000, 0)
+	}
+	/// Storage: `Contracts::Nonce` (r:1 w:0)
+	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	fn seal_instantiation_nonce() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `219`
+		//  Estimated: `1704`
+		// Minimum execution time: 2_814_000 picoseconds.
+		Weight::from_parts(3_038_000, 1704)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
 	}
-	/// The range of component `r` is `[0, 160]`.
-	fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight {
+	/// The range of component `r` is `[0, 5000]`.
+	fn instr_i64_load_store(r: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_407_000 picoseconds.
-		Weight::from_parts(14_375_492, 0)
-			// Standard Error: 4_036
-			.saturating_add(Weight::from_parts(11_666_630, 0).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::CodeInfoOf` (r:1536 w:1536)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1535 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1537 w:1537)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_set_code_hash(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0 + r * (926 ±0)`
-		//  Estimated: `8966 + r * (3047 ±10)`
-		// Minimum execution time: 10_566_000 picoseconds.
-		Weight::from_parts(10_627_000, 8966)
-			// Standard Error: 46_429
-			.saturating_add(Weight::from_parts(22_435_893, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 3047).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::CodeInfoOf` (r:32 w:32)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// The range of component `r` is `[0, 32]`.
-	fn lock_delegate_dependency(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `274 + r * (78 ±0)`
-		//  Estimated: `1265 + r * (2553 ±0)`
-		// Minimum execution time: 10_305_000 picoseconds.
-		Weight::from_parts(16_073_202, 1265)
-			// Standard Error: 8_841
-			.saturating_add(Weight::from_parts(5_125_440, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2553).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::CodeInfoOf` (r:32 w:32)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`)
-	/// The range of component `r` is `[0, 32]`.
-	fn unlock_delegate_dependency(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `275 + r * (78 ±0)`
-		//  Estimated: `990 + r * (2568 ±0)`
-		// Minimum execution time: 10_389_000 picoseconds.
-		Weight::from_parts(16_221_879, 990)
-			// Standard Error: 9_409
-			.saturating_add(Weight::from_parts(4_235_040, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2568).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
-	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
-	/// Storage: `System::Account` (r:1 w:0)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Timestamp::Now` (r:1 w:0)
-	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_reentrance_count(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `858 + r * (3 ±0)`
-		//  Estimated: `6804 + r * (3 ±0)`
-		// Minimum execution time: 265_499_000 picoseconds.
-		Weight::from_parts(282_172_889, 6804)
-			// Standard Error: 442
-			.saturating_add(Weight::from_parts(165_070, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads(8_u64))
-			.saturating_add(T::DbWeight::get().writes(3_u64))
-			.saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into()))
-	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_account_reentrance_count(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_367_000 picoseconds.
-		Weight::from_parts(13_220_303, 0)
-			// Standard Error: 151
-			.saturating_add(Weight::from_parts(86_117, 0).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::Nonce` (r:1 w:0)
-	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_instantiation_nonce(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `219`
-		//  Estimated: `1704`
-		// Minimum execution time: 10_223_000 picoseconds.
-		Weight::from_parts(14_170_002, 1704)
-			// Standard Error: 71
-			.saturating_add(Weight::from_parts(76_372, 0).saturating_mul(r.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
-	}
-	/// The range of component `r` is `[0, 5000]`.
-	fn instr_i64_load_store(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 754_000 picoseconds.
-		Weight::from_parts(1_091_740, 0)
-			// Standard Error: 29
-			.saturating_add(Weight::from_parts(14_954, 0).saturating_mul(r.into()))
+		// Minimum execution time: 693_000 picoseconds.
+		Weight::from_parts(665_431, 0)
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(7_030, 0).saturating_mul(r.into()))
 	}
 }
 
@@ -1393,8 +992,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `1627`
-		// Minimum execution time: 2_002_000 picoseconds.
-		Weight::from_parts(2_193_000, 1627)
+		// Minimum execution time: 1_896_000 picoseconds.
+		Weight::from_parts(1_990_000, 1627)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
@@ -1404,10 +1003,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `452 + k * (69 ±0)`
 		//  Estimated: `442 + k * (70 ±0)`
-		// Minimum execution time: 12_339_000 picoseconds.
-		Weight::from_parts(12_682_000, 442)
-			// Standard Error: 1_302
-			.saturating_add(Weight::from_parts(1_163_234, 0).saturating_mul(k.into()))
+		// Minimum execution time: 11_142_000 picoseconds.
+		Weight::from_parts(11_578_000, 442)
+			// Standard Error: 1_557
+			.saturating_add(Weight::from_parts(1_165_198, 0).saturating_mul(k.into()))
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into())))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
@@ -1421,10 +1020,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `211 + c * (1 ±0)`
 		//  Estimated: `6149 + c * (1 ±0)`
-		// Minimum execution time: 8_145_000 picoseconds.
-		Weight::from_parts(8_747_247, 6149)
-			// Standard Error: 1
-			.saturating_add(Weight::from_parts(1_154, 0).saturating_mul(c.into()))
+		// Minimum execution time: 7_649_000 picoseconds.
+		Weight::from_parts(4_827_445, 6149)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(1_630, 0).saturating_mul(c.into()))
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
@@ -1437,8 +1036,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `510`
 		//  Estimated: `6450`
-		// Minimum execution time: 16_950_000 picoseconds.
-		Weight::from_parts(17_498_000, 6450)
+		// Minimum execution time: 16_096_000 picoseconds.
+		Weight::from_parts(16_937_000, 6450)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1451,10 +1050,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `171 + k * (1 ±0)`
 		//  Estimated: `3635 + k * (1 ±0)`
-		// Minimum execution time: 3_431_000 picoseconds.
-		Weight::from_parts(2_161_027, 3635)
-			// Standard Error: 949
-			.saturating_add(Weight::from_parts(1_219_406, 0).saturating_mul(k.into()))
+		// Minimum execution time: 3_131_000 picoseconds.
+		Weight::from_parts(3_209_000, 3635)
+			// Standard Error: 481
+			.saturating_add(Weight::from_parts(1_087_506, 0).saturating_mul(k.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into())))
@@ -1473,10 +1072,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `325 + c * (1 ±0)`
 		//  Estimated: `6263 + c * (1 ±0)`
-		// Minimum execution time: 16_384_000 picoseconds.
-		Weight::from_parts(16_741_331, 6263)
+		// Minimum execution time: 15_289_000 picoseconds.
+		Weight::from_parts(16_157_168, 6263)
 			// Standard Error: 1
-			.saturating_add(Weight::from_parts(375, 0).saturating_mul(c.into()))
+			.saturating_add(Weight::from_parts(395, 0).saturating_mul(c.into()))
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
@@ -1487,8 +1086,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `440`
 		//  Estimated: `6380`
-		// Minimum execution time: 12_529_000 picoseconds.
-		Weight::from_parts(13_319_000, 6380)
+		// Minimum execution time: 12_312_000 picoseconds.
+		Weight::from_parts(12_650_000, 6380)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1502,8 +1101,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `352`
 		//  Estimated: `6292`
-		// Minimum execution time: 47_462_000 picoseconds.
-		Weight::from_parts(48_784_000, 6292)
+		// Minimum execution time: 47_239_000 picoseconds.
+		Weight::from_parts(48_617_000, 6292)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1515,8 +1114,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `594`
 		//  Estimated: `6534`
-		// Minimum execution time: 55_712_000 picoseconds.
-		Weight::from_parts(58_629_000, 6534)
+		// Minimum execution time: 52_084_000 picoseconds.
+		Weight::from_parts(53_838_000, 6534)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1526,8 +1125,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `409`
 		//  Estimated: `6349`
-		// Minimum execution time: 11_992_000 picoseconds.
-		Weight::from_parts(12_686_000, 6349)
+		// Minimum execution time: 11_785_000 picoseconds.
+		Weight::from_parts(12_284_000, 6349)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1537,8 +1136,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `1627`
-		// Minimum execution time: 2_498_000 picoseconds.
-		Weight::from_parts(2_594_000, 1627)
+		// Minimum execution time: 2_136_000 picoseconds.
+		Weight::from_parts(2_233_000, 1627)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1550,8 +1149,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `166`
 		//  Estimated: `3631`
-		// Minimum execution time: 12_179_000 picoseconds.
-		Weight::from_parts(12_805_000, 3631)
+		// Minimum execution time: 10_957_000 picoseconds.
+		Weight::from_parts(11_314_000, 3631)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1561,8 +1160,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 4_695_000 picoseconds.
-		Weight::from_parts(5_105_000, 3607)
+		// Minimum execution time: 4_354_000 picoseconds.
+		Weight::from_parts(4_613_000, 3607)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
@@ -1573,8 +1172,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `167`
 		//  Estimated: `3632`
-		// Minimum execution time: 6_223_000 picoseconds.
-		Weight::from_parts(6_509_000, 3632)
+		// Minimum execution time: 5_541_000 picoseconds.
+		Weight::from_parts(5_790_000, 3632)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 	}
 	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
@@ -1585,8 +1184,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 6_073_000 picoseconds.
-		Weight::from_parts(6_524_000, 3607)
+		// Minimum execution time: 5_502_000 picoseconds.
+		Weight::from_parts(5_701_000, 3607)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1602,19 +1201,17 @@ impl WeightInfo for () {
 	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `c` is `[0, 125952]`.
 	fn call_with_code_per_byte(c: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `801 + c * (1 ±0)`
-		//  Estimated: `6739 + c * (1 ±0)`
-		// Minimum execution time: 289_627_000 picoseconds.
-		Weight::from_parts(281_167_857, 6739)
-			// Standard Error: 68
-			.saturating_add(Weight::from_parts(33_442, 0).saturating_mul(c.into()))
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
-			.saturating_add(RocksDbWeight::get().writes(4_u64))
+		//  Estimated: `4264 + c * (1 ±0)`
+		// Minimum execution time: 247_884_000 picoseconds.
+		Weight::from_parts(265_795_781, 4264)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(724, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
@@ -1623,8 +1220,6 @@ impl WeightInfo for () {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:2 w:2)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:3 w:3)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::Nonce` (r:1 w:1)
 	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
@@ -1641,17 +1236,17 @@ impl WeightInfo for () {
 	fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `323`
-		//  Estimated: `8737`
-		// Minimum execution time: 3_829_638_000 picoseconds.
-		Weight::from_parts(744_994_885, 8737)
-			// Standard Error: 165
-			.saturating_add(Weight::from_parts(68_083, 0).saturating_mul(c.into()))
-			// Standard Error: 19
-			.saturating_add(Weight::from_parts(1_484, 0).saturating_mul(i.into()))
-			// Standard Error: 19
-			.saturating_add(Weight::from_parts(1_581, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(11_u64))
-			.saturating_add(RocksDbWeight::get().writes(10_u64))
+		//  Estimated: `6262`
+		// Minimum execution time: 4_500_184_000 picoseconds.
+		Weight::from_parts(160_729_258, 6262)
+			// Standard Error: 143
+			.saturating_add(Weight::from_parts(52_809, 0).saturating_mul(c.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(2_173, 0).saturating_mul(i.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(2_165, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -1667,8 +1262,6 @@ impl WeightInfo for () {
 	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
 	/// The range of component `i` is `[0, 1048576]`.
@@ -1676,15 +1269,15 @@ impl WeightInfo for () {
 	fn instantiate(i: u32, s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `560`
-		//  Estimated: `6504`
-		// Minimum execution time: 1_960_218_000 picoseconds.
-		Weight::from_parts(1_976_273_000, 6504)
-			// Standard Error: 25
-			.saturating_add(Weight::from_parts(866, 0).saturating_mul(i.into()))
-			// Standard Error: 25
-			.saturating_add(Weight::from_parts(824, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(10_u64))
-			.saturating_add(RocksDbWeight::get().writes(7_u64))
+		//  Estimated: `4029`
+		// Minimum execution time: 2_219_163_000 picoseconds.
+		Weight::from_parts(2_236_918_000, 4029)
+			// Standard Error: 32
+			.saturating_add(Weight::from_parts(937, 0).saturating_mul(i.into()))
+			// Standard Error: 32
+			.saturating_add(Weight::from_parts(938, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -1698,16 +1291,14 @@ impl WeightInfo for () {
 	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	fn call() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `826`
-		//  Estimated: `6766`
-		// Minimum execution time: 200_542_000 picoseconds.
-		Weight::from_parts(209_713_000, 6766)
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
-			.saturating_add(RocksDbWeight::get().writes(4_u64))
+		//  Estimated: `4291`
+		// Minimum execution time: 164_801_000 picoseconds.
+		Weight::from_parts(167_250_000, 4291)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -1715,8 +1306,6 @@ impl WeightInfo for () {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1 w:1)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:0 w:1)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	/// The range of component `c` is `[0, 125952]`.
@@ -1724,12 +1313,12 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 258_375_000 picoseconds.
-		Weight::from_parts(271_214_455, 3607)
-			// Standard Error: 61
-			.saturating_add(Weight::from_parts(32_587, 0).saturating_mul(c.into()))
-			.saturating_add(RocksDbWeight::get().reads(4_u64))
-			.saturating_add(RocksDbWeight::get().writes(4_u64))
+		// Minimum execution time: 225_207_000 picoseconds.
+		Weight::from_parts(263_665_658, 3607)
+			// Standard Error: 47
+			.saturating_add(Weight::from_parts(50_732, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -1737,8 +1326,6 @@ impl WeightInfo for () {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1 w:1)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:0 w:1)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	/// The range of component `c` is `[0, 125952]`.
@@ -1746,12 +1333,12 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `142`
 		//  Estimated: `3607`
-		// Minimum execution time: 279_363_000 picoseconds.
-		Weight::from_parts(257_721_413, 3607)
-			// Standard Error: 81
-			.saturating_add(Weight::from_parts(33_850, 0).saturating_mul(c.into()))
-			.saturating_add(RocksDbWeight::get().reads(4_u64))
-			.saturating_add(RocksDbWeight::get().writes(4_u64))
+		// Minimum execution time: 230_718_000 picoseconds.
+		Weight::from_parts(258_359_271, 3607)
+			// Standard Error: 47
+			.saturating_add(Weight::from_parts(51_014, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -1759,18 +1346,16 @@ impl WeightInfo for () {
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Balances::Holds` (r:1 w:1)
 	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1 w:1)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:0 w:1)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	fn remove_code() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `315`
 		//  Estimated: `3780`
-		// Minimum execution time: 45_096_000 picoseconds.
-		Weight::from_parts(46_661_000, 3780)
-			.saturating_add(RocksDbWeight::get().reads(4_u64))
-			.saturating_add(RocksDbWeight::get().writes(4_u64))
+		// Minimum execution time: 39_668_000 picoseconds.
+		Weight::from_parts(41_031_000, 3780)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
 	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
@@ -1778,598 +1363,331 @@ impl WeightInfo for () {
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
 	/// Storage: `Contracts::CodeInfoOf` (r:2 w:2)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:3 w:3)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	fn set_code() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `552`
-		//  Estimated: `8967`
-		// Minimum execution time: 34_260_000 picoseconds.
-		Weight::from_parts(35_761_000, 8967)
-			.saturating_add(RocksDbWeight::get().reads(7_u64))
-			.saturating_add(RocksDbWeight::get().writes(6_u64))
+		//  Estimated: `6492`
+		// Minimum execution time: 25_890_000 picoseconds.
+		Weight::from_parts(26_603_000, 6492)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// The range of component `r` is `[0, 1600]`.
-	fn seal_caller(r: u32, ) -> Weight {
+	fn noop_host_fn(r: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_265_000 picoseconds.
-		Weight::from_parts(10_174_088, 0)
-			// Standard Error: 275
-			.saturating_add(Weight::from_parts(271_791, 0).saturating_mul(r.into()))
+		// Minimum execution time: 8_269_000 picoseconds.
+		Weight::from_parts(9_227_069, 0)
+			// Standard Error: 74
+			.saturating_add(Weight::from_parts(51_396, 0).saturating_mul(r.into()))
 	}
-	/// Storage: `Contracts::ContractInfoOf` (r:1600 w:0)
+	fn seal_caller() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 602_000 picoseconds.
+		Weight::from_parts(664_000, 0)
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_is_contract(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `509 + r * (77 ±0)`
-		//  Estimated: `1467 + r * (2552 ±0)`
-		// Minimum execution time: 10_498_000 picoseconds.
-		Weight::from_parts(10_551_000, 1467)
-			// Standard Error: 5_538
-			.saturating_add(Weight::from_parts(3_269_462, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2552).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::ContractInfoOf` (r:1600 w:0)
+	fn seal_is_contract() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `354`
+		//  Estimated: `3819`
+		// Minimum execution time: 6_131_000 picoseconds.
+		Weight::from_parts(6_468_000, 3819)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_code_hash(r: u32, ) -> Weight {
+	fn seal_code_hash() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `517 + r * (170 ±0)`
-		//  Estimated: `1468 + r * (2645 ±0)`
-		// Minimum execution time: 10_289_000 picoseconds.
-		Weight::from_parts(10_469_000, 1468)
-			// Standard Error: 5_674
-			.saturating_add(Weight::from_parts(4_105_274, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2645).saturating_mul(r.into()))
+		//  Measured:  `447`
+		//  Estimated: `3912`
+		// Minimum execution time: 7_557_000 picoseconds.
+		Weight::from_parts(7_704_000, 3912)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_own_code_hash(r: u32, ) -> Weight {
+	fn seal_own_code_hash() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_769_000 picoseconds.
-		Weight::from_parts(10_389_944, 0)
-			// Standard Error: 240
-			.saturating_add(Weight::from_parts(350_466, 0).saturating_mul(r.into()))
+		// Minimum execution time: 783_000 picoseconds.
+		Weight::from_parts(848_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_caller_is_origin(r: u32, ) -> Weight {
+	fn seal_caller_is_origin() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_443_000 picoseconds.
-		Weight::from_parts(11_651_820, 0)
-			// Standard Error: 91
-			.saturating_add(Weight::from_parts(100_579, 0).saturating_mul(r.into()))
+		// Minimum execution time: 397_000 picoseconds.
+		Weight::from_parts(435_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_caller_is_root(r: u32, ) -> Weight {
+	fn seal_caller_is_root() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_474_000 picoseconds.
-		Weight::from_parts(11_313_654, 0)
-			// Standard Error: 103
-			.saturating_add(Weight::from_parts(85_902, 0).saturating_mul(r.into()))
+		// Minimum execution time: 351_000 picoseconds.
+		Weight::from_parts(372_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_address(r: u32, ) -> Weight {
+	fn seal_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_360_000 picoseconds.
-		Weight::from_parts(11_283_384, 0)
-			// Standard Error: 163
-			.saturating_add(Weight::from_parts(253_111, 0).saturating_mul(r.into()))
+		// Minimum execution time: 608_000 picoseconds.
+		Weight::from_parts(645_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_gas_left(r: u32, ) -> Weight {
+	fn seal_gas_left() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_289_000 picoseconds.
-		Weight::from_parts(10_747_872, 0)
-			// Standard Error: 197
-			.saturating_add(Weight::from_parts(299_097, 0).saturating_mul(r.into()))
+		// Minimum execution time: 661_000 picoseconds.
+		Weight::from_parts(729_000, 0)
 	}
-	/// Storage: `System::Account` (r:1 w:0)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_balance(r: u32, ) -> Weight {
+	fn seal_balance() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `140`
-		//  Estimated: `3599`
-		// Minimum execution time: 10_368_000 picoseconds.
-		Weight::from_parts(29_685_372, 3599)
-			// Standard Error: 1_202
-			.saturating_add(Weight::from_parts(1_517_645, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		//  Estimated: `0`
+		// Minimum execution time: 4_545_000 picoseconds.
+		Weight::from_parts(4_663_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_value_transferred(r: u32, ) -> Weight {
+	fn seal_value_transferred() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_528_000 picoseconds.
-		Weight::from_parts(11_653_603, 0)
-			// Standard Error: 203
-			.saturating_add(Weight::from_parts(241_937, 0).saturating_mul(r.into()))
+		// Minimum execution time: 614_000 picoseconds.
+		Weight::from_parts(641_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_minimum_balance(r: u32, ) -> Weight {
+	fn seal_minimum_balance() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_385_000 picoseconds.
-		Weight::from_parts(11_483_212, 0)
-			// Standard Error: 227
-			.saturating_add(Weight::from_parts(248_076, 0).saturating_mul(r.into()))
+		// Minimum execution time: 583_000 picoseconds.
+		Weight::from_parts(618_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_block_number(r: u32, ) -> Weight {
+	fn seal_block_number() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_341_000 picoseconds.
-		Weight::from_parts(12_055_382, 0)
-			// Standard Error: 1_231
-			.saturating_add(Weight::from_parts(249_662, 0).saturating_mul(r.into()))
+		// Minimum execution time: 583_000 picoseconds.
+		Weight::from_parts(617_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_now(r: u32, ) -> Weight {
+	fn seal_now() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_467_000 picoseconds.
-		Weight::from_parts(10_579_667, 0)
-			// Standard Error: 247
-			.saturating_add(Weight::from_parts(246_711, 0).saturating_mul(r.into()))
+		// Minimum execution time: 607_000 picoseconds.
+		Weight::from_parts(638_000, 0)
 	}
 	/// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
 	/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_weight_to_fee(r: u32, ) -> Weight {
+	fn seal_weight_to_fee() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `67`
 		//  Estimated: `1552`
-		// Minimum execution time: 10_293_000 picoseconds.
-		Weight::from_parts(18_229_738, 1552)
-			// Standard Error: 452
-			.saturating_add(Weight::from_parts(655_277, 0).saturating_mul(r.into()))
+		// Minimum execution time: 4_172_000 picoseconds.
+		Weight::from_parts(4_408_000, 1552)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_input(r: u32, ) -> Weight {
+	/// The range of component `n` is `[0, 1048572]`.
+	fn seal_input(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_355_000 picoseconds.
-		Weight::from_parts(11_641_920, 0)
-			// Standard Error: 166
-			.saturating_add(Weight::from_parts(168_271, 0).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
-	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
-	/// Storage: `System::Account` (r:1 w:0)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Timestamp::Now` (r:1 w:0)
-	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_input_per_byte(n: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `869`
-		//  Estimated: `6809`
-		// Minimum execution time: 268_424_000 picoseconds.
-		Weight::from_parts(136_261_773, 6809)
-			// Standard Error: 16
-			.saturating_add(Weight::from_parts(1_373, 0).saturating_mul(n.into()))
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
-			.saturating_add(RocksDbWeight::get().writes(3_u64))
-	}
-	/// The range of component `r` is `[0, 1]`.
-	fn seal_return(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_044_000 picoseconds.
-		Weight::from_parts(10_550_491, 0)
-			// Standard Error: 20_456
-			.saturating_add(Weight::from_parts(925_808, 0).saturating_mul(r.into()))
+		// Minimum execution time: 475_000 picoseconds.
+		Weight::from_parts(515_000, 0)
+			// Standard Error: 3
+			.saturating_add(Weight::from_parts(298, 0).saturating_mul(n.into()))
 	}
-	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_return_per_byte(n: u32, ) -> Weight {
+	/// The range of component `n` is `[0, 1048572]`.
+	fn seal_return(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_361_000 picoseconds.
-		Weight::from_parts(11_935_556, 0)
-			// Standard Error: 0
-			.saturating_add(Weight::from_parts(315, 0).saturating_mul(n.into()))
+		// Minimum execution time: 289_000 picoseconds.
+		Weight::from_parts(357_000, 0)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(405, 0).saturating_mul(n.into()))
 	}
-	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
-	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
-	/// Storage: `System::Account` (r:3 w:3)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `Contracts::CodeInfoOf` (r:33 w:33)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Timestamp::Now` (r:1 w:0)
-	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
 	/// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1)
 	/// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:4 w:4)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// Storage: `Balances::Holds` (r:1 w:1)
-	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:33 w:33)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Contracts::DeletionQueue` (r:0 w:1)
 	/// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`)
-	/// The range of component `r` is `[0, 1]`.
-	fn seal_terminate(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `4802 + r * (2121 ±0)`
-		//  Estimated: `10742 + r * (81321 ±0)`
-		// Minimum execution time: 293_793_000 picoseconds.
-		Weight::from_parts(314_285_185, 10742)
-			// Standard Error: 808_383
-			.saturating_add(Weight::from_parts(256_215_014, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
-			.saturating_add(RocksDbWeight::get().reads((38_u64).saturating_mul(r.into())))
+	/// The range of component `n` is `[0, 32]`.
+	fn seal_terminate(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `319 + n * (78 ±0)`
+		//  Estimated: `3784 + n * (2553 ±0)`
+		// Minimum execution time: 13_316_000 picoseconds.
+		Weight::from_parts(15_855_821, 3784)
+			// Standard Error: 7_274
+			.saturating_add(Weight::from_parts(3_447_246, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
-			.saturating_add(RocksDbWeight::get().writes((41_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 81321).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2553).saturating_mul(n.into()))
 	}
 	/// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0)
 	/// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_random(r: u32, ) -> Weight {
+	fn seal_random() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `76`
 		//  Estimated: `1561`
-		// Minimum execution time: 10_323_000 picoseconds.
-		Weight::from_parts(10_996_645, 1561)
-			// Standard Error: 566
-			.saturating_add(Weight::from_parts(1_133_870, 0).saturating_mul(r.into()))
+		// Minimum execution time: 3_468_000 picoseconds.
+		Weight::from_parts(3_608_000, 1561)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_deposit_event(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_122_000 picoseconds.
-		Weight::from_parts(17_368_451, 0)
-			// Standard Error: 679
-			.saturating_add(Weight::from_parts(1_660_129, 0).saturating_mul(r.into()))
-	}
 	/// Storage: `System::EventTopics` (r:4 w:4)
 	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `t` is `[0, 4]`.
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight {
+	fn seal_deposit_event(t: u32, n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `990 + t * (2475 ±0)`
-		// Minimum execution time: 24_515_000 picoseconds.
-		Weight::from_parts(16_807_493, 990)
-			// Standard Error: 13_923
-			.saturating_add(Weight::from_parts(2_315_122, 0).saturating_mul(t.into()))
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(573, 0).saturating_mul(n.into()))
+		// Minimum execution time: 3_777_000 picoseconds.
+		Weight::from_parts(4_028_191, 990)
+			// Standard Error: 5_907
+			.saturating_add(Weight::from_parts(2_183_733, 0).saturating_mul(t.into()))
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(18, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into())))
 			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into())))
 			.saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into()))
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_debug_message(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 9_596_000 picoseconds.
-		Weight::from_parts(9_113_960, 0)
-			// Standard Error: 139
-			.saturating_add(Weight::from_parts(112_197, 0).saturating_mul(r.into()))
-	}
 	/// The range of component `i` is `[0, 1048576]`.
-	fn seal_debug_message_per_byte(i: u32, ) -> Weight {
+	fn seal_debug_message(i: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_260_000 picoseconds.
-		Weight::from_parts(11_341_000, 0)
-			// Standard Error: 8
-			.saturating_add(Weight::from_parts(984, 0).saturating_mul(i.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_set_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_660_000 picoseconds.
-		Weight::from_parts(10_762_000, 105)
-			// Standard Error: 7_920
-			.saturating_add(Weight::from_parts(5_122_380, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
+		// Minimum execution time: 400_000 picoseconds.
+		Weight::from_parts(423_000, 0)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(1_209, 0).saturating_mul(i.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_set_storage_per_new_byte(n: u32, ) -> Weight {
+	/// The range of component `o` is `[0, 16384]`.
+	fn seal_set_storage(n: u32, o: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `245`
-		//  Estimated: `245`
-		// Minimum execution time: 19_446_000 picoseconds.
-		Weight::from_parts(20_166_940, 245)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(287, 0).saturating_mul(n.into()))
+		//  Measured:  `250 + o * (1 ±0)`
+		//  Estimated: `249 + o * (1 ±0)`
+		// Minimum execution time: 9_033_000 picoseconds.
+		Weight::from_parts(8_797_934, 249)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(257, 0).saturating_mul(n.into()))
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(51, 0).saturating_mul(o.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_set_storage_per_old_byte(n: u32, ) -> Weight {
+	fn seal_clear_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 19_249_000 picoseconds.
-		Weight::from_parts(20_875_560, 248)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(73, 0).saturating_mul(n.into()))
+		// Minimum execution time: 7_167_000 picoseconds.
+		Weight::from_parts(8_012_194, 248)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(90, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_clear_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_477_000 picoseconds.
-		Weight::from_parts(10_633_000, 105)
-			// Standard Error: 8_552
-			.saturating_add(Weight::from_parts(5_159_505, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_clear_storage_per_byte(n: u32, ) -> Weight {
+	fn seal_get_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 19_265_000 picoseconds.
-		Weight::from_parts(20_699_861, 248)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into()))
+		// Minimum execution time: 6_868_000 picoseconds.
+		Weight::from_parts(7_801_811, 248)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(605, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
-			.saturating_add(RocksDbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_get_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_336_000 picoseconds.
-		Weight::from_parts(10_466_000, 105)
-			// Standard Error: 7_699
-			.saturating_add(Weight::from_parts(4_542_224, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_get_storage_per_byte(n: u32, ) -> Weight {
+	fn seal_contains_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 18_513_000 picoseconds.
-		Weight::from_parts(20_357_236, 248)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(588, 0).saturating_mul(n.into()))
+		// Minimum execution time: 6_322_000 picoseconds.
+		Weight::from_parts(7_103_552, 248)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(79, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
 	/// Storage: `Skipped::Metadata` (r:0 w:0)
 	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_contains_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_432_000 picoseconds.
-		Weight::from_parts(10_658_000, 105)
-			// Standard Error: 7_129
-			.saturating_add(Weight::from_parts(4_423_298, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
 	/// The range of component `n` is `[0, 16384]`.
-	fn seal_contains_storage_per_byte(n: u32, ) -> Weight {
+	fn seal_take_storage(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `248 + n * (1 ±0)`
 		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 17_663_000 picoseconds.
-		Weight::from_parts(19_107_828, 248)
+		// Minimum execution time: 7_702_000 picoseconds.
+		Weight::from_parts(8_746_305, 248)
 			// Standard Error: 2
-			.saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into()))
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
-			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_take_storage(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `108 + r * (150 ±0)`
-		//  Estimated: `105 + r * (151 ±0)`
-		// Minimum execution time: 10_254_000 picoseconds.
-		Weight::from_parts(10_332_000, 105)
-			// Standard Error: 9_485
-			.saturating_add(Weight::from_parts(5_242_433, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into()))
-	}
-	/// Storage: `Skipped::Metadata` (r:0 w:0)
-	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `n` is `[0, 16384]`.
-	fn seal_take_storage_per_byte(n: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `248 + n * (1 ±0)`
-		//  Estimated: `248 + n * (1 ±0)`
-		// Minimum execution time: 19_410_000 picoseconds.
-		Weight::from_parts(21_347_311, 248)
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(607, 0).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(604, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
 	}
-	/// Storage: `System::Account` (r:1601 w:1601)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_transfer(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `770`
-		//  Estimated: `4221 + r * (2475 ±0)`
-		// Minimum execution time: 10_365_000 picoseconds.
-		Weight::from_parts(10_514_000, 4221)
-			// Standard Error: 18_360
-			.saturating_add(Weight::from_parts(33_433_850, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes(1_u64))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2475).saturating_mul(r.into()))
+	fn seal_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `140`
+		//  Estimated: `0`
+		// Minimum execution time: 8_851_000 picoseconds.
+		Weight::from_parts(9_083_000, 0)
 	}
-	/// Storage: `Contracts::ContractInfoOf` (r:800 w:801)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
 	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:1 w:0)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:801 w:801)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_call(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `517 + r * (170 ±0)`
-		//  Estimated: `3985 + r * (2646 ±0)`
-		// Minimum execution time: 10_332_000 picoseconds.
-		Weight::from_parts(10_424_000, 3985)
-			// Standard Error: 117_754
-			.saturating_add(Weight::from_parts(242_191_645, 0).saturating_mul(r.into()))
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// The range of component `t` is `[0, 1]`.
+	/// The range of component `i` is `[0, 1048576]`.
+	fn seal_call(t: u32, i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `620 + t * (280 ±0)`
+		//  Estimated: `4085 + t * (2182 ±0)`
+		// Minimum execution time: 121_148_000 picoseconds.
+		Weight::from_parts(119_605_377, 4085)
+			// Standard Error: 208_337
+			.saturating_add(Weight::from_parts(43_153_338, 0).saturating_mul(t.into()))
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(5, 0).saturating_mul(i.into()))
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
-			.saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes(2_u64))
-			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2646).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 2182).saturating_mul(t.into()))
 	}
-	/// Storage: `Contracts::CodeInfoOf` (r:735 w:0)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:735 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:736 w:736)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:0 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// The range of component `r` is `[0, 800]`.
-	fn seal_delegate_call(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0 + r * (527 ±0)`
-		//  Estimated: `6444 + r * (2583 ±10)`
-		// Minimum execution time: 10_550_000 picoseconds.
-		Weight::from_parts(10_667_000, 6444)
-			// Standard Error: 147_918
-			.saturating_add(Weight::from_parts(242_824_174, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2583).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:2)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
 	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
 	/// Storage: `Contracts::PristineCode` (r:1 w:0)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::Account` (r:2 w:2)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `t` is `[0, 1]`.
-	/// The range of component `c` is `[0, 1048576]`.
-	fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `696 + t * (277 ±0)`
-		//  Estimated: `6636 + t * (3457 ±0)`
-		// Minimum execution time: 213_206_000 picoseconds.
-		Weight::from_parts(120_511_970, 6636)
-			// Standard Error: 2_501_856
-			.saturating_add(Weight::from_parts(40_016_645, 0).saturating_mul(t.into()))
-			// Standard Error: 3
-			.saturating_add(Weight::from_parts(420, 0).saturating_mul(c.into()))
-			.saturating_add(RocksDbWeight::get().reads(5_u64))
-			.saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into())))
-			.saturating_add(RocksDbWeight::get().writes(4_u64))
-			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(t.into())))
-			.saturating_add(Weight::from_parts(0, 3457).saturating_mul(t.into()))
-	}
-	/// Storage: `Contracts::CodeInfoOf` (r:800 w:800)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:800 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Contracts::Nonce` (r:1 w:0)
-	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:800 w:801)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `System::Account` (r:802 w:802)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:801 w:801)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[1, 800]`.
-	fn seal_instantiate(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `1094 + r * (188 ±0)`
-		//  Estimated: `6987 + r * (2664 ±0)`
-		// Minimum execution time: 334_708_000 picoseconds.
-		Weight::from_parts(346_676_000, 6987)
-			// Standard Error: 236_074
-			.saturating_add(Weight::from_parts(330_734_734, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads(4_u64))
-			.saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes(4_u64))
-			.saturating_add(RocksDbWeight::get().writes((4_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2664).saturating_mul(r.into()))
+	fn seal_delegate_call() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `430`
+		//  Estimated: `3895`
+		// Minimum execution time: 108_159_000 picoseconds.
+		Weight::from_parts(110_027_000, 3895)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 	}
 	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
@@ -2377,250 +1695,146 @@ impl WeightInfo for () {
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
 	/// Storage: `Contracts::Nonce` (r:1 w:0)
 	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:2)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `System::Account` (r:3 w:3)
+	/// Storage: `System::Account` (r:1 w:1)
 	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `t` is `[0, 1]`.
 	/// The range of component `i` is `[0, 983040]`.
 	/// The range of component `s` is `[0, 983040]`.
-	fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `757 + t * (104 ±0)`
-		//  Estimated: `6716 + t * (2549 ±1)`
-		// Minimum execution time: 1_854_462_000 picoseconds.
-		Weight::from_parts(855_253_052, 6716)
-			// Standard Error: 13_502_046
-			.saturating_add(Weight::from_parts(20_015_409, 0).saturating_mul(t.into()))
-			// Standard Error: 21
-			.saturating_add(Weight::from_parts(1_060, 0).saturating_mul(i.into()))
-			// Standard Error: 21
-			.saturating_add(Weight::from_parts(1_201, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into())))
-			.saturating_add(RocksDbWeight::get().writes(7_u64))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into())))
-			.saturating_add(Weight::from_parts(0, 2549).saturating_mul(t.into()))
-	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_sha2_256(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_384_000 picoseconds.
-		Weight::from_parts(10_319_961, 0)
-			// Standard Error: 293
-			.saturating_add(Weight::from_parts(267_788, 0).saturating_mul(r.into()))
+	fn seal_instantiate(i: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `676`
+		//  Estimated: `4127`
+		// Minimum execution time: 1_861_874_000 picoseconds.
+		Weight::from_parts(1_872_926_000, 4127)
+			// Standard Error: 23
+			.saturating_add(Weight::from_parts(557, 0).saturating_mul(i.into()))
+			// Standard Error: 23
+			.saturating_add(Weight::from_parts(920, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight {
+	fn seal_hash_sha2_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_991_000 picoseconds.
-		Weight::from_parts(792_256, 0)
-			// Standard Error: 1
-			.saturating_add(Weight::from_parts(1_071, 0).saturating_mul(n.into()))
-	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_keccak_256(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_210_000 picoseconds.
-		Weight::from_parts(8_251_750, 0)
-			// Standard Error: 584
-			.saturating_add(Weight::from_parts(662_961, 0).saturating_mul(r.into()))
+		// Minimum execution time: 878_000 picoseconds.
+		Weight::from_parts(10_993_950, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_325, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight {
+	fn seal_hash_keccak_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_994_000 picoseconds.
-		Weight::from_parts(6_532_799, 0)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(3_351, 0).saturating_mul(n.into()))
-	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_blake2_256(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_209_000 picoseconds.
-		Weight::from_parts(10_895_450, 0)
-			// Standard Error: 195
-			.saturating_add(Weight::from_parts(328_195, 0).saturating_mul(r.into()))
+		// Minimum execution time: 1_261_000 picoseconds.
+		Weight::from_parts(9_759_497, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(3_594, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight {
+	fn seal_hash_blake2_256(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_493_000 picoseconds.
-		Weight::from_parts(4_721_812, 0)
+		// Minimum execution time: 726_000 picoseconds.
+		Weight::from_parts(9_795_728, 0)
 			// Standard Error: 0
-			.saturating_add(Weight::from_parts(1_195, 0).saturating_mul(n.into()))
-	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_hash_blake2_128(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_134_000 picoseconds.
-		Weight::from_parts(11_712_472, 0)
-			// Standard Error: 316
-			.saturating_add(Weight::from_parts(335_912, 0).saturating_mul(r.into()))
+			.saturating_add(Weight::from_parts(1_455, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 1048576]`.
-	fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight {
+	fn seal_hash_blake2_128(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 11_448_000 picoseconds.
-		Weight::from_parts(1_407_440, 0)
-			// Standard Error: 1
-			.saturating_add(Weight::from_parts(1_205, 0).saturating_mul(n.into()))
+		// Minimum execution time: 739_000 picoseconds.
+		Weight::from_parts(9_701_202, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_459, 0).saturating_mul(n.into()))
 	}
 	/// The range of component `n` is `[0, 125697]`.
-	fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight {
+	fn seal_sr25519_verify(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 54_644_000 picoseconds.
-		Weight::from_parts(55_793_413, 0)
-			// Standard Error: 11
-			.saturating_add(Weight::from_parts(4_511, 0).saturating_mul(n.into()))
-	}
-	/// The range of component `r` is `[0, 160]`.
-	fn seal_sr25519_verify(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 10_378_000 picoseconds.
-		Weight::from_parts(25_185_485, 0)
-			// Standard Error: 8_828
-			.saturating_add(Weight::from_parts(41_091_818, 0).saturating_mul(r.into()))
+		// Minimum execution time: 43_309_000 picoseconds.
+		Weight::from_parts(41_405_949, 0)
+			// Standard Error: 8
+			.saturating_add(Weight::from_parts(5_336, 0).saturating_mul(n.into()))
 	}
-	/// The range of component `r` is `[0, 160]`.
-	fn seal_ecdsa_recover(r: u32, ) -> Weight {
+	fn seal_ecdsa_recover() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_371_000 picoseconds.
-		Weight::from_parts(35_350_533, 0)
-			// Standard Error: 9_805
-			.saturating_add(Weight::from_parts(45_466_060, 0).saturating_mul(r.into()))
+		// Minimum execution time: 47_880_000 picoseconds.
+		Weight::from_parts(49_025_000, 0)
 	}
-	/// The range of component `r` is `[0, 160]`.
-	fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight {
+	fn seal_ecdsa_to_eth_address() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_407_000 picoseconds.
-		Weight::from_parts(14_375_492, 0)
-			// Standard Error: 4_036
-			.saturating_add(Weight::from_parts(11_666_630, 0).saturating_mul(r.into()))
+		// Minimum execution time: 13_462_000 picoseconds.
+		Weight::from_parts(13_631_000, 0)
 	}
-	/// Storage: `Contracts::CodeInfoOf` (r:1536 w:1536)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1535 w:0)
+	/// Storage: `Contracts::PristineCode` (r:1 w:0)
 	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:1537 w:1537)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_set_code_hash(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `0 + r * (926 ±0)`
-		//  Estimated: `8966 + r * (3047 ±10)`
-		// Minimum execution time: 10_566_000 picoseconds.
-		Weight::from_parts(10_627_000, 8966)
-			// Standard Error: 46_429
-			.saturating_add(Weight::from_parts(22_435_893, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 3047).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::CodeInfoOf` (r:32 w:32)
+	fn seal_set_code_hash() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `430`
+		//  Estimated: `3895`
+		// Minimum execution time: 17_978_000 picoseconds.
+		Weight::from_parts(18_578_000, 3895)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// The range of component `r` is `[0, 32]`.
-	fn lock_delegate_dependency(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `274 + r * (78 ±0)`
-		//  Estimated: `1265 + r * (2553 ±0)`
-		// Minimum execution time: 10_305_000 picoseconds.
-		Weight::from_parts(16_073_202, 1265)
-			// Standard Error: 8_841
-			.saturating_add(Weight::from_parts(5_125_440, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2553).saturating_mul(r.into()))
-	}
-	/// Storage: `Contracts::CodeInfoOf` (r:32 w:32)
+	fn lock_delegate_dependency() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `355`
+		//  Estimated: `3820`
+		// Minimum execution time: 8_384_000 picoseconds.
+		Weight::from_parts(8_687_000, 3820)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
 	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`)
-	/// The range of component `r` is `[0, 32]`.
-	fn unlock_delegate_dependency(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `275 + r * (78 ±0)`
-		//  Estimated: `990 + r * (2568 ±0)`
-		// Minimum execution time: 10_389_000 picoseconds.
-		Weight::from_parts(16_221_879, 990)
-			// Standard Error: 9_409
-			.saturating_add(Weight::from_parts(4_235_040, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
-			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
-			.saturating_add(Weight::from_parts(0, 2568).saturating_mul(r.into()))
+	fn unlock_delegate_dependency() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `355`
+		//  Estimated: `3558`
+		// Minimum execution time: 7_547_000 picoseconds.
+		Weight::from_parts(7_935_000, 3558)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
-	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
-	/// Storage: `System::Account` (r:1 w:0)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
-	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
-	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
-	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
-	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
-	/// Storage: `Contracts::PristineCode` (r:1 w:0)
-	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`)
-	/// Storage: `Timestamp::Now` (r:1 w:0)
-	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// Storage: `System::EventTopics` (r:2 w:2)
-	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_reentrance_count(r: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `858 + r * (3 ±0)`
-		//  Estimated: `6804 + r * (3 ±0)`
-		// Minimum execution time: 265_499_000 picoseconds.
-		Weight::from_parts(282_172_889, 6804)
-			// Standard Error: 442
-			.saturating_add(Weight::from_parts(165_070, 0).saturating_mul(r.into()))
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
-			.saturating_add(RocksDbWeight::get().writes(3_u64))
-			.saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into()))
+	fn seal_reentrance_count() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 331_000 picoseconds.
+		Weight::from_parts(363_000, 0)
 	}
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_account_reentrance_count(r: u32, ) -> Weight {
+	fn seal_account_reentrance_count() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 10_367_000 picoseconds.
-		Weight::from_parts(13_220_303, 0)
-			// Standard Error: 151
-			.saturating_add(Weight::from_parts(86_117, 0).saturating_mul(r.into()))
+		// Minimum execution time: 349_000 picoseconds.
+		Weight::from_parts(365_000, 0)
 	}
 	/// Storage: `Contracts::Nonce` (r:1 w:0)
 	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
-	/// The range of component `r` is `[0, 1600]`.
-	fn seal_instantiation_nonce(r: u32, ) -> Weight {
+	fn seal_instantiation_nonce() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `219`
 		//  Estimated: `1704`
-		// Minimum execution time: 10_223_000 picoseconds.
-		Weight::from_parts(14_170_002, 1704)
-			// Standard Error: 71
-			.saturating_add(Weight::from_parts(76_372, 0).saturating_mul(r.into()))
+		// Minimum execution time: 2_814_000 picoseconds.
+		Weight::from_parts(3_038_000, 1704)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 	}
 	/// The range of component `r` is `[0, 5000]`.
@@ -2628,9 +1842,9 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 754_000 picoseconds.
-		Weight::from_parts(1_091_740, 0)
-			// Standard Error: 29
-			.saturating_add(Weight::from_parts(14_954, 0).saturating_mul(r.into()))
+		// Minimum execution time: 693_000 picoseconds.
+		Weight::from_parts(665_431, 0)
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(7_030, 0).saturating_mul(r.into()))
 	}
 }
diff --git a/substrate/frame/contracts/uapi/Cargo.toml b/substrate/frame/contracts/uapi/Cargo.toml
index 80de7a1d5d69077d91ec9e0b845128027aad55ca..e19caa460419eb1557f9ed2cad9d8112e1270175 100644
--- a/substrate/frame/contracts/uapi/Cargo.toml
+++ b/substrate/frame/contracts/uapi/Cargo.toml
@@ -15,7 +15,7 @@ workspace = true
 paste = { version = "1.0", default-features = false }
 bitflags = "1.0"
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"], optional = true }
-scale = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
 	"derive",
 	"max-encoded-len",
 ], optional = true }
@@ -28,4 +28,4 @@ default-target = ["wasm32-unknown-unknown"]
 
 [features]
 default = ["scale"]
-scale = ["dep:scale", "scale-info"]
+scale = ["dep:codec", "scale-info"]
diff --git a/substrate/frame/contracts/uapi/src/flags.rs b/substrate/frame/contracts/uapi/src/flags.rs
index 32553817fb7ae08a7c778853f458a3bfd52d3a2b..9ad105b8372a1dd3d2315ec6019233babfccbd66 100644
--- a/substrate/frame/contracts/uapi/src/flags.rs
+++ b/substrate/frame/contracts/uapi/src/flags.rs
@@ -19,7 +19,7 @@ use bitflags::bitflags;
 
 bitflags! {
 	/// Flags used by a contract to customize exit behaviour.
-	#[cfg_attr(feature = "scale", derive(scale::Encode, scale::Decode, scale_info::TypeInfo))]
+	#[cfg_attr(feature = "scale", derive(codec::Encode, codec::Decode, scale_info::TypeInfo))]
 	pub struct ReturnFlags: u32 {
 		/// If this bit is set all changes made by the contract execution are rolled back.
 		const REVERT = 0x0000_0001;
@@ -69,5 +69,13 @@ bitflags! {
 		/// For `seal_delegate_call` should be always unset, otherwise
 		/// [`Error::InvalidCallFlags`] is returned.
 		const ALLOW_REENTRY = 0b0000_1000;
+		/// Indicates that the callee is restricted from modifying the state during call execution,
+		/// equivalent to Ethereum's STATICCALL.
+		///
+		/// # Note
+		///
+		/// For `seal_delegate_call` should be always unset, otherwise
+		/// [`Error::InvalidCallFlags`] is returned.
+		const READ_ONLY = 0b0001_0000;
 	}
 }
diff --git a/substrate/frame/conviction-voting/src/tests.rs b/substrate/frame/conviction-voting/src/tests.rs
index 74baeace898b09084a20b5e8e431efb2973c149f..78569fb3c9f250d6b5d009936a34a6187639ce1a 100644
--- a/substrate/frame/conviction-voting/src/tests.rs
+++ b/substrate/frame/conviction-voting/src/tests.rs
@@ -49,24 +49,14 @@ impl Contains<RuntimeCall> for BaseFilter {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
+	type BaseCallFilter = BaseFilter;
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type MaxLocks = ConstU32<10>;
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/substrate/frame/core-fellowship/src/benchmarking.rs b/substrate/frame/core-fellowship/src/benchmarking.rs
index b3ee3ab7d165fd87710b207ab4668bba450e2189..2dabab3983d094d566ad500ae4e4e5cbdba65b70 100644
--- a/substrate/frame/core-fellowship/src/benchmarking.rs
+++ b/substrate/frame/core-fellowship/src/benchmarking.rs
@@ -85,6 +85,45 @@ mod benchmarks {
 		Ok(())
 	}
 
+	#[benchmark]
+	fn set_partial_params() -> Result<(), BenchmarkError> {
+		let max_rank = T::MaxRank::get().try_into().unwrap();
+
+		// Set up the initial default state for the Params storage
+		let params = ParamsType {
+			active_salary: BoundedVec::try_from(vec![100u32.into(); max_rank]).unwrap(),
+			passive_salary: BoundedVec::try_from(vec![10u32.into(); max_rank]).unwrap(),
+			demotion_period: BoundedVec::try_from(vec![100u32.into(); max_rank]).unwrap(),
+			min_promotion_period: BoundedVec::try_from(vec![100u32.into(); max_rank]).unwrap(),
+			offboard_timeout: 1u32.into(),
+		};
+		CoreFellowship::<T, I>::set_params(RawOrigin::Root.into(), Box::new(params))?;
+
+		let default_params = Params::<T, I>::get();
+		let expected_params = ParamsType {
+			active_salary: default_params.active_salary,
+			passive_salary: BoundedVec::try_from(vec![10u32.into(); max_rank]).unwrap(),
+			demotion_period: default_params.demotion_period,
+			min_promotion_period: BoundedVec::try_from(vec![100u32.into(); max_rank]).unwrap(),
+			offboard_timeout: 1u32.into(),
+		};
+
+		let params_payload = ParamsType {
+			active_salary: BoundedVec::try_from(vec![None; max_rank]).unwrap(),
+			passive_salary: BoundedVec::try_from(vec![Some(10u32.into()); max_rank]).unwrap(),
+			demotion_period: BoundedVec::try_from(vec![None; max_rank]).unwrap(),
+			min_promotion_period: BoundedVec::try_from(vec![Some(100u32.into()); max_rank])
+				.unwrap(),
+			offboard_timeout: None,
+		};
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, Box::new(params_payload.clone()));
+
+		assert_eq!(Params::<T, I>::get(), expected_params);
+		Ok(())
+	}
+
 	#[benchmark]
 	fn bump_offboard() -> Result<(), BenchmarkError> {
 		set_benchmark_params::<T, I>()?;
diff --git a/substrate/frame/core-fellowship/src/lib.rs b/substrate/frame/core-fellowship/src/lib.rs
index 94339b85d0524a297241248312e92b31e761149c..6f0bb77714d99fd174f0c3ec3df31269df64823f 100644
--- a/substrate/frame/core-fellowship/src/lib.rs
+++ b/substrate/frame/core-fellowship/src/lib.rs
@@ -222,6 +222,11 @@ pub mod pallet {
 
 	pub type ParamsOf<T, I> =
 		ParamsType<<T as Config<I>>::Balance, BlockNumberFor<T>, <T as Config<I>>::MaxRank>;
+	pub type PartialParamsOf<T, I> = ParamsType<
+		Option<<T as Config<I>>::Balance>,
+		Option<BlockNumberFor<T>>,
+		<T as Config<I>>::MaxRank,
+	>;
 	pub type MemberStatusOf<T> = MemberStatus<BlockNumberFor<T>>;
 	pub type RankOf<T, I> = <<T as Config<I>>::Members as RankedMembers>::Rank;
 
@@ -558,9 +563,59 @@ pub mod pallet {
 
 			Ok(Pays::No.into())
 		}
+
+		/// Set the parameters partially.
+		///
+		/// - `origin`: An origin complying with `ParamsOrigin` or root.
+		/// - `partial_params`: The new parameters for the pallet.
+		///
+		/// This update config with multiple arguments without duplicating
+		/// the fields that does not need to update (set to None).
+		#[pallet::weight(T::WeightInfo::set_partial_params())]
+		#[pallet::call_index(9)]
+		pub fn set_partial_params(
+			origin: OriginFor<T>,
+			partial_params: Box<PartialParamsOf<T, I>>,
+		) -> DispatchResult {
+			T::ParamsOrigin::ensure_origin_or_root(origin)?;
+			let params = Params::<T, I>::mutate(|p| {
+				Self::set_partial_params_slice(&mut p.active_salary, partial_params.active_salary);
+				Self::set_partial_params_slice(
+					&mut p.passive_salary,
+					partial_params.passive_salary,
+				);
+				Self::set_partial_params_slice(
+					&mut p.demotion_period,
+					partial_params.demotion_period,
+				);
+				Self::set_partial_params_slice(
+					&mut p.min_promotion_period,
+					partial_params.min_promotion_period,
+				);
+				if let Some(new_offboard_timeout) = partial_params.offboard_timeout {
+					p.offboard_timeout = new_offboard_timeout;
+				}
+				p.clone()
+			});
+			Self::deposit_event(Event::<T, I>::ParamsChanged { params });
+			Ok(())
+		}
 	}
 
 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Partially update the base slice with a new slice
+		///
+		/// Only elements in the base slice which has a new value in the new slice will be updated.
+		pub(crate) fn set_partial_params_slice<S>(
+			base_slice: &mut BoundedVec<S, <T as Config<I>>::MaxRank>,
+			new_slice: BoundedVec<Option<S>, <T as Config<I>>::MaxRank>,
+		) {
+			for (base_element, new_element) in base_slice.iter_mut().zip(new_slice) {
+				if let Some(element) = new_element {
+					*base_element = element;
+				}
+			}
+		}
 		/// Convert a rank into a `0..RANK_COUNT` index suitable for the arrays in Params.
 		///
 		/// Rank 1 becomes index 0, rank `RANK_COUNT` becomes index `RANK_COUNT - 1`. Any rank not
diff --git a/substrate/frame/core-fellowship/src/tests/unit.rs b/substrate/frame/core-fellowship/src/tests/unit.rs
index 9245e5159a901d47842339836ae3f0767a2b1b1f..5d6d59c5c8918987087ea4dc3537a96fd56e00e4 100644
--- a/substrate/frame/core-fellowship/src/tests/unit.rs
+++ b/substrate/frame/core-fellowship/src/tests/unit.rs
@@ -187,6 +187,40 @@ fn set_params_works() {
 	});
 }
 
+#[test]
+fn set_partial_params_works() {
+	new_test_ext().execute_with(|| {
+		let params = ParamsType {
+			active_salary: bounded_vec![None; 9],
+			passive_salary: bounded_vec![None; 9],
+			demotion_period: bounded_vec![None, Some(10), None, None, None, None, None, None, None],
+			min_promotion_period: bounded_vec![None; 9],
+			offboard_timeout: Some(2),
+		};
+		assert_noop!(
+			CoreFellowship::set_partial_params(signed(2), Box::new(params.clone())),
+			DispatchError::BadOrigin
+		);
+		assert_ok!(CoreFellowship::set_partial_params(signed(1), Box::new(params)));
+
+		// Update params from the base params value declared in `new_test_ext`
+		let raw_updated_params = ParamsType {
+			active_salary: bounded_vec![10, 20, 30, 40, 50, 60, 70, 80, 90],
+			passive_salary: bounded_vec![1, 2, 3, 4, 5, 6, 7, 8, 9],
+			demotion_period: bounded_vec![2, 10, 6, 8, 10, 12, 14, 16, 18],
+			min_promotion_period: bounded_vec![3, 6, 9, 12, 15, 18, 21, 24, 27],
+			offboard_timeout: 2,
+		};
+		// Updated params stored in Params storage value
+		let updated_params = Params::<Test>::get();
+		assert_eq!(raw_updated_params, updated_params);
+
+		System::assert_last_event(
+			Event::<Test, _>::ParamsChanged { params: updated_params }.into(),
+		);
+	});
+}
+
 #[test]
 fn induct_works() {
 	new_test_ext().execute_with(|| {
diff --git a/substrate/frame/core-fellowship/src/weights.rs b/substrate/frame/core-fellowship/src/weights.rs
index 8fad6f585c1129e9a6c4160ed396cea28158e990..c1042d0ddfafa6c05fb1632c751d81c309fda1b3 100644
--- a/substrate/frame/core-fellowship/src/weights.rs
+++ b/substrate/frame/core-fellowship/src/weights.rs
@@ -50,6 +50,7 @@ use core::marker::PhantomData;
 /// Weight functions needed for `pallet_core_fellowship`.
 pub trait WeightInfo {
 	fn set_params() -> Weight;
+	fn set_partial_params() -> Weight;
 	fn bump_offboard() -> Weight;
 	fn bump_demote() -> Weight;
 	fn set_active() -> Weight;
@@ -74,6 +75,16 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		Weight::from_parts(8_018_000, 0)
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
+	/// Storage: CoreFellowship Params (r:0 w:1)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	fn set_partial_params() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_454_000 picoseconds.
+		Weight::from_parts(9_804_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
 	/// Storage: `CoreFellowship::Member` (r:1 w:1)
 	/// Proof: `CoreFellowship::Member` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`)
 	/// Storage: `RankedCollective::Members` (r:1 w:1)
@@ -245,6 +256,16 @@ impl WeightInfo for () {
 		Weight::from_parts(8_018_000, 0)
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
+	/// Storage: CoreFellowship Params (r:0 w:1)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	fn set_partial_params() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_454_000 picoseconds.
+		Weight::from_parts(9_804_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
 	/// Storage: `CoreFellowship::Member` (r:1 w:1)
 	/// Proof: `CoreFellowship::Member` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`)
 	/// Storage: `RankedCollective::Members` (r:1 w:1)
diff --git a/substrate/frame/delegated-staking/Cargo.toml b/substrate/frame/delegated-staking/Cargo.toml
index 4a4898827110105c4b05f81841494e19c14411f4..3b122dc2e26c3c9d0f56f07427b037bd1cd388c0 100644
--- a/substrate/frame/delegated-staking/Cargo.toml
+++ b/substrate/frame/delegated-staking/Cargo.toml
@@ -26,6 +26,7 @@ sp-io = { path = "../../primitives/io" }
 substrate-test-utils = { path = "../../test-utils" }
 sp-tracing = { path = "../../primitives/tracing" }
 pallet-staking = { path = "../staking" }
+pallet-nomination-pools = { path = "../nomination-pools" }
 pallet-balances = { path = "../balances" }
 pallet-timestamp = { path = "../timestamp" }
 pallet-staking-reward-curve = { path = "../staking/reward-curve" }
@@ -39,6 +40,7 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"pallet-balances/std",
+	"pallet-nomination-pools/std",
 	"pallet-staking/std",
 	"pallet-timestamp/std",
 	"scale-info/std",
@@ -53,6 +55,7 @@ runtime-benchmarks = [
 	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
+	"pallet-nomination-pools/runtime-benchmarks",
 	"pallet-staking/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
@@ -63,6 +66,7 @@ try-runtime = [
 	"frame-support/try-runtime",
 	"frame-system/try-runtime",
 	"pallet-balances/try-runtime",
+	"pallet-nomination-pools/try-runtime",
 	"pallet-staking/try-runtime",
 	"pallet-timestamp/try-runtime",
 	"sp-runtime/try-runtime",
diff --git a/substrate/frame/delegated-staking/src/impls.rs b/substrate/frame/delegated-staking/src/impls.rs
index b1945b0ce3769affb7537d9b575adb85890304e6..9f5649672d70e9e55ad84350d0be53bd4abb2b0f 100644
--- a/substrate/frame/delegated-staking/src/impls.rs
+++ b/substrate/frame/delegated-staking/src/impls.rs
@@ -19,46 +19,46 @@
 //! Implementations of public traits, namely [`DelegationInterface`] and [`OnStakingUpdate`].
 
 use super::*;
-use sp_staking::{DelegationInterface, DelegationMigrator, OnStakingUpdate};
+use sp_staking::{Agent, DelegationInterface, DelegationMigrator, Delegator, OnStakingUpdate};
 
 impl<T: Config> DelegationInterface for Pallet<T> {
 	type Balance = BalanceOf<T>;
 	type AccountId = T::AccountId;
 
 	/// Effective balance of the `Agent` account.
-	fn agent_balance(who: &Self::AccountId) -> Self::Balance {
-		Agent::<T>::get(who)
-			.map(|agent| agent.ledger.effective_balance())
-			.unwrap_or_default()
+	fn agent_balance(agent: Agent<Self::AccountId>) -> Option<Self::Balance> {
+		AgentLedgerOuter::<T>::get(&agent.get())
+			.map(|a| a.ledger.effective_balance())
+			.ok()
 	}
 
-	fn delegator_balance(delegator: &Self::AccountId) -> Self::Balance {
-		Delegation::<T>::get(delegator).map(|d| d.amount).unwrap_or_default()
+	fn delegator_balance(delegator: Delegator<Self::AccountId>) -> Option<Self::Balance> {
+		Delegation::<T>::get(&delegator.get()).map(|d| d.amount)
 	}
 
 	/// Delegate funds to an `Agent`.
 	fn delegate(
-		who: &Self::AccountId,
-		agent: &Self::AccountId,
+		who: Delegator<Self::AccountId>,
+		agent: Agent<Self::AccountId>,
 		reward_account: &Self::AccountId,
 		amount: Self::Balance,
 	) -> DispatchResult {
 		Pallet::<T>::register_agent(
-			RawOrigin::Signed(agent.clone()).into(),
+			RawOrigin::Signed(agent.clone().get()).into(),
 			reward_account.clone(),
 		)?;
 
 		// Delegate the funds from who to the `Agent` account.
-		Pallet::<T>::delegate_to_agent(RawOrigin::Signed(who.clone()).into(), agent.clone(), amount)
+		Pallet::<T>::delegate_to_agent(RawOrigin::Signed(who.get()).into(), agent.get(), amount)
 	}
 
 	/// Add more delegation to the `Agent` account.
 	fn delegate_extra(
-		who: &Self::AccountId,
-		agent: &Self::AccountId,
+		who: Delegator<Self::AccountId>,
+		agent: Agent<Self::AccountId>,
 		amount: Self::Balance,
 	) -> DispatchResult {
-		Pallet::<T>::delegate_to_agent(RawOrigin::Signed(who.clone()).into(), agent.clone(), amount)
+		Pallet::<T>::delegate_to_agent(RawOrigin::Signed(who.get()).into(), agent.get(), amount)
 	}
 
 	/// Withdraw delegation of `delegator` to `Agent`.
@@ -66,33 +66,31 @@ impl<T: Config> DelegationInterface for Pallet<T> {
 	/// If there are funds in `Agent` account that can be withdrawn, then those funds would be
 	/// unlocked/released in the delegator's account.
 	fn withdraw_delegation(
-		delegator: &Self::AccountId,
-		agent: &Self::AccountId,
+		delegator: Delegator<Self::AccountId>,
+		agent: Agent<Self::AccountId>,
 		amount: Self::Balance,
 		num_slashing_spans: u32,
 	) -> DispatchResult {
 		Pallet::<T>::release_delegation(
-			RawOrigin::Signed(agent.clone()).into(),
-			delegator.clone(),
+			RawOrigin::Signed(agent.get()).into(),
+			delegator.get(),
 			amount,
 			num_slashing_spans,
 		)
 	}
 
-	/// Returns true if the `Agent` have any slash pending to be applied.
-	fn has_pending_slash(agent: &Self::AccountId) -> bool {
-		Agent::<T>::get(agent)
-			.map(|d| !d.ledger.pending_slash.is_zero())
-			.unwrap_or(false)
+	/// Returns pending slash of the `agent`.
+	fn pending_slash(agent: Agent<Self::AccountId>) -> Option<Self::Balance> {
+		AgentLedgerOuter::<T>::get(&agent.get()).map(|d| d.ledger.pending_slash).ok()
 	}
 
 	fn delegator_slash(
-		agent: &Self::AccountId,
-		delegator: &Self::AccountId,
+		agent: Agent<Self::AccountId>,
+		delegator: Delegator<Self::AccountId>,
 		value: Self::Balance,
 		maybe_reporter: Option<Self::AccountId>,
 	) -> sp_runtime::DispatchResult {
-		Pallet::<T>::do_slash(agent.clone(), delegator.clone(), value, maybe_reporter)
+		Pallet::<T>::do_slash(agent, delegator, value, maybe_reporter)
 	}
 }
 
@@ -101,26 +99,40 @@ impl<T: Config> DelegationMigrator for Pallet<T> {
 	type AccountId = T::AccountId;
 
 	fn migrate_nominator_to_agent(
-		agent: &Self::AccountId,
+		agent: Agent<Self::AccountId>,
 		reward_account: &Self::AccountId,
 	) -> DispatchResult {
-		Pallet::<T>::migrate_to_agent(
-			RawOrigin::Signed(agent.clone()).into(),
-			reward_account.clone(),
-		)
+		Pallet::<T>::migrate_to_agent(RawOrigin::Signed(agent.get()).into(), reward_account.clone())
 	}
-
 	fn migrate_delegation(
-		agent: &Self::AccountId,
-		delegator: &Self::AccountId,
+		agent: Agent<Self::AccountId>,
+		delegator: Delegator<Self::AccountId>,
 		value: Self::Balance,
 	) -> DispatchResult {
 		Pallet::<T>::migrate_delegation(
-			RawOrigin::Signed(agent.clone()).into(),
-			delegator.clone(),
+			RawOrigin::Signed(agent.get()).into(),
+			delegator.get(),
 			value,
 		)
 	}
+
+	/// Only used for testing.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn drop_agent(agent: Agent<Self::AccountId>) {
+		<Agents<T>>::remove(agent.clone().get());
+		<Delegators<T>>::iter()
+			.filter(|(_, delegation)| delegation.agent == agent.clone().get())
+			.for_each(|(delegator, _)| {
+				let _ = T::Currency::release_all(
+					&HoldReason::StakingDelegation.into(),
+					&delegator,
+					Precision::BestEffort,
+				);
+				<Delegators<T>>::remove(&delegator);
+			});
+
+		T::CoreStaking::migrate_to_direct_staker(&agent.get());
+	}
 }
 
 impl<T: Config> OnStakingUpdate<T::AccountId, BalanceOf<T>> for Pallet<T> {
@@ -141,7 +153,7 @@ impl<T: Config> OnStakingUpdate<T::AccountId, BalanceOf<T>> for Pallet<T> {
 
 	fn on_withdraw(stash: &T::AccountId, amount: BalanceOf<T>) {
 		// if there is a withdraw to the agent, then add it to the unclaimed withdrawals.
-		let _ = Agent::<T>::get(stash)
+		let _ = AgentLedgerOuter::<T>::get(stash)
 			// can't do anything if there is an overflow error. Just raise a defensive error.
 			.and_then(|agent| agent.add_unclaimed_withdraw(amount).defensive())
 			.map(|agent| agent.save());
diff --git a/substrate/frame/delegated-staking/src/lib.rs b/substrate/frame/delegated-staking/src/lib.rs
index 210f69d9c839d5b977506c177a11f425c26e87f6..4b924bce3a579ace305d998cc1db84dee82f78bf 100644
--- a/substrate/frame/delegated-staking/src/lib.rs
+++ b/substrate/frame/delegated-staking/src/lib.rs
@@ -153,7 +153,7 @@ use sp_runtime::{
 	traits::{AccountIdConversion, CheckedAdd, CheckedSub, Zero},
 	ArithmeticError, DispatchResult, Perbill, RuntimeDebug, Saturating,
 };
-use sp_staking::{EraIndex, StakingInterface, StakingUnchecked};
+use sp_staking::{Agent, Delegator, EraIndex, StakingInterface, StakingUnchecked};
 use sp_std::{convert::TryInto, prelude::*};
 
 pub type BalanceOf<T> =
@@ -165,7 +165,10 @@ use frame_system::{ensure_signed, pallet_prelude::*, RawOrigin};
 pub mod pallet {
 	use super::*;
 
+	/// The in-code storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);
 	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
 	pub struct Pallet<T>(PhantomData<T>);
 
 	#[pallet::config]
@@ -245,6 +248,8 @@ pub mod pallet {
 		Released { agent: T::AccountId, delegator: T::AccountId, amount: BalanceOf<T> },
 		/// Funds slashed from a delegator.
 		Slashed { agent: T::AccountId, delegator: T::AccountId, amount: BalanceOf<T> },
+		/// Unclaimed delegation funds migrated to delegator.
+		MigratedDelegation { agent: T::AccountId, delegator: T::AccountId, amount: BalanceOf<T> },
 	}
 
 	/// Map of Delegators to their `Delegation`.
@@ -340,7 +345,12 @@ pub mod pallet {
 			num_slashing_spans: u32,
 		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
-			Self::do_release(&who, &delegator, amount, num_slashing_spans)
+			Self::do_release(
+				Agent::from(who),
+				Delegator::from(delegator),
+				amount,
+				num_slashing_spans,
+			)
 		}
 
 		/// Migrate delegated funds that are held in `proxy_delegator` to the claiming `delegator`'s
@@ -371,11 +381,11 @@ pub mod pallet {
 			ensure!(Self::is_agent(&agent), Error::<T>::NotAgent);
 
 			// and has enough delegated balance to migrate.
-			let proxy_delegator = Self::sub_account(AccountType::ProxyDelegator, agent);
-			let balance_remaining = Self::held_balance_of(&proxy_delegator);
+			let proxy_delegator = Self::generate_proxy_delegator(Agent::from(agent));
+			let balance_remaining = Self::held_balance_of(proxy_delegator.clone());
 			ensure!(balance_remaining >= amount, Error::<T>::NotEnoughFunds);
 
-			Self::do_migrate_delegation(&proxy_delegator, &delegator, amount)
+			Self::do_migrate_delegation(proxy_delegator, Delegator::from(delegator), amount)
 		}
 
 		/// Delegate given `amount` of tokens to an `Agent` account.
@@ -405,10 +415,10 @@ pub mod pallet {
 			ensure!(Self::is_agent(&agent), Error::<T>::NotAgent);
 
 			// add to delegation.
-			Self::do_delegate(&delegator, &agent, amount)?;
+			Self::do_delegate(Delegator::from(delegator), Agent::from(agent.clone()), amount)?;
 
 			// bond the newly delegated amount to `CoreStaking`.
-			Self::do_bond(&agent, amount)
+			Self::do_bond(Agent::from(agent), amount)
 		}
 	}
 
@@ -422,14 +432,20 @@ pub mod pallet {
 }
 
 impl<T: Config> Pallet<T> {
+	/// Derive an account from the migrating agent account where the unclaimed delegation funds
+	/// are held.
+	pub fn generate_proxy_delegator(agent: Agent<T::AccountId>) -> Delegator<T::AccountId> {
+		Delegator::from(Self::sub_account(AccountType::ProxyDelegator, agent.get()))
+	}
+
 	/// Derive a (keyless) pot account from the given agent account and account type.
-	pub(crate) fn sub_account(account_type: AccountType, agent: T::AccountId) -> T::AccountId {
-		T::PalletId::get().into_sub_account_truncating((account_type, agent.clone()))
+	fn sub_account(account_type: AccountType, acc: T::AccountId) -> T::AccountId {
+		T::PalletId::get().into_sub_account_truncating((account_type, acc.clone()))
 	}
 
 	/// Held balance of a delegator.
-	pub(crate) fn held_balance_of(who: &T::AccountId) -> BalanceOf<T> {
-		T::Currency::balance_on_hold(&HoldReason::StakingDelegation.into(), who)
+	pub(crate) fn held_balance_of(who: Delegator<T::AccountId>) -> BalanceOf<T> {
+		T::Currency::balance_on_hold(&HoldReason::StakingDelegation.into(), &who.get())
 	}
 
 	/// Returns true if who is registered as an `Agent`.
@@ -464,10 +480,10 @@ impl<T: Config> Pallet<T> {
 
 		// We create a proxy delegator that will keep all the delegation funds until funds are
 		// transferred to actual delegator.
-		let proxy_delegator = Self::sub_account(AccountType::ProxyDelegator, who.clone());
+		let proxy_delegator = Self::generate_proxy_delegator(Agent::from(who.clone()));
 
 		// Keep proxy delegator alive until all funds are migrated.
-		frame_system::Pallet::<T>::inc_providers(&proxy_delegator);
+		frame_system::Pallet::<T>::inc_providers(&proxy_delegator.clone().get());
 
 		// Get current stake
 		let stake = T::CoreStaking::stake(who)?;
@@ -480,11 +496,16 @@ impl<T: Config> Pallet<T> {
 			T::Currency::reducible_balance(who, Preservation::Expendable, Fortitude::Polite);
 
 		// This should never fail but if it does, it indicates bad state and we abort.
-		T::Currency::transfer(who, &proxy_delegator, amount_to_transfer, Preservation::Expendable)?;
+		T::Currency::transfer(
+			who,
+			&proxy_delegator.clone().get(),
+			amount_to_transfer,
+			Preservation::Expendable,
+		)?;
 
 		T::CoreStaking::update_payee(who, reward_account)?;
 		// delegate all transferred funds back to agent.
-		Self::do_delegate(&proxy_delegator, who, amount_to_transfer)?;
+		Self::do_delegate(proxy_delegator, Agent::from(who.clone()), amount_to_transfer)?;
 
 		// if the transferred/delegated amount was greater than the stake, mark the extra as
 		// unclaimed withdrawal.
@@ -505,32 +526,36 @@ impl<T: Config> Pallet<T> {
 	}
 
 	/// Bond `amount` to `agent_acc` in [`Config::CoreStaking`].
-	fn do_bond(agent_acc: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {
-		let agent = Agent::<T>::get(agent_acc)?;
+	fn do_bond(agent_acc: Agent<T::AccountId>, amount: BalanceOf<T>) -> DispatchResult {
+		let agent_ledger = AgentLedgerOuter::<T>::get(&agent_acc.get())?;
 
-		let available_to_bond = agent.available_to_bond();
+		let available_to_bond = agent_ledger.available_to_bond();
 		defensive_assert!(amount == available_to_bond, "not expected value to bond");
 
-		if agent.is_bonded() {
-			T::CoreStaking::bond_extra(&agent.key, amount)
+		if agent_ledger.is_bonded() {
+			T::CoreStaking::bond_extra(&agent_ledger.key, amount)
 		} else {
-			T::CoreStaking::virtual_bond(&agent.key, amount, agent.reward_account())
+			T::CoreStaking::virtual_bond(&agent_ledger.key, amount, agent_ledger.reward_account())
 		}
 	}
 
 	/// Delegate `amount` from `delegator` to `agent`.
 	fn do_delegate(
-		delegator: &T::AccountId,
-		agent: &T::AccountId,
+		delegator: Delegator<T::AccountId>,
+		agent: Agent<T::AccountId>,
 		amount: BalanceOf<T>,
 	) -> DispatchResult {
-		let mut ledger = AgentLedger::<T>::get(agent).ok_or(Error::<T>::NotAgent)?;
+		// get inner type
+		let agent = agent.get();
+		let delegator = delegator.get();
+
+		let mut ledger = AgentLedger::<T>::get(&agent).ok_or(Error::<T>::NotAgent)?;
 		// try to hold the funds.
-		T::Currency::hold(&HoldReason::StakingDelegation.into(), delegator, amount)?;
+		T::Currency::hold(&HoldReason::StakingDelegation.into(), &delegator, amount)?;
 
 		let new_delegation_amount =
-			if let Some(existing_delegation) = Delegation::<T>::get(delegator) {
-				ensure!(&existing_delegation.agent == agent, Error::<T>::InvalidDelegation);
+			if let Some(existing_delegation) = Delegation::<T>::get(&delegator) {
+				ensure!(existing_delegation.agent == agent, Error::<T>::InvalidDelegation);
 				existing_delegation
 					.amount
 					.checked_add(&amount)
@@ -539,54 +564,54 @@ impl<T: Config> Pallet<T> {
 				amount
 			};
 
-		Delegation::<T>::new(agent, new_delegation_amount).update_or_kill(delegator);
+		Delegation::<T>::new(&agent, new_delegation_amount).update_or_kill(&delegator);
 		ledger.total_delegated =
 			ledger.total_delegated.checked_add(&amount).ok_or(ArithmeticError::Overflow)?;
-		ledger.update(agent);
+		ledger.update(&agent);
 
-		Self::deposit_event(Event::<T>::Delegated {
-			agent: agent.clone(),
-			delegator: delegator.clone(),
-			amount,
-		});
+		Self::deposit_event(Event::<T>::Delegated { agent, delegator, amount });
 
 		Ok(())
 	}
 
 	/// Release `amount` of delegated funds from `agent` to `delegator`.
 	fn do_release(
-		who: &T::AccountId,
-		delegator: &T::AccountId,
+		who: Agent<T::AccountId>,
+		delegator: Delegator<T::AccountId>,
 		amount: BalanceOf<T>,
 		num_slashing_spans: u32,
 	) -> DispatchResult {
-		let mut agent = Agent::<T>::get(who)?;
-		let mut delegation = Delegation::<T>::get(delegator).ok_or(Error::<T>::NotDelegator)?;
+		// get inner type
+		let agent = who.get();
+		let delegator = delegator.get();
+
+		let mut agent_ledger = AgentLedgerOuter::<T>::get(&agent)?;
+		let mut delegation = Delegation::<T>::get(&delegator).ok_or(Error::<T>::NotDelegator)?;
 
 		// make sure delegation to be released is sound.
-		ensure!(&delegation.agent == who, Error::<T>::NotAgent);
+		ensure!(delegation.agent == agent, Error::<T>::NotAgent);
 		ensure!(delegation.amount >= amount, Error::<T>::NotEnoughFunds);
 
 		// if we do not already have enough funds to be claimed, try withdraw some more.
 		// keep track if we killed the staker in the process.
-		let stash_killed = if agent.ledger.unclaimed_withdrawals < amount {
+		let stash_killed = if agent_ledger.ledger.unclaimed_withdrawals < amount {
 			// withdraw account.
-			let killed = T::CoreStaking::withdraw_unbonded(who.clone(), num_slashing_spans)
+			let killed = T::CoreStaking::withdraw_unbonded(agent.clone(), num_slashing_spans)
 				.map_err(|_| Error::<T>::WithdrawFailed)?;
 			// reload agent from storage since withdrawal might have changed the state.
-			agent = agent.refresh()?;
+			agent_ledger = agent_ledger.reload()?;
 			Some(killed)
 		} else {
 			None
 		};
 
 		// if we still do not have enough funds to release, abort.
-		ensure!(agent.ledger.unclaimed_withdrawals >= amount, Error::<T>::NotEnoughFunds);
+		ensure!(agent_ledger.ledger.unclaimed_withdrawals >= amount, Error::<T>::NotEnoughFunds);
 
 		// Claim withdraw from agent. Kill agent if no delegation left.
 		// TODO: Ideally if there is a register, there should be an unregister that should
 		// clean up the agent. Can be improved in future.
-		if agent.remove_unclaimed_withdraw(amount)?.update_or_kill()? {
+		if agent_ledger.remove_unclaimed_withdraw(amount)?.update_or_kill()? {
 			match stash_killed {
 				Some(killed) => {
 					// this implies we did a `CoreStaking::withdraw` before release. Ensure
@@ -596,12 +621,12 @@ impl<T: Config> Pallet<T> {
 				None => {
 					// We did not do a `CoreStaking::withdraw` before release. Ensure staker is
 					// already killed in `CoreStaking`.
-					ensure!(T::CoreStaking::status(who).is_err(), Error::<T>::BadState);
+					ensure!(T::CoreStaking::status(&agent).is_err(), Error::<T>::BadState);
 				},
 			}
 
 			// Remove provider reference for `who`.
-			let _ = frame_system::Pallet::<T>::dec_providers(who).defensive();
+			let _ = frame_system::Pallet::<T>::dec_providers(&agent).defensive();
 		}
 
 		// book keep delegation
@@ -611,56 +636,56 @@ impl<T: Config> Pallet<T> {
 			.defensive_ok_or(ArithmeticError::Overflow)?;
 
 		// remove delegator if nothing delegated anymore
-		delegation.update_or_kill(delegator);
+		delegation.update_or_kill(&delegator);
 
 		let released = T::Currency::release(
 			&HoldReason::StakingDelegation.into(),
-			delegator,
+			&delegator,
 			amount,
 			Precision::BestEffort,
 		)?;
 
 		defensive_assert!(released == amount, "hold should have been released fully");
 
-		Self::deposit_event(Event::<T>::Released {
-			agent: who.clone(),
-			delegator: delegator.clone(),
-			amount,
-		});
+		Self::deposit_event(Event::<T>::Released { agent, delegator, amount });
 
 		Ok(())
 	}
 
 	/// Migrates delegation of `amount` from `source` account to `destination` account.
 	fn do_migrate_delegation(
-		source_delegator: &T::AccountId,
-		destination_delegator: &T::AccountId,
+		source_delegator: Delegator<T::AccountId>,
+		destination_delegator: Delegator<T::AccountId>,
 		amount: BalanceOf<T>,
 	) -> DispatchResult {
+		// get inner type
+		let source_delegator = source_delegator.get();
+		let destination_delegator = destination_delegator.get();
+
 		let mut source_delegation =
-			Delegators::<T>::get(source_delegator).defensive_ok_or(Error::<T>::BadState)?;
+			Delegators::<T>::get(&source_delegator).defensive_ok_or(Error::<T>::BadState)?;
 
 		// some checks that must have already been checked before.
 		ensure!(source_delegation.amount >= amount, Error::<T>::NotEnoughFunds);
 		debug_assert!(
-			!Self::is_delegator(destination_delegator) && !Self::is_agent(destination_delegator)
+			!Self::is_delegator(&destination_delegator) && !Self::is_agent(&destination_delegator)
 		);
 
+		let agent = source_delegation.agent.clone();
 		// update delegations
-		Delegation::<T>::new(&source_delegation.agent, amount)
-			.update_or_kill(destination_delegator);
+		Delegation::<T>::new(&agent, amount).update_or_kill(&destination_delegator);
 
 		source_delegation.amount = source_delegation
 			.amount
 			.checked_sub(&amount)
 			.defensive_ok_or(Error::<T>::BadState)?;
 
-		source_delegation.update_or_kill(source_delegator);
+		source_delegation.update_or_kill(&source_delegator);
 
 		// release funds from source
 		let released = T::Currency::release(
 			&HoldReason::StakingDelegation.into(),
-			source_delegator,
+			&source_delegator,
 			amount,
 			Precision::BestEffort,
 		)?;
@@ -669,8 +694,8 @@ impl<T: Config> Pallet<T> {
 
 		// transfer the released amount to `destination_delegator`.
 		let post_balance = T::Currency::transfer(
-			source_delegator,
-			destination_delegator,
+			&source_delegator,
+			&destination_delegator,
 			amount,
 			Preservation::Expendable,
 		)
@@ -678,28 +703,38 @@ impl<T: Config> Pallet<T> {
 
 		// if balance is zero, clear provider for source (proxy) delegator.
 		if post_balance == Zero::zero() {
-			let _ = frame_system::Pallet::<T>::dec_providers(source_delegator).defensive();
+			let _ = frame_system::Pallet::<T>::dec_providers(&source_delegator).defensive();
 		}
 
 		// hold the funds again in the new delegator account.
-		T::Currency::hold(&HoldReason::StakingDelegation.into(), destination_delegator, amount)?;
+		T::Currency::hold(&HoldReason::StakingDelegation.into(), &destination_delegator, amount)?;
+
+		Self::deposit_event(Event::<T>::MigratedDelegation {
+			agent,
+			delegator: destination_delegator,
+			amount,
+		});
 
 		Ok(())
 	}
 
 	/// Take slash `amount` from agent's `pending_slash`counter and apply it to `delegator` account.
 	pub fn do_slash(
-		agent_acc: T::AccountId,
-		delegator: T::AccountId,
+		agent: Agent<T::AccountId>,
+		delegator: Delegator<T::AccountId>,
 		amount: BalanceOf<T>,
 		maybe_reporter: Option<T::AccountId>,
 	) -> DispatchResult {
-		let agent = Agent::<T>::get(&agent_acc)?;
+		// get inner type
+		let agent = agent.get();
+		let delegator = delegator.get();
+
+		let agent_ledger = AgentLedgerOuter::<T>::get(&agent)?;
 		// ensure there is something to slash
-		ensure!(agent.ledger.pending_slash > Zero::zero(), Error::<T>::NothingToSlash);
+		ensure!(agent_ledger.ledger.pending_slash > Zero::zero(), Error::<T>::NothingToSlash);
 
 		let mut delegation = <Delegators<T>>::get(&delegator).ok_or(Error::<T>::NotDelegator)?;
-		ensure!(delegation.agent == agent_acc, Error::<T>::NotAgent);
+		ensure!(delegation.agent == agent.clone(), Error::<T>::NotAgent);
 		ensure!(delegation.amount >= amount, Error::<T>::NotEnoughFunds);
 
 		// slash delegator
@@ -711,7 +746,7 @@ impl<T: Config> Pallet<T> {
 		let actual_slash = credit.peek();
 
 		// remove the applied slashed amount from agent.
-		agent.remove_slash(actual_slash).save();
+		agent_ledger.remove_slash(actual_slash).save();
 		delegation.amount =
 			delegation.amount.checked_sub(&actual_slash).ok_or(ArithmeticError::Overflow)?;
 		delegation.update_or_kill(&delegator);
@@ -729,15 +764,15 @@ impl<T: Config> Pallet<T> {
 
 		T::OnSlash::on_unbalanced(credit);
 
-		Self::deposit_event(Event::<T>::Slashed { agent: agent_acc, delegator, amount });
+		Self::deposit_event(Event::<T>::Slashed { agent, delegator, amount });
 
 		Ok(())
 	}
 
 	/// Total balance that is available for stake. Includes already staked amount.
 	#[cfg(test)]
-	pub(crate) fn stakeable_balance(who: &T::AccountId) -> BalanceOf<T> {
-		Agent::<T>::get(who)
+	pub(crate) fn stakeable_balance(who: Agent<T::AccountId>) -> BalanceOf<T> {
+		AgentLedgerOuter::<T>::get(&who.get())
 			.map(|agent| agent.ledger.stakeable_balance())
 			.unwrap_or_default()
 	}
diff --git a/substrate/frame/delegated-staking/src/mock.rs b/substrate/frame/delegated-staking/src/mock.rs
index 21a9fe6b227009abe3b31c9fa6a4bbdc81e831d7..811d5739f4e98f24c30c7514455dac049fbbc421 100644
--- a/substrate/frame/delegated-staking/src/mock.rs
+++ b/substrate/frame/delegated-staking/src/mock.rs
@@ -15,12 +15,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::{self as delegated_staking, types::Agent};
+use crate::{self as delegated_staking, types::AgentLedgerOuter};
 use frame_support::{
 	assert_ok, derive_impl,
 	pallet_prelude::*,
 	parameter_types,
-	traits::{ConstU64, Currency},
+	traits::{ConstU64, Currency, VariantCountOf},
 	PalletId,
 };
 
@@ -32,7 +32,9 @@ use frame_election_provider_support::{
 };
 use frame_support::dispatch::RawOrigin;
 use pallet_staking::{ActiveEra, ActiveEraInfo, CurrentEra};
-use sp_staking::{Stake, StakingInterface};
+use sp_core::U256;
+use sp_runtime::traits::Convert;
+use sp_staking::{Agent, Stake, StakingInterface};
 
 pub type T = Runtime;
 type Block = frame_system::mocking::MockBlock<Runtime>;
@@ -42,7 +44,7 @@ pub const GENESIS_VALIDATOR: AccountId = 1;
 pub const GENESIS_NOMINATOR_ONE: AccountId = 101;
 pub const GENESIS_NOMINATOR_TWO: AccountId = 102;
 
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<Balance>;
@@ -62,19 +64,14 @@ pub type Balance = u128;
 parameter_types! {
 	pub static ExistentialDeposit: Balance = 1;
 }
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = ConstU32<128>;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
 	type FreezeIdentifier = RuntimeFreezeReason;
-	type MaxFreezes = ConstU32<1>;
-	type RuntimeHoldReason = RuntimeHoldReason;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
 	type RuntimeFreezeReason = RuntimeFreezeReason;
 }
 
@@ -91,7 +88,6 @@ pallet_staking_reward_curve::build! {
 
 parameter_types! {
 	pub const RewardCurve: &'static sp_runtime::curve::PiecewiseLinear<'static> = &I_NPOS;
-	pub static BondingDuration: u32 = 3;
 	pub static ElectionsBoundsOnChain: ElectionBounds = ElectionBoundsBuilder::default().build();
 }
 pub struct OnChainSeqPhragmen;
@@ -104,35 +100,17 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type Bounds = ElectionsBoundsOnChain;
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Runtime {
 	type Currency = Balances;
-	type CurrencyBalance = Balance;
 	type UnixTime = pallet_timestamp::Pallet<Self>;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
-	type Reward = ();
-	type SessionsPerEra = ConstU32<1>;
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
-	type BondingDuration = BondingDuration;
-	type SessionInterface = ();
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
-	type NextNewSession = ();
-	type HistoryDepth = ConstU32<84>;
-	type MaxExposurePageSize = ConstU32<64>;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<10>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type EventListeners = DelegatedStaking;
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
+	type EventListeners = (Pools, DelegatedStaking);
 }
 
 parameter_types! {
@@ -149,8 +127,39 @@ impl delegated_staking::Config for Runtime {
 	type CoreStaking = Staking;
 }
 
+pub struct BalanceToU256;
+impl Convert<Balance, U256> for BalanceToU256 {
+	fn convert(n: Balance) -> U256 {
+		n.into()
+	}
+}
+pub struct U256ToBalance;
+impl Convert<U256, Balance> for U256ToBalance {
+	fn convert(n: U256) -> Balance {
+		n.try_into().unwrap()
+	}
+}
+
 parameter_types! {
 	pub static MaxUnbonding: u32 = 8;
+	pub const PoolsPalletId: PalletId = PalletId(*b"py/nopls");
+}
+impl pallet_nomination_pools::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RewardCounter = sp_runtime::FixedU128;
+	type BalanceToU256 = BalanceToU256;
+	type U256ToBalance = U256ToBalance;
+	type PostUnbondingPoolsWindow = ConstU32<2>;
+	type PalletId = PoolsPalletId;
+	type MaxMetadataLen = ConstU32<256>;
+	type MaxUnbonding = MaxUnbonding;
+	type MaxPointsToBalance = frame_support::traits::ConstU8<10>;
+	type StakeAdapter =
+		pallet_nomination_pools::adapter::DelegateStake<Self, Staking, DelegatedStaking>;
+	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 }
 
 frame_support::construct_runtime!(
@@ -159,6 +168,7 @@ frame_support::construct_runtime!(
 		Timestamp: pallet_timestamp,
 		Balances: pallet_balances,
 		Staking: pallet_staking,
+		Pools: pallet_nomination_pools,
 		DelegatedStaking: delegated_staking,
 	}
 );
@@ -275,8 +285,8 @@ pub(crate) fn setup_delegation_stake(
 	}
 
 	// sanity checks
-	assert_eq!(DelegatedStaking::stakeable_balance(&agent), delegated_amount);
-	assert_eq!(Agent::<T>::get(&agent).unwrap().available_to_bond(), 0);
+	assert_eq!(DelegatedStaking::stakeable_balance(Agent::from(agent)), delegated_amount);
+	assert_eq!(AgentLedgerOuter::<T>::get(&agent).unwrap().available_to_bond(), 0);
 
 	delegated_amount
 }
@@ -288,18 +298,25 @@ pub(crate) fn start_era(era: sp_staking::EraIndex) {
 
 pub(crate) fn eq_stake(who: AccountId, total: Balance, active: Balance) -> bool {
 	Staking::stake(&who).unwrap() == Stake { total, active } &&
-		get_agent(&who).ledger.stakeable_balance() == total
+		get_agent_ledger(&who).ledger.stakeable_balance() == total
 }
 
-pub(crate) fn get_agent(agent: &AccountId) -> Agent<T> {
-	Agent::<T>::get(agent).expect("delegate should exist")
+pub(crate) fn get_agent_ledger(agent: &AccountId) -> AgentLedgerOuter<T> {
+	AgentLedgerOuter::<T>::get(agent).expect("delegate should exist")
 }
 
 parameter_types! {
 	static ObservedEventsDelegatedStaking: usize = 0;
+	static ObservedEventsPools: usize = 0;
+}
+
+pub(crate) fn pool_events_since_last_call() -> Vec<pallet_nomination_pools::Event<Runtime>> {
+	let events = System::read_events_for_pallet::<pallet_nomination_pools::Event<Runtime>>();
+	let already_seen = ObservedEventsPools::get();
+	ObservedEventsPools::set(events.len());
+	events.into_iter().skip(already_seen).collect()
 }
 
-#[allow(unused)]
 pub(crate) fn events_since_last_call() -> Vec<crate::Event<Runtime>> {
 	let events = System::read_events_for_pallet::<crate::Event<Runtime>>();
 	let already_seen = ObservedEventsDelegatedStaking::get();
diff --git a/substrate/frame/delegated-staking/src/tests.rs b/substrate/frame/delegated-staking/src/tests.rs
index 1f36f655beb865f138a87fb4a9546ea1ad97a3ae..2295f7d0c8719bdd8c57be1a341816bdc547baf9 100644
--- a/substrate/frame/delegated-staking/src/tests.rs
+++ b/substrate/frame/delegated-staking/src/tests.rs
@@ -20,8 +20,9 @@
 use super::*;
 use crate::mock::*;
 use frame_support::{assert_noop, assert_ok, traits::fungible::InspectHold};
+use pallet_nomination_pools::{Error as PoolsError, Event as PoolsEvent};
 use pallet_staking::Error as StakingError;
-use sp_staking::DelegationInterface;
+use sp_staking::{Agent, DelegationInterface, Delegator, StakerStatus};
 
 #[test]
 fn create_an_agent_with_first_delegator() {
@@ -47,12 +48,12 @@ fn create_an_agent_with_first_delegator() {
 
 		// verify
 		assert!(DelegatedStaking::is_agent(&agent));
-		assert_eq!(DelegatedStaking::stakeable_balance(&agent), 100);
+		assert_eq!(DelegatedStaking::stakeable_balance(Agent::from(agent)), 100);
 		assert_eq!(
 			Balances::balance_on_hold(&HoldReason::StakingDelegation.into(), &delegator),
 			100
 		);
-		assert_eq!(DelegatedStaking::held_balance_of(&delegator), 100);
+		assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(delegator)), 100);
 	});
 }
 
@@ -101,7 +102,7 @@ fn create_multiple_delegators() {
 		// stakeable balance is 0 for non agent
 		fund(&agent, 1000);
 		assert!(!DelegatedStaking::is_agent(&agent));
-		assert_eq!(DelegatedStaking::stakeable_balance(&agent), 0);
+		assert_eq!(DelegatedStaking::stakeable_balance(Agent::from(agent)), 0);
 
 		// set intention to accept delegation.
 		assert_ok!(DelegatedStaking::register_agent(
@@ -123,7 +124,7 @@ fn create_multiple_delegators() {
 
 		// verify
 		assert!(DelegatedStaking::is_agent(&agent));
-		assert_eq!(DelegatedStaking::stakeable_balance(&agent), 100 * 100);
+		assert_eq!(DelegatedStaking::stakeable_balance(Agent::from(agent)), 100 * 100);
 	});
 }
 
@@ -259,39 +260,55 @@ fn apply_pending_slash() {
 		// agent cannot slash an account that is not its delegator.
 		setup_delegation_stake(210, 211, (351..=352).collect(), 100, 0);
 		assert_noop!(
-			<DelegatedStaking as DelegationInterface>::delegator_slash(&agent, &351, 1, Some(400)),
+			<DelegatedStaking as DelegationInterface>::delegator_slash(
+				Agent::from(agent),
+				Delegator::from(351),
+				1,
+				Some(400)
+			),
 			Error::<T>::NotAgent
 		);
 		// or a non delegator account
 		fund(&353, 100);
 		assert_noop!(
-			<DelegatedStaking as DelegationInterface>::delegator_slash(&agent, &353, 1, Some(400)),
+			<DelegatedStaking as DelegationInterface>::delegator_slash(
+				Agent::from(agent),
+				Delegator::from(353),
+				1,
+				Some(400)
+			),
 			Error::<T>::NotDelegator
 		);
 
 		// ensure bookkept pending slash is correct.
-		assert_eq!(get_agent(&agent).ledger.pending_slash, total_staked / 2);
+		assert_eq!(get_agent_ledger(&agent).ledger.pending_slash, total_staked / 2);
 		let mut old_reporter_balance = Balances::free_balance(reporter);
 
 		// lets apply the pending slash on delegators.
 		for i in delegators {
 			// balance before slash
-			let initial_pending_slash = get_agent(&agent).ledger.pending_slash;
+			let initial_pending_slash = get_agent_ledger(&agent).ledger.pending_slash;
 			assert!(initial_pending_slash > 0);
-			let unslashed_balance = DelegatedStaking::held_balance_of(&i);
+			let unslashed_balance = DelegatedStaking::held_balance_of(Delegator::from(i));
 			let slash = unslashed_balance / 2;
 			// slash half of delegator's delegation.
 			assert_ok!(<DelegatedStaking as DelegationInterface>::delegator_slash(
-				&agent,
-				&i,
+				Agent::from(agent),
+				Delegator::from(i),
 				slash,
 				Some(400)
 			));
 
 			// balance after slash.
-			assert_eq!(DelegatedStaking::held_balance_of(&i), unslashed_balance - slash);
+			assert_eq!(
+				DelegatedStaking::held_balance_of(Delegator::from(i)),
+				unslashed_balance - slash
+			);
 			// pending slash is reduced by the amount slashed.
-			assert_eq!(get_agent(&agent).ledger.pending_slash, initial_pending_slash - slash);
+			assert_eq!(
+				get_agent_ledger(&agent).ledger.pending_slash,
+				initial_pending_slash - slash
+			);
 			// reporter get 10% of the slash amount.
 			assert_eq!(
 				Balances::free_balance(reporter) - old_reporter_balance,
@@ -302,11 +319,16 @@ fn apply_pending_slash() {
 		}
 
 		// nothing to slash anymore
-		assert_eq!(get_agent(&agent).ledger.pending_slash, 0);
+		assert_eq!(get_agent_ledger(&agent).ledger.pending_slash, 0);
 
 		// cannot slash anymore
 		assert_noop!(
-			<DelegatedStaking as DelegationInterface>::delegator_slash(&agent, &350, 1, None),
+			<DelegatedStaking as DelegationInterface>::delegator_slash(
+				Agent::from(agent),
+				Delegator::from(350),
+				1,
+				None
+			),
 			Error::<T>::NothingToSlash
 		);
 	});
@@ -331,7 +353,7 @@ mod staking_integration {
 				RawOrigin::Signed(agent).into(),
 				reward_acc
 			));
-			assert_eq!(DelegatedStaking::stakeable_balance(&agent), 0);
+			assert_eq!(DelegatedStaking::stakeable_balance(Agent::from(agent)), 0);
 
 			let mut delegated_balance: Balance = 0;
 
@@ -348,9 +370,12 @@ mod staking_integration {
 					Balances::balance_on_hold(&HoldReason::StakingDelegation.into(), &delegator),
 					100
 				);
-				assert_eq!(DelegatedStaking::delegator_balance(&delegator), 100);
+				assert_eq!(
+					DelegatedStaking::delegator_balance(Delegator::from(delegator)).unwrap(),
+					100
+				);
 
-				let agent_obj = get_agent(&agent);
+				let agent_obj = get_agent_ledger(&agent);
 				assert_eq!(agent_obj.ledger.stakeable_balance(), delegated_balance);
 				assert_eq!(agent_obj.available_to_bond(), 0);
 				assert_eq!(agent_obj.bonded_stake(), delegated_balance);
@@ -402,9 +427,9 @@ mod staking_integration {
 				Error::<T>::NotEnoughFunds
 			);
 
-			assert_eq!(get_agent(&agent).available_to_bond(), 0);
+			assert_eq!(get_agent_ledger(&agent).available_to_bond(), 0);
 			// full amount is still delegated
-			assert_eq!(get_agent(&agent).ledger.effective_balance(), total_staked);
+			assert_eq!(get_agent_ledger(&agent).ledger.effective_balance(), total_staked);
 
 			start_era(5);
 			// at era 5, 50 tokens are withdrawable, cannot withdraw more.
@@ -476,53 +501,53 @@ mod staking_integration {
 		ExtBuilder::default().build_and_execute(|| {
 			start_era(1);
 			let agent = 200;
-			setup_delegation_stake(agent, 201, (300..350).collect(), 100, 0);
+			setup_delegation_stake(agent, 201, (300..350).collect(), 320, 0);
 
 			// verify withdraw not possible yet
 			assert_noop!(
-				DelegatedStaking::release_delegation(RawOrigin::Signed(agent).into(), 300, 100, 0),
+				DelegatedStaking::release_delegation(RawOrigin::Signed(agent).into(), 300, 320, 0),
 				Error::<T>::NotEnoughFunds
 			);
 
 			// fill up unlocking chunks in core staking.
-			// 10 is the max chunks
-			for i in 2..=11 {
+			// 32 is the max chunks
+			for i in 2..=33 {
 				start_era(i);
 				assert_ok!(Staking::unbond(RawOrigin::Signed(agent).into(), 10));
 				// no withdrawals from core staking yet.
-				assert_eq!(get_agent(&agent).ledger.unclaimed_withdrawals, 0);
+				assert_eq!(get_agent_ledger(&agent).ledger.unclaimed_withdrawals, 0);
 			}
 
 			// another unbond would trigger withdrawal
-			start_era(12);
+			start_era(34);
 			assert_ok!(Staking::unbond(RawOrigin::Signed(agent).into(), 10));
 
-			// 8 previous unbonds would be withdrawn as they were already unlocked. Unlocking period
-			// is 3 eras.
-			assert_eq!(get_agent(&agent).ledger.unclaimed_withdrawals, 8 * 10);
+			// 30 previous unbonds would be withdrawn as they were already unlocked. Unlocking
+			// period is 3 eras.
+			assert_eq!(get_agent_ledger(&agent).ledger.unclaimed_withdrawals, 30 * 10);
 
 			// release some delegation now.
 			assert_ok!(DelegatedStaking::release_delegation(
 				RawOrigin::Signed(agent).into(),
 				300,
-				40,
+				160,
 				0
 			));
-			assert_eq!(get_agent(&agent).ledger.unclaimed_withdrawals, 80 - 40);
+			assert_eq!(get_agent_ledger(&agent).ledger.unclaimed_withdrawals, 300 - 160);
 
 			// cannot release more than available
 			assert_noop!(
-				DelegatedStaking::release_delegation(RawOrigin::Signed(agent).into(), 300, 50, 0),
+				DelegatedStaking::release_delegation(RawOrigin::Signed(agent).into(), 300, 141, 0),
 				Error::<T>::NotEnoughFunds
 			);
 			assert_ok!(DelegatedStaking::release_delegation(
 				RawOrigin::Signed(agent).into(),
 				300,
-				40,
+				140,
 				0
 			));
 
-			assert_eq!(DelegatedStaking::held_balance_of(&300), 100 - 80);
+			assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(300)), 320 - 300);
 		});
 	}
 
@@ -560,8 +585,8 @@ mod staking_integration {
 
 			// amount is staked correctly
 			assert!(eq_stake(200, 100, 100));
-			assert_eq!(get_agent(&200).available_to_bond(), 0);
-			assert_eq!(get_agent(&200).ledger.effective_balance(), 100);
+			assert_eq!(get_agent_ledger(&200).available_to_bond(), 0);
+			assert_eq!(get_agent_ledger(&200).ledger.effective_balance(), 100);
 
 			// free balance of delegate is untouched
 			assert_eq!(Balances::free_balance(200), balance_200);
@@ -623,7 +648,8 @@ mod staking_integration {
 			// to migrate, nominator needs to set an account as a proxy delegator where staked funds
 			// will be moved and delegated back to this old nominator account. This should be funded
 			// with at least ED.
-			let proxy_delegator = DelegatedStaking::sub_account(AccountType::ProxyDelegator, 200);
+			let proxy_delegator =
+				DelegatedStaking::generate_proxy_delegator(Agent::from(200)).get();
 
 			assert_ok!(DelegatedStaking::migrate_to_agent(RawOrigin::Signed(200).into(), 201));
 
@@ -636,9 +662,12 @@ mod staking_integration {
 			// stake amount is transferred from delegate to proxy delegator account.
 			assert_eq!(Balances::free_balance(200), 0);
 			assert_eq!(Staking::stake(&200).unwrap(), init_stake);
-			assert_eq!(get_agent(&200).ledger.effective_balance(), agent_amount);
-			assert_eq!(get_agent(&200).available_to_bond(), 0);
-			assert_eq!(get_agent(&200).ledger.unclaimed_withdrawals, agent_amount - staked_amount);
+			assert_eq!(get_agent_ledger(&200).ledger.effective_balance(), agent_amount);
+			assert_eq!(get_agent_ledger(&200).available_to_bond(), 0);
+			assert_eq!(
+				get_agent_ledger(&200).ledger.unclaimed_withdrawals,
+				agent_amount - staked_amount
+			);
 
 			// now lets migrate the delegators
 			let delegator_share = agent_amount / 4;
@@ -667,10 +696,10 @@ mod staking_integration {
 
 				// delegate stake is unchanged.
 				assert_eq!(Staking::stake(&200).unwrap(), init_stake);
-				assert_eq!(get_agent(&200).ledger.effective_balance(), agent_amount);
-				assert_eq!(get_agent(&200).available_to_bond(), 0);
+				assert_eq!(get_agent_ledger(&200).ledger.effective_balance(), agent_amount);
+				assert_eq!(get_agent_ledger(&200).available_to_bond(), 0);
 				assert_eq!(
-					get_agent(&200).ledger.unclaimed_withdrawals,
+					get_agent_ledger(&200).ledger.unclaimed_withdrawals,
 					agent_amount - staked_amount
 				);
 			}
@@ -683,3 +712,532 @@ mod staking_integration {
 		});
 	}
 }
+
+mod pool_integration {
+	use super::*;
+	use pallet_nomination_pools::{BondExtra, BondedPools, PoolState};
+
+	#[test]
+	fn create_pool_test() {
+		ExtBuilder::default().build_and_execute(|| {
+			let creator: AccountId = 100;
+			fund(&creator, 500);
+			let delegate_amount = 200;
+
+			// nothing held initially
+			assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(creator)), 0);
+
+			// create pool
+			assert_ok!(Pools::create(
+				RawOrigin::Signed(creator).into(),
+				delegate_amount,
+				creator,
+				creator,
+				creator
+			));
+
+			// correct amount is locked in depositor's account.
+			assert_eq!(
+				DelegatedStaking::held_balance_of(Delegator::from(creator)),
+				delegate_amount
+			);
+
+			let pool_account = Pools::generate_bonded_account(1);
+			let agent = get_agent_ledger(&pool_account);
+
+			// verify state
+			assert_eq!(agent.ledger.effective_balance(), delegate_amount);
+			assert_eq!(agent.available_to_bond(), 0);
+			assert_eq!(agent.total_unbonded(), 0);
+		});
+	}
+
+	#[test]
+	fn join_pool() {
+		ExtBuilder::default().build_and_execute(|| {
+			// create a pool
+			let pool_id = create_pool(100, 200);
+			// keep track of staked amount.
+			let mut staked_amount: Balance = 200;
+
+			// fund delegator
+			let delegator: AccountId = 300;
+			fund(&delegator, 500);
+			// nothing held initially
+			assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(delegator)), 0);
+
+			// delegator joins pool
+			assert_ok!(Pools::join(RawOrigin::Signed(delegator).into(), 100, pool_id));
+			staked_amount += 100;
+
+			// correct amount is locked in depositor's account.
+			assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(delegator)), 100);
+
+			// delegator is not actively exposed to core staking.
+			assert_eq!(Staking::status(&delegator), Err(StakingError::<T>::NotStash.into()));
+
+			let pool_agent = get_agent_ledger(&Pools::generate_bonded_account(1));
+			// verify state
+			assert_eq!(pool_agent.ledger.effective_balance(), staked_amount);
+			assert_eq!(pool_agent.bonded_stake(), staked_amount);
+			assert_eq!(pool_agent.available_to_bond(), 0);
+			assert_eq!(pool_agent.total_unbonded(), 0);
+
+			// cannot reap agent in staking.
+			assert_noop!(
+				Staking::reap_stash(RuntimeOrigin::signed(100), pool_agent.key, 0),
+				StakingError::<T>::VirtualStakerNotAllowed
+			);
+
+			// let a bunch of delegators join this pool
+			for i in 301..350 {
+				fund(&i, 500);
+				assert_ok!(Pools::join(RawOrigin::Signed(i).into(), 100 + i, pool_id));
+				staked_amount += 100 + i;
+				assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(i)), 100 + i);
+			}
+
+			let pool_agent = pool_agent.reload().unwrap();
+			assert_eq!(pool_agent.ledger.effective_balance(), staked_amount);
+			assert_eq!(pool_agent.bonded_stake(), staked_amount);
+			assert_eq!(pool_agent.available_to_bond(), 0);
+			assert_eq!(pool_agent.total_unbonded(), 0);
+		});
+	}
+
+	#[test]
+	fn bond_extra_to_pool() {
+		ExtBuilder::default().build_and_execute(|| {
+			let pool_id = create_pool(100, 200);
+			add_delegators_to_pool(pool_id, (300..310).collect(), 100);
+			let mut staked_amount = 200 + 100 * 10;
+			assert_eq!(get_pool_agent(pool_id).bonded_stake(), staked_amount);
+
+			// bond extra to pool
+			for i in 300..310 {
+				assert_ok!(Pools::bond_extra(
+					RawOrigin::Signed(i).into(),
+					BondExtra::FreeBalance(50)
+				));
+				staked_amount += 50;
+				assert_eq!(get_pool_agent(pool_id).bonded_stake(), staked_amount);
+			}
+		});
+	}
+
+	#[test]
+	fn claim_pool_rewards() {
+		ExtBuilder::default().build_and_execute(|| {
+			let creator = 100;
+			let creator_stake = 1000;
+			let pool_id = create_pool(creator, creator_stake);
+			add_delegators_to_pool(pool_id, (300..310).collect(), 100);
+			add_delegators_to_pool(pool_id, (310..320).collect(), 200);
+			let total_staked = creator_stake + 100 * 10 + 200 * 10;
+
+			// give some rewards
+			let reward_acc = Pools::generate_reward_account(pool_id);
+			let reward_amount = 1000;
+			fund(&reward_acc, reward_amount);
+
+			// claim rewards
+			for i in 300..320 {
+				let pre_balance = Balances::free_balance(i);
+				let delegator_staked_balance =
+					DelegatedStaking::held_balance_of(Delegator::from(i));
+				// payout reward
+				assert_ok!(Pools::claim_payout(RawOrigin::Signed(i).into()));
+
+				let reward = Balances::free_balance(i) - pre_balance;
+				assert_eq!(reward, delegator_staked_balance * reward_amount / total_staked);
+			}
+
+			// payout creator
+			let pre_balance = Balances::free_balance(creator);
+			assert_ok!(Pools::claim_payout(RawOrigin::Signed(creator).into()));
+			// verify they are paid out correctly
+			let reward = Balances::free_balance(creator) - pre_balance;
+			assert_eq!(reward, creator_stake * reward_amount / total_staked);
+
+			// reward account should only have left minimum balance after paying out everyone.
+			assert_eq!(Balances::free_balance(reward_acc), ExistentialDeposit::get());
+		});
+	}
+
+	#[test]
+	fn withdraw_from_pool() {
+		ExtBuilder::default().build_and_execute(|| {
+			// initial era
+			start_era(1);
+
+			let pool_id = create_pool(100, 1000);
+			let bond_amount = 200;
+			add_delegators_to_pool(pool_id, (300..310).collect(), bond_amount);
+			let total_staked = 1000 + bond_amount * 10;
+			let pool_acc = Pools::generate_bonded_account(pool_id);
+
+			start_era(2);
+			// nothing to release yet.
+			assert_noop!(
+				Pools::withdraw_unbonded(RawOrigin::Signed(301).into(), 301, 0),
+				PoolsError::<T>::SubPoolsNotFound
+			);
+
+			// 301 wants to unbond 50 in era 2, withdrawable in era 5.
+			assert_ok!(Pools::unbond(RawOrigin::Signed(301).into(), 301, 50));
+
+			// 302 wants to unbond 100 in era 3, withdrawable in era 6.
+			start_era(3);
+			assert_ok!(Pools::unbond(RawOrigin::Signed(302).into(), 302, 100));
+
+			// 303 wants to unbond 200 in era 4, withdrawable in era 7.
+			start_era(4);
+			assert_ok!(Pools::unbond(RawOrigin::Signed(303).into(), 303, 200));
+
+			// active stake is now reduced..
+			let expected_active = total_staked - (50 + 100 + 200);
+			assert!(eq_stake(pool_acc, total_staked, expected_active));
+
+			// nothing to withdraw at era 4
+			for i in 301..310 {
+				assert_noop!(
+					Pools::withdraw_unbonded(RawOrigin::Signed(i).into(), i, 0),
+					PoolsError::<T>::CannotWithdrawAny
+				);
+			}
+
+			assert!(eq_stake(pool_acc, total_staked, expected_active));
+
+			start_era(5);
+			// at era 5, 301 can withdraw.
+
+			System::reset_events();
+			let held_301 = DelegatedStaking::held_balance_of(Delegator::from(301));
+			let free_301 = Balances::free_balance(301);
+
+			assert_ok!(Pools::withdraw_unbonded(RawOrigin::Signed(301).into(), 301, 0));
+			assert_eq!(
+				events_since_last_call(),
+				vec![Event::Released { agent: pool_acc, delegator: 301, amount: 50 }]
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![PoolsEvent::Withdrawn { member: 301, pool_id, balance: 50, points: 50 }]
+			);
+			assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(301)), held_301 - 50);
+			assert_eq!(Balances::free_balance(301), free_301 + 50);
+
+			start_era(7);
+			// era 7 both delegators can withdraw
+			assert_ok!(Pools::withdraw_unbonded(RawOrigin::Signed(302).into(), 302, 0));
+			assert_ok!(Pools::withdraw_unbonded(RawOrigin::Signed(303).into(), 303, 0));
+
+			assert_eq!(
+				events_since_last_call(),
+				vec![
+					Event::Released { agent: pool_acc, delegator: 302, amount: 100 },
+					Event::Released { agent: pool_acc, delegator: 303, amount: 200 },
+				]
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					PoolsEvent::Withdrawn { member: 302, pool_id, balance: 100, points: 100 },
+					PoolsEvent::Withdrawn { member: 303, pool_id, balance: 200, points: 200 },
+					PoolsEvent::MemberRemoved { pool_id: 1, member: 303 },
+				]
+			);
+
+			// 303 is killed
+			assert!(!Delegators::<T>::contains_key(303));
+		});
+	}
+
+	#[test]
+	fn pool_withdraw_unbonded() {
+		ExtBuilder::default().build_and_execute(|| {
+			// initial era
+			start_era(1);
+			let pool_id = create_pool(100, 1000);
+			add_delegators_to_pool(pool_id, (300..310).collect(), 200);
+
+			start_era(2);
+			// 1000 tokens to be unbonded in era 5.
+			for i in 300..310 {
+				assert_ok!(Pools::unbond(RawOrigin::Signed(i).into(), i, 100));
+			}
+
+			start_era(3);
+			// 500 tokens to be unbonded in era 6.
+			for i in 300..310 {
+				assert_ok!(Pools::unbond(RawOrigin::Signed(i).into(), i, 50));
+			}
+
+			start_era(5);
+			// withdraw pool should withdraw 1000 tokens
+			assert_ok!(Pools::pool_withdraw_unbonded(RawOrigin::Signed(100).into(), pool_id, 0));
+			assert_eq!(get_pool_agent(pool_id).total_unbonded(), 1000);
+
+			start_era(6);
+			// should withdraw 500 more
+			assert_ok!(Pools::pool_withdraw_unbonded(RawOrigin::Signed(100).into(), pool_id, 0));
+			assert_eq!(get_pool_agent(pool_id).total_unbonded(), 1000 + 500);
+
+			start_era(7);
+			// Nothing to withdraw, still at 1500.
+			assert_ok!(Pools::pool_withdraw_unbonded(RawOrigin::Signed(100).into(), pool_id, 0));
+			assert_eq!(get_pool_agent(pool_id).total_unbonded(), 1500);
+		});
+	}
+
+	#[test]
+	fn update_nominations() {
+		ExtBuilder::default().build_and_execute(|| {
+			start_era(1);
+			// can't nominate for non-existent pool
+			assert_noop!(
+				Pools::nominate(RawOrigin::Signed(100).into(), 1, vec![99]),
+				PoolsError::<T>::PoolNotFound
+			);
+
+			let pool_id = create_pool(100, 1000);
+			let pool_acc = Pools::generate_bonded_account(pool_id);
+			assert_ok!(Pools::nominate(RawOrigin::Signed(100).into(), 1, vec![20, 21, 22]));
+			assert!(Staking::status(&pool_acc) == Ok(StakerStatus::Nominator(vec![20, 21, 22])));
+
+			start_era(3);
+			assert_ok!(Pools::nominate(RawOrigin::Signed(100).into(), 1, vec![18, 19, 22]));
+			assert!(Staking::status(&pool_acc) == Ok(StakerStatus::Nominator(vec![18, 19, 22])));
+		});
+	}
+
+	#[test]
+	fn destroy_pool() {
+		ExtBuilder::default().build_and_execute(|| {
+			start_era(1);
+			let creator = 100;
+			let creator_stake = 1000;
+			let pool_id = create_pool(creator, creator_stake);
+			add_delegators_to_pool(pool_id, (300..310).collect(), 200);
+
+			start_era(3);
+			// lets destroy the pool
+			assert_ok!(Pools::set_state(
+				RawOrigin::Signed(creator).into(),
+				pool_id,
+				PoolState::Destroying
+			));
+			assert_ok!(Pools::chill(RawOrigin::Signed(creator).into(), pool_id));
+
+			// unbond all members by the creator/admin
+			for i in 300..310 {
+				assert_ok!(Pools::unbond(RawOrigin::Signed(creator).into(), i, 200));
+			}
+
+			start_era(6);
+			// withdraw all members by the creator/admin
+			for i in 300..310 {
+				assert_ok!(Pools::withdraw_unbonded(RawOrigin::Signed(creator).into(), i, 0));
+			}
+
+			// unbond creator
+			assert_ok!(Pools::unbond(RawOrigin::Signed(creator).into(), creator, creator_stake));
+
+			start_era(9);
+			System::reset_events();
+			// Withdraw self
+			assert_ok!(Pools::withdraw_unbonded(RawOrigin::Signed(creator).into(), creator, 0));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					PoolsEvent::Withdrawn {
+						member: creator,
+						pool_id,
+						balance: creator_stake,
+						points: creator_stake,
+					},
+					PoolsEvent::MemberRemoved { pool_id, member: creator },
+					PoolsEvent::Destroyed { pool_id },
+				]
+			);
+
+			// Make sure all data is cleaned up.
+			assert!(!Agents::<T>::contains_key(Pools::generate_bonded_account(pool_id)));
+			assert!(!System::account_exists(&Pools::generate_bonded_account(pool_id)));
+			assert!(!Delegators::<T>::contains_key(creator));
+			for i in 300..310 {
+				assert!(!Delegators::<T>::contains_key(i));
+			}
+		});
+	}
+
+	#[test]
+	fn pool_partially_slashed() {
+		ExtBuilder::default().build_and_execute(|| {
+			start_era(1);
+			let creator = 100;
+			let creator_stake = 500;
+			let pool_id = create_pool(creator, creator_stake);
+			let delegator_stake = 100;
+			add_delegators_to_pool(pool_id, (300..306).collect(), delegator_stake);
+			let pool_acc = Pools::generate_bonded_account(pool_id);
+
+			let total_staked = creator_stake + delegator_stake * 6;
+			assert_eq!(Staking::stake(&pool_acc).unwrap().total, total_staked);
+
+			// lets unbond a delegator each in next eras (2, 3, 4).
+			start_era(2);
+			assert_ok!(Pools::unbond(RawOrigin::Signed(300).into(), 300, delegator_stake));
+
+			start_era(3);
+			assert_ok!(Pools::unbond(RawOrigin::Signed(301).into(), 301, delegator_stake));
+
+			start_era(4);
+			assert_ok!(Pools::unbond(RawOrigin::Signed(302).into(), 302, delegator_stake));
+			System::reset_events();
+
+			// slash the pool at era 3
+			assert_eq!(
+				BondedPools::<T>::get(1).unwrap().points,
+				creator_stake + delegator_stake * 6 - delegator_stake * 3
+			);
+
+			// pool has currently no pending slash
+			assert_eq!(Pools::api_pool_pending_slash(pool_id), 0);
+
+			// slash the pool partially
+			pallet_staking::slashing::do_slash::<T>(
+				&pool_acc,
+				500,
+				&mut Default::default(),
+				&mut Default::default(),
+				3,
+			);
+
+			// pool has now pending slash of 500.
+			assert_eq!(Pools::api_pool_pending_slash(pool_id), 500);
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					// 300 did not get slashed as all as it unbonded in an era before slash.
+					// 301 got slashed 50% of 100 = 50.
+					PoolsEvent::UnbondingPoolSlashed { pool_id: 1, era: 6, balance: 50 },
+					// 302 got slashed 50% of 100 = 50.
+					PoolsEvent::UnbondingPoolSlashed { pool_id: 1, era: 7, balance: 50 },
+					// Rest of the pool slashed 50% of 800 = 400.
+					PoolsEvent::PoolSlashed { pool_id: 1, balance: 400 },
+				]
+			);
+
+			// slash is lazy and balance is still locked in user's accounts.
+			assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(creator)), creator_stake);
+			for i in 300..306 {
+				assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(i)), delegator_stake);
+			}
+			assert_eq!(
+				get_pool_agent(pool_id).ledger.effective_balance(),
+				Staking::total_stake(&pool_acc).unwrap()
+			);
+
+			// pending slash is book kept.
+			assert_eq!(get_pool_agent(pool_id).ledger.pending_slash, 500);
+
+			// go in some distant future era.
+			start_era(10);
+			System::reset_events();
+
+			// 300 is not slashed and can withdraw all balance.
+			assert_ok!(Pools::withdraw_unbonded(RawOrigin::Signed(300).into(), 300, 1));
+			assert_eq!(
+				events_since_last_call(),
+				vec![Event::Released { agent: pool_acc, delegator: 300, amount: 100 }]
+			);
+			assert_eq!(get_pool_agent(pool_id).ledger.pending_slash, 500);
+
+			// withdraw the other two delegators (301 and 302) who were unbonding.
+			for i in 301..=302 {
+				let pre_balance = Balances::free_balance(i);
+				let pre_pending_slash = get_pool_agent(pool_id).ledger.pending_slash;
+				assert_ok!(Pools::withdraw_unbonded(RawOrigin::Signed(i).into(), i, 0));
+				assert_eq!(
+					events_since_last_call(),
+					vec![
+						Event::Slashed { agent: pool_acc, delegator: i, amount: 50 },
+						Event::Released { agent: pool_acc, delegator: i, amount: 50 },
+					]
+				);
+				assert_eq!(get_pool_agent(pool_id).ledger.pending_slash, pre_pending_slash - 50);
+				assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(i)), 0);
+				assert_eq!(Balances::free_balance(i) - pre_balance, 50);
+			}
+
+			// let's update all the slash
+			let slash_reporter = 99;
+			// give our reporter some balance.
+			fund(&slash_reporter, 100);
+
+			for i in 303..306 {
+				let pre_pending_slash = get_pool_agent(pool_id).ledger.pending_slash;
+				// pool api returns correct pending slash.
+				assert_eq!(Pools::api_pool_pending_slash(pool_id), pre_pending_slash);
+				// delegator has pending slash of 50.
+				assert_eq!(Pools::api_member_pending_slash(i), 50);
+				// apply slash
+				assert_ok!(Pools::apply_slash(RawOrigin::Signed(slash_reporter).into(), i));
+				// nothing pending anymore.
+				assert_eq!(Pools::api_member_pending_slash(i), 0);
+
+				// each member is slashed 50% of 100 = 50.
+				assert_eq!(get_pool_agent(pool_id).ledger.pending_slash, pre_pending_slash - 50);
+				// pool api returns correctly as well.
+				assert_eq!(Pools::api_pool_pending_slash(pool_id), pre_pending_slash - 50);
+				// left with 50.
+				assert_eq!(DelegatedStaking::held_balance_of(Delegator::from(i)), 50);
+			}
+
+			// pool has still pending slash of creator.
+			assert_eq!(Pools::api_pool_pending_slash(pool_id), 250);
+
+			// reporter is paid SlashRewardFraction of the slash, i.e. 10% of 50 = 5
+			assert_eq!(Balances::free_balance(slash_reporter), 100 + 5 * 3);
+			// creator has pending slash.
+			assert_eq!(Pools::api_member_pending_slash(creator), 250);
+			// slash creator
+			assert_ok!(Pools::apply_slash(RawOrigin::Signed(slash_reporter).into(), creator));
+			// no pending slash anymore.
+			assert_eq!(Pools::api_member_pending_slash(creator), 0);
+
+			// all slash should be applied now.
+			assert_eq!(get_pool_agent(pool_id).ledger.pending_slash, 0);
+			assert_eq!(Pools::api_pool_pending_slash(pool_id), 0);
+			// for creator, 50% of stake should be slashed (250), 10% of which should go to reporter
+			// (25).
+			assert_eq!(Balances::free_balance(slash_reporter), 115 + 25);
+		});
+	}
+
+	fn create_pool(creator: AccountId, amount: Balance) -> u32 {
+		fund(&creator, amount * 2);
+		assert_ok!(Pools::create(
+			RawOrigin::Signed(creator).into(),
+			amount,
+			creator,
+			creator,
+			creator
+		));
+
+		pallet_nomination_pools::LastPoolId::<T>::get()
+	}
+
+	fn add_delegators_to_pool(pool_id: u32, delegators: Vec<AccountId>, amount: Balance) {
+		for delegator in delegators {
+			fund(&delegator, amount * 2);
+			assert_ok!(Pools::join(RawOrigin::Signed(delegator).into(), amount, pool_id));
+		}
+	}
+
+	fn get_pool_agent(pool_id: u32) -> AgentLedgerOuter<T> {
+		get_agent_ledger(&Pools::generate_bonded_account(pool_id))
+	}
+}
diff --git a/substrate/frame/delegated-staking/src/types.rs b/substrate/frame/delegated-staking/src/types.rs
index 0bfc23281dfe6eb3648418610a1184babdd3605d..24b4573565441301c3a63e4adf159488b44feb73 100644
--- a/substrate/frame/delegated-staking/src/types.rs
+++ b/substrate/frame/delegated-staking/src/types.rs
@@ -143,18 +143,18 @@ impl<T: Config> AgentLedger<T> {
 
 /// Wrapper around `AgentLedger` to provide some helper functions to mutate the ledger.
 #[derive(Clone)]
-pub struct Agent<T: Config> {
+pub struct AgentLedgerOuter<T: Config> {
 	/// storage key
 	pub key: T::AccountId,
 	/// storage value
 	pub ledger: AgentLedger<T>,
 }
 
-impl<T: Config> Agent<T> {
+impl<T: Config> AgentLedgerOuter<T> {
 	/// Get `Agent` from storage if it exists or return an error.
-	pub(crate) fn get(agent: &T::AccountId) -> Result<Agent<T>, DispatchError> {
+	pub(crate) fn get(agent: &T::AccountId) -> Result<AgentLedgerOuter<T>, DispatchError> {
 		let ledger = AgentLedger::<T>::get(agent).ok_or(Error::<T>::NotAgent)?;
-		Ok(Agent { key: agent.clone(), ledger })
+		Ok(AgentLedgerOuter { key: agent.clone(), ledger })
 	}
 
 	/// Remove funds that are withdrawn from [Config::CoreStaking] but not claimed by a delegator.
@@ -176,7 +176,7 @@ impl<T: Config> Agent<T> {
 			.checked_sub(&amount)
 			.defensive_ok_or(ArithmeticError::Overflow)?;
 
-		Ok(Agent {
+		Ok(AgentLedgerOuter {
 			ledger: AgentLedger {
 				total_delegated: new_total_delegated,
 				unclaimed_withdrawals: new_unclaimed_withdrawals,
@@ -197,7 +197,7 @@ impl<T: Config> Agent<T> {
 			.checked_add(&amount)
 			.defensive_ok_or(ArithmeticError::Overflow)?;
 
-		Ok(Agent {
+		Ok(AgentLedgerOuter {
 			ledger: AgentLedger { unclaimed_withdrawals: new_unclaimed_withdrawals, ..self.ledger },
 			..self
 		})
@@ -224,7 +224,10 @@ impl<T: Config> Agent<T> {
 		let pending_slash = self.ledger.pending_slash.defensive_saturating_sub(amount);
 		let total_delegated = self.ledger.total_delegated.defensive_saturating_sub(amount);
 
-		Agent { ledger: AgentLedger { pending_slash, total_delegated, ..self.ledger }, ..self }
+		AgentLedgerOuter {
+			ledger: AgentLedger { pending_slash, total_delegated, ..self.ledger },
+			..self
+		}
 	}
 
 	/// Get the total stake of agent bonded in [`Config::CoreStaking`].
@@ -270,7 +273,7 @@ impl<T: Config> Agent<T> {
 	}
 
 	/// Reloads self from storage.
-	pub(crate) fn refresh(self) -> Result<Agent<T>, DispatchError> {
+	pub(crate) fn reload(self) -> Result<AgentLedgerOuter<T>, DispatchError> {
 		Self::get(&self.key)
 	}
 
@@ -279,7 +282,6 @@ impl<T: Config> Agent<T> {
 	/// This is similar to [Self::available_to_bond] except it also includes `unclaimed_withdrawals`
 	/// of `Agent`.
 	#[cfg(test)]
-	#[allow(unused)]
 	pub(crate) fn total_unbonded(&self) -> BalanceOf<T> {
 		let bonded_stake = self.bonded_stake();
 
diff --git a/substrate/frame/democracy/src/tests.rs b/substrate/frame/democracy/src/tests.rs
index 9303c0da504f366288f6f06cb33c54abbd125321..7d7066c8af691e7f7a8fe5cd8bfb7dec21d57e9b 100644
--- a/substrate/frame/democracy/src/tests.rs
+++ b/substrate/frame/democracy/src/tests.rs
@@ -108,20 +108,9 @@ impl pallet_scheduler::Config for Test {
 	type Preimages = ();
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type MaxLocks = ConstU32<10>;
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 parameter_types! {
 	pub static PreimageByteDeposit: u64 = 0;
diff --git a/substrate/frame/election-provider-multi-phase/src/mock.rs b/substrate/frame/election-provider-multi-phase/src/mock.rs
index 92b87d92e99b16c959e9d719e91251da94fa7576..4532185b959c0ca59e6cfd4782f49b3773928b36 100644
--- a/substrate/frame/election-provider-multi-phase/src/mock.rs
+++ b/substrate/frame/election-provider-multi-phase/src/mock.rs
@@ -237,7 +237,6 @@ impl frame_system::Config for Runtime {
 
 const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
 parameter_types! {
-	pub const ExistentialDeposit: u64 = 1;
 	pub BlockWeights: frame_system::limits::BlockWeights = frame_system::limits::BlockWeights
 		::with_sensible_defaults(
 			Weight::from_parts(2u64 * constants::WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
@@ -245,20 +244,9 @@ parameter_types! {
 		);
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 #[derive(Default, Eq, PartialEq, Debug, Clone, Copy)]
diff --git a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs
index c00bb66ea13044f8b11aa781e30896e03225aea8..aaffbb6681cd26b0bfb6af7c7a8d9e27fe5f06fa 100644
--- a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs
@@ -22,6 +22,7 @@ pub(crate) const LOG_TARGET: &str = "tests::e2e-epm";
 
 use frame_support::{assert_err, assert_noop, assert_ok};
 use mock::*;
+use pallet_timestamp::Now;
 use sp_core::Get;
 use sp_runtime::Perbill;
 
@@ -46,7 +47,7 @@ fn log_current_time() {
 		Session::current_index(),
 		Staking::current_era(),
 		ElectionProviderMultiPhase::current_phase(),
-		Timestamp::now()
+		Now::<Runtime>::get()
 	);
 }
 
@@ -209,7 +210,7 @@ fn continuous_slashes_below_offending_threshold() {
 			// failed due to election minimum score.
 			if start_next_active_era(pool_state.clone()).is_err() {
 				assert!(ElectionProviderMultiPhase::current_phase().is_emergency());
-				break
+				break;
 			}
 
 			active_validator_set = Session::validators();
@@ -322,7 +323,7 @@ fn automatic_unbonding_pools() {
 		let init_free_balance_2 = Balances::free_balance(2);
 		let init_free_balance_3 = Balances::free_balance(3);
 
-		let pool_bonded_account = Pools::create_bonded_account(1);
+		let pool_bonded_account = Pools::generate_bonded_account(1);
 
 		// creates a pool with 5 bonded, owned by 1.
 		assert_ok!(Pools::create(RuntimeOrigin::signed(1), 5, 1, 1, 1));
diff --git a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
index 8f1775a7e5951ad1c9271f486a782b18fe5da900..bb1bdb31420565a104fb58b553b211411d7a3520 100644
--- a/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
@@ -19,7 +19,7 @@
 
 use frame_support::{
 	assert_ok, parameter_types, traits,
-	traits::{Hooks, UnfilteredDispatchable},
+	traits::{Hooks, UnfilteredDispatchable, VariantCountOf},
 	weights::constants,
 };
 use frame_system::EnsureRoot;
@@ -90,7 +90,6 @@ pub(crate) type Moment = u32;
 impl frame_system::Config for Runtime {
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<Balance>;
-	type BlockHashCount = ConstU32<10>;
 }
 
 const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
@@ -103,20 +102,14 @@ parameter_types! {
 		);
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = traits::ConstU32<1024>;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type MaxFreezes = traits::ConstU32<1>;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
 	type RuntimeHoldReason = RuntimeHoldReason;
 	type RuntimeFreezeReason = RuntimeFreezeReason;
 	type FreezeIdentifier = RuntimeFreezeReason;
-	type WeightInfo = ();
 }
 
 impl pallet_timestamp::Config for Runtime {
@@ -236,7 +229,6 @@ parameter_types! {
 	pub const SessionsPerEra: sp_staking::SessionIndex = 2;
 	pub static BondingDuration: sp_staking::EraIndex = 28;
 	pub const SlashDeferDuration: sp_staking::EraIndex = 7; // 1/4 the bonding duration.
-	pub HistoryDepth: u32 = 84;
 }
 
 impl pallet_bags_list::Config for Runtime {
@@ -274,7 +266,7 @@ impl pallet_nomination_pools::Config for Runtime {
 	type RewardCounter = sp_runtime::FixedU128;
 	type BalanceToU256 = BalanceToU256;
 	type U256ToBalance = U256ToBalance;
-	type Staking = Staking;
+	type StakeAdapter = pallet_nomination_pools::adapter::TransferStake<Self, Staking>;
 	type PostUnbondingPoolsWindow = ConstU32<2>;
 	type PalletId = PoolsPalletId;
 	type MaxMetadataLen = ConstU32<256>;
@@ -292,15 +284,11 @@ const MAX_QUOTA_NOMINATIONS: u32 = 16;
 /// Disabling factor set explicitly to byzantine threshold
 pub(crate) const SLASHING_DISABLING_FACTOR: usize = 3;
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Runtime {
 	type Currency = Balances;
 	type CurrencyBalance = Balance;
 	type UnixTime = Timestamp;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = (); // burn slashes
-	type Reward = (); // rewards are minted from the void
 	type SessionsPerEra = SessionsPerEra;
 	type BondingDuration = BondingDuration;
 	type SlashDeferDuration = SlashDeferDuration;
@@ -315,12 +303,10 @@ impl pallet_staking::Config for Runtime {
 	type NominationsQuota = pallet_staking::FixedNominationsQuota<MAX_QUOTA_NOMINATIONS>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
 	type MaxUnlockingChunks = MaxUnlockingChunks;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type HistoryDepth = HistoryDepth;
 	type EventListeners = Pools;
 	type WeightInfo = pallet_staking::weights::SubstrateWeight<Runtime>;
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
 	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy<SLASHING_DISABLING_FACTOR>;
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
 }
 
 impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Runtime
diff --git a/substrate/frame/election-provider-support/solution-type/Cargo.toml b/substrate/frame/election-provider-support/solution-type/Cargo.toml
index 3f8893dad6f2094ae75dec2e6e9de00d0b091495..0b631bd7bb035345a909a8911f4511f05d1b4f9b 100644
--- a/substrate/frame/election-provider-support/solution-type/Cargo.toml
+++ b/substrate/frame/election-provider-support/solution-type/Cargo.toml
@@ -24,7 +24,7 @@ proc-macro2 = "1.0.56"
 proc-macro-crate = "3.0.0"
 
 [dev-dependencies]
-parity-scale-codec = "3.6.12"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
 scale-info = "2.11.1"
 sp-arithmetic = { path = "../../../primitives/arithmetic" }
 # used by generate_solution_type:
diff --git a/substrate/frame/election-provider-support/solution-type/src/lib.rs b/substrate/frame/election-provider-support/solution-type/src/lib.rs
index 80773f6fb476859746677711401d70bd955b8ad7..1a88f0cf835fbe813da9d990ef4fd98651096614 100644
--- a/substrate/frame/election-provider-support/solution-type/src/lib.rs
+++ b/substrate/frame/election-provider-support/solution-type/src/lib.rs
@@ -263,7 +263,16 @@ fn imports() -> Result<TokenStream2> {
 					use _feps::private as _fepsp;
 			))
 		},
-		Err(e) => Err(syn::Error::new(Span::call_site(), e)),
+		Err(e) => match crate_name("polkadot-sdk") {
+			Ok(FoundCrate::Name(polkadot_sdk)) => {
+				let ident = syn::Ident::new(&polkadot_sdk, Span::call_site());
+				Ok(quote!(
+					use #ident::frame_election_provider_support as _feps;
+					use _feps::private as _fepsp;
+				))
+			},
+			_ => Err(syn::Error::new(Span::call_site(), e)),
+		},
 	}
 }
 
diff --git a/substrate/frame/elections-phragmen/src/lib.rs b/substrate/frame/elections-phragmen/src/lib.rs
index b4be07030efbbf3d52405320830f86f524c9b0ad..a5b6fca0a8a1fa33379d22f7d31afba07a69d5a5 100644
--- a/substrate/frame/elections-phragmen/src/lib.rs
+++ b/substrate/frame/elections-phragmen/src/lib.rs
@@ -1310,7 +1310,7 @@ mod tests {
 		assert_noop, assert_ok, derive_impl,
 		dispatch::DispatchResultWithPostInfo,
 		parameter_types,
-		traits::{ConstU32, ConstU64, OnInitialize},
+		traits::{ConstU32, OnInitialize},
 	};
 	use frame_system::ensure_signed;
 	use sp_runtime::{testing::Header, BuildStorage};
@@ -1322,20 +1322,9 @@ mod tests {
 		type AccountData = pallet_balances::AccountData<u64>;
 	}
 
+	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 	impl pallet_balances::Config for Test {
-		type Balance = u64;
-		type RuntimeEvent = RuntimeEvent;
-		type DustRemoval = ();
-		type ExistentialDeposit = ConstU64<1>;
 		type AccountStore = frame_system::Pallet<Test>;
-		type MaxLocks = ();
-		type MaxReserves = ();
-		type ReserveIdentifier = [u8; 8];
-		type WeightInfo = ();
-		type FreezeIdentifier = ();
-		type MaxFreezes = ();
-		type RuntimeHoldReason = ();
-		type RuntimeFreezeReason = ();
 	}
 
 	frame_support::parameter_types! {
diff --git a/substrate/frame/examples/basic/src/tests.rs b/substrate/frame/examples/basic/src/tests.rs
index de37bcf75569575b5eb42336424af2e3a917bf1d..505cd6f906de23bb5045834125201cc51c613217 100644
--- a/substrate/frame/examples/basic/src/tests.rs
+++ b/substrate/frame/examples/basic/src/tests.rs
@@ -60,7 +60,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
@@ -72,20 +71,9 @@ impl frame_system::Config for Test {
 	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl Config for Test {
diff --git a/substrate/frame/examples/dev-mode/src/tests.rs b/substrate/frame/examples/dev-mode/src/tests.rs
index 1c79b5f5fa6050758f5158bdcbede75e914eaf97..637864b87bc43d9e4e55cd9fe4f054cf5efd1ca8 100644
--- a/substrate/frame/examples/dev-mode/src/tests.rs
+++ b/substrate/frame/examples/dev-mode/src/tests.rs
@@ -18,7 +18,7 @@
 //! Tests for pallet-dev-mode.
 
 use crate::*;
-use frame_support::{assert_ok, derive_impl, traits::ConstU64};
+use frame_support::{assert_ok, derive_impl};
 use sp_core::H256;
 use sp_runtime::{
 	traits::{BlakeTwo256, IdentityLookup},
@@ -54,7 +54,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
@@ -66,20 +65,9 @@ impl frame_system::Config for Test {
 	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
 }
 
 impl Config for Test {
diff --git a/substrate/frame/examples/kitchensink/src/tests.rs b/substrate/frame/examples/kitchensink/src/tests.rs
index 1205fefc422983d2b6f621b601a96b786353f83a..7cf95497bf06408b0aae5543513a81a3316ddeaa 100644
--- a/substrate/frame/examples/kitchensink/src/tests.rs
+++ b/substrate/frame/examples/kitchensink/src/tests.rs
@@ -18,7 +18,7 @@
 //! Tests for pallet-example-kitchensink.
 
 use crate::*;
-use frame_support::{assert_ok, derive_impl, parameter_types, traits::ConstU64};
+use frame_support::{assert_ok, derive_impl, parameter_types, traits::VariantCountOf};
 use sp_runtime::BuildStorage;
 // Reexport crate as its pallet name for construct_runtime.
 use crate as pallet_example_kitchensink;
@@ -43,20 +43,14 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
 	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
+	type FreezeIdentifier = RuntimeFreezeReason;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type RuntimeFreezeReason = RuntimeFreezeReason;
 }
 
 parameter_types! {
diff --git a/substrate/frame/examples/multi-block-migrations/src/mock.rs b/substrate/frame/examples/multi-block-migrations/src/mock.rs
index 9da1d2051fa1f42666755e701b77c671791c6392..b2a946e1c505c2bd71e6929ff031d0b365ad702e 100644
--- a/substrate/frame/examples/multi-block-migrations/src/mock.rs
+++ b/substrate/frame/examples/multi-block-migrations/src/mock.rs
@@ -59,7 +59,7 @@ impl pallet_migrations::Config for Runtime {
 	type MaxServiceWeight = MigratorServiceWeight;
 }
 
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type Block = Block;
 	type MultiBlockMigrator = Migrator;
diff --git a/substrate/frame/examples/offchain-worker/src/tests.rs b/substrate/frame/examples/offchain-worker/src/tests.rs
index 3525b3b67edf1569f00600e1e210e426c5f858dc..e2c57a8c1e1abcb855a97db9590edc19c7bf881b 100644
--- a/substrate/frame/examples/offchain-worker/src/tests.rs
+++ b/substrate/frame/examples/offchain-worker/src/tests.rs
@@ -61,7 +61,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = ();
diff --git a/substrate/frame/examples/single-block-migrations/src/mock.rs b/substrate/frame/examples/single-block-migrations/src/mock.rs
index 68594cc4ad727a18f97b5d8b55381d36d1e7aeed..f4cf81ea6474f2971c08b1174e276fe0b7b9a0f0 100644
--- a/substrate/frame/examples/single-block-migrations/src/mock.rs
+++ b/substrate/frame/examples/single-block-migrations/src/mock.rs
@@ -18,7 +18,7 @@
 #![cfg(any(all(feature = "try-runtime", test), doc))]
 
 use crate::*;
-use frame_support::{derive_impl, traits::ConstU64, weights::constants::ParityDbWeight};
+use frame_support::{derive_impl, weights::constants::ParityDbWeight};
 
 // Re-export crate as its pallet name for construct_runtime.
 use crate as pallet_example_storage_migration;
@@ -41,20 +41,9 @@ impl frame_system::Config for MockRuntime {
 	type DbWeight = ParityDbWeight;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for MockRuntime {
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
 }
 
 impl Config for MockRuntime {}
diff --git a/substrate/frame/executive/src/tests.rs b/substrate/frame/executive/src/tests.rs
index e3721f7b6dcbac24be073515d78fbf0f1d2658b8..69a970a89d93070fec01a3b80867e1ff529d014c 100644
--- a/substrate/frame/executive/src/tests.rs
+++ b/substrate/frame/executive/src/tests.rs
@@ -36,7 +36,7 @@ use frame_support::{
 	migrations::MultiStepMigrator,
 	pallet_prelude::*,
 	parameter_types,
-	traits::{fungible, ConstU8, Currency, IsInherent},
+	traits::{fungible, ConstU8, Currency, IsInherent, VariantCount, VariantCountOf},
 	weights::{ConstantMultiplier, IdentityFee, RuntimeDbWeight, Weight, WeightMeter, WeightToFee},
 };
 use frame_system::{pallet_prelude::*, ChainContext, LastRuntimeUpgrade, LastRuntimeUpgradeInfo};
@@ -325,12 +325,24 @@ impl frame_system::Config for Runtime {
 	type MultiBlockMigrator = MockedModeGetter;
 }
 
+#[derive(Encode, Decode, Copy, Clone, Eq, PartialEq, MaxEncodedLen, TypeInfo, RuntimeDebug)]
+pub enum FreezeReasonId {
+	Foo,
+}
+
+impl VariantCount for FreezeReasonId {
+	const VARIANT_COUNT: u32 = 1;
+}
+
 type Balance = u64;
 
 #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
 	type Balance = Balance;
 	type AccountStore = System;
+	type RuntimeFreezeReason = FreezeReasonId;
+	type FreezeIdentifier = FreezeReasonId;
+	type MaxFreezes = VariantCountOf<FreezeReasonId>;
 }
 
 parameter_types! {
@@ -637,8 +649,8 @@ fn block_weight_limit_enforced() {
 				assert!(res.is_ok());
 				assert_eq!(
 					<frame_system::Pallet<Runtime>>::block_weight().total(),
-					//--------------------- on_initialize + block_execution + extrinsic_base weight
-					Weight::from_parts((encoded_len + 5) * (nonce + 1), 0) + base_block_weight,
+					//--------------------- on_initialize + block_execution + extrinsic_base weight + extrinsic len
+					Weight::from_parts((encoded_len + 5) * (nonce + 1), (nonce + 1)* encoded_len) + base_block_weight,
 				);
 				assert_eq!(
 					<frame_system::Pallet<Runtime>>::extrinsic_index(),
@@ -686,9 +698,10 @@ fn block_weight_and_size_is_stored_per_tx() {
 			<Runtime as frame_system::Config>::BlockWeights::get()
 				.get(DispatchClass::Normal)
 				.base_extrinsic;
+		// Check we account for all extrinsic weight and their len.
 		assert_eq!(
 			<frame_system::Pallet<Runtime>>::block_weight().total(),
-			base_block_weight + 3u64 * extrinsic_weight,
+			base_block_weight + 3u64 * extrinsic_weight + 3u64 * Weight::from_parts(0, len as u64),
 		);
 		assert_eq!(<frame_system::Pallet<Runtime>>::all_extrinsics_len(), 3 * len);
 
@@ -743,8 +756,12 @@ fn validate_unsigned() {
 fn can_not_pay_for_tx_fee_on_full_lock() {
 	let mut t = new_test_ext(1);
 	t.execute_with(|| {
-		<pallet_balances::Pallet<Runtime> as fungible::MutateFreeze<u64>>::set_freeze(&(), &1, 110)
-			.unwrap();
+		<pallet_balances::Pallet<Runtime> as fungible::MutateFreeze<u64>>::set_freeze(
+			&FreezeReasonId::Foo,
+			&1,
+			110,
+		)
+		.unwrap();
 		let xt = TestXt::new(
 			RuntimeCall::System(frame_system::Call::remark { remark: vec![1u8] }),
 			sign_extra(1, 0, 0),
diff --git a/substrate/frame/fast-unstake/src/mock.rs b/substrate/frame/fast-unstake/src/mock.rs
index d876f9f6171e5ed55d9cbe95fd678fa071b5bd9b..7ce7fee1410782a2166f7e696f2f0cad71746b40 100644
--- a/substrate/frame/fast-unstake/src/mock.rs
+++ b/substrate/frame/fast-unstake/src/mock.rs
@@ -23,10 +23,7 @@ use frame_support::{
 	traits::{ConstU64, Currency},
 	weights::constants::WEIGHT_REF_TIME_PER_SECOND,
 };
-use sp_runtime::{
-	traits::{Convert, IdentityLookup},
-	BuildStorage,
-};
+use sp_runtime::{traits::IdentityLookup, BuildStorage};
 
 use pallet_staking::{Exposure, IndividualExposure, StakerStatus};
 use sp_std::prelude::*;
@@ -63,20 +60,11 @@ parameter_types! {
 	pub static ExistentialDeposit: Balance = 1;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = ConstU32<128>;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 pallet_staking_reward_curve::build! {
@@ -116,49 +104,17 @@ impl frame_election_provider_support::ElectionProvider for MockElection {
 	}
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Runtime {
 	type Currency = Balances;
-	type CurrencyBalance = Balance;
 	type UnixTime = pallet_timestamp::Pallet<Self>;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
-	type Reward = ();
-	type SessionsPerEra = ();
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BondingDuration = BondingDuration;
-	type SessionInterface = ();
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
-	type NextNewSession = ();
-	type HistoryDepth = ConstU32<84>;
-	type MaxExposurePageSize = ConstU32<64>;
 	type ElectionProvider = MockElection;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type EventListeners = ();
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
-}
-
-pub struct BalanceToU256;
-impl Convert<Balance, sp_core::U256> for BalanceToU256 {
-	fn convert(n: Balance) -> sp_core::U256 {
-		n.into()
-	}
-}
-
-pub struct U256ToBalance;
-impl Convert<sp_core::U256, Balance> for U256ToBalance {
-	fn convert(n: sp_core::U256) -> Balance {
-		n.try_into().unwrap()
-	}
 }
 
 parameter_types! {
diff --git a/substrate/frame/glutton/Cargo.toml b/substrate/frame/glutton/Cargo.toml
index 730c4e70935c0be3cb840087011a37ca9668b317..39d2b49b50e5377d73c8c0c574263ddb18722d5c 100644
--- a/substrate/frame/glutton/Cargo.toml
+++ b/substrate/frame/glutton/Cargo.toml
@@ -27,6 +27,7 @@ sp-core = { path = "../../primitives/core", default-features = false }
 sp-io = { path = "../../primitives/io", default-features = false }
 sp-runtime = { path = "../../primitives/runtime", default-features = false }
 sp-std = { path = "../../primitives/std", default-features = false }
+sp-inherents = { path = "../../primitives/inherents", default-features = false }
 
 [dev-dependencies]
 pallet-balances = { path = "../balances" }
@@ -43,6 +44,7 @@ std = [
 	"pallet-balances/std",
 	"scale-info/std",
 	"sp-core/std",
+	"sp-inherents/std",
 	"sp-io/std",
 	"sp-runtime/std",
 	"sp-std/std",
diff --git a/substrate/frame/glutton/README.md b/substrate/frame/glutton/README.md
index 89dbe26ec7a9d7eb0ad379f0526a770b4ba45a28..43642df19104a709bdab08661848774ff955fb48 100644
--- a/substrate/frame/glutton/README.md
+++ b/substrate/frame/glutton/README.md
@@ -7,6 +7,7 @@
 The `Glutton` pallet gets the name from its property to consume vast amounts of resources. It can be used to push
 para-chains and their relay-chains to the limits. This is good for testing out theoretical limits in a practical way.
 
-The `Glutton` can be set to consume a fraction of the available unused weight of a chain. It accomplishes this by
-utilizing the `on_idle` hook and consuming a specific ration of the remaining weight. The rations can be set via
-`set_compute` and `set_storage`. Initially the `Glutton` needs to be initialized once with `initialize_pallet`.
+The `Glutton` can be set to consume a fraction of the available block length and unused weight of a chain. It
+accomplishes this by filling the block length up to a ration and utilizing the `on_idle` hook to consume a
+specific ration of the remaining weight. The rations can be set via `set_compute`, `set_storage` and `set_block_length`.
+Initially the `Glutton` needs to be initialized once with `initialize_pallet`.
diff --git a/substrate/frame/glutton/src/lib.rs b/substrate/frame/glutton/src/lib.rs
index 344a70becaeb9eb35cb17c640977f4c8401684ab..5427173b486bab7dfbc830d6af130bf8bccf7e6a 100644
--- a/substrate/frame/glutton/src/lib.rs
+++ b/substrate/frame/glutton/src/lib.rs
@@ -89,6 +89,11 @@ pub mod pallet {
 			/// The storage limit.
 			storage: FixedU64,
 		},
+		/// The block length limit has been updated.
+		BlockLengthLimitSet {
+			/// The block length limit.
+			block_length: FixedU64,
+		},
 	}
 
 	#[pallet::error]
@@ -116,6 +121,13 @@ pub mod pallet {
 	#[pallet::storage]
 	pub(crate) type Storage<T: Config> = StorageValue<_, FixedU64, ValueQuery>;
 
+	/// The proportion of the `block length` to consume on each block.
+	///
+	/// `1.0` is mapped to `100%`. Must be at most [`crate::RESOURCE_HARD_LIMIT`]. Setting this to
+	/// over `1.0` could stall the chain.
+	#[pallet::storage]
+	pub(crate) type Length<T: Config> = StorageValue<_, FixedU64, ValueQuery>;
+
 	/// Storage map used for wasting proof size.
 	///
 	/// It contains no meaningful data - hence the name "Trash". The maximal number of entries is
@@ -146,6 +158,8 @@ pub mod pallet {
 		pub storage: FixedU64,
 		/// The amount of trash data for wasting proof size.
 		pub trash_data_count: u32,
+		/// The block length limit.
+		pub block_length: FixedU64,
 		#[serde(skip)]
 		/// The required configuration field.
 		pub _config: sp_std::marker::PhantomData<T>,
@@ -170,6 +184,9 @@ pub mod pallet {
 
 			assert!(self.storage <= RESOURCE_HARD_LIMIT, "Storage limit is insane");
 			<Storage<T>>::put(self.storage);
+
+			assert!(self.block_length <= RESOURCE_HARD_LIMIT, "Block length limit is insane");
+			<Length<T>>::put(self.block_length);
 		}
 	}
 
@@ -208,6 +225,40 @@ pub mod pallet {
 		}
 	}
 
+	#[pallet::inherent]
+	impl<T: Config> ProvideInherent for Pallet<T> {
+		type Call = Call<T>;
+		type Error = sp_inherents::MakeFatalError<()>;
+
+		const INHERENT_IDENTIFIER: InherentIdentifier = *b"bloated0";
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Mandatory);
+			let bloat_size = Length::<T>::get().saturating_mul_int(max_block_length) as usize;
+			let amount_trash = bloat_size / VALUE_SIZE;
+			let garbage = TrashData::<T>::iter()
+				.map(|(_k, v)| v)
+				.collect::<Vec<_>>()
+				.into_iter()
+				.cycle()
+				.take(amount_trash)
+				.collect::<Vec<_>>();
+
+			Some(Call::bloat { garbage })
+		}
+
+		fn is_inherent(call: &Self::Call) -> bool {
+			matches!(call, Call::bloat { .. })
+		}
+
+		fn check_inherent(call: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
+			match call {
+				Call::bloat { .. } => Ok(()),
+				_ => unreachable!("other calls are not inherents"),
+			}
+		}
+	}
+
 	#[pallet::call(weight = T::WeightInfo)]
 	impl<T: Config> Pallet<T> {
 		/// Initialize the pallet. Should be called once, if no genesis state was provided.
@@ -277,6 +328,31 @@ pub mod pallet {
 			Self::deposit_event(Event::StorageLimitSet { storage });
 			Ok(())
 		}
+
+		/// Increase the block size by including the specified garbage bytes.
+		#[pallet::call_index(3)]
+		#[pallet::weight((0, DispatchClass::Mandatory))]
+		pub fn bloat(_origin: OriginFor<T>, _garbage: Vec<[u8; VALUE_SIZE]>) -> DispatchResult {
+			Ok(())
+		}
+
+		/// Set how much of the block length should be filled with trash data on each block.
+		///
+		/// `1.0` means that all block should be filled. If set to `1.0`, storage proof size will
+		///  be close to zero.
+		///
+		/// Only callable by Root or `AdminOrigin`.
+		#[pallet::call_index(4)]
+		#[pallet::weight({1})]
+		pub fn set_block_length(origin: OriginFor<T>, block_length: FixedU64) -> DispatchResult {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+
+			ensure!(block_length <= RESOURCE_HARD_LIMIT, Error::<T>::InsaneLimit);
+			Length::<T>::set(block_length);
+
+			Self::deposit_event(Event::BlockLengthLimitSet { block_length });
+			Ok(())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {
diff --git a/substrate/frame/glutton/src/mock.rs b/substrate/frame/glutton/src/mock.rs
index 132ef5cfbcbbabb077b7968cc0ae1451bcd06bc7..7163d7c46781f331222ee6dbbc9cf4807b2ecb1e 100644
--- a/substrate/frame/glutton/src/mock.rs
+++ b/substrate/frame/glutton/src/mock.rs
@@ -50,10 +50,14 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 	ext
 }
 
-/// Set the `compute` and `storage` limits.
+/// Set the `compute`, `storage` and `block_length` limits.
 ///
 /// `1.0` corresponds to `100%`.
-pub fn set_limits(compute: f64, storage: f64) {
+pub fn set_limits(compute: f64, storage: f64, block_length: f64) {
 	assert_ok!(Glutton::set_compute(RuntimeOrigin::root(), FixedU64::from_float(compute)));
 	assert_ok!(Glutton::set_storage(RuntimeOrigin::root(), FixedU64::from_float(storage)));
+	assert_ok!(Glutton::set_block_length(
+		RuntimeOrigin::root(),
+		FixedU64::from_float(block_length)
+	));
 }
diff --git a/substrate/frame/glutton/src/tests.rs b/substrate/frame/glutton/src/tests.rs
index b72d5272772540e5106af8cec248170cfcf910d6..81d228f39a9363961dd7e64cc952414d07ab1a33 100644
--- a/substrate/frame/glutton/src/tests.rs
+++ b/substrate/frame/glutton/src/tests.rs
@@ -123,6 +123,43 @@ fn setting_compute_respects_limit() {
 	});
 }
 
+#[test]
+fn setting_block_length_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Compute::<Test>::get(), Zero::zero());
+
+		assert_ok!(Glutton::set_block_length(RuntimeOrigin::root(), FixedU64::from_float(0.3)));
+		assert_eq!(Length::<Test>::get(), FixedU64::from_float(0.3));
+		System::assert_last_event(
+			Event::BlockLengthLimitSet { block_length: FixedU64::from_float(0.3) }.into(),
+		);
+
+		assert_noop!(
+			Glutton::set_block_length(RuntimeOrigin::signed(1), FixedU64::from_float(0.5)),
+			DispatchError::BadOrigin
+		);
+		assert_noop!(
+			Glutton::set_block_length(RuntimeOrigin::none(), FixedU64::from_float(0.5)),
+			DispatchError::BadOrigin
+		);
+	});
+}
+
+#[test]
+fn setting_block_length_respects_limit() {
+	new_test_ext().execute_with(|| {
+		// < 1000% is fine
+		assert_ok!(Glutton::set_block_length(RuntimeOrigin::root(), FixedU64::from_float(9.99)),);
+		// == 1000% is fine
+		assert_ok!(Glutton::set_block_length(RuntimeOrigin::root(), FixedU64::from_u32(10)),);
+		// > 1000% is not
+		assert_noop!(
+			Glutton::set_block_length(RuntimeOrigin::root(), FixedU64::from_float(10.01)),
+			Error::<Test>::InsaneLimit
+		);
+	});
+}
+
 #[test]
 fn setting_storage_works() {
 	new_test_ext().execute_with(|| {
@@ -163,7 +200,7 @@ fn setting_storage_respects_limit() {
 #[test]
 fn on_idle_works() {
 	new_test_ext().execute_with(|| {
-		set_limits(One::one(), One::one());
+		set_limits(One::one(), One::one(), One::one());
 
 		Glutton::on_idle(1, Weight::from_parts(20_000_000, 0));
 	});
@@ -173,7 +210,7 @@ fn on_idle_works() {
 #[test]
 fn on_idle_weight_high_proof_is_close_enough_works() {
 	new_test_ext().execute_with(|| {
-		set_limits(One::one(), One::one());
+		set_limits(One::one(), One::one(), One::one());
 
 		let should = Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, WEIGHT_PROOF_SIZE_PER_MB * 5);
 		let got = Glutton::on_idle(1, should);
@@ -196,7 +233,7 @@ fn on_idle_weight_high_proof_is_close_enough_works() {
 #[test]
 fn on_idle_weight_low_proof_is_close_enough_works() {
 	new_test_ext().execute_with(|| {
-		set_limits(One::one(), One::one());
+		set_limits(One::one(), One::one(), One::one());
 
 		let should = Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, WEIGHT_PROOF_SIZE_PER_KB * 20);
 		let got = Glutton::on_idle(1, should);
@@ -224,7 +261,7 @@ fn on_idle_weight_over_unity_is_close_enough_works() {
 		let max_block =
 			Weight::from_parts(500 * WEIGHT_REF_TIME_PER_MILLIS, 5 * WEIGHT_PROOF_SIZE_PER_MB);
 		// But now we tell it to consume more than that.
-		set_limits(1.75, 1.5);
+		set_limits(1.75, 1.5, 0.0);
 		let want = Weight::from_parts(
 			(1.75 * max_block.ref_time() as f64) as u64,
 			(1.5 * max_block.proof_size() as f64) as u64,
diff --git a/substrate/frame/grandpa/Cargo.toml b/substrate/frame/grandpa/Cargo.toml
index 302ce327aed4b037432b660cf65b0c9aba5123f6..37048b06608f613f0e0c724314b7fb2093dec619 100644
--- a/substrate/frame/grandpa/Cargo.toml
+++ b/substrate/frame/grandpa/Cargo.toml
@@ -34,7 +34,7 @@ sp-staking = { path = "../../primitives/staking", default-features = false, feat
 sp-std = { path = "../../primitives/std", default-features = false }
 
 [dev-dependencies]
-grandpa = { package = "finality-grandpa", version = "0.16.2", features = ["derive-codec"] }
+finality-grandpa = { version = "0.16.2", features = ["derive-codec"] }
 frame-benchmarking = { path = "../benchmarking" }
 frame-election-provider-support = { path = "../election-provider-support" }
 pallet-balances = { path = "../balances" }
diff --git a/substrate/frame/grandpa/src/mock.rs b/substrate/frame/grandpa/src/mock.rs
index 2d54f525b1f0c6b6a78f8df848c5770391f4fa2d..5ba7da7f9fda2a6e0d30f1b04b7aac1e808c55cb 100644
--- a/substrate/frame/grandpa/src/mock.rs
+++ b/substrate/frame/grandpa/src/mock.rs
@@ -20,8 +20,8 @@
 #![cfg(test)]
 
 use crate::{self as pallet_grandpa, AuthorityId, AuthorityList, Config, ConsensusLog};
-use ::grandpa as finality_grandpa;
 use codec::Encode;
+use finality_grandpa;
 use frame_election_provider_support::{
 	bounds::{ElectionBounds, ElectionBoundsBuilder},
 	onchain, SequentialPhragmen,
@@ -108,20 +108,11 @@ impl pallet_authorship::Config for Test {
 	type EventHandler = ();
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = u128;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ConstU128<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_timestamp::Config for Test {
@@ -159,35 +150,22 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type Bounds = ElectionsBoundsOnChain;
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Test {
-	type RewardRemainder = ();
-	type CurrencyToVote = ();
-	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
-	type Slash = ();
-	type Reward = ();
 	type SessionsPerEra = SessionsPerEra;
 	type BondingDuration = BondingDuration;
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type SessionInterface = Self;
 	type UnixTime = pallet_timestamp::Pallet<Test>;
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
-	type MaxExposurePageSize = ConstU32<64>;
 	type NextNewSession = Session;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
 	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type HistoryDepth = ConstU32<84>;
-	type EventListeners = ();
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
 
 impl pallet_offences::Config for Test {
diff --git a/substrate/frame/identity/Cargo.toml b/substrate/frame/identity/Cargo.toml
index e0bce8a77bdc68c26a9de9b95438b8b06ff4228b..987e418048d3629b0f2c042d898fe7e2d925a22c 100644
--- a/substrate/frame/identity/Cargo.toml
+++ b/substrate/frame/identity/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pallet-identity"
-version = "28.0.0"
+version = "29.0.0"
 authors.workspace = true
 edition.workspace = true
 license = "Apache-2.0"
diff --git a/substrate/frame/identity/src/benchmarking.rs b/substrate/frame/identity/src/benchmarking.rs
index cdcdb9522615d0439f4d8370551d73b710edc685..957549b19f859d39377ca6281e51fb35cf039d8e 100644
--- a/substrate/frame/identity/src/benchmarking.rs
+++ b/substrate/frame/identity/src/benchmarking.rs
@@ -22,7 +22,6 @@
 use super::*;
 
 use crate::Pallet as Identity;
-use codec::Encode;
 use frame_benchmarking::{account, v2::*, whitelisted_caller, BenchmarkError};
 use frame_support::{
 	assert_ok, ensure,
@@ -623,17 +622,17 @@ mod benchmarks {
 
 		let username = bench_username();
 		let bounded_username = bounded_username::<T>(username.clone(), suffix.clone());
-		let encoded_username = Encode::encode(&bounded_username.to_vec());
 
 		let public = sr25519_generate(0.into(), None);
 		let who_account: T::AccountId = MultiSigner::Sr25519(public).into_account().into();
 		let who_lookup = T::Lookup::unlookup(who_account.clone());
 
-		let signature =
-			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &encoded_username).unwrap());
+		let signature = MultiSignature::Sr25519(
+			sr25519_sign(0.into(), &public, &bounded_username[..]).unwrap(),
+		);
 
 		// Verify signature here to avoid surprise errors at runtime
-		assert!(signature.verify(&encoded_username[..], &public.into()));
+		assert!(signature.verify(&bounded_username[..], &public.into()));
 
 		#[extrinsic_call]
 		_(RawOrigin::Signed(authority.clone()), who_lookup, username, Some(signature.into()));
diff --git a/substrate/frame/identity/src/lib.rs b/substrate/frame/identity/src/lib.rs
index 4a977880b3150cf9ffa7e2b4032e258483a6d242..50d6de32ac61e7c8ee9d8aeeeace0b3a42dac65b 100644
--- a/substrate/frame/identity/src/lib.rs
+++ b/substrate/frame/identity/src/lib.rs
@@ -1116,8 +1116,7 @@ pub mod pallet {
 			if let Some(s) = signature {
 				// Account has pre-signed an authorization. Verify the signature provided and grant
 				// the username directly.
-				let encoded = Encode::encode(&bounded_username.to_vec());
-				Self::validate_signature(&encoded, &s, &who)?;
+				Self::validate_signature(&bounded_username[..], &s, &who)?;
 				Self::insert_username(&who, bounded_username);
 			} else {
 				// The user must accept the username, therefore, queue it.
@@ -1169,7 +1168,9 @@ pub mod pallet {
 		pub fn set_primary_username(origin: OriginFor<T>, username: Username<T>) -> DispatchResult {
 			// ensure `username` maps to `origin` (i.e. has already been set by an authority).
 			let who = ensure_signed(origin)?;
-			ensure!(AccountOfUsername::<T>::contains_key(&username), Error::<T>::NoUsername);
+			let account_of_username =
+				AccountOfUsername::<T>::get(&username).ok_or(Error::<T>::NoUsername)?;
+			ensure!(who == account_of_username, Error::<T>::InvalidUsername);
 			let (registration, _maybe_username) =
 				IdentityOf::<T>::get(&who).ok_or(Error::<T>::NoIdentity)?;
 			IdentityOf::<T>::insert(&who, (registration, Some(username.clone())));
@@ -1265,12 +1266,12 @@ impl<T: Config> Pallet<T> {
 
 	/// Validate a signature. Supports signatures on raw `data` or `data` wrapped in HTML `<Bytes>`.
 	pub fn validate_signature(
-		data: &Vec<u8>,
+		data: &[u8],
 		signature: &T::OffchainSignature,
 		signer: &T::AccountId,
 	) -> DispatchResult {
 		// Happy path, user has signed the raw data.
-		if signature.verify(&data[..], &signer) {
+		if signature.verify(data, &signer) {
 			return Ok(())
 		}
 		// NOTE: for security reasons modern UIs implicitly wrap the data requested to sign into
diff --git a/substrate/frame/identity/src/tests.rs b/substrate/frame/identity/src/tests.rs
index 0a9464256ce3fbf7bf84d0a463b9c00ad87bef29..09edd5de79bb2ff9ba483dbd03c6b24ad59a28de 100644
--- a/substrate/frame/identity/src/tests.rs
+++ b/substrate/frame/identity/src/tests.rs
@@ -25,7 +25,7 @@ use crate::{
 
 use codec::{Decode, Encode};
 use frame_support::{
-	assert_noop, assert_ok, derive_impl, parameter_types,
+	assert_err, assert_noop, assert_ok, derive_impl, parameter_types,
 	traits::{ConstU32, ConstU64, Get, OnFinalize, OnInitialize},
 	BoundedVec,
 };
@@ -61,20 +61,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 parameter_types! {
@@ -1042,13 +1031,13 @@ fn set_username_with_signature_without_existing_identity_should_work() {
 
 		// set up username
 		let (username, username_to_sign) = test_username_of(b"42".to_vec(), suffix);
-		let encoded_username = Encode::encode(&username_to_sign.to_vec());
 
 		// set up user and sign message
 		let public = sr25519_generate(0.into(), None);
 		let who_account: AccountIdOf<Test> = MultiSigner::Sr25519(public).into_account().into();
-		let signature =
-			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &encoded_username).unwrap());
+		let signature = MultiSignature::Sr25519(
+			sr25519_sign(0.into(), &public, &username_to_sign[..]).unwrap(),
+		);
 
 		assert_ok!(Identity::set_username_for(
 			RuntimeOrigin::signed(authority),
@@ -1093,13 +1082,13 @@ fn set_username_with_signature_with_existing_identity_should_work() {
 
 		// set up username
 		let (username, username_to_sign) = test_username_of(b"42".to_vec(), suffix);
-		let encoded_username = Encode::encode(&username_to_sign.to_vec());
 
 		// set up user and sign message
 		let public = sr25519_generate(0.into(), None);
 		let who_account: AccountIdOf<Test> = MultiSigner::Sr25519(public).into_account().into();
-		let signature =
-			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &encoded_username).unwrap());
+		let signature = MultiSignature::Sr25519(
+			sr25519_sign(0.into(), &public, &username_to_sign[..]).unwrap(),
+		);
 
 		// Set an identity for who. They need some balance though.
 		Balances::make_free_balance_be(&who_account, 1000);
@@ -1156,13 +1145,13 @@ fn set_username_with_bytes_signature_should_work() {
 		let unwrapped_username = username_to_sign.to_vec();
 
 		// Sign an unwrapped version, as in `username.suffix`.
-		let unwrapped_encoded = Encode::encode(&unwrapped_username);
-		let signature_on_unwrapped =
-			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &unwrapped_encoded).unwrap());
+		let signature_on_unwrapped = MultiSignature::Sr25519(
+			sr25519_sign(0.into(), &public, &unwrapped_username[..]).unwrap(),
+		);
 
 		// Trivial
 		assert_ok!(Identity::validate_signature(
-			&unwrapped_encoded,
+			&unwrapped_username,
 			&signature_on_unwrapped,
 			&who_account
 		));
@@ -1174,7 +1163,7 @@ fn set_username_with_bytes_signature_should_work() {
 		let mut wrapped_username: Vec<u8> =
 			Vec::with_capacity(unwrapped_username.len() + prehtml.len() + posthtml.len());
 		wrapped_username.extend(prehtml);
-		wrapped_username.extend(unwrapped_encoded.clone());
+		wrapped_username.extend(&unwrapped_username);
 		wrapped_username.extend(posthtml);
 		let signature_on_wrapped =
 			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &wrapped_username).unwrap());
@@ -1182,7 +1171,7 @@ fn set_username_with_bytes_signature_should_work() {
 		// We want to call `validate_signature` on the *unwrapped* username, but the signature on
 		// the *wrapped* data.
 		assert_ok!(Identity::validate_signature(
-			&unwrapped_encoded,
+			&unwrapped_username,
 			&signature_on_wrapped,
 			&who_account
 		));
@@ -1401,9 +1390,8 @@ fn setting_primary_should_work() {
 
 		// set up username
 		let (first_username, first_to_sign) = test_username_of(b"42".to_vec(), suffix.clone());
-		let encoded_username = Encode::encode(&first_to_sign.to_vec());
 		let first_signature =
-			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &encoded_username).unwrap());
+			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &first_to_sign[..]).unwrap());
 
 		assert_ok!(Identity::set_username_for(
 			RuntimeOrigin::signed(authority.clone()),
@@ -1427,9 +1415,8 @@ fn setting_primary_should_work() {
 
 		// set up username
 		let (second_username, second_to_sign) = test_username_of(b"101".to_vec(), suffix);
-		let encoded_username = Encode::encode(&second_to_sign.to_vec());
 		let second_signature =
-			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &encoded_username).unwrap());
+			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &second_to_sign[..]).unwrap());
 
 		assert_ok!(Identity::set_username_for(
 			RuntimeOrigin::signed(authority),
@@ -1491,6 +1478,72 @@ fn setting_primary_should_work() {
 	});
 }
 
+#[test]
+fn must_own_primary() {
+	new_test_ext().execute_with(|| {
+		// set up authority
+		let [authority, _] = unfunded_accounts();
+		let suffix: Vec<u8> = b"test".to_vec();
+		let allocation: u32 = 10;
+		assert_ok!(Identity::add_username_authority(
+			RuntimeOrigin::root(),
+			authority.clone(),
+			suffix.clone(),
+			allocation
+		));
+
+		// Set up first user ("pi") and a username.
+		let pi_public = sr25519_generate(0.into(), None);
+		let pi_account: AccountIdOf<Test> = MultiSigner::Sr25519(pi_public).into_account().into();
+		let (pi_username, pi_to_sign) =
+			test_username_of(b"username314159".to_vec(), suffix.clone());
+		let pi_signature =
+			MultiSignature::Sr25519(sr25519_sign(0.into(), &pi_public, &pi_to_sign[..]).unwrap());
+		assert_ok!(Identity::set_username_for(
+			RuntimeOrigin::signed(authority.clone()),
+			pi_account.clone(),
+			pi_username.clone(),
+			Some(pi_signature)
+		));
+
+		// Set up second user ("e") and a username.
+		let e_public = sr25519_generate(1.into(), None);
+		let e_account: AccountIdOf<Test> = MultiSigner::Sr25519(e_public).into_account().into();
+		let (e_username, e_to_sign) = test_username_of(b"username271828".to_vec(), suffix.clone());
+		let e_signature =
+			MultiSignature::Sr25519(sr25519_sign(1.into(), &e_public, &e_to_sign[..]).unwrap());
+		assert_ok!(Identity::set_username_for(
+			RuntimeOrigin::signed(authority.clone()),
+			e_account.clone(),
+			e_username.clone(),
+			Some(e_signature)
+		));
+
+		// Ensure that both users have their usernames.
+		assert_eq!(
+			AccountOfUsername::<Test>::get::<&Username<Test>>(&pi_to_sign),
+			Some(pi_account.clone())
+		);
+		assert_eq!(
+			AccountOfUsername::<Test>::get::<&Username<Test>>(&e_to_sign),
+			Some(e_account.clone())
+		);
+
+		// Cannot set primary to a username that does not exist.
+		let (_, c_username) = test_username_of(b"speedoflight".to_vec(), suffix.clone());
+		assert_err!(
+			Identity::set_primary_username(RuntimeOrigin::signed(pi_account.clone()), c_username,),
+			Error::<Test>::NoUsername
+		);
+
+		// Cannot take someone else's username as your primary.
+		assert_err!(
+			Identity::set_primary_username(RuntimeOrigin::signed(pi_account.clone()), e_to_sign,),
+			Error::<Test>::InvalidUsername
+		);
+	});
+}
+
 #[test]
 fn unaccepted_usernames_should_expire() {
 	new_test_ext().execute_with(|| {
@@ -1563,13 +1616,13 @@ fn removing_dangling_usernames_should_work() {
 
 		// set up username
 		let (username, username_to_sign) = test_username_of(b"42".to_vec(), suffix.clone());
-		let encoded_username = Encode::encode(&username_to_sign.to_vec());
 
 		// set up user and sign message
 		let public = sr25519_generate(0.into(), None);
 		let who_account: AccountIdOf<Test> = MultiSigner::Sr25519(public).into_account().into();
-		let signature =
-			MultiSignature::Sr25519(sr25519_sign(0.into(), &public, &encoded_username).unwrap());
+		let signature = MultiSignature::Sr25519(
+			sr25519_sign(0.into(), &public, &username_to_sign[..]).unwrap(),
+		);
 
 		// Set an identity for who. They need some balance though.
 		Balances::make_free_balance_be(&who_account, 1000);
@@ -1587,11 +1640,10 @@ fn removing_dangling_usernames_should_work() {
 
 		// Now they set up a second username.
 		let (username_two, username_two_to_sign) = test_username_of(b"43".to_vec(), suffix);
-		let encoded_username_two = Encode::encode(&username_two_to_sign.to_vec());
 
 		// set up user and sign message
 		let signature_two = MultiSignature::Sr25519(
-			sr25519_sign(0.into(), &public, &encoded_username_two).unwrap(),
+			sr25519_sign(0.into(), &public, &username_two_to_sign[..]).unwrap(),
 		);
 
 		assert_ok!(Identity::set_username_for(
diff --git a/substrate/frame/im-online/src/mock.rs b/substrate/frame/im-online/src/mock.rs
index cc448dc1ae10bcc80a4389348b5969042bc02caf..882581702ea11341146c908d90205361dca0db30 100644
--- a/substrate/frame/im-online/src/mock.rs
+++ b/substrate/frame/im-online/src/mock.rs
@@ -25,10 +25,9 @@ use frame_support::{
 	weights::Weight,
 };
 use pallet_session::historical as pallet_session_historical;
-use sp_core::H256;
 use sp_runtime::{
 	testing::{TestXt, UintAuthorityId},
-	traits::{BlakeTwo256, ConvertInto, IdentityLookup},
+	traits::ConvertInto,
 	BuildStorage, Permill,
 };
 use sp_staking::{
@@ -114,29 +113,7 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type Nonce = u64;
-	type RuntimeCall = RuntimeCall;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = ();
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
 }
 
 parameter_types! {
diff --git a/substrate/frame/indices/src/mock.rs b/substrate/frame/indices/src/mock.rs
index 9f8bf8c3758832d203d088616b4cb5247a116805..72bbc6dab4a42b7c3556aa986a770ff3fbf24bdc 100644
--- a/substrate/frame/indices/src/mock.rs
+++ b/substrate/frame/indices/src/mock.rs
@@ -20,11 +20,7 @@
 #![cfg(test)]
 
 use crate::{self as pallet_indices, Config};
-use frame_support::{
-	derive_impl,
-	traits::{ConstU32, ConstU64},
-};
-use sp_core::H256;
+use frame_support::{derive_impl, traits::ConstU64};
 use sp_runtime::BuildStorage;
 
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -40,45 +36,15 @@ frame_support::construct_runtime!(
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
 	type Nonce = u64;
-	type Hash = H256;
-	type Hashing = ::sp_runtime::traits::BlakeTwo256;
-	type AccountId = u64;
 	type Lookup = Indices;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl Config for Test {
diff --git a/substrate/frame/lottery/src/mock.rs b/substrate/frame/lottery/src/mock.rs
index 596e1a9d837d16486e8a2017b0ab679a02bc2dd6..d2c442e2ac6e5acd0b096308ebed02ad9fe0f78e 100644
--- a/substrate/frame/lottery/src/mock.rs
+++ b/substrate/frame/lottery/src/mock.rs
@@ -22,7 +22,7 @@ use crate as pallet_lottery;
 
 use frame_support::{
 	derive_impl, parameter_types,
-	traits::{ConstU32, ConstU64, OnFinalize, OnInitialize},
+	traits::{ConstU32, OnFinalize, OnInitialize},
 };
 use frame_support_test::TestRandomness;
 use frame_system::EnsureRoot;
@@ -49,20 +49,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 parameter_types! {
diff --git a/substrate/frame/metadata-hash-extension/Cargo.toml b/substrate/frame/metadata-hash-extension/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..13d4bd0c2ea909700dda8d1ec621892c4a728724
--- /dev/null
+++ b/substrate/frame/metadata-hash-extension/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "frame-metadata-hash-extension"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "FRAME signed extension for verifying the metadata hash"
+
+[dependencies]
+array-bytes = "6.2.2"
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] }
+sp-runtime = { path = "../../primitives/runtime", default-features = false, features = ["serde"] }
+frame-support = { path = "../support", default-features = false }
+frame-system = { path = "../system", default-features = false }
+log = { workspace = true, default-features = false }
+docify = "0.2.8"
+
+[dev-dependencies]
+substrate-wasm-builder = { path = "../../utils/wasm-builder", features = ["metadata-hash"] }
+substrate-test-runtime-client = { path = "../../test-utils/runtime/client" }
+sp-api = { path = "../../primitives/api" }
+sp-transaction-pool = { path = "../../primitives/transaction-pool" }
+merkleized-metadata = "0.1.0"
+frame-metadata = { version = "16.0.0", features = ["current"] }
+sp-tracing = { path = "../../primitives/tracing" }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-runtime/std",
+]
diff --git a/substrate/frame/metadata-hash-extension/src/lib.rs b/substrate/frame/metadata-hash-extension/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d09acbfb3df22e6c3e6706019ede1f16621ef767
--- /dev/null
+++ b/substrate/frame/metadata-hash-extension/src/lib.rs
@@ -0,0 +1,168 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+//! The [`CheckMetadataHash`] signed extension.
+//!
+//! The extension for optionally checking the metadata hash. For information how it works and what
+//! it does exactly, see the docs of [`CheckMetadataHash`].
+//!
+//! # Integration
+//!
+//! As any signed extension you will need to add it to your runtime signed extensions:
+#![doc = docify::embed!("src/tests.rs", add_metadata_hash_extension)]
+//! As the extension requires the `RUNTIME_METADATA_HASH` environment variable to be present at
+//! compile time, it requires a little bit more setup. To have this environment variable available
+//! at compile time required to tell the `substrate-wasm-builder` to do so:
+#![doc = docify::embed!("src/tests.rs", enable_metadata_hash_in_wasm_builder)]
+//! As generating the metadata hash requires to compile the runtime twice, it is
+//! recommended to only enable the metadata hash generation when doing a build for a release or when
+//! you want to test this feature.
+
+extern crate alloc;
+/// For our tests
+extern crate self as frame_metadata_hash_extension;
+
+use codec::{Decode, Encode};
+use frame_support::DebugNoBound;
+use frame_system::Config;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, SignedExtension},
+	transaction_validity::{TransactionValidityError, UnknownTransaction},
+};
+
+#[cfg(test)]
+mod tests;
+
+/// The mode of [`CheckMetadataHash`].
+#[derive(Decode, Encode, PartialEq, Debug, TypeInfo, Clone, Copy, Eq)]
+enum Mode {
+	Disabled,
+	Enabled,
+}
+
+/// Wrapper around the metadata hash and from where to get it from.
+#[derive(Default, Debug, PartialEq, Clone, Copy, Eq)]
+enum MetadataHash {
+	/// Fetch it from the `RUNTIME_METADATA_HASH` env variable at compile time.
+	#[default]
+	FetchFromEnv,
+	/// Use the given metadata hash.
+	Custom([u8; 32]),
+}
+
+impl MetadataHash {
+	/// Returns the metadata hash.
+	fn hash(&self) -> Option<[u8; 32]> {
+		match self {
+			Self::FetchFromEnv =>
+				option_env!("RUNTIME_METADATA_HASH").map(array_bytes::hex2array_unchecked),
+			Self::Custom(hash) => Some(*hash),
+		}
+	}
+}
+
+/// Extension for optionally verifying the metadata hash.
+///
+/// The metadata hash is cryptographical representation of the runtime metadata. This metadata hash
+/// is build as described in [RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html).
+/// This metadata hash should give users the confidence that what they build with an online wallet
+/// is the same they are signing with their offline wallet and then applying on chain. To ensure
+/// that the online wallet is not tricking the offline wallet into decoding and showing an incorrect
+/// extrinsic, the offline wallet will include the metadata hash into the additional signed data and
+/// the runtime will then do the same. If the metadata hash doesn't match, the signature
+/// verification will fail and thus, the transaction will be rejected. The RFC contains more details
+/// on how it works.
+///
+/// The extension adds one byte (the `mode`) to the size of the extrinsic. This one byte is
+/// controlling if the metadata hash should be added to the signed data or not. Mode `0` means that
+/// the metadata hash is not added and thus, `None` is added to the signed data. Mode `1` means that
+/// the metadata hash is added and thus, `Some(metadata_hash)` is added to the signed data. Further
+/// values of `mode` are reserved for future changes.
+///
+/// The metadata hash is read from the environment variable `RUNTIME_METADATA_HASH`. This
+/// environment variable is for example set by the `substrate-wasm-builder` when the feature for
+/// generating the metadata hash is enabled. If the environment variable is not set and `mode = 1`
+/// is passed, the transaction is rejected with [`UnknownTransaction::CannotLookup`].
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo, DebugNoBound)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckMetadataHash<T> {
+	_phantom: core::marker::PhantomData<T>,
+	mode: Mode,
+	#[codec(skip)]
+	metadata_hash: MetadataHash,
+}
+
+impl<T> CheckMetadataHash<T> {
+	/// Creates new `SignedExtension` to check metadata hash.
+	pub fn new(enable: bool) -> Self {
+		Self {
+			_phantom: core::marker::PhantomData,
+			mode: if enable { Mode::Enabled } else { Mode::Disabled },
+			metadata_hash: MetadataHash::FetchFromEnv,
+		}
+	}
+
+	/// Create an instance that uses the given `metadata_hash`.
+	///
+	/// This is useful for testing the extension.
+	pub fn new_with_custom_hash(metadata_hash: [u8; 32]) -> Self {
+		Self {
+			_phantom: core::marker::PhantomData,
+			mode: Mode::Enabled,
+			metadata_hash: MetadataHash::Custom(metadata_hash),
+		}
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckMetadataHash<T> {
+	type AccountId = T::AccountId;
+	type Call = <T as Config>::RuntimeCall;
+	type AdditionalSigned = Option<[u8; 32]>;
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckMetadataHash";
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		let signed = match self.mode {
+			Mode::Disabled => None,
+			Mode::Enabled => match self.metadata_hash.hash() {
+				Some(hash) => Some(hash),
+				None => return Err(UnknownTransaction::CannotLookup.into()),
+			},
+		};
+
+		log::debug!(
+			target: "runtime::metadata-hash",
+			"CheckMetadataHash::additional_signed => {:?}",
+			signed.as_ref().map(|h| array_bytes::bytes2hex("0x", h)),
+		);
+
+		Ok(signed)
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		self.validate(who, call, info, len).map(|_| ())
+	}
+}
diff --git a/substrate/frame/metadata-hash-extension/src/tests.rs b/substrate/frame/metadata-hash-extension/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f13eecfd94bfb5f78224e7dc40f2b08e1ce7c034
--- /dev/null
+++ b/substrate/frame/metadata-hash-extension/src/tests.rs
@@ -0,0 +1,179 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::CheckMetadataHash;
+use codec::{Decode, Encode};
+use frame_metadata::RuntimeMetadataPrefixed;
+use frame_support::{
+	derive_impl,
+	pallet_prelude::{InvalidTransaction, TransactionValidityError},
+};
+use merkleized_metadata::{generate_metadata_digest, ExtraInfo};
+use sp_api::{Metadata, ProvideRuntimeApi};
+use sp_runtime::{
+	traits::{Extrinsic as _, SignedExtension},
+	transaction_validity::{TransactionSource, UnknownTransaction},
+};
+use sp_transaction_pool::runtime_api::TaggedTransactionQueue;
+use substrate_test_runtime_client::{
+	prelude::*,
+	runtime::{self, ExtrinsicBuilder},
+	DefaultTestClientBuilderExt, TestClientBuilder,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime! {
+	pub enum Test {
+		System: frame_system,
+	}
+}
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+}
+
+#[test]
+fn rejects_when_no_metadata_hash_was_passed() {
+	let ext = CheckMetadataHash::<Test>::decode(&mut &1u8.encode()[..]).unwrap();
+	assert_eq!(Err(UnknownTransaction::CannotLookup.into()), ext.additional_signed());
+}
+
+#[test]
+fn rejects_unknown_mode() {
+	assert!(CheckMetadataHash::<Test>::decode(&mut &50u8.encode()[..]).is_err());
+}
+
+/// Generate the metadata hash for the `test-runtime`.
+fn generate_metadata_hash(metadata: RuntimeMetadataPrefixed) -> [u8; 32] {
+	let runtime_version = runtime::VERSION;
+	let base58_prefix = 0;
+
+	let extra_info = ExtraInfo {
+		spec_version: runtime_version.spec_version,
+		spec_name: runtime_version.spec_name.into(),
+		base58_prefix,
+		decimals: 10,
+		token_symbol: "TOKEN".into(),
+	};
+
+	generate_metadata_digest(&metadata.1, extra_info).unwrap().hash()
+}
+
+#[test]
+fn ensure_check_metadata_works_on_real_extrinsics() {
+	sp_tracing::try_init_simple();
+
+	let client = TestClientBuilder::new().build();
+	let runtime_api = client.runtime_api();
+	let best_hash = client.chain_info().best_hash;
+
+	let metadata = RuntimeMetadataPrefixed::decode(
+		&mut &runtime_api.metadata_at_version(best_hash, 15).unwrap().unwrap()[..],
+	)
+	.unwrap();
+
+	let valid_transaction = ExtrinsicBuilder::new_include_data(vec![1, 2, 3])
+		.metadata_hash(generate_metadata_hash(metadata))
+		.build();
+	// Ensure that the transaction is signed.
+	assert!(valid_transaction.is_signed().unwrap());
+
+	runtime_api
+		.validate_transaction(best_hash, TransactionSource::External, valid_transaction, best_hash)
+		.unwrap()
+		.unwrap();
+
+	// Including some random metadata hash should make the transaction invalid.
+	let invalid_transaction = ExtrinsicBuilder::new_include_data(vec![1, 2, 3])
+		.metadata_hash([10u8; 32])
+		.build();
+	// Ensure that the transaction is signed.
+	assert!(invalid_transaction.is_signed().unwrap());
+
+	assert_eq!(
+		TransactionValidityError::from(InvalidTransaction::BadProof),
+		runtime_api
+			.validate_transaction(
+				best_hash,
+				TransactionSource::External,
+				invalid_transaction,
+				best_hash
+			)
+			.unwrap()
+			.unwrap_err()
+	);
+}
+
+#[allow(unused)]
+mod docs {
+	use super::*;
+
+	#[docify::export]
+	mod add_metadata_hash_extension {
+		frame_support::construct_runtime! {
+			pub enum Runtime {
+				System: frame_system,
+			}
+		}
+
+		/// The `SignedExtension` to the basic transaction logic.
+		pub type SignedExtra = (
+			frame_system::CheckNonZeroSender<Runtime>,
+			frame_system::CheckSpecVersion<Runtime>,
+			frame_system::CheckTxVersion<Runtime>,
+			frame_system::CheckGenesis<Runtime>,
+			frame_system::CheckMortality<Runtime>,
+			frame_system::CheckNonce<Runtime>,
+			frame_system::CheckWeight<Runtime>,
+			// Add the `CheckMetadataHash` extension.
+			// The position in this list is not important, so we could also add it to beginning.
+			frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
+		);
+
+		/// In your runtime this will be your real address type.
+		type Address = ();
+		/// In your runtime this will be your real signature type.
+		type Signature = ();
+
+		/// Unchecked extrinsic type as expected by this runtime.
+		pub type UncheckedExtrinsic =
+			sp_runtime::generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
+	}
+
+	// Put here to not have it in the docs as well.
+	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+	impl frame_system::Config for add_metadata_hash_extension::Runtime {
+		type Block = Block;
+		type RuntimeEvent = add_metadata_hash_extension::RuntimeEvent;
+		type RuntimeOrigin = add_metadata_hash_extension::RuntimeOrigin;
+		type RuntimeCall = add_metadata_hash_extension::RuntimeCall;
+		type PalletInfo = add_metadata_hash_extension::PalletInfo;
+	}
+
+	#[docify::export]
+	fn enable_metadata_hash_in_wasm_builder() {
+		substrate_wasm_builder::WasmBuilder::init_with_defaults()
+			// Requires the `metadata-hash` feature to be activated.
+			// You need to pass the main token symbol and its number of decimals.
+			.enable_metadata_hash("TOKEN", 12)
+			// The runtime will be build twice and the second time the `RUNTIME_METADATA_HASH`
+			// environment variable will be set for the `CheckMetadataHash` extension.
+			.build()
+	}
+}
diff --git a/substrate/frame/multisig/src/tests.rs b/substrate/frame/multisig/src/tests.rs
index 0d73e3db66153f6c5fe16dd4974567c3584a2372..cfdd33f7dfcc3d3f5a49c302c0784718a70dfaca 100644
--- a/substrate/frame/multisig/src/tests.rs
+++ b/substrate/frame/multisig/src/tests.rs
@@ -41,7 +41,6 @@ frame_support::construct_runtime!(
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
 	type Block = Block;
-	type BlockHashCount = ConstU32<250>;
 	type AccountData = pallet_balances::AccountData<u64>;
 	// This pallet wishes to overwrite this.
 	type BaseCallFilter = TestBaseCallFilter;
diff --git a/substrate/frame/nft-fractionalization/src/mock.rs b/substrate/frame/nft-fractionalization/src/mock.rs
index 82a608816260041d6887af80334b423de1c4f744..50b41b5fc64e101713f326444c2efaa326093fde 100644
--- a/substrate/frame/nft-fractionalization/src/mock.rs
+++ b/substrate/frame/nft-fractionalization/src/mock.rs
@@ -57,20 +57,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
 }
 
 impl pallet_assets::Config for Test {
diff --git a/substrate/frame/nfts/src/benchmarking.rs b/substrate/frame/nfts/src/benchmarking.rs
index 8792af675fc16de7c18f07312aa74e4bab46d3db..80860bc5a53c432685abd7144e92b85e0c697edf 100644
--- a/substrate/frame/nfts/src/benchmarking.rs
+++ b/substrate/frame/nfts/src/benchmarking.rs
@@ -30,11 +30,7 @@ use frame_support::{
 	BoundedVec,
 };
 use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin as SystemOrigin};
-use sp_io::crypto::{sr25519_generate, sr25519_sign};
-use sp_runtime::{
-	traits::{Bounded, IdentifyAccount, One},
-	AccountId32, MultiSignature, MultiSigner,
-};
+use sp_runtime::traits::{Bounded, One};
 use sp_std::prelude::*;
 
 use crate::Pallet as Nfts;
@@ -229,12 +225,6 @@ fn make_filled_vec(value: u16, length: usize) -> Vec<u8> {
 }
 
 benchmarks_instance_pallet! {
-	where_clause {
-		where
-			T::OffchainSignature: From<MultiSignature>,
-			T::AccountId: From<AccountId32>,
-	}
-
 	create {
 		let collection = T::Helper::collection(0);
 		let origin = T::CreateOrigin::try_successful_origin(&collection)
@@ -800,8 +790,7 @@ benchmarks_instance_pallet! {
 
 	mint_pre_signed {
 		let n in 0 .. T::MaxAttributesPerCall::get() as u32;
-		let caller_public = sr25519_generate(0.into(), None);
-		let caller = MultiSigner::Sr25519(caller_public).into_account().into();
+		let (caller_public, caller) = T::Helper::signer();
 		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
 
@@ -830,7 +819,7 @@ benchmarks_instance_pallet! {
 			mint_price: Some(DepositBalanceOf::<T, I>::min_value()),
 		};
 		let message = Encode::encode(&mint_data);
-		let signature = MultiSignature::Sr25519(sr25519_sign(0.into(), &caller_public, &message).unwrap());
+		let signature = T::Helper::sign(&caller_public, &message);
 
 		let target: T::AccountId = account("target", 0, SEED);
 		T::Currency::make_free_balance_be(&target, DepositBalanceOf::<T, I>::max_value());
@@ -848,8 +837,7 @@ benchmarks_instance_pallet! {
 		let item_owner: T::AccountId = account("item_owner", 0, SEED);
 		let item_owner_lookup = T::Lookup::unlookup(item_owner.clone());
 
-		let signer_public = sr25519_generate(0.into(), None);
-		let signer: T::AccountId = MultiSigner::Sr25519(signer_public).into_account().into();
+		let (signer_public, signer) = T::Helper::signer();
 
 		T::Currency::make_free_balance_be(&item_owner, DepositBalanceOf::<T, I>::max_value());
 
@@ -876,7 +864,7 @@ benchmarks_instance_pallet! {
 			deadline: One::one(),
 		};
 		let message = Encode::encode(&pre_signed_data);
-		let signature = MultiSignature::Sr25519(sr25519_sign(0.into(), &signer_public, &message).unwrap());
+		let signature = T::Helper::sign(&signer_public, &message);
 
 		frame_system::Pallet::<T>::set_block_number(One::one());
 	}: _(SystemOrigin::Signed(item_owner.clone()), pre_signed_data, signature.into(), signer.clone())
diff --git a/substrate/frame/nfts/src/lib.rs b/substrate/frame/nfts/src/lib.rs
index 615720268fed611bbf7effa1f4b71eca0df4a7e7..0406cac6e2c983da4e7ef3db9e4fd506c1803506 100644
--- a/substrate/frame/nfts/src/lib.rs
+++ b/substrate/frame/nfts/src/lib.rs
@@ -84,18 +84,42 @@ pub mod pallet {
 	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
 
 	#[cfg(feature = "runtime-benchmarks")]
-	pub trait BenchmarkHelper<CollectionId, ItemId> {
+	pub trait BenchmarkHelper<CollectionId, ItemId, Public, AccountId, Signature> {
 		fn collection(i: u16) -> CollectionId;
 		fn item(i: u16) -> ItemId;
+		fn signer() -> (Public, AccountId);
+		fn sign(signer: &Public, message: &[u8]) -> Signature;
 	}
 	#[cfg(feature = "runtime-benchmarks")]
-	impl<CollectionId: From<u16>, ItemId: From<u16>> BenchmarkHelper<CollectionId, ItemId> for () {
+	impl<CollectionId, ItemId>
+		BenchmarkHelper<
+			CollectionId,
+			ItemId,
+			sp_runtime::MultiSigner,
+			sp_runtime::AccountId32,
+			sp_runtime::MultiSignature,
+		> for ()
+	where
+		CollectionId: From<u16>,
+		ItemId: From<u16>,
+	{
 		fn collection(i: u16) -> CollectionId {
 			i.into()
 		}
 		fn item(i: u16) -> ItemId {
 			i.into()
 		}
+		fn signer() -> (sp_runtime::MultiSigner, sp_runtime::AccountId32) {
+			let public = sp_io::crypto::sr25519_generate(0.into(), None);
+			let account = sp_runtime::MultiSigner::Sr25519(public).into_account();
+			(public.into(), account)
+		}
+		fn sign(signer: &sp_runtime::MultiSigner, message: &[u8]) -> sp_runtime::MultiSignature {
+			sp_runtime::MultiSignature::Sr25519(
+				sp_io::crypto::sr25519_sign(0.into(), &signer.clone().try_into().unwrap(), message)
+					.unwrap(),
+			)
+		}
 	}
 
 	#[pallet::config]
@@ -206,7 +230,13 @@ pub mod pallet {
 
 		#[cfg(feature = "runtime-benchmarks")]
 		/// A set of helper functions for benchmarking.
-		type Helper: BenchmarkHelper<Self::CollectionId, Self::ItemId>;
+		type Helper: BenchmarkHelper<
+			Self::CollectionId,
+			Self::ItemId,
+			Self::OffchainPublic,
+			Self::AccountId,
+			Self::OffchainSignature,
+		>;
 
 		/// Weight information for extrinsics in this pallet.
 		type WeightInfo: WeightInfo;
diff --git a/substrate/frame/nfts/src/mock.rs b/substrate/frame/nfts/src/mock.rs
index 51cfd5f244bcdb14fcdb1f66cff245df9030185f..5b589f591ca347a670becdc9557f24ec1a4e8520 100644
--- a/substrate/frame/nfts/src/mock.rs
+++ b/substrate/frame/nfts/src/mock.rs
@@ -53,20 +53,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 parameter_types! {
diff --git a/substrate/frame/nomination-pools/benchmarking/Cargo.toml b/substrate/frame/nomination-pools/benchmarking/Cargo.toml
index 3186bce5164cc9fa57c2601a1219b5aadfca4e50..3f9463a9c429b93da7cf5945a6ebd2ac46077196 100644
--- a/substrate/frame/nomination-pools/benchmarking/Cargo.toml
+++ b/substrate/frame/nomination-pools/benchmarking/Cargo.toml
@@ -27,6 +27,7 @@ frame-support = { path = "../../support", default-features = false }
 frame-system = { path = "../../system", default-features = false }
 pallet-bags-list = { path = "../../bags-list", default-features = false }
 pallet-staking = { path = "../../staking", default-features = false }
+pallet-delegated-staking = { path = "../../delegated-staking", default-features = false }
 pallet-nomination-pools = { path = "..", default-features = false }
 
 # Substrate Primitives
@@ -53,6 +54,7 @@ std = [
 	"frame-system/std",
 	"pallet-bags-list/std",
 	"pallet-balances/std",
+	"pallet-delegated-staking/std",
 	"pallet-nomination-pools/std",
 	"pallet-staking/std",
 	"pallet-timestamp/std",
@@ -72,6 +74,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-bags-list/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
+	"pallet-delegated-staking/runtime-benchmarks",
 	"pallet-nomination-pools/runtime-benchmarks",
 	"pallet-staking/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
diff --git a/substrate/frame/nomination-pools/benchmarking/src/inner.rs b/substrate/frame/nomination-pools/benchmarking/src/inner.rs
index 277060e7f640f962bd112a6f337339ec1cf2559e..b8c978945e9ee18657e5307c0aebd1d4aaf742fd 100644
--- a/substrate/frame/nomination-pools/benchmarking/src/inner.rs
+++ b/substrate/frame/nomination-pools/benchmarking/src/inner.rs
@@ -23,22 +23,24 @@ use frame_support::{
 	assert_ok, ensure,
 	traits::{
 		fungible::{Inspect, Mutate, Unbalanced},
-		Get,
+		tokens::Preservation,
+		Get, Imbalance,
 	},
 };
 use frame_system::RawOrigin as RuntimeOrigin;
 use pallet_nomination_pools::{
+	adapter::{Member, Pool, StakeStrategy, StakeStrategyType},
 	BalanceOf, BondExtra, BondedPoolInner, BondedPools, ClaimPermission, ClaimPermissions,
 	Commission, CommissionChangeRate, CommissionClaimPermission, ConfigOp, GlobalMaxCommission,
 	MaxPoolMembers, MaxPoolMembersPerPool, MaxPools, Metadata, MinCreateBond, MinJoinBond,
-	Pallet as Pools, PoolMembers, PoolRoles, PoolState, RewardPools, SubPoolsStorage,
+	Pallet as Pools, PoolId, PoolMembers, PoolRoles, PoolState, RewardPools, SubPoolsStorage,
 };
 use pallet_staking::MaxNominationsOf;
 use sp_runtime::{
 	traits::{Bounded, StaticLookup, Zero},
 	Perbill,
 };
-use sp_staking::{EraIndex, StakingInterface};
+use sp_staking::EraIndex;
 use sp_std::{vec, vec::Vec};
 // `frame_benchmarking::benchmarks!` macro needs this
 use pallet_nomination_pools::Call;
@@ -101,18 +103,50 @@ fn create_pool_account<T: pallet_nomination_pools::Config>(
 
 	let pool_account = pallet_nomination_pools::BondedPools::<T>::iter()
 		.find(|(_, bonded_pool)| bonded_pool.roles.depositor == pool_creator)
-		.map(|(pool_id, _)| Pools::<T>::create_bonded_account(pool_id))
+		.map(|(pool_id, _)| Pools::<T>::generate_bonded_account(pool_id))
 		.expect("pool_creator created a pool above");
 
 	(pool_creator, pool_account)
 }
 
+fn migrate_to_transfer_stake<T: Config>(pool_id: PoolId) {
+	if T::StakeAdapter::strategy_type() == StakeStrategyType::Transfer {
+		// should already be in the correct strategy
+		return;
+	}
+	let pool_acc = Pools::<T>::generate_bonded_account(pool_id);
+	// drop the agent and its associated delegators .
+	T::StakeAdapter::remove_as_agent(Pool::from(pool_acc.clone()));
+
+	// tranfer funds from all members to the pool account.
+	PoolMembers::<T>::iter()
+		.filter(|(_, member)| member.pool_id == pool_id)
+		.for_each(|(member_acc, member)| {
+			let member_balance = member.total_balance();
+			<T as pallet_nomination_pools::Config>::Currency::transfer(
+				&member_acc,
+				&pool_acc,
+				member_balance,
+				Preservation::Preserve,
+			)
+			.expect("member should have enough balance to transfer");
+		});
+}
+
 fn vote_to_balance<T: pallet_nomination_pools::Config>(
 	vote: u64,
 ) -> Result<BalanceOf<T>, &'static str> {
 	vote.try_into().map_err(|_| "could not convert u64 to Balance")
 }
 
+/// `assertion` should strictly be true if the adapter is using `Delegate` strategy and strictly
+/// false if the adapter is not using `Delegate` strategy.
+fn assert_if_delegate<T: pallet_nomination_pools::Config>(assertion: bool) {
+	let legacy_adapter_used = T::StakeAdapter::strategy_type() != StakeStrategyType::Delegate;
+	// one and only one of the two should be true.
+	assert!(assertion ^ legacy_adapter_used);
+}
+
 #[allow(unused)]
 struct ListScenario<T: pallet_nomination_pools::Config> {
 	/// Stash/Controller that is expected to be moved.
@@ -151,8 +185,8 @@ impl<T: Config> ListScenario<T> {
 		let (pool_creator1, pool_origin1) =
 			create_pool_account::<T>(USER_SEED + 1, origin_weight, Some(Perbill::from_percent(50)));
 
-		T::Staking::nominate(
-			&pool_origin1,
+		T::StakeAdapter::nominate(
+			Pool::from(pool_origin1.clone()),
 			// NOTE: these don't really need to be validators.
 			vec![account("random_validator", 0, USER_SEED)],
 		)?;
@@ -160,8 +194,8 @@ impl<T: Config> ListScenario<T> {
 		let (_, pool_origin2) =
 			create_pool_account::<T>(USER_SEED + 2, origin_weight, Some(Perbill::from_percent(50)));
 
-		T::Staking::nominate(
-			&pool_origin2,
+		T::StakeAdapter::nominate(
+			Pool::from(pool_origin2.clone()),
 			vec![account("random_validator", 0, USER_SEED)].clone(),
 		)?;
 
@@ -178,7 +212,10 @@ impl<T: Config> ListScenario<T> {
 		let (_, pool_dest1) =
 			create_pool_account::<T>(USER_SEED + 3, dest_weight, Some(Perbill::from_percent(50)));
 
-		T::Staking::nominate(&pool_dest1, vec![account("random_validator", 0, USER_SEED)])?;
+		T::StakeAdapter::nominate(
+			Pool::from(pool_dest1.clone()),
+			vec![account("random_validator", 0, USER_SEED)],
+		)?;
 
 		let weight_of = pallet_staking::Pallet::<T>::weight_of_fn();
 		assert_eq!(vote_to_balance::<T>(weight_of(&pool_origin1)).unwrap(), origin_weight);
@@ -204,11 +241,12 @@ impl<T: Config> ListScenario<T> {
 		self.origin1_member = Some(joiner.clone());
 		CurrencyOf::<T>::set_balance(&joiner, amount * 2u32.into());
 
-		let original_bonded = T::Staking::active_stake(&self.origin1).unwrap();
+		let original_bonded = T::StakeAdapter::active_stake(Pool::from(self.origin1.clone()));
 
 		// Unbond `amount` from the underlying pool account so when the member joins
 		// we will maintain `current_bonded`.
-		T::Staking::unbond(&self.origin1, amount).expect("the pool was created in `Self::new`.");
+		T::StakeAdapter::unbond(Pool::from(self.origin1.clone()), amount)
+			.expect("the pool was created in `Self::new`.");
 
 		// Account pool points for the unbonded balance.
 		BondedPools::<T>::mutate(&1, |maybe_pool| {
@@ -231,13 +269,20 @@ impl<T: Config> ListScenario<T> {
 }
 
 frame_benchmarking::benchmarks! {
+	where_clause {
+		where
+			T: pallet_staking::Config,
+			pallet_staking::BalanceOf<T>: From<u128>,
+			BalanceOf<T>: Into<u128>,
+	}
+
 	join {
 		let origin_weight = Pools::<T>::depositor_min_bond() * 2u32.into();
 
 		// setup the worst case list scenario.
 		let scenario = ListScenario::<T>::new(origin_weight, true)?;
 		assert_eq!(
-			T::Staking::active_stake(&scenario.origin1).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(scenario.origin1.clone())),
 			origin_weight
 		);
 
@@ -252,7 +297,7 @@ frame_benchmarking::benchmarks! {
 	verify {
 		assert_eq!(CurrencyOf::<T>::balance(&joiner), joiner_free - max_additional);
 		assert_eq!(
-			T::Staking::active_stake(&scenario.origin1).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(scenario.origin1)),
 			scenario.dest_weight
 		);
 	}
@@ -267,7 +312,7 @@ frame_benchmarking::benchmarks! {
 	}: bond_extra(RuntimeOrigin::Signed(scenario.creator1.clone()), BondExtra::FreeBalance(extra))
 	verify {
 		assert!(
-			T::Staking::active_stake(&scenario.origin1).unwrap() >=
+			T::StakeAdapter::active_stake(Pool::from(scenario.origin1)) >=
 			scenario.dest_weight
 		);
 	}
@@ -283,7 +328,7 @@ frame_benchmarking::benchmarks! {
 		let _ = Pools::<T>::set_claim_permission(RuntimeOrigin::Signed(scenario.creator1.clone()).into(), ClaimPermission::PermissionlessAll);
 
 		// transfer exactly `extra` to the depositor of the src pool (1),
-		let reward_account1 = Pools::<T>::create_reward_account(1);
+		let reward_account1 = Pools::<T>::generate_reward_account(1);
 		assert!(extra >= CurrencyOf::<T>::minimum_balance());
 		let _ = CurrencyOf::<T>::mint_into(&reward_account1, extra);
 
@@ -291,7 +336,7 @@ frame_benchmarking::benchmarks! {
 	verify {
 		 // commission of 50% deducted here.
 		assert!(
-			T::Staking::active_stake(&scenario.origin1).unwrap() >=
+			T::StakeAdapter::active_stake(Pool::from(scenario.origin1)) >=
 			scenario.dest_weight / 2u32.into()
 		);
 	}
@@ -302,7 +347,7 @@ frame_benchmarking::benchmarks! {
 		let origin_weight = Pools::<T>::depositor_min_bond() * 2u32.into();
 		let ed = CurrencyOf::<T>::minimum_balance();
 		let (depositor, pool_account) = create_pool_account::<T>(0, origin_weight, Some(commission));
-		let reward_account = Pools::<T>::create_reward_account(1);
+		let reward_account = Pools::<T>::generate_reward_account(1);
 
 		// Send funds to the reward account of the pool
 		CurrencyOf::<T>::set_balance(&reward_account, ed + origin_weight);
@@ -345,7 +390,7 @@ frame_benchmarking::benchmarks! {
 		whitelist_account!(member_id);
 	}: _(RuntimeOrigin::Signed(member_id.clone()), member_id_lookup, all_points)
 	verify {
-		let bonded_after = T::Staking::active_stake(&scenario.origin1).unwrap();
+		let bonded_after = T::StakeAdapter::active_stake(Pool::from(scenario.origin1));
 		// We at least went down to the destination bag
 		assert!(bonded_after <= scenario.dest_weight);
 		let member = PoolMembers::<T>::get(
@@ -354,7 +399,7 @@ frame_benchmarking::benchmarks! {
 		.unwrap();
 		assert_eq!(
 			member.unbonding_eras.keys().cloned().collect::<Vec<_>>(),
-			vec![0 + T::Staking::bonding_duration()]
+			vec![0 + T::StakeAdapter::bonding_duration()]
 		);
 		assert_eq!(
 			member.unbonding_eras.values().cloned().collect::<Vec<_>>(),
@@ -376,7 +421,7 @@ frame_benchmarking::benchmarks! {
 
 		// Sanity check join worked
 		assert_eq!(
-			T::Staking::active_stake(&pool_account).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(pool_account.clone())),
 			min_create_bond + min_join_bond
 		);
 		assert_eq!(CurrencyOf::<T>::balance(&joiner), min_join_bond);
@@ -386,7 +431,7 @@ frame_benchmarking::benchmarks! {
 
 		// Sanity check that unbond worked
 		assert_eq!(
-			T::Staking::active_stake(&pool_account).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(pool_account.clone())),
 			min_create_bond
 		);
 		assert_eq!(pallet_staking::Ledger::<T>::get(&pool_account).unwrap().unlocking.len(), 1);
@@ -419,7 +464,7 @@ frame_benchmarking::benchmarks! {
 
 		// Sanity check join worked
 		assert_eq!(
-			T::Staking::active_stake(&pool_account).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(pool_account.clone())),
 			min_create_bond + min_join_bond
 		);
 		assert_eq!(CurrencyOf::<T>::balance(&joiner), min_join_bond);
@@ -430,7 +475,7 @@ frame_benchmarking::benchmarks! {
 
 		// Sanity check that unbond worked
 		assert_eq!(
-			T::Staking::active_stake(&pool_account).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(pool_account.clone())),
 			min_create_bond
 		);
 		assert_eq!(pallet_staking::Ledger::<T>::get(&pool_account).unwrap().unlocking.len(), 1);
@@ -470,18 +515,18 @@ frame_benchmarking::benchmarks! {
 		// here to ensure the complete flow for destroying a pool works - the reward pool account
 		// should never exist by time the depositor withdraws so we test that it gets cleaned
 		// up when unbonding.
-		let reward_account = Pools::<T>::create_reward_account(1);
+		let reward_account = Pools::<T>::generate_reward_account(1);
 		assert!(frame_system::Account::<T>::contains_key(&reward_account));
 		Pools::<T>::fully_unbond(RuntimeOrigin::Signed(depositor.clone()).into(), depositor.clone()).unwrap();
 
 		// Sanity check that unbond worked
 		assert_eq!(
-			T::Staking::active_stake(&pool_account).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(pool_account.clone())),
 			Zero::zero()
 		);
 		assert_eq!(
-			CurrencyOf::<T>::balance(&pool_account),
-			min_create_bond
+			T::StakeAdapter::total_balance(Pool::from(pool_account.clone())),
+			Some(min_create_bond)
 		);
 		assert_eq!(pallet_staking::Ledger::<T>::get(&pool_account).unwrap().unlocking.len(), 1);
 
@@ -522,8 +567,8 @@ frame_benchmarking::benchmarks! {
 		let depositor_lookup = T::Lookup::unlookup(depositor.clone());
 
 		// Give the depositor some balance to bond
-		CurrencyOf::<T>::set_balance(&depositor, min_create_bond * 2u32.into());
-
+		// it needs to transfer min balance to reward account as well so give additional min balance.
+		CurrencyOf::<T>::set_balance(&depositor, min_create_bond + CurrencyOf::<T>::minimum_balance() * 2u32.into());
 		// Make sure no Pools exist at a pre-condition for our verify checks
 		assert_eq!(RewardPools::<T>::count(), 0);
 		assert_eq!(BondedPools::<T>::count(), 0);
@@ -556,8 +601,8 @@ frame_benchmarking::benchmarks! {
 			}
 		);
 		assert_eq!(
-			T::Staking::active_stake(&Pools::<T>::create_bonded_account(1)),
-			Ok(min_create_bond)
+			T::StakeAdapter::active_stake(Pool::from(Pools::<T>::generate_bonded_account(1))),
+			min_create_bond
 		);
 	}
 
@@ -596,8 +641,8 @@ frame_benchmarking::benchmarks! {
 			}
 		);
 		assert_eq!(
-			T::Staking::active_stake(&Pools::<T>::create_bonded_account(1)),
-			Ok(min_create_bond)
+			T::StakeAdapter::active_stake(Pool::from(Pools::<T>::generate_bonded_account(1))),
+			min_create_bond
 		);
 	}
 
@@ -681,13 +726,13 @@ frame_benchmarking::benchmarks! {
 			.map(|i| account("stash", USER_SEED, i))
 			.collect();
 
-		assert_ok!(T::Staking::nominate(&pool_account, validators));
-		assert!(T::Staking::nominations(&Pools::<T>::create_bonded_account(1)).is_some());
+		assert_ok!(T::StakeAdapter::nominate(Pool::from(pool_account.clone()), validators));
+		assert!(T::StakeAdapter::nominations(Pool::from(pool_account.clone())).is_some());
 
 		whitelist_account!(depositor);
 	}:_(RuntimeOrigin::Signed(depositor.clone()), 1)
 	verify {
-		assert!(T::Staking::nominations(&Pools::<T>::create_bonded_account(1)).is_none());
+		assert!(T::StakeAdapter::nominations(Pool::from(pool_account.clone())).is_none());
 	}
 
 	set_commission {
@@ -786,7 +831,7 @@ frame_benchmarking::benchmarks! {
 
 		// Sanity check join worked
 		assert_eq!(
-			T::Staking::active_stake(&pool_account).unwrap(),
+			T::StakeAdapter::active_stake(Pool::from(pool_account.clone())),
 			min_create_bond + min_join_bond
 		);
 	}:_(RuntimeOrigin::Signed(joiner.clone()), ClaimPermission::Permissioned)
@@ -800,7 +845,7 @@ frame_benchmarking::benchmarks! {
 		let origin_weight = Pools::<T>::depositor_min_bond() * 2u32.into();
 		let ed = CurrencyOf::<T>::minimum_balance();
 		let (depositor, pool_account) = create_pool_account::<T>(0, origin_weight, Some(commission));
-		let reward_account = Pools::<T>::create_reward_account(1);
+		let reward_account = Pools::<T>::generate_reward_account(1);
 		CurrencyOf::<T>::set_balance(&reward_account, ed + origin_weight);
 
 		// member claims a payout to make some commission available.
@@ -829,7 +874,7 @@ frame_benchmarking::benchmarks! {
 		let (depositor, _) = create_pool_account::<T>(0, Pools::<T>::depositor_min_bond() * 2u32.into(), None);
 
 		// Remove ed freeze to create a scenario where the ed deposit needs to be adjusted.
-		let _ = Pools::<T>::unfreeze_pool_deposit(&Pools::<T>::create_reward_account(1));
+		let _ = Pools::<T>::unfreeze_pool_deposit(&Pools::<T>::generate_reward_account(1));
 		assert!(&Pools::<T>::check_ed_imbalance().is_err());
 
 		whitelist_account!(depositor);
@@ -838,6 +883,141 @@ frame_benchmarking::benchmarks! {
 		assert!(&Pools::<T>::check_ed_imbalance().is_ok());
 	}
 
+	apply_slash {
+		// Note: With older `TransferStake` strategy, slashing is greedy and apply_slash should
+		// always fail.
+
+		// We want to fill member's unbonding pools. So let's bond with big enough amount.
+		let deposit_amount = Pools::<T>::depositor_min_bond() * T::MaxUnbonding::get().into() * 4u32.into();
+		let (depositor, pool_account) = create_pool_account::<T>(0, deposit_amount, None);
+		let depositor_lookup = T::Lookup::unlookup(depositor.clone());
+
+		// verify user balance in the pool.
+		assert_eq!(PoolMembers::<T>::get(&depositor).unwrap().total_balance(), deposit_amount);
+		// verify delegated balance.
+		assert_if_delegate::<T>(T::StakeAdapter::member_delegation_balance(Member::from(depositor.clone())) == Some(deposit_amount));
+
+		// ugly type conversion between balances of pallet staking and pools (which really are same
+		// type). Maybe there is a better way?
+		let slash_amount: u128 = deposit_amount.into()/2;
+
+		// slash pool by half
+		pallet_staking::slashing::do_slash::<T>(
+			&pool_account,
+			slash_amount.into(),
+			&mut pallet_staking::BalanceOf::<T>::zero(),
+			&mut pallet_staking::NegativeImbalanceOf::<T>::zero(),
+			EraIndex::zero()
+		);
+
+		// verify user balance is slashed in the pool.
+		assert_eq!(PoolMembers::<T>::get(&depositor).unwrap().total_balance(), deposit_amount/2u32.into());
+		// verify delegated balance are not yet slashed.
+		assert_if_delegate::<T>(T::StakeAdapter::member_delegation_balance(Member::from(depositor.clone())) == Some(deposit_amount));
+
+		// Fill member's sub pools for the worst case.
+		for i in 1..(T::MaxUnbonding::get() + 1) {
+			pallet_staking::CurrentEra::<T>::put(i);
+			assert!(Pools::<T>::unbond(RuntimeOrigin::Signed(depositor.clone()).into(), depositor_lookup.clone(), Pools::<T>::depositor_min_bond()).is_ok());
+		}
+
+		pallet_staking::CurrentEra::<T>::put(T::MaxUnbonding::get() + 2);
+
+		let slash_reporter = create_funded_user_with_balance::<T>("slasher", 0, CurrencyOf::<T>::minimum_balance());
+		whitelist_account!(depositor);
+	}:
+	{
+		assert_if_delegate::<T>(Pools::<T>::apply_slash(RuntimeOrigin::Signed(slash_reporter.clone()).into(), depositor_lookup.clone()).is_ok());
+	}
+	verify {
+		// verify balances are correct and slash applied.
+		assert_eq!(PoolMembers::<T>::get(&depositor).unwrap().total_balance(), deposit_amount/2u32.into());
+		assert_if_delegate::<T>(T::StakeAdapter::member_delegation_balance(Member::from(depositor.clone())) == Some(deposit_amount/2u32.into()));
+	}
+
+	apply_slash_fail {
+		// Bench the scenario where pool has some unapplied slash but the member does not have any
+		// slash to be applied.
+		let deposit_amount = Pools::<T>::depositor_min_bond() * 10u32.into();
+		// Create pool.
+		let (depositor, pool_account) = create_pool_account::<T>(0, deposit_amount, None);
+
+		// slash pool by half
+		let slash_amount: u128 = deposit_amount.into()/2;
+		pallet_staking::slashing::do_slash::<T>(
+			&pool_account,
+			slash_amount.into(),
+			&mut pallet_staking::BalanceOf::<T>::zero(),
+			&mut pallet_staking::NegativeImbalanceOf::<T>::zero(),
+			EraIndex::zero()
+		);
+
+		pallet_staking::CurrentEra::<T>::put(1);
+
+		// new member joins the pool who should not be affected by slash.
+		let min_join_bond = MinJoinBond::<T>::get().max(CurrencyOf::<T>::minimum_balance());
+		let join_amount = min_join_bond * T::MaxUnbonding::get().into() * 2u32.into();
+		let joiner = create_funded_user_with_balance::<T>("joiner", 0, join_amount * 2u32.into());
+		let joiner_lookup = T::Lookup::unlookup(joiner.clone());
+		assert!(Pools::<T>::join(RuntimeOrigin::Signed(joiner.clone()).into(), join_amount, 1).is_ok());
+
+		// Fill member's sub pools for the worst case.
+		for i in 0..T::MaxUnbonding::get() {
+			pallet_staking::CurrentEra::<T>::put(i + 2); // +2 because we already set the current era to 1.
+			assert!(Pools::<T>::unbond(RuntimeOrigin::Signed(joiner.clone()).into(), joiner_lookup.clone(), min_join_bond).is_ok());
+		}
+
+		pallet_staking::CurrentEra::<T>::put(T::MaxUnbonding::get() + 3);
+		whitelist_account!(joiner);
+
+	}: {
+		// Since the StakeAdapter can be different based on the runtime config, the errors could be different as well.
+		assert!(Pools::<T>::apply_slash(RuntimeOrigin::Signed(joiner.clone()).into(), joiner_lookup.clone()).is_err());
+	}
+
+
+	pool_migrate {
+		// create a pool.
+		let deposit_amount = Pools::<T>::depositor_min_bond() * 2u32.into();
+		let (depositor, pool_account) = create_pool_account::<T>(0, deposit_amount, None);
+
+		// migrate pool to transfer stake.
+		let _ = migrate_to_transfer_stake::<T>(1);
+	}: {
+		assert_if_delegate::<T>(Pools::<T>::migrate_pool_to_delegate_stake(RuntimeOrigin::Signed(depositor.clone()).into(), 1u32.into()).is_ok());
+	}
+	verify {
+		// this queries agent balance if `DelegateStake` strategy.
+		assert!(T::StakeAdapter::total_balance(Pool::from(pool_account.clone())) == Some(deposit_amount));
+	}
+
+	migrate_delegation {
+		// create a pool.
+		let deposit_amount = Pools::<T>::depositor_min_bond() * 2u32.into();
+		let (depositor, pool_account) = create_pool_account::<T>(0, deposit_amount, None);
+		let depositor_lookup = T::Lookup::unlookup(depositor.clone());
+
+		// migrate pool to transfer stake.
+		let _ = migrate_to_transfer_stake::<T>(1);
+
+		// Now migrate pool to delegate stake keeping delegators unmigrated.
+		assert_if_delegate::<T>(Pools::<T>::migrate_pool_to_delegate_stake(RuntimeOrigin::Signed(depositor.clone()).into(), 1u32.into()).is_ok());
+
+		// delegation does not exist.
+		assert!(T::StakeAdapter::member_delegation_balance(Member::from(depositor.clone())).is_none());
+		// contribution exists in the pool.
+		assert_eq!(PoolMembers::<T>::get(&depositor).unwrap().total_balance(), deposit_amount);
+
+		whitelist_account!(depositor);
+	}: {
+		assert_if_delegate::<T>(Pools::<T>::migrate_delegation(RuntimeOrigin::Signed(depositor.clone()).into(), depositor_lookup.clone()).is_ok());
+	}
+	verify {
+		// verify balances once more.
+		assert_if_delegate::<T>(T::StakeAdapter::member_delegation_balance(Member::from(depositor.clone())) == Some(deposit_amount));
+		assert_eq!(PoolMembers::<T>::get(&depositor).unwrap().total_balance(), deposit_amount);
+	}
+
 	impl_benchmark_test_suite!(
 		Pallet,
 		crate::mock::new_test_ext(),
diff --git a/substrate/frame/nomination-pools/benchmarking/src/lib.rs b/substrate/frame/nomination-pools/benchmarking/src/lib.rs
index 45e8f1f27e99a52b5900aa5e18c5439d9d7baa5c..910cdf2e3dff6353d90a2ba138c4731b0b020a0f 100644
--- a/substrate/frame/nomination-pools/benchmarking/src/lib.rs
+++ b/substrate/frame/nomination-pools/benchmarking/src/lib.rs
@@ -18,6 +18,7 @@
 //! Benchmarks for the nomination pools coupled with the staking and bags list pallets.
 
 #![cfg_attr(not(feature = "std"), no_std)]
+#![recursion_limit = "256"]
 
 #[cfg(feature = "runtime-benchmarks")]
 pub mod inner;
diff --git a/substrate/frame/nomination-pools/benchmarking/src/mock.rs b/substrate/frame/nomination-pools/benchmarking/src/mock.rs
index 2752d53a6b9f3364c234d9144a6c40b10b449a5b..15d9e2c56031fe1e47b7b0cef3139ca177ddeb67 100644
--- a/substrate/frame/nomination-pools/benchmarking/src/mock.rs
+++ b/substrate/frame/nomination-pools/benchmarking/src/mock.rs
@@ -17,42 +17,28 @@
 
 use crate::VoterBagsListInstance;
 use frame_election_provider_support::VoteWeight;
-use frame_support::{derive_impl, pallet_prelude::*, parameter_types, traits::ConstU64, PalletId};
+use frame_support::{
+	derive_impl,
+	pallet_prelude::*,
+	parameter_types,
+	traits::{ConstU64, VariantCountOf},
+	PalletId,
+};
 use sp_runtime::{
 	traits::{Convert, IdentityLookup},
 	BuildStorage, FixedU128, Perbill,
 };
 
 type AccountId = u128;
-type Nonce = u32;
 type BlockNumber = u64;
 type Balance = u128;
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type Nonce = Nonce;
-	type RuntimeCall = RuntimeCall;
-	type Hash = sp_core::H256;
-	type Hashing = sp_runtime::traits::BlakeTwo256;
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<Balance>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
 impl pallet_timestamp::Config for Runtime {
@@ -65,20 +51,16 @@ impl pallet_timestamp::Config for Runtime {
 parameter_types! {
 	pub const ExistentialDeposit: Balance = 10;
 }
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
 	type FreezeIdentifier = RuntimeFreezeReason;
-	type MaxFreezes = ConstU32<1>;
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type RuntimeFreezeReason = RuntimeFreezeReason;
 }
 
 pallet_staking_reward_curve::build! {
@@ -94,36 +76,19 @@ pallet_staking_reward_curve::build! {
 parameter_types! {
 	pub const RewardCurve: &'static sp_runtime::curve::PiecewiseLinear<'static> = &I_NPOS;
 }
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Runtime {
 	type Currency = Balances;
 	type CurrencyBalance = Balance;
 	type UnixTime = pallet_timestamp::Pallet<Self>;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
-	type Reward = ();
-	type SessionsPerEra = ();
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
-	type BondingDuration = ConstU32<3>;
-	type SessionInterface = ();
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
-	type NextNewSession = ();
-	type MaxExposurePageSize = ConstU32<64>;
 	type ElectionProvider =
 		frame_election_provider_support::NoElection<(AccountId, BlockNumber, Staking, ())>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = VoterList;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type HistoryDepth = ConstU32<84>;
-	type EventListeners = Pools;
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
+	type EventListeners = (Pools, DelegatedStaking);
 }
 
 parameter_types! {
@@ -166,7 +131,8 @@ impl pallet_nomination_pools::Config for Runtime {
 	type RewardCounter = FixedU128;
 	type BalanceToU256 = BalanceToU256;
 	type U256ToBalance = U256ToBalance;
-	type Staking = Staking;
+	type StakeAdapter =
+		pallet_nomination_pools::adapter::DelegateStake<Self, Staking, DelegatedStaking>;
 	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
 	type MaxMetadataLen = ConstU32<256>;
 	type MaxUnbonding = ConstU32<8>;
@@ -175,6 +141,20 @@ impl pallet_nomination_pools::Config for Runtime {
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 }
 
+parameter_types! {
+	pub const DelegatedStakingPalletId: PalletId = PalletId(*b"py/dlstk");
+	pub const SlashRewardFraction: Perbill = Perbill::from_percent(1);
+}
+impl pallet_delegated_staking::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = DelegatedStakingPalletId;
+	type Currency = Balances;
+	type OnSlash = ();
+	type SlashRewardFraction = SlashRewardFraction;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type CoreStaking = Staking;
+}
+
 impl crate::Config for Runtime {}
 
 type Block = frame_system::mocking::MockBlock<Runtime>;
@@ -187,6 +167,7 @@ frame_support::construct_runtime!(
 		Staking: pallet_staking,
 		VoterList: pallet_bags_list::<Instance1>,
 		Pools: pallet_nomination_pools,
+		DelegatedStaking: pallet_delegated_staking,
 	}
 );
 
diff --git a/substrate/frame/nomination-pools/fuzzer/src/call.rs b/substrate/frame/nomination-pools/fuzzer/src/call.rs
index 027fb2b69138c64f8903f99737187b7cd65c12c2..9e10d87da6750e4171d2736eb6fb7dcbc7324640 100644
--- a/substrate/frame/nomination-pools/fuzzer/src/call.rs
+++ b/substrate/frame/nomination-pools/fuzzer/src/call.rs
@@ -306,7 +306,7 @@ fn main() {
 					BondedPools::<T>::iter().for_each(|(id, _)| {
 						let amount = random_ed_multiple(&mut rng);
 						let _ =
-							Balances::deposit_creating(&Pools::create_reward_account(id), amount);
+							Balances::deposit_creating(&Pools::generate_reward_account(id), amount);
 						// if we just paid out the reward agent, let's calculate how much we expect
 						// our reward agent to have earned.
 						if reward_agent.pool_id.map_or(false, |mid| mid == id) {
diff --git a/substrate/frame/nomination-pools/runtime-api/src/lib.rs b/substrate/frame/nomination-pools/runtime-api/src/lib.rs
index 881c3c36331b64168eceed8eeebfa5b62b7e5f41..67627e0acb13de6120fdd7f9b0c0cf910e8d6dc3 100644
--- a/substrate/frame/nomination-pools/runtime-api/src/lib.rs
+++ b/substrate/frame/nomination-pools/runtime-api/src/lib.rs
@@ -38,5 +38,30 @@ sp_api::decl_runtime_apis! {
 
 		/// Returns the equivalent points of `new_funds` for a given pool.
 		fn balance_to_points(pool_id: PoolId, new_funds: Balance) -> Balance;
+
+		/// Returns the pending slash for a given pool.
+		fn pool_pending_slash(pool_id: PoolId) -> Balance;
+
+		/// Returns the pending slash for a given pool member.
+		fn member_pending_slash(member: AccountId) -> Balance;
+
+		/// Returns true if the pool with `pool_id` needs migration.
+		///
+		/// This can happen when the `pallet-nomination-pools` has switched to using strategy
+		/// [`DelegateStake`](pallet_nomination_pools::adapter::DelegateStake) but the pool
+		/// still has funds that were staked using the older strategy
+		/// [TransferStake](pallet_nomination_pools::adapter::TransferStake). Use
+		/// [`migrate_pool_to_delegate_stake`](pallet_nomination_pools::Call::migrate_pool_to_delegate_stake)
+		/// to migrate the pool.
+		fn pool_needs_delegate_migration(pool_id: PoolId) -> bool;
+
+		/// Returns true if the delegated funds of the pool `member` needs migration.
+		///
+		/// Once a pool has successfully migrated to the strategy
+		/// [`DelegateStake`](pallet_nomination_pools::adapter::DelegateStake), the funds of the
+		/// member can be migrated from pool account to the member's account. Use
+		/// [`migrate_delegation`](pallet_nomination_pools::Call::migrate_delegation)
+		/// to migrate the funds of the pool member.
+		fn member_needs_delegate_migration(member: AccountId) -> bool;
 	}
 }
diff --git a/substrate/frame/nomination-pools/src/adapter.rs b/substrate/frame/nomination-pools/src/adapter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4809fbc0e9da08f3f8d84f662acec5ce5a4de6cd
--- /dev/null
+++ b/substrate/frame/nomination-pools/src/adapter.rs
@@ -0,0 +1,438 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::*;
+use sp_staking::{Agent, DelegationInterface, DelegationMigrator, Delegator};
+
+/// Types of stake strategies.
+///
+/// Useful for determining current staking strategy of a runtime and enforce integrity tests.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebugNoBound, PartialEq)]
+pub enum StakeStrategyType {
+	/// Member funds are transferred to pool account and staked.
+	///
+	/// This is the older staking strategy used by pools. For a new runtime, it is recommended to
+	/// use [`StakeStrategyType::Delegate`] strategy instead.
+	Transfer,
+	/// Member funds are delegated to pool account and staked.
+	Delegate,
+}
+
+/// A type that only belongs in context of a pool.
+///
+/// Maps directly [`Agent`] account.
+#[derive(Clone, Debug)]
+pub struct Pool<T>(T);
+impl<AccountID> Into<Agent<AccountID>> for Pool<AccountID> {
+	fn into(self) -> Agent<AccountID> {
+		Agent::from(self.0)
+	}
+}
+impl<T> From<T> for Pool<T> {
+	fn from(acc: T) -> Self {
+		Pool(acc)
+	}
+}
+
+impl<T> Pool<T> {
+	pub fn get(self) -> T {
+		self.0
+	}
+}
+
+/// A type that only belongs in context of a pool member.
+///
+/// Maps directly [`Delegator`] account.
+#[derive(Clone, Debug)]
+pub struct Member<T>(T);
+impl<AccountID> Into<Delegator<AccountID>> for Member<AccountID> {
+	fn into(self) -> Delegator<AccountID> {
+		Delegator::from(self.0)
+	}
+}
+impl<T> From<T> for Member<T> {
+	fn from(acc: T) -> Self {
+		Member(acc)
+	}
+}
+
+impl<T> Member<T> {
+	pub fn get(self) -> T {
+		self.0
+	}
+}
+
+/// An adapter trait that can support multiple staking strategies.
+///
+/// Depending on which staking strategy we want to use, the staking logic can be slightly
+/// different. Refer the two possible strategies currently: [`TransferStake`] and
+/// [`DelegateStake`] for more detail.
+pub trait StakeStrategy {
+	type Balance: frame_support::traits::tokens::Balance;
+	type AccountId: Clone + sp_std::fmt::Debug;
+	type CoreStaking: StakingInterface<Balance = Self::Balance, AccountId = Self::AccountId>;
+
+	/// The type of staking strategy of the current adapter.
+	fn strategy_type() -> StakeStrategyType;
+
+	/// See [`StakingInterface::bonding_duration`].
+	fn bonding_duration() -> EraIndex {
+		Self::CoreStaking::bonding_duration()
+	}
+
+	/// See [`StakingInterface::current_era`].
+	fn current_era() -> EraIndex {
+		Self::CoreStaking::current_era()
+	}
+
+	/// See [`StakingInterface::minimum_nominator_bond`].
+	fn minimum_nominator_bond() -> Self::Balance {
+		Self::CoreStaking::minimum_nominator_bond()
+	}
+
+	/// Balance that can be transferred from pool account to member.
+	///
+	/// This is part of the pool balance that is not actively staked. That is, tokens that are
+	/// in unbonding period or unbonded.
+	fn transferable_balance(pool_account: Pool<Self::AccountId>) -> Self::Balance;
+
+	/// Total balance of the pool including amount that is actively staked.
+	fn total_balance(pool_account: Pool<Self::AccountId>) -> Option<Self::Balance>;
+
+	/// Amount of tokens delegated by the member.
+	fn member_delegation_balance(member_account: Member<Self::AccountId>) -> Option<Self::Balance>;
+
+	/// See [`StakingInterface::active_stake`].
+	fn active_stake(pool_account: Pool<Self::AccountId>) -> Self::Balance {
+		Self::CoreStaking::active_stake(&pool_account.0).unwrap_or_default()
+	}
+
+	/// See [`StakingInterface::total_stake`].
+	fn total_stake(pool_account: Pool<Self::AccountId>) -> Self::Balance {
+		Self::CoreStaking::total_stake(&pool_account.0).unwrap_or_default()
+	}
+
+	/// Which strategy the pool account is using.
+	///
+	/// This can be different from the [`Self::strategy_type`] of the adapter if the pool has not
+	/// migrated to the new strategy yet.
+	fn pool_strategy(pool_account: Pool<Self::AccountId>) -> StakeStrategyType {
+		match Self::CoreStaking::is_virtual_staker(&pool_account.0) {
+			true => StakeStrategyType::Delegate,
+			false => StakeStrategyType::Transfer,
+		}
+	}
+
+	/// See [`StakingInterface::nominate`].
+	fn nominate(
+		pool_account: Pool<Self::AccountId>,
+		validators: Vec<Self::AccountId>,
+	) -> DispatchResult {
+		Self::CoreStaking::nominate(&pool_account.0, validators)
+	}
+
+	/// See [`StakingInterface::chill`].
+	fn chill(pool_account: Pool<Self::AccountId>) -> DispatchResult {
+		Self::CoreStaking::chill(&pool_account.0)
+	}
+
+	/// Pledge `amount` towards `pool_account` and update the pool bond. Also see
+	/// [`StakingInterface::bond`].
+	fn pledge_bond(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		reward_account: &Self::AccountId,
+		amount: Self::Balance,
+		bond_type: BondType,
+	) -> DispatchResult;
+
+	/// See [`StakingInterface::unbond`].
+	fn unbond(pool_account: Pool<Self::AccountId>, amount: Self::Balance) -> DispatchResult {
+		Self::CoreStaking::unbond(&pool_account.0, amount)
+	}
+
+	/// See [`StakingInterface::withdraw_unbonded`].
+	fn withdraw_unbonded(
+		pool_account: Pool<Self::AccountId>,
+		num_slashing_spans: u32,
+	) -> Result<bool, DispatchError> {
+		Self::CoreStaking::withdraw_unbonded(pool_account.0, num_slashing_spans)
+	}
+
+	/// Withdraw funds from pool account to member account.
+	fn member_withdraw(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		amount: Self::Balance,
+		num_slashing_spans: u32,
+	) -> DispatchResult;
+
+	/// Check if there is any pending slash for the pool.
+	fn pending_slash(pool_account: Pool<Self::AccountId>) -> Self::Balance;
+
+	/// Slash the member account with `amount` against pending slashes for the pool.
+	fn member_slash(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		amount: Self::Balance,
+		maybe_reporter: Option<Self::AccountId>,
+	) -> DispatchResult;
+
+	/// Migrate pool account from being a direct nominator to a delegated agent.
+	///
+	/// This is useful for migrating a pool account from [`StakeStrategyType::Transfer`] to
+	/// [`StakeStrategyType::Delegate`].
+	fn migrate_nominator_to_agent(
+		pool_account: Pool<Self::AccountId>,
+		reward_account: &Self::AccountId,
+	) -> DispatchResult;
+
+	/// Migrate member balance from pool account to member account.
+	///
+	/// This is useful for a pool account that migrated from [`StakeStrategyType::Transfer`] to
+	/// [`StakeStrategyType::Delegate`]. Its members can then migrate their delegated balance
+	/// back to their account.
+	///
+	/// Internally, the member funds that are locked in the pool account are transferred back and
+	/// locked in the member account.
+	fn migrate_delegation(
+		pool: Pool<Self::AccountId>,
+		delegator: Member<Self::AccountId>,
+		value: Self::Balance,
+	) -> DispatchResult;
+
+	/// List of validators nominated by the pool account.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn nominations(pool_account: Pool<Self::AccountId>) -> Option<Vec<Self::AccountId>> {
+		Self::CoreStaking::nominations(&pool_account.0)
+	}
+
+	/// Remove the pool account as agent.
+	///
+	/// Useful for migrating pool account from a delegated agent to a direct nominator. Only used
+	/// in tests and benchmarks.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn remove_as_agent(_pool: Pool<Self::AccountId>) {
+		// noop by default
+	}
+}
+
+/// A staking strategy implementation that supports transfer based staking.
+///
+/// In order to stake, this adapter transfers the funds from the member/delegator account to the
+/// pool account and stakes through the pool account on `Staking`.
+///
+/// This is the older Staking strategy used by pools. To switch to the newer [`DelegateStake`]
+/// strategy in an existing runtime, storage migration is required. See
+/// [`migration::unversioned::DelegationStakeMigration`]. For new runtimes, it is highly recommended
+/// to use the [`DelegateStake`] strategy.
+pub struct TransferStake<T: Config, Staking: StakingInterface>(PhantomData<(T, Staking)>);
+
+impl<T: Config, Staking: StakingInterface<Balance = BalanceOf<T>, AccountId = T::AccountId>>
+	StakeStrategy for TransferStake<T, Staking>
+{
+	type Balance = BalanceOf<T>;
+	type AccountId = T::AccountId;
+	type CoreStaking = Staking;
+
+	fn strategy_type() -> StakeStrategyType {
+		StakeStrategyType::Transfer
+	}
+
+	fn transferable_balance(pool_account: Pool<Self::AccountId>) -> BalanceOf<T> {
+		T::Currency::balance(&pool_account.0).saturating_sub(Self::active_stake(pool_account))
+	}
+
+	fn total_balance(pool_account: Pool<Self::AccountId>) -> Option<BalanceOf<T>> {
+		Some(T::Currency::total_balance(&pool_account.0))
+	}
+
+	fn member_delegation_balance(
+		_member_account: Member<T::AccountId>,
+	) -> Option<Staking::Balance> {
+		// for transfer stake, no delegation exists.
+		None
+	}
+
+	fn pledge_bond(
+		who: Member<T::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		reward_account: &Self::AccountId,
+		amount: BalanceOf<T>,
+		bond_type: BondType,
+	) -> DispatchResult {
+		match bond_type {
+			BondType::Create => {
+				// first bond
+				T::Currency::transfer(&who.0, &pool_account.0, amount, Preservation::Expendable)?;
+				Staking::bond(&pool_account.0, amount, &reward_account)
+			},
+			BondType::Extra => {
+				// additional bond
+				T::Currency::transfer(&who.0, &pool_account.0, amount, Preservation::Preserve)?;
+				Staking::bond_extra(&pool_account.0, amount)
+			},
+		}
+	}
+
+	fn member_withdraw(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		amount: BalanceOf<T>,
+		_num_slashing_spans: u32,
+	) -> DispatchResult {
+		T::Currency::transfer(&pool_account.0, &who.0, amount, Preservation::Expendable)?;
+
+		Ok(())
+	}
+
+	fn pending_slash(_: Pool<Self::AccountId>) -> Self::Balance {
+		// for transfer stake strategy, slashing is greedy and never deferred.
+		Zero::zero()
+	}
+
+	fn member_slash(
+		_who: Member<Self::AccountId>,
+		_pool: Pool<Self::AccountId>,
+		_amount: Staking::Balance,
+		_maybe_reporter: Option<T::AccountId>,
+	) -> DispatchResult {
+		Err(Error::<T>::Defensive(DefensiveError::DelegationUnsupported).into())
+	}
+
+	fn migrate_nominator_to_agent(
+		_pool: Pool<Self::AccountId>,
+		_reward_account: &Self::AccountId,
+	) -> DispatchResult {
+		Err(Error::<T>::Defensive(DefensiveError::DelegationUnsupported).into())
+	}
+
+	fn migrate_delegation(
+		_pool: Pool<Self::AccountId>,
+		_delegator: Member<Self::AccountId>,
+		_value: Self::Balance,
+	) -> DispatchResult {
+		Err(Error::<T>::Defensive(DefensiveError::DelegationUnsupported).into())
+	}
+}
+
+/// A staking strategy implementation that supports delegation based staking.
+///
+/// In this approach, first the funds are delegated from delegator to the pool account and later
+/// staked with `Staking`. The advantage of this approach is that the funds are held in the
+/// user account itself and not in the pool account.
+///
+/// This is the newer staking strategy used by pools. Once switched to this and migrated, ideally
+/// the `TransferStake` strategy should not be used. Or a separate migration would be required for
+/// it which is not provided by this pallet.
+///
+/// Use [`migration::unversioned::DelegationStakeMigration`] to migrate to this strategy.
+pub struct DelegateStake<T: Config, Staking: StakingInterface, Delegation: DelegationInterface>(
+	PhantomData<(T, Staking, Delegation)>,
+);
+
+impl<
+		T: Config,
+		Staking: StakingInterface<Balance = BalanceOf<T>, AccountId = T::AccountId>,
+		Delegation: DelegationInterface<Balance = BalanceOf<T>, AccountId = T::AccountId>
+			+ DelegationMigrator<Balance = BalanceOf<T>, AccountId = T::AccountId>,
+	> StakeStrategy for DelegateStake<T, Staking, Delegation>
+{
+	type Balance = BalanceOf<T>;
+	type AccountId = T::AccountId;
+	type CoreStaking = Staking;
+
+	fn strategy_type() -> StakeStrategyType {
+		StakeStrategyType::Delegate
+	}
+
+	fn transferable_balance(pool_account: Pool<Self::AccountId>) -> BalanceOf<T> {
+		Delegation::agent_balance(pool_account.clone().into())
+			// pool should always be an agent.
+			.defensive_unwrap_or_default()
+			.saturating_sub(Self::active_stake(pool_account))
+	}
+
+	fn total_balance(pool_account: Pool<Self::AccountId>) -> Option<BalanceOf<T>> {
+		Delegation::agent_balance(pool_account.into())
+	}
+
+	fn member_delegation_balance(member_account: Member<T::AccountId>) -> Option<BalanceOf<T>> {
+		Delegation::delegator_balance(member_account.into())
+	}
+
+	fn pledge_bond(
+		who: Member<T::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		reward_account: &Self::AccountId,
+		amount: BalanceOf<T>,
+		bond_type: BondType,
+	) -> DispatchResult {
+		match bond_type {
+			BondType::Create => {
+				// first delegation
+				Delegation::delegate(who.into(), pool_account.into(), reward_account, amount)
+			},
+			BondType::Extra => {
+				// additional delegation
+				Delegation::delegate_extra(who.into(), pool_account.into(), amount)
+			},
+		}
+	}
+
+	fn member_withdraw(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		amount: BalanceOf<T>,
+		num_slashing_spans: u32,
+	) -> DispatchResult {
+		Delegation::withdraw_delegation(who.into(), pool_account.into(), amount, num_slashing_spans)
+	}
+
+	fn pending_slash(pool_account: Pool<Self::AccountId>) -> Self::Balance {
+		Delegation::pending_slash(pool_account.into()).defensive_unwrap_or_default()
+	}
+
+	fn member_slash(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		amount: BalanceOf<T>,
+		maybe_reporter: Option<T::AccountId>,
+	) -> DispatchResult {
+		Delegation::delegator_slash(pool_account.into(), who.into(), amount, maybe_reporter)
+	}
+
+	fn migrate_nominator_to_agent(
+		pool: Pool<Self::AccountId>,
+		reward_account: &Self::AccountId,
+	) -> DispatchResult {
+		Delegation::migrate_nominator_to_agent(pool.into(), reward_account)
+	}
+
+	fn migrate_delegation(
+		pool: Pool<Self::AccountId>,
+		delegator: Member<Self::AccountId>,
+		value: Self::Balance,
+	) -> DispatchResult {
+		Delegation::migrate_delegation(pool.into(), delegator.into(), value)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn remove_as_agent(pool: Pool<Self::AccountId>) {
+		Delegation::drop_agent(pool.into())
+	}
+}
diff --git a/substrate/frame/nomination-pools/src/lib.rs b/substrate/frame/nomination-pools/src/lib.rs
index 95d23f2280a7e57e76a491c62536174d23f204af..2aaea04463661d6421588e791e7fc281cd872813 100644
--- a/substrate/frame/nomination-pools/src/lib.rs
+++ b/substrate/frame/nomination-pools/src/lib.rs
@@ -351,6 +351,7 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use adapter::{Member, Pool, StakeStrategy};
 use codec::Codec;
 use frame_support::{
 	defensive, defensive_assert, ensure,
@@ -397,6 +398,7 @@ pub mod mock;
 #[cfg(test)]
 mod tests;
 
+pub mod adapter;
 pub mod migration;
 pub mod weights;
 
@@ -425,11 +427,11 @@ pub enum ConfigOp<T: Codec + Debug> {
 }
 
 /// The type of bonding that can happen to a pool.
-enum BondType {
+pub enum BondType {
 	/// Someone is bonding into the pool upon creation.
 	Create,
 	/// Someone is adding more funds later to this pool.
-	Later,
+	Extra,
 }
 
 /// How to increase the bond of a member.
@@ -549,9 +551,19 @@ impl<T: Config> PoolMember<T> {
 
 	/// Total balance of the member, both active and unbonding.
 	/// Doesn't mutate state.
-	#[cfg(any(feature = "try-runtime", feature = "fuzzing", test, debug_assertions))]
-	fn total_balance(&self) -> BalanceOf<T> {
-		let pool = BondedPool::<T>::get(self.pool_id).unwrap();
+	///
+	/// Worst case, iterates over [`TotalUnbondingPools`] member unbonding pools to calculate member
+	/// balance.
+	pub fn total_balance(&self) -> BalanceOf<T> {
+		let pool = match BondedPool::<T>::get(self.pool_id) {
+			Some(pool) => pool,
+			None => {
+				// this internal function is always called with a valid pool id.
+				defensive!("pool should exist; qed");
+				return Zero::zero();
+			},
+		};
+
 		let active_balance = pool.points_to_balance(self.active_points());
 
 		let sub_pools = match SubPoolsStorage::<T>::get(self.pool_id) {
@@ -973,12 +985,12 @@ impl<T: Config> BondedPool<T> {
 
 	/// Get the bonded account id of this pool.
 	fn bonded_account(&self) -> T::AccountId {
-		Pallet::<T>::create_bonded_account(self.id)
+		Pallet::<T>::generate_bonded_account(self.id)
 	}
 
 	/// Get the reward account id of this pool.
 	fn reward_account(&self) -> T::AccountId {
-		Pallet::<T>::create_reward_account(self.id)
+		Pallet::<T>::generate_reward_account(self.id)
 	}
 
 	/// Consume self and put into storage.
@@ -995,8 +1007,7 @@ impl<T: Config> BondedPool<T> {
 	///
 	/// This is often used for bonding and issuing new funds into the pool.
 	fn balance_to_point(&self, new_funds: BalanceOf<T>) -> BalanceOf<T> {
-		let bonded_balance =
-			T::Staking::active_stake(&self.bonded_account()).unwrap_or(Zero::zero());
+		let bonded_balance = T::StakeAdapter::active_stake(Pool::from(self.bonded_account()));
 		Pallet::<T>::balance_to_point(bonded_balance, self.points, new_funds)
 	}
 
@@ -1004,8 +1015,7 @@ impl<T: Config> BondedPool<T> {
 	///
 	/// This is often used for unbonding.
 	fn points_to_balance(&self, points: BalanceOf<T>) -> BalanceOf<T> {
-		let bonded_balance =
-			T::Staking::active_stake(&self.bonded_account()).unwrap_or(Zero::zero());
+		let bonded_balance = T::StakeAdapter::active_stake(Pool::from(self.bonded_account()));
 		Pallet::<T>::point_to_balance(bonded_balance, self.points, points)
 	}
 
@@ -1052,18 +1062,6 @@ impl<T: Config> BondedPool<T> {
 		self
 	}
 
-	/// The pools balance that is transferable provided it is expendable by staking pallet.
-	fn transferable_balance(&self) -> BalanceOf<T> {
-		let account = self.bonded_account();
-		// Note on why we can't use `Currency::reducible_balance`: Since pooled account has a
-		// provider (staking pallet), the account can not be set expendable by
-		// `pallet-nomination-pool`. This means reducible balance always returns balance preserving
-		// ED in the account. What we want though is transferable balance given the account can be
-		// dusted.
-		T::Currency::balance(&account)
-			.saturating_sub(T::Staking::active_stake(&account).unwrap_or_default())
-	}
-
 	fn is_root(&self, who: &T::AccountId) -> bool {
 		self.roles.root.as_ref().map_or(false, |root| root == who)
 	}
@@ -1127,8 +1125,7 @@ impl<T: Config> BondedPool<T> {
 	fn ok_to_be_open(&self) -> Result<(), DispatchError> {
 		ensure!(!self.is_destroying(), Error::<T>::CanNotChangeState);
 
-		let bonded_balance =
-			T::Staking::active_stake(&self.bonded_account()).unwrap_or(Zero::zero());
+		let bonded_balance = T::StakeAdapter::active_stake(Pool::from(self.bonded_account()));
 		ensure!(!bonded_balance.is_zero(), Error::<T>::OverflowRisk);
 
 		let points_to_balance_ratio_floor = self
@@ -1257,28 +1254,17 @@ impl<T: Config> BondedPool<T> {
 		amount: BalanceOf<T>,
 		ty: BondType,
 	) -> Result<BalanceOf<T>, DispatchError> {
-		// Cache the value
-		let bonded_account = self.bonded_account();
-		T::Currency::transfer(
-			who,
-			&bonded_account,
-			amount,
-			match ty {
-				BondType::Create => Preservation::Expendable,
-				BondType::Later => Preservation::Preserve,
-			},
-		)?;
 		// We must calculate the points issued *before* we bond who's funds, else points:balance
 		// ratio will be wrong.
 		let points_issued = self.issue(amount);
 
-		match ty {
-			BondType::Create => T::Staking::bond(&bonded_account, amount, &self.reward_account())?,
-			// The pool should always be created in such a way its in a state to bond extra, but if
-			// the active balance is slashed below the minimum bonded or the account cannot be
-			// found, we exit early.
-			BondType::Later => T::Staking::bond_extra(&bonded_account, amount)?,
-		}
+		T::StakeAdapter::pledge_bond(
+			Member::from(who.clone()),
+			Pool::from(self.bonded_account()),
+			&self.reward_account(),
+			amount,
+			ty,
+		)?;
 		TotalValueLocked::<T>::mutate(|tvl| {
 			tvl.saturating_accrue(amount);
 		});
@@ -1456,7 +1442,7 @@ impl<T: Config> RewardPool<T> {
 	/// This is sum of all the rewards that are claimable by pool members.
 	fn current_balance(id: PoolId) -> BalanceOf<T> {
 		T::Currency::reducible_balance(
-			&Pallet::<T>::create_reward_account(id),
+			&Pallet::<T>::generate_reward_account(id),
 			Preservation::Expendable,
 			Fortitude::Polite,
 		)
@@ -1569,7 +1555,7 @@ impl<T: Config> Get<u32> for TotalUnbondingPools<T> {
 		// NOTE: this may be dangerous in the scenario bonding_duration gets decreased because
 		// we would no longer be able to decode `BoundedBTreeMap::<EraIndex, UnbondPool<T>,
 		// TotalUnbondingPools<T>>`, which uses `TotalUnbondingPools` as the bound
-		T::Staking::bonding_duration() + T::PostUnbondingPoolsWindow::get()
+		T::StakeAdapter::bonding_duration() + T::PostUnbondingPoolsWindow::get()
 	}
 }
 
@@ -1646,7 +1632,9 @@ pub mod pallet {
 		type U256ToBalance: Convert<U256, BalanceOf<Self>>;
 
 		/// The interface for nominating.
-		type Staking: StakingInterface<Balance = BalanceOf<Self>, AccountId = Self::AccountId>;
+		///
+		/// Note: Switching to a new [`StakeStrategy`] might require a migration of the storage.
+		type StakeAdapter: StakeStrategy<AccountId = Self::AccountId, Balance = BalanceOf<Self>>;
 
 		/// The amount of eras a `SubPools::with_era` pool can exist before it gets merged into the
 		/// `SubPools::no_era` pool. In other words, this is the amount of eras a member will be
@@ -1950,6 +1938,14 @@ pub mod pallet {
 		BondExtraRestricted,
 		/// No imbalance in the ED deposit for the pool.
 		NothingToAdjust,
+		/// No slash pending that can be applied to the member.
+		NothingToSlash,
+		/// The pool or member delegation has already migrated to delegate stake.
+		AlreadyMigrated,
+		/// The pool or member delegation has not migrated yet to delegate stake.
+		NotMigrated,
+		/// This call is not allowed in the current state of the pallet.
+		NotSupported,
 	}
 
 	#[derive(Encode, Decode, PartialEq, TypeInfo, PalletError, RuntimeDebug)]
@@ -1965,6 +1961,10 @@ pub mod pallet {
 		/// The bonded account should only be killed by the staking system when the depositor is
 		/// withdrawing
 		BondedStashKilledPrematurely,
+		/// The delegation feature is unsupported.
+		DelegationUnsupported,
+		/// Unable to slash to the member of the pool.
+		SlashNotApplied,
 	}
 
 	impl<T> From<DefensiveError> for Error<T> {
@@ -2019,7 +2019,7 @@ pub mod pallet {
 			)?;
 
 			bonded_pool.try_inc_members()?;
-			let points_issued = bonded_pool.try_bond_funds(&who, amount, BondType::Later)?;
+			let points_issued = bonded_pool.try_bond_funds(&who, amount, BondType::Extra)?;
 
 			PoolMembers::insert(
 				who.clone(),
@@ -2141,12 +2141,12 @@ pub mod pallet {
 				&mut reward_pool,
 			)?;
 
-			let current_era = T::Staking::current_era();
-			let unbond_era = T::Staking::bonding_duration().saturating_add(current_era);
+			let current_era = T::StakeAdapter::current_era();
+			let unbond_era = T::StakeAdapter::bonding_duration().saturating_add(current_era);
 
 			// Unbond in the actual underlying nominator.
 			let unbonding_balance = bonded_pool.dissolve(unbonding_points);
-			T::Staking::unbond(&bonded_pool.bonded_account(), unbonding_balance)?;
+			T::StakeAdapter::unbond(Pool::from(bonded_pool.bonded_account()), unbonding_balance)?;
 
 			// Note that we lazily create the unbonding pools here if they don't already exist
 			let mut sub_pools = SubPoolsStorage::<T>::get(member.pool_id)
@@ -2209,7 +2209,10 @@ pub mod pallet {
 			// For now we only allow a pool to withdraw unbonded if its not destroying. If the pool
 			// is destroying then `withdraw_unbonded` can be used.
 			ensure!(pool.state != PoolState::Destroying, Error::<T>::NotDestroying);
-			T::Staking::withdraw_unbonded(pool.bonded_account(), num_slashing_spans)?;
+			T::StakeAdapter::withdraw_unbonded(
+				Pool::from(pool.bonded_account()),
+				num_slashing_spans,
+			)?;
 
 			Ok(())
 		}
@@ -2232,7 +2235,10 @@ pub mod pallet {
 		///
 		/// # Note
 		///
-		/// If the target is the depositor, the pool will be destroyed.
+		/// - If the target is the depositor, the pool will be destroyed.
+		/// - If the pool has any pending slash, we also try to slash the member before letting them
+		/// withdraw. This calculation adds some weight overhead and is only defensive. In reality,
+		/// pool slashes must have been already applied via permissionless [`Call::apply_slash`].
 		#[pallet::call_index(5)]
 		#[pallet::weight(
 			T::WeightInfo::withdraw_unbonded_kill(*num_slashing_spans)
@@ -2246,13 +2252,30 @@ pub mod pallet {
 			let member_account = T::Lookup::lookup(member_account)?;
 			let mut member =
 				PoolMembers::<T>::get(&member_account).ok_or(Error::<T>::PoolMemberNotFound)?;
-			let current_era = T::Staking::current_era();
+			let current_era = T::StakeAdapter::current_era();
 
 			let bonded_pool = BondedPool::<T>::get(member.pool_id)
 				.defensive_ok_or::<Error<T>>(DefensiveError::PoolNotFound.into())?;
 			let mut sub_pools =
 				SubPoolsStorage::<T>::get(member.pool_id).ok_or(Error::<T>::SubPoolsNotFound)?;
 
+			let slash_weight =
+				// apply slash if any before withdraw.
+				match Self::do_apply_slash(&member_account, None) {
+					Ok(_) => T::WeightInfo::apply_slash(),
+					Err(e) => {
+						let no_pending_slash: DispatchResult = Err(Error::<T>::NothingToSlash.into());
+						// This is an expected error. We add appropriate fees and continue withdrawal.
+						if Err(e) == no_pending_slash {
+							T::WeightInfo::apply_slash_fail()
+						} else {
+							// defensive: if we can't apply slash for some reason, we abort.
+							return Err(Error::<T>::Defensive(DefensiveError::SlashNotApplied).into());
+						}
+					}
+
+				};
+
 			bonded_pool.ok_to_withdraw_unbonded_with(&caller, &member_account)?;
 			let pool_account = bonded_pool.bonded_account();
 
@@ -2261,9 +2284,11 @@ pub mod pallet {
 			ensure!(!withdrawn_points.is_empty(), Error::<T>::CannotWithdrawAny);
 
 			// Before calculating the `balance_to_unbond`, we call withdraw unbonded to ensure the
-			// `transferrable_balance` is correct.
-			let stash_killed =
-				T::Staking::withdraw_unbonded(pool_account.clone(), num_slashing_spans)?;
+			// `transferable_balance` is correct.
+			let stash_killed = T::StakeAdapter::withdraw_unbonded(
+				Pool::from(bonded_pool.bonded_account()),
+				num_slashing_spans,
+			)?;
 
 			// defensive-only: the depositor puts enough funds into the stash so that it will only
 			// be destroyed when they are leaving.
@@ -2310,15 +2335,18 @@ pub mod pallet {
 				// don't exist. This check is also defensive in cases where the unbond pool does not
 				// update its balance (e.g. a bug in the slashing hook.) We gracefully proceed in
 				// order to ensure members can leave the pool and it can be destroyed.
-				.min(bonded_pool.transferable_balance());
-
-			T::Currency::transfer(
-				&bonded_pool.bonded_account(),
-				&member_account,
+				.min(T::StakeAdapter::transferable_balance(Pool::from(
+					bonded_pool.bonded_account(),
+				)));
+
+			// this can fail if the pool uses `DelegateStake` strategy and the member delegation
+			// is not claimed yet. See `Call::migrate_delegation()`.
+			T::StakeAdapter::member_withdraw(
+				Member::from(member_account.clone()),
+				Pool::from(bonded_pool.bonded_account()),
 				balance_to_unbond,
-				Preservation::Expendable,
-			)
-			.defensive()?;
+				num_slashing_spans,
+			)?;
 
 			Self::deposit_event(Event::<T>::Withdrawn {
 				member: member_account.clone(),
@@ -2340,20 +2368,20 @@ pub mod pallet {
 
 				if member_account == bonded_pool.roles.depositor {
 					Pallet::<T>::dissolve_pool(bonded_pool);
-					None
+					Weight::default()
 				} else {
 					bonded_pool.dec_members().put();
 					SubPoolsStorage::<T>::insert(member.pool_id, sub_pools);
-					Some(T::WeightInfo::withdraw_unbonded_update(num_slashing_spans))
+					T::WeightInfo::withdraw_unbonded_update(num_slashing_spans)
 				}
 			} else {
 				// we certainly don't need to delete any pools, because no one is being removed.
 				SubPoolsStorage::<T>::insert(member.pool_id, sub_pools);
 				PoolMembers::<T>::insert(&member_account, member);
-				Some(T::WeightInfo::withdraw_unbonded_update(num_slashing_spans))
+				T::WeightInfo::withdraw_unbonded_update(num_slashing_spans)
 			};
 
-			Ok(post_info_weight.into())
+			Ok(Some(post_info_weight.saturating_add(slash_weight)).into())
 		}
 
 		/// Create a new delegation pool.
@@ -2448,7 +2476,7 @@ pub mod pallet {
 				Error::<T>::MinimumBondNotMet
 			);
 
-			T::Staking::nominate(&bonded_pool.bonded_account(), validators)
+			T::StakeAdapter::nominate(Pool::from(bonded_pool.bonded_account()), validators)
 		}
 
 		/// Set a new state for the pool.
@@ -2636,12 +2664,12 @@ pub mod pallet {
 				.active_points();
 
 			if bonded_pool.points_to_balance(depositor_points) >=
-				T::Staking::minimum_nominator_bond()
+				T::StakeAdapter::minimum_nominator_bond()
 			{
 				ensure!(bonded_pool.can_nominate(&who), Error::<T>::NotNominator);
 			}
 
-			T::Staking::chill(&bonded_pool.bonded_account())
+			T::StakeAdapter::chill(Pool::from(bonded_pool.bonded_account()))
 		}
 
 		/// `origin` bonds funds from `extra` for some pool member `member` into their respective
@@ -2838,6 +2866,120 @@ pub mod pallet {
 
 			Ok(())
 		}
+
+		/// Apply a pending slash on a member.
+		///
+		/// Fails unless [`crate::pallet::Config::StakeAdapter`] is of strategy type:
+		/// [`adapter::StakeStrategyType::Delegate`].
+		///
+		/// This call can be dispatched permissionlessly (i.e. by any account). If the member has
+		/// slash to be applied, caller may be rewarded with the part of the slash.
+		#[pallet::call_index(23)]
+		#[pallet::weight(T::WeightInfo::apply_slash())]
+		pub fn apply_slash(
+			origin: OriginFor<T>,
+			member_account: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			ensure!(
+				T::StakeAdapter::strategy_type() == adapter::StakeStrategyType::Delegate,
+				Error::<T>::NotSupported
+			);
+
+			let who = ensure_signed(origin)?;
+			let member_account = T::Lookup::lookup(member_account)?;
+			Self::do_apply_slash(&member_account, Some(who))?;
+
+			// If successful, refund the fees.
+			Ok(Pays::No.into())
+		}
+
+		/// Migrates delegated funds from the pool account to the `member_account`.
+		///
+		/// Fails unless [`crate::pallet::Config::StakeAdapter`] is of strategy type:
+		/// [`adapter::StakeStrategyType::Delegate`].
+		///
+		/// This is a permission-less call and refunds any fee if claim is successful.
+		///
+		/// If the pool has migrated to delegation based staking, the staked tokens of pool members
+		/// can be moved and held in their own account. See [`adapter::DelegateStake`]
+		#[pallet::call_index(24)]
+		#[pallet::weight(T::WeightInfo::migrate_delegation())]
+		pub fn migrate_delegation(
+			origin: OriginFor<T>,
+			member_account: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let _caller = ensure_signed(origin)?;
+
+			ensure!(
+				T::StakeAdapter::strategy_type() == adapter::StakeStrategyType::Delegate,
+				Error::<T>::NotSupported
+			);
+
+			let member_account = T::Lookup::lookup(member_account)?;
+			let member =
+				PoolMembers::<T>::get(&member_account).ok_or(Error::<T>::PoolMemberNotFound)?;
+
+			// ensure pool is migrated.
+			ensure!(
+				T::StakeAdapter::pool_strategy(Pool::from(Self::generate_bonded_account(
+					member.pool_id
+				))) == adapter::StakeStrategyType::Delegate,
+				Error::<T>::NotMigrated
+			);
+
+			let pool_contribution = member.total_balance();
+			ensure!(pool_contribution >= MinJoinBond::<T>::get(), Error::<T>::MinimumBondNotMet);
+			// the member must have some contribution to be migrated.
+			ensure!(pool_contribution > Zero::zero(), Error::<T>::AlreadyMigrated);
+
+			let delegation =
+				T::StakeAdapter::member_delegation_balance(Member::from(member_account.clone()));
+			// delegation should not exist.
+			ensure!(delegation.is_none(), Error::<T>::AlreadyMigrated);
+
+			T::StakeAdapter::migrate_delegation(
+				Pool::from(Pallet::<T>::generate_bonded_account(member.pool_id)),
+				Member::from(member_account),
+				pool_contribution,
+			)?;
+
+			// if successful, we refund the fee.
+			Ok(Pays::No.into())
+		}
+
+		/// Migrate pool from [`adapter::StakeStrategyType::Transfer`] to
+		/// [`adapter::StakeStrategyType::Delegate`].
+		///
+		/// Fails unless [`crate::pallet::Config::StakeAdapter`] is of strategy type:
+		/// [`adapter::StakeStrategyType::Delegate`].
+		///
+		/// This call can be dispatched permissionlessly, and refunds any fee if successful.
+		///
+		/// If the pool has already migrated to delegation based staking, this call will fail.
+		#[pallet::call_index(25)]
+		#[pallet::weight(T::WeightInfo::pool_migrate())]
+		pub fn migrate_pool_to_delegate_stake(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+		) -> DispatchResultWithPostInfo {
+			// gate this call to be called only if `DelegateStake` strategy is used.
+			ensure!(
+				T::StakeAdapter::strategy_type() == adapter::StakeStrategyType::Delegate,
+				Error::<T>::NotSupported
+			);
+
+			let _caller = ensure_signed(origin)?;
+			// ensure pool exists.
+			let bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			ensure!(
+				T::StakeAdapter::pool_strategy(Pool::from(bonded_pool.bonded_account())) ==
+					adapter::StakeStrategyType::Transfer,
+				Error::<T>::AlreadyMigrated
+			);
+
+			Self::migrate_to_delegate_stake(pool_id)?;
+			Ok(Pays::No.into())
+		}
 	}
 
 	#[pallet::hooks]
@@ -2853,7 +2995,7 @@ pub mod pallet {
 				"Minimum points to balance ratio must be greater than 0"
 			);
 			assert!(
-				T::Staking::bonding_duration() < TotalUnbondingPools::<T>::get(),
+				T::StakeAdapter::bonding_duration() < TotalUnbondingPools::<T>::get(),
 				"There must be more unbonding pools then the bonding duration /
 				so a slash can be applied to relevant unbonding pools. (We assume /
 				the bonding duration > slash deffer duration.",
@@ -2871,7 +3013,7 @@ impl<T: Config> Pallet<T> {
 	/// It is essentially `max { MinNominatorBond, MinCreateBond, MinJoinBond }`, where the former
 	/// is coming from the staking pallet and the latter two are configured in this pallet.
 	pub fn depositor_min_bond() -> BalanceOf<T> {
-		T::Staking::minimum_nominator_bond()
+		T::StakeAdapter::minimum_nominator_bond()
 			.max(MinCreateBond::<T>::get())
 			.max(MinJoinBond::<T>::get())
 			.max(T::Currency::minimum_balance())
@@ -2907,7 +3049,7 @@ impl<T: Config> Pallet<T> {
 			"bonded account of dissolving pool should have no consumers"
 		);
 		defensive_assert!(
-			T::Staking::total_stake(&bonded_account).unwrap_or_default() == Zero::zero(),
+			T::StakeAdapter::total_stake(Pool::from(bonded_pool.bonded_account())) == Zero::zero(),
 			"dissolving pool should not have any stake in the staking pallet"
 		);
 
@@ -2930,11 +3072,14 @@ impl<T: Config> Pallet<T> {
 			"could not transfer all amount to depositor while dissolving pool"
 		);
 		defensive_assert!(
-			T::Currency::total_balance(&bonded_pool.bonded_account()) == Zero::zero(),
+			T::StakeAdapter::total_balance(Pool::from(bonded_pool.bonded_account()))
+				.unwrap_or_default() ==
+				Zero::zero(),
 			"dissolving pool should not have any balance"
 		);
 		// NOTE: Defensively force set balance to zero.
 		T::Currency::set_balance(&reward_account, Zero::zero());
+		// NOTE: With `DelegateStake` strategy, this won't do anything.
 		T::Currency::set_balance(&bonded_pool.bonded_account(), Zero::zero());
 
 		Self::deposit_event(Event::<T>::Destroyed { pool_id: bonded_pool.id });
@@ -2945,12 +3090,19 @@ impl<T: Config> Pallet<T> {
 	}
 
 	/// Create the main, bonded account of a pool with the given id.
-	pub fn create_bonded_account(id: PoolId) -> T::AccountId {
+	pub fn generate_bonded_account(id: PoolId) -> T::AccountId {
 		T::PalletId::get().into_sub_account_truncating((AccountType::Bonded, id))
 	}
 
+	fn migrate_to_delegate_stake(id: PoolId) -> DispatchResult {
+		T::StakeAdapter::migrate_nominator_to_agent(
+			Pool::from(Self::generate_bonded_account(id)),
+			&Self::generate_reward_account(id),
+		)
+	}
+
 	/// Create the reward account of a pool with the given id.
-	pub fn create_reward_account(id: PoolId) -> T::AccountId {
+	pub fn generate_reward_account(id: PoolId) -> T::AccountId {
 		// NOTE: in order to have a distinction in the test account id type (u128), we put
 		// account_type first so it does not get truncated out.
 		T::PalletId::get().into_sub_account_truncating((AccountType::Reward, id))
@@ -3194,9 +3346,9 @@ impl<T: Config> Pallet<T> {
 
 		let (points_issued, bonded) = match extra {
 			BondExtra::FreeBalance(amount) =>
-				(bonded_pool.try_bond_funds(&member_account, amount, BondType::Later)?, amount),
+				(bonded_pool.try_bond_funds(&member_account, amount, BondType::Extra)?, amount),
 			BondExtra::Rewards =>
-				(bonded_pool.try_bond_funds(&member_account, claimed, BondType::Later)?, claimed),
+				(bonded_pool.try_bond_funds(&member_account, claimed, BondType::Extra)?, claimed),
 		};
 
 		bonded_pool.ok_to_be_open()?;
@@ -3317,6 +3469,64 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
+	/// Slash member against the pending slash for the pool.
+	fn do_apply_slash(
+		member_account: &T::AccountId,
+		reporter: Option<T::AccountId>,
+	) -> DispatchResult {
+		let member = PoolMembers::<T>::get(member_account).ok_or(Error::<T>::PoolMemberNotFound)?;
+
+		let pending_slash =
+			Self::member_pending_slash(Member::from(member_account.clone()), member.clone())?;
+
+		// if nothing to slash, return error.
+		ensure!(!pending_slash.is_zero(), Error::<T>::NothingToSlash);
+
+		T::StakeAdapter::member_slash(
+			Member::from(member_account.clone()),
+			Pool::from(Pallet::<T>::generate_bonded_account(member.pool_id)),
+			pending_slash,
+			reporter,
+		)
+	}
+
+	/// Pending slash for a member.
+	///
+	/// Takes the pool_member object corresponding to the `member_account`.
+	fn member_pending_slash(
+		member_account: Member<T::AccountId>,
+		pool_member: PoolMember<T>,
+	) -> Result<BalanceOf<T>, DispatchError> {
+		// only executed in tests: ensure the member account is correct.
+		debug_assert!(
+			PoolMembers::<T>::get(member_account.clone().get()).expect("member must exist") ==
+				pool_member
+		);
+
+		let pool_account = Pallet::<T>::generate_bonded_account(pool_member.pool_id);
+		// if the pool doesn't have any pending slash, it implies the member also does not have any
+		// pending slash.
+		if T::StakeAdapter::pending_slash(Pool::from(pool_account.clone())).is_zero() {
+			return Ok(Zero::zero())
+		}
+
+		// this is their actual held balance that may or may not have been slashed.
+		let actual_balance = T::StakeAdapter::member_delegation_balance(member_account)
+			// no delegation implies the member delegation is not migrated yet to `DelegateStake`.
+			.ok_or(Error::<T>::NotMigrated)?;
+
+		// this is their balance in the pool
+		let expected_balance = pool_member.total_balance();
+
+		defensive_assert!(
+			actual_balance >= expected_balance,
+			"actual balance should always be greater or equal to the expected"
+		);
+
+		// return the amount to be slashed.
+		Ok(actual_balance.defensive_saturating_sub(expected_balance))
+	}
+
 	/// Apply freeze on reward account to restrict it from going below ED.
 	pub(crate) fn freeze_pool_deposit(reward_acc: &T::AccountId) -> DispatchResult {
 		T::Currency::set_freeze(
@@ -3395,7 +3605,7 @@ impl<T: Config> Pallet<T> {
 		);
 
 		for id in reward_pools {
-			let account = Self::create_reward_account(id);
+			let account = Self::generate_reward_account(id);
 			if T::Currency::reducible_balance(&account, Preservation::Expendable, Fortitude::Polite) <
 				T::Currency::minimum_balance()
 			{
@@ -3480,8 +3690,7 @@ impl<T: Config> Pallet<T> {
 				pool is being destroyed and the depositor is the last member",
 			);
 
-			expected_tvl +=
-				T::Staking::total_stake(&bonded_pool.bonded_account()).unwrap_or_default();
+			expected_tvl += T::StakeAdapter::total_stake(Pool::from(bonded_pool.bonded_account()));
 
 			Ok(())
 		})?;
@@ -3506,12 +3715,15 @@ impl<T: Config> Pallet<T> {
 		}
 
 		for (pool_id, _pool) in BondedPools::<T>::iter() {
-			let pool_account = Pallet::<T>::create_bonded_account(pool_id);
+			let pool_account = Pallet::<T>::generate_bonded_account(pool_id);
 			let subs = SubPoolsStorage::<T>::get(pool_id).unwrap_or_default();
 
 			let sum_unbonding_balance = subs.sum_unbonding_balance();
-			let bonded_balance = T::Staking::active_stake(&pool_account).unwrap_or_default();
-			let total_balance = T::Currency::total_balance(&pool_account);
+			let bonded_balance = T::StakeAdapter::active_stake(Pool::from(pool_account.clone()));
+			let total_balance = T::StakeAdapter::total_balance(Pool::from(pool_account.clone()))
+				// At the time when StakeAdapter is changed to `DelegateStake` but pool is not yet
+				// migrated, the total balance would be none.
+				.unwrap_or(T::Currency::total_balance(&pool_account));
 
 			assert!(
 				total_balance >= bonded_balance + sum_unbonding_balance,
@@ -3544,7 +3756,7 @@ impl<T: Config> Pallet<T> {
 	pub fn check_ed_imbalance() -> Result<(), DispatchError> {
 		let mut failed: u32 = 0;
 		BondedPools::<T>::iter_keys().for_each(|id| {
-			let reward_acc = Self::create_reward_account(id);
+			let reward_acc = Self::generate_reward_account(id);
 			let frozen_balance =
 				T::Currency::balance_frozen(&FreezeReason::PoolMinBalance.into(), &reward_acc);
 
@@ -3615,12 +3827,75 @@ impl<T: Config> Pallet<T> {
 	pub fn api_balance_to_points(pool_id: PoolId, new_funds: BalanceOf<T>) -> BalanceOf<T> {
 		if let Some(pool) = BondedPool::<T>::get(pool_id) {
 			let bonded_balance =
-				T::Staking::active_stake(&pool.bonded_account()).unwrap_or(Zero::zero());
+				T::StakeAdapter::active_stake(Pool::from(Self::generate_bonded_account(pool_id)));
 			Pallet::<T>::balance_to_point(bonded_balance, pool.points, new_funds)
 		} else {
 			Zero::zero()
 		}
 	}
+
+	/// Returns the unapplied slash of the pool.
+	///
+	/// Pending slash is only applicable with [`adapter::DelegateStake`] strategy.
+	pub fn api_pool_pending_slash(pool_id: PoolId) -> BalanceOf<T> {
+		T::StakeAdapter::pending_slash(Pool::from(Self::generate_bonded_account(pool_id)))
+	}
+
+	/// Returns the unapplied slash of a member.
+	///
+	/// Pending slash is only applicable with [`adapter::DelegateStake`] strategy.
+	pub fn api_member_pending_slash(who: T::AccountId) -> BalanceOf<T> {
+		PoolMembers::<T>::get(who.clone())
+			.map(|pool_member| {
+				Self::member_pending_slash(Member::from(who), pool_member).unwrap_or_default()
+			})
+			.unwrap_or_default()
+	}
+
+	/// Checks whether pool needs to be migrated to [`adapter::StakeStrategyType::Delegate`]. Only
+	/// applicable when the [`Config::StakeAdapter`] is [`adapter::DelegateStake`].
+	///
+	/// Useful to check this before calling [`Call::migrate_pool_to_delegate_stake`].
+	pub fn api_pool_needs_delegate_migration(pool_id: PoolId) -> bool {
+		// if the `Delegate` strategy is not used in the pallet, then no migration required.
+		if T::StakeAdapter::strategy_type() != adapter::StakeStrategyType::Delegate {
+			return false
+		}
+
+		let pool_account = Self::generate_bonded_account(pool_id);
+		// true if pool is still not migrated to `DelegateStake`.
+		T::StakeAdapter::pool_strategy(Pool::from(pool_account)) !=
+			adapter::StakeStrategyType::Delegate
+	}
+
+	/// Checks whether member delegation needs to be migrated to
+	/// [`adapter::StakeStrategyType::Delegate`]. Only applicable when the [`Config::StakeAdapter`]
+	/// is [`adapter::DelegateStake`].
+	///
+	/// Useful to check this before calling [`Call::migrate_delegation`].
+	pub fn api_member_needs_delegate_migration(who: T::AccountId) -> bool {
+		// if the `Delegate` strategy is not used in the pallet, then no migration required.
+		if T::StakeAdapter::strategy_type() != adapter::StakeStrategyType::Delegate {
+			return false
+		}
+
+		PoolMembers::<T>::get(who.clone())
+			.map(|pool_member| {
+				if Self::api_pool_needs_delegate_migration(pool_member.pool_id) {
+					// the pool needs to be migrated before members can be migrated.
+					return false
+				}
+
+				let member_balance = pool_member.total_balance();
+				let delegated_balance =
+					T::StakeAdapter::member_delegation_balance(Member::from(who.clone()));
+
+				// if the member has no delegation but has some balance in the pool, then it needs
+				// to be migrated.
+				delegated_balance.is_none() && !member_balance.is_zero()
+			})
+			.unwrap_or_default()
+	}
 }
 
 impl<T: Config> sp_staking::OnStakingUpdate<T::AccountId, BalanceOf<T>> for Pallet<T> {
diff --git a/substrate/frame/nomination-pools/src/migration.rs b/substrate/frame/nomination-pools/src/migration.rs
index 796b310862afcb8b897d4dafd66395e33e1970fb..a9222ea53d75fde59ac47ca0c6fd4d209aa3177b 100644
--- a/substrate/frame/nomination-pools/src/migration.rs
+++ b/substrate/frame/nomination-pools/src/migration.rs
@@ -107,6 +107,137 @@ pub mod unversioned {
 			Ok(())
 		}
 	}
+
+	/// Migrate existing pools from [`adapter::StakeStrategyType::Transfer`] to
+	/// [`adapter::StakeStrategyType::Delegate`].
+	///
+	/// Note: This only migrates the pools, the members are not migrated. They can use the
+	/// permission-less [`Pallet::migrate_delegation()`] to migrate their funds.
+	///
+	/// This migration does not break any existing pool storage item, does not need to happen in any
+	/// sequence and hence can be applied unversioned on a production runtime.
+	///
+	/// Takes `MaxPools` as type parameter to limit the number of pools that should be migrated in a
+	/// single block. It should be set such that migration weight does not exceed the block weight
+	/// limit. If all pools can be safely migrated, it is good to keep this number a little higher
+	/// than the actual number of pools to handle any extra pools created while the migration is
+	/// proposed, and before it is executed.
+	///
+	/// If there are pools that fail to migrate or did not fit in the bounds, the remaining pools
+	/// can be migrated via the permission-less extrinsic [`Call::migrate_pool_to_delegate_stake`].
+	pub struct DelegationStakeMigration<T, MaxPools>(sp_std::marker::PhantomData<(T, MaxPools)>);
+
+	impl<T: Config, MaxPools: Get<u32>> OnRuntimeUpgrade for DelegationStakeMigration<T, MaxPools> {
+		fn on_runtime_upgrade() -> Weight {
+			let mut count: u32 = 0;
+
+			BondedPools::<T>::iter_keys().take(MaxPools::get() as usize).for_each(|id| {
+				let pool_acc = Pallet::<T>::generate_bonded_account(id);
+
+				// only migrate if the pool is in Transfer Strategy.
+				if T::StakeAdapter::pool_strategy(Pool::from(pool_acc)) ==
+					adapter::StakeStrategyType::Transfer
+				{
+					let _ = Pallet::<T>::migrate_to_delegate_stake(id).map_err(|err| {
+						log!(
+							warn,
+							"failed to migrate pool {:?} to delegate stake strategy with err: {:?}",
+							id,
+							err
+						)
+					});
+					count.saturating_inc();
+				}
+			});
+
+			log!(info, "migrated {:?} pools to delegate stake strategy", count);
+
+			// reads: (bonded pool key + current pool strategy) * MaxPools (worst case)
+			T::DbWeight::get()
+				.reads_writes(2, 0)
+				.saturating_mul(MaxPools::get() as u64)
+				// migration weight: `pool_migrate` weight * count
+				.saturating_add(T::WeightInfo::pool_migrate().saturating_mul(count.into()))
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			// ensure stake adapter is correct.
+			ensure!(
+				T::StakeAdapter::strategy_type() == adapter::StakeStrategyType::Delegate,
+				"Current strategy is not `Delegate"
+			);
+
+			if BondedPools::<T>::count() > MaxPools::get() {
+				// we log a warning if the number of pools exceeds the bound.
+				log!(
+					warn,
+					"Number of pools {} exceeds the maximum bound {}. This would leave some pools unmigrated.", BondedPools::<T>::count(), MaxPools::get()
+				);
+			}
+
+			let mut pool_balances: Vec<BalanceOf<T>> = Vec::new();
+			BondedPools::<T>::iter_keys().take(MaxPools::get() as usize).for_each(|id| {
+				let pool_account = Pallet::<T>::generate_bonded_account(id);
+
+				// we ensure migration is idempotent.
+				let pool_balance = T::StakeAdapter::total_balance(Pool::from(pool_account.clone()))
+					// we check actual account balance if pool has not migrated yet.
+					.unwrap_or(T::Currency::total_balance(&pool_account));
+
+				pool_balances.push(pool_balance);
+			});
+
+			Ok(pool_balances.encode())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(data: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let expected_pool_balances: Vec<BalanceOf<T>> = Decode::decode(&mut &data[..]).unwrap();
+
+			for (index, id) in
+				BondedPools::<T>::iter_keys().take(MaxPools::get() as usize).enumerate()
+			{
+				let pool_account = Pallet::<T>::generate_bonded_account(id);
+				if T::StakeAdapter::pool_strategy(Pool::from(pool_account.clone())) ==
+					adapter::StakeStrategyType::Transfer
+				{
+					log!(error, "Pool {} failed to migrate", id,);
+					return Err(TryRuntimeError::Other("Pool failed to migrate"));
+				}
+
+				let actual_balance =
+					T::StakeAdapter::total_balance(Pool::from(pool_account.clone()))
+						.expect("after migration, this should return a value");
+				let expected_balance = expected_pool_balances.get(index).unwrap();
+
+				if actual_balance != *expected_balance {
+					log!(
+						error,
+						"Pool {} balance mismatch. Expected: {:?}, Actual: {:?}",
+						id,
+						expected_balance,
+						actual_balance
+					);
+					return Err(TryRuntimeError::Other("Pool balance mismatch"));
+				}
+
+				// account balance should be zero.
+				let pool_account_balance = T::Currency::total_balance(&pool_account);
+				if pool_account_balance != Zero::zero() {
+					log!(
+						error,
+						"Pool account balance was expected to be zero. Pool: {}, Balance: {:?}",
+						id,
+						pool_account_balance
+					);
+					return Err(TryRuntimeError::Other("Pool account balance not migrated"));
+				}
+			}
+
+			Ok(())
+		}
+	}
 }
 
 pub mod v8 {
@@ -201,7 +332,7 @@ pub(crate) mod v7 {
 	impl<T: Config> V7BondedPool<T> {
 		#[allow(dead_code)]
 		fn bonded_account(&self) -> T::AccountId {
-			Pallet::<T>::create_bonded_account(self.id)
+			Pallet::<T>::generate_bonded_account(self.id)
 		}
 	}
 
@@ -275,7 +406,7 @@ mod v6 {
 
 	impl<T: Config> MigrateToV6<T> {
 		fn freeze_ed(pool_id: PoolId) -> Result<(), ()> {
-			let reward_acc = Pallet::<T>::create_reward_account(pool_id);
+			let reward_acc = Pallet::<T>::generate_reward_account(pool_id);
 			Pallet::<T>::freeze_pool_deposit(&reward_acc).map_err(|e| {
 				log!(error, "Failed to freeze ED for pool {} with error: {:?}", pool_id, e);
 				()
@@ -760,7 +891,7 @@ pub mod v2 {
 					};
 
 					let accumulated_reward = RewardPool::<T>::current_balance(id);
-					let reward_account = Pallet::<T>::create_reward_account(id);
+					let reward_account = Pallet::<T>::generate_reward_account(id);
 					let mut sum_paid_out = BalanceOf::<T>::zero();
 
 					members
@@ -882,7 +1013,7 @@ pub mod v2 {
 			// all reward accounts must have more than ED.
 			RewardPools::<T>::iter().try_for_each(|(id, _)| -> Result<(), TryRuntimeError> {
 				ensure!(
-					<T::Currency as frame_support::traits::fungible::Inspect<T::AccountId>>::balance(&Pallet::<T>::create_reward_account(id)) >=
+					<T::Currency as frame_support::traits::fungible::Inspect<T::AccountId>>::balance(&Pallet::<T>::generate_reward_account(id)) >=
 						T::Currency::minimum_balance(),
 					"Reward accounts must have greater balance than ED."
 				);
@@ -1022,10 +1153,9 @@ mod helpers {
 	use super::*;
 
 	pub(crate) fn calculate_tvl_by_total_stake<T: Config>() -> BalanceOf<T> {
-		BondedPools::<T>::iter()
-			.map(|(id, inner)| {
-				T::Staking::total_stake(&BondedPool { id, inner: inner.clone() }.bonded_account())
-					.unwrap_or_default()
+		BondedPools::<T>::iter_keys()
+			.map(|id| {
+				T::StakeAdapter::total_stake(Pool::from(Pallet::<T>::generate_bonded_account(id)))
 			})
 			.reduce(|acc, total_balance| acc + total_balance)
 			.unwrap_or_default()
diff --git a/substrate/frame/nomination-pools/src/mock.rs b/substrate/frame/nomination-pools/src/mock.rs
index e34719a7b80e87cef65cfc5dd638ee4ca5573803..6c0082073f6827a5d264281bc29e08b708233e35 100644
--- a/substrate/frame/nomination-pools/src/mock.rs
+++ b/substrate/frame/nomination-pools/src/mock.rs
@@ -18,7 +18,8 @@
 use super::*;
 use crate::{self as pools};
 use frame_support::{
-	assert_ok, derive_impl, ord_parameter_types, parameter_types, traits::fungible::Mutate,
+	assert_ok, derive_impl, ord_parameter_types, parameter_types,
+	traits::{fungible::Mutate, VariantCountOf},
 	PalletId,
 };
 use frame_system::{EnsureSignedBy, RawOrigin};
@@ -36,12 +37,12 @@ pub type Currency = <T as Config>::Currency;
 
 // Ext builder creates a pool with id 1.
 pub fn default_bonded_account() -> AccountId {
-	Pools::create_bonded_account(1)
+	Pools::generate_bonded_account(1)
 }
 
 // Ext builder creates a pool with id 1.
 pub fn default_reward_account() -> AccountId {
-	Pools::create_reward_account(1)
+	Pools::generate_reward_account(1)
 }
 
 parameter_types! {
@@ -71,7 +72,7 @@ impl StakingMock {
 	/// Does not modify any [`SubPools`] of the pool as [`Default::default`] is passed for
 	/// `slashed_unlocking`.
 	pub fn slash_by(pool_id: PoolId, amount: Balance) {
-		let acc = Pools::create_bonded_account(pool_id);
+		let acc = Pools::generate_bonded_account(pool_id);
 		let bonded = BondedBalanceMap::get();
 		let pre_total = bonded.get(&acc).unwrap();
 		Self::set_bonded_balance(acc, pre_total - amount);
@@ -111,6 +112,10 @@ impl sp_staking::StakingInterface for StakingMock {
 			.ok_or(DispatchError::Other("NotStash"))
 	}
 
+	fn is_virtual_staker(_who: &Self::AccountId) -> bool {
+		false
+	}
+
 	fn bond_extra(who: &Self::AccountId, extra: Self::Balance) -> DispatchResult {
 		let mut x = BondedBalanceMap::get();
 		x.get_mut(who).map(|v| *v += extra);
@@ -236,49 +241,25 @@ impl sp_staking::StakingInterface for StakingMock {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type SS58Prefix = ();
-	type BaseCallFilter = frame_support::traits::Everything;
-	type RuntimeOrigin = RuntimeOrigin;
 	type Nonce = u64;
-	type RuntimeCall = RuntimeCall;
-	type Hash = sp_core::H256;
-	type Hashing = sp_runtime::traits::BlakeTwo256;
 	type AccountId = AccountId;
 	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ();
-	type DbWeight = ();
-	type BlockLength = ();
-	type BlockWeights = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<Balance>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
 parameter_types! {
 	pub static ExistentialDeposit: Balance = 5;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = frame_support::traits::ConstU32<1024>;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
 	type FreezeIdentifier = RuntimeFreezeReason;
-	type MaxFreezes = ConstU32<1>;
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
+	type RuntimeFreezeReason = RuntimeFreezeReason;
 }
 
 pub struct BalanceToU256;
@@ -314,7 +295,7 @@ impl pools::Config for Runtime {
 	type RewardCounter = RewardCounter;
 	type BalanceToU256 = BalanceToU256;
 	type U256ToBalance = U256ToBalance;
-	type Staking = StakingMock;
+	type StakeAdapter = adapter::TransferStake<Self, StakingMock>;
 	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
 	type PalletId = PoolsPalletId;
 	type MaxMetadataLen = MaxMetadataLen;
diff --git a/substrate/frame/nomination-pools/src/tests.rs b/substrate/frame/nomination-pools/src/tests.rs
index 535e7537469ecd77a8eb261c895b4d5fd264ecfb..28063c2ecaecd8caa6214553d2e16484ba5f5af8 100644
--- a/substrate/frame/nomination-pools/src/tests.rs
+++ b/substrate/frame/nomination-pools/src/tests.rs
@@ -95,8 +95,8 @@ fn test_setup_works() {
 			PoolMember::<Runtime> { pool_id: last_pool, points: 10, ..Default::default() }
 		);
 
-		let bonded_account = Pools::create_bonded_account(last_pool);
-		let reward_account = Pools::create_reward_account(last_pool);
+		let bonded_account = Pools::generate_bonded_account(last_pool);
+		let reward_account = Pools::generate_reward_account(last_pool);
 
 		// the bonded_account should be bonded by the depositor's funds.
 		assert_eq!(StakingMock::active_stake(&bonded_account).unwrap(), 10);
@@ -728,7 +728,7 @@ mod join {
 			);
 
 			// Force the pools bonded balance to 0, simulating a 100% slash
-			StakingMock::set_bonded_balance(Pools::create_bonded_account(1), 0);
+			StakingMock::set_bonded_balance(Pools::generate_bonded_account(1), 0);
 			assert_noop!(
 				Pools::join(RuntimeOrigin::signed(11), 420, 1),
 				Error::<Runtime>::OverflowRisk
@@ -755,7 +755,7 @@ mod join {
 				<<Runtime as Config>::MaxPointsToBalance as Get<u8>>::get().into();
 
 			StakingMock::set_bonded_balance(
-				Pools::create_bonded_account(123),
+				Pools::generate_bonded_account(123),
 				max_points_to_balance,
 			);
 			assert_noop!(
@@ -764,7 +764,7 @@ mod join {
 			);
 
 			StakingMock::set_bonded_balance(
-				Pools::create_bonded_account(123),
+				Pools::generate_bonded_account(123),
 				Balance::MAX / max_points_to_balance,
 			);
 			// Balance needs to be gt Balance::MAX / `MaxPointsToBalance`
@@ -773,7 +773,10 @@ mod join {
 				TokenError::FundsUnavailable,
 			);
 
-			StakingMock::set_bonded_balance(Pools::create_bonded_account(1), max_points_to_balance);
+			StakingMock::set_bonded_balance(
+				Pools::generate_bonded_account(1),
+				max_points_to_balance,
+			);
 
 			// Cannot join a pool that isn't open
 			unsafe_set_state(123, PoolState::Blocked);
@@ -804,7 +807,7 @@ mod join {
 	#[cfg_attr(not(debug_assertions), should_panic)]
 	fn join_panics_when_reward_pool_not_found() {
 		ExtBuilder::default().build_and_execute(|| {
-			StakingMock::set_bonded_balance(Pools::create_bonded_account(123), 100);
+			StakingMock::set_bonded_balance(Pools::generate_bonded_account(123), 100);
 			BondedPool::<Runtime> {
 				id: 123,
 				inner: BondedPoolInner {
@@ -1979,7 +1982,7 @@ mod claim_payout {
 			assert_eq!(member_20.last_recorded_reward_counter, 0.into());
 
 			// pre-fund the reward account of pool id 3 with some funds.
-			Currency::set_balance(&Pools::create_reward_account(3), 10);
+			Currency::set_balance(&Pools::generate_reward_account(3), 10);
 
 			// create pool 3
 			Currency::set_balance(&30, 100);
@@ -1988,7 +1991,7 @@ mod claim_payout {
 			// reward counter is still the same.
 			let (member_30, _, reward_pool_30) = Pools::get_member_with_pools(&30).unwrap();
 			assert_eq!(
-				Currency::free_balance(&Pools::create_reward_account(3)),
+				Currency::free_balance(&Pools::generate_reward_account(3)),
 				10 + Currency::minimum_balance()
 			);
 
@@ -4631,7 +4634,7 @@ mod withdraw_unbonded {
 			// pool is destroyed.
 			assert!(!Metadata::<T>::contains_key(1));
 			// ensure the pool account is reaped.
-			assert!(!frame_system::Account::<T>::contains_key(&Pools::create_bonded_account(1)));
+			assert!(!frame_system::Account::<T>::contains_key(&Pools::generate_bonded_account(1)));
 		})
 	}
 
@@ -4639,7 +4642,7 @@ mod withdraw_unbonded {
 	fn destroy_works_with_erroneous_extra_consumer() {
 		ExtBuilder::default().ed(1).build_and_execute(|| {
 			// 10 is the depositor for pool 1, with min join bond 10.
-			let pool_one = Pools::create_bonded_account(1);
+			let pool_one = Pools::generate_bonded_account(1);
 
 			// set pool to destroying.
 			unsafe_set_state(1, PoolState::Destroying);
@@ -4690,7 +4693,7 @@ mod create {
 	fn create_works() {
 		ExtBuilder::default().build_and_execute(|| {
 			// next pool id is 2.
-			let next_pool_stash = Pools::create_bonded_account(2);
+			let next_pool_stash = Pools::generate_bonded_account(2);
 			let ed = Currency::minimum_balance();
 
 			assert_eq!(TotalValueLocked::<T>::get(), 10);
@@ -5011,6 +5014,17 @@ mod set_state {
 			// surpassed. Making this pool destroyable by anyone.
 			StakingMock::slash_by(1, 10);
 
+			// in mock we are using transfer stake which implies slash is greedy. Extrinsic to
+			// apply pending slash should fail.
+			assert_noop!(
+				Pools::apply_slash(RuntimeOrigin::signed(11), 10),
+				Error::<Runtime>::NotSupported
+			);
+
+			// pending slash api should return zero as well.
+			assert_eq!(Pools::api_pool_pending_slash(1), 0);
+			assert_eq!(Pools::api_member_pending_slash(10), 0);
+
 			// When
 			assert_ok!(Pools::set_state(RuntimeOrigin::signed(11), 1, PoolState::Destroying));
 			// Then
@@ -7473,3 +7487,63 @@ mod chill {
 		})
 	}
 }
+
+// the test mock is using `TransferStake` and so `DelegateStake` is not tested here. Extrinsics
+// meant for `DelegateStake` should be gated.
+//
+// `DelegateStake` tests are in `pallet-nomination-pools-test-delegate-stake`. Since we support both
+// strategies currently, we keep these tests as it is but in future we may remove `TransferStake`
+// completely.
+mod delegate_stake {
+	use super::*;
+	#[test]
+	fn delegation_specific_calls_are_gated() {
+		ExtBuilder::default().with_check(0).build_and_execute(|| {
+			// Given
+			Currency::set_balance(&11, ExistentialDeposit::get() + 2);
+			assert!(!PoolMembers::<Runtime>::contains_key(11));
+
+			// When
+			assert_ok!(Pools::join(RuntimeOrigin::signed(11), 2, 1));
+
+			// Then
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 10, pool_id: 1 },
+					Event::Bonded { member: 10, pool_id: 1, bonded: 10, joined: true },
+					Event::Bonded { member: 11, pool_id: 1, bonded: 2, joined: true },
+				]
+			);
+
+			assert_eq!(
+				PoolMembers::<Runtime>::get(11).unwrap(),
+				PoolMember::<Runtime> { pool_id: 1, points: 2, ..Default::default() }
+			);
+
+			// ensure pool 1 cannot be migrated.
+			assert!(!Pools::api_pool_needs_delegate_migration(1));
+			assert_noop!(
+				Pools::migrate_pool_to_delegate_stake(RuntimeOrigin::signed(10), 1),
+				Error::<Runtime>::NotSupported
+			);
+
+			// members cannot be migrated either.
+			assert!(!Pools::api_member_needs_delegate_migration(10));
+			assert_noop!(
+				Pools::migrate_delegation(RuntimeOrigin::signed(10), 11),
+				Error::<Runtime>::NotSupported
+			);
+
+			// Given
+			// The bonded balance is slashed in half
+			StakingMock::slash_by(1, 6);
+
+			// since slash is greedy with `TransferStake`, `apply_slash` should not work either.
+			assert_noop!(
+				Pools::apply_slash(RuntimeOrigin::signed(10), 11),
+				Error::<Runtime>::NotSupported
+			);
+		});
+	}
+}
diff --git a/substrate/frame/nomination-pools/src/weights.rs b/substrate/frame/nomination-pools/src/weights.rs
index 57ea8dc388f6869c8f4f2be761816cced9758e19..21711a499b623fad15198b265b99476545f6b2b5 100644
--- a/substrate/frame/nomination-pools/src/weights.rs
+++ b/substrate/frame/nomination-pools/src/weights.rs
@@ -18,27 +18,25 @@
 //! Autogenerated weights for `pallet_nomination_pools`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
-//! DATE: 2024-04-09, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2024-04-25, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-anb7yjbi-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! HOSTNAME: `runner-dcu62vjg-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
 
 // Executed Command:
-// ./target/production/substrate-node
+// target/production/substrate-node
 // benchmark
 // pallet
-// --chain=dev
 // --steps=50
 // --repeat=20
-// --pallet=pallet_nomination_pools
-// --no-storage-info
-// --no-median-slopes
-// --no-min-squares
 // --extrinsic=*
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --output=./substrate/frame/nomination-pools/src/weights.rs
+// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json
+// --pallet=pallet_nomination_pools
+// --chain=dev
 // --header=./substrate/HEADER-APACHE2
+// --output=./substrate/frame/nomination-pools/src/weights.rs
 // --template=./substrate/.maintain/frame-weight-template.hbs
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
@@ -73,6 +71,10 @@ pub trait WeightInfo {
 	fn set_claim_permission() -> Weight;
 	fn claim_commission() -> Weight;
 	fn adjust_pool_deposit() -> Weight;
+	fn apply_slash() -> Weight;
+	fn apply_slash_fail() -> Weight;
+	fn pool_migrate() -> Weight;
+	fn migrate_delegation() -> Weight;
 }
 
 /// Weights for `pallet_nomination_pools` using the Substrate node and recommended hardware.
@@ -100,6 +102,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -112,11 +116,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn join() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3425`
+		//  Measured:  `3458`
 		//  Estimated: `8877`
-		// Minimum execution time: 201_783_000 picoseconds.
-		Weight::from_parts(206_014_000, 8877)
-			.saturating_add(T::DbWeight::get().reads(20_u64))
+		// Minimum execution time: 195_962_000 picoseconds.
+		Weight::from_parts(201_682_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(21_u64))
 			.saturating_add(T::DbWeight::get().writes(13_u64))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
@@ -133,6 +137,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -145,11 +151,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn bond_extra_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3435`
+		//  Measured:  `3468`
 		//  Estimated: `8877`
-		// Minimum execution time: 204_124_000 picoseconds.
-		Weight::from_parts(207_910_000, 8877)
-			.saturating_add(T::DbWeight::get().reads(17_u64))
+		// Minimum execution time: 197_466_000 picoseconds.
+		Weight::from_parts(201_356_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(18_u64))
 			.saturating_add(T::DbWeight::get().writes(13_u64))
 	}
 	/// Storage: `NominationPools::ClaimPermissions` (r:1 w:0)
@@ -168,6 +174,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -180,11 +188,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn bond_extra_other() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3500`
+		//  Measured:  `3533`
 		//  Estimated: `8877`
-		// Minimum execution time: 240_342_000 picoseconds.
-		Weight::from_parts(245_735_000, 8877)
-			.saturating_add(T::DbWeight::get().reads(18_u64))
+		// Minimum execution time: 232_623_000 picoseconds.
+		Weight::from_parts(236_970_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(19_u64))
 			.saturating_add(T::DbWeight::get().writes(14_u64))
 	}
 	/// Storage: `NominationPools::ClaimPermissions` (r:1 w:0)
@@ -203,8 +211,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `1172`
 		//  Estimated: `3719`
-		// Minimum execution time: 81_054_000 picoseconds.
-		Weight::from_parts(83_324_000, 3719)
+		// Minimum execution time: 77_992_000 picoseconds.
+		Weight::from_parts(79_927_000, 3719)
 			.saturating_add(T::DbWeight::get().reads(6_u64))
 			.saturating_add(T::DbWeight::get().writes(4_u64))
 	}
@@ -228,6 +236,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::MinNominatorBond` (r:1 w:0)
 	/// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -242,11 +252,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `NominationPools::CounterForSubPoolsStorage` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	fn unbond() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3622`
+		//  Measured:  `3655`
 		//  Estimated: `27847`
-		// Minimum execution time: 188_835_000 picoseconds.
-		Weight::from_parts(192_565_000, 27847)
-			.saturating_add(T::DbWeight::get().reads(20_u64))
+		// Minimum execution time: 182_368_000 picoseconds.
+		Weight::from_parts(185_387_000, 27847)
+			.saturating_add(T::DbWeight::get().reads(21_u64))
 			.saturating_add(T::DbWeight::get().writes(13_u64))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
@@ -257,6 +267,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::CurrentEra` (r:1 w:0)
 	/// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -268,13 +280,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `s` is `[0, 100]`.
 	fn pool_withdraw_unbonded(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1848`
+		//  Measured:  `1881`
 		//  Estimated: `4764`
-		// Minimum execution time: 73_556_000 picoseconds.
-		Weight::from_parts(76_075_881, 4764)
-			// Standard Error: 1_419
-			.saturating_add(Weight::from_parts(54_476, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(8_u64))
+		// Minimum execution time: 72_179_000 picoseconds.
+		Weight::from_parts(75_031_092, 4764)
+			// Standard Error: 1_487
+			.saturating_add(Weight::from_parts(56_741, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
@@ -289,6 +301,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -306,13 +320,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_update(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2238`
+		//  Measured:  `2271`
 		//  Estimated: `27847`
-		// Minimum execution time: 144_177_000 picoseconds.
-		Weight::from_parts(148_686_524, 27847)
-			// Standard Error: 2_475
-			.saturating_add(Weight::from_parts(77_460, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(12_u64))
+		// Minimum execution time: 137_277_000 picoseconds.
+		Weight::from_parts(143_537_793, 27847)
+			// Standard Error: 3_049
+			.saturating_add(Weight::from_parts(71_178, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(13_u64))
 			.saturating_add(T::DbWeight::get().writes(9_u64))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
@@ -329,6 +343,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::SlashingSpans` (r:1 w:0)
 	/// Proof: `Staking::SlashingSpans` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:2 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:2 w:1)
@@ -364,14 +380,14 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_kill(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2525`
+		//  Measured:  `2558`
 		//  Estimated: `27847`
-		// Minimum execution time: 255_957_000 picoseconds.
-		Weight::from_parts(264_206_788, 27847)
-			// Standard Error: 4_229
-			.saturating_add(Weight::from_parts(3_064, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(24_u64))
-			.saturating_add(T::DbWeight::get().writes(20_u64))
+		// Minimum execution time: 242_522_000 picoseconds.
+		Weight::from_parts(250_740_608, 27847)
+			// Standard Error: 4_517
+			.saturating_add(Weight::from_parts(13_231, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(25_u64))
+			.saturating_add(T::DbWeight::get().writes(21_u64))
 	}
 	/// Storage: `NominationPools::LastPoolId` (r:1 w:1)
 	/// Proof: `NominationPools::LastPoolId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
@@ -393,12 +409,14 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:2 w:2)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Bonded` (r:1 w:1)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:2 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:2 w:1)
@@ -419,11 +437,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Payee` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn create() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1284`
+		//  Measured:  `1317`
 		//  Estimated: `8538`
-		// Minimum execution time: 193_527_000 picoseconds.
-		Weight::from_parts(197_140_000, 8538)
-			.saturating_add(T::DbWeight::get().reads(24_u64))
+		// Minimum execution time: 182_740_000 picoseconds.
+		Weight::from_parts(188_820_000, 8538)
+			.saturating_add(T::DbWeight::get().reads(25_u64))
 			.saturating_add(T::DbWeight::get().writes(17_u64))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
@@ -459,12 +477,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// The range of component `n` is `[1, 16]`.
 	fn nominate(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1976`
+		//  Measured:  `2009`
 		//  Estimated: `4556 + n * (2520 ±0)`
-		// Minimum execution time: 86_054_000 picoseconds.
-		Weight::from_parts(88_743_932, 4556)
-			// Standard Error: 12_699
-			.saturating_add(Weight::from_parts(1_829_097, 0).saturating_mul(n.into()))
+		// Minimum execution time: 83_649_000 picoseconds.
+		Weight::from_parts(85_754_306, 4556)
+			// Standard Error: 12_757
+			.saturating_add(Weight::from_parts(1_616_356, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(15_u64))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
@@ -478,10 +496,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	fn set_state() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1434`
+		//  Measured:  `1467`
 		//  Estimated: `4556`
-		// Minimum execution time: 34_544_000 picoseconds.
-		Weight::from_parts(35_910_000, 4556)
+		// Minimum execution time: 34_594_000 picoseconds.
+		Weight::from_parts(36_173_000, 4556)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -496,10 +514,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3735`
-		// Minimum execution time: 14_111_000 picoseconds.
-		Weight::from_parts(15_204_218, 3735)
-			// Standard Error: 226
-			.saturating_add(Weight::from_parts(1_291, 0).saturating_mul(n.into()))
+		// Minimum execution time: 13_945_000 picoseconds.
+		Weight::from_parts(14_764_062, 3735)
+			// Standard Error: 127
+			.saturating_add(Weight::from_parts(1_406, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -519,8 +537,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 4_524_000 picoseconds.
-		Weight::from_parts(4_882_000, 0)
+		// Minimum execution time: 4_523_000 picoseconds.
+		Weight::from_parts(4_727_000, 0)
 			.saturating_add(T::DbWeight::get().writes(6_u64))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:1)
@@ -529,8 +547,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3719`
-		// Minimum execution time: 17_975_000 picoseconds.
-		Weight::from_parts(18_549_000, 3719)
+		// Minimum execution time: 17_124_000 picoseconds.
+		Weight::from_parts(17_718_000, 3719)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -558,10 +576,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	/// Proof: `VoterList::CounterForListNodes` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	fn chill() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2143`
+		//  Measured:  `2176`
 		//  Estimated: `4556`
-		// Minimum execution time: 81_574_000 picoseconds.
-		Weight::from_parts(83_519_000, 4556)
+		// Minimum execution time: 78_293_000 picoseconds.
+		Weight::from_parts(81_177_000, 4556)
 			.saturating_add(T::DbWeight::get().reads(11_u64))
 			.saturating_add(T::DbWeight::get().writes(5_u64))
 	}
@@ -577,8 +595,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `804`
 		//  Estimated: `3719`
-		// Minimum execution time: 35_015_000 picoseconds.
-		Weight::from_parts(36_159_000, 3719)
+		// Minimum execution time: 33_105_000 picoseconds.
+		Weight::from_parts(34_106_000, 3719)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -590,8 +608,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `572`
 		//  Estimated: `3719`
-		// Minimum execution time: 17_775_000 picoseconds.
-		Weight::from_parts(18_358_000, 3719)
+		// Minimum execution time: 16_710_000 picoseconds.
+		Weight::from_parts(17_269_000, 3719)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -601,8 +619,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3719`
-		// Minimum execution time: 16_997_000 picoseconds.
-		Weight::from_parts(18_041_000, 3719)
+		// Minimum execution time: 16_557_000 picoseconds.
+		Weight::from_parts(17_431_000, 3719)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -612,8 +630,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3719`
-		// Minimum execution time: 17_000_000 picoseconds.
-		Weight::from_parts(17_807_000, 3719)
+		// Minimum execution time: 16_723_000 picoseconds.
+		Weight::from_parts(17_155_000, 3719)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -625,8 +643,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `542`
 		//  Estimated: `3702`
-		// Minimum execution time: 14_803_000 picoseconds.
-		Weight::from_parts(15_401_000, 3702)
+		// Minimum execution time: 14_667_000 picoseconds.
+		Weight::from_parts(15_242_000, 3702)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -642,8 +660,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `1002`
 		//  Estimated: `3719`
-		// Minimum execution time: 69_759_000 picoseconds.
-		Weight::from_parts(71_985_000, 3719)
+		// Minimum execution time: 64_219_000 picoseconds.
+		Weight::from_parts(66_718_000, 3719)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -659,11 +677,58 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `901`
 		//  Estimated: `4764`
-		// Minimum execution time: 73_829_000 picoseconds.
-		Weight::from_parts(75_966_000, 4764)
+		// Minimum execution time: 70_284_000 picoseconds.
+		Weight::from_parts(71_375_000, 4764)
 			.saturating_add(T::DbWeight::get().reads(4_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(237), added: 2712, mode: `MaxEncodedLen`)
+	fn apply_slash() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `694`
+		//  Estimated: `3702`
+		// Minimum execution time: 13_403_000 picoseconds.
+		Weight::from_parts(14_064_000, 3702)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(237), added: 2712, mode: `MaxEncodedLen`)
+	fn apply_slash_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `732`
+		//  Estimated: `3702`
+		// Minimum execution time: 14_419_000 picoseconds.
+		Weight::from_parts(15_004_000, 3702)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	fn pool_migrate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 759_000 picoseconds.
+		Weight::from_parts(819_000, 0)
+	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(237), added: 2712, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
+	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Ledger` (r:1 w:0)
+	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0)
+	/// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(24382), added: 26857, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::MinJoinBond` (r:1 w:0)
+	/// Proof: `NominationPools::MinJoinBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	fn migrate_delegation() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1648`
+		//  Estimated: `27847`
+		// Minimum execution time: 36_192_000 picoseconds.
+		Weight::from_parts(37_038_000, 27847)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+	}
 }
 
 // For backwards compatibility and tests.
@@ -690,6 +755,8 @@ impl WeightInfo for () {
 	/// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -702,11 +769,11 @@ impl WeightInfo for () {
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn join() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3425`
+		//  Measured:  `3458`
 		//  Estimated: `8877`
-		// Minimum execution time: 201_783_000 picoseconds.
-		Weight::from_parts(206_014_000, 8877)
-			.saturating_add(RocksDbWeight::get().reads(20_u64))
+		// Minimum execution time: 195_962_000 picoseconds.
+		Weight::from_parts(201_682_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(21_u64))
 			.saturating_add(RocksDbWeight::get().writes(13_u64))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
@@ -723,6 +790,8 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -735,11 +804,11 @@ impl WeightInfo for () {
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn bond_extra_transfer() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3435`
+		//  Measured:  `3468`
 		//  Estimated: `8877`
-		// Minimum execution time: 204_124_000 picoseconds.
-		Weight::from_parts(207_910_000, 8877)
-			.saturating_add(RocksDbWeight::get().reads(17_u64))
+		// Minimum execution time: 197_466_000 picoseconds.
+		Weight::from_parts(201_356_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(18_u64))
 			.saturating_add(RocksDbWeight::get().writes(13_u64))
 	}
 	/// Storage: `NominationPools::ClaimPermissions` (r:1 w:0)
@@ -758,6 +827,8 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -770,11 +841,11 @@ impl WeightInfo for () {
 	/// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
 	fn bond_extra_other() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3500`
+		//  Measured:  `3533`
 		//  Estimated: `8877`
-		// Minimum execution time: 240_342_000 picoseconds.
-		Weight::from_parts(245_735_000, 8877)
-			.saturating_add(RocksDbWeight::get().reads(18_u64))
+		// Minimum execution time: 232_623_000 picoseconds.
+		Weight::from_parts(236_970_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(19_u64))
 			.saturating_add(RocksDbWeight::get().writes(14_u64))
 	}
 	/// Storage: `NominationPools::ClaimPermissions` (r:1 w:0)
@@ -793,8 +864,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `1172`
 		//  Estimated: `3719`
-		// Minimum execution time: 81_054_000 picoseconds.
-		Weight::from_parts(83_324_000, 3719)
+		// Minimum execution time: 77_992_000 picoseconds.
+		Weight::from_parts(79_927_000, 3719)
 			.saturating_add(RocksDbWeight::get().reads(6_u64))
 			.saturating_add(RocksDbWeight::get().writes(4_u64))
 	}
@@ -818,6 +889,8 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::MinNominatorBond` (r:1 w:0)
 	/// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -832,11 +905,11 @@ impl WeightInfo for () {
 	/// Proof: `NominationPools::CounterForSubPoolsStorage` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	fn unbond() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `3622`
+		//  Measured:  `3655`
 		//  Estimated: `27847`
-		// Minimum execution time: 188_835_000 picoseconds.
-		Weight::from_parts(192_565_000, 27847)
-			.saturating_add(RocksDbWeight::get().reads(20_u64))
+		// Minimum execution time: 182_368_000 picoseconds.
+		Weight::from_parts(185_387_000, 27847)
+			.saturating_add(RocksDbWeight::get().reads(21_u64))
 			.saturating_add(RocksDbWeight::get().writes(13_u64))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
@@ -847,6 +920,8 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::CurrentEra` (r:1 w:0)
 	/// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -858,13 +933,13 @@ impl WeightInfo for () {
 	/// The range of component `s` is `[0, 100]`.
 	fn pool_withdraw_unbonded(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1848`
+		//  Measured:  `1881`
 		//  Estimated: `4764`
-		// Minimum execution time: 73_556_000 picoseconds.
-		Weight::from_parts(76_075_881, 4764)
-			// Standard Error: 1_419
-			.saturating_add(Weight::from_parts(54_476, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(8_u64))
+		// Minimum execution time: 72_179_000 picoseconds.
+		Weight::from_parts(75_031_092, 4764)
+			// Standard Error: 1_487
+			.saturating_add(Weight::from_parts(56_741, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
@@ -879,6 +954,8 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:1 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:1 w:0)
@@ -896,13 +973,13 @@ impl WeightInfo for () {
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_update(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2238`
+		//  Measured:  `2271`
 		//  Estimated: `27847`
-		// Minimum execution time: 144_177_000 picoseconds.
-		Weight::from_parts(148_686_524, 27847)
-			// Standard Error: 2_475
-			.saturating_add(Weight::from_parts(77_460, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(12_u64))
+		// Minimum execution time: 137_277_000 picoseconds.
+		Weight::from_parts(143_537_793, 27847)
+			// Standard Error: 3_049
+			.saturating_add(Weight::from_parts(71_178, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(13_u64))
 			.saturating_add(RocksDbWeight::get().writes(9_u64))
 	}
 	/// Storage: `NominationPools::PoolMembers` (r:1 w:1)
@@ -919,6 +996,8 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::SlashingSpans` (r:1 w:0)
 	/// Proof: `Staking::SlashingSpans` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:1)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:2 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:2 w:1)
@@ -954,14 +1033,14 @@ impl WeightInfo for () {
 	/// The range of component `s` is `[0, 100]`.
 	fn withdraw_unbonded_kill(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2525`
+		//  Measured:  `2558`
 		//  Estimated: `27847`
-		// Minimum execution time: 255_957_000 picoseconds.
-		Weight::from_parts(264_206_788, 27847)
-			// Standard Error: 4_229
-			.saturating_add(Weight::from_parts(3_064, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(24_u64))
-			.saturating_add(RocksDbWeight::get().writes(20_u64))
+		// Minimum execution time: 242_522_000 picoseconds.
+		Weight::from_parts(250_740_608, 27847)
+			// Standard Error: 4_517
+			.saturating_add(Weight::from_parts(13_231, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(25_u64))
+			.saturating_add(RocksDbWeight::get().writes(21_u64))
 	}
 	/// Storage: `NominationPools::LastPoolId` (r:1 w:1)
 	/// Proof: `NominationPools::LastPoolId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
@@ -983,12 +1062,14 @@ impl WeightInfo for () {
 	/// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	/// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1)
 	/// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:2 w:2)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Bonded` (r:1 w:1)
 	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
 	/// Storage: `Staking::Ledger` (r:1 w:1)
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::VirtualStakers` (r:1 w:0)
+	/// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Locks` (r:2 w:1)
 	/// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`)
 	/// Storage: `Balances::Freezes` (r:2 w:1)
@@ -1009,11 +1090,11 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Payee` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
 	fn create() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1284`
+		//  Measured:  `1317`
 		//  Estimated: `8538`
-		// Minimum execution time: 193_527_000 picoseconds.
-		Weight::from_parts(197_140_000, 8538)
-			.saturating_add(RocksDbWeight::get().reads(24_u64))
+		// Minimum execution time: 182_740_000 picoseconds.
+		Weight::from_parts(188_820_000, 8538)
+			.saturating_add(RocksDbWeight::get().reads(25_u64))
 			.saturating_add(RocksDbWeight::get().writes(17_u64))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
@@ -1049,12 +1130,12 @@ impl WeightInfo for () {
 	/// The range of component `n` is `[1, 16]`.
 	fn nominate(n: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1976`
+		//  Measured:  `2009`
 		//  Estimated: `4556 + n * (2520 ±0)`
-		// Minimum execution time: 86_054_000 picoseconds.
-		Weight::from_parts(88_743_932, 4556)
-			// Standard Error: 12_699
-			.saturating_add(Weight::from_parts(1_829_097, 0).saturating_mul(n.into()))
+		// Minimum execution time: 83_649_000 picoseconds.
+		Weight::from_parts(85_754_306, 4556)
+			// Standard Error: 12_757
+			.saturating_add(Weight::from_parts(1_616_356, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(15_u64))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
@@ -1068,10 +1149,10 @@ impl WeightInfo for () {
 	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
 	fn set_state() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `1434`
+		//  Measured:  `1467`
 		//  Estimated: `4556`
-		// Minimum execution time: 34_544_000 picoseconds.
-		Weight::from_parts(35_910_000, 4556)
+		// Minimum execution time: 34_594_000 picoseconds.
+		Weight::from_parts(36_173_000, 4556)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1086,10 +1167,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3735`
-		// Minimum execution time: 14_111_000 picoseconds.
-		Weight::from_parts(15_204_218, 3735)
-			// Standard Error: 226
-			.saturating_add(Weight::from_parts(1_291, 0).saturating_mul(n.into()))
+		// Minimum execution time: 13_945_000 picoseconds.
+		Weight::from_parts(14_764_062, 3735)
+			// Standard Error: 127
+			.saturating_add(Weight::from_parts(1_406, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1109,8 +1190,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0`
 		//  Estimated: `0`
-		// Minimum execution time: 4_524_000 picoseconds.
-		Weight::from_parts(4_882_000, 0)
+		// Minimum execution time: 4_523_000 picoseconds.
+		Weight::from_parts(4_727_000, 0)
 			.saturating_add(RocksDbWeight::get().writes(6_u64))
 	}
 	/// Storage: `NominationPools::BondedPools` (r:1 w:1)
@@ -1119,8 +1200,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3719`
-		// Minimum execution time: 17_975_000 picoseconds.
-		Weight::from_parts(18_549_000, 3719)
+		// Minimum execution time: 17_124_000 picoseconds.
+		Weight::from_parts(17_718_000, 3719)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1148,10 +1229,10 @@ impl WeightInfo for () {
 	/// Proof: `VoterList::CounterForListNodes` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
 	fn chill() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `2143`
+		//  Measured:  `2176`
 		//  Estimated: `4556`
-		// Minimum execution time: 81_574_000 picoseconds.
-		Weight::from_parts(83_519_000, 4556)
+		// Minimum execution time: 78_293_000 picoseconds.
+		Weight::from_parts(81_177_000, 4556)
 			.saturating_add(RocksDbWeight::get().reads(11_u64))
 			.saturating_add(RocksDbWeight::get().writes(5_u64))
 	}
@@ -1167,8 +1248,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `804`
 		//  Estimated: `3719`
-		// Minimum execution time: 35_015_000 picoseconds.
-		Weight::from_parts(36_159_000, 3719)
+		// Minimum execution time: 33_105_000 picoseconds.
+		Weight::from_parts(34_106_000, 3719)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1180,8 +1261,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `572`
 		//  Estimated: `3719`
-		// Minimum execution time: 17_775_000 picoseconds.
-		Weight::from_parts(18_358_000, 3719)
+		// Minimum execution time: 16_710_000 picoseconds.
+		Weight::from_parts(17_269_000, 3719)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1191,8 +1272,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3719`
-		// Minimum execution time: 16_997_000 picoseconds.
-		Weight::from_parts(18_041_000, 3719)
+		// Minimum execution time: 16_557_000 picoseconds.
+		Weight::from_parts(17_431_000, 3719)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1202,8 +1283,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `532`
 		//  Estimated: `3719`
-		// Minimum execution time: 17_000_000 picoseconds.
-		Weight::from_parts(17_807_000, 3719)
+		// Minimum execution time: 16_723_000 picoseconds.
+		Weight::from_parts(17_155_000, 3719)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1215,8 +1296,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `542`
 		//  Estimated: `3702`
-		// Minimum execution time: 14_803_000 picoseconds.
-		Weight::from_parts(15_401_000, 3702)
+		// Minimum execution time: 14_667_000 picoseconds.
+		Weight::from_parts(15_242_000, 3702)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -1232,8 +1313,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `1002`
 		//  Estimated: `3719`
-		// Minimum execution time: 69_759_000 picoseconds.
-		Weight::from_parts(71_985_000, 3719)
+		// Minimum execution time: 64_219_000 picoseconds.
+		Weight::from_parts(66_718_000, 3719)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -1249,9 +1330,56 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `901`
 		//  Estimated: `4764`
-		// Minimum execution time: 73_829_000 picoseconds.
-		Weight::from_parts(75_966_000, 4764)
+		// Minimum execution time: 70_284_000 picoseconds.
+		Weight::from_parts(71_375_000, 4764)
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(237), added: 2712, mode: `MaxEncodedLen`)
+	fn apply_slash() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `694`
+		//  Estimated: `3702`
+		// Minimum execution time: 13_403_000 picoseconds.
+		Weight::from_parts(14_064_000, 3702)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(237), added: 2712, mode: `MaxEncodedLen`)
+	fn apply_slash_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `732`
+		//  Estimated: `3702`
+		// Minimum execution time: 14_419_000 picoseconds.
+		Weight::from_parts(15_004_000, 3702)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	fn pool_migrate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 759_000 picoseconds.
+		Weight::from_parts(819_000, 0)
+	}
+	/// Storage: `NominationPools::PoolMembers` (r:1 w:0)
+	/// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(237), added: 2712, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::BondedPools` (r:1 w:0)
+	/// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Bonded` (r:1 w:0)
+	/// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`)
+	/// Storage: `Staking::Ledger` (r:1 w:0)
+	/// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0)
+	/// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(24382), added: 26857, mode: `MaxEncodedLen`)
+	/// Storage: `NominationPools::MinJoinBond` (r:1 w:0)
+	/// Proof: `NominationPools::MinJoinBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	fn migrate_delegation() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1648`
+		//  Estimated: `27847`
+		// Minimum execution time: 36_192_000 picoseconds.
+		Weight::from_parts(37_038_000, 27847)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+	}
 }
diff --git a/substrate/frame/nomination-pools/test-delegate-stake/Cargo.toml b/substrate/frame/nomination-pools/test-delegate-stake/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ea8eb20696931f8c45edc6f67e4d5af49412eccd
--- /dev/null
+++ b/substrate/frame/nomination-pools/test-delegate-stake/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "pallet-nomination-pools-test-delegate-stake"
+version = "1.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository.workspace = true
+description = "FRAME nomination pools pallet tests with the staking pallet"
+publish = false
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dev-dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.12", features = ["derive"] }
+scale-info = { version = "2.11.1", features = ["derive"] }
+
+sp-runtime = { path = "../../../primitives/runtime" }
+sp-io = { path = "../../../primitives/io" }
+sp-std = { path = "../../../primitives/std" }
+sp-staking = { path = "../../../primitives/staking" }
+sp-core = { path = "../../../primitives/core" }
+
+frame-system = { path = "../../system" }
+frame-support = { path = "../../support" }
+frame-election-provider-support = { path = "../../election-provider-support" }
+
+pallet-timestamp = { path = "../../timestamp" }
+pallet-balances = { path = "../../balances" }
+pallet-staking = { path = "../../staking" }
+pallet-delegated-staking = { path = "../../delegated-staking" }
+pallet-bags-list = { path = "../../bags-list" }
+pallet-staking-reward-curve = { path = "../../staking/reward-curve" }
+pallet-nomination-pools = { path = ".." }
+
+sp-tracing = { path = "../../../primitives/tracing" }
+log = { workspace = true, default-features = true }
diff --git a/substrate/frame/nomination-pools/test-delegate-stake/src/lib.rs b/substrate/frame/nomination-pools/test-delegate-stake/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51f6470f90d028caefe38f1a0bdd2ce868a21643
--- /dev/null
+++ b/substrate/frame/nomination-pools/test-delegate-stake/src/lib.rs
@@ -0,0 +1,1185 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg(test)]
+
+mod mock;
+
+use frame_support::{
+	assert_noop, assert_ok,
+	traits::{fungible::InspectHold, Currency},
+};
+use mock::*;
+use pallet_nomination_pools::{
+	BondExtra, BondedPools, Error as PoolsError, Event as PoolsEvent, LastPoolId, PoolMember,
+	PoolMembers, PoolState,
+};
+use pallet_staking::{
+	CurrentEra, Error as StakingError, Event as StakingEvent, Payee, RewardDestination,
+};
+
+use pallet_delegated_staking::{Error as DelegatedStakingError, Event as DelegatedStakingEvent};
+
+use sp_runtime::{bounded_btree_map, traits::Zero};
+use sp_staking::Agent;
+
+#[test]
+fn pool_lifecycle_e2e() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::minimum_balance(), 5);
+		assert_eq!(Staking::current_era(), None);
+
+		// create the pool, we know this has id 1.
+		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
+		assert_eq!(LastPoolId::<Runtime>::get(), 1);
+
+		// have the pool nominate.
+		assert_ok!(Pools::nominate(RuntimeOrigin::signed(10), 1, vec![1, 2, 3]));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 50 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Created { depositor: 10, pool_id: 1 },
+				PoolsEvent::Bonded { member: 10, pool_id: 1, bonded: 50, joined: true },
+			]
+		);
+
+		// have two members join
+		assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10, 1));
+		assert_ok!(Pools::join(RuntimeOrigin::signed(21), 10, 1));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Bonded { member: 20, pool_id: 1, bonded: 10, joined: true },
+				PoolsEvent::Bonded { member: 21, pool_id: 1, bonded: 10, joined: true },
+			]
+		);
+
+		// pool goes into destroying
+		assert_ok!(Pools::set_state(RuntimeOrigin::signed(10), 1, PoolState::Destroying));
+
+		// depositor cannot unbond yet.
+		assert_noop!(
+			Pools::unbond(RuntimeOrigin::signed(10), 10, 50),
+			PoolsError::<Runtime>::MinimumBondNotMet,
+		);
+
+		// now the members want to unbond.
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 10));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(21), 21, 10));
+
+		assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras.len(), 1);
+		assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 0);
+		assert_eq!(PoolMembers::<Runtime>::get(21).unwrap().unbonding_eras.len(), 1);
+		assert_eq!(PoolMembers::<Runtime>::get(21).unwrap().points, 0);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::StateChanged { pool_id: 1, new_state: PoolState::Destroying },
+				PoolsEvent::Unbonded { member: 20, pool_id: 1, points: 10, balance: 10, era: 3 },
+				PoolsEvent::Unbonded { member: 21, pool_id: 1, points: 10, balance: 10, era: 3 },
+			]
+		);
+
+		// depositor cannot still unbond
+		assert_noop!(
+			Pools::unbond(RuntimeOrigin::signed(10), 10, 50),
+			PoolsError::<Runtime>::MinimumBondNotMet,
+		);
+
+		for e in 1..BondingDuration::get() {
+			CurrentEra::<Runtime>::set(Some(e));
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 0),
+				PoolsError::<Runtime>::CannotWithdrawAny
+			);
+		}
+
+		// members are now unlocked.
+		CurrentEra::<Runtime>::set(Some(BondingDuration::get()));
+
+		// depositor cannot still unbond
+		assert_noop!(
+			Pools::unbond(RuntimeOrigin::signed(10), 10, 50),
+			PoolsError::<Runtime>::MinimumBondNotMet,
+		);
+
+		// but members can now withdraw.
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 0));
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(21), 21, 0));
+		assert!(PoolMembers::<Runtime>::get(20).is_none());
+		assert!(PoolMembers::<Runtime>::get(21).is_none());
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 20 },]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Withdrawn { member: 20, pool_id: 1, points: 10, balance: 10 },
+				PoolsEvent::MemberRemoved { pool_id: 1, member: 20 },
+				PoolsEvent::Withdrawn { member: 21, pool_id: 1, points: 10, balance: 10 },
+				PoolsEvent::MemberRemoved { pool_id: 1, member: 21 },
+			]
+		);
+
+		// as soon as all members have left, the depositor can try to unbond, but since the
+		// min-nominator intention is set, they must chill first.
+		assert_noop!(
+			Pools::unbond(RuntimeOrigin::signed(10), 10, 50),
+			pallet_staking::Error::<Runtime>::InsufficientBond
+		);
+
+		assert_ok!(Pools::chill(RuntimeOrigin::signed(10), 1));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 50));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Chilled { stash: POOL1_BONDED },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 50 },
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Unbonded { member: 10, pool_id: 1, points: 50, balance: 50, era: 6 }]
+		);
+
+		// waiting another bonding duration:
+		CurrentEra::<Runtime>::set(Some(BondingDuration::get() * 2));
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 1));
+
+		// pools is fully destroyed now.
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 50 },]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Withdrawn { member: 10, pool_id: 1, points: 50, balance: 50 },
+				PoolsEvent::MemberRemoved { pool_id: 1, member: 10 },
+				PoolsEvent::Destroyed { pool_id: 1 }
+			]
+		);
+	})
+}
+
+#[test]
+fn pool_chill_e2e() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::minimum_balance(), 5);
+		assert_eq!(Staking::current_era(), None);
+
+		// create the pool, we know this has id 1.
+		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
+		assert_eq!(LastPoolId::<Runtime>::get(), 1);
+
+		// have the pool nominate.
+		assert_ok!(Pools::nominate(RuntimeOrigin::signed(10), 1, vec![1, 2, 3]));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 50 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Created { depositor: 10, pool_id: 1 },
+				PoolsEvent::Bonded { member: 10, pool_id: 1, bonded: 50, joined: true },
+			]
+		);
+
+		// have two members join
+		assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10, 1));
+		assert_ok!(Pools::join(RuntimeOrigin::signed(21), 10, 1));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Bonded { member: 20, pool_id: 1, bonded: 10, joined: true },
+				PoolsEvent::Bonded { member: 21, pool_id: 1, bonded: 10, joined: true },
+			]
+		);
+
+		// in case depositor does not have more than `MinNominatorBond` staked, we can end up in
+		// situation where a member unbonding would cause pool balance to drop below
+		// `MinNominatorBond` and hence not allowed. This can happen if the `MinNominatorBond` is
+		// increased after the pool is created.
+		assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			pallet_staking::ConfigOp::Set(55), // minimum nominator bond
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+		));
+
+		// members can unbond as long as total stake of the pool is above min nominator bond
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 10),);
+		assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras.len(), 1);
+		assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 0);
+
+		// this member cannot unbond since it will cause `pool stake < MinNominatorBond`
+		assert_noop!(
+			Pools::unbond(RuntimeOrigin::signed(21), 21, 10),
+			StakingError::<Runtime>::InsufficientBond,
+		);
+
+		// members can call `chill` permissionlessly now
+		assert_ok!(Pools::chill(RuntimeOrigin::signed(20), 1));
+
+		// now another member can unbond.
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(21), 21, 10));
+		assert_eq!(PoolMembers::<Runtime>::get(21).unwrap().unbonding_eras.len(), 1);
+		assert_eq!(PoolMembers::<Runtime>::get(21).unwrap().points, 0);
+
+		// nominator can not resume nomination until depositor have enough stake
+		assert_noop!(
+			Pools::nominate(RuntimeOrigin::signed(10), 1, vec![1, 2, 3]),
+			PoolsError::<Runtime>::MinimumBondNotMet,
+		);
+
+		// other members joining pool does not affect the depositor's ability to resume nomination
+		assert_ok!(Pools::join(RuntimeOrigin::signed(22), 10, 1));
+
+		assert_noop!(
+			Pools::nominate(RuntimeOrigin::signed(10), 1, vec![1, 2, 3]),
+			PoolsError::<Runtime>::MinimumBondNotMet,
+		);
+
+		// depositor can bond extra stake
+		assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+
+		// `chill` can not be called permissionlessly anymore
+		assert_noop!(
+			Pools::chill(RuntimeOrigin::signed(20), 1),
+			PoolsError::<Runtime>::NotNominator,
+		);
+
+		// now nominator can resume nomination
+		assert_ok!(Pools::nominate(RuntimeOrigin::signed(10), 1, vec![1, 2, 3]));
+
+		// skip to make the unbonding period end.
+		CurrentEra::<Runtime>::set(Some(BondingDuration::get()));
+
+		// members can now withdraw.
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 0));
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(21), 21, 0));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Chilled { stash: POOL1_BONDED },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 }, // other member bonding
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 }, // depositor bond extra
+				StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 20 },
+			]
+		);
+	})
+}
+
+#[test]
+fn pool_slash_e2e() {
+	new_test_ext().execute_with(|| {
+		ExistentialDeposit::set(1);
+		assert_eq!(Balances::minimum_balance(), 1);
+		assert_eq!(Staking::current_era(), None);
+
+		// create the pool, we know this has id 1.
+		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
+		assert_eq!(LastPoolId::<Runtime>::get(), 1);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Created { depositor: 10, pool_id: 1 },
+				PoolsEvent::Bonded { member: 10, pool_id: 1, bonded: 40, joined: true },
+			]
+		);
+
+		assert_eq!(
+			Payee::<Runtime>::get(POOL1_BONDED),
+			Some(RewardDestination::Account(POOL1_REWARD))
+		);
+
+		// have two members join
+		assert_ok!(Pools::join(RuntimeOrigin::signed(20), 20, 1));
+		assert_ok!(Pools::join(RuntimeOrigin::signed(21), 20, 1));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 20 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 20 }
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Bonded { member: 20, pool_id: 1, bonded: 20, joined: true },
+				PoolsEvent::Bonded { member: 21, pool_id: 1, bonded: 20, joined: true },
+			]
+		);
+
+		// now let's progress a bit.
+		CurrentEra::<Runtime>::set(Some(1));
+
+		// 20 / 80 of the total funds are unlocked, and safe from any further slash.
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 10));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 10));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 }
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Unbonded { member: 10, pool_id: 1, balance: 10, points: 10, era: 4 },
+				PoolsEvent::Unbonded { member: 20, pool_id: 1, balance: 10, points: 10, era: 4 }
+			]
+		);
+
+		CurrentEra::<Runtime>::set(Some(2));
+
+		// note: depositor cannot fully unbond at this point.
+		// these funds will still get slashed.
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 10));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 10));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(21), 21, 10));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+			]
+		);
+
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Unbonded { member: 10, pool_id: 1, balance: 10, points: 10, era: 5 },
+				PoolsEvent::Unbonded { member: 20, pool_id: 1, balance: 10, points: 10, era: 5 },
+				PoolsEvent::Unbonded { member: 21, pool_id: 1, balance: 10, points: 10, era: 5 },
+			]
+		);
+
+		// At this point, 20 are safe from slash, 30 are unlocking but vulnerable to slash, and and
+		// another 30 are active and vulnerable to slash. Let's slash half of them.
+		pallet_staking::slashing::do_slash::<Runtime>(
+			&POOL1_BONDED,
+			30,
+			&mut Default::default(),
+			&mut Default::default(),
+			2, // slash era 2, affects chunks at era 5 onwards.
+		);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 30 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				// 30 has been slashed to 15 (15 slash)
+				PoolsEvent::UnbondingPoolSlashed { pool_id: 1, era: 5, balance: 15 },
+				// 30 has been slashed to 15 (15 slash)
+				PoolsEvent::PoolSlashed { pool_id: 1, balance: 15 }
+			]
+		);
+
+		CurrentEra::<Runtime>::set(Some(3));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(21), 21, 10));
+
+		assert_eq!(
+			PoolMembers::<Runtime>::get(21).unwrap(),
+			PoolMember {
+				pool_id: 1,
+				points: 0,
+				last_recorded_reward_counter: Zero::zero(),
+				// the 10 points unlocked just now correspond to 5 points in the unbond pool.
+				unbonding_eras: bounded_btree_map!(5 => 10, 6 => 5)
+			}
+		);
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 5 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Unbonded { member: 21, pool_id: 1, balance: 5, points: 5, era: 6 }]
+		);
+
+		// now we start withdrawing. we do it all at once, at era 6 where 20 and 21 are fully free.
+		CurrentEra::<Runtime>::set(Some(6));
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 0));
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(21), 21, 0));
+
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				// 20 had unbonded 10 safely, and 10 got slashed by half.
+				PoolsEvent::Withdrawn { member: 20, pool_id: 1, balance: 10 + 5, points: 20 },
+				PoolsEvent::MemberRemoved { pool_id: 1, member: 20 },
+				// 21 unbonded all of it after the slash
+				PoolsEvent::Withdrawn { member: 21, pool_id: 1, balance: 5 + 5, points: 15 },
+				PoolsEvent::MemberRemoved { pool_id: 1, member: 21 }
+			]
+		);
+		assert_eq!(
+			staking_events_since_last_call(),
+			// a 10 (un-slashed) + 10/2 (slashed) balance from 10 has also been unlocked
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 15 + 10 + 15 }]
+		);
+
+		// now, finally, we can unbond the depositor further than their current limit.
+		assert_ok!(Pools::set_state(RuntimeOrigin::signed(10), 1, PoolState::Destroying));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 20));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::StateChanged { pool_id: 1, new_state: PoolState::Destroying },
+				PoolsEvent::Unbonded { member: 10, pool_id: 1, points: 10, balance: 10, era: 9 }
+			]
+		);
+
+		CurrentEra::<Runtime>::set(Some(9));
+		assert_eq!(
+			PoolMembers::<Runtime>::get(10).unwrap(),
+			PoolMember {
+				pool_id: 1,
+				points: 0,
+				last_recorded_reward_counter: Zero::zero(),
+				unbonding_eras: bounded_btree_map!(4 => 10, 5 => 10, 9 => 10)
+			}
+		);
+		// withdraw the depositor, they should lose 12 balance in total due to slash.
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 10 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Withdrawn { member: 10, pool_id: 1, balance: 10 + 15, points: 30 },
+				PoolsEvent::MemberRemoved { pool_id: 1, member: 10 },
+				PoolsEvent::Destroyed { pool_id: 1 }
+			]
+		);
+	});
+}
+
+#[test]
+fn pool_slash_proportional() {
+	// a typical example where 3 pool members unbond in era 99, 100, and 101, and a slash that
+	// happened in era 100 should only affect the latter two.
+	new_test_ext().execute_with(|| {
+		ExistentialDeposit::set(1);
+		BondingDuration::set(28);
+		assert_eq!(Balances::minimum_balance(), 1);
+		assert_eq!(Staking::current_era(), None);
+
+		// create the pool, we know this has id 1.
+		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
+		assert_eq!(LastPoolId::<T>::get(), 1);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
+		assert_eq!(
+			delegated_staking_events_since_last_call(),
+			vec![DelegatedStakingEvent::Delegated {
+				agent: POOL1_BONDED,
+				delegator: 10,
+				amount: 40
+			}]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Created { depositor: 10, pool_id: 1 },
+				PoolsEvent::Bonded { member: 10, pool_id: 1, bonded: 40, joined: true },
+			]
+		);
+
+		// have two members join
+		let bond = 20;
+		assert_ok!(Pools::join(RuntimeOrigin::signed(20), bond, 1));
+		assert_ok!(Pools::join(RuntimeOrigin::signed(21), bond, 1));
+		assert_ok!(Pools::join(RuntimeOrigin::signed(22), bond, 1));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond },
+			]
+		);
+		assert_eq!(
+			delegated_staking_events_since_last_call(),
+			vec![
+				DelegatedStakingEvent::Delegated {
+					agent: POOL1_BONDED,
+					delegator: 20,
+					amount: bond
+				},
+				DelegatedStakingEvent::Delegated {
+					agent: POOL1_BONDED,
+					delegator: 21,
+					amount: bond
+				},
+				DelegatedStakingEvent::Delegated {
+					agent: POOL1_BONDED,
+					delegator: 22,
+					amount: bond
+				}
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Bonded { member: 20, pool_id: 1, bonded: bond, joined: true },
+				PoolsEvent::Bonded { member: 21, pool_id: 1, bonded: bond, joined: true },
+				PoolsEvent::Bonded { member: 22, pool_id: 1, bonded: bond, joined: true },
+			]
+		);
+
+		// now let's progress a lot.
+		CurrentEra::<T>::set(Some(99));
+
+		// and unbond
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, bond));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond },]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Unbonded {
+				member: 20,
+				pool_id: 1,
+				balance: bond,
+				points: bond,
+				era: 127
+			}]
+		);
+
+		CurrentEra::<T>::set(Some(100));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(21), 21, bond));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond },]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Unbonded {
+				member: 21,
+				pool_id: 1,
+				balance: bond,
+				points: bond,
+				era: 128
+			}]
+		);
+
+		CurrentEra::<T>::set(Some(101));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(22), 22, bond));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond },]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Unbonded {
+				member: 22,
+				pool_id: 1,
+				balance: bond,
+				points: bond,
+				era: 129
+			}]
+		);
+
+		// Apply a slash that happened in era 100. This is typically applied with a delay.
+		// Of the total 100, 50 is slashed.
+		assert_eq!(BondedPools::<T>::get(1).unwrap().points, 40);
+
+		// no pending slash yet.
+		assert_eq!(Pools::api_pool_pending_slash(1), 0);
+
+		pallet_staking::slashing::do_slash::<Runtime>(
+			&POOL1_BONDED,
+			50,
+			&mut Default::default(),
+			&mut Default::default(),
+			100,
+		);
+
+		// Pools api returns correct slash amount.
+		assert_eq!(Pools::api_pool_pending_slash(1), 50);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 50 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				// This era got slashed 12.5, which rounded up to 13.
+				PoolsEvent::UnbondingPoolSlashed { pool_id: 1, era: 128, balance: 7 },
+				// This era got slashed 12 instead of 12.5 because an earlier chunk got 0.5 more
+				// slashed, and 12 is all the remaining slash
+				PoolsEvent::UnbondingPoolSlashed { pool_id: 1, era: 129, balance: 8 },
+				// Bonded pool got slashed for 25, remaining 15 in it.
+				PoolsEvent::PoolSlashed { pool_id: 1, balance: 15 }
+			]
+		);
+
+		// 21's balance in the pool is slashed.
+		assert_eq!(PoolMembers::<Runtime>::get(21).unwrap().total_balance(), 7);
+		// But their actual balance is still unslashed.
+		assert_eq!(Balances::total_balance_on_hold(&21), bond);
+		// 21 has pending slash
+		assert_eq!(Pools::api_member_pending_slash(21), bond - 7);
+		// apply slash permissionlessly.
+		assert_ok!(Pools::apply_slash(RuntimeOrigin::signed(10), 21));
+		// member balance is slashed.
+		assert_eq!(Balances::total_balance_on_hold(&21), 7);
+		// 21 has no pending slash anymore
+		assert_eq!(Pools::api_member_pending_slash(21), 0);
+
+		assert_eq!(
+			delegated_staking_events_since_last_call(),
+			vec![DelegatedStakingEvent::Slashed {
+				agent: POOL1_BONDED,
+				delegator: 21,
+				amount: bond - 7
+			}]
+		);
+
+		// 22 balance isn't slashed yet as well.
+		assert_eq!(PoolMembers::<Runtime>::get(22).unwrap().total_balance(), 8);
+		assert_eq!(Balances::total_balance_on_hold(&22), bond);
+
+		// they try to withdraw. This should slash them.
+		CurrentEra::<T>::set(Some(129));
+		let pre_balance = Balances::free_balance(&22);
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(22), 22, 0));
+		// all balance should be released.
+		assert_eq!(Balances::total_balance_on_hold(&22), 0);
+		assert_eq!(Balances::free_balance(&22), pre_balance + 8);
+
+		assert_eq!(
+			delegated_staking_events_since_last_call(),
+			vec![
+				DelegatedStakingEvent::Slashed {
+					agent: POOL1_BONDED,
+					delegator: 22,
+					amount: bond - 8
+				},
+				DelegatedStakingEvent::Released { agent: POOL1_BONDED, delegator: 22, amount: 8 },
+			]
+		);
+	});
+}
+
+#[test]
+fn pool_slash_non_proportional_only_bonded_pool() {
+	// A typical example where a pool member unbonds in era 99, and they can get away with a slash
+	// that happened in era 100, as long as the pool has enough active bond to cover the slash. If
+	// everything else in the slashing/staking system works, this should always be the case.
+	// Nonetheless, `ledger.slash` has been written such that it will slash greedily from any chunk
+	// if it runs out of chunks that it thinks should be affected by the slash.
+	new_test_ext().execute_with(|| {
+		ExistentialDeposit::set(1);
+		BondingDuration::set(28);
+		assert_eq!(Balances::minimum_balance(), 1);
+		assert_eq!(Staking::current_era(), None);
+
+		// create the pool, we know this has id 1.
+		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Created { depositor: 10, pool_id: 1 },
+				PoolsEvent::Bonded { member: 10, pool_id: 1, bonded: 40, joined: true },
+			]
+		);
+
+		// have two members join
+		let bond = 20;
+		assert_ok!(Pools::join(RuntimeOrigin::signed(20), bond, 1));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Bonded { member: 20, pool_id: 1, bonded: bond, joined: true }]
+		);
+
+		// progress and unbond.
+		CurrentEra::<T>::set(Some(99));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, bond));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Unbonded {
+				member: 20,
+				pool_id: 1,
+				balance: bond,
+				points: bond,
+				era: 127
+			}]
+		);
+
+		// slash for 30. This will be deducted only from the bonded pool.
+		CurrentEra::<T>::set(Some(100));
+		assert_eq!(BondedPools::<T>::get(1).unwrap().points, 40);
+		pallet_staking::slashing::do_slash::<Runtime>(
+			&POOL1_BONDED,
+			30,
+			&mut Default::default(),
+			&mut Default::default(),
+			100,
+		);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 30 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::PoolSlashed { pool_id: 1, balance: 10 }]
+		);
+	});
+}
+
+#[test]
+fn pool_slash_non_proportional_bonded_pool_and_chunks() {
+	// An uncommon example where even though some funds are unlocked such that they should not be
+	// affected by a slash, we still slash out of them. This should not happen at all. If a
+	// nomination has unbonded, from the next era onwards, their exposure will drop, so if an era
+	// happens in that era, then their share of that slash should naturally be less, such that only
+	// their active ledger stake is enough to compensate it.
+	new_test_ext().execute_with(|| {
+		ExistentialDeposit::set(1);
+		BondingDuration::set(28);
+		assert_eq!(Balances::minimum_balance(), 1);
+		assert_eq!(Staking::current_era(), None);
+
+		// create the pool, we know this has id 1.
+		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 40, 10, 10, 10));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 40 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Created { depositor: 10, pool_id: 1 },
+				PoolsEvent::Bonded { member: 10, pool_id: 1, bonded: 40, joined: true },
+			]
+		);
+
+		// have two members join
+		let bond = 20;
+		assert_ok!(Pools::join(RuntimeOrigin::signed(20), bond, 1));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: bond }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Bonded { member: 20, pool_id: 1, bonded: bond, joined: true }]
+		);
+
+		// progress and unbond.
+		CurrentEra::<T>::set(Some(99));
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, bond));
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Unbonded { stash: POOL1_BONDED, amount: bond }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![PoolsEvent::Unbonded {
+				member: 20,
+				pool_id: 1,
+				balance: bond,
+				points: bond,
+				era: 127
+			}]
+		);
+
+		// slash 50. This will be deducted only from the bonded pool and one of the unbonding pools.
+		CurrentEra::<T>::set(Some(100));
+		assert_eq!(BondedPools::<T>::get(1).unwrap().points, 40);
+		pallet_staking::slashing::do_slash::<Runtime>(
+			&POOL1_BONDED,
+			50,
+			&mut Default::default(),
+			&mut Default::default(),
+			100,
+		);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Slashed { staker: POOL1_BONDED, amount: 50 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				// out of 20, 10 was taken.
+				PoolsEvent::UnbondingPoolSlashed { pool_id: 1, era: 127, balance: 10 },
+				// out of 40, all was taken.
+				PoolsEvent::PoolSlashed { pool_id: 1, balance: 0 }
+			]
+		);
+	});
+}
+#[test]
+fn pool_migration_e2e() {
+	new_test_ext().execute_with(|| {
+		LegacyAdapter::set(true);
+		assert_eq!(Balances::minimum_balance(), 5);
+		assert_eq!(Staking::current_era(), None);
+
+		// create the pool with TransferStake strategy.
+		assert_ok!(Pools::create(RuntimeOrigin::signed(10), 50, 10, 10, 10));
+		assert_eq!(LastPoolId::<Runtime>::get(), 1);
+
+		// have the pool nominate.
+		assert_ok!(Pools::nominate(RuntimeOrigin::signed(10), 1, vec![1, 2, 3]));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![StakingEvent::Bonded { stash: POOL1_BONDED, amount: 50 }]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Created { depositor: 10, pool_id: 1 },
+				PoolsEvent::Bonded { member: 10, pool_id: 1, bonded: 50, joined: true },
+			]
+		);
+
+		// have three members join
+		let pre_20 = Balances::free_balance(20);
+		assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10, 1));
+		let pre_21 = Balances::free_balance(21);
+		assert_ok!(Pools::join(RuntimeOrigin::signed(21), 10, 1));
+		let pre_22 = Balances::free_balance(22);
+		assert_ok!(Pools::join(RuntimeOrigin::signed(22), 10, 1));
+
+		// verify members balance is moved to pool.
+		assert_eq!(Balances::free_balance(20), pre_20 - 10);
+		assert_eq!(Balances::free_balance(21), pre_21 - 10);
+		assert_eq!(Balances::free_balance(22), pre_22 - 10);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Bonded { stash: POOL1_BONDED, amount: 10 },
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Bonded { member: 20, pool_id: 1, bonded: 10, joined: true },
+				PoolsEvent::Bonded { member: 21, pool_id: 1, bonded: 10, joined: true },
+				PoolsEvent::Bonded { member: 22, pool_id: 1, bonded: 10, joined: true },
+			]
+		);
+
+		CurrentEra::<Runtime>::set(Some(2));
+		// 20 is partially unbonding
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+
+		CurrentEra::<Runtime>::set(Some(3));
+		// 21 is fully unbonding
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(21), 21, 10));
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 5 },
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 10 },
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Unbonded { member: 20, pool_id: 1, balance: 5, points: 5, era: 5 },
+				PoolsEvent::Unbonded { member: 21, pool_id: 1, balance: 10, points: 10, era: 6 },
+			]
+		);
+
+		// with `TransferStake`, we can't migrate.
+		assert!(!Pools::api_pool_needs_delegate_migration(1));
+		assert_noop!(
+			Pools::migrate_pool_to_delegate_stake(RuntimeOrigin::signed(10), 1),
+			PoolsError::<Runtime>::NotSupported
+		);
+
+		// we reset the adapter to `DelegateStake`.
+		LegacyAdapter::set(false);
+
+		// cannot migrate the member delegation unless pool is migrated first.
+		assert!(!Pools::api_member_needs_delegate_migration(20));
+		assert_noop!(
+			Pools::migrate_delegation(RuntimeOrigin::signed(10), 20),
+			PoolsError::<Runtime>::NotMigrated
+		);
+
+		// migrate the pool.
+		assert!(Pools::api_pool_needs_delegate_migration(1));
+		assert_ok!(Pools::migrate_pool_to_delegate_stake(RuntimeOrigin::signed(10), 1));
+
+		// migrate again does not work.
+		assert!(!Pools::api_pool_needs_delegate_migration(1));
+		assert_noop!(
+			Pools::migrate_pool_to_delegate_stake(RuntimeOrigin::signed(10), 1),
+			PoolsError::<Runtime>::AlreadyMigrated
+		);
+
+		// unclaimed delegations to the pool are stored in this account.
+		let proxy_delegator_1 =
+			DelegatedStaking::generate_proxy_delegator(Agent::from(POOL1_BONDED)).get();
+
+		assert_eq!(
+			delegated_staking_events_since_last_call(),
+			vec![DelegatedStakingEvent::Delegated {
+				agent: POOL1_BONDED,
+				delegator: proxy_delegator_1,
+				amount: 50 + 10 * 3
+			}]
+		);
+
+		// move to era 5 when 20 can withdraw unbonded funds.
+		CurrentEra::<Runtime>::set(Some(5));
+		// Unbond works even without claiming delegation. Lets unbond 22.
+		assert_ok!(Pools::unbond(RuntimeOrigin::signed(22), 22, 5));
+
+		// withdraw fails for 20 before claiming delegation
+		assert_noop!(
+			Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 10),
+			DelegatedStakingError::<Runtime>::NotDelegator
+		);
+
+		let pre_claim_balance_20 = Balances::total_balance(&20);
+		assert_eq!(Balances::total_balance_on_hold(&20), 0);
+
+		// migrate delegation for 20. This is permissionless and can be called by anyone.
+		assert!(Pools::api_member_needs_delegate_migration(20));
+		assert_ok!(Pools::migrate_delegation(RuntimeOrigin::signed(10), 20));
+
+		// tokens moved to 20's account and held there.
+		assert_eq!(Balances::total_balance(&20), pre_claim_balance_20 + 10);
+		assert_eq!(Balances::total_balance_on_hold(&20), 10);
+
+		// withdraw works now
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 5));
+
+		// balance unlocked in 20's account
+		assert_eq!(Balances::total_balance_on_hold(&20), 5);
+		assert_eq!(Balances::total_balance(&20), pre_claim_balance_20 + 10);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Unbonded { stash: POOL1_BONDED, amount: 5 },
+				StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 5 }
+			]
+		);
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Unbonded { member: 22, pool_id: 1, balance: 5, points: 5, era: 8 },
+				PoolsEvent::Withdrawn { member: 20, pool_id: 1, balance: 5, points: 5 },
+			]
+		);
+		assert_eq!(
+			delegated_staking_events_since_last_call(),
+			vec![
+				DelegatedStakingEvent::MigratedDelegation {
+					agent: POOL1_BONDED,
+					delegator: 20,
+					amount: 10
+				},
+				DelegatedStakingEvent::Released { agent: POOL1_BONDED, delegator: 20, amount: 5 }
+			]
+		);
+
+		// MIGRATE 21
+		let pre_migrate_balance_21 = Balances::total_balance(&21);
+		assert_eq!(Balances::total_balance_on_hold(&21), 0);
+
+		// migrate delegation for 21.
+		assert!(Pools::api_member_needs_delegate_migration(21));
+		assert_ok!(Pools::migrate_delegation(RuntimeOrigin::signed(10), 21));
+
+		// tokens moved to 21's account and held there.
+		assert_eq!(Balances::total_balance(&21), pre_migrate_balance_21 + 10);
+		assert_eq!(Balances::total_balance_on_hold(&21), 10);
+
+		// withdraw fails since 21 only unbonds at era 6.
+		assert_noop!(
+			Pools::withdraw_unbonded(RuntimeOrigin::signed(21), 21, 10),
+			PoolsError::<Runtime>::CannotWithdrawAny
+		);
+
+		// go to era when 21 can unbond
+		CurrentEra::<Runtime>::set(Some(6));
+
+		// withdraw works now
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(21), 21, 10));
+
+		// all balance unlocked in 21's account
+		assert_eq!(Balances::total_balance_on_hold(&21), 0);
+		assert_eq!(Balances::total_balance(&21), pre_migrate_balance_21 + 10);
+
+		// MIGRATE 22
+		let pre_migrate_balance_22 = Balances::total_balance(&22);
+		assert_eq!(Balances::total_balance_on_hold(&22), 0);
+
+		// migrate delegation for 22.
+		assert!(Pools::api_member_needs_delegate_migration(22));
+		assert_ok!(Pools::migrate_delegation(RuntimeOrigin::signed(10), 22));
+
+		// cannot migrate a pool member again.
+		assert!(!Pools::api_member_needs_delegate_migration(22));
+		assert_noop!(
+			Pools::migrate_delegation(RuntimeOrigin::signed(10), 22),
+			PoolsError::<Runtime>::AlreadyMigrated
+		);
+
+		// tokens moved to 22's account and held there.
+		assert_eq!(Balances::total_balance(&22), pre_migrate_balance_22 + 10);
+		assert_eq!(Balances::total_balance_on_hold(&22), 10);
+
+		// withdraw fails since 22 only unbonds at era 8.
+		assert_noop!(
+			Pools::withdraw_unbonded(RuntimeOrigin::signed(22), 22, 5),
+			PoolsError::<Runtime>::CannotWithdrawAny
+		);
+
+		// go to era when 22 can unbond
+		CurrentEra::<Runtime>::set(Some(10));
+
+		// withdraw works now
+		assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(22), 22, 10));
+
+		// balance of 5 unlocked in 22's account
+		assert_eq!(Balances::total_balance_on_hold(&22), 10 - 5);
+
+		// assert events for 21 and 22.
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 10 },
+				StakingEvent::Withdrawn { stash: POOL1_BONDED, amount: 5 }
+			]
+		);
+
+		assert_eq!(
+			pool_events_since_last_call(),
+			vec![
+				PoolsEvent::Withdrawn { member: 21, pool_id: 1, balance: 10, points: 10 },
+				// 21 was fully unbonding and removed from pool.
+				PoolsEvent::MemberRemoved { member: 21, pool_id: 1 },
+				PoolsEvent::Withdrawn { member: 22, pool_id: 1, balance: 5, points: 5 },
+			]
+		);
+		assert_eq!(
+			delegated_staking_events_since_last_call(),
+			vec![
+				DelegatedStakingEvent::MigratedDelegation {
+					agent: POOL1_BONDED,
+					delegator: 21,
+					amount: 10
+				},
+				DelegatedStakingEvent::Released { agent: POOL1_BONDED, delegator: 21, amount: 10 },
+				DelegatedStakingEvent::MigratedDelegation {
+					agent: POOL1_BONDED,
+					delegator: 22,
+					amount: 10
+				},
+				DelegatedStakingEvent::Released { agent: POOL1_BONDED, delegator: 22, amount: 5 }
+			]
+		);
+	})
+}
diff --git a/substrate/frame/nomination-pools/test-delegate-stake/src/mock.rs b/substrate/frame/nomination-pools/test-delegate-stake/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ed47932a323bf14335d5bb74fec03cfa749625e3
--- /dev/null
+++ b/substrate/frame/nomination-pools/test-delegate-stake/src/mock.rs
@@ -0,0 +1,370 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use frame_election_provider_support::VoteWeight;
+use frame_support::{
+	assert_ok, derive_impl,
+	pallet_prelude::*,
+	parameter_types,
+	traits::{ConstU64, ConstU8, VariantCountOf},
+	PalletId,
+};
+use frame_system::EnsureRoot;
+use pallet_nomination_pools::{
+	adapter::{Member, Pool, StakeStrategyType},
+	BondType,
+};
+use sp_runtime::{
+	traits::{Convert, IdentityLookup},
+	BuildStorage, FixedU128, Perbill,
+};
+
+type AccountId = u128;
+type Nonce = u32;
+type BlockNumber = u64;
+type Balance = u128;
+
+pub(crate) type T = Runtime;
+
+pub(crate) const POOL1_BONDED: AccountId = 20318131474730217858575332831085u128;
+pub(crate) const POOL1_REWARD: AccountId = 20397359637244482196168876781421u128;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Runtime {
+	type Nonce = Nonce;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type AccountData = pallet_balances::AccountData<Balance>;
+}
+
+impl pallet_timestamp::Config for Runtime {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub static ExistentialDeposit: Balance = 5;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Runtime {
+	type Balance = Balance;
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+	type FreezeIdentifier = RuntimeFreezeReason;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+}
+
+pallet_staking_reward_curve::build! {
+	const I_NPOS: sp_runtime::curve::PiecewiseLinear<'static> = curve!(
+		min_inflation: 0_025_000,
+		max_inflation: 0_100_000,
+		ideal_stake: 0_500_000,
+		falloff: 0_050_000,
+		max_piece_count: 40,
+		test_precision: 0_005_000,
+	);
+}
+
+parameter_types! {
+	pub const RewardCurve: &'static sp_runtime::curve::PiecewiseLinear<'static> = &I_NPOS;
+	pub static BondingDuration: u32 = 3;
+}
+
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
+impl pallet_staking::Config for Runtime {
+	type Currency = Balances;
+	type UnixTime = pallet_timestamp::Pallet<Self>;
+	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type BondingDuration = BondingDuration;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
+	type ElectionProvider =
+		frame_election_provider_support::NoElection<(AccountId, BlockNumber, Staking, ())>;
+	type GenesisElectionProvider = Self::ElectionProvider;
+	type VoterList = VoterList;
+	type TargetList = pallet_staking::UseValidatorsMap<Self>;
+	type EventListeners = (Pools, DelegatedStaking);
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+}
+
+parameter_types! {
+	pub static BagThresholds: &'static [VoteWeight] = &[10, 20, 30, 40, 50, 60, 1_000, 2_000, 10_000];
+}
+
+type VoterBagsListInstance = pallet_bags_list::Instance1;
+impl pallet_bags_list::Config<VoterBagsListInstance> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type BagThresholds = BagThresholds;
+	type ScoreProvider = Staking;
+	type Score = VoteWeight;
+}
+
+pub struct BalanceToU256;
+impl Convert<Balance, sp_core::U256> for BalanceToU256 {
+	fn convert(n: Balance) -> sp_core::U256 {
+		n.into()
+	}
+}
+
+pub struct U256ToBalance;
+impl Convert<sp_core::U256, Balance> for U256ToBalance {
+	fn convert(n: sp_core::U256) -> Balance {
+		n.try_into().unwrap()
+	}
+}
+
+parameter_types! {
+	pub const PostUnbondingPoolsWindow: u32 = 10;
+	pub const PoolsPalletId: PalletId = PalletId(*b"py/nopls");
+	pub static LegacyAdapter: bool = false;
+}
+
+pub struct MockAdapter;
+type DelegateStake =
+	pallet_nomination_pools::adapter::DelegateStake<Runtime, Staking, DelegatedStaking>;
+type TransferStake = pallet_nomination_pools::adapter::TransferStake<Runtime, Staking>;
+impl pallet_nomination_pools::adapter::StakeStrategy for MockAdapter {
+	type Balance = Balance;
+	type AccountId = AccountId;
+	type CoreStaking = Staking;
+
+	fn strategy_type() -> StakeStrategyType {
+		if LegacyAdapter::get() {
+			return TransferStake::strategy_type()
+		}
+		DelegateStake::strategy_type()
+	}
+	fn transferable_balance(pool_account: Pool<Self::AccountId>) -> Self::Balance {
+		if LegacyAdapter::get() {
+			return TransferStake::transferable_balance(pool_account)
+		}
+		DelegateStake::transferable_balance(pool_account)
+	}
+
+	fn total_balance(pool_account: Pool<Self::AccountId>) -> Option<Self::Balance> {
+		if LegacyAdapter::get() {
+			return TransferStake::total_balance(pool_account)
+		}
+		DelegateStake::total_balance(pool_account)
+	}
+
+	fn member_delegation_balance(member_account: Member<Self::AccountId>) -> Option<Self::Balance> {
+		if LegacyAdapter::get() {
+			return TransferStake::member_delegation_balance(member_account)
+		}
+		DelegateStake::member_delegation_balance(member_account)
+	}
+
+	fn pledge_bond(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		reward_account: &Self::AccountId,
+		amount: Self::Balance,
+		bond_type: BondType,
+	) -> DispatchResult {
+		if LegacyAdapter::get() {
+			return TransferStake::pledge_bond(who, pool_account, reward_account, amount, bond_type)
+		}
+		DelegateStake::pledge_bond(who, pool_account, reward_account, amount, bond_type)
+	}
+
+	fn member_withdraw(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		amount: Self::Balance,
+		num_slashing_spans: u32,
+	) -> DispatchResult {
+		if LegacyAdapter::get() {
+			return TransferStake::member_withdraw(who, pool_account, amount, num_slashing_spans)
+		}
+		DelegateStake::member_withdraw(who, pool_account, amount, num_slashing_spans)
+	}
+
+	fn pending_slash(pool_account: Pool<Self::AccountId>) -> Self::Balance {
+		if LegacyAdapter::get() {
+			return TransferStake::pending_slash(pool_account)
+		}
+		DelegateStake::pending_slash(pool_account)
+	}
+
+	fn member_slash(
+		who: Member<Self::AccountId>,
+		pool_account: Pool<Self::AccountId>,
+		amount: Self::Balance,
+		maybe_reporter: Option<Self::AccountId>,
+	) -> DispatchResult {
+		if LegacyAdapter::get() {
+			return TransferStake::member_slash(who, pool_account, amount, maybe_reporter)
+		}
+		DelegateStake::member_slash(who, pool_account, amount, maybe_reporter)
+	}
+
+	fn migrate_nominator_to_agent(
+		agent: Pool<Self::AccountId>,
+		reward_account: &Self::AccountId,
+	) -> DispatchResult {
+		if LegacyAdapter::get() {
+			return TransferStake::migrate_nominator_to_agent(agent, reward_account)
+		}
+		DelegateStake::migrate_nominator_to_agent(agent, reward_account)
+	}
+
+	fn migrate_delegation(
+		agent: Pool<Self::AccountId>,
+		delegator: Member<Self::AccountId>,
+		value: Self::Balance,
+	) -> DispatchResult {
+		if LegacyAdapter::get() {
+			return TransferStake::migrate_delegation(agent, delegator, value)
+		}
+		DelegateStake::migrate_delegation(agent, delegator, value)
+	}
+}
+impl pallet_nomination_pools::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RewardCounter = FixedU128;
+	type BalanceToU256 = BalanceToU256;
+	type U256ToBalance = U256ToBalance;
+	type StakeAdapter = MockAdapter;
+	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
+	type MaxMetadataLen = ConstU32<256>;
+	type MaxUnbonding = ConstU32<8>;
+	type MaxPointsToBalance = ConstU8<10>;
+	type PalletId = PoolsPalletId;
+	type AdminOrigin = EnsureRoot<AccountId>;
+}
+
+parameter_types! {
+	pub const DelegatedStakingPalletId: PalletId = PalletId(*b"py/dlstk");
+	pub const SlashRewardFraction: Perbill = Perbill::from_percent(1);
+}
+impl pallet_delegated_staking::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = DelegatedStakingPalletId;
+	type Currency = Balances;
+	type OnSlash = ();
+	type SlashRewardFraction = SlashRewardFraction;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type CoreStaking = Staking;
+}
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub enum Runtime {
+		System: frame_system,
+		Timestamp: pallet_timestamp,
+		Balances: pallet_balances,
+		Staking: pallet_staking,
+		VoterList: pallet_bags_list::<Instance1>,
+		Pools: pallet_nomination_pools,
+		DelegatedStaking: pallet_delegated_staking,
+	}
+);
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	sp_tracing::try_init_simple();
+	let mut storage = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+	let _ = pallet_nomination_pools::GenesisConfig::<Runtime> {
+		min_join_bond: 2,
+		min_create_bond: 2,
+		max_pools: Some(3),
+		max_members_per_pool: Some(5),
+		max_members: Some(3 * 5),
+		global_max_commission: Some(Perbill::from_percent(90)),
+	}
+	.assimilate_storage(&mut storage)
+	.unwrap();
+
+	let _ = pallet_balances::GenesisConfig::<Runtime> {
+		balances: vec![(10, 100), (20, 100), (21, 100), (22, 100)],
+	}
+	.assimilate_storage(&mut storage)
+	.unwrap();
+
+	let mut ext = sp_io::TestExternalities::from(storage);
+
+	ext.execute_with(|| {
+		// for events to be deposited.
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+
+		// set some limit for nominations.
+		assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			pallet_staking::ConfigOp::Set(10), // minimum nominator bond
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+			pallet_staking::ConfigOp::Noop,
+		));
+	});
+
+	ext
+}
+
+parameter_types! {
+	static ObservedEventsPools: usize = 0;
+	static ObservedEventsStaking: usize = 0;
+	static ObservedEventsBalances: usize = 0;
+	static ObservedEventsDelegatedStaking: usize = 0;
+}
+
+pub(crate) fn pool_events_since_last_call() -> Vec<pallet_nomination_pools::Event<Runtime>> {
+	let events = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::Pools(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>();
+	let already_seen = ObservedEventsPools::get();
+	ObservedEventsPools::set(events.len());
+	events.into_iter().skip(already_seen).collect()
+}
+
+pub(crate) fn staking_events_since_last_call() -> Vec<pallet_staking::Event<Runtime>> {
+	let events = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::Staking(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>();
+	let already_seen = ObservedEventsStaking::get();
+	ObservedEventsStaking::set(events.len());
+	events.into_iter().skip(already_seen).collect()
+}
+
+pub(crate) fn delegated_staking_events_since_last_call(
+) -> Vec<pallet_delegated_staking::Event<Runtime>> {
+	let events = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(
+			|e| if let RuntimeEvent::DelegatedStaking(inner) = e { Some(inner) } else { None },
+		)
+		.collect::<Vec<_>>();
+	let already_seen = ObservedEventsDelegatedStaking::get();
+	ObservedEventsDelegatedStaking::set(events.len());
+	events.into_iter().skip(already_seen).collect()
+}
diff --git a/substrate/frame/nomination-pools/test-staking/Cargo.toml b/substrate/frame/nomination-pools/test-transfer-stake/Cargo.toml
similarity index 96%
rename from substrate/frame/nomination-pools/test-staking/Cargo.toml
rename to substrate/frame/nomination-pools/test-transfer-stake/Cargo.toml
index ada52db6de53180093eafc47a140a4b229ced685..5f9bc9af3a214eb3d82da11786c93bf462565a26 100644
--- a/substrate/frame/nomination-pools/test-staking/Cargo.toml
+++ b/substrate/frame/nomination-pools/test-transfer-stake/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "pallet-nomination-pools-test-staking"
+name = "pallet-nomination-pools-test-transfer-stake"
 version = "1.0.0"
 authors.workspace = true
 edition.workspace = true
diff --git a/substrate/frame/nomination-pools/test-staking/src/lib.rs b/substrate/frame/nomination-pools/test-transfer-stake/src/lib.rs
similarity index 100%
rename from substrate/frame/nomination-pools/test-staking/src/lib.rs
rename to substrate/frame/nomination-pools/test-transfer-stake/src/lib.rs
diff --git a/substrate/frame/nomination-pools/test-staking/src/mock.rs b/substrate/frame/nomination-pools/test-transfer-stake/src/mock.rs
similarity index 81%
rename from substrate/frame/nomination-pools/test-staking/src/mock.rs
rename to substrate/frame/nomination-pools/test-transfer-stake/src/mock.rs
index 93a05ddfae990108c7277c2448ff1470ae11d2ae..d913c5fe6948cb5a0fae1d5ccf8e533e5ddb8cc7 100644
--- a/substrate/frame/nomination-pools/test-staking/src/mock.rs
+++ b/substrate/frame/nomination-pools/test-transfer-stake/src/mock.rs
@@ -20,7 +20,7 @@ use frame_support::{
 	assert_ok, derive_impl,
 	pallet_prelude::*,
 	parameter_types,
-	traits::{ConstU64, ConstU8},
+	traits::{ConstU64, ConstU8, VariantCountOf},
 	PalletId,
 };
 use sp_runtime::{
@@ -29,7 +29,6 @@ use sp_runtime::{
 };
 
 type AccountId = u128;
-type Nonce = u32;
 type BlockNumber = u64;
 type Balance = u128;
 
@@ -40,29 +39,10 @@ pub(crate) const POOL1_REWARD: AccountId = 20397359637244482196168876781421u128;
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type Nonce = Nonce;
-	type RuntimeCall = RuntimeCall;
-	type Hash = sp_core::H256;
-	type Hashing = sp_runtime::traits::BlakeTwo256;
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<Balance>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
 impl pallet_timestamp::Config for Runtime {
@@ -76,20 +56,14 @@ parameter_types! {
 	pub static ExistentialDeposit: Balance = 5;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
 	type FreezeIdentifier = RuntimeFreezeReason;
-	type MaxFreezes = ConstU32<1>;
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
+	type RuntimeFreezeReason = RuntimeFreezeReason;
 }
 
 pallet_staking_reward_curve::build! {
@@ -108,36 +82,20 @@ parameter_types! {
 	pub static BondingDuration: u32 = 3;
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Runtime {
 	type Currency = Balances;
-	type CurrencyBalance = Balance;
 	type UnixTime = pallet_timestamp::Pallet<Self>;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
-	type Reward = ();
-	type SessionsPerEra = ();
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BondingDuration = BondingDuration;
-	type SessionInterface = ();
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
-	type NextNewSession = ();
-	type MaxExposurePageSize = ConstU32<64>;
 	type ElectionProvider =
 		frame_election_provider_support::NoElection<(AccountId, BlockNumber, Staking, ())>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = VoterList;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type HistoryDepth = ConstU32<84>;
 	type EventListeners = Pools;
 	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
 
 parameter_types! {
@@ -180,7 +138,7 @@ impl pallet_nomination_pools::Config for Runtime {
 	type RewardCounter = FixedU128;
 	type BalanceToU256 = BalanceToU256;
 	type U256ToBalance = U256ToBalance;
-	type Staking = Staking;
+	type StakeAdapter = pallet_nomination_pools::adapter::TransferStake<Self, Staking>;
 	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
 	type MaxMetadataLen = ConstU32<256>;
 	type MaxUnbonding = ConstU32<8>;
diff --git a/substrate/frame/offences/benchmarking/src/mock.rs b/substrate/frame/offences/benchmarking/src/mock.rs
index eeaa1364504abbb3aae3c2953d99f21952198b72..e243ad0e718eb85fadca375dbf9e883635653972 100644
--- a/substrate/frame/offences/benchmarking/src/mock.rs
+++ b/substrate/frame/offences/benchmarking/src/mock.rs
@@ -29,55 +29,22 @@ use frame_system as system;
 use pallet_session::historical as pallet_session_historical;
 use sp_runtime::{
 	testing::{Header, UintAuthorityId},
-	traits::IdentityLookup,
 	BuildStorage, Perbill,
 };
 
 type AccountId = u64;
-type Nonce = u32;
 type Balance = u64;
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type Nonce = Nonce;
-	type RuntimeCall = RuntimeCall;
-	type Hash = sp_core::H256;
-	type Hashing = ::sp_runtime::traits::BlakeTwo256;
-	type AccountId = AccountId;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ConstU32<128>;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ConstU64<10>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_timestamp::Config for Test {
@@ -157,35 +124,19 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type Bounds = ElectionsBounds;
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Test {
 	type Currency = Balances;
 	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
 	type UnixTime = pallet_timestamp::Pallet<Self>;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
-	type Reward = ();
-	type SessionsPerEra = ();
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
-	type BondingDuration = ();
 	type SessionInterface = Self;
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
-	type MaxExposurePageSize = ConstU32<64>;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type HistoryDepth = ConstU32<84>;
-	type EventListeners = ();
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
 
 impl pallet_im_online::Config for Test {
diff --git a/substrate/frame/offences/src/mock.rs b/substrate/frame/offences/src/mock.rs
index 9a3120e41eaa0ae04ef4d211868c53782e3a4cbf..6796837637ae74330ab924d0eec1190379fc5ccc 100644
--- a/substrate/frame/offences/src/mock.rs
+++ b/substrate/frame/offences/src/mock.rs
@@ -24,14 +24,10 @@ use crate::Config;
 use codec::Encode;
 use frame_support::{
 	derive_impl, parameter_types,
-	traits::{ConstU32, ConstU64},
+	traits::ConstU32,
 	weights::{constants::RocksDbWeight, Weight},
 };
-use sp_core::H256;
-use sp_runtime::{
-	traits::{BlakeTwo256, IdentityLookup},
-	BuildStorage, Perbill,
-};
+use sp_runtime::{traits::IdentityLookup, BuildStorage, Perbill};
 use sp_staking::{
 	offence::{self, Kind, OffenceDetails},
 	SessionIndex,
@@ -75,28 +71,11 @@ frame_support::construct_runtime!(
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = RocksDbWeight;
-	type RuntimeOrigin = RuntimeOrigin;
 	type Nonce = u64;
-	type RuntimeCall = RuntimeCall;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = ();
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
+	type DbWeight = RocksDbWeight;
 	type MaxConsumers = ConstU32<16>;
 }
 
diff --git a/substrate/frame/paged-list/src/mock.rs b/substrate/frame/paged-list/src/mock.rs
index 5d06170aae7f991ae1e0b77c530272cbd5ef14dd..3e4903200c3d083b0e34f5668899aea3ae38c6af 100644
--- a/substrate/frame/paged-list/src/mock.rs
+++ b/substrate/frame/paged-list/src/mock.rs
@@ -20,15 +20,8 @@
 #![cfg(feature = "std")]
 
 use crate::{paged_list::StoragePagedListMeta, Config, ListPrefix};
-use frame_support::{
-	derive_impl,
-	traits::{ConstU16, ConstU64},
-};
-use sp_core::H256;
-use sp_runtime::{
-	traits::{BlakeTwo256, IdentityLookup},
-	BuildStorage,
-};
+use frame_support::derive_impl;
+use sp_runtime::{traits::IdentityLookup, BuildStorage};
 
 type Block = frame_system::mocking::MockBlock<Test>;
 
@@ -43,29 +36,11 @@ frame_support::construct_runtime!(
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
 	type Nonce = u64;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
 	type AccountId = u64;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = ();
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ConstU16<42>;
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
 frame_support::parameter_types! {
diff --git a/substrate/frame/parameters/src/tests/mock.rs b/substrate/frame/parameters/src/tests/mock.rs
index 6cfd7c8f30b8119ff1e1f0a63165c98afba1577b..53a3b3e394c4b7c5d8410ba6e1af758d78cbf8ae 100644
--- a/substrate/frame/parameters/src/tests/mock.rs
+++ b/substrate/frame/parameters/src/tests/mock.rs
@@ -37,7 +37,6 @@ impl frame_system::Config for Runtime {
 
 #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type ReserveIdentifier = [u8; 8];
 	type AccountStore = System;
 }
 
diff --git a/substrate/frame/parameters/src/tests/test_renamed.rs b/substrate/frame/parameters/src/tests/test_renamed.rs
index cfc870fbe1096aeeab930d548e6455427962d62a..7c371c5e55f874c01fffde081bb65b551c75d5b3 100644
--- a/substrate/frame/parameters/src/tests/test_renamed.rs
+++ b/substrate/frame/parameters/src/tests/test_renamed.rs
@@ -39,7 +39,6 @@ impl frame_system::Config for Runtime {
 
 #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type ReserveIdentifier = [u8; 8];
 	type AccountStore = System;
 }
 
diff --git a/substrate/frame/preimage/src/benchmarking.rs b/substrate/frame/preimage/src/benchmarking.rs
index d0c3404f40a911cf32d620858b97652b242f2be8..f2b76a7999d6c61827624b3b9ca6d9e55a0341d9 100644
--- a/substrate/frame/preimage/src/benchmarking.rs
+++ b/substrate/frame/preimage/src/benchmarking.rs
@@ -116,7 +116,7 @@ benchmarks! {
 		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
 		hash
 	) verify {
-		let ticket = TicketOf::<T>::new(&noter, Footprint { count: 1, size: MAX_SIZE as u64 }).unwrap();
+		let ticket = TicketOf::<T>::new(&noter, Footprint { count: 1, size: MAX_SIZE as u64 }).unwrap().unwrap();
 		let s = RequestStatus::Requested { maybe_ticket: Some((noter, ticket)), count: 1, maybe_len: Some(MAX_SIZE) };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
diff --git a/substrate/frame/preimage/src/lib.rs b/substrate/frame/preimage/src/lib.rs
index 4e474685166631ba41eed644d3754a332a290663..dd323a12b8f8479ba5d419243c9585f79ac0385a 100644
--- a/substrate/frame/preimage/src/lib.rs
+++ b/substrate/frame/preimage/src/lib.rs
@@ -122,7 +122,9 @@ pub mod pallet {
 		type ManagerOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
 		/// A means of providing some cost while data is stored on-chain.
-		type Consideration: Consideration<Self::AccountId>;
+		///
+		/// Should never return a `None`, implying no cost for a non-empty preimage.
+		type Consideration: Consideration<Self::AccountId, Footprint>;
 	}
 
 	#[pallet::pallet]
@@ -158,6 +160,8 @@ pub mod pallet {
 		TooMany,
 		/// Too few hashes were requested to be upgraded (i.e. zero).
 		TooFew,
+		/// No ticket with a cost was returned by [`Config::Consideration`] to store the preimage.
+		NoCost,
 	}
 
 	/// A reason for this pallet placing a hold on funds.
@@ -268,10 +272,10 @@ impl<T: Config> Pallet<T> {
 				// unreserve deposit
 				T::Currency::unreserve(&who, amount);
 				// take consideration
-				let Ok(ticket) =
+				let Ok(Some(ticket)) =
 					T::Consideration::new(&who, Footprint::from_parts(1, len as usize))
-						.defensive_proof("Unexpected inability to take deposit after unreserved")
 				else {
+					defensive!("None ticket or inability to take deposit after unreserved");
 					return true
 				};
 				RequestStatus::Unrequested { ticket: (who, ticket), len }
@@ -282,12 +286,10 @@ impl<T: Config> Pallet<T> {
 					T::Currency::unreserve(&who, deposit);
 					// take consideration
 					if let Some(len) = maybe_len {
-						let Ok(ticket) =
+						let Ok(Some(ticket)) =
 							T::Consideration::new(&who, Footprint::from_parts(1, len as usize))
-								.defensive_proof(
-									"Unexpected inability to take deposit after unreserved",
-								)
 						else {
+							defensive!("None ticket or inability to take deposit after unreserved");
 							return true
 						};
 						Some((who, ticket))
@@ -347,7 +349,8 @@ impl<T: Config> Pallet<T> {
 				RequestStatus::Requested { maybe_ticket: None, count: 1, maybe_len: Some(len) },
 			(None, Some(depositor)) => {
 				let ticket =
-					T::Consideration::new(depositor, Footprint::from_parts(1, len as usize))?;
+					T::Consideration::new(depositor, Footprint::from_parts(1, len as usize))?
+						.ok_or(Error::<T>::NoCost)?;
 				RequestStatus::Unrequested { ticket: (depositor.clone(), ticket), len }
 			},
 		};
diff --git a/substrate/frame/preimage/src/mock.rs b/substrate/frame/preimage/src/mock.rs
index 903c34596aebacfd7116f1b172d54f9ed26f6426..9c72d09cae1463395aaebe1e06f95d5e22cced9f 100644
--- a/substrate/frame/preimage/src/mock.rs
+++ b/substrate/frame/preimage/src/mock.rs
@@ -22,7 +22,7 @@ use super::*;
 use crate as pallet_preimage;
 use frame_support::{
 	derive_impl, ord_parameter_types, parameter_types,
-	traits::{fungible::HoldConsideration, ConstU32, ConstU64},
+	traits::{fungible::HoldConsideration, ConstU64},
 };
 use frame_system::EnsureSignedBy;
 use sp_core::H256;
@@ -48,20 +48,10 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ConstU64<5>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<1>;
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = ();
 }
 
 ord_parameter_types! {
diff --git a/substrate/frame/recovery/src/mock.rs b/substrate/frame/recovery/src/mock.rs
index bec7e02c128bbfc2c9975d881ac5210cd31aa56f..8e30cbe997e17b80e8ef74a598b15343e6affdef 100644
--- a/substrate/frame/recovery/src/mock.rs
+++ b/substrate/frame/recovery/src/mock.rs
@@ -47,20 +47,11 @@ parameter_types! {
 	pub const ExistentialDeposit: u64 = 1;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = u128;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 parameter_types! {
diff --git a/substrate/frame/referenda/src/mock.rs b/substrate/frame/referenda/src/mock.rs
index 135476d7cb1373ea1e7d3164e9df9d5b9dfc36ee..d47da45581195b43328d081ea3373a36487847d3 100644
--- a/substrate/frame/referenda/src/mock.rs
+++ b/substrate/frame/referenda/src/mock.rs
@@ -83,20 +83,9 @@ impl pallet_scheduler::Config for Test {
 	type OriginPrivilegeCmp = EqualPrivilegeOnly;
 	type Preimages = Preimage;
 }
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type MaxLocks = ConstU32<10>;
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 parameter_types! {
 	pub static AlarmInterval: u64 = 1;
diff --git a/substrate/frame/root-offences/src/mock.rs b/substrate/frame/root-offences/src/mock.rs
index 7e7332c3f7e3b39ca9457c6da05c7eb66197d0c4..3c758b91d52fe851dd279a3e7e3bb3b9dd69ebe3 100644
--- a/substrate/frame/root-offences/src/mock.rs
+++ b/substrate/frame/root-offences/src/mock.rs
@@ -84,20 +84,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 pallet_staking_reward_curve::build! {
@@ -135,15 +124,11 @@ parameter_types! {
 	pub static LedgerSlashPerEra: (BalanceOf<Test>, BTreeMap<EraIndex, BalanceOf<Test>>) = (Zero::zero(), BTreeMap::new());
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Test {
 	type Currency = Balances;
 	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
 	type UnixTime = Timestamp;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
-	type Reward = ();
 	type SessionsPerEra = SessionsPerEra;
 	type SlashDeferDuration = SlashDeferDuration;
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
@@ -151,19 +136,10 @@ impl pallet_staking::Config for Test {
 	type SessionInterface = Self;
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
-	type MaxExposurePageSize = ConstU32<64>;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type HistoryDepth = ConstU32<84>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
-	type EventListeners = ();
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
 
 impl pallet_session::historical::Config for Test {
diff --git a/substrate/frame/safe-mode/src/mock.rs b/substrate/frame/safe-mode/src/mock.rs
index fbfc16f4aa2881b25db9b27c3be3c53973a925ab..ec1ad82495147dbfc3039fc32dd3cd1e280629ad 100644
--- a/substrate/frame/safe-mode/src/mock.rs
+++ b/substrate/frame/safe-mode/src/mock.rs
@@ -47,7 +47,6 @@ impl frame_system::Config for Test {
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
 	type DbWeight = ();
 	type Version = ();
 	type PalletInfo = PalletInfo;
@@ -69,20 +68,10 @@ pub enum HoldReason {
 	SafeMode,
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ConstU64<2>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ConstU32<10>;
-	type ReserveIdentifier = [u8; 8];
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
 }
 
 impl pallet_utility::Config for Test {
diff --git a/substrate/frame/sassafras/Cargo.toml b/substrate/frame/sassafras/Cargo.toml
index 82fb9a1d8c5f1bd57073d9212003f6f35da42178..2105ba13314762151c02b3fc880795798414d32c 100644
--- a/substrate/frame/sassafras/Cargo.toml
+++ b/substrate/frame/sassafras/Cargo.toml
@@ -17,7 +17,7 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-scale-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 frame-benchmarking = { path = "../benchmarking", default-features = false, optional = true }
 frame-support = { path = "../support", default-features = false }
@@ -36,11 +36,11 @@ sp-crypto-hashing = { path = "../../primitives/crypto/hashing" }
 [features]
 default = ["std"]
 std = [
+	"codec/std",
 	"frame-benchmarking?/std",
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",
-	"scale-codec/std",
 	"scale-info/std",
 	"sp-consensus-sassafras/std",
 	"sp-io/std",
diff --git a/substrate/frame/sassafras/src/lib.rs b/substrate/frame/sassafras/src/lib.rs
index 8cbf1e47e3203a208578abb1b8b8431cbfd22ebb..d521ed9dd91b87ab46ccc19f0643f44d5a2013a6 100644
--- a/substrate/frame/sassafras/src/lib.rs
+++ b/substrate/frame/sassafras/src/lib.rs
@@ -47,8 +47,8 @@
 #![warn(unused_must_use, unsafe_code, unused_variables, unused_imports, missing_docs)]
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use codec::{Decode, Encode, MaxEncodedLen};
 use log::{debug, error, trace, warn};
-use scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 use frame_support::{
diff --git a/substrate/frame/scored-pool/src/mock.rs b/substrate/frame/scored-pool/src/mock.rs
index 9d2f5eb1099f819ad0db2ac1c6d1878a5d2df2da..7708c06e56bd8056b0b2ff89f5b383d3b4c180bf 100644
--- a/substrate/frame/scored-pool/src/mock.rs
+++ b/substrate/frame/scored-pool/src/mock.rs
@@ -52,20 +52,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 parameter_types! {
diff --git a/substrate/frame/session/benchmarking/src/mock.rs b/substrate/frame/session/benchmarking/src/mock.rs
index 6cefa8f39a8c6081be0f5dfcec4b1d7ed0f8122c..2aec58cceded2d186d9ead2ca2c4768e7cce1b90 100644
--- a/substrate/frame/session/benchmarking/src/mock.rs
+++ b/substrate/frame/session/benchmarking/src/mock.rs
@@ -47,45 +47,17 @@ frame_support::construct_runtime!(
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
 	type Nonce = Nonce;
-	type RuntimeCall = RuntimeCall;
-	type Hash = sp_core::H256;
-	type Hashing = ::sp_runtime::traits::BlakeTwo256;
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ConstU64<10>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_timestamp::Config for Test {
@@ -157,35 +129,19 @@ impl onchain::Config for OnChainSeqPhragmen {
 	type Bounds = ElectionsBounds;
 }
 
+#[derive_impl(pallet_staking::config_preludes::TestDefaultConfig)]
 impl pallet_staking::Config for Test {
 	type Currency = Balances;
 	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
 	type UnixTime = pallet_timestamp::Pallet<Self>;
-	type CurrencyToVote = ();
-	type RewardRemainder = ();
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
-	type Reward = ();
-	type SessionsPerEra = ();
-	type SlashDeferDuration = ();
 	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
-	type BondingDuration = ();
 	type SessionInterface = Self;
 	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
-	type MaxExposurePageSize = ConstU32<64>;
 	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
 	type GenesisElectionProvider = Self::ElectionProvider;
-	type MaxUnlockingChunks = ConstU32<32>;
-	type MaxControllersInDeprecationBatch = ConstU32<100>;
-	type HistoryDepth = ConstU32<84>;
 	type VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
 	type TargetList = pallet_staking::UseValidatorsMap<Self>;
-	type NominationsQuota = pallet_staking::FixedNominationsQuota<16>;
-	type EventListeners = ();
-	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
-	type WeightInfo = ();
-	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy;
 }
 
 impl crate::Config for Test {}
diff --git a/substrate/frame/src/lib.rs b/substrate/frame/src/lib.rs
index f6507cd02c71ae5542836119821fc29070a24f6a..e41f7f1c0ef308673b11ce99018156e2eff064e1 100644
--- a/substrate/frame/src/lib.rs
+++ b/substrate/frame/src/lib.rs
@@ -316,11 +316,11 @@ pub mod primitives {
 ///
 /// This is already part of the [`prelude`].
 pub mod derive {
+	pub use codec::{Decode, Encode};
 	pub use frame_support::{
 		CloneNoBound, DebugNoBound, DefaultNoBound, EqNoBound, OrdNoBound, PartialEqNoBound,
 		PartialOrdNoBound, RuntimeDebugNoBound,
 	};
-	pub use parity_scale_codec::{Decode, Encode};
 	pub use scale_info::TypeInfo;
 	pub use sp_runtime::RuntimeDebug;
 	pub use sp_std::fmt::Debug;
@@ -345,7 +345,7 @@ pub mod deps {
 	pub use sp_runtime;
 	pub use sp_std;
 
-	pub use parity_scale_codec as codec;
+	pub use codec;
 	pub use scale_info;
 
 	#[cfg(feature = "runtime")]
diff --git a/substrate/frame/staking/reward-curve/src/lib.rs b/substrate/frame/staking/reward-curve/src/lib.rs
index 1986357edabe20cca94d0d0e26e1bee54e08a0ac..cfb8b896f9394ad06223da2097a91b620fcf30d4 100644
--- a/substrate/frame/staking/reward-curve/src/lib.rs
+++ b/substrate/frame/staking/reward-curve/src/lib.rs
@@ -88,7 +88,13 @@ pub fn build(input: TokenStream) -> TokenStream {
 			let ident = syn::Ident::new(&sp_runtime, Span::call_site());
 			quote!( #[doc(hidden)] pub use #ident as _sp_runtime; )
 		},
-		Err(e) => syn::Error::new(Span::call_site(), e).to_compile_error(),
+		Err(e) => match crate_name("polkadot-sdk") {
+			Ok(FoundCrate::Name(polkadot_sdk)) => {
+				let ident = syn::Ident::new(&polkadot_sdk, Span::call_site());
+				quote!( #[doc(hidden)] pub use #ident::sp_runtime as _sp_runtime; )
+			},
+			_ => syn::Error::new(Span::call_site(), e).to_compile_error(),
+		},
 	};
 
 	let const_name = input.ident;
diff --git a/substrate/frame/staking/src/ledger.rs b/substrate/frame/staking/src/ledger.rs
index 67a86b86226cfb1aa5da4c8bca794f315f348009..294918376d82ce5a8473a5353cea0dc5cdd1ba50 100644
--- a/substrate/frame/staking/src/ledger.rs
+++ b/substrate/frame/staking/src/ledger.rs
@@ -35,7 +35,7 @@ use frame_support::{
 	defensive, ensure,
 	traits::{Defensive, LockableCurrency},
 };
-use sp_staking::StakingAccount;
+use sp_staking::{StakingAccount, StakingInterface};
 use sp_std::prelude::*;
 
 use crate::{
diff --git a/substrate/frame/staking/src/lib.rs b/substrate/frame/staking/src/lib.rs
index 4f91fd6dff220d7fbf2b768a3b9f9a4d3e8c29ab..053ecdef2b00b7bb900443153f63e64f51d89252 100644
--- a/substrate/frame/staking/src/lib.rs
+++ b/substrate/frame/staking/src/lib.rs
@@ -361,7 +361,7 @@ pub type BalanceOf<T> = <T as Config>::CurrencyBalance;
 type PositiveImbalanceOf<T> = <<T as Config>::Currency as Currency<
 	<T as frame_system::Config>::AccountId,
 >>::PositiveImbalance;
-type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<
+pub type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<
 	<T as frame_system::Config>::AccountId,
 >>::NegativeImbalance;
 
diff --git a/substrate/frame/staking/src/mock.rs b/substrate/frame/staking/src/mock.rs
index 8c60dec65a81a123b5d1bd04b3ea8614ae1e9f0f..7e6a87955b08371dddbecc6e17477ed5808173ef 100644
--- a/substrate/frame/staking/src/mock.rs
+++ b/substrate/frame/staking/src/mock.rs
@@ -124,20 +124,12 @@ impl frame_system::Config for Test {
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<Balance>;
 }
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
 	type MaxLocks = frame_support::traits::ConstU32<1024>;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
 	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 sp_runtime::impl_opaque_keys! {
@@ -269,19 +261,15 @@ impl OnStakingUpdate<AccountId, Balance> for EventListenerMock {
 // Disabling threshold for `UpToLimitDisablingStrategy`
 pub(crate) const DISABLING_LIMIT_FACTOR: usize = 3;
 
+#[derive_impl(crate::config_preludes::TestDefaultConfig)]
 impl crate::pallet::pallet::Config for Test {
 	type Currency = Balances;
-	type CurrencyBalance = <Self as pallet_balances::Config>::Balance;
 	type UnixTime = Timestamp;
-	type CurrencyToVote = ();
 	type RewardRemainder = RewardRemainderMock;
-	type RuntimeEvent = RuntimeEvent;
-	type Slash = ();
 	type Reward = MockReward;
 	type SessionsPerEra = SessionsPerEra;
 	type SlashDeferDuration = SlashDeferDuration;
 	type AdminOrigin = EnsureOneOrRoot;
-	type BondingDuration = BondingDuration;
 	type SessionInterface = Self;
 	type EraPayout = ConvertCurve<RewardCurve>;
 	type NextNewSession = Session;
@@ -296,8 +284,6 @@ impl crate::pallet::pallet::Config for Test {
 	type HistoryDepth = HistoryDepth;
 	type MaxControllersInDeprecationBatch = MaxControllersInDeprecationBatch;
 	type EventListeners = EventListenerMock;
-	type BenchmarkingConfig = TestBenchmarkingConfig;
-	type WeightInfo = ();
 	type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy<DISABLING_LIMIT_FACTOR>;
 }
 
diff --git a/substrate/frame/staking/src/pallet/impls.rs b/substrate/frame/staking/src/pallet/impls.rs
index 52361c6ccdc13653e155df8e1535ec6a16cbe65a..90374451a3a5266362699e6fc55e957a552ba157 100644
--- a/substrate/frame/staking/src/pallet/impls.rs
+++ b/substrate/frame/staking/src/pallet/impls.rs
@@ -1161,11 +1161,6 @@ impl<T: Config> Pallet<T> {
 	) -> Exposure<T::AccountId, BalanceOf<T>> {
 		EraInfo::<T>::get_full_exposure(era, account)
 	}
-
-	/// Whether `who` is a virtual staker whose funds are managed by another pallet.
-	pub(crate) fn is_virtual_staker(who: &T::AccountId) -> bool {
-		VirtualStakers::<T>::contains_key(who)
-	}
 }
 
 impl<T: Config> Pallet<T> {
@@ -1885,6 +1880,11 @@ impl<T: Config> StakingInterface for Pallet<T> {
 		}
 	}
 
+	/// Whether `who` is a virtual staker whose funds are managed by another pallet.
+	fn is_virtual_staker(who: &T::AccountId) -> bool {
+		VirtualStakers::<T>::contains_key(who)
+	}
+
 	fn slash_reward_fraction() -> Perbill {
 		SlashRewardFraction::<T>::get()
 	}
diff --git a/substrate/frame/staking/src/pallet/mod.rs b/substrate/frame/staking/src/pallet/mod.rs
index f82266c03903ceb09703324ba8e79a75d8a0fa16..a76e47edf38039501fe0ac9d3434e13b3fdafe4c 100644
--- a/substrate/frame/staking/src/pallet/mod.rs
+++ b/substrate/frame/staking/src/pallet/mod.rs
@@ -39,6 +39,7 @@ use sp_runtime::{
 use sp_staking::{
 	EraIndex, Page, SessionIndex,
 	StakingAccount::{self, Controller, Stash},
+	StakingInterface,
 };
 use sp_std::prelude::*;
 
@@ -85,9 +86,10 @@ pub mod pallet {
 		Remove,
 	}
 
-	#[pallet::config]
+	#[pallet::config(with_default)]
 	pub trait Config: frame_system::Config {
 		/// The staking balance.
+		#[pallet::no_default]
 		type Currency: LockableCurrency<
 				Self::AccountId,
 				Moment = BlockNumberFor<Self>,
@@ -108,6 +110,7 @@ pub mod pallet {
 		///
 		/// It is guaranteed to start being called from the first `on_finalize`. Thus value at
 		/// genesis is not used.
+		#[pallet::no_default]
 		type UnixTime: UnixTime;
 
 		/// Convert a balance into a number used for election calculation. This must fit into a
@@ -116,9 +119,11 @@ pub mod pallet {
 		/// in 128.
 		/// Consequently, the backward convert is used convert the u128s from sp-elections back to a
 		/// [`BalanceOf`].
+		#[pallet::no_default_bounds]
 		type CurrencyToVote: sp_staking::currency_to_vote::CurrencyToVote<BalanceOf<Self>>;
 
 		/// Something that provides the election functionality.
+		#[pallet::no_default]
 		type ElectionProvider: ElectionProvider<
 			AccountId = Self::AccountId,
 			BlockNumber = BlockNumberFor<Self>,
@@ -126,6 +131,7 @@ pub mod pallet {
 			DataProvider = Pallet<Self>,
 		>;
 		/// Something that provides the election functionality at genesis.
+		#[pallet::no_default]
 		type GenesisElectionProvider: ElectionProvider<
 			AccountId = Self::AccountId,
 			BlockNumber = BlockNumberFor<Self>,
@@ -133,6 +139,7 @@ pub mod pallet {
 		>;
 
 		/// Something that defines the maximum number of nominations per nominator.
+		#[pallet::no_default_bounds]
 		type NominationsQuota: NominationsQuota<BalanceOf<Self>>;
 
 		/// Number of eras to keep in history.
@@ -160,17 +167,21 @@ pub mod pallet {
 
 		/// Tokens have been minted and are unused for validator-reward.
 		/// See [Era payout](./index.html#era-payout).
+		#[pallet::no_default_bounds]
 		type RewardRemainder: OnUnbalanced<NegativeImbalanceOf<Self>>;
 
 		/// The overarching event type.
+		#[pallet::no_default_bounds]
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
 		/// Handler for the unbalanced reduction when slashing a staker.
+		#[pallet::no_default_bounds]
 		type Slash: OnUnbalanced<NegativeImbalanceOf<Self>>;
 
 		/// Handler for the unbalanced increment when rewarding a staker.
 		/// NOTE: in most cases, the implementation of `OnUnbalanced` should modify the total
 		/// issuance.
+		#[pallet::no_default_bounds]
 		type Reward: OnUnbalanced<PositiveImbalanceOf<Self>>;
 
 		/// Number of sessions per era.
@@ -191,6 +202,7 @@ pub mod pallet {
 		/// The origin which can manage less critical staking parameters that does not require root.
 		///
 		/// Supported actions: (1) cancel deferred slash, (2) set minimum commission.
+		#[pallet::no_default]
 		type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
 		/// Interface for interacting with a session pallet.
@@ -198,10 +210,12 @@ pub mod pallet {
 
 		/// The payout for validators and the system for the current era.
 		/// See [Era payout](./index.html#era-payout).
+		#[pallet::no_default]
 		type EraPayout: EraPayout<BalanceOf<Self>>;
 
 		/// Something that can estimate the next session change, accurately or as a best effort
 		/// guess.
+		#[pallet::no_default_bounds]
 		type NextNewSession: EstimateNextNewSession<BlockNumberFor<Self>>;
 
 		/// The maximum size of each `T::ExposurePage`.
@@ -229,6 +243,7 @@ pub mod pallet {
 		/// staker. In case of `bags-list`, this always means using `rebag` and `putInFrontOf`.
 		///
 		/// Invariant: what comes out of this list will always be a nominator.
+		#[pallet::no_default]
 		type VoterList: SortedListProvider<Self::AccountId, Score = VoteWeight>;
 
 		/// WIP: This is a noop as of now, the actual business logic that's described below is going
@@ -251,6 +266,7 @@ pub mod pallet {
 		/// validators, they can chill at any point, and their approval stakes will still be
 		/// recorded. This implies that what comes out of iterating this list MIGHT NOT BE AN ACTIVE
 		/// VALIDATOR.
+		#[pallet::no_default]
 		type TargetList: SortedListProvider<Self::AccountId, Score = BalanceOf<Self>>;
 
 		/// The maximum number of `unlocking` chunks a [`StakingLedger`] can
@@ -273,18 +289,66 @@ pub mod pallet {
 		/// receives.
 		///
 		/// WARNING: this only reports slashing and withdraw events for the time being.
+		#[pallet::no_default_bounds]
 		type EventListeners: sp_staking::OnStakingUpdate<Self::AccountId, BalanceOf<Self>>;
 
-		// `DisablingStragegy` controls how validators are disabled
+		/// `DisablingStragegy` controls how validators are disabled
+		#[pallet::no_default_bounds]
 		type DisablingStrategy: DisablingStrategy<Self>;
 
 		/// Some parameters of the benchmarking.
+		#[cfg(feature = "std")]
+		type BenchmarkingConfig: BenchmarkingConfig;
+
+		#[cfg(not(feature = "std"))]
+		#[pallet::no_default]
 		type BenchmarkingConfig: BenchmarkingConfig;
 
 		/// Weight information for extrinsics in this pallet.
 		type WeightInfo: WeightInfo;
 	}
 
+	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].
+	pub mod config_preludes {
+		use super::*;
+		use frame_support::{derive_impl, parameter_types, traits::ConstU32};
+		pub struct TestDefaultConfig;
+
+		#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]
+		impl frame_system::DefaultConfig for TestDefaultConfig {}
+
+		parameter_types! {
+			pub const SessionsPerEra: SessionIndex = 3;
+			pub const BondingDuration: EraIndex = 3;
+		}
+
+		#[frame_support::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			#[inject_runtime_type]
+			type RuntimeEvent = ();
+			type CurrencyBalance = u128;
+			type CurrencyToVote = ();
+			type NominationsQuota = crate::FixedNominationsQuota<16>;
+			type HistoryDepth = ConstU32<84>;
+			type RewardRemainder = ();
+			type Slash = ();
+			type Reward = ();
+			type SessionsPerEra = SessionsPerEra;
+			type BondingDuration = BondingDuration;
+			type SlashDeferDuration = ();
+			type SessionInterface = ();
+			type NextNewSession = ();
+			type MaxExposurePageSize = ConstU32<64>;
+			type MaxUnlockingChunks = ConstU32<32>;
+			type MaxControllersInDeprecationBatch = ConstU32<100>;
+			type EventListeners = ();
+			type DisablingStrategy = crate::UpToLimitDisablingStrategy;
+			#[cfg(feature = "std")]
+			type BenchmarkingConfig = crate::TestBenchmarkingConfig;
+			type WeightInfo = ();
+		}
+	}
+
 	/// The ideal number of active validators.
 	#[pallet::storage]
 	#[pallet::getter(fn validator_count)]
diff --git a/substrate/frame/staking/src/slashing.rs b/substrate/frame/staking/src/slashing.rs
index f831f625957d4c495fce3b239e68faed737cb3ab..1fe608cd3358bb8d7ab113ee96d720df4998c759 100644
--- a/substrate/frame/staking/src/slashing.rs
+++ b/substrate/frame/staking/src/slashing.rs
@@ -64,7 +64,7 @@ use sp_runtime::{
 	traits::{Saturating, Zero},
 	DispatchResult, RuntimeDebug,
 };
-use sp_staking::EraIndex;
+use sp_staking::{EraIndex, StakingInterface};
 use sp_std::vec::Vec;
 
 /// The proportion of the slashing reward to be paid out on the first slashing detection.
diff --git a/substrate/frame/staking/src/tests.rs b/substrate/frame/staking/src/tests.rs
index 76afa3333cb465b9f7f9e119871730f31fcd6720..2229eb28329ad07b5eb8742293a3b10eb6bdc905 100644
--- a/substrate/frame/staking/src/tests.rs
+++ b/substrate/frame/staking/src/tests.rs
@@ -5251,6 +5251,7 @@ mod election_data_provider {
 	// maybe_max_len`.
 	#[test]
 	#[should_panic]
+	#[cfg(debug_assertions)]
 	fn only_iterates_max_2_times_max_allowed_len() {
 		ExtBuilder::default()
 			.nominate(false)
@@ -5939,6 +5940,7 @@ fn min_commission_works() {
 
 #[test]
 #[should_panic]
+#[cfg(debug_assertions)]
 fn change_of_absolute_max_nominations() {
 	use frame_election_provider_support::ElectionDataProvider;
 	ExtBuilder::default()
diff --git a/substrate/frame/state-trie-migration/src/lib.rs b/substrate/frame/state-trie-migration/src/lib.rs
index 5c54c27966cd6951309ff320d942fac1ba15e9c7..4ec649f9080d463dcf72dbb96e9a34ce49124af0 100644
--- a/substrate/frame/state-trie-migration/src/lib.rs
+++ b/substrate/frame/state-trie-migration/src/lib.rs
@@ -1103,11 +1103,7 @@ mod benchmarks {
 mod mock {
 	use super::*;
 	use crate as pallet_state_trie_migration;
-	use frame_support::{
-		derive_impl, parameter_types,
-		traits::{ConstU32, Hooks},
-		weights::Weight,
-	};
+	use frame_support::{derive_impl, parameter_types, traits::Hooks, weights::Weight};
 	use frame_system::{EnsureRoot, EnsureSigned};
 	use sp_core::{
 		storage::{ChildInfo, StateVersion},
@@ -1134,7 +1130,6 @@ mod mock {
 	#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 	impl frame_system::Config for Test {
 		type Block = Block;
-		type BlockHashCount = ConstU32<250>;
 		type AccountData = pallet_balances::AccountData<u64>;
 	}
 
diff --git a/substrate/frame/statement/src/mock.rs b/substrate/frame/statement/src/mock.rs
index 35d51e7a27bfc82e82d9b0b19220c31816c27e37..34afd332c083ddb4baefd367349a9e37f806838f 100644
--- a/substrate/frame/statement/src/mock.rs
+++ b/substrate/frame/statement/src/mock.rs
@@ -51,20 +51,10 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ConstU64<5>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
 }
 
 ord_parameter_types! {
diff --git a/substrate/frame/sudo/src/mock.rs b/substrate/frame/sudo/src/mock.rs
index a3a786c4af3924a4477823018a6400090b316c57..67f896e1c021ce22b04e6b23210895d6b95409d3 100644
--- a/substrate/frame/sudo/src/mock.rs
+++ b/substrate/frame/sudo/src/mock.rs
@@ -106,6 +106,7 @@ impl Contains<RuntimeCall> for BlockEverything {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
+	type BaseCallFilter = BlockEverything;
 	type Block = Block;
 }
 
diff --git a/substrate/frame/support/procedural/src/lib.rs b/substrate/frame/support/procedural/src/lib.rs
index 53f01329d1815d280031574ca232a166e7f8148e..e812ac071b2c9a2cf2e8ef199c2e1d656b7f0494 100644
--- a/substrate/frame/support/procedural/src/lib.rs
+++ b/substrate/frame/support/procedural/src/lib.rs
@@ -1249,7 +1249,6 @@ pub fn import_section(attr: TokenStream, tokens: TokenStream) -> TokenStream {
 ///
 /// * The macro generates a type alias for each pallet to their `Pallet`. E.g. `type System =
 ///   frame_system::Pallet<Runtime>`
-#[cfg(feature = "experimental")]
 #[proc_macro_attribute]
 pub fn runtime(attr: TokenStream, item: TokenStream) -> TokenStream {
 	runtime::runtime(attr, item)
diff --git a/substrate/frame/support/procedural/src/pallet/expand/constants.rs b/substrate/frame/support/procedural/src/pallet/expand/constants.rs
index 57fa8b7f3cd9af0e24feffaac17367b7cc817054..d7fbb5a718973c9d2a9ed9f32ab384536265f3d6 100644
--- a/substrate/frame/support/procedural/src/pallet/expand/constants.rs
+++ b/substrate/frame/support/procedural/src/pallet/expand/constants.rs
@@ -30,8 +30,7 @@ struct ConstDef {
 	pub metadata_name: Option<syn::Ident>,
 }
 
-///
-/// * Impl fn module_constant_metadata for pallet.
+/// Implement the `pallet_constants_metadata` function for the pallet.
 pub fn expand_constants(def: &mut Def) -> proc_macro2::TokenStream {
 	let frame_support = &def.frame_support;
 	let type_impl_gen = &def.type_impl_generics(proc_macro2::Span::call_site());
diff --git a/substrate/frame/support/procedural/src/pallet/parse/config.rs b/substrate/frame/support/procedural/src/pallet/parse/config.rs
index 406072df4b9d60b874df83578c12df5df1216329..eaeaab247588052a36d7aac469935b62151fa013 100644
--- a/substrate/frame/support/procedural/src/pallet/parse/config.rs
+++ b/substrate/frame/support/procedural/src/pallet/parse/config.rs
@@ -94,30 +94,26 @@ impl TryFrom<&syn::TraitItemType> for ConstMetadataDef {
 		let bound = trait_ty
 			.bounds
 			.iter()
-			.find_map(|b| {
-				if let syn::TypeParamBound::Trait(tb) = b {
-					tb.path
-						.segments
-						.last()
-						.and_then(|s| if s.ident == "Get" { Some(s) } else { None })
-				} else {
-					None
-				}
+			.find_map(|param_bound| {
+				let syn::TypeParamBound::Trait(trait_bound) = param_bound else { return None };
+
+				trait_bound.path.segments.last().and_then(|s| (s.ident == "Get").then(|| s))
 			})
 			.ok_or_else(|| err(trait_ty.span(), "`Get<T>` trait bound not found"))?;
-		let type_arg = if let syn::PathArguments::AngleBracketed(ref ab) = bound.arguments {
-			if ab.args.len() == 1 {
-				if let syn::GenericArgument::Type(ref ty) = ab.args[0] {
-					Ok(ty)
-				} else {
-					Err(err(ab.args[0].span(), "Expected a type argument"))
-				}
-			} else {
-				Err(err(bound.span(), "Expected a single type argument"))
-			}
-		} else {
-			Err(err(bound.span(), "Expected trait generic args"))
-		}?;
+
+		let syn::PathArguments::AngleBracketed(ref ab) = bound.arguments else {
+			return Err(err(bound.span(), "Expected trait generic args"))
+		};
+
+		// Only one type argument is expected.
+		if ab.args.len() != 1 {
+			return Err(err(bound.span(), "Expected a single type argument"))
+		}
+
+		let syn::GenericArgument::Type(ref type_arg) = ab.args[0] else {
+			return Err(err(ab.args[0].span(), "Expected a type argument"))
+		};
+
 		let type_ = syn::parse2::<syn::Type>(replace_self_by_t(type_arg.to_token_stream()))
 			.expect("Internal error: replacing `Self` by `T` should result in valid type");
 
@@ -223,55 +219,55 @@ fn check_event_type(
 	trait_item: &syn::TraitItem,
 	trait_has_instance: bool,
 ) -> syn::Result<bool> {
-	if let syn::TraitItem::Type(type_) = trait_item {
-		if type_.ident == "RuntimeEvent" {
-			// Check event has no generics
-			if !type_.generics.params.is_empty() || type_.generics.where_clause.is_some() {
-				let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must have\
-					no generics nor where_clause";
-				return Err(syn::Error::new(trait_item.span(), msg))
-			}
+	let syn::TraitItem::Type(type_) = trait_item else { return Ok(false) };
 
-			// Check bound contains IsType and From
-			let has_is_type_bound = type_.bounds.iter().any(|s| {
-				syn::parse2::<IsTypeBoundEventParse>(s.to_token_stream())
-					.map_or(false, |b| has_expected_system_config(b.0, frame_system))
-			});
-
-			if !has_is_type_bound {
-				let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
-					bound: `IsType<<Self as frame_system::Config>::RuntimeEvent>`".to_string();
-				return Err(syn::Error::new(type_.span(), msg))
-			}
+	if type_.ident != "RuntimeEvent" {
+		return Ok(false)
+	}
 
-			let from_event_bound = type_
-				.bounds
-				.iter()
-				.find_map(|s| syn::parse2::<FromEventParse>(s.to_token_stream()).ok());
+	// Check event has no generics
+	if !type_.generics.params.is_empty() || type_.generics.where_clause.is_some() {
+		let msg =
+			"Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must have\
+					no generics nor where_clause";
+		return Err(syn::Error::new(trait_item.span(), msg))
+	}
 
-			let from_event_bound = if let Some(b) = from_event_bound {
-				b
-			} else {
-				let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
-					bound: `From<Event>` or `From<Event<Self>>` or `From<Event<Self, I>>`";
-				return Err(syn::Error::new(type_.span(), msg))
-			};
+	// Check bound contains IsType and From
+	let has_is_type_bound = type_.bounds.iter().any(|s| {
+		syn::parse2::<IsTypeBoundEventParse>(s.to_token_stream())
+			.map_or(false, |b| has_expected_system_config(b.0, frame_system))
+	});
+
+	if !has_is_type_bound {
+		let msg =
+			"Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
+					bound: `IsType<<Self as frame_system::Config>::RuntimeEvent>`"
+				.to_string();
+		return Err(syn::Error::new(type_.span(), msg))
+	}
 
-			if from_event_bound.is_generic && (from_event_bound.has_instance != trait_has_instance)
-			{
-				let msg = "Invalid `type RuntimeEvent`, associated type `RuntimeEvent` bounds inconsistent \
+	let from_event_bound = type_
+		.bounds
+		.iter()
+		.find_map(|s| syn::parse2::<FromEventParse>(s.to_token_stream()).ok());
+
+	let Some(from_event_bound) = from_event_bound else {
+		let msg =
+			"Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
+				bound: `From<Event>` or `From<Event<Self>>` or `From<Event<Self, I>>`";
+		return Err(syn::Error::new(type_.span(), msg))
+	};
+
+	if from_event_bound.is_generic && (from_event_bound.has_instance != trait_has_instance) {
+		let msg =
+			"Invalid `type RuntimeEvent`, associated type `RuntimeEvent` bounds inconsistent \
 					`From<Event..>`. Config and generic Event must be both with instance or \
 					without instance";
-				return Err(syn::Error::new(type_.span(), msg))
-			}
-
-			Ok(true)
-		} else {
-			Ok(false)
-		}
-	} else {
-		Ok(false)
+		return Err(syn::Error::new(type_.span(), msg))
 	}
+
+	Ok(true)
 }
 
 /// Check that the path to `frame_system::Config` is valid, this is that the path is just
@@ -334,9 +330,7 @@ impl ConfigDef {
 		item: &mut syn::Item,
 		enable_default: bool,
 	) -> syn::Result<Self> {
-		let item = if let syn::Item::Trait(item) = item {
-			item
-		} else {
+		let syn::Item::Trait(item) = item else {
 			let msg = "Invalid pallet::config, expected trait definition";
 			return Err(syn::Error::new(item.span(), msg))
 		};
diff --git a/substrate/frame/support/procedural/src/pallet/parse/helper.rs b/substrate/frame/support/procedural/src/pallet/parse/helper.rs
index 3187c9139c8f46c7664e96edb6870f68979146ae..d4f58a4c56df8ba61e26535cc19287f336e78846 100644
--- a/substrate/frame/support/procedural/src/pallet/parse/helper.rs
+++ b/substrate/frame/support/procedural/src/pallet/parse/helper.rs
@@ -55,16 +55,16 @@ pub(crate) fn take_first_item_pallet_attr<Attr>(
 where
 	Attr: syn::parse::Parse,
 {
-	let attrs = if let Some(attrs) = item.mut_item_attrs() { attrs } else { return Ok(None) };
+	let Some(attrs) = item.mut_item_attrs() else { return Ok(None) };
 
-	if let Some(index) = attrs.iter().position(|attr| {
+	let Some(index) = attrs.iter().position(|attr| {
 		attr.path().segments.first().map_or(false, |segment| segment.ident == "pallet")
-	}) {
-		let pallet_attr = attrs.remove(index);
-		Ok(Some(syn::parse2(pallet_attr.into_token_stream())?))
-	} else {
-		Ok(None)
-	}
+	}) else {
+		return Ok(None)
+	};
+
+	let pallet_attr = attrs.remove(index);
+	Ok(Some(syn::parse2(pallet_attr.into_token_stream())?))
 }
 
 /// Take all the pallet attributes (e.g. attribute like `#[pallet..]`) and decode them to `Attr`
diff --git a/substrate/frame/support/procedural/src/runtime/mod.rs b/substrate/frame/support/procedural/src/runtime/mod.rs
index aaae579eb086638f1bfacf02105a8fcd0e3d01b5..1d4242cd122eb798d82494ef2f4d630571f2d518 100644
--- a/substrate/frame/support/procedural/src/runtime/mod.rs
+++ b/substrate/frame/support/procedural/src/runtime/mod.rs
@@ -200,8 +200,6 @@
 //!     +----------------------+
 //! ```
 
-#![cfg(feature = "experimental")]
-
 pub use parse::Def;
 use proc_macro::TokenStream;
 use syn::spanned::Spanned;
diff --git a/substrate/frame/support/procedural/src/runtime/parse/mod.rs b/substrate/frame/support/procedural/src/runtime/parse/mod.rs
index 893cb4726e2b6016fa2e728add86990e24087c42..dd83cd0da90a2185ebc5015daadba0a9d00ac438 100644
--- a/substrate/frame/support/procedural/src/runtime/parse/mod.rs
+++ b/substrate/frame/support/procedural/src/runtime/parse/mod.rs
@@ -152,8 +152,7 @@ impl Def {
 		let mut pallets = vec![];
 
 		for item in items.iter_mut() {
-			let mut pallet_item = None;
-			let mut pallet_index = 0;
+			let mut pallet_index_and_item = None;
 
 			let mut disable_call = false;
 			let mut disable_unsigned = false;
@@ -170,9 +169,8 @@ impl Def {
 						runtime_types = Some(types);
 					},
 					RuntimeAttr::PalletIndex(span, index) => {
-						pallet_index = index;
-						pallet_item = if let syn::Item::Type(item) = item {
-							Some(item.clone())
+						pallet_index_and_item = if let syn::Item::Type(item) = item {
+							Some((index, item.clone()))
 						} else {
 							let msg = "Invalid runtime::pallet_index, expected type definition";
 							return Err(syn::Error::new(span, msg))
@@ -187,7 +185,7 @@ impl Def {
 				}
 			}
 
-			if let Some(pallet_item) = pallet_item {
+			if let Some((pallet_index, pallet_item)) = pallet_index_and_item {
 				match *pallet_item.ty.clone() {
 					syn::Type::Path(ref path) => {
 						let pallet_decl =
@@ -230,6 +228,11 @@ impl Def {
 					},
 					_ => continue,
 				}
+			} else {
+				if let syn::Item::Type(item) = item {
+					let msg = "Missing pallet index for pallet declaration. Please add `#[runtime::pallet_index(...)]`";
+					return Err(syn::Error::new(item.span(), &msg))
+				}
 			}
 		}
 
diff --git a/substrate/frame/support/procedural/tools/src/lib.rs b/substrate/frame/support/procedural/tools/src/lib.rs
index 8952cd6011ff5bb717a9e731d09525d160d95739..ea53335a88fd4565e41680e2393b9affb248c975 100644
--- a/substrate/frame/support/procedural/tools/src/lib.rs
+++ b/substrate/frame/support/procedural/tools/src/lib.rs
@@ -70,6 +70,8 @@ pub fn is_using_frame_crate(path: &syn::Path) -> bool {
 pub fn generate_access_from_frame_or_crate(def_crate: &str) -> Result<syn::Path, Error> {
 	if let Some(path) = get_frame_crate_path(def_crate) {
 		Ok(path)
+	} else if let Some(path) = get_sdk_crate_path(def_crate) {
+		Ok(path)
 	} else {
 		let ident = match crate_name(def_crate) {
 			Ok(FoundCrate::Itself) => {
@@ -95,6 +97,13 @@ pub fn generate_hidden_includes(unique_id: &str, def_crate: &str) -> TokenStream
 				pub use #path as hidden_include;
 			}
 		)
+	} else if let Some(path) = get_sdk_crate_path(def_crate) {
+		quote::quote!(
+			#[doc(hidden)]
+			mod #mod_name {
+				pub use #path as hidden_include;
+			}
+		)
 	} else {
 		match crate_name(def_crate) {
 			Ok(FoundCrate::Itself) => quote!(),
@@ -128,6 +137,15 @@ fn get_frame_crate_path(def_crate: &str) -> Option<syn::Path> {
 	}
 }
 
+fn get_sdk_crate_path(def_crate: &str) -> Option<syn::Path> {
+	if let Ok(FoundCrate::Name(name)) = crate_name(&"polkadot-sdk") {
+		let path = format!("{}::{}", name, def_crate.to_string()).replace("-", "_");
+		Some(syn::parse_str::<syn::Path>(&path).expect("is a valid path; qed"))
+	} else {
+		None
+	}
+}
+
 // fn to remove white spaces around string types
 // (basically whitespaces around tokens)
 pub fn clean_type_string(input: &str) -> String {
diff --git a/substrate/frame/support/src/lib.rs b/substrate/frame/support/src/lib.rs
index 7eddea1259d7d040e57084232feb53eb2b6b1270..8ae1f56b4d686e6d6aa637aac1f6f2a0973e6157 100644
--- a/substrate/frame/support/src/lib.rs
+++ b/substrate/frame/support/src/lib.rs
@@ -508,7 +508,6 @@ pub use frame_support_procedural::{
 	construct_runtime, match_and_insert, transactional, PalletError, RuntimeDebugNoBound,
 };
 
-#[cfg(feature = "experimental")]
 pub use frame_support_procedural::runtime;
 
 #[doc(hidden)]
diff --git a/substrate/frame/support/src/traits/hooks.rs b/substrate/frame/support/src/traits/hooks.rs
index ccccc5063286602538c0c46293ffabe8ad01181a..1a687cade79f5973a8b2816d0cba40ef250c4b3a 100644
--- a/substrate/frame/support/src/traits/hooks.rs
+++ b/substrate/frame/support/src/traits/hooks.rs
@@ -351,6 +351,7 @@ pub trait IntegrityTest {
 /// - [`crate::traits::misc::OffchainWorker`]
 /// - [`OnIdle`]
 /// - [`IntegrityTest`]
+/// - [`OnPoll`]
 ///
 /// ## Ordering
 ///
@@ -363,34 +364,32 @@ pub trait IntegrityTest {
 ///
 /// ```mermaid
 /// graph LR
-/// 	Optional --> BeforeExtrinsics
-/// 	BeforeExtrinsics --> Extrinsics
-/// 	Extrinsics --> AfterExtrinsics
-/// 	subgraph Optional
+/// 	Optional --> Mandatory
+/// 	Mandatory --> ExtrinsicsMandatory
+/// 	ExtrinsicsMandatory --> Poll
+/// 	Poll --> Extrinsics
+/// 	Extrinsics --> AfterMandatory
+/// 	AfterMandatory --> onIdle
+///
+/// subgraph Optional
 /// 	OnRuntimeUpgrade
 /// end
 ///
-/// subgraph BeforeExtrinsics
+/// subgraph Mandatory
 /// 	OnInitialize
 /// end
 ///
+/// subgraph ExtrinsicsMandatory
+/// 	Inherent1 --> Inherent2
+/// end
+///
 /// subgraph Extrinsics
 /// 	direction TB
-/// 	Inherent1
-/// 	Inherent2
-/// 	Extrinsic1
-/// 	Extrinsic2
-///
-/// 	Inherent1 --> Inherent2
-/// 	Inherent2 --> Extrinsic1
 /// 	Extrinsic1 --> Extrinsic2
 /// end
 ///
-/// subgraph AfterExtrinsics
-/// 	OnIdle
+/// subgraph AfterMandatory
 /// 	OnFinalize
-///
-/// 	OnIdle --> OnFinalize
 /// end
 /// ```
 ///
@@ -466,6 +465,8 @@ pub trait Hooks<BlockNumber> {
 	///
 	/// Is not guaranteed to execute in a block and should therefore only be used in no-deadline
 	/// scenarios.
+	///
+	/// This is the non-mandatory version of [`Hooks::on_initialize`].
 	fn on_poll(_n: BlockNumber, _weight: &mut WeightMeter) {}
 
 	/// Hook executed when a code change (aka. a "runtime upgrade") is detected by the FRAME
diff --git a/substrate/frame/support/src/traits/storage.rs b/substrate/frame/support/src/traits/storage.rs
index 9e467aea4220dd7296a3ccad8236f122ff39e7d8..875ff56bea19e3c9f5770365833092da58fca6f4 100644
--- a/substrate/frame/support/src/traits/storage.rs
+++ b/substrate/frame/support/src/traits/storage.rs
@@ -194,7 +194,7 @@ where
 }
 
 /// Some sort of cost taken from account temporarily in order to offset the cost to the chain of
-/// holding some data [`Footprint`] in state.
+/// holding some data `Footprint` (e.g. [`Footprint`]) in state.
 ///
 /// The cost may be increased, reduced or dropped entirely as the footprint changes.
 ///
@@ -206,16 +206,20 @@ where
 /// treated as one*. Don't type to duplicate it, and remember to drop it when you're done with
 /// it.
 #[must_use]
-pub trait Consideration<AccountId>: Member + FullCodec + TypeInfo + MaxEncodedLen {
+pub trait Consideration<AccountId, Footprint>:
+	Member + FullCodec + TypeInfo + MaxEncodedLen
+{
 	/// Create a ticket for the `new` footprint attributable to `who`. This ticket *must* ultimately
-	/// be consumed through `update` or `drop` once the footprint changes or is removed.
-	fn new(who: &AccountId, new: Footprint) -> Result<Self, DispatchError>;
+	/// be consumed through `update` or `drop` once the footprint changes or is removed. `None`
+	/// implies no cost for a given footprint.
+	fn new(who: &AccountId, new: Footprint) -> Result<Option<Self>, DispatchError>;
 
 	/// Optionally consume an old ticket and alter the footprint, enforcing the new cost to `who`
-	/// and returning the new ticket (or an error if there was an issue).
+	/// and returning the new ticket (or an error if there was an issue). `None` implies no cost for
+	/// a given footprint.
 	///
 	/// For creating tickets and dropping them, you can use the simpler `new` and `drop` instead.
-	fn update(self, who: &AccountId, new: Footprint) -> Result<Self, DispatchError>;
+	fn update(self, who: &AccountId, new: Footprint) -> Result<Option<Self>, DispatchError>;
 
 	/// Consume a ticket for some `old` footprint attributable to `who` which should now been freed.
 	fn drop(self, who: &AccountId) -> Result<(), DispatchError>;
@@ -230,12 +234,12 @@ pub trait Consideration<AccountId>: Member + FullCodec + TypeInfo + MaxEncodedLe
 	}
 }
 
-impl<A> Consideration<A> for () {
-	fn new(_: &A, _: Footprint) -> Result<Self, DispatchError> {
-		Ok(())
+impl<A, F> Consideration<A, F> for () {
+	fn new(_: &A, _: F) -> Result<Option<Self>, DispatchError> {
+		Ok(Some(()))
 	}
-	fn update(self, _: &A, _: Footprint) -> Result<(), DispatchError> {
-		Ok(())
+	fn update(self, _: &A, _: F) -> Result<Option<Self>, DispatchError> {
+		Ok(Some(()))
 	}
 	fn drop(self, _: &A) -> Result<(), DispatchError> {
 		Ok(())
diff --git a/substrate/frame/support/src/traits/tokens.rs b/substrate/frame/support/src/traits/tokens.rs
index 8842b20580181f81e4377a0d9f6223e59a6fee6a..138703cf1d135ef50a228e008fae3d37e0c972a1 100644
--- a/substrate/frame/support/src/traits/tokens.rs
+++ b/substrate/frame/support/src/traits/tokens.rs
@@ -30,8 +30,8 @@ pub use imbalance::Imbalance;
 pub mod pay;
 pub use misc::{
 	AssetId, Balance, BalanceStatus, ConversionFromAssetBalance, ConversionToAssetBalance,
-	ConvertRank, DepositConsequence, ExistenceRequirement, Fortitude, GetSalary, Locker, Precision,
-	Preservation, Provenance, Restriction, UnityAssetBalanceConversion, UnityOrOuterConversion,
-	WithdrawConsequence, WithdrawReasons,
+	ConvertRank, DepositConsequence, ExistenceRequirement, Fortitude, GetSalary, IdAmount, Locker,
+	Precision, Preservation, Provenance, Restriction, UnityAssetBalanceConversion,
+	UnityOrOuterConversion, WithdrawConsequence, WithdrawReasons,
 };
 pub use pay::{Pay, PayFromAccount, PaymentStatus};
diff --git a/substrate/frame/support/src/traits/tokens/fungible/mod.rs b/substrate/frame/support/src/traits/tokens/fungible/mod.rs
index 01c3b9dfe46a562ec5c0692fd51ecc0e53f83872..b8e985648983e0fe6257e4f676f39b6a34847533 100644
--- a/substrate/frame/support/src/traits/tokens/fungible/mod.rs
+++ b/substrate/frame/support/src/traits/tokens/fungible/mod.rs
@@ -198,31 +198,40 @@ use crate::{
 	MaxEncodedLen,
 	RuntimeDebugNoBound,
 )]
-#[scale_info(skip_type_params(A, F, R, D))]
+#[scale_info(skip_type_params(A, F, R, D, Fp))]
 #[codec(mel_bound())]
-pub struct FreezeConsideration<A, F, R, D>(F::Balance, PhantomData<fn() -> (A, R, D)>)
+pub struct FreezeConsideration<A, F, R, D, Fp>(F::Balance, PhantomData<fn() -> (A, R, D, Fp)>)
 where
 	F: MutateFreeze<A>;
 impl<
 		A: 'static,
 		F: 'static + MutateFreeze<A>,
 		R: 'static + Get<F::Id>,
-		D: 'static + Convert<Footprint, F::Balance>,
-	> Consideration<A> for FreezeConsideration<A, F, R, D>
+		D: 'static + Convert<Fp, F::Balance>,
+		Fp: 'static,
+	> Consideration<A, Fp> for FreezeConsideration<A, F, R, D, Fp>
 {
-	fn new(who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
+	fn new(who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
 		let new = D::convert(footprint);
-		F::increase_frozen(&R::get(), who, new)?;
-		Ok(Self(new, PhantomData))
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			F::increase_frozen(&R::get(), who, new)?;
+			Ok(Some(Self(new, PhantomData)))
+		}
 	}
-	fn update(self, who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
+	fn update(self, who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
 		let new = D::convert(footprint);
 		if self.0 > new {
 			F::decrease_frozen(&R::get(), who, self.0 - new)?;
 		} else if new > self.0 {
 			F::increase_frozen(&R::get(), who, new - self.0)?;
 		}
-		Ok(Self(new, PhantomData))
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			Ok(Some(Self(new, PhantomData)))
+		}
 	}
 	fn drop(self, who: &A) -> Result<(), DispatchError> {
 		F::decrease_frozen(&R::get(), who, self.0).map(|_| ())
@@ -240,31 +249,43 @@ impl<
 	MaxEncodedLen,
 	RuntimeDebugNoBound,
 )]
-#[scale_info(skip_type_params(A, F, R, D))]
+#[scale_info(skip_type_params(A, F, R, D, Fp))]
 #[codec(mel_bound())]
-pub struct HoldConsideration<A, F, R, D>(F::Balance, PhantomData<fn() -> (A, R, D)>)
+pub struct HoldConsideration<A, F, R, D, Fp = Footprint>(
+	F::Balance,
+	PhantomData<fn() -> (A, R, D, Fp)>,
+)
 where
 	F: MutateHold<A>;
 impl<
 		A: 'static,
 		F: 'static + MutateHold<A>,
 		R: 'static + Get<F::Reason>,
-		D: 'static + Convert<Footprint, F::Balance>,
-	> Consideration<A> for HoldConsideration<A, F, R, D>
+		D: 'static + Convert<Fp, F::Balance>,
+		Fp: 'static,
+	> Consideration<A, Fp> for HoldConsideration<A, F, R, D, Fp>
 {
-	fn new(who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
+	fn new(who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
 		let new = D::convert(footprint);
-		F::hold(&R::get(), who, new)?;
-		Ok(Self(new, PhantomData))
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			F::hold(&R::get(), who, new)?;
+			Ok(Some(Self(new, PhantomData)))
+		}
 	}
-	fn update(self, who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
+	fn update(self, who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
 		let new = D::convert(footprint);
 		if self.0 > new {
 			F::release(&R::get(), who, self.0 - new, BestEffort)?;
 		} else if new > self.0 {
 			F::hold(&R::get(), who, new - self.0)?;
 		}
-		Ok(Self(new, PhantomData))
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			Ok(Some(Self(new, PhantomData)))
+		}
 	}
 	fn drop(self, who: &A) -> Result<(), DispatchError> {
 		F::release(&R::get(), who, self.0, BestEffort).map(|_| ())
@@ -291,22 +312,34 @@ impl<
 	MaxEncodedLen,
 	RuntimeDebugNoBound,
 )]
-#[scale_info(skip_type_params(A, Fx, Rx, D))]
+#[scale_info(skip_type_params(A, Fx, Rx, D, Fp))]
 #[codec(mel_bound())]
-pub struct LoneFreezeConsideration<A, Fx, Rx, D>(PhantomData<fn() -> (A, Fx, Rx, D)>);
+pub struct LoneFreezeConsideration<A, Fx, Rx, D, Fp>(PhantomData<fn() -> (A, Fx, Rx, D, Fp)>);
 impl<
 		A: 'static,
 		Fx: 'static + MutateFreeze<A>,
 		Rx: 'static + Get<Fx::Id>,
-		D: 'static + Convert<Footprint, Fx::Balance>,
-	> Consideration<A> for LoneFreezeConsideration<A, Fx, Rx, D>
+		D: 'static + Convert<Fp, Fx::Balance>,
+		Fp: 'static,
+	> Consideration<A, Fp> for LoneFreezeConsideration<A, Fx, Rx, D, Fp>
 {
-	fn new(who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
+	fn new(who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
 		ensure!(Fx::balance_frozen(&Rx::get(), who).is_zero(), DispatchError::Unavailable);
-		Fx::set_frozen(&Rx::get(), who, D::convert(footprint), Polite).map(|_| Self(PhantomData))
+		let new = D::convert(footprint);
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			Fx::set_frozen(&Rx::get(), who, new, Polite).map(|_| Some(Self(PhantomData)))
+		}
 	}
-	fn update(self, who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
-		Fx::set_frozen(&Rx::get(), who, D::convert(footprint), Polite).map(|_| Self(PhantomData))
+	fn update(self, who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
+		let new = D::convert(footprint);
+		let _ = Fx::set_frozen(&Rx::get(), who, new, Polite)?;
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			Ok(Some(Self(PhantomData)))
+		}
 	}
 	fn drop(self, who: &A) -> Result<(), DispatchError> {
 		Fx::thaw(&Rx::get(), who).map(|_| ())
@@ -330,22 +363,34 @@ impl<
 	MaxEncodedLen,
 	RuntimeDebugNoBound,
 )]
-#[scale_info(skip_type_params(A, Fx, Rx, D))]
+#[scale_info(skip_type_params(A, Fx, Rx, D, Fp))]
 #[codec(mel_bound())]
-pub struct LoneHoldConsideration<A, Fx, Rx, D>(PhantomData<fn() -> (A, Fx, Rx, D)>);
+pub struct LoneHoldConsideration<A, Fx, Rx, D, Fp>(PhantomData<fn() -> (A, Fx, Rx, D, Fp)>);
 impl<
 		A: 'static,
 		F: 'static + MutateHold<A>,
 		R: 'static + Get<F::Reason>,
-		D: 'static + Convert<Footprint, F::Balance>,
-	> Consideration<A> for LoneHoldConsideration<A, F, R, D>
+		D: 'static + Convert<Fp, F::Balance>,
+		Fp: 'static,
+	> Consideration<A, Fp> for LoneHoldConsideration<A, F, R, D, Fp>
 {
-	fn new(who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
+	fn new(who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
 		ensure!(F::balance_on_hold(&R::get(), who).is_zero(), DispatchError::Unavailable);
-		F::set_on_hold(&R::get(), who, D::convert(footprint)).map(|_| Self(PhantomData))
+		let new = D::convert(footprint);
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			F::set_on_hold(&R::get(), who, new).map(|_| Some(Self(PhantomData)))
+		}
 	}
-	fn update(self, who: &A, footprint: Footprint) -> Result<Self, DispatchError> {
-		F::set_on_hold(&R::get(), who, D::convert(footprint)).map(|_| Self(PhantomData))
+	fn update(self, who: &A, footprint: Fp) -> Result<Option<Self>, DispatchError> {
+		let new = D::convert(footprint);
+		let _ = F::set_on_hold(&R::get(), who, new)?;
+		if new.is_zero() {
+			Ok(None)
+		} else {
+			Ok(Some(Self(PhantomData)))
+		}
 	}
 	fn drop(self, who: &A) -> Result<(), DispatchError> {
 		F::release_all(&R::get(), who, BestEffort).map(|_| ())
diff --git a/substrate/frame/support/src/traits/tokens/misc.rs b/substrate/frame/support/src/traits/tokens/misc.rs
index 424acb1d550b15b69582d004e2e466e65e6a9b3f..e1ff1e058ae7aabd8ce9e0725b51f292c406a1a5 100644
--- a/substrate/frame/support/src/traits/tokens/misc.rs
+++ b/substrate/frame/support/src/traits/tokens/misc.rs
@@ -17,7 +17,7 @@
 
 //! Miscellaneous types.
 
-use crate::traits::Contains;
+use crate::{traits::Contains, TypeInfo};
 use codec::{Decode, Encode, FullCodec, MaxEncodedLen};
 use sp_arithmetic::traits::{AtLeast32BitUnsigned, Zero};
 use sp_core::RuntimeDebug;
@@ -357,3 +357,12 @@ impl<A, R, B, C: Convert<R, B>> GetSalary<R, A, B> for ConvertRank<C> {
 		C::convert(rank)
 	}
 }
+
+/// An identifier and balance.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct IdAmount<Id, Balance> {
+	/// An identifier for this item.
+	pub id: Id,
+	/// Some amount for this item.
+	pub amount: Balance,
+}
diff --git a/substrate/frame/support/test/compile_pass/Cargo.toml b/substrate/frame/support/test/compile_pass/Cargo.toml
index 37c069247e1875b547baa047c71a7895c686abe6..d6e0c66261a993ba70413d89d70dabc107177e1d 100644
--- a/substrate/frame/support/test/compile_pass/Cargo.toml
+++ b/substrate/frame/support/test/compile_pass/Cargo.toml
@@ -17,8 +17,8 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
-renamed-frame-support = { package = "frame-support", path = "../..", default-features = false }
-renamed-frame-system = { package = "frame-system", path = "../../../system", default-features = false }
+frame-support = { path = "../..", default-features = false }
+frame-system = { path = "../../../system", default-features = false }
 sp-core = { path = "../../../../primitives/core", default-features = false }
 sp-runtime = { path = "../../../../primitives/runtime", default-features = false }
 sp-version = { path = "../../../../primitives/version", default-features = false }
@@ -27,8 +27,8 @@ sp-version = { path = "../../../../primitives/version", default-features = false
 default = ["std"]
 std = [
 	"codec/std",
-	"renamed-frame-support/std",
-	"renamed-frame-system/std",
+	"frame-support/std",
+	"frame-system/std",
 	"scale-info/std",
 	"sp-core/std",
 	"sp-runtime/std",
diff --git a/substrate/frame/support/test/compile_pass/src/lib.rs b/substrate/frame/support/test/compile_pass/src/lib.rs
index 07d2f7d9ecdbe803139f6017d71f06bc278adc6a..37af683fbc7f239c3481ee5e9b368902d363aff6 100644
--- a/substrate/frame/support/test/compile_pass/src/lib.rs
+++ b/substrate/frame/support/test/compile_pass/src/lib.rs
@@ -21,7 +21,7 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use renamed_frame_support::{
+use frame_support::{
 	construct_runtime, derive_impl, parameter_types,
 	traits::{ConstU16, ConstU32, ConstU64, Everything},
 };
@@ -51,8 +51,8 @@ parameter_types! {
 	pub const Version: RuntimeVersion = VERSION;
 }
 
-#[derive_impl(renamed_frame_system::config_preludes::TestDefaultConfig)]
-impl renamed_frame_system::Config for Runtime {
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Runtime {
 	type BaseCallFilter = Everything;
 	type BlockWeights = ();
 	type BlockLength = ();
@@ -84,6 +84,6 @@ pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Sign
 
 construct_runtime!(
 	pub enum Runtime {
-		System: renamed_frame_system,
+		System: frame_system,
 	}
 );
diff --git a/substrate/frame/support/test/tests/final_keys.rs b/substrate/frame/support/test/tests/final_keys.rs
index a777c20a1e98f7a38c4a4cc4dead81e5565b6ebc..64f56d5200354c8957d2d10915bc49d820e1c4cb 100644
--- a/substrate/frame/support/test/tests/final_keys.rs
+++ b/substrate/frame/support/test/tests/final_keys.rs
@@ -19,7 +19,7 @@ use codec::Encode;
 use frame_support::{derive_impl, storage::unhashed, StoragePrefixedMap};
 use frame_system::pallet_prelude::BlockNumberFor;
 
-use sp_core::{sr25519, ConstU32};
+use sp_core::sr25519;
 use sp_io::{
 	hashing::{blake2_128, twox_128, twox_64},
 	TestExternalities,
@@ -213,7 +213,6 @@ frame_support::construct_runtime!(
 impl frame_system::Config for Runtime {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU32<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/genesisconfig.rs b/substrate/frame/support/test/tests/genesisconfig.rs
index a82425cf6befe3c014543943ffb6a72e9f00770b..0673bcfdff3ca036d7be863ff1b169e3471ddb9e 100644
--- a/substrate/frame/support/test/tests/genesisconfig.rs
+++ b/substrate/frame/support/test/tests/genesisconfig.rs
@@ -17,7 +17,7 @@
 
 use frame_support::derive_impl;
 use frame_system::pallet_prelude::BlockNumberFor;
-use sp_core::{sr25519, ConstU32};
+use sp_core::sr25519;
 use sp_runtime::{
 	generic,
 	traits::{BlakeTwo256, Verify},
@@ -83,7 +83,6 @@ frame_support::construct_runtime!(
 impl frame_system::Config for Test {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU32<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/instance.rs b/substrate/frame/support/test/tests/instance.rs
index 332f5725e055eb2aa9ca70dff987f021a76d41ba..30b8338bc5c7052a6a50474cd44e46a7202ed77e 100644
--- a/substrate/frame/support/test/tests/instance.rs
+++ b/substrate/frame/support/test/tests/instance.rs
@@ -293,7 +293,6 @@ frame_support::construct_runtime!(
 impl frame_system::Config for Runtime {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU32<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/issue2219.rs b/substrate/frame/support/test/tests/issue2219.rs
index 1542c4a6c434cec98547c533ba3f3530a5aff853..20c2773406ff111ebd03d08a89924ddf30cccdba 100644
--- a/substrate/frame/support/test/tests/issue2219.rs
+++ b/substrate/frame/support/test/tests/issue2219.rs
@@ -165,7 +165,6 @@ pub type Block = generic::Block<Header, UncheckedExtrinsic>;
 impl frame_system::Config for Runtime {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU64<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/origin.rs b/substrate/frame/support/test/tests/origin.rs
index a25c575cc5177a4511dec8a8b24918ffde6da8d3..4f14bda184c867b54aa10246a995943835abf375 100644
--- a/substrate/frame/support/test/tests/origin.rs
+++ b/substrate/frame/support/test/tests/origin.rs
@@ -23,7 +23,6 @@ use frame_support::{
 	derive_impl,
 	traits::{Contains, OriginTrait},
 };
-use sp_core::ConstU32;
 use sp_runtime::{generic, traits::BlakeTwo256};
 
 mod nested {
@@ -174,7 +173,6 @@ frame_support::construct_runtime!(
 impl frame_system::Config for RuntimeOriginTest {
 	type BaseCallFilter = BaseCallFilter;
 	type Block = Block;
-	type BlockHashCount = ConstU32<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/pallet.rs b/substrate/frame/support/test/tests/pallet.rs
index f41e606ad7c3e927e9719afccde3d5e0266509e0..c441d4c371af0926a0508025ae5473c77fb98346 100644
--- a/substrate/frame/support/test/tests/pallet.rs
+++ b/substrate/frame/support/test/tests/pallet.rs
@@ -705,7 +705,6 @@ impl frame_system::Config for Runtime {
 	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU32<250>;
 	type BlockWeights = ();
 	type BlockLength = ();
 	type DbWeight = ();
diff --git a/substrate/frame/support/test/tests/pallet_instance.rs b/substrate/frame/support/test/tests/pallet_instance.rs
index c79cdf93e97dc5a2f257ab9ba62a5d26e078b53f..dfe4caa476d3b9e1fa2a1024adb48eea5cdf9be9 100644
--- a/substrate/frame/support/test/tests/pallet_instance.rs
+++ b/substrate/frame/support/test/tests/pallet_instance.rs
@@ -308,7 +308,6 @@ impl frame_system::Config for Runtime {
 	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU32<250>;
 	type BlockWeights = ();
 	type BlockLength = ();
 	type DbWeight = ();
diff --git a/substrate/frame/support/test/tests/pallet_outer_enums_explicit.rs b/substrate/frame/support/test/tests/pallet_outer_enums_explicit.rs
index 6c71b544426512c54a4320452204b0a4b62e7764..326f3530e26ecc75c30420f5e1f4575f381fbf08 100644
--- a/substrate/frame/support/test/tests/pallet_outer_enums_explicit.rs
+++ b/substrate/frame/support/test/tests/pallet_outer_enums_explicit.rs
@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use frame_support::{derive_impl, traits::ConstU32};
+use frame_support::derive_impl;
 
 mod common;
 
@@ -29,7 +29,6 @@ pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, Runti
 impl frame_system::Config for Runtime {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU32<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/pallet_outer_enums_implicit.rs b/substrate/frame/support/test/tests/pallet_outer_enums_implicit.rs
index 79828119742c106763b97096ffaed85acf7381da..4149c4880cca29585d5d4dc45ec190f34e90d858 100644
--- a/substrate/frame/support/test/tests/pallet_outer_enums_implicit.rs
+++ b/substrate/frame/support/test/tests/pallet_outer_enums_implicit.rs
@@ -15,7 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use frame_support::{derive_impl, traits::ConstU32};
+use frame_support::derive_impl;
 
 mod common;
 
@@ -29,7 +29,6 @@ pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, Runti
 impl frame_system::Config for Runtime {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU32<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/dev_mode_valid.rs b/substrate/frame/support/test/tests/pallet_ui/pass/dev_mode_valid.rs
index e4ea094d0692e2f39167da014e3c3185d997ac08..3386632c13a2af834651d765aecfa723c1d4d5f9 100644
--- a/substrate/frame/support/test/tests/pallet_ui/pass/dev_mode_valid.rs
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/dev_mode_valid.rs
@@ -82,7 +82,6 @@ impl frame_system::Config for Runtime {
 	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU32<250>;
 	type BlockWeights = ();
 	type BlockLength = ();
 	type DbWeight = ();
diff --git a/substrate/frame/support/test/tests/runtime.rs b/substrate/frame/support/test/tests/runtime.rs
index 7c2a8139a1345a4903766970a13bbf955aeef7c8..1f4d9110a24fc4e8f18fec0f1d7e2b714f920fa4 100644
--- a/substrate/frame/support/test/tests/runtime.rs
+++ b/substrate/frame/support/test/tests/runtime.rs
@@ -27,7 +27,7 @@ use frame_support::{
 };
 use frame_system::limits::{BlockLength, BlockWeights};
 use scale_info::TypeInfo;
-use sp_core::{sr25519, ConstU64};
+use sp_core::sr25519;
 use sp_runtime::{
 	generic,
 	traits::{BlakeTwo256, ValidateUnsigned, Verify},
@@ -351,7 +351,6 @@ impl frame_system::Config for Runtime {
 	type PalletInfo = PalletInfo;
 	type OnSetCode = ();
 	type Block = Block;
-	type BlockHashCount = ConstU64<10>;
 }
 
 impl module1::Config<module1::Instance1> for Runtime {
diff --git a/substrate/frame/support/test/tests/runtime_legacy_ordering.rs b/substrate/frame/support/test/tests/runtime_legacy_ordering.rs
index 4c7012dca14979f0ed7f560bdc339146a676caa3..6330a138e2f2a66a5b763ecd57d1c742fa092465 100644
--- a/substrate/frame/support/test/tests/runtime_legacy_ordering.rs
+++ b/substrate/frame/support/test/tests/runtime_legacy_ordering.rs
@@ -27,7 +27,7 @@ use frame_support::{
 };
 use frame_system::limits::{BlockLength, BlockWeights};
 use scale_info::TypeInfo;
-use sp_core::{sr25519, ConstU64};
+use sp_core::sr25519;
 use sp_runtime::{
 	generic,
 	traits::{BlakeTwo256, ValidateUnsigned, Verify},
@@ -340,7 +340,7 @@ mod runtime {
 	pub type Module1_9 = module1<Instance9>;
 }
 
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
 	type AccountId = AccountId;
 	type Lookup = sp_runtime::traits::IdentityLookup<AccountId>;
@@ -351,7 +351,6 @@ impl frame_system::Config for Runtime {
 	type PalletInfo = PalletInfo;
 	type OnSetCode = ();
 	type Block = Block;
-	type BlockHashCount = ConstU64<10>;
 }
 
 impl module1::Config<module1::Instance1> for Runtime {
diff --git a/substrate/frame/support/test/tests/runtime_metadata.rs b/substrate/frame/support/test/tests/runtime_metadata.rs
index 819ec176d2b13c3fb5c90290339ef328a4c523ff..48e4d975eb083ec38baf6521cac1891b1e5e3d82 100644
--- a/substrate/frame/support/test/tests/runtime_metadata.rs
+++ b/substrate/frame/support/test/tests/runtime_metadata.rs
@@ -42,7 +42,6 @@ impl frame_system::Config for Runtime {
 	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU32<250>;
 	type Version = ();
 	type PalletInfo = PalletInfo;
 	type AccountData = ();
diff --git a/substrate/frame/support/test/tests/runtime_ui/missing_pallet_index.rs b/substrate/frame/support/test/tests/runtime_ui/missing_pallet_index.rs
new file mode 100644
index 0000000000000000000000000000000000000000..469a7833e5afce4c3e8b2afda124ce92a05df43e
--- /dev/null
+++ b/substrate/frame/support/test/tests/runtime_ui/missing_pallet_index.rs
@@ -0,0 +1,27 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#[frame_support::runtime]
+mod runtime {
+    #[runtime::runtime]
+    #[runtime::derive(RuntimeCall)]
+    pub struct Runtime;
+
+    pub type System = frame_system;
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/runtime_ui/missing_pallet_index.stderr b/substrate/frame/support/test/tests/runtime_ui/missing_pallet_index.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..a2cbaa48199d915cef506af495751986e0509874
--- /dev/null
+++ b/substrate/frame/support/test/tests/runtime_ui/missing_pallet_index.stderr
@@ -0,0 +1,5 @@
+error: Missing pallet index for pallet declaration. Please add `#[runtime::pallet_index(...)]`
+  --> tests/runtime_ui/missing_pallet_index.rs:24:5
+   |
+24 |     pub type System = frame_system;
+   |     ^^^
diff --git a/substrate/frame/support/test/tests/storage_layers.rs b/substrate/frame/support/test/tests/storage_layers.rs
index caa125153e9dc597f8ca859e2e5dd6ac16618992..0e8ef668531816c736cf4edb6807b612fcfe85b5 100644
--- a/substrate/frame/support/test/tests/storage_layers.rs
+++ b/substrate/frame/support/test/tests/storage_layers.rs
@@ -78,7 +78,6 @@ impl frame_system::Config for Runtime {
 	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
 	type Block = Block;
 	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU32<250>;
 	type DbWeight = ();
 	type Version = ();
 	type PalletInfo = PalletInfo;
diff --git a/substrate/frame/support/test/tests/storage_transaction.rs b/substrate/frame/support/test/tests/storage_transaction.rs
index a5bbfd24ab09a8084f58ad47e342174454133ef2..7f66a43b9afd735166847e2eb9c320a220458079 100644
--- a/substrate/frame/support/test/tests/storage_transaction.rs
+++ b/substrate/frame/support/test/tests/storage_transaction.rs
@@ -24,7 +24,7 @@ use frame_support::{
 	storage::{with_transaction, TransactionOutcome::*},
 	transactional,
 };
-use sp_core::{sr25519, ConstU32};
+use sp_core::sr25519;
 use sp_io::TestExternalities;
 use sp_runtime::{
 	generic,
@@ -91,7 +91,6 @@ frame_support::construct_runtime!(
 impl frame_system::Config for Runtime {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU32<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/support/test/tests/versioned_migration.rs b/substrate/frame/support/test/tests/versioned_migration.rs
index e7d146940cb92f31020e8b27fe014983f50396f0..c83dd6b71de9b3c72ee8c3f9b00cd81fecb0dfde 100644
--- a/substrate/frame/support/test/tests/versioned_migration.rs
+++ b/substrate/frame/support/test/tests/versioned_migration.rs
@@ -27,7 +27,6 @@ use frame_support::{
 	weights::constants::RocksDbWeight,
 };
 use frame_system::Config;
-use sp_core::ConstU64;
 use sp_runtime::BuildStorage;
 
 type Block = frame_system::mocking::MockBlock<Test>;
@@ -75,7 +74,6 @@ construct_runtime!(
 impl frame_system::Config for Test {
 	type BaseCallFilter = frame_support::traits::Everything;
 	type Block = Block;
-	type BlockHashCount = ConstU64<10>;
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeEvent = RuntimeEvent;
diff --git a/substrate/frame/system/benches/bench.rs b/substrate/frame/system/benches/bench.rs
index 87c5581b2a3409f511f0a8f83a7c7aeae7e7b2c6..1b0f459c9792fb054cfe28ae21797856f6ec941d 100644
--- a/substrate/frame/system/benches/bench.rs
+++ b/substrate/frame/system/benches/bench.rs
@@ -16,15 +16,8 @@
 // limitations under the License.
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use frame_support::{
-	derive_impl,
-	traits::{ConstU32, ConstU64},
-};
-use sp_core::H256;
-use sp_runtime::{
-	traits::{BlakeTwo256, IdentityLookup},
-	BuildStorage, Perbill,
-};
+use frame_support::derive_impl;
+use sp_runtime::{BuildStorage, Perbill};
 #[frame_support::pallet]
 mod module {
 	use frame_support::pallet_prelude::*;
@@ -62,29 +55,8 @@ frame_support::parameter_types! {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = BlockLength;
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
 	type Nonce = u64;
-	type RuntimeCall = RuntimeCall;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = ();
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
 }
 
 impl module::Config for Runtime {
diff --git a/substrate/frame/system/benchmarking/src/mock.rs b/substrate/frame/system/benchmarking/src/mock.rs
index 39a64ff6177c38bee487fde66cbf4f7b0df77117..42e4aa0eaf4b70b930f16da4145f62a8137cc883 100644
--- a/substrate/frame/system/benchmarking/src/mock.rs
+++ b/substrate/frame/system/benchmarking/src/mock.rs
@@ -21,10 +21,7 @@
 
 use codec::Encode;
 use frame_support::derive_impl;
-use sp_runtime::{traits::IdentityLookup, BuildStorage};
-
-type AccountId = u64;
-type Nonce = u32;
+use sp_runtime::BuildStorage;
 
 type Block = frame_system::mocking::MockBlock<Test>;
 
@@ -37,29 +34,7 @@ frame_support::construct_runtime!(
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type Nonce = Nonce;
-	type RuntimeCall = RuntimeCall;
-	type Hash = sp_core::H256;
-	type Hashing = ::sp_runtime::traits::BlakeTwo256;
-	type AccountId = AccountId;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = ();
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
 impl crate::Config for Test {}
diff --git a/substrate/frame/system/rpc/runtime-api/Cargo.toml b/substrate/frame/system/rpc/runtime-api/Cargo.toml
index b134cc3b617308265222d9dec6669dbbacf7f566..8b71ca2a13952d4aa1bf983a30d17d3126189524 100644
--- a/substrate/frame/system/rpc/runtime-api/Cargo.toml
+++ b/substrate/frame/system/rpc/runtime-api/Cargo.toml
@@ -18,6 +18,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
 sp-api = { path = "../../../../primitives/api", default-features = false }
+docify = "0.2.0"
 
 [features]
 default = ["std"]
diff --git a/substrate/frame/system/rpc/runtime-api/src/lib.rs b/substrate/frame/system/rpc/runtime-api/src/lib.rs
index f59988d818f07d716b153839c072513a2a6ad746..67adeb5cb9da8f9decd4bd1d876fd87b958d1ba0 100644
--- a/substrate/frame/system/rpc/runtime-api/src/lib.rs
+++ b/substrate/frame/system/rpc/runtime-api/src/lib.rs
@@ -23,6 +23,7 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+#[docify::export(AccountNonceApi)]
 sp_api::decl_runtime_apis! {
 	/// The API to query account nonce.
 	pub trait AccountNonceApi<AccountId, Nonce> where
diff --git a/substrate/frame/system/src/extensions/check_weight.rs b/substrate/frame/system/src/extensions/check_weight.rs
index 061d543f8c311140ac692c183d08c462d0452d89..d4705f200efddacd18149651acf8ed431ca722a8 100644
--- a/substrate/frame/system/src/extensions/check_weight.rs
+++ b/substrate/frame/system/src/extensions/check_weight.rs
@@ -106,8 +106,7 @@ where
 		let all_weight = Pallet::<T>::block_weight();
 		let maximum_weight = T::BlockWeights::get();
 		let next_weight =
-			calculate_consumed_weight::<T::RuntimeCall>(&maximum_weight, all_weight, info)?;
-		check_combined_proof_size(&maximum_weight, next_len, &next_weight)?;
+			calculate_consumed_weight::<T::RuntimeCall>(&maximum_weight, all_weight, info, len)?;
 		Self::check_extrinsic_weight(info)?;
 
 		crate::AllExtrinsicsLen::<T>::put(next_len);
@@ -130,27 +129,6 @@ where
 	}
 }
 
-/// Check that the combined extrinsic length and proof size together do not exceed the PoV limit.
-pub fn check_combined_proof_size(
-	maximum_weight: &BlockWeights,
-	next_len: u32,
-	next_weight: &crate::ConsumedWeight,
-) -> Result<(), TransactionValidityError> {
-	// This extra check ensures that the extrinsic length does not push the
-	// PoV over the limit.
-	let total_pov_size = next_weight.total().proof_size().saturating_add(next_len as u64);
-	if total_pov_size > maximum_weight.max_block.proof_size() {
-		log::debug!(
-			target: LOG_TARGET,
-			"Extrinsic exceeds total pov size: {}kb, limit: {}kb",
-			total_pov_size as f64/1024.0,
-			maximum_weight.max_block.proof_size() as f64/1024.0
-		);
-		return Err(InvalidTransaction::ExhaustsResources.into())
-	}
-	Ok(())
-}
-
 /// Checks if the current extrinsic can fit into the block with respect to block weight limits.
 ///
 /// Upon successes, it returns the new block weight as a `Result`.
@@ -158,12 +136,16 @@ pub fn calculate_consumed_weight<Call>(
 	maximum_weight: &BlockWeights,
 	mut all_weight: crate::ConsumedWeight,
 	info: &DispatchInfoOf<Call>,
+	len: usize,
 ) -> Result<crate::ConsumedWeight, TransactionValidityError>
 where
 	Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
 {
-	let extrinsic_weight =
-		info.weight.saturating_add(maximum_weight.get(info.class).base_extrinsic);
+	// Also Consider extrinsic length as proof weight.
+	let extrinsic_weight = info
+		.weight
+		.saturating_add(maximum_weight.get(info.class).base_extrinsic)
+		.saturating_add(Weight::from_parts(0, len as u64));
 	let limit_per_class = maximum_weight.get(info.class);
 
 	// add the weight. If class is unlimited, use saturating add instead of checked one.
@@ -190,7 +172,7 @@ where
 				"Exceeded the per-class allowance.",
 			);
 
-			return Err(InvalidTransaction::ExhaustsResources.into())
+			return Err(InvalidTransaction::ExhaustsResources.into());
 		},
 		// There is no `max_total` limit (`None`),
 		// or we are below the limit.
@@ -208,7 +190,7 @@ where
 					"Total block weight is exceeded.",
 				);
 
-				return Err(InvalidTransaction::ExhaustsResources.into())
+				return Err(InvalidTransaction::ExhaustsResources.into());
 			},
 			// There is either no limit in reserved pool (`None`),
 			// or we are below the limit.
@@ -763,87 +745,115 @@ mod tests {
 			&maximum_weight,
 			all_weight.clone(),
 			&mandatory1,
+			0
 		));
 		assert_err!(
 			calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
 				&maximum_weight,
 				all_weight,
 				&mandatory2,
+				0
 			),
 			InvalidTransaction::ExhaustsResources
 		);
 	}
 
 	#[test]
-	fn maximum_proof_size_includes_length() {
+	fn proof_size_includes_length() {
 		let maximum_weight = BlockWeights::builder()
 			.base_block(Weight::zero())
 			.for_class(DispatchClass::non_mandatory(), |w| {
 				w.base_extrinsic = Weight::zero();
-				w.max_total = Some(Weight::from_parts(20, 10));
+				w.max_total = Some(Weight::from_parts(20, 1000));
 			})
 			.for_class(DispatchClass::Mandatory, |w| {
 				w.base_extrinsic = Weight::zero();
-				w.reserved = Some(Weight::from_parts(5, 10));
-				w.max_total = None;
+				w.max_total = Some(Weight::from_parts(20, 1000));
 			})
 			.build_or_panic();
+		let all_weight = crate::ConsumedWeight::new(|class| match class {
+			DispatchClass::Normal => Weight::from_parts(5, 0),
+			DispatchClass::Operational => Weight::from_parts(5, 0),
+			DispatchClass::Mandatory => Weight::from_parts(0, 0),
+		});
 
-		assert_eq!(maximum_weight.max_block, Weight::from_parts(20, 10));
+		let normal = DispatchInfo {
+			weight: Weight::from_parts(5, 0),
+			class: DispatchClass::Normal,
+			..Default::default()
+		};
 
-		// We have 10 reftime and 5 proof size left over.
-		let next_weight = crate::ConsumedWeight::new(|class| match class {
-			DispatchClass::Normal => Weight::from_parts(10, 5),
-			DispatchClass::Operational => Weight::from_parts(0, 0),
-			DispatchClass::Mandatory => Weight::zero(),
-		});
+		let mandatory = DispatchInfo {
+			weight: Weight::from_parts(5, 0),
+			class: DispatchClass::Mandatory,
+			..Default::default()
+		};
 
-		// Simple checks for the length
-		assert_ok!(check_combined_proof_size(&maximum_weight, 0, &next_weight));
-		assert_ok!(check_combined_proof_size(&maximum_weight, 5, &next_weight));
-		assert_err!(
-			check_combined_proof_size(&maximum_weight, 6, &next_weight),
-			InvalidTransaction::ExhaustsResources
+		// Using 0 length extrinsics.
+		let consumed = calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+			&maximum_weight,
+			all_weight.clone(),
+			&normal,
+			0,
+		)
+		.unwrap();
+
+		assert_eq!(consumed.total().saturating_sub(all_weight.total()), normal.weight);
+
+		let consumed = calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+			&maximum_weight,
+			all_weight.clone(),
+			&mandatory,
+			0,
+		)
+		.unwrap();
+		assert_eq!(consumed.total().saturating_sub(all_weight.total()), mandatory.weight);
+
+		// Using non zero length extrinsics.
+		let consumed = calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+			&maximum_weight,
+			all_weight.clone(),
+			&normal,
+			100,
+		)
+		.unwrap();
+		// Must account for the len in the proof size
+		assert_eq!(
+			consumed.total().saturating_sub(all_weight.total()),
+			normal.weight.add_proof_size(100)
 		);
 
-		// We have 10 reftime and 0 proof size left over.
-		let next_weight = crate::ConsumedWeight::new(|class| match class {
-			DispatchClass::Normal => Weight::from_parts(10, 10),
-			DispatchClass::Operational => Weight::from_parts(0, 0),
-			DispatchClass::Mandatory => Weight::zero(),
-		});
-		assert_ok!(check_combined_proof_size(&maximum_weight, 0, &next_weight));
-		assert_err!(
-			check_combined_proof_size(&maximum_weight, 1, &next_weight),
-			InvalidTransaction::ExhaustsResources
+		let consumed = calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+			&maximum_weight,
+			all_weight.clone(),
+			&mandatory,
+			100,
+		)
+		.unwrap();
+		// Must account for the len in the proof size
+		assert_eq!(
+			consumed.total().saturating_sub(all_weight.total()),
+			mandatory.weight.add_proof_size(100)
 		);
 
-		// We have 10 reftime and 2 proof size left over.
-		// Used weight is spread across dispatch classes this time.
-		let next_weight = crate::ConsumedWeight::new(|class| match class {
-			DispatchClass::Normal => Weight::from_parts(10, 5),
-			DispatchClass::Operational => Weight::from_parts(0, 3),
-			DispatchClass::Mandatory => Weight::zero(),
-		});
-		assert_ok!(check_combined_proof_size(&maximum_weight, 0, &next_weight));
-		assert_ok!(check_combined_proof_size(&maximum_weight, 2, &next_weight));
-		assert_err!(
-			check_combined_proof_size(&maximum_weight, 3, &next_weight),
-			InvalidTransaction::ExhaustsResources
+		// Using oversized zero length extrinsics.
+		let consumed = calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+			&maximum_weight,
+			all_weight.clone(),
+			&normal,
+			2000,
 		);
+		// errors out
+		assert_eq!(consumed, Err(InvalidTransaction::ExhaustsResources.into()));
 
-		// Ref time is over the limit. Should not happen, but we should make sure that it is
-		// ignored.
-		let next_weight = crate::ConsumedWeight::new(|class| match class {
-			DispatchClass::Normal => Weight::from_parts(30, 5),
-			DispatchClass::Operational => Weight::from_parts(0, 0),
-			DispatchClass::Mandatory => Weight::zero(),
-		});
-		assert_ok!(check_combined_proof_size(&maximum_weight, 0, &next_weight));
-		assert_ok!(check_combined_proof_size(&maximum_weight, 5, &next_weight));
-		assert_err!(
-			check_combined_proof_size(&maximum_weight, 6, &next_weight),
-			InvalidTransaction::ExhaustsResources
+		// Using oversized zero length extrinsics.
+		let consumed = calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+			&maximum_weight,
+			all_weight.clone(),
+			&mandatory,
+			2000,
 		);
+		// errors out
+		assert_eq!(consumed, Err(InvalidTransaction::ExhaustsResources.into()));
 	}
 }
diff --git a/substrate/frame/system/src/lib.rs b/substrate/frame/system/src/lib.rs
index 7ed954d83aa814564f0c534951511ba23ce53b12..84d00a1e917ec033d4fe534f932236db76569625 100644
--- a/substrate/frame/system/src/lib.rs
+++ b/substrate/frame/system/src/lib.rs
@@ -262,7 +262,19 @@ pub mod pallet {
 	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].
 	pub mod config_preludes {
 		use super::{inject_runtime_type, DefaultConfig};
-		use frame_support::derive_impl;
+		use frame_support::{derive_impl, traits::Get};
+
+		/// A predefined adapter that covers `BlockNumberFor<T>` for `Config::Block::BlockNumber` of
+		/// the types `u32`, `u64`, and `u128`.
+		///
+		/// NOTE: Avoids overriding `BlockHashCount` when using `mocking::{MockBlock, MockBlockU32,
+		/// MockBlockU128}`.
+		pub struct TestBlockHashCount<C: Get<u32>>(sp_std::marker::PhantomData<C>);
+		impl<I: From<u32>, C: Get<u32>> Get<I> for TestBlockHashCount<C> {
+			fn get() -> I {
+				C::get().into()
+			}
+		}
 
 		/// Provides a viable default config that can be used with
 		/// [`derive_impl`](`frame_support::derive_impl`) to derive a testing pallet config
@@ -300,7 +312,7 @@ pub mod pallet {
 			#[inject_runtime_type]
 			type RuntimeTask = ();
 			type BaseCallFilter = frame_support::traits::Everything;
-			type BlockHashCount = frame_support::traits::ConstU64<10>;
+			type BlockHashCount = TestBlockHashCount<frame_support::traits::ConstU32<10>>;
 			type OnSetCode = ();
 			type SingleBlockMigrations = ();
 			type MultiBlockMigrator = ();
@@ -397,7 +409,7 @@ pub mod pallet {
 
 			/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
 			/// Using 256 as default.
-			type BlockHashCount = frame_support::traits::ConstU32<256>;
+			type BlockHashCount = TestBlockHashCount<frame_support::traits::ConstU32<256>>;
 
 			/// The set code logic, just the default since we're not a parachain.
 			type OnSetCode = ();
diff --git a/substrate/frame/timestamp/src/benchmarking.rs b/substrate/frame/timestamp/src/benchmarking.rs
index 82dfdfa8b312065aededecd7e81404c19403fe24..d8c27b4967af9a59a6a1711b8aa53726d4968fd2 100644
--- a/substrate/frame/timestamp/src/benchmarking.rs
+++ b/substrate/frame/timestamp/src/benchmarking.rs
@@ -25,7 +25,7 @@ use frame_support::{ensure, traits::OnFinalize};
 use frame_system::RawOrigin;
 use sp_storage::TrackedStorageKey;
 
-use crate::Pallet as Timestamp;
+use crate::{Now, Pallet as Timestamp};
 
 const MAX_TIME: u32 = 100;
 
@@ -42,7 +42,7 @@ benchmarks! {
 		});
 	}: _(RawOrigin::None, t.into())
 	verify {
-		ensure!(Timestamp::<T>::now() == t.into(), "Time was not set.");
+		ensure!(Now::<T>::get() == t.into(), "Time was not set.");
 	}
 
 	on_finalize {
diff --git a/substrate/frame/timestamp/src/lib.rs b/substrate/frame/timestamp/src/lib.rs
index 5269f17eca6b2151a787f91a1126c822aaf83879..6a22ab1cd5ef8fde0d94791e82750f46629a2340 100644
--- a/substrate/frame/timestamp/src/lib.rs
+++ b/substrate/frame/timestamp/src/lib.rs
@@ -202,7 +202,6 @@ pub mod pallet {
 
 	/// The current time for the current block.
 	#[pallet::storage]
-	#[pallet::getter(fn now)]
 	pub type Now<T: Config> = StorageValue<_, T::Moment, ValueQuery>;
 
 	/// Whether the timestamp has been updated in this block.
@@ -261,7 +260,7 @@ pub mod pallet {
 		pub fn set(origin: OriginFor<T>, #[pallet::compact] now: T::Moment) -> DispatchResult {
 			ensure_none(origin)?;
 			assert!(!DidUpdate::<T>::exists(), "Timestamp must be updated only once in the block");
-			let prev = Self::now();
+			let prev = Now::<T>::get();
 			assert!(
 				prev.is_zero() || now >= prev + T::MinimumPeriod::get(),
 				"Timestamp must increment by at least <MinimumPeriod> between sequential blocks"
@@ -296,7 +295,7 @@ pub mod pallet {
 				.expect("Timestamp inherent data must be provided");
 			let data = (*inherent_data).saturated_into::<T::Moment>();
 
-			let next_time = cmp::max(data, Self::now() + T::MinimumPeriod::get());
+			let next_time = cmp::max(data, Now::<T>::get() + T::MinimumPeriod::get());
 			Some(Call::set { now: next_time })
 		}
 
@@ -317,7 +316,7 @@ pub mod pallet {
 				.expect("Timestamp inherent data not correctly encoded")
 				.expect("Timestamp inherent data must be provided");
 
-			let minimum = (Self::now() + T::MinimumPeriod::get()).saturated_into::<u64>();
+			let minimum = (Now::<T>::get() + T::MinimumPeriod::get()).saturated_into::<u64>();
 			if t > *(data + MAX_TIMESTAMP_DRIFT_MILLIS) {
 				Err(InherentError::TooFarInFuture)
 			} else if t < minimum {
@@ -339,7 +338,7 @@ impl<T: Config> Pallet<T> {
 	/// NOTE: if this function is called prior to setting the timestamp,
 	/// it will return the timestamp of the previous block.
 	pub fn get() -> T::Moment {
-		Self::now()
+		Now::<T>::get()
 	}
 
 	/// Set the timestamp to something in particular. Only used for tests.
@@ -356,7 +355,7 @@ impl<T: Config> Time for Pallet<T> {
 	type Moment = T::Moment;
 
 	fn now() -> Self::Moment {
-		Self::now()
+		Now::<T>::get()
 	}
 }
 
@@ -367,7 +366,7 @@ impl<T: Config> UnixTime for Pallet<T> {
 	fn now() -> core::time::Duration {
 		// now is duration since unix epoch in millisecond as documented in
 		// `sp_timestamp::InherentDataProvider`.
-		let now = Self::now();
+		let now = Now::<T>::get();
 		sp_std::if_std! {
 			if now == T::Moment::zero() {
 				log::error!(
diff --git a/substrate/frame/timestamp/src/tests.rs b/substrate/frame/timestamp/src/tests.rs
index cc49d8a3296e831ae01fd60ab28c0cf7fafbf9b5..a83855561889f162c0787400e700ef6464fb854f 100644
--- a/substrate/frame/timestamp/src/tests.rs
+++ b/substrate/frame/timestamp/src/tests.rs
@@ -25,7 +25,7 @@ fn timestamp_works() {
 	new_test_ext().execute_with(|| {
 		crate::Now::<Test>::put(46);
 		assert_ok!(Timestamp::set(RuntimeOrigin::none(), 69));
-		assert_eq!(Timestamp::now(), 69);
+		assert_eq!(crate::Now::<Test>::get(), 69);
 		assert_eq!(Some(69), get_captured_moment());
 	});
 }
diff --git a/substrate/frame/tips/src/tests.rs b/substrate/frame/tips/src/tests.rs
index 78df3736815a11dcc8a766e6eb88c4972157a7b3..ad987cc6cd6636f61fa5989201d2369c02d19f6a 100644
--- a/substrate/frame/tips/src/tests.rs
+++ b/substrate/frame/tips/src/tests.rs
@@ -65,20 +65,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 parameter_types! {
 	static TenToFourteenTestValue: Vec<u128> = vec![10,11,12,13,14];
@@ -105,7 +94,6 @@ impl ContainsLengthBound for TenToFourteen {
 	}
 }
 parameter_types! {
-	pub const ProposalBond: Permill = Permill::from_percent(5);
 	pub const Burn: Permill = Permill::from_percent(50);
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
 	pub const TreasuryPalletId2: PalletId = PalletId(*b"py/trsr2");
@@ -120,9 +108,6 @@ impl pallet_treasury::Config for Test {
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = ();
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ConstU64<1>;
-	type ProposalBondMaximum = ();
 	type SpendPeriod = ConstU64<2>;
 	type Burn = Burn;
 	type BurnDestination = (); // Just gets burned.
@@ -147,9 +132,6 @@ impl pallet_treasury::Config<Instance1> for Test {
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = ();
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ConstU64<1>;
-	type ProposalBondMaximum = ();
 	type SpendPeriod = ConstU64<2>;
 	type Burn = Burn;
 	type BurnDestination = (); // Just gets burned.
diff --git a/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/mock.rs b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/mock.rs
index 9a2b22b817096916193db338df62269415ec7a52..3f8c7bc0ea34d297dcb8ace6cb25735d9e1592a6 100644
--- a/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/mock.rs
+++ b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/mock.rs
@@ -38,9 +38,8 @@ use frame_system as system;
 use frame_system::{EnsureRoot, EnsureSignedBy};
 use pallet_asset_conversion::{Ascending, Chain, WithFirstAsset};
 use pallet_transaction_payment::FungibleAdapter;
-use sp_core::H256;
 use sp_runtime::{
-	traits::{AccountIdConversion, BlakeTwo256, IdentityLookup, SaturatedConversion},
+	traits::{AccountIdConversion, IdentityLookup, SaturatedConversion},
 	Permill,
 };
 
@@ -87,49 +86,22 @@ parameter_types! {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
 	type BlockWeights = BlockWeights;
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
 	type Nonce = u64;
-	type RuntimeCall = RuntimeCall;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
 	type AccountId = AccountId;
 	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
 }
 
 parameter_types! {
 	pub const ExistentialDeposit: u64 = 10;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ConstU64<10>;
 	type AccountStore = System;
-	type MaxLocks = ();
-	type WeightInfo = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl WeightToFeeT for WeightToFee {
diff --git a/substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs b/substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs
index b04d4ffd9e0b794f56fd7be0219f8150f45e7078..e84df1e4eb91b67a1cdb1477a6f5eac9b1b5180f 100644
--- a/substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs
+++ b/substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs
@@ -29,8 +29,7 @@ use frame_support::{
 use frame_system as system;
 use frame_system::EnsureRoot;
 use pallet_transaction_payment::FungibleAdapter;
-use sp_core::H256;
-use sp_runtime::traits::{BlakeTwo256, ConvertInto, IdentityLookup, SaturatedConversion};
+use sp_runtime::traits::{ConvertInto, SaturatedConversion};
 
 type Block = frame_system::mocking::MockBlock<Runtime>;
 type Balance = u64;
@@ -73,49 +72,19 @@ parameter_types! {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
 	type BlockWeights = BlockWeights;
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type Nonce = u64;
-	type RuntimeCall = RuntimeCall;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = AccountId;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
 }
 
 parameter_types! {
 	pub const ExistentialDeposit: u64 = 10;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type Balance = Balance;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
 	type ExistentialDeposit = ConstU64<10>;
 	type AccountStore = System;
-	type MaxLocks = ();
-	type WeightInfo = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl WeightToFeeT for WeightToFee {
diff --git a/substrate/frame/transaction-payment/src/mock.rs b/substrate/frame/transaction-payment/src/mock.rs
index c1bb05ab5c7eb8e03c49e5f8d789276de296bba9..fa61572e9831f6487cb4c19a97737475776c55d1 100644
--- a/substrate/frame/transaction-payment/src/mock.rs
+++ b/substrate/frame/transaction-payment/src/mock.rs
@@ -17,15 +17,11 @@
 
 use super::*;
 use crate as pallet_transaction_payment;
-
-use sp_core::H256;
-use sp_runtime::traits::{BlakeTwo256, IdentityLookup};
-
 use frame_support::{
 	derive_impl,
 	dispatch::DispatchClass,
 	parameter_types,
-	traits::{fungible, ConstU32, ConstU64, Imbalance, OnUnbalanced},
+	traits::{fungible, Imbalance, OnUnbalanced},
 	weights::{Weight, WeightToFee as WeightToFeeT},
 };
 use frame_system as system;
@@ -72,45 +68,14 @@ parameter_types! {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
 	type BlockWeights = BlockWeights;
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type Nonce = u64;
-	type RuntimeCall = RuntimeCall;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
+	type AccountData = pallet_balances::AccountData<Self::AccountId>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Runtime {
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl WeightToFeeT for WeightToFee {
diff --git a/substrate/frame/transaction-storage/src/mock.rs b/substrate/frame/transaction-storage/src/mock.rs
index f1e9e0591f6f521bad4fda1cb4ae4aa879efc483..73174b73dbacc7c803ad947c3108165688832767 100644
--- a/substrate/frame/transaction-storage/src/mock.rs
+++ b/substrate/frame/transaction-storage/src/mock.rs
@@ -23,7 +23,7 @@ use crate::{
 };
 use frame_support::{
 	derive_impl,
-	traits::{ConstU32, ConstU64, OnFinalize, OnInitialize},
+	traits::{ConstU32, OnFinalize, OnInitialize},
 };
 use sp_runtime::{traits::IdentityLookup, BuildStorage};
 
@@ -44,7 +44,6 @@ impl frame_system::Config for Test {
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<u64>;
 	type AccountId = u64;
-	type BlockHashCount = ConstU64<250>;
 	type Lookup = IdentityLookup<Self::AccountId>;
 }
 
diff --git a/substrate/frame/treasury/README.md b/substrate/frame/treasury/README.md
index 4945d79d1429694a1c8db79e8508561f515163da..2bd58a9817aab8efb47dc83752b817d6e11a59a2 100644
--- a/substrate/frame/treasury/README.md
+++ b/substrate/frame/treasury/README.md
@@ -26,6 +26,14 @@ and use the funds to pay developers.
 ### Dispatchable Functions
 
 General spending/proposal protocol:
-- `propose_spend` - Make a spending proposal and stake the required deposit.
-- `reject_proposal` - Reject a proposal, slashing the deposit.
-- `approve_proposal` - Accept the proposal, returning the deposit.
+- `spend_local` - Propose and approve a spend of treasury funds, enables the
+  creation of spends using the native currency of the chain, utilizing the funds
+  stored in the pot
+- `spend` - Propose and approve a spend of treasury funds, allows spending any
+  asset kind managed by the treasury
+- `remove_approval` - Force a previously approved proposal to be removed from
+  the approval queue
+- `payout` - Claim a spend
+- `check_status` - Check the status of the spend and remove it from the storage
+  if processed
+- `void_spend` - Void previously approved spend
diff --git a/substrate/frame/treasury/src/benchmarking.rs b/substrate/frame/treasury/src/benchmarking.rs
index 0b9999e37fbea566e7ec74f61357104b9b5d6376..63978c94e682f8cca84146e69c4b2e17d06ae637 100644
--- a/substrate/frame/treasury/src/benchmarking.rs
+++ b/substrate/frame/treasury/src/benchmarking.rs
@@ -59,12 +59,12 @@ where
 
 const SEED: u32 = 0;
 
-// Create the pre-requisite information needed to create a treasury `propose_spend`.
+// Create the pre-requisite information needed to create a treasury `spend_local`.
 fn setup_proposal<T: Config<I>, I: 'static>(
 	u: u32,
 ) -> (T::AccountId, BalanceOf<T, I>, AccountIdLookupOf<T>) {
 	let caller = account("caller", u, SEED);
-	let value: BalanceOf<T, I> = T::ProposalBondMinimum::get().saturating_mul(100u32.into());
+	let value: BalanceOf<T, I> = T::Currency::minimum_balance() * 100u32.into();
 	let _ = T::Currency::make_free_balance_be(&caller, value);
 	let beneficiary = account("beneficiary", u, SEED);
 	let beneficiary_lookup = T::Lookup::unlookup(beneficiary);
@@ -73,12 +73,10 @@ fn setup_proposal<T: Config<I>, I: 'static>(
 
 // Create proposals that are approved for use in `on_initialize`.
 fn create_approved_proposals<T: Config<I>, I: 'static>(n: u32) -> Result<(), &'static str> {
+	let origin = T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
 	for i in 0..n {
-		let (caller, value, lookup) = setup_proposal::<T, I>(i);
-		#[allow(deprecated)]
-		Treasury::<T, I>::propose_spend(RawOrigin::Signed(caller).into(), value, lookup)?;
-		let proposal_id = <ProposalCount<T, I>>::get() - 1;
-		Approvals::<T, I>::try_append(proposal_id).unwrap();
+		let (_, value, lookup) = setup_proposal::<T, I>(i);
+		Treasury::<T, I>::spend_local(origin.clone(), value, lookup)?;
 	}
 	ensure!(<Approvals<T, I>>::get().len() == n as usize, "Not all approved");
 	Ok(())
@@ -126,71 +124,13 @@ mod benchmarks {
 		Ok(())
 	}
 
-	#[benchmark]
-	fn propose_spend() -> Result<(), BenchmarkError> {
-		let (caller, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
-		// Whitelist caller account from further DB operations.
-		let caller_key = frame_system::Account::<T>::hashed_key_for(&caller);
-		frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into());
-
-		#[extrinsic_call]
-		_(RawOrigin::Signed(caller), value, beneficiary_lookup);
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn reject_proposal() -> Result<(), BenchmarkError> {
-		let (caller, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
-		#[allow(deprecated)]
-		Treasury::<T, _>::propose_spend(
-			RawOrigin::Signed(caller).into(),
-			value,
-			beneficiary_lookup,
-		)?;
-		let proposal_id = Treasury::<T, _>::proposal_count() - 1;
-		let reject_origin =
-			T::RejectOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
-
-		#[extrinsic_call]
-		_(reject_origin as T::RuntimeOrigin, proposal_id);
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn approve_proposal(
-		p: Linear<0, { T::MaxApprovals::get() - 1 }>,
-	) -> Result<(), BenchmarkError> {
-		let approve_origin =
-			T::ApproveOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
-		create_approved_proposals::<T, _>(p)?;
-		let (caller, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
-		#[allow(deprecated)]
-		Treasury::<T, _>::propose_spend(
-			RawOrigin::Signed(caller).into(),
-			value,
-			beneficiary_lookup,
-		)?;
-		let proposal_id = Treasury::<T, _>::proposal_count() - 1;
-
-		#[extrinsic_call]
-		_(approve_origin as T::RuntimeOrigin, proposal_id);
-
-		Ok(())
-	}
-
 	#[benchmark]
 	fn remove_approval() -> Result<(), BenchmarkError> {
-		let (caller, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
-		#[allow(deprecated)]
-		Treasury::<T, _>::propose_spend(
-			RawOrigin::Signed(caller).into(),
-			value,
-			beneficiary_lookup,
-		)?;
+		let origin =
+			T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let (_, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
+		Treasury::<T, _>::spend_local(origin, value, beneficiary_lookup)?;
 		let proposal_id = Treasury::<T, _>::proposal_count() - 1;
-		Approvals::<T, _>::try_append(proposal_id).unwrap();
 		let reject_origin =
 			T::RejectOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
 
diff --git a/substrate/frame/treasury/src/lib.rs b/substrate/frame/treasury/src/lib.rs
index 1ccd8456643233c71eb3095aa7c05980b9e52e25..4677a0e0335cd3d0613c29d915f74f1b33432d14 100644
--- a/substrate/frame/treasury/src/lib.rs
+++ b/substrate/frame/treasury/src/lib.rs
@@ -218,19 +218,6 @@ pub mod pallet {
 		/// Handler for the unbalanced decrease when slashing for a rejected proposal or bounty.
 		type OnSlash: OnUnbalanced<NegativeImbalanceOf<Self, I>>;
 
-		/// Fraction of a proposal's value that should be bonded in order to place the proposal.
-		/// An accepted proposal gets these back. A rejected proposal does not.
-		#[pallet::constant]
-		type ProposalBond: Get<Permill>;
-
-		/// Minimum amount of funds that should be placed in a deposit for making a proposal.
-		#[pallet::constant]
-		type ProposalBondMinimum: Get<BalanceOf<Self, I>>;
-
-		/// Maximum amount of funds that should be placed in a deposit for making a proposal.
-		#[pallet::constant]
-		type ProposalBondMaximum: Get<Option<BalanceOf<Self, I>>>;
-
 		/// Period between successive spends.
 		#[pallet::constant]
 		type SpendPeriod: Get<BlockNumberFor<Self>>;
@@ -363,14 +350,10 @@ pub mod pallet {
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config<I>, I: 'static = ()> {
-		/// New proposal.
-		Proposed { proposal_index: ProposalIndex },
 		/// We have ended a spend period and will now allocate funds.
 		Spending { budget_remaining: BalanceOf<T, I> },
 		/// Some funds have been allocated.
 		Awarded { proposal_index: ProposalIndex, award: BalanceOf<T, I>, account: T::AccountId },
-		/// A proposal was rejected; funds were slashed.
-		Rejected { proposal_index: ProposalIndex, slashed: BalanceOf<T, I> },
 		/// Some of our funds have been burnt.
 		Burnt { burnt_funds: BalanceOf<T, I> },
 		/// Spending has finished; this is the amount that rolls over until next spend.
@@ -408,8 +391,6 @@ pub mod pallet {
 	/// Error for the treasury pallet.
 	#[pallet::error]
 	pub enum Error<T, I = ()> {
-		/// Proposer's balance is too low.
-		InsufficientProposersBalance,
 		/// No proposal, bounty or spend at that index.
 		InvalidIndex,
 		/// Too many approvals in the queue.
@@ -476,123 +457,6 @@ pub mod pallet {
 
 	#[pallet::call]
 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
-		/// Put forward a suggestion for spending.
-		///
-		/// ## Dispatch Origin
-		///
-		/// Must be signed.
-		///
-		/// ## Details
-		/// A deposit proportional to the value is reserved and slashed if the proposal is rejected.
-		/// It is returned once the proposal is awarded.
-		///
-		/// ### Complexity
-		/// - O(1)
-		///
-		/// ## Events
-		///
-		/// Emits [`Event::Proposed`] if successful.
-		#[pallet::call_index(0)]
-		#[pallet::weight(T::WeightInfo::propose_spend())]
-		#[allow(deprecated)]
-		#[deprecated(
-			note = "`propose_spend` will be removed in February 2024. Use `spend` instead."
-		)]
-		pub fn propose_spend(
-			origin: OriginFor<T>,
-			#[pallet::compact] value: BalanceOf<T, I>,
-			beneficiary: AccountIdLookupOf<T>,
-		) -> DispatchResult {
-			let proposer = ensure_signed(origin)?;
-			let beneficiary = T::Lookup::lookup(beneficiary)?;
-
-			let bond = Self::calculate_bond(value);
-			T::Currency::reserve(&proposer, bond)
-				.map_err(|_| Error::<T, I>::InsufficientProposersBalance)?;
-
-			let c = Self::proposal_count();
-			<ProposalCount<T, I>>::put(c + 1);
-			<Proposals<T, I>>::insert(c, Proposal { proposer, value, beneficiary, bond });
-
-			Self::deposit_event(Event::Proposed { proposal_index: c });
-			Ok(())
-		}
-
-		/// Reject a proposed spend.
-		///
-		/// ## Dispatch Origin
-		///
-		/// Must be [`Config::RejectOrigin`].
-		///
-		/// ## Details
-		/// The original deposit will be slashed.
-		///
-		/// ### Complexity
-		/// - O(1)
-		///
-		/// ## Events
-		///
-		/// Emits [`Event::Rejected`] if successful.
-		#[pallet::call_index(1)]
-		#[pallet::weight((T::WeightInfo::reject_proposal(), DispatchClass::Operational))]
-		#[allow(deprecated)]
-		#[deprecated(
-			note = "`reject_proposal` will be removed in February 2024. Use `spend` instead."
-		)]
-		pub fn reject_proposal(
-			origin: OriginFor<T>,
-			#[pallet::compact] proposal_id: ProposalIndex,
-		) -> DispatchResult {
-			T::RejectOrigin::ensure_origin(origin)?;
-
-			let proposal =
-				<Proposals<T, I>>::take(&proposal_id).ok_or(Error::<T, I>::InvalidIndex)?;
-			let value = proposal.bond;
-			let imbalance = T::Currency::slash_reserved(&proposal.proposer, value).0;
-			T::OnSlash::on_unbalanced(imbalance);
-
-			Self::deposit_event(Event::<T, I>::Rejected {
-				proposal_index: proposal_id,
-				slashed: value,
-			});
-			Ok(())
-		}
-
-		/// Approve a proposal.
-		///
-		/// ## Dispatch Origin
-		///
-		/// Must be [`Config::ApproveOrigin`].
-		///
-		/// ## Details
-		///
-		/// At a later time, the proposal will be allocated to the beneficiary and the original
-		/// deposit will be returned.
-		///
-		/// ### Complexity
-		///  - O(1).
-		///
-		/// ## Events
-		///
-		/// No events are emitted from this dispatch.
-		#[pallet::call_index(2)]
-		#[pallet::weight((T::WeightInfo::approve_proposal(T::MaxApprovals::get()), DispatchClass::Operational))]
-		#[allow(deprecated)]
-		#[deprecated(
-			note = "`approve_proposal` will be removed in February 2024. Use `spend` instead."
-		)]
-		pub fn approve_proposal(
-			origin: OriginFor<T>,
-			#[pallet::compact] proposal_id: ProposalIndex,
-		) -> DispatchResult {
-			T::ApproveOrigin::ensure_origin(origin)?;
-
-			ensure!(<Proposals<T, I>>::contains_key(proposal_id), Error::<T, I>::InvalidIndex);
-			Approvals::<T, I>::try_append(proposal_id)
-				.map_err(|_| Error::<T, I>::TooManyApprovals)?;
-			Ok(())
-		}
-
 		/// Propose and approve a spend of treasury funds.
 		///
 		/// ## Dispatch Origin
@@ -794,7 +658,7 @@ pub mod pallet {
 		///
 		/// ## Dispatch Origin
 		///
-		/// Must be signed.
+		/// Must be signed
 		///
 		/// ## Details
 		///
@@ -934,15 +798,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		T::PalletId::get().into_account_truncating()
 	}
 
-	/// The needed bond for a proposal whose spend is `value`.
-	fn calculate_bond(value: BalanceOf<T, I>) -> BalanceOf<T, I> {
-		let mut r = T::ProposalBondMinimum::get().max(T::ProposalBond::get() * value);
-		if let Some(m) = T::ProposalBondMaximum::get() {
-			r = r.min(m);
-		}
-		r
-	}
-
 	/// Spend some money! returns number of approvals before spend.
 	pub fn spend_funds() -> Weight {
 		let mut total_weight = Weight::zero();
diff --git a/substrate/frame/treasury/src/tests.rs b/substrate/frame/treasury/src/tests.rs
index 67d81cb5c30224e68a2b72bcda3255273304b14a..94f5e6b70942b54914f388536bd5a447f098eb36 100644
--- a/substrate/frame/treasury/src/tests.rs
+++ b/substrate/frame/treasury/src/tests.rs
@@ -60,20 +60,10 @@ impl frame_system::Config for Test {
 	type Block = Block;
 	type AccountData = pallet_balances::AccountData<u64>;
 }
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_utility::Config for Test {
@@ -136,7 +126,6 @@ impl Pay for TestPay {
 }
 
 parameter_types! {
-	pub const ProposalBond: Permill = Permill::from_percent(5);
 	pub const Burn: Permill = Permill::from_percent(50);
 	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
 	pub TreasuryAccount: u128 = Treasury::account_id();
@@ -152,6 +141,7 @@ impl frame_support::traits::EnsureOrigin<RuntimeOrigin> for TestSpendOrigin {
 			frame_system::RawOrigin::Signed(11) => Ok(10),
 			frame_system::RawOrigin::Signed(12) => Ok(20),
 			frame_system::RawOrigin::Signed(13) => Ok(50),
+			frame_system::RawOrigin::Signed(14) => Ok(500),
 			r => Err(RuntimeOrigin::from(r)),
 		})
 	}
@@ -178,9 +168,6 @@ impl Config for Test {
 	type RejectOrigin = frame_system::EnsureRoot<u128>;
 	type RuntimeEvent = RuntimeEvent;
 	type OnSlash = ();
-	type ProposalBond = ProposalBond;
-	type ProposalBondMinimum = ConstU64<1>;
-	type ProposalBondMaximum = ();
 	type SpendPeriod = ConstU64<2>;
 	type Burn = Burn;
 	type BurnDestination = (); // Just gets burned.
@@ -295,56 +282,12 @@ fn minting_works() {
 	});
 }
 
-#[test]
-fn spend_proposal_takes_min_deposit() {
-	ExtBuilder::default().build().execute_with(|| {
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 1, 3)
-		});
-		assert_eq!(Balances::free_balance(0), 99);
-		assert_eq!(Balances::reserved_balance(0), 1);
-	});
-}
-
-#[test]
-fn spend_proposal_takes_proportional_deposit() {
-	ExtBuilder::default().build().execute_with(|| {
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_eq!(Balances::free_balance(0), 95);
-		assert_eq!(Balances::reserved_balance(0), 5);
-	});
-}
-
-#[test]
-fn spend_proposal_fails_when_proposer_poor() {
-	ExtBuilder::default().build().execute_with(|| {
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::propose_spend(RuntimeOrigin::signed(2), 100, 3)
-			},
-			Error::<Test, _>::InsufficientProposersBalance,
-		);
-	});
-}
-
 #[test]
 fn accepted_spend_proposal_ignored_outside_spend_period() {
 	ExtBuilder::default().build().execute_with(|| {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 100, 3));
 
 		<Treasury as OnInitialize<u64>>::on_initialize(1);
 		assert_eq!(Balances::free_balance(3), 0);
@@ -365,112 +308,13 @@ fn unused_pot_should_diminish() {
 	});
 }
 
-#[test]
-fn rejected_spend_proposal_ignored_on_spend_period() {
-	ExtBuilder::default().build().execute_with(|| {
-		Balances::make_free_balance_be(&Treasury::account_id(), 101);
-
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-		});
-
-		<Treasury as OnInitialize<u64>>::on_initialize(2);
-		assert_eq!(Balances::free_balance(3), 0);
-		assert_eq!(Treasury::pot(), 50);
-	});
-}
-
-#[test]
-fn reject_already_rejected_spend_proposal_fails() {
-	ExtBuilder::default().build().execute_with(|| {
-		Balances::make_free_balance_be(&Treasury::account_id(), 101);
-
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-		});
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-			},
-			Error::<Test, _>::InvalidIndex
-		);
-	});
-}
-
-#[test]
-fn reject_non_existent_spend_proposal_fails() {
-	ExtBuilder::default().build().execute_with(|| {
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-			},
-			Error::<Test, _>::InvalidIndex
-		);
-	});
-}
-
-#[test]
-fn accept_non_existent_spend_proposal_fails() {
-	ExtBuilder::default().build().execute_with(|| {
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-			},
-			Error::<Test, _>::InvalidIndex
-		);
-	});
-}
-
-#[test]
-fn accept_already_rejected_spend_proposal_fails() {
-	ExtBuilder::default().build().execute_with(|| {
-		Balances::make_free_balance_be(&Treasury::account_id(), 101);
-
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::reject_proposal(RuntimeOrigin::root(), 0)
-		});
-		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-			},
-			Error::<Test, _>::InvalidIndex
-		);
-	});
-}
-
 #[test]
 fn accepted_spend_proposal_enacted_on_spend_period() {
 	ExtBuilder::default().build().execute_with(|| {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_eq!(Treasury::pot(), 100);
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 100, 3));
 
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Balances::free_balance(3), 100);
@@ -484,14 +328,7 @@ fn pot_underflow_should_not_diminish() {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 		assert_eq!(Treasury::pot(), 100);
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 150, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 150, 3));
 
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Treasury::pot(), 100); // Pot hasn't changed
@@ -512,26 +349,12 @@ fn treasury_account_doesnt_get_deleted() {
 		assert_eq!(Treasury::pot(), 100);
 		let treasury_balance = Balances::free_balance(&Treasury::account_id());
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), treasury_balance, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), treasury_balance, 3));
 
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Treasury::pot(), 100); // Pot hasn't changed
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), Treasury::pot(), 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 1)
-		});
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), Treasury::pot(), 3));
 
 		<Treasury as OnInitialize<u64>>::on_initialize(4);
 		assert_eq!(Treasury::pot(), 0); // Pot is emptied
@@ -554,22 +377,9 @@ fn inexistent_account_works() {
 		assert_eq!(Balances::free_balance(Treasury::account_id()), 0); // Account does not exist
 		assert_eq!(Treasury::pot(), 0); // Pot is empty
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 99, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 1, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 1)
-		});
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 99, 3));
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 1, 3));
+
 		<Treasury as OnInitialize<u64>>::on_initialize(2);
 		assert_eq!(Treasury::pot(), 0); // Pot hasn't changed
 		assert_eq!(Balances::free_balance(3), 0); // Balance of `3` hasn't changed
@@ -611,26 +421,12 @@ fn max_approvals_limited() {
 		Balances::make_free_balance_be(&0, u64::MAX);
 
 		for _ in 0..<Test as Config>::MaxApprovals::get() {
-			assert_ok!({
-				#[allow(deprecated)]
-				Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-			});
-			assert_ok!({
-				#[allow(deprecated)]
-				Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-			});
+			assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 100, 3));
 		}
 
 		// One too many will fail
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
 		assert_noop!(
-			{
-				#[allow(deprecated)]
-				Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-			},
+			Treasury::spend_local(RuntimeOrigin::signed(14), 100, 3),
 			Error::<Test, _>::TooManyApprovals
 		);
 	});
@@ -641,14 +437,8 @@ fn remove_already_removed_approval_fails() {
 	ExtBuilder::default().build().execute_with(|| {
 		Balances::make_free_balance_be(&Treasury::account_id(), 101);
 
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 100, 3)
-		});
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 100, 3));
+
 		assert_eq!(Treasury::approvals(), vec![0]);
 		assert_ok!(Treasury::remove_approval(RuntimeOrigin::root(), 0));
 		assert_eq!(Treasury::approvals(), vec![]);
@@ -982,11 +772,9 @@ fn check_status_works() {
 fn try_state_proposals_invariant_1_works() {
 	ExtBuilder::default().build().execute_with(|| {
 		use frame_support::pallet_prelude::DispatchError::Other;
-		// Add a proposal using `propose_spend`
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 1, 3)
-		});
+		// Add a proposal and approve using `spend_local`
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 1, 3));
+
 		assert_eq!(Proposals::<Test>::iter().count(), 1);
 		assert_eq!(ProposalCount::<Test>::get(), 1);
 		// Check invariant 1 holds
@@ -1005,12 +793,11 @@ fn try_state_proposals_invariant_1_works() {
 fn try_state_proposals_invariant_2_works() {
 	ExtBuilder::default().build().execute_with(|| {
 		use frame_support::pallet_prelude::DispatchError::Other;
-		// Add a proposal using `propose_spend`
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 1, 3)
-		});
+		// Add a proposal and approve using `spend_local`
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 1, 3));
+
 		assert_eq!(Proposals::<Test>::iter().count(), 1);
+		assert_eq!(Approvals::<Test>::get().len(), 1);
 		let current_proposal_count = ProposalCount::<Test>::get();
 		assert_eq!(current_proposal_count, 1);
 		// Check invariant 2 holds
@@ -1035,17 +822,10 @@ fn try_state_proposals_invariant_2_works() {
 fn try_state_proposals_invariant_3_works() {
 	ExtBuilder::default().build().execute_with(|| {
 		use frame_support::pallet_prelude::DispatchError::Other;
-		// Add a proposal using `propose_spend`
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::propose_spend(RuntimeOrigin::signed(0), 10, 3)
-		});
+		// Add a proposal and approve using `spend_local`
+		assert_ok!(Treasury::spend_local(RuntimeOrigin::signed(14), 10, 3));
+
 		assert_eq!(Proposals::<Test>::iter().count(), 1);
-		// Approve the proposal
-		assert_ok!({
-			#[allow(deprecated)]
-			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
-		});
 		assert_eq!(Approvals::<Test>::get().len(), 1);
 		// Check invariant 3 holds
 		assert!(Approvals::<Test>::get()
diff --git a/substrate/frame/treasury/src/weights.rs b/substrate/frame/treasury/src/weights.rs
index 82277e2d28f6c80e2bfa040103bb4a311ca41ac1..8c9c6eb1d0fbb552bb210be6435e973078d64d30 100644
--- a/substrate/frame/treasury/src/weights.rs
+++ b/substrate/frame/treasury/src/weights.rs
@@ -52,9 +52,6 @@ use core::marker::PhantomData;
 /// Weight functions needed for `pallet_treasury`.
 pub trait WeightInfo {
 	fn spend_local() -> Weight;
-	fn propose_spend() -> Weight;
-	fn reject_proposal() -> Weight;
-	fn approve_proposal(p: u32, ) -> Weight;
 	fn remove_approval() -> Weight;
 	fn on_initialize_proposals(p: u32, ) -> Weight;
 	fn spend() -> Weight;
@@ -81,50 +78,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
-	/// Storage: `Treasury::ProposalCount` (r:1 w:1)
-	/// Proof: `Treasury::ProposalCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `Treasury::Proposals` (r:0 w:1)
-	/// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	fn propose_spend() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `177`
-		//  Estimated: `1489`
-		// Minimum execution time: 24_704_000 picoseconds.
-		Weight::from_parts(25_484_000, 1489)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
-			.saturating_add(T::DbWeight::get().writes(2_u64))
-	}
-	/// Storage: `Treasury::Proposals` (r:1 w:1)
-	/// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:1 w:1)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
-	fn reject_proposal() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `335`
-		//  Estimated: `3593`
-		// Minimum execution time: 26_632_000 picoseconds.
-		Weight::from_parts(27_325_000, 3593)
-			.saturating_add(T::DbWeight::get().reads(2_u64))
-			.saturating_add(T::DbWeight::get().writes(2_u64))
-	}
-	/// Storage: `Treasury::Proposals` (r:1 w:0)
-	/// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	/// Storage: `Treasury::Approvals` (r:1 w:1)
-	/// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`)
-	/// The range of component `p` is `[0, 99]`.
-	fn approve_proposal(p: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `504 + p * (8 ±0)`
-		//  Estimated: `3573`
-		// Minimum execution time: 8_436_000 picoseconds.
-		Weight::from_parts(11_268_438, 3573)
-			// Standard Error: 1_039
-			.saturating_add(Weight::from_parts(70_903, 0).saturating_mul(p.into()))
-			.saturating_add(T::DbWeight::get().reads(2_u64))
-			.saturating_add(T::DbWeight::get().writes(1_u64))
-	}
-	/// Storage: `Treasury::Approvals` (r:1 w:1)
-	/// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`)
+	/// Storage: Treasury Approvals (r:1 w:1)
+	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
 	fn remove_approval() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `161`
@@ -232,50 +187,8 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
-	/// Storage: `Treasury::ProposalCount` (r:1 w:1)
-	/// Proof: `Treasury::ProposalCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
-	/// Storage: `Treasury::Proposals` (r:0 w:1)
-	/// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	fn propose_spend() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `177`
-		//  Estimated: `1489`
-		// Minimum execution time: 24_704_000 picoseconds.
-		Weight::from_parts(25_484_000, 1489)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
-			.saturating_add(RocksDbWeight::get().writes(2_u64))
-	}
-	/// Storage: `Treasury::Proposals` (r:1 w:1)
-	/// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	/// Storage: `System::Account` (r:1 w:1)
-	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
-	fn reject_proposal() -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `335`
-		//  Estimated: `3593`
-		// Minimum execution time: 26_632_000 picoseconds.
-		Weight::from_parts(27_325_000, 3593)
-			.saturating_add(RocksDbWeight::get().reads(2_u64))
-			.saturating_add(RocksDbWeight::get().writes(2_u64))
-	}
-	/// Storage: `Treasury::Proposals` (r:1 w:0)
-	/// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
-	/// Storage: `Treasury::Approvals` (r:1 w:1)
-	/// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`)
-	/// The range of component `p` is `[0, 99]`.
-	fn approve_proposal(p: u32, ) -> Weight {
-		// Proof Size summary in bytes:
-		//  Measured:  `504 + p * (8 ±0)`
-		//  Estimated: `3573`
-		// Minimum execution time: 8_436_000 picoseconds.
-		Weight::from_parts(11_268_438, 3573)
-			// Standard Error: 1_039
-			.saturating_add(Weight::from_parts(70_903, 0).saturating_mul(p.into()))
-			.saturating_add(RocksDbWeight::get().reads(2_u64))
-			.saturating_add(RocksDbWeight::get().writes(1_u64))
-	}
-	/// Storage: `Treasury::Approvals` (r:1 w:1)
-	/// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`)
+	/// Storage: Treasury Approvals (r:1 w:1)
+	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
 	fn remove_approval() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `161`
diff --git a/substrate/frame/tx-pause/src/mock.rs b/substrate/frame/tx-pause/src/mock.rs
index 5206023838b95290d1a153b37074dccb0b5635d9..84ce45e835280dd9beeddacf84193ff858c3ea80 100644
--- a/substrate/frame/tx-pause/src/mock.rs
+++ b/substrate/frame/tx-pause/src/mock.rs
@@ -27,60 +27,18 @@ use frame_support::{
 	traits::{ConstU64, Everything, InsideBoth, InstanceFilter},
 };
 use frame_system::EnsureSignedBy;
-use sp_core::H256;
-use sp_runtime::{
-	traits::{BlakeTwo256, IdentityLookup},
-	BuildStorage,
-};
+use sp_runtime::{traits::BlakeTwo256, BuildStorage};
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-}
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
 	type BaseCallFilter = InsideBoth<Everything, TxPause>;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
-	type Nonce = u64;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
-	type Lookup = IdentityLookup<Self::AccountId>;
-	type RuntimeEvent = RuntimeEvent;
 	type Block = Block;
-	type BlockHashCount = BlockHashCount;
-	type DbWeight = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<u64>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
-parameter_types! {
-	pub const ExistentialDeposit: u64 = 1;
-	pub const MaxLocks: u32 = 10;
-}
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = MaxLocks;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type RuntimeHoldReason = RuntimeHoldReason;
-	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type MaxFreezes = ConstU32<0>;
 }
 
 impl pallet_utility::Config for Test {
diff --git a/substrate/frame/uniques/src/mock.rs b/substrate/frame/uniques/src/mock.rs
index 9fd7f87e159bb29bb7206fcba05b573ccc140115..c3b74eb8c255417b7a6ed12f2d2ee771ec3d9f48 100644
--- a/substrate/frame/uniques/src/mock.rs
+++ b/substrate/frame/uniques/src/mock.rs
@@ -43,20 +43,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type MaxLocks = ();
-	type MaxReserves = ConstU32<50>;
-	type ReserveIdentifier = [u8; 8];
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl Config for Test {
diff --git a/substrate/frame/utility/src/tests.rs b/substrate/frame/utility/src/tests.rs
index 9bcbec99f3b441669eaf68433f0e88b3f5117502..eb2047aac28af40e9d8872c38ed21b89666e1c48 100644
--- a/substrate/frame/utility/src/tests.rs
+++ b/substrate/frame/utility/src/tests.rs
@@ -151,20 +151,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_root_testing::Config for Test {
diff --git a/substrate/frame/vesting/src/mock.rs b/substrate/frame/vesting/src/mock.rs
index 674a6f6e2a83677eae30fae445c05def44741e12..f0954a5b989c8a20d1fbb7feba9e49b20d61a27c 100644
--- a/substrate/frame/vesting/src/mock.rs
+++ b/substrate/frame/vesting/src/mock.rs
@@ -15,10 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use frame_support::{
-	derive_impl, parameter_types,
-	traits::{ConstU32, WithdrawReasons},
-};
+use frame_support::{derive_impl, parameter_types, traits::WithdrawReasons};
 use sp_runtime::{traits::Identity, BuildStorage};
 
 use super::*;
@@ -41,20 +38,10 @@ impl frame_system::Config for Test {
 	type Block = Block;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
 	type AccountStore = System;
-	type Balance = u64;
-	type DustRemoval = ();
-	type RuntimeEvent = RuntimeEvent;
 	type ExistentialDeposit = ExistentialDeposit;
-	type MaxLocks = ConstU32<10>;
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 parameter_types! {
 	pub const MinVestedTransfer: u64 = 256 * 2;
diff --git a/substrate/frame/whitelist/src/mock.rs b/substrate/frame/whitelist/src/mock.rs
index 6fb8711057ef0cd53cc388e07cf90347c0e13000..0a97d1c2df5445223a4253cf0e1b81bd020806b0 100644
--- a/substrate/frame/whitelist/src/mock.rs
+++ b/substrate/frame/whitelist/src/mock.rs
@@ -21,7 +21,7 @@
 
 use crate as pallet_whitelist;
 
-use frame_support::{construct_runtime, derive_impl, traits::ConstU64};
+use frame_support::{construct_runtime, derive_impl};
 use frame_system::EnsureRoot;
 use sp_runtime::BuildStorage;
 
@@ -43,20 +43,9 @@ impl frame_system::Config for Test {
 	type AccountData = pallet_balances::AccountData<u64>;
 }
 
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
 impl pallet_balances::Config for Test {
-	type MaxLocks = ();
-	type MaxReserves = ();
-	type ReserveIdentifier = [u8; 8];
-	type Balance = u64;
-	type RuntimeEvent = RuntimeEvent;
-	type DustRemoval = ();
-	type ExistentialDeposit = ConstU64<1>;
 	type AccountStore = System;
-	type WeightInfo = ();
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
 }
 
 impl pallet_preimage::Config for Test {
diff --git a/substrate/primitives/api/Cargo.toml b/substrate/primitives/api/Cargo.toml
index f48480f398d00729a5fb10e0c9bcfba5d62f9776..b334880785f2fd0195d197b878a3d6fc2252c5a7 100644
--- a/substrate/primitives/api/Cargo.toml
+++ b/substrate/primitives/api/Cargo.toml
@@ -33,6 +33,7 @@ scale-info = { version = "2.11.1", default-features = false, features = [
 ] }
 sp-metadata-ir = { path = "../metadata-ir", default-features = false, optional = true }
 log = { workspace = true }
+docify = { version = "0.2.1" }
 
 [dev-dependencies]
 sp-test-primitives = { path = "../test-primitives" }
diff --git a/substrate/primitives/api/proc-macro/src/utils.rs b/substrate/primitives/api/proc-macro/src/utils.rs
index d90b56058648ba8653992c210586238028629689..36577670a40ce48df9ea805adb2fde5f02399599 100644
--- a/substrate/primitives/api/proc-macro/src/utils.rs
+++ b/substrate/primitives/api/proc-macro/src/utils.rs
@@ -40,6 +40,10 @@ pub fn generate_crate_access() -> TokenStream {
 				let path = format!("{}::deps::sp_api::__private", name);
 				let path = syn::parse_str::<syn::Path>(&path).expect("is a valid path; qed");
 				quote!( #path )
+			} else if let Ok(FoundCrate::Name(name)) = crate_name(&"polkadot-sdk") {
+				let path = format!("{}::sp_api::__private", name);
+				let path = syn::parse_str::<syn::Path>(&path).expect("is a valid path; qed");
+				quote!( #path )
 			} else {
 				let err = Error::new(Span::call_site(), e).to_compile_error();
 				quote!( #err )
diff --git a/substrate/primitives/api/src/lib.rs b/substrate/primitives/api/src/lib.rs
index 20f989c4882e35fe06d5496f851b4adec2c6f1c0..cd8da8ba2374e142835967c8f304c62b1d0bf250 100644
--- a/substrate/primitives/api/src/lib.rs
+++ b/substrate/primitives/api/src/lib.rs
@@ -532,6 +532,7 @@ pub trait ConstructRuntimeApi<Block: BlockT, C: CallApiAt<Block>> {
 	fn construct_runtime_api(call: &C) -> ApiRef<Self::RuntimeApi>;
 }
 
+#[docify::export]
 /// Init the [`RuntimeLogger`](sp_runtime::runtime_logger::RuntimeLogger).
 pub fn init_runtime_logger() {
 	#[cfg(not(feature = "disable-logging"))]
diff --git a/substrate/primitives/blockchain/src/backend.rs b/substrate/primitives/blockchain/src/backend.rs
index 06e5b682964a4e7672575c9e8b5460d7acb2de96..76393420da740b269a3790f7e69ed12ddf77b21a 100644
--- a/substrate/primitives/blockchain/src/backend.rs
+++ b/substrate/primitives/blockchain/src/backend.rs
@@ -21,16 +21,15 @@ use log::warn;
 use parking_lot::RwLock;
 use sp_runtime::{
 	generic::BlockId,
-	traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero},
+	traits::{Block as BlockT, CheckedSub, Header as HeaderT, NumberFor, Zero},
 	Justifications,
 };
 use std::collections::{btree_map::BTreeMap, btree_set::BTreeSet};
 
-use crate::header_metadata::HeaderMetadata;
-
 use crate::{
 	error::{Error, Result},
-	tree_route, TreeRoute,
+	header_metadata::{self, HeaderMetadata},
+	lowest_common_ancestor_multiblock, tree_route, TreeRoute,
 };
 
 /// Blockchain database header backend. Does not perform any validation.
@@ -229,12 +228,41 @@ pub trait Backend<Block: BlockT>:
 	) -> std::result::Result<DisplacedLeavesAfterFinalization<Block>, Error> {
 		let mut result = DisplacedLeavesAfterFinalization::default();
 
-		if finalized_block_number == Zero::zero() {
+		let leaves = self.leaves()?;
+
+		// If we have only one leaf there are no forks, and we can return early.
+		if finalized_block_number == Zero::zero() || leaves.len() == 1 {
 			return Ok(result)
 		}
 
+		let first_leaf = leaves.first().ok_or(Error::Backend(
+			"Unable to find any leaves. This should not happen.".to_string(),
+		))?;
+		let leaf_block_header = self.expect_header(*first_leaf)?;
+
+		// If the distance between the leafs and the finalized block is large,  calculating
+		// tree routes can be very expensive. In that case, we will try to find the
+		// lowest common ancestor between all the leaves. The assumption here is that the forks are
+		// close to the tip and not long. So the LCA can be computed from the header cache. If the
+		// LCA is above the finalized block, we know that there are no displaced leaves by the
+		// finalization.
+		if leaf_block_header
+			.number()
+			.checked_sub(&finalized_block_number)
+			.unwrap_or(0u32.into()) >
+			header_metadata::LRU_CACHE_SIZE.into()
+		{
+			if let Some(lca) = lowest_common_ancestor_multiblock(self, leaves.clone())? {
+				if lca.number > finalized_block_number {
+					return Ok(result)
+				} else {
+					log::warn!("The distance between leafs and finalized block is large. Finalization can take a long time.");
+				}
+			};
+		}
+
 		// For each leaf determine whether it belongs to a non-canonical branch.
-		for leaf_hash in self.leaves()? {
+		for leaf_hash in leaves {
 			let leaf_block_header = self.expect_header(leaf_hash)?;
 			let leaf_number = *leaf_block_header.number();
 
@@ -284,7 +312,7 @@ impl<Block: BlockT> DisplacedLeavesAfterFinalization<Block> {
 }
 
 /// Blockchain info
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 pub struct Info<Block: BlockT> {
 	/// Best block hash.
 	pub best_hash: Block::Hash,
diff --git a/substrate/primitives/blockchain/src/header_metadata.rs b/substrate/primitives/blockchain/src/header_metadata.rs
index 27caaae71add1a440b8a772db131329c951befbc..c2054445b06765ad42b4d5a0718997fc9686cc14 100644
--- a/substrate/primitives/blockchain/src/header_metadata.rs
+++ b/substrate/primitives/blockchain/src/header_metadata.rs
@@ -23,7 +23,7 @@ use schnellru::{ByLength, LruMap};
 use sp_runtime::traits::{Block as BlockT, Header, NumberFor, One};
 
 /// Set to the expected max difference between `best` and `finalized` blocks at sync.
-const LRU_CACHE_SIZE: u32 = 5_000;
+pub(crate) const LRU_CACHE_SIZE: u32 = 5_000;
 
 /// Get lowest common ancestor between two blocks in the tree.
 ///
@@ -96,6 +96,30 @@ pub fn lowest_common_ancestor<Block: BlockT, T: HeaderMetadata<Block> + ?Sized>(
 	Ok(HashAndNumber { hash: header_one.hash, number: header_one.number })
 }
 
+/// Get lowest common ancestor between multiple blocks.
+pub fn lowest_common_ancestor_multiblock<Block: BlockT, T: HeaderMetadata<Block> + ?Sized>(
+	backend: &T,
+	hashes: Vec<Block::Hash>,
+) -> Result<Option<HashAndNumber<Block>>, T::Error> {
+	// Ensure the list of hashes is not empty
+	let mut hashes_iter = hashes.into_iter();
+
+	let first_hash = match hashes_iter.next() {
+		Some(hash) => hash,
+		None => return Ok(None),
+	};
+
+	// Start with the first hash as the initial LCA
+	let first_cached = backend.header_metadata(first_hash)?;
+	let mut lca = HashAndNumber { number: first_cached.number, hash: first_cached.hash };
+	for hash in hashes_iter {
+		// Calculate the LCA of the current LCA and the next hash
+		lca = lowest_common_ancestor(backend, lca.hash, hash)?;
+	}
+
+	Ok(Some(lca))
+}
+
 /// Compute a tree-route between two blocks. See tree-route docs for more details.
 pub fn tree_route<Block: BlockT, T: HeaderMetadata<Block> + ?Sized>(
 	backend: &T,
diff --git a/substrate/primitives/consensus/beefy/src/lib.rs b/substrate/primitives/consensus/beefy/src/lib.rs
index 390c0ff71273ad4b9993a5a3e7be0265148a8c5b..913184402aef7bf9d1ee906faea935262e177a93 100644
--- a/substrate/primitives/consensus/beefy/src/lib.rs
+++ b/substrate/primitives/consensus/beefy/src/lib.rs
@@ -50,9 +50,12 @@ use alloc::vec::Vec;
 use codec::{Codec, Decode, Encode};
 use core::fmt::{Debug, Display};
 use scale_info::TypeInfo;
-use sp_application_crypto::{AppCrypto, AppPublic, ByteArray, RuntimeAppPublic};
+use sp_application_crypto::{AppPublic, RuntimeAppPublic};
 use sp_core::H256;
-use sp_runtime::traits::{Hash, Keccak256, NumberFor};
+use sp_runtime::{
+	traits::{Hash, Keccak256, NumberFor},
+	OpaqueValue,
+};
 
 /// Key type for BEEFY module.
 pub const KEY_TYPE: sp_core::crypto::KeyTypeId = sp_application_crypto::key_types::BEEFY;
@@ -73,17 +76,13 @@ pub type BeefySignatureHasher = sp_runtime::traits::Keccak256;
 /// A trait bound which lists all traits which are required to be implemented by
 /// a BEEFY AuthorityId type in order to be able to be used in BEEFY Keystore
 pub trait AuthorityIdBound:
-	Codec
-	+ Debug
-	+ Clone
-	+ AsRef<[u8]>
-	+ ByteArray
+	Ord
 	+ AppPublic
-	+ AppCrypto
-	+ RuntimeAppPublic
 	+ Display
-	+ BeefyAuthorityId<BeefySignatureHasher>
+	+ BeefyAuthorityId<BeefySignatureHasher, Signature = Self::BoundedSignature>
 {
+	/// Necessary bounds on the Signature associated with the AuthorityId
+	type BoundedSignature: Debug + Eq + PartialEq + Clone + TypeInfo + Codec + Send + Sync;
 }
 
 /// BEEFY cryptographic types for ECDSA crypto
@@ -124,7 +123,9 @@ pub mod ecdsa_crypto {
 			}
 		}
 	}
-	impl AuthorityIdBound for AuthorityId {}
+	impl AuthorityIdBound for AuthorityId {
+		type BoundedSignature = Signature;
+	}
 }
 
 /// BEEFY cryptographic types for BLS crypto
@@ -165,7 +166,9 @@ pub mod bls_crypto {
 			BlsPair::verify(signature.as_inner_ref(), msg, self.as_inner_ref())
 		}
 	}
-	impl AuthorityIdBound for AuthorityId {}
+	impl AuthorityIdBound for AuthorityId {
+		type BoundedSignature = Signature;
+	}
 }
 
 /// BEEFY cryptographic types for (ECDSA,BLS) crypto pair
@@ -213,7 +216,9 @@ pub mod ecdsa_bls_crypto {
 		}
 	}
 
-	impl AuthorityIdBound for AuthorityId {}
+	impl AuthorityIdBound for AuthorityId {
+		type BoundedSignature = Signature;
+	}
 }
 
 /// The `ConsensusEngineId` of BEEFY.
@@ -399,21 +404,7 @@ impl<AuthorityId> OnNewValidatorSet<AuthorityId> for () {
 /// the runtime API boundary this type is unknown and as such we keep this
 /// opaque representation, implementors of the runtime API will have to make
 /// sure that all usages of `OpaqueKeyOwnershipProof` refer to the same type.
-#[derive(Decode, Encode, PartialEq, TypeInfo)]
-pub struct OpaqueKeyOwnershipProof(Vec<u8>);
-impl OpaqueKeyOwnershipProof {
-	/// Create a new `OpaqueKeyOwnershipProof` using the given encoded
-	/// representation.
-	pub fn new(inner: Vec<u8>) -> OpaqueKeyOwnershipProof {
-		OpaqueKeyOwnershipProof(inner)
-	}
-
-	/// Try to decode this `OpaqueKeyOwnershipProof` into the given concrete key
-	/// ownership proof type.
-	pub fn decode<T: Decode>(self) -> Option<T> {
-		codec::Decode::decode(&mut &self.0[..]).ok()
-	}
-}
+pub type OpaqueKeyOwnershipProof = OpaqueValue;
 
 sp_api::decl_runtime_apis! {
 	/// API necessary for BEEFY voters.
diff --git a/substrate/primitives/consensus/common/src/lib.rs b/substrate/primitives/consensus/common/src/lib.rs
index 01d3b7a24f9c143201f07092c7484e72f513d8f0..37636b34b03df6221865eada59abbb11cb92519a 100644
--- a/substrate/primitives/consensus/common/src/lib.rs
+++ b/substrate/primitives/consensus/common/src/lib.rs
@@ -40,7 +40,7 @@ pub use sp_inherents::InherentData;
 pub use sp_state_machine::Backend as StateBackend;
 
 /// Block status.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum BlockStatus {
 	/// Added to the import queue.
 	Queued,
diff --git a/substrate/primitives/consensus/grandpa/Cargo.toml b/substrate/primitives/consensus/grandpa/Cargo.toml
index f63f5f3122f41f76640dcebb8dca592f31268577..9a59575a22c3908c53665522233ac1d7e688a0ed 100644
--- a/substrate/primitives/consensus/grandpa/Cargo.toml
+++ b/substrate/primitives/consensus/grandpa/Cargo.toml
@@ -18,7 +18,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
-grandpa = { package = "finality-grandpa", version = "0.16.2", default-features = false, features = ["derive-codec"] }
+finality-grandpa = { version = "0.16.2", default-features = false, features = ["derive-codec"] }
 log = { workspace = true }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 serde = { features = ["alloc", "derive"], optional = true, workspace = true }
@@ -32,7 +32,7 @@ sp-runtime = { path = "../../runtime", default-features = false }
 default = ["std"]
 std = [
 	"codec/std",
-	"grandpa/std",
+	"finality-grandpa/std",
 	"log/std",
 	"scale-info/std",
 	"serde/std",
diff --git a/substrate/primitives/consensus/grandpa/src/lib.rs b/substrate/primitives/consensus/grandpa/src/lib.rs
index 75ed81894c259ad7102b9b98bb3e6e29bea4cdcd..d86ea0992c2e1c1beb134dddd057b45484d9891c 100644
--- a/substrate/primitives/consensus/grandpa/src/lib.rs
+++ b/substrate/primitives/consensus/grandpa/src/lib.rs
@@ -31,7 +31,7 @@ use scale_info::TypeInfo;
 use sp_keystore::KeystorePtr;
 use sp_runtime::{
 	traits::{Header as HeaderT, NumberFor},
-	ConsensusEngineId, RuntimeDebug,
+	ConsensusEngineId, OpaqueValue, RuntimeDebug,
 };
 
 /// The log target to be used by client code.
@@ -77,10 +77,11 @@ pub type RoundNumber = u64;
 pub type AuthorityList = Vec<(AuthorityId, AuthorityWeight)>;
 
 /// A GRANDPA message for a substrate chain.
-pub type Message<Header> = grandpa::Message<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
+pub type Message<Header> =
+	finality_grandpa::Message<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
 
 /// A signed message.
-pub type SignedMessage<Header> = grandpa::SignedMessage<
+pub type SignedMessage<Header> = finality_grandpa::SignedMessage<
 	<Header as HeaderT>::Hash,
 	<Header as HeaderT>::Number,
 	AuthoritySignature,
@@ -89,21 +90,22 @@ pub type SignedMessage<Header> = grandpa::SignedMessage<
 
 /// A primary propose message for this chain's block type.
 pub type PrimaryPropose<Header> =
-	grandpa::PrimaryPropose<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
+	finality_grandpa::PrimaryPropose<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
 /// A prevote message for this chain's block type.
-pub type Prevote<Header> = grandpa::Prevote<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
+pub type Prevote<Header> =
+	finality_grandpa::Prevote<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
 /// A precommit message for this chain's block type.
 pub type Precommit<Header> =
-	grandpa::Precommit<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
+	finality_grandpa::Precommit<<Header as HeaderT>::Hash, <Header as HeaderT>::Number>;
 /// A catch up message for this chain's block type.
-pub type CatchUp<Header> = grandpa::CatchUp<
+pub type CatchUp<Header> = finality_grandpa::CatchUp<
 	<Header as HeaderT>::Hash,
 	<Header as HeaderT>::Number,
 	AuthoritySignature,
 	AuthorityId,
 >;
 /// A commit message for this chain's block type.
-pub type Commit<Header> = grandpa::Commit<
+pub type Commit<Header> = finality_grandpa::Commit<
 	<Header as HeaderT>::Hash,
 	<Header as HeaderT>::Number,
 	AuthoritySignature,
@@ -111,7 +113,7 @@ pub type Commit<Header> = grandpa::Commit<
 >;
 
 /// A compact commit message for this chain's block type.
-pub type CompactCommit<Header> = grandpa::CompactCommit<
+pub type CompactCommit<Header> = finality_grandpa::CompactCommit<
 	<Header as HeaderT>::Hash,
 	<Header as HeaderT>::Number,
 	AuthoritySignature,
@@ -266,18 +268,36 @@ impl<H, N> EquivocationProof<H, N> {
 #[derive(Clone, Debug, Decode, Encode, PartialEq, Eq, TypeInfo)]
 pub enum Equivocation<H, N> {
 	/// Proof of equivocation at prevote stage.
-	Prevote(grandpa::Equivocation<AuthorityId, grandpa::Prevote<H, N>, AuthoritySignature>),
+	Prevote(
+		finality_grandpa::Equivocation<
+			AuthorityId,
+			finality_grandpa::Prevote<H, N>,
+			AuthoritySignature,
+		>,
+	),
 	/// Proof of equivocation at precommit stage.
-	Precommit(grandpa::Equivocation<AuthorityId, grandpa::Precommit<H, N>, AuthoritySignature>),
+	Precommit(
+		finality_grandpa::Equivocation<
+			AuthorityId,
+			finality_grandpa::Precommit<H, N>,
+			AuthoritySignature,
+		>,
+	),
 }
 
-impl<H, N> From<grandpa::Equivocation<AuthorityId, grandpa::Prevote<H, N>, AuthoritySignature>>
-	for Equivocation<H, N>
+impl<H, N>
+	From<
+		finality_grandpa::Equivocation<
+			AuthorityId,
+			finality_grandpa::Prevote<H, N>,
+			AuthoritySignature,
+		>,
+	> for Equivocation<H, N>
 {
 	fn from(
-		equivocation: grandpa::Equivocation<
+		equivocation: finality_grandpa::Equivocation<
 			AuthorityId,
-			grandpa::Prevote<H, N>,
+			finality_grandpa::Prevote<H, N>,
 			AuthoritySignature,
 		>,
 	) -> Self {
@@ -285,13 +305,19 @@ impl<H, N> From<grandpa::Equivocation<AuthorityId, grandpa::Prevote<H, N>, Autho
 	}
 }
 
-impl<H, N> From<grandpa::Equivocation<AuthorityId, grandpa::Precommit<H, N>, AuthoritySignature>>
-	for Equivocation<H, N>
+impl<H, N>
+	From<
+		finality_grandpa::Equivocation<
+			AuthorityId,
+			finality_grandpa::Precommit<H, N>,
+			AuthoritySignature,
+		>,
+	> for Equivocation<H, N>
 {
 	fn from(
-		equivocation: grandpa::Equivocation<
+		equivocation: finality_grandpa::Equivocation<
 			AuthorityId,
-			grandpa::Precommit<H, N>,
+			finality_grandpa::Precommit<H, N>,
 			AuthoritySignature,
 		>,
 	) -> Self {
@@ -358,10 +384,10 @@ where
 
 	match report.equivocation {
 		Equivocation::Prevote(equivocation) => {
-			check!(equivocation, grandpa::Message::Prevote);
+			check!(equivocation, finality_grandpa::Message::Prevote);
 		},
 		Equivocation::Precommit(equivocation) => {
-			check!(equivocation, grandpa::Message::Precommit);
+			check!(equivocation, finality_grandpa::Message::Precommit);
 		},
 	}
 }
@@ -389,7 +415,7 @@ pub fn localized_payload_with_buffer<E: Encode>(
 /// Check a message signature by encoding the message as a localized payload and
 /// verifying the provided signature using the expected authority id.
 pub fn check_message_signature<H, N>(
-	message: &grandpa::Message<H, N>,
+	message: &finality_grandpa::Message<H, N>,
 	id: &AuthorityId,
 	signature: &AuthoritySignature,
 	round: RoundNumber,
@@ -407,7 +433,7 @@ where
 /// The encoding necessary to verify the signature will be done using the given
 /// buffer, the original content of the buffer will be cleared.
 pub fn check_message_signature_with_buffer<H, N>(
-	message: &grandpa::Message<H, N>,
+	message: &finality_grandpa::Message<H, N>,
 	id: &AuthorityId,
 	signature: &AuthoritySignature,
 	round: RoundNumber,
@@ -437,11 +463,11 @@ where
 #[cfg(feature = "std")]
 pub fn sign_message<H, N>(
 	keystore: KeystorePtr,
-	message: grandpa::Message<H, N>,
+	message: finality_grandpa::Message<H, N>,
 	public: AuthorityId,
 	round: RoundNumber,
 	set_id: SetId,
-) -> Option<grandpa::SignedMessage<H, N, AuthoritySignature, AuthorityId>>
+) -> Option<finality_grandpa::SignedMessage<H, N, AuthoritySignature, AuthorityId>>
 where
 	H: Encode,
 	N: Encode,
@@ -456,7 +482,7 @@ where
 		.try_into()
 		.ok()?;
 
-	Some(grandpa::SignedMessage { message, signature, id: public })
+	Some(finality_grandpa::SignedMessage { message, signature, id: public })
 }
 
 /// An opaque type used to represent the key ownership proof at the runtime API
@@ -465,22 +491,7 @@ where
 /// the runtime API boundary this type is unknown and as such we keep this
 /// opaque representation, implementors of the runtime API will have to make
 /// sure that all usages of `OpaqueKeyOwnershipProof` refer to the same type.
-#[derive(Decode, Encode, PartialEq, TypeInfo)]
-pub struct OpaqueKeyOwnershipProof(Vec<u8>);
-
-impl OpaqueKeyOwnershipProof {
-	/// Create a new `OpaqueKeyOwnershipProof` using the given encoded
-	/// representation.
-	pub fn new(inner: Vec<u8>) -> OpaqueKeyOwnershipProof {
-		OpaqueKeyOwnershipProof(inner)
-	}
-
-	/// Try to decode this `OpaqueKeyOwnershipProof` into the given concrete key
-	/// ownership proof type.
-	pub fn decode<T: Decode>(self) -> Option<T> {
-		codec::Decode::decode(&mut &self.0[..]).ok()
-	}
-}
+pub type OpaqueKeyOwnershipProof = OpaqueValue;
 
 sp_api::decl_runtime_apis! {
 	/// APIs for integrating the GRANDPA finality gadget into runtimes.
diff --git a/substrate/primitives/consensus/sassafras/Cargo.toml b/substrate/primitives/consensus/sassafras/Cargo.toml
index c8eb9b76b93b0e65de11aa65116353d1e429cfb7..792755730839226e2d200cdabccaa6f8bed0dda5 100644
--- a/substrate/primitives/consensus/sassafras/Cargo.toml
+++ b/substrate/primitives/consensus/sassafras/Cargo.toml
@@ -18,7 +18,7 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-scale-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 serde = { features = ["derive"], optional = true, workspace = true }
 sp-api = { path = "../../api", default-features = false }
@@ -30,7 +30,7 @@ sp-runtime = { path = "../../runtime", default-features = false }
 [features]
 default = ["std"]
 std = [
-	"scale-codec/std",
+	"codec/std",
 	"scale-info/std",
 	"serde/std",
 	"sp-api/std",
diff --git a/substrate/primitives/consensus/sassafras/src/digests.rs b/substrate/primitives/consensus/sassafras/src/digests.rs
index 64190a41ce1c95d5251f25f0991daf2bed4cc802..bac31f57f2da3ee590680d2545bc0375d3f4464f 100644
--- a/substrate/primitives/consensus/sassafras/src/digests.rs
+++ b/substrate/primitives/consensus/sassafras/src/digests.rs
@@ -22,7 +22,7 @@ use crate::{
 	EpochConfiguration, Randomness, Slot, SASSAFRAS_ENGINE_ID,
 };
 
-use scale_codec::{Decode, Encode, MaxEncodedLen};
+use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 #[cfg(not(feature = "std"))]
diff --git a/substrate/primitives/consensus/sassafras/src/lib.rs b/substrate/primitives/consensus/sassafras/src/lib.rs
index c1fea74d04522896b249979caac7658cb5f8a6a8..d7880c4de9e8fec6d5feb4345af90214f3ac76bc 100644
--- a/substrate/primitives/consensus/sassafras/src/lib.rs
+++ b/substrate/primitives/consensus/sassafras/src/lib.rs
@@ -24,7 +24,7 @@
 extern crate alloc;
 
 use alloc::vec::Vec;
-use scale_codec::{Decode, Encode, MaxEncodedLen};
+use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_core::crypto::KeyTypeId;
 use sp_runtime::{ConsensusEngineId, RuntimeDebug};
diff --git a/substrate/primitives/consensus/sassafras/src/ticket.rs b/substrate/primitives/consensus/sassafras/src/ticket.rs
index 345de99be28d88ec5125067f0eaaa838b13373fd..fd025f1d53eaffc01c615233d8000da220d6ea7c 100644
--- a/substrate/primitives/consensus/sassafras/src/ticket.rs
+++ b/substrate/primitives/consensus/sassafras/src/ticket.rs
@@ -18,7 +18,7 @@
 //! Primitives related to tickets.
 
 use crate::vrf::RingVrfSignature;
-use scale_codec::{Decode, Encode, MaxEncodedLen};
+use codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
 pub use sp_core::ed25519::{Public as EphemeralPublic, Signature as EphemeralSignature};
diff --git a/substrate/primitives/consensus/sassafras/src/vrf.rs b/substrate/primitives/consensus/sassafras/src/vrf.rs
index 537cff52ab6fb7e42c0309431e5dc4b5a767716a..f8def1b5f189f9be2bea1cf3ea4f4f5591ff7d4f 100644
--- a/substrate/primitives/consensus/sassafras/src/vrf.rs
+++ b/substrate/primitives/consensus/sassafras/src/vrf.rs
@@ -20,7 +20,7 @@
 use crate::{Randomness, TicketBody, TicketId};
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
-use scale_codec::Encode;
+use codec::Encode;
 use sp_consensus_slots::Slot;
 
 pub use sp_core::bandersnatch::{
diff --git a/substrate/primitives/externalities/src/lib.rs b/substrate/primitives/externalities/src/lib.rs
index 142200f614a69d8a5e195db8d434fba4bb5a83b7..bcc46ee4f1b2993fd34a5d632d2ce4a2757872e4 100644
--- a/substrate/primitives/externalities/src/lib.rs
+++ b/substrate/primitives/externalities/src/lib.rs
@@ -83,24 +83,24 @@ pub trait Externalities: ExtensionStore {
 	fn set_offchain_storage(&mut self, key: &[u8], value: Option<&[u8]>);
 
 	/// Read runtime storage.
-	fn storage(&self, key: &[u8]) -> Option<Vec<u8>>;
+	fn storage(&mut self, key: &[u8]) -> Option<Vec<u8>>;
 
 	/// Get storage value hash.
 	///
 	/// This may be optimized for large values.
-	fn storage_hash(&self, key: &[u8]) -> Option<Vec<u8>>;
+	fn storage_hash(&mut self, key: &[u8]) -> Option<Vec<u8>>;
 
 	/// Get child storage value hash.
 	///
 	/// This may be optimized for large values.
 	///
 	/// Returns an `Option` that holds the SCALE encoded hash.
-	fn child_storage_hash(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
+	fn child_storage_hash(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
 
 	/// Read child runtime storage.
 	///
 	/// Returns an `Option` that holds the SCALE encoded hash.
-	fn child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
+	fn child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
 
 	/// Set storage entry `key` of current contract being called (effective immediately).
 	fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>) {
@@ -124,20 +124,20 @@ pub trait Externalities: ExtensionStore {
 	}
 
 	/// Whether a storage entry exists.
-	fn exists_storage(&self, key: &[u8]) -> bool {
+	fn exists_storage(&mut self, key: &[u8]) -> bool {
 		self.storage(key).is_some()
 	}
 
 	/// Whether a child storage entry exists.
-	fn exists_child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> bool {
+	fn exists_child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> bool {
 		self.child_storage(child_info, key).is_some()
 	}
 
 	/// Returns the key immediately following the given key, if it exists.
-	fn next_storage_key(&self, key: &[u8]) -> Option<Vec<u8>>;
+	fn next_storage_key(&mut self, key: &[u8]) -> Option<Vec<u8>>;
 
 	/// Returns the key immediately following the given key, if it exists, in child storage.
-	fn next_child_storage_key(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
+	fn next_child_storage_key(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
 
 	/// Clear an entire child storage.
 	///
diff --git a/substrate/primitives/io/Cargo.toml b/substrate/primitives/io/Cargo.toml
index abb16d163da060ae1d152276189157b77fb6970d..f6e157680f9c3a988c4371a649ac742a030735cb 100644
--- a/substrate/primitives/io/Cargo.toml
+++ b/substrate/primitives/io/Cargo.toml
@@ -19,7 +19,9 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 bytes = { version = "1.1.0", default-features = false }
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["bytes"] }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
+	"bytes",
+] }
 sp-core = { path = "../core", default-features = false }
 sp-crypto-hashing = { path = "../crypto/hashing", default-features = false }
 sp-keystore = { path = "../keystore", default-features = false, optional = true }
@@ -31,13 +33,18 @@ sp-trie = { path = "../trie", default-features = false, optional = true }
 sp-externalities = { path = "../externalities", default-features = false }
 sp-tracing = { path = "../tracing", default-features = false }
 log = { optional = true, workspace = true, default-features = true }
-secp256k1 = { version = "0.28.0", features = ["global-context", "recovery"], optional = true }
+secp256k1 = { version = "0.28.0", features = [
+	"global-context",
+	"recovery",
+], optional = true }
 tracing = { version = "0.1.29", default-features = false }
 tracing-core = { version = "0.1.32", default-features = false }
 
 # Required for backwards compatibility reason, but only used for verifying when `UseDalekExt` is set.
 ed25519-dalek = { version = "2.1", default-features = false, optional = true }
 
+docify = { version = "0.2.8" }
+
 [target.'cfg(all(any(target_arch = "riscv32", target_arch = "riscv64"), substrate_runtime))'.dependencies]
 polkavm-derive = { workspace = true }
 
diff --git a/substrate/primitives/io/src/lib.rs b/substrate/primitives/io/src/lib.rs
index c8675a9a90bd2ee16b9deca27457fafa88f8fec0..67e822ba7e248ed2b07614b85dca4e1c72e8c3e3 100644
--- a/substrate/primitives/io/src/lib.rs
+++ b/substrate/primitives/io/src/lib.rs
@@ -181,7 +181,7 @@ impl From<MultiRemovalResults> for KillStorageResult {
 #[runtime_interface]
 pub trait Storage {
 	/// Returns the data for `key` in the storage or `None` if the key can not be found.
-	fn get(&self, key: &[u8]) -> Option<bytes::Bytes> {
+	fn get(&mut self, key: &[u8]) -> Option<bytes::Bytes> {
 		self.storage(key).map(bytes::Bytes::from)
 	}
 
@@ -190,7 +190,7 @@ pub trait Storage {
 	/// doesn't exist at all.
 	/// If `value_out` length is smaller than the returned length, only `value_out` length bytes
 	/// are copied into `value_out`.
-	fn read(&self, key: &[u8], value_out: &mut [u8], value_offset: u32) -> Option<u32> {
+	fn read(&mut self, key: &[u8], value_out: &mut [u8], value_offset: u32) -> Option<u32> {
 		self.storage(key).map(|value| {
 			let value_offset = value_offset as usize;
 			let data = &value[value_offset.min(value.len())..];
@@ -211,7 +211,7 @@ pub trait Storage {
 	}
 
 	/// Check whether the given `key` exists in storage.
-	fn exists(&self, key: &[u8]) -> bool {
+	fn exists(&mut self, key: &[u8]) -> bool {
 		self.exists_storage(key)
 	}
 
@@ -387,7 +387,7 @@ pub trait DefaultChildStorage {
 	///
 	/// Parameter `storage_key` is the unprefixed location of the root of the child trie in the
 	/// parent trie. Result is `None` if the value for `key` in the child storage can not be found.
-	fn get(&self, storage_key: &[u8], key: &[u8]) -> Option<Vec<u8>> {
+	fn get(&mut self, storage_key: &[u8], key: &[u8]) -> Option<Vec<u8>> {
 		let child_info = ChildInfo::new_default(storage_key);
 		self.child_storage(&child_info, key).map(|s| s.to_vec())
 	}
@@ -400,7 +400,7 @@ pub trait DefaultChildStorage {
 	/// If `value_out` length is smaller than the returned length, only `value_out` length bytes
 	/// are copied into `value_out`.
 	fn read(
-		&self,
+		&mut self,
 		storage_key: &[u8],
 		key: &[u8],
 		value_out: &mut [u8],
@@ -478,7 +478,7 @@ pub trait DefaultChildStorage {
 	/// Check a child storage key.
 	///
 	/// Check whether the given `key` exists in default child defined at `storage_key`.
-	fn exists(&self, storage_key: &[u8], key: &[u8]) -> bool {
+	fn exists(&mut self, storage_key: &[u8], key: &[u8]) -> bool {
 		let child_info = ChildInfo::new_default(storage_key);
 		self.exists_child_storage(&child_info, key)
 	}
@@ -1805,6 +1805,7 @@ pub type TestExternalities = sp_state_machine::TestExternalities<sp_core::Blake2
 /// The host functions Substrate provides for the Wasm runtime environment.
 ///
 /// All these host functions will be callable from inside the Wasm environment.
+#[docify::export]
 #[cfg(feature = "std")]
 pub type SubstrateHostFunctions = (
 	storage::HostFunctions,
diff --git a/substrate/primitives/keystore/src/testing.rs b/substrate/primitives/keystore/src/testing.rs
index d8610ecfa5b60d8891b6690e00ce6efb55342983..1403e4745ff11120606295ef3c69cbb116843e8b 100644
--- a/substrate/primitives/keystore/src/testing.rs
+++ b/substrate/primitives/keystore/src/testing.rs
@@ -516,7 +516,7 @@ mod tests {
 		let suri = "//Alice";
 		let pair = ecdsa_bls377::Pair::from_string(suri, None).unwrap();
 
-		let msg = b"this should be a normal unhashed message not ";
+		let msg = b"this should be a normal unhashed message not a hash of a message because bls scheme comes with its own hashing";
 
 		// insert key, sign again
 		store.insert(ECDSA_BLS377, suri, pair.public().as_ref()).unwrap();
diff --git a/substrate/primitives/merkle-mountain-range/Cargo.toml b/substrate/primitives/merkle-mountain-range/Cargo.toml
index 23efc1b687c2b812be0bf1cd78e21b69941e9af8..7b043355c723b0627b574284782a0252e0b536dc 100644
--- a/substrate/primitives/merkle-mountain-range/Cargo.toml
+++ b/substrate/primitives/merkle-mountain-range/Cargo.toml
@@ -18,7 +18,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
 log = { workspace = true }
-mmr-lib = { package = "ckb-merkle-mountain-range", git = "https://github.com/paritytech/merkle-mountain-range.git", branch = "master", default-features = false }
+mmr-lib = { package = "polkadot-ckb-merkle-mountain-range", version = "0.7.0", default-features = false }
 serde = { features = ["alloc", "derive"], optional = true, workspace = true }
 sp-api = { path = "../api", default-features = false }
 sp-core = { path = "../core", default-features = false }
diff --git a/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs b/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs
index 8f6c0c6f650daa36f18f132e3fc0fa13eaa76621..df1f5645f04827873fdee3e984f851d40b836c25 100644
--- a/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs
+++ b/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs
@@ -57,7 +57,7 @@ type UncheckedSignaturePayload<Address, Signature, Extra> = (Address, Signature,
 /// could in principle be any other interaction. Transactions are either signed or unsigned. A
 /// sensible transaction pool should ensure that only transactions that are worthwhile are
 /// considered for block-building.
-#[cfg_attr(feature = "std", doc = simple_mermaid::mermaid!("../../docs/mermaid/extrinsics.mmd"))]
+#[cfg_attr(all(feature = "std", not(windows)), doc = simple_mermaid::mermaid!("../../docs/mermaid/extrinsics.mmd"))]
 /// This type is by no means enforced within Substrate, but given its genericness, it is highly
 /// likely that for most use-cases it will suffice. Thus, the encoding of this type will dictate
 /// exactly what bytes should be sent to a runtime to transact with it.
diff --git a/substrate/primitives/runtime/src/lib.rs b/substrate/primitives/runtime/src/lib.rs
index e4e6b98ff77cf786ce9fb37958bdaeff9a36c76c..046909b9a38d732a80f5178d228090fe10939c8d 100644
--- a/substrate/primitives/runtime/src/lib.rs
+++ b/substrate/primitives/runtime/src/lib.rs
@@ -1009,6 +1009,21 @@ pub enum ExtrinsicInclusionMode {
 	OnlyInherents,
 }
 
+/// Simple blob that hold a value in an encoded form without committing to its type.
+#[derive(Decode, Encode, PartialEq, TypeInfo)]
+pub struct OpaqueValue(Vec<u8>);
+impl OpaqueValue {
+	/// Create a new `OpaqueValue` using the given encoded representation.
+	pub fn new(inner: Vec<u8>) -> OpaqueValue {
+		OpaqueValue(inner)
+	}
+
+	/// Try to decode this `OpaqueValue` into the given concrete type.
+	pub fn decode<T: Decode>(&self) -> Option<T> {
+		Decode::decode(&mut &self.0[..]).ok()
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use crate::traits::BlakeTwo256;
diff --git a/substrate/primitives/staking/src/lib.rs b/substrate/primitives/staking/src/lib.rs
index c7045508cea3ff789e8a8910170f97dcca82c6d0..c1cf7f2778ff6ea4041c88f90bb48522d1f1c7e9 100644
--- a/substrate/primitives/staking/src/lib.rs
+++ b/substrate/primitives/staking/src/lib.rs
@@ -285,6 +285,13 @@ pub trait StakingInterface {
 		Self::status(who).map(|s| matches!(s, StakerStatus::Validator)).unwrap_or(false)
 	}
 
+	/// Checks whether the staker is a virtual account.
+	///
+	/// A virtual staker is an account whose locks are not managed by the [`StakingInterface`]
+	/// implementation but by an external pallet. See [`StakingUnchecked::virtual_bond`] for more
+	/// details.
+	fn is_virtual_staker(who: &Self::AccountId) -> bool;
+
 	/// Get the nominations of a stash, if they are a nominator, `None` otherwise.
 	fn nominations(who: &Self::AccountId) -> Option<Vec<Self::AccountId>> {
 		match Self::status(who) {
@@ -456,17 +463,48 @@ pub struct PagedExposureMetadata<Balance: HasCompact + codec::MaxEncodedLen> {
 	pub page_count: Page,
 }
 
-/// Trait to provide delegation functionality for stakers.
+/// A type that belongs only in the context of an `Agent`.
 ///
-/// Introduces two new terms to the staking system:
-/// - `Delegator`: An account that delegates funds to an `Agent`.
-/// - `Agent`: An account that receives delegated funds from `Delegators`. It can then use these
-/// funds to participate in the staking system. It can never use its own funds to stake. They
-/// (virtually bond)[`StakingUnchecked::virtual_bond`] into the staking system and can also be
-/// termed as `Virtual Nominators`.
+/// `Agent` is someone that manages delegated funds from [`Delegator`] accounts. It can
+/// then use these funds to participate in the staking system. It can never use its own funds to
+/// stake. They instead (virtually bond)[`StakingUnchecked::virtual_bond`] into the staking system
+/// and are also called `Virtual Stakers`.
 ///
-/// The `Agent` is responsible for managing rewards and slashing for all the `Delegators` that
+/// The `Agent` is also responsible for managing rewards and slashing for all the `Delegators` that
 /// have delegated funds to it.
+#[derive(Clone, Debug)]
+pub struct Agent<T>(T);
+impl<T> From<T> for Agent<T> {
+	fn from(acc: T) -> Self {
+		Agent(acc)
+	}
+}
+
+impl<T> Agent<T> {
+	pub fn get(self) -> T {
+		self.0
+	}
+}
+
+/// A type that belongs only in the context of a `Delegator`.
+///
+/// `Delegator` is someone that delegates funds to an `Agent`, allowing them to pool funds
+/// along with other delegators and participate in the staking system.
+#[derive(Clone, Debug)]
+pub struct Delegator<T>(T);
+impl<T> From<T> for Delegator<T> {
+	fn from(acc: T) -> Self {
+		Delegator(acc)
+	}
+}
+
+impl<T> Delegator<T> {
+	pub fn get(self) -> T {
+		self.0
+	}
+}
+
+/// Trait to provide delegation functionality for stakers.
 pub trait DelegationInterface {
 	/// Balance type used by the staking system.
 	type Balance: Sub<Output = Self::Balance>
@@ -482,20 +520,20 @@ pub trait DelegationInterface {
 	/// AccountId type used by the staking system.
 	type AccountId: Clone + core::fmt::Debug;
 
-	/// Effective balance of the `Agent` account.
+	/// Returns effective balance of the `Agent` account. `None` if not an `Agent`.
 	///
-	/// This takes into account any pending slashes to `Agent`.
-	fn agent_balance(agent: &Self::AccountId) -> Self::Balance;
+	/// This takes into account any pending slashes to `Agent` against the delegated balance.
+	fn agent_balance(agent: Agent<Self::AccountId>) -> Option<Self::Balance>;
 
-	/// Returns the total amount of funds delegated by a `delegator`.
-	fn delegator_balance(delegator: &Self::AccountId) -> Self::Balance;
+	/// Returns the total amount of funds delegated. `None` if not a `Delegator`.
+	fn delegator_balance(delegator: Delegator<Self::AccountId>) -> Option<Self::Balance>;
 
 	/// Delegate funds to `Agent`.
 	///
 	/// Only used for the initial delegation. Use [`Self::delegate_extra`] to add more delegation.
 	fn delegate(
-		delegator: &Self::AccountId,
-		agent: &Self::AccountId,
+		delegator: Delegator<Self::AccountId>,
+		agent: Agent<Self::AccountId>,
 		reward_account: &Self::AccountId,
 		amount: Self::Balance,
 	) -> DispatchResult;
@@ -504,8 +542,8 @@ pub trait DelegationInterface {
 	///
 	/// If this is the first delegation, use [`Self::delegate`] instead.
 	fn delegate_extra(
-		delegator: &Self::AccountId,
-		agent: &Self::AccountId,
+		delegator: Delegator<Self::AccountId>,
+		agent: Agent<Self::AccountId>,
 		amount: Self::Balance,
 	) -> DispatchResult;
 
@@ -514,25 +552,25 @@ pub trait DelegationInterface {
 	/// If there are `Agent` funds upto `amount` available to withdraw, then those funds would
 	/// be released to the `delegator`
 	fn withdraw_delegation(
-		delegator: &Self::AccountId,
-		agent: &Self::AccountId,
+		delegator: Delegator<Self::AccountId>,
+		agent: Agent<Self::AccountId>,
 		amount: Self::Balance,
 		num_slashing_spans: u32,
 	) -> DispatchResult;
 
-	/// Returns true if there are pending slashes posted to the `Agent` account.
+	/// Returns pending slashes posted to the `Agent` account. None if not an `Agent`.
 	///
 	/// Slashes to `Agent` account are not immediate and are applied lazily. Since `Agent`
 	/// has an unbounded number of delegators, immediate slashing is not possible.
-	fn has_pending_slash(agent: &Self::AccountId) -> bool;
+	fn pending_slash(agent: Agent<Self::AccountId>) -> Option<Self::Balance>;
 
 	/// Apply a pending slash to an `Agent` by slashing `value` from `delegator`.
 	///
 	/// A reporter may be provided (if one exists) in order for the implementor to reward them,
 	/// if applicable.
 	fn delegator_slash(
-		agent: &Self::AccountId,
-		delegator: &Self::AccountId,
+		agent: Agent<Self::AccountId>,
+		delegator: Delegator<Self::AccountId>,
 		value: Self::Balance,
 		maybe_reporter: Option<Self::AccountId>,
 	) -> DispatchResult;
@@ -560,7 +598,7 @@ pub trait DelegationMigrator {
 	/// The implementation should ensure the `Nominator` account funds are moved to an escrow
 	/// from which `Agents` can later release funds to its `Delegators`.
 	fn migrate_nominator_to_agent(
-		agent: &Self::AccountId,
+		agent: Agent<Self::AccountId>,
 		reward_account: &Self::AccountId,
 	) -> DispatchResult;
 
@@ -569,10 +607,16 @@ pub trait DelegationMigrator {
 	/// When a direct `Nominator` migrates to `Agent`, the funds are kept in escrow. This function
 	/// allows the `Agent` to release the funds to the `delegator`.
 	fn migrate_delegation(
-		agent: &Self::AccountId,
-		delegator: &Self::AccountId,
+		agent: Agent<Self::AccountId>,
+		delegator: Delegator<Self::AccountId>,
 		value: Self::Balance,
 	) -> DispatchResult;
+
+	/// Drop the `Agent` account and its associated delegators.
+	///
+	/// Also removed from [`StakingUnchecked`] as a Virtual Staker. Useful for testing.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn drop_agent(agent: Agent<Self::AccountId>);
 }
 
 sp_core::generate_feature_enabled_macro!(runtime_benchmarks_enabled, feature = "runtime-benchmarks", $);
diff --git a/substrate/primitives/state-machine/Cargo.toml b/substrate/primitives/state-machine/Cargo.toml
index c383a17cb006e3c4433172aedde957465fbb569f..f6402eccf0df0c7f9161bd8daf9456b267702876 100644
--- a/substrate/primitives/state-machine/Cargo.toml
+++ b/substrate/primitives/state-machine/Cargo.toml
@@ -30,6 +30,7 @@ sp-externalities = { path = "../externalities", default-features = false }
 sp-panic-handler = { path = "../panic-handler", optional = true }
 sp-trie = { path = "../trie", default-features = false }
 trie-db = { version = "0.29.0", default-features = false }
+arbitrary = { version = "1", features = ["derive"], optional = true }
 
 [dev-dependencies]
 array-bytes = "6.2.2"
@@ -37,9 +38,11 @@ pretty_assertions = "1.2.1"
 rand = "0.8.5"
 sp-runtime = { path = "../runtime" }
 assert_matches = "1.5"
+arbitrary = { version = "1", features = ["derive"] }
 
 [features]
 default = ["std"]
+fuzzing = ["arbitrary"]
 std = [
 	"codec/std",
 	"hash-db/std",
diff --git a/substrate/primitives/state-machine/fuzz/Cargo.toml b/substrate/primitives/state-machine/fuzz/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..416c00c34fda4e8e1853f2b8d414e40f7d1ff808
--- /dev/null
+++ b/substrate/primitives/state-machine/fuzz/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "sp-state-machine-fuzz"
+version = "0.0.0"
+publish = false
+license = "Apache-2.0"
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+sp-runtime = { path = "../../runtime" }
+
+[dependencies.sp-state-machine]
+path = ".."
+features = ["fuzzing"]
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[profile.release]
+debug = 1
+
+[[bin]]
+name = "fuzz_append"
+path = "fuzz_targets/fuzz_append.rs"
+test = false
+doc = false
diff --git a/substrate/primitives/state-machine/fuzz/fuzz_targets/fuzz_append.rs b/substrate/primitives/state-machine/fuzz/fuzz_targets/fuzz_append.rs
new file mode 100644
index 0000000000000000000000000000000000000000..44847f535655f61a7b40bf2d8d08484abbdccddb
--- /dev/null
+++ b/substrate/primitives/state-machine/fuzz/fuzz_targets/fuzz_append.rs
@@ -0,0 +1,26 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use sp_state_machine::fuzzing::{fuzz_append, FuzzAppendPayload};
+use sp_runtime::traits::BlakeTwo256;
+
+fuzz_target!(|data: FuzzAppendPayload| {
+	fuzz_append::<BlakeTwo256>(data);
+});
diff --git a/substrate/primitives/state-machine/src/basic.rs b/substrate/primitives/state-machine/src/basic.rs
index 8b6f746eaba0af9438557dc7dbe118bfbc4cdf34..6201d60ababd27d1e212791a03e62b7915be2c98 100644
--- a/substrate/primitives/state-machine/src/basic.rs
+++ b/substrate/primitives/state-machine/src/basic.rs
@@ -59,16 +59,17 @@ impl BasicExternalities {
 	}
 
 	/// Consume self and returns inner storages
-	pub fn into_storages(self) -> Storage {
+	#[cfg(feature = "std")]
+	pub fn into_storages(mut self) -> Storage {
 		Storage {
 			top: self
 				.overlay
-				.changes()
+				.changes_mut()
 				.filter_map(|(k, v)| v.value().map(|v| (k.to_vec(), v.to_vec())))
 				.collect(),
 			children_default: self
 				.overlay
-				.children()
+				.children_mut()
 				.map(|(iter, i)| {
 					(
 						i.storage_key().to_vec(),
@@ -87,6 +88,7 @@ impl BasicExternalities {
 	/// Execute the given closure `f` with the externalities set and initialized with `storage`.
 	///
 	/// Returns the result of the closure and updates `storage` with all changes.
+	#[cfg(feature = "std")]
 	pub fn execute_with_storage<R>(
 		storage: &mut sp_core::storage::Storage,
 		f: impl FnOnce() -> R,
@@ -118,19 +120,37 @@ impl BasicExternalities {
 	}
 }
 
+#[cfg(test)]
 impl PartialEq for BasicExternalities {
-	fn eq(&self, other: &BasicExternalities) -> bool {
-		self.overlay.changes().map(|(k, v)| (k, v.value())).collect::<BTreeMap<_, _>>() ==
-			other.overlay.changes().map(|(k, v)| (k, v.value())).collect::<BTreeMap<_, _>>() &&
+	fn eq(&self, other: &Self) -> bool {
+		self.overlay
+			.changes()
+			.map(|(k, v)| (k, v.value_ref().materialize()))
+			.collect::<BTreeMap<_, _>>() ==
+			other
+				.overlay
+				.changes()
+				.map(|(k, v)| (k, v.value_ref().materialize()))
+				.collect::<BTreeMap<_, _>>() &&
 			self.overlay
 				.children()
-				.map(|(iter, i)| (i, iter.map(|(k, v)| (k, v.value())).collect::<BTreeMap<_, _>>()))
+				.map(|(iter, i)| {
+					(
+						i,
+						iter.map(|(k, v)| (k, v.value_ref().materialize()))
+							.collect::<BTreeMap<_, _>>(),
+					)
+				})
 				.collect::<BTreeMap<_, _>>() ==
 				other
 					.overlay
 					.children()
 					.map(|(iter, i)| {
-						(i, iter.map(|(k, v)| (k, v.value())).collect::<BTreeMap<_, _>>())
+						(
+							i,
+							iter.map(|(k, v)| (k, v.value_ref().materialize()))
+								.collect::<BTreeMap<_, _>>(),
+						)
 					})
 					.collect::<BTreeMap<_, _>>()
 	}
@@ -159,27 +179,27 @@ impl From<BTreeMap<StorageKey, StorageValue>> for BasicExternalities {
 impl Externalities for BasicExternalities {
 	fn set_offchain_storage(&mut self, _key: &[u8], _value: Option<&[u8]>) {}
 
-	fn storage(&self, key: &[u8]) -> Option<StorageValue> {
+	fn storage(&mut self, key: &[u8]) -> Option<StorageValue> {
 		self.overlay.storage(key).and_then(|v| v.map(|v| v.to_vec()))
 	}
 
-	fn storage_hash(&self, key: &[u8]) -> Option<Vec<u8>> {
+	fn storage_hash(&mut self, key: &[u8]) -> Option<Vec<u8>> {
 		self.storage(key).map(|v| Blake2Hasher::hash(&v).encode())
 	}
 
-	fn child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageValue> {
+	fn child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageValue> {
 		self.overlay.child_storage(child_info, key).and_then(|v| v.map(|v| v.to_vec()))
 	}
 
-	fn child_storage_hash(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage_hash(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
 		self.child_storage(child_info, key).map(|v| Blake2Hasher::hash(&v).encode())
 	}
 
-	fn next_storage_key(&self, key: &[u8]) -> Option<StorageKey> {
+	fn next_storage_key(&mut self, key: &[u8]) -> Option<StorageKey> {
 		self.overlay.iter_after(key).find_map(|(k, v)| v.value().map(|_| k.to_vec()))
 	}
 
-	fn next_child_storage_key(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageKey> {
+	fn next_child_storage_key(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageKey> {
 		self.overlay
 			.child_iter_after(child_info.storage_key(), key)
 			.find_map(|(k, v)| v.value().map(|_| k.to_vec()))
@@ -243,15 +263,14 @@ impl Externalities for BasicExternalities {
 		MultiRemovalResults { maybe_cursor: None, backend: count, unique: count, loops: count }
 	}
 
-	fn storage_append(&mut self, key: Vec<u8>, value: Vec<u8>) {
-		let current_value = self.overlay.value_mut_or_insert_with(&key, || Default::default());
-		crate::ext::StorageAppend::new(current_value).append(value);
+	fn storage_append(&mut self, key: Vec<u8>, element: Vec<u8>) {
+		self.overlay.append_storage(key, element, Default::default);
 	}
 
 	fn storage_root(&mut self, state_version: StateVersion) -> Vec<u8> {
 		let mut top = self
 			.overlay
-			.changes()
+			.changes_mut()
 			.filter_map(|(k, v)| v.value().map(|v| (k.clone(), v.clone())))
 			.collect::<BTreeMap<_, _>>();
 		// Single child trie implementation currently allows using the same child
@@ -278,7 +297,7 @@ impl Externalities for BasicExternalities {
 		child_info: &ChildInfo,
 		state_version: StateVersion,
 	) -> Vec<u8> {
-		if let Some((data, child_info)) = self.overlay.child_changes(child_info.storage_key()) {
+		if let Some((data, child_info)) = self.overlay.child_changes_mut(child_info.storage_key()) {
 			let delta =
 				data.into_iter().map(|(k, v)| (k.as_ref(), v.value().map(|v| v.as_slice())));
 			crate::in_memory_backend::new_in_mem::<Blake2Hasher>()
diff --git a/substrate/primitives/state-machine/src/ext.rs b/substrate/primitives/state-machine/src/ext.rs
index 9aa32bc866cfab9e2db44959c93bc4fe0b11e120..7a79c4e8a1f1bbd51fbdb34f5b91d2427bdd2995 100644
--- a/substrate/primitives/state-machine/src/ext.rs
+++ b/substrate/primitives/state-machine/src/ext.rs
@@ -22,7 +22,7 @@ use crate::overlayed_changes::OverlayedExtensions;
 use crate::{
 	backend::Backend, IndexOperation, IterArgs, OverlayedChanges, StorageKey, StorageValue,
 };
-use codec::{Encode, EncodeAppend};
+use codec::{Compact, CompactLen, Decode, Encode};
 use hash_db::Hasher;
 #[cfg(feature = "std")]
 use sp_core::hexdisplay::HexDisplay;
@@ -31,8 +31,8 @@ use sp_core::storage::{
 };
 use sp_externalities::{Extension, ExtensionStore, Externalities, MultiRemovalResults};
 
-use crate::{log_error, trace, warn};
-use alloc::{boxed::Box, vec, vec::Vec};
+use crate::{trace, warn};
+use alloc::{boxed::Box, vec::Vec};
 use core::{
 	any::{Any, TypeId},
 	cmp::Ordering,
@@ -139,7 +139,7 @@ where
 	H::Out: Ord + 'static,
 	B: 'a + Backend<H>,
 {
-	pub fn storage_pairs(&self) -> Vec<(StorageKey, StorageValue)> {
+	pub fn storage_pairs(&mut self) -> Vec<(StorageKey, StorageValue)> {
 		use std::collections::HashMap;
 
 		self.backend
@@ -147,7 +147,7 @@ where
 			.expect("never fails in tests; qed.")
 			.map(|key_value| key_value.expect("never fails in tests; qed."))
 			.map(|(k, v)| (k, Some(v)))
-			.chain(self.overlay.changes().map(|(k, v)| (k.clone(), v.value().cloned())))
+			.chain(self.overlay.changes_mut().map(|(k, v)| (k.clone(), v.value().cloned())))
 			.collect::<HashMap<_, _>>()
 			.into_iter()
 			.filter_map(|(k, maybe_val)| maybe_val.map(|val| (k, val)))
@@ -165,7 +165,7 @@ where
 		self.overlay.set_offchain_storage(key, value)
 	}
 
-	fn storage(&self, key: &[u8]) -> Option<StorageValue> {
+	fn storage(&mut self, key: &[u8]) -> Option<StorageValue> {
 		let _guard = guard();
 		let result = self
 			.overlay
@@ -191,7 +191,7 @@ where
 		result
 	}
 
-	fn storage_hash(&self, key: &[u8]) -> Option<Vec<u8>> {
+	fn storage_hash(&mut self, key: &[u8]) -> Option<Vec<u8>> {
 		let _guard = guard();
 		let result = self
 			.overlay
@@ -209,7 +209,7 @@ where
 		result.map(|r| r.encode())
 	}
 
-	fn child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageValue> {
+	fn child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageValue> {
 		let _guard = guard();
 		let result = self
 			.overlay
@@ -231,7 +231,7 @@ where
 		result
 	}
 
-	fn child_storage_hash(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage_hash(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
 		let _guard = guard();
 		let result = self
 			.overlay
@@ -253,7 +253,7 @@ where
 		result.map(|r| r.encode())
 	}
 
-	fn exists_storage(&self, key: &[u8]) -> bool {
+	fn exists_storage(&mut self, key: &[u8]) -> bool {
 		let _guard = guard();
 		let result = match self.overlay.storage(key) {
 			Some(x) => x.is_some(),
@@ -271,7 +271,7 @@ where
 		result
 	}
 
-	fn exists_child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> bool {
+	fn exists_child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> bool {
 		let _guard = guard();
 
 		let result = match self.overlay.child_storage(child_info, key) {
@@ -293,7 +293,7 @@ where
 		result
 	}
 
-	fn next_storage_key(&self, key: &[u8]) -> Option<StorageKey> {
+	fn next_storage_key(&mut self, key: &[u8]) -> Option<StorageKey> {
 		let mut next_backend_key =
 			self.backend.next_storage_key(key).expect(EXT_NOT_ALLOWED_TO_FAIL);
 		let mut overlay_changes = self.overlay.iter_after(key).peekable();
@@ -331,7 +331,7 @@ where
 		}
 	}
 
-	fn next_child_storage_key(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageKey> {
+	fn next_child_storage_key(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageKey> {
 		let mut next_backend_key = self
 			.backend
 			.next_child_storage_key(child_info, key)
@@ -501,10 +501,9 @@ where
 		let _guard = guard();
 
 		let backend = &mut self.backend;
-		let current_value = self.overlay.value_mut_or_insert_with(&key, || {
+		self.overlay.append_storage(key.clone(), value, || {
 			backend.storage(&key).expect(EXT_NOT_ALLOWED_TO_FAIL).unwrap_or_default()
 		});
-		StorageAppend::new(current_value).append(value);
 	}
 
 	fn storage_root(&mut self, state_version: StateVersion) -> Vec<u8> {
@@ -731,10 +730,27 @@ impl<'a> StorageAppend<'a> {
 		Self(storage)
 	}
 
+	/// Extract the length of the list like data structure.
+	pub fn extract_length(&self) -> Option<u32> {
+		Compact::<u32>::decode(&mut &self.0[..]).map(|c| c.0).ok()
+	}
+
+	/// Replace the length in the encoded data.
+	///
+	/// If `old_length` is `None`, the previous length will be assumed to be `0`.
+	pub fn replace_length(&mut self, old_length: Option<u32>, new_length: u32) {
+		let old_len_encoded_len = old_length.map(|l| Compact::<u32>::compact_len(&l)).unwrap_or(0);
+		let new_len_encoded = Compact::<u32>(new_length).encode();
+		self.0.splice(0..old_len_encoded_len, new_len_encoded);
+	}
+
 	/// Append the given `value` to the storage item.
 	///
-	/// If appending fails, `[value]` is stored in the storage item.
-	pub fn append(&mut self, value: Vec<u8>) {
+	/// If appending fails, `[value]` is stored in the storage item and we return false.
+	#[cfg(any(test, feature = "fuzzing"))]
+	pub fn append(&mut self, value: Vec<u8>) -> bool {
+		use codec::EncodeAppend;
+		let mut result = true;
 		let value = vec![EncodeOpaqueValue(value)];
 
 		let item = core::mem::take(self.0);
@@ -742,13 +758,20 @@ impl<'a> StorageAppend<'a> {
 		*self.0 = match Vec::<EncodeOpaqueValue>::append_or_new(item, &value) {
 			Ok(item) => item,
 			Err(_) => {
-				log_error!(
+				result = false;
+				crate::log_error!(
 					target: "runtime",
 					"Failed to append value, resetting storage item to `[value]`.",
 				);
 				value.encode()
 			},
 		};
+		result
+	}
+
+	/// Append to current buffer, do not touch the prefixed length.
+	pub fn append_raw(&mut self, mut value: Vec<u8>) {
+		self.0.append(&mut value)
 	}
 }
 
@@ -849,7 +872,7 @@ mod tests {
 		)
 			.into();
 
-		let ext = TestExt::new(&mut overlay, &backend, None);
+		let mut ext = TestExt::new(&mut overlay, &backend, None);
 
 		// next_backend < next_overlay
 		assert_eq!(ext.next_storage_key(&[5]), Some(vec![10]));
@@ -865,7 +888,7 @@ mod tests {
 
 		drop(ext);
 		overlay.set_storage(vec![50], Some(vec![50]));
-		let ext = TestExt::new(&mut overlay, &backend, None);
+		let mut ext = TestExt::new(&mut overlay, &backend, None);
 
 		// next_overlay exist but next_backend doesn't exist
 		assert_eq!(ext.next_storage_key(&[40]), Some(vec![50]));
@@ -895,7 +918,7 @@ mod tests {
 		)
 			.into();
 
-		let ext = TestExt::new(&mut overlay, &backend, None);
+		let mut ext = TestExt::new(&mut overlay, &backend, None);
 
 		assert_eq!(ext.next_storage_key(&[5]), Some(vec![30]));
 
@@ -928,7 +951,7 @@ mod tests {
 		)
 			.into();
 
-		let ext = TestExt::new(&mut overlay, &backend, None);
+		let mut ext = TestExt::new(&mut overlay, &backend, None);
 
 		// next_backend < next_overlay
 		assert_eq!(ext.next_child_storage_key(child_info, &[5]), Some(vec![10]));
@@ -944,7 +967,7 @@ mod tests {
 
 		drop(ext);
 		overlay.set_child_storage(child_info, vec![50], Some(vec![50]));
-		let ext = TestExt::new(&mut overlay, &backend, None);
+		let mut ext = TestExt::new(&mut overlay, &backend, None);
 
 		// next_overlay exist but next_backend doesn't exist
 		assert_eq!(ext.next_child_storage_key(child_info, &[40]), Some(vec![50]));
@@ -975,7 +998,7 @@ mod tests {
 		)
 			.into();
 
-		let ext = TestExt::new(&mut overlay, &backend, None);
+		let mut ext = TestExt::new(&mut overlay, &backend, None);
 
 		assert_eq!(ext.child_storage(child_info, &[10]), Some(vec![10]));
 		assert_eq!(
diff --git a/substrate/primitives/state-machine/src/fuzzing.rs b/substrate/primitives/state-machine/src/fuzzing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e147e6e88003cf720d4f6062c392630602210388
--- /dev/null
+++ b/substrate/primitives/state-machine/src/fuzzing.rs
@@ -0,0 +1,319 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! State machine fuzzing implementation, behind `fuzzing` feature.
+
+use super::{ext::Ext, *};
+use crate::ext::StorageAppend;
+use arbitrary::Arbitrary;
+#[cfg(test)]
+use codec::Encode;
+use hash_db::Hasher;
+use sp_core::{storage::StateVersion, traits::Externalities};
+#[cfg(test)]
+use sp_runtime::traits::BlakeTwo256;
+use sp_trie::PrefixedMemoryDB;
+use std::collections::BTreeMap;
+
+#[derive(Arbitrary, Debug, Clone)]
+enum DataLength {
+	Zero = 0,
+	Small = 1,
+	Medium = 3,
+	Big = 300, // 2 byte scale encode length
+}
+
+#[derive(Arbitrary, Debug, Clone)]
+#[repr(u8)]
+enum DataValue {
+	A = b'a',
+	B = b'b',
+	C = b'c',
+	D = b'd',       // This can be read as a multiple byte compact length.
+	EasyBug = 20u8, // value compact len.
+}
+
+/// Action to fuzz
+#[derive(Arbitrary, Debug, Clone)]
+enum FuzzAppendItem {
+	Append(DataValue, DataLength),
+	Insert(DataValue, DataLength),
+	StartTransaction,
+	RollbackTransaction,
+	CommitTransaction,
+	Read,
+	Remove,
+	// To go over 256 items easily (different compact size then).
+	Append50(DataValue, DataLength),
+}
+
+/// Arbitrary payload for fuzzing append.
+#[derive(Arbitrary, Debug, Clone)]
+pub struct FuzzAppendPayload(Vec<FuzzAppendItem>, Option<(DataValue, DataLength)>);
+
+struct SimpleOverlay {
+	data: Vec<BTreeMap<Vec<u8>, Option<Vec<u8>>>>,
+}
+
+impl Default for SimpleOverlay {
+	fn default() -> Self {
+		Self { data: vec![BTreeMap::new()] }
+	}
+}
+
+impl SimpleOverlay {
+	fn insert(&mut self, key: Vec<u8>, value: Option<Vec<u8>>) {
+		self.data.last_mut().expect("always at least one item").insert(key, value);
+	}
+
+	fn append<H>(
+		&mut self,
+		key: Vec<u8>,
+		value: Vec<u8>,
+		backend: &mut TrieBackend<PrefixedMemoryDB<H>, H>,
+	) where
+		H: Hasher,
+		H::Out: codec::Decode + codec::Encode + 'static,
+	{
+		let current_value = self
+			.data
+			.last_mut()
+			.expect("always at least one item")
+			.entry(key.clone())
+			.or_insert_with(|| {
+				Some(backend.storage(&key).expect("Ext not allowed to fail").unwrap_or_default())
+			});
+		if current_value.is_none() {
+			*current_value = Some(vec![]);
+		}
+		StorageAppend::new(current_value.as_mut().expect("init above")).append(value);
+	}
+
+	fn get(&mut self, key: &[u8]) -> Option<&Vec<u8>> {
+		self.data
+			.last_mut()
+			.expect("always at least one item")
+			.get(key)
+			.and_then(|o| o.as_ref())
+	}
+
+	fn commit_transaction(&mut self) {
+		if let Some(to_commit) = self.data.pop() {
+			let dest = self.data.last_mut().expect("always at least one item");
+			for (k, v) in to_commit.into_iter() {
+				dest.insert(k, v);
+			}
+		}
+	}
+
+	fn rollback_transaction(&mut self) {
+		let _ = self.data.pop();
+	}
+
+	fn start_transaction(&mut self) {
+		let cloned = self.data.last().expect("always at least one item").clone();
+		self.data.push(cloned);
+	}
+}
+
+struct FuzzAppendState<H: Hasher> {
+	key: Vec<u8>,
+
+	// reference simple implementation
+	reference: SimpleOverlay,
+
+	// trie backend
+	backend: TrieBackend<PrefixedMemoryDB<H>, H>,
+	// Standard Overlay
+	overlay: OverlayedChanges<H>,
+
+	// block dropping/commiting too many transaction
+	transaction_depth: usize,
+}
+
+impl<H> FuzzAppendState<H>
+where
+	H: Hasher,
+	H::Out: codec::Decode + codec::Encode + 'static,
+{
+	fn process_item(&mut self, item: FuzzAppendItem) {
+		let mut ext = Ext::new(&mut self.overlay, &mut self.backend, None);
+		match item {
+			FuzzAppendItem::Append(value, length) => {
+				let value = vec![value as u8; length as usize];
+				ext.storage_append(self.key.clone(), value.clone());
+				self.reference.append(self.key.clone(), value, &mut self.backend);
+			},
+			FuzzAppendItem::Append50(value, length) => {
+				let value = vec![value as u8; length as usize];
+				for _ in 0..50 {
+					let mut ext = Ext::new(&mut self.overlay, &mut self.backend, None);
+					ext.storage_append(self.key.clone(), value.clone());
+					self.reference.append(self.key.clone(), value.clone(), &mut self.backend);
+				}
+			},
+			FuzzAppendItem::Insert(value, length) => {
+				let value = vec![value as u8; length as usize];
+				ext.set_storage(self.key.clone(), value.clone());
+				self.reference.insert(self.key.clone(), Some(value));
+			},
+			FuzzAppendItem::Remove => {
+				ext.clear_storage(&self.key);
+				self.reference.insert(self.key.clone(), None);
+			},
+			FuzzAppendItem::Read => {
+				let left = ext.storage(self.key.as_slice());
+				let right = self.reference.get(self.key.as_slice());
+				assert_eq!(left.as_ref(), right);
+			},
+			FuzzAppendItem::StartTransaction => {
+				self.transaction_depth += 1;
+				self.reference.start_transaction();
+				ext.storage_start_transaction();
+			},
+			FuzzAppendItem::RollbackTransaction => {
+				if self.transaction_depth == 0 {
+					return
+				}
+				self.transaction_depth -= 1;
+				self.reference.rollback_transaction();
+				ext.storage_rollback_transaction().unwrap();
+			},
+			FuzzAppendItem::CommitTransaction => {
+				if self.transaction_depth == 0 {
+					return
+				}
+				self.transaction_depth -= 1;
+				self.reference.commit_transaction();
+				ext.storage_commit_transaction().unwrap();
+			},
+		}
+	}
+
+	fn check_final_state(&mut self) {
+		let mut ext = Ext::new(&mut self.overlay, &mut self.backend, None);
+		let left = ext.storage(self.key.as_slice());
+		let right = self.reference.get(self.key.as_slice());
+		assert_eq!(left.as_ref(), right);
+	}
+}
+
+#[test]
+fn fuzz_scenarii() {
+	assert_eq!(codec::Compact(5u16).encode()[0], DataValue::EasyBug as u8);
+	let scenarii = vec![
+		(
+			vec![
+				FuzzAppendItem::Append(DataValue::A, DataLength::Small),
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Append50(DataValue::D, DataLength::Small),
+				FuzzAppendItem::Read,
+				FuzzAppendItem::RollbackTransaction,
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Append(DataValue::D, DataLength::Small),
+				FuzzAppendItem::Read,
+				FuzzAppendItem::RollbackTransaction,
+			],
+			Some((DataValue::D, DataLength::Small)),
+		),
+		(
+			vec![
+				FuzzAppendItem::Append(DataValue::B, DataLength::Small),
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Append(DataValue::A, DataLength::Small),
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Remove,
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Append(DataValue::A, DataLength::Zero),
+				FuzzAppendItem::CommitTransaction,
+				FuzzAppendItem::CommitTransaction,
+				FuzzAppendItem::Remove,
+			],
+			Some((DataValue::EasyBug, DataLength::Small)),
+		),
+		(
+			vec![
+				FuzzAppendItem::Append(DataValue::A, DataLength::Small),
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Append(DataValue::A, DataLength::Medium),
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Remove,
+				FuzzAppendItem::CommitTransaction,
+				FuzzAppendItem::RollbackTransaction,
+			],
+			Some((DataValue::B, DataLength::Big)),
+		),
+		(
+			vec![
+				FuzzAppendItem::Append(DataValue::A, DataLength::Big),
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Append(DataValue::A, DataLength::Medium),
+				FuzzAppendItem::Remove,
+				FuzzAppendItem::RollbackTransaction,
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::Append(DataValue::A, DataLength::Zero),
+			],
+			None,
+		),
+		(
+			vec![
+				FuzzAppendItem::StartTransaction,
+				FuzzAppendItem::RollbackTransaction,
+				FuzzAppendItem::RollbackTransaction,
+				FuzzAppendItem::Append(DataValue::A, DataLength::Zero),
+			],
+			None,
+		),
+		(vec![FuzzAppendItem::StartTransaction], Some((DataValue::EasyBug, DataLength::Zero))),
+	];
+
+	for (scenario, init) in scenarii.into_iter() {
+		fuzz_append::<BlakeTwo256>(FuzzAppendPayload(scenario, init));
+	}
+}
+
+/// Test append operation for a given fuzzing payload.
+pub fn fuzz_append<H>(payload: FuzzAppendPayload)
+where
+	H: Hasher,
+	H::Out: codec::Decode + codec::Encode + 'static,
+{
+	let FuzzAppendPayload(to_fuzz, initial) = payload;
+	let key = b"k".to_vec();
+	let mut reference = SimpleOverlay::default();
+	let initial: BTreeMap<_, _> = initial
+		.into_iter()
+		.map(|(v, l)| (key.clone(), vec![v as u8; l as usize]))
+		.collect();
+	for (k, v) in initial.iter() {
+		reference.data[0].insert(k.clone(), Some(v.clone()));
+	}
+	reference.start_transaction(); // level 0 is backend, keep it untouched.
+	let overlay = OverlayedChanges::default();
+
+	let mut state = FuzzAppendState::<H> {
+		key,
+		reference,
+		overlay,
+		backend: (initial, StateVersion::default()).into(),
+		transaction_depth: 0,
+	};
+	for item in to_fuzz {
+		state.process_item(item);
+	}
+	state.check_final_state();
+}
diff --git a/substrate/primitives/state-machine/src/in_memory_backend.rs b/substrate/primitives/state-machine/src/in_memory_backend.rs
index 06fe6d4162a7f4c920c8f09c2e4e8b05a3c72c03..7ba7457a6bf18bfb17d3faa7c6d3aaea6cd36788 100644
--- a/substrate/primitives/state-machine/src/in_memory_backend.rs
+++ b/substrate/primitives/state-machine/src/in_memory_backend.rs
@@ -132,6 +132,7 @@ where
 	}
 }
 
+#[cfg(feature = "std")]
 impl<H: Hasher> From<(Storage, StateVersion)> for TrieBackend<PrefixedMemoryDB<H>, H>
 where
 	H::Out: Codec + Ord,
diff --git a/substrate/primitives/state-machine/src/lib.rs b/substrate/primitives/state-machine/src/lib.rs
index 13087431d387b9e986519bbdcabfe9eb3c4fe5c5..289b08755f680605a28a16adabac3cb3698a83fc 100644
--- a/substrate/primitives/state-machine/src/lib.rs
+++ b/substrate/primitives/state-machine/src/lib.rs
@@ -27,6 +27,8 @@ pub mod backend;
 mod basic;
 mod error;
 mod ext;
+#[cfg(feature = "fuzzing")]
+pub mod fuzzing;
 #[cfg(feature = "std")]
 mod in_memory_backend;
 pub(crate) mod overlayed_changes;
@@ -1273,7 +1275,7 @@ mod tests {
 
 		assert_eq!(
 			overlay
-				.changes()
+				.changes_mut()
 				.map(|(k, v)| (k.clone(), v.value().cloned()))
 				.collect::<HashMap<_, _>>(),
 			map![
@@ -1299,7 +1301,7 @@ mod tests {
 
 		assert_eq!(
 			overlay
-				.changes()
+				.changes_mut()
 				.map(|(k, v)| (k.clone(), v.value().cloned()))
 				.collect::<HashMap<_, _>>(),
 			map![
@@ -1340,7 +1342,7 @@ mod tests {
 
 		assert_eq!(
 			overlay
-				.children()
+				.children_mut()
 				.flat_map(|(iter, _child_info)| iter)
 				.map(|(k, v)| (k.clone(), v.value()))
 				.collect::<BTreeMap<_, _>>(),
@@ -1440,11 +1442,78 @@ mod tests {
 		}
 		overlay.rollback_transaction().unwrap();
 		{
-			let ext = Ext::new(&mut overlay, backend, None);
+			let mut ext = Ext::new(&mut overlay, backend, None);
 			assert_eq!(ext.storage(key.as_slice()), Some(vec![reference_data[0].clone()].encode()));
 		}
 	}
 
+	// Test that we can append twice to a key, then perform a remove operation.
+	// The test checks specifically that the append is merged with its parent transaction
+	// on commit.
+	#[test]
+	fn commit_merges_append_with_parent() {
+		#[derive(codec::Encode, codec::Decode)]
+		enum Item {
+			Item1,
+			Item2,
+		}
+
+		let key = b"events".to_vec();
+		let state = new_in_mem::<BlakeTwo256>();
+		let backend = state.as_trie_backend();
+		let mut overlay = OverlayedChanges::default();
+
+		// Append first item
+		overlay.start_transaction();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			ext.clear_storage(key.as_slice());
+			ext.storage_append(key.clone(), Item::Item1.encode());
+		}
+
+		// Append second item
+		overlay.start_transaction();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::Item1].encode()));
+
+			ext.storage_append(key.clone(), Item::Item2.encode());
+
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::Item1, Item::Item2].encode()),);
+		}
+
+		// Remove item
+		overlay.start_transaction();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+
+			ext.place_storage(key.clone(), None);
+
+			assert_eq!(ext.storage(key.as_slice()), None);
+		}
+
+		// Remove gets commited and merged into previous transaction
+		overlay.commit_transaction().unwrap();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			assert_eq!(ext.storage(key.as_slice()), None,);
+		}
+
+		// Remove gets rolled back, we should see the initial append again.
+		overlay.rollback_transaction().unwrap();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::Item1].encode()));
+		}
+
+		overlay.commit_transaction().unwrap();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::Item1].encode()));
+		}
+	}
+
 	#[test]
 	fn remove_with_append_then_rollback_appended_then_append_again() {
 		#[derive(codec::Encode, codec::Decode)]
@@ -1499,7 +1568,7 @@ mod tests {
 
 		// Then only initialization item and second (committed) item should persist.
 		{
-			let ext = Ext::new(&mut overlay, backend, None);
+			let mut ext = Ext::new(&mut overlay, backend, None);
 			assert_eq!(
 				ext.storage(key.as_slice()),
 				Some(vec![Item::InitializationItem, Item::CommittedItem].encode()),
diff --git a/substrate/primitives/state-machine/src/overlayed_changes/changeset.rs b/substrate/primitives/state-machine/src/overlayed_changes/changeset.rs
index 601bc2e29198561d501e1f20b11c2323c0064989..c478983e979af440a409199934c641eb01492675 100644
--- a/substrate/primitives/state-machine/src/overlayed_changes/changeset.rs
+++ b/substrate/primitives/state-machine/src/overlayed_changes/changeset.rs
@@ -21,11 +21,15 @@ use super::{Extrinsics, StorageKey, StorageValue};
 
 #[cfg(not(feature = "std"))]
 use alloc::collections::btree_set::BTreeSet as Set;
+use codec::{Compact, CompactLen};
 #[cfg(feature = "std")]
 use std::collections::HashSet as Set;
 
-use crate::warn;
-use alloc::collections::{btree_map::BTreeMap, btree_set::BTreeSet};
+use crate::{ext::StorageAppend, warn};
+use alloc::{
+	collections::{btree_map::BTreeMap, btree_set::BTreeSet},
+	vec::Vec,
+};
 use core::hash::Hash;
 use smallvec::SmallVec;
 
@@ -86,10 +90,97 @@ impl<V> Default for OverlayedEntry<V> {
 }
 
 /// History of value, with removal support.
-pub type OverlayedValue = OverlayedEntry<Option<StorageValue>>;
+pub type OverlayedValue = OverlayedEntry<StorageEntry>;
+
+/// Content in an overlay for a given transactional depth.
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(test, derive(PartialEq))]
+pub enum StorageEntry {
+	/// The storage entry should be set to the stored value.
+	Set(StorageValue),
+	/// The storage entry should be removed.
+	#[default]
+	Remove,
+	/// The storage entry was appended to.
+	///
+	/// This assumes that the storage entry is encoded as a SCALE list. This means that it is
+	/// prefixed with a `Compact<u32>` that reprensents the length, followed by all the encoded
+	/// elements.
+	Append {
+		/// The value of the storage entry.
+		///
+		/// This may or may not be prefixed by the length, depending on the materialized length.
+		data: StorageValue,
+		/// Current number of elements stored in data.
+		current_length: u32,
+		/// The number of elements as stored in the prefixed length in `data`.
+		///
+		/// If `None`, than `data` is not yet prefixed with the length.
+		materialized_length: Option<u32>,
+		/// The size of `data` in the parent transactional layer.
+		///
+		/// Only set when the parent layer is in  `Append` state.
+		parent_size: Option<usize>,
+	},
+}
+
+impl StorageEntry {
+	/// Convert to an [`Option<StorageValue>`].
+	pub(super) fn to_option(mut self) -> Option<StorageValue> {
+		self.materialize_in_place();
+		match self {
+			StorageEntry::Append { data, .. } | StorageEntry::Set(data) => Some(data),
+			StorageEntry::Remove => None,
+		}
+	}
+
+	/// Return as an [`Option<StorageValue>`].
+	fn as_option(&mut self) -> Option<&StorageValue> {
+		self.materialize_in_place();
+		match self {
+			StorageEntry::Append { data, .. } | StorageEntry::Set(data) => Some(data),
+			StorageEntry::Remove => None,
+		}
+	}
+
+	/// Materialize the internal state and cache the resulting materialized value.
+	fn materialize_in_place(&mut self) {
+		if let StorageEntry::Append { data, materialized_length, current_length, .. } = self {
+			let current_length = *current_length;
+			if materialized_length.map_or(false, |m| m == current_length) {
+				return
+			}
+			StorageAppend::new(data).replace_length(*materialized_length, current_length);
+			*materialized_length = Some(current_length);
+		}
+	}
+
+	/// Materialize the internal state.
+	#[cfg(test)]
+	pub(crate) fn materialize(&self) -> Option<alloc::borrow::Cow<[u8]>> {
+		use alloc::borrow::Cow;
+
+		match self {
+			StorageEntry::Append { data, materialized_length, current_length, .. } => {
+				let current_length = *current_length;
+				if materialized_length.map_or(false, |m| m == current_length) {
+					Some(Cow::Borrowed(data.as_ref()))
+				} else {
+					let mut data = data.clone();
+					StorageAppend::new(&mut data)
+						.replace_length(*materialized_length, current_length);
+
+					Some(data.into())
+				}
+			},
+			StorageEntry::Remove => None,
+			StorageEntry::Set(e) => Some(Cow::Borrowed(e.as_ref())),
+		}
+	}
+}
 
 /// Change set for basic key value with extrinsics index recording and removal support.
-pub type OverlayedChangeSet = OverlayedMap<StorageKey, Option<StorageValue>>;
+pub type OverlayedChangeSet = OverlayedMap<StorageKey, StorageEntry>;
 
 /// Holds a set of changes with the ability modify them using nested transactions.
 #[derive(Debug, Clone)]
@@ -120,7 +211,7 @@ impl<K, V> Default for OverlayedMap<K, V> {
 }
 
 #[cfg(feature = "std")]
-impl From<sp_core::storage::StorageMap> for OverlayedMap<StorageKey, Option<StorageValue>> {
+impl From<sp_core::storage::StorageMap> for OverlayedMap<StorageKey, StorageEntry> {
 	fn from(storage: sp_core::storage::StorageMap) -> Self {
 		Self {
 			changes: storage
@@ -130,7 +221,7 @@ impl From<sp_core::storage::StorageMap> for OverlayedMap<StorageKey, Option<Stor
 						k,
 						OverlayedEntry {
 							transactions: SmallVec::from_iter([InnerValue {
-								value: Some(v),
+								value: StorageEntry::Set(v),
 								extrinsics: Default::default(),
 							}]),
 						},
@@ -189,7 +280,7 @@ impl<V> OverlayedEntry<V> {
 	///
 	/// This makes sure that the old version is not overwritten and can be properly
 	/// rolled back when required.
-	fn set(&mut self, value: V, first_write_in_tx: bool, at_extrinsic: Option<u32>) {
+	fn set_offchain(&mut self, value: V, first_write_in_tx: bool, at_extrinsic: Option<u32>) {
 		if first_write_in_tx || self.transactions.is_empty() {
 			self.transactions.push(InnerValue { value, extrinsics: Default::default() });
 		} else {
@@ -202,10 +293,223 @@ impl<V> OverlayedEntry<V> {
 	}
 }
 
-impl OverlayedEntry<Option<StorageValue>> {
+/// Restore the `current_data` from an [`StorageEntry::Append`] back to the parent.
+///
+/// When creating a new transaction layer from an appended entry, the `data` will be moved to
+/// prevent extra allocations. So, we need to move back the `data` to the parent layer when there is
+/// a roll back or the entry is set to some different value. This functions puts back the data to
+/// the `parent` and truncates any extra elements that got added in the current layer.
+///
+/// The current and the `parent` layer need to be [`StorageEntry::Append`] or otherwise the function
+/// is a no-op.
+fn restore_append_to_parent(
+	parent: &mut StorageEntry,
+	mut current_data: Vec<u8>,
+	current_materialized: Option<u32>,
+	mut target_parent_size: usize,
+) {
+	match parent {
+		StorageEntry::Append {
+			data: parent_data,
+			materialized_length: parent_materialized,
+			..
+		} => {
+			// Forward the materialized length to the parent with the data. Next time when
+			// materializing the value, the length will be corrected. This prevents doing a
+			// potential allocation here.
+
+			let prev = parent_materialized.map(|l| Compact::<u32>::compact_len(&l)).unwrap_or(0);
+			let new = current_materialized.map(|l| Compact::<u32>::compact_len(&l)).unwrap_or(0);
+			let delta = new.abs_diff(prev);
+			if prev >= new {
+				target_parent_size -= delta;
+			} else {
+				target_parent_size += delta;
+			}
+			*parent_materialized = current_materialized;
+
+			// Truncate the data to remove any extra elements
+			current_data.truncate(target_parent_size);
+			*parent_data = current_data;
+		},
+		_ => {
+			// No value or a simple value, no need to restore
+		},
+	}
+}
+
+impl OverlayedEntry<StorageEntry> {
+	/// Writes a new version of a value.
+	///
+	/// This makes sure that the old version is not overwritten and can be properly
+	/// rolled back when required.
+	fn set(
+		&mut self,
+		value: Option<StorageValue>,
+		first_write_in_tx: bool,
+		at_extrinsic: Option<u32>,
+	) {
+		let value = value.map_or_else(|| StorageEntry::Remove, StorageEntry::Set);
+
+		if first_write_in_tx || self.transactions.is_empty() {
+			self.transactions.push(InnerValue { value, extrinsics: Default::default() });
+		} else {
+			let mut old_value = self.value_mut();
+
+			let set_prev = if let StorageEntry::Append {
+				data,
+				current_length: _,
+				materialized_length,
+				parent_size,
+			} = &mut old_value
+			{
+				parent_size
+					.map(|parent_size| (core::mem::take(data), *materialized_length, parent_size))
+			} else {
+				None
+			};
+
+			*old_value = value;
+
+			if let Some((data, current_materialized, parent_size)) = set_prev {
+				let transactions = self.transactions.len();
+
+				debug_assert!(transactions >= 2);
+				let parent = self
+					.transactions
+					.get_mut(transactions - 2)
+					.expect("`set_prev` is only `Some(_)`, if the value came from parent; qed");
+				restore_append_to_parent(
+					&mut parent.value,
+					data,
+					current_materialized,
+					parent_size,
+				);
+			}
+		}
+
+		if let Some(extrinsic) = at_extrinsic {
+			self.transaction_extrinsics_mut().insert(extrinsic);
+		}
+	}
+
+	/// Append content to a value, updating a prefixed compact encoded length.
+	///
+	/// This makes sure that the old version is not overwritten and can be properly
+	/// rolled back when required.
+	/// This avoid copying value from previous transaction.
+	fn append(
+		&mut self,
+		element: StorageValue,
+		first_write_in_tx: bool,
+		init: impl Fn() -> StorageValue,
+		at_extrinsic: Option<u32>,
+	) {
+		if self.transactions.is_empty() {
+			let mut init_value = init();
+
+			let mut append = StorageAppend::new(&mut init_value);
+
+			// Either the init value is a SCALE list like value to that the `element` gets appended
+			// or the value is reset to `[element]`.
+			let (data, current_length, materialized_length) =
+				if let Some(len) = append.extract_length() {
+					append.append_raw(element);
+
+					(init_value, len + 1, Some(len))
+				} else {
+					(element, 1, None)
+				};
+
+			self.transactions.push(InnerValue {
+				value: StorageEntry::Append {
+					data,
+					current_length,
+					materialized_length,
+					parent_size: None,
+				},
+				extrinsics: Default::default(),
+			});
+		} else if first_write_in_tx {
+			let parent = self.value_mut();
+			let (data, current_length, materialized_length, parent_size) = match parent {
+				StorageEntry::Remove => (element, 1, None, None),
+				StorageEntry::Append { data, current_length, materialized_length, .. } => {
+					let parent_len = data.len();
+					let mut data_buf = core::mem::take(data);
+					StorageAppend::new(&mut data_buf).append_raw(element);
+					(data_buf, *current_length + 1, *materialized_length, Some(parent_len))
+				},
+				StorageEntry::Set(prev) => {
+					// For compatibility: append if there is a encoded length, overwrite
+					// with value otherwhise.
+					if let Some(current_length) = StorageAppend::new(prev).extract_length() {
+						// The `prev` is cloned here, but it could be optimized to not do the clone
+						// here as it is done for `Append` above.
+						let mut data = prev.clone();
+						StorageAppend::new(&mut data).append_raw(element);
+						(data, current_length + 1, Some(current_length), None)
+					} else {
+						// overwrite, same as empty case.
+						(element, 1, None, None)
+					}
+				},
+			};
+
+			self.transactions.push(InnerValue {
+				value: StorageEntry::Append {
+					data,
+					current_length,
+					materialized_length,
+					parent_size,
+				},
+				extrinsics: Default::default(),
+			});
+		} else {
+			// not first transaction write
+			let old_value = self.value_mut();
+			let replace = match old_value {
+				StorageEntry::Remove => Some((element, 1, None)),
+				StorageEntry::Set(data) => {
+					// Note that when the data here is not initialized with append,
+					// and still starts with a valid compact u32 we can have totally broken
+					// encoding.
+					let mut append = StorageAppend::new(data);
+
+					// For compatibility: append if there is a encoded length, overwrite
+					// with value otherwhise.
+					if let Some(current_length) = append.extract_length() {
+						append.append_raw(element);
+						Some((core::mem::take(data), current_length + 1, Some(current_length)))
+					} else {
+						Some((element, 1, None))
+					}
+				},
+				StorageEntry::Append { data, current_length, .. } => {
+					StorageAppend::new(data).append_raw(element);
+					*current_length += 1;
+					None
+				},
+			};
+
+			if let Some((data, current_length, materialized_length)) = replace {
+				*old_value = StorageEntry::Append {
+					data,
+					current_length,
+					materialized_length,
+					parent_size: None,
+				};
+			}
+		}
+
+		if let Some(extrinsic) = at_extrinsic {
+			self.transaction_extrinsics_mut().insert(extrinsic);
+		}
+	}
+
 	/// The value as seen by the current transaction.
-	pub fn value(&self) -> Option<&StorageValue> {
-		self.value_ref().as_ref()
+	pub fn value(&mut self) -> Option<&StorageValue> {
+		self.value_mut().as_option()
 	}
 }
 
@@ -238,20 +542,20 @@ impl<K: Ord + Hash + Clone, V> OverlayedMap<K, V> {
 	}
 
 	/// Get an optional reference to the value stored for the specified key.
-	pub fn get<Q>(&self, key: &Q) -> Option<&OverlayedEntry<V>>
+	pub fn get<Q>(&mut self, key: &Q) -> Option<&mut OverlayedEntry<V>>
 	where
 		K: core::borrow::Borrow<Q>,
 		Q: Ord + ?Sized,
 	{
-		self.changes.get(key)
+		self.changes.get_mut(key)
 	}
 
 	/// Set a new value for the specified key.
 	///
 	/// Can be rolled back or committed when called inside a transaction.
-	pub fn set(&mut self, key: K, value: V, at_extrinsic: Option<u32>) {
+	pub fn set_offchain(&mut self, key: K, value: V, at_extrinsic: Option<u32>) {
 		let overlayed = self.changes.entry(key.clone()).or_default();
-		overlayed.set(value, insert_dirty(&mut self.dirty_keys, key), at_extrinsic);
+		overlayed.set_offchain(value, insert_dirty(&mut self.dirty_keys, key), at_extrinsic);
 	}
 
 	/// Get a list of all changes as seen by current transaction.
@@ -259,6 +563,11 @@ impl<K: Ord + Hash + Clone, V> OverlayedMap<K, V> {
 		self.changes.iter()
 	}
 
+	/// Get a list of all changes as seen by current transaction.
+	pub fn changes_mut(&mut self) -> impl Iterator<Item = (&K, &mut OverlayedEntry<V>)> {
+		self.changes.iter_mut()
+	}
+
 	/// Get a list of all changes as seen by current transaction, consumes
 	/// the overlay.
 	pub fn into_changes(self) -> impl Iterator<Item = (K, OverlayedEntry<V>)> {
@@ -298,7 +607,7 @@ impl<K: Ord + Hash + Clone, V> OverlayedMap<K, V> {
 	///
 	/// This rollbacks all dangling transaction left open by the runtime.
 	/// Calling this while already outside the runtime will return an error.
-	pub fn exit_runtime(&mut self) -> Result<(), NotInRuntime> {
+	pub fn exit_runtime_offchain(&mut self) -> Result<(), NotInRuntime> {
 		if let ExecutionMode::Client = self.execution_mode {
 			return Err(NotInRuntime)
 		}
@@ -310,7 +619,7 @@ impl<K: Ord + Hash + Clone, V> OverlayedMap<K, V> {
 			);
 		}
 		while self.has_open_runtime_transactions() {
-			self.rollback_transaction()
+			self.rollback_transaction_offchain()
 				.expect("The loop condition checks that the transaction depth is > 0; qed");
 		}
 		Ok(())
@@ -331,24 +640,24 @@ impl<K: Ord + Hash + Clone, V> OverlayedMap<K, V> {
 	///
 	/// Any changes made during that transaction are discarded. Returns an error if
 	/// there is no open transaction that can be rolled back.
-	pub fn rollback_transaction(&mut self) -> Result<(), NoOpenTransaction> {
-		self.close_transaction(true)
+	pub fn rollback_transaction_offchain(&mut self) -> Result<(), NoOpenTransaction> {
+		self.close_transaction_offchain(true)
 	}
 
 	/// Commit the last transaction started by `start_transaction`.
 	///
 	/// Any changes made during that transaction are committed. Returns an error if
 	/// there is no open transaction that can be committed.
-	pub fn commit_transaction(&mut self) -> Result<(), NoOpenTransaction> {
-		self.close_transaction(false)
+	pub fn commit_transaction_offchain(&mut self) -> Result<(), NoOpenTransaction> {
+		self.close_transaction_offchain(false)
 	}
 
-	fn close_transaction(&mut self, rollback: bool) -> Result<(), NoOpenTransaction> {
+	fn close_transaction_offchain(&mut self, rollback: bool) -> Result<(), NoOpenTransaction> {
 		// runtime is not allowed to close transactions started by the client
-		if let ExecutionMode::Runtime = self.execution_mode {
-			if !self.has_open_runtime_transactions() {
-				return Err(NoOpenTransaction)
-			}
+		if matches!(self.execution_mode, ExecutionMode::Runtime) &&
+			!self.has_open_runtime_transactions()
+		{
+			return Err(NoOpenTransaction)
 		}
 
 		for key in self.dirty_keys.pop().ok_or(NoOpenTransaction)? {
@@ -398,32 +707,176 @@ impl<K: Ord + Hash + Clone, V> OverlayedMap<K, V> {
 }
 
 impl OverlayedChangeSet {
-	/// Get a mutable reference for a value.
+	/// Rollback the last transaction started by `start_transaction`.
+	///
+	/// Any changes made during that transaction are discarded. Returns an error if
+	/// there is no open transaction that can be rolled back.
+	pub fn rollback_transaction(&mut self) -> Result<(), NoOpenTransaction> {
+		self.close_transaction(true)
+	}
+
+	/// Commit the last transaction started by `start_transaction`.
+	///
+	/// Any changes made during that transaction are committed. Returns an error if
+	/// there is no open transaction that can be committed.
+	pub fn commit_transaction(&mut self) -> Result<(), NoOpenTransaction> {
+		self.close_transaction(false)
+	}
+
+	fn close_transaction(&mut self, rollback: bool) -> Result<(), NoOpenTransaction> {
+		// runtime is not allowed to close transactions started by the client
+		if matches!(self.execution_mode, ExecutionMode::Runtime) &&
+			!self.has_open_runtime_transactions()
+		{
+			return Err(NoOpenTransaction)
+		}
+
+		for key in self.dirty_keys.pop().ok_or(NoOpenTransaction)? {
+			let overlayed = self.changes.get_mut(&key).expect(
+				"\
+				A write to an OverlayedValue is recorded in the dirty key set. Before an
+				OverlayedValue is removed, its containing dirty set is removed. This
+				function is only called for keys that are in the dirty set. qed\
+			",
+			);
+
+			if rollback {
+				match overlayed.pop_transaction().value {
+					StorageEntry::Append {
+						data,
+						materialized_length,
+						parent_size: Some(parent_size),
+						..
+					} => {
+						debug_assert!(!overlayed.transactions.is_empty());
+						restore_append_to_parent(
+							overlayed.value_mut(),
+							data,
+							materialized_length,
+							parent_size,
+						);
+					},
+					_ => (),
+				}
+
+				// We need to remove the key as an `OverlayValue` with no transactions
+				// violates its invariant of always having at least one transaction.
+				if overlayed.transactions.is_empty() {
+					self.changes.remove(&key);
+				}
+			} else {
+				let has_predecessor = if let Some(dirty_keys) = self.dirty_keys.last_mut() {
+					// Not the last tx: Did the previous tx write to this key?
+					!dirty_keys.insert(key)
+				} else {
+					// Last tx: Is there already a value in the committed set?
+					// Check against one rather than empty because the current tx is still
+					// in the list as it is popped later in this function.
+					overlayed.transactions.len() > 1
+				};
+
+				// We only need to merge if there is an pre-existing value. It may be a value from
+				// the previous transaction or a value committed without any open transaction.
+				if has_predecessor {
+					let mut committed_tx = overlayed.pop_transaction();
+					let mut merge_appends = false;
+
+					// consecutive appends need to keep past `parent_size` value.
+					if let StorageEntry::Append { parent_size, .. } = &mut committed_tx.value {
+						if parent_size.is_some() {
+							let parent = overlayed.value_mut();
+							if let StorageEntry::Append { parent_size: keep_me, .. } = parent {
+								merge_appends = true;
+								*parent_size = *keep_me;
+							}
+						}
+					}
+
+					if merge_appends {
+						*overlayed.value_mut() = committed_tx.value;
+					} else {
+						let removed = core::mem::replace(overlayed.value_mut(), committed_tx.value);
+						// The transaction being commited is not an append operation. However, the
+						// value being overwritten in the previous transaction might be an append
+						// that needs to be merged with its parent. We only need to handle `Append`
+						// here because `Set` and `Remove` can directly overwrite previous
+						// operations.
+						if let StorageEntry::Append {
+							parent_size, data, materialized_length, ..
+						} = removed
+						{
+							if let Some(parent_size) = parent_size {
+								let transactions = overlayed.transactions.len();
+
+								// info from replaced head so len is at least one
+								// and parent_size implies a parent transaction
+								// so length is at least two.
+								debug_assert!(transactions >= 2);
+								if let Some(parent) =
+									overlayed.transactions.get_mut(transactions - 2)
+								{
+									restore_append_to_parent(
+										&mut parent.value,
+										data,
+										materialized_length,
+										parent_size,
+									)
+								}
+							}
+						}
+					}
+
+					overlayed.transaction_extrinsics_mut().extend(committed_tx.extrinsics);
+				}
+			}
+		}
+
+		Ok(())
+	}
+
+	/// Call this when control returns from the runtime.
+	///
+	/// This commits all dangling transaction left open by the runtime.
+	/// Calling this while already outside the runtime will return an error.
+	pub fn exit_runtime(&mut self) -> Result<(), NotInRuntime> {
+		if matches!(self.execution_mode, ExecutionMode::Client) {
+			return Err(NotInRuntime)
+		}
+
+		self.execution_mode = ExecutionMode::Client;
+		if self.has_open_runtime_transactions() {
+			warn!(
+				"{} storage transactions are left open by the runtime. Those will be rolled back.",
+				self.transaction_depth() - self.num_client_transactions,
+			);
+		}
+		while self.has_open_runtime_transactions() {
+			self.rollback_transaction()
+				.expect("The loop condition checks that the transaction depth is > 0; qed");
+		}
+
+		Ok(())
+	}
+
+	/// Set a new value for the specified key.
 	///
 	/// Can be rolled back or committed when called inside a transaction.
-	#[must_use = "A change was registered, so this value MUST be modified."]
-	pub fn modify(
+	pub fn set(&mut self, key: StorageKey, value: Option<StorageValue>, at_extrinsic: Option<u32>) {
+		let overlayed = self.changes.entry(key.clone()).or_default();
+		overlayed.set(value, insert_dirty(&mut self.dirty_keys, key), at_extrinsic);
+	}
+
+	/// Append bytes to an existing content.
+	pub fn append_storage(
 		&mut self,
 		key: StorageKey,
+		value: StorageValue,
 		init: impl Fn() -> StorageValue,
 		at_extrinsic: Option<u32>,
-	) -> &mut Option<StorageValue> {
+	) {
 		let overlayed = self.changes.entry(key.clone()).or_default();
 		let first_write_in_tx = insert_dirty(&mut self.dirty_keys, key);
-		let clone_into_new_tx = if let Some(tx) = overlayed.transactions.last() {
-			if first_write_in_tx {
-				Some(tx.value.clone())
-			} else {
-				None
-			}
-		} else {
-			Some(Some(init()))
-		};
-
-		if let Some(cloned) = clone_into_new_tx {
-			overlayed.set(cloned, first_write_in_tx, at_extrinsic);
-		}
-		overlayed.value_mut()
+		overlayed.append(value, first_write_in_tx, init, at_extrinsic);
 	}
 
 	/// Set all values to deleted which are matched by the predicate.
@@ -436,7 +889,7 @@ impl OverlayedChangeSet {
 	) -> u32 {
 		let mut count = 0;
 		for (key, val) in self.changes.iter_mut().filter(|(k, v)| predicate(k, v)) {
-			if val.value_ref().is_some() {
+			if matches!(val.value_ref(), StorageEntry::Set(..) | StorageEntry::Append { .. }) {
 				count += 1;
 			}
 			val.set(None, insert_dirty(&mut self.dirty_keys, key.clone()), at_extrinsic);
@@ -445,10 +898,13 @@ impl OverlayedChangeSet {
 	}
 
 	/// Get the iterator over all changes that follow the supplied `key`.
-	pub fn changes_after(&self, key: &[u8]) -> impl Iterator<Item = (&[u8], &OverlayedValue)> {
+	pub fn changes_after(
+		&mut self,
+		key: &[u8],
+	) -> impl Iterator<Item = (&[u8], &mut OverlayedValue)> {
 		use core::ops::Bound;
 		let range = (Bound::Excluded(key), Bound::Unbounded);
-		self.changes.range::<[u8], _>(range).map(|(k, v)| (k.as_slice(), v))
+		self.changes.range_mut::<[u8], _>(range).map(|(k, v)| (k.as_slice(), v))
 	}
 }
 
@@ -460,18 +916,19 @@ mod test {
 	type Changes<'a> = Vec<(&'a [u8], (Option<&'a [u8]>, Vec<u32>))>;
 	type Drained<'a> = Vec<(&'a [u8], Option<&'a [u8]>)>;
 
-	fn assert_changes(is: &OverlayedChangeSet, expected: &Changes) {
+	fn assert_changes(is: &mut OverlayedChangeSet, expected: &Changes) {
 		let is: Changes = is
-			.changes()
+			.changes_mut()
 			.map(|(k, v)| {
-				(k.as_ref(), (v.value().map(AsRef::as_ref), v.extrinsics().into_iter().collect()))
+				let extrinsics = v.extrinsics().into_iter().collect();
+				(k.as_ref(), (v.value().map(AsRef::as_ref), extrinsics))
 			})
 			.collect();
 		assert_eq!(&is, expected);
 	}
 
 	fn assert_drained_changes(is: OverlayedChangeSet, expected: Changes) {
-		let is = is.drain_committed().collect::<Vec<_>>();
+		let is = is.drain_committed().map(|(k, v)| (k, v.to_option())).collect::<Vec<_>>();
 		let expected = expected
 			.iter()
 			.map(|(k, v)| (k.to_vec(), v.0.map(From::from)))
@@ -480,7 +937,7 @@ mod test {
 	}
 
 	fn assert_drained(is: OverlayedChangeSet, expected: Drained) {
-		let is = is.drain_committed().collect::<Vec<_>>();
+		let is = is.drain_committed().map(|(k, v)| (k, v.to_option())).collect::<Vec<_>>();
 		let expected = expected
 			.iter()
 			.map(|(k, v)| (k.to_vec(), v.map(From::from)))
@@ -535,7 +992,7 @@ mod test {
 			(b"key7", (Some(b"val7-rolled"), vec![77])),
 			(b"key99", (Some(b"val99"), vec![99])),
 		];
-		assert_changes(&changeset, &all_changes);
+		assert_changes(&mut changeset, &all_changes);
 
 		// this should be no-op
 		changeset.start_transaction();
@@ -546,7 +1003,7 @@ mod test {
 		assert_eq!(changeset.transaction_depth(), 3);
 		changeset.commit_transaction().unwrap();
 		assert_eq!(changeset.transaction_depth(), 2);
-		assert_changes(&changeset, &all_changes);
+		assert_changes(&mut changeset, &all_changes);
 
 		// roll back our first transactions that actually contains something
 		changeset.rollback_transaction().unwrap();
@@ -558,11 +1015,11 @@ mod test {
 			(b"key42", (Some(b"val42"), vec![42])),
 			(b"key99", (Some(b"val99"), vec![99])),
 		];
-		assert_changes(&changeset, &rolled_back);
+		assert_changes(&mut changeset, &rolled_back);
 
 		changeset.commit_transaction().unwrap();
 		assert_eq!(changeset.transaction_depth(), 0);
-		assert_changes(&changeset, &rolled_back);
+		assert_changes(&mut changeset, &rolled_back);
 
 		assert_drained_changes(changeset, rolled_back);
 	}
@@ -598,7 +1055,7 @@ mod test {
 			(b"key7", (Some(b"val7-rolled"), vec![77])),
 			(b"key99", (Some(b"val99"), vec![99])),
 		];
-		assert_changes(&changeset, &all_changes);
+		assert_changes(&mut changeset, &all_changes);
 
 		// this should be no-op
 		changeset.start_transaction();
@@ -609,35 +1066,46 @@ mod test {
 		assert_eq!(changeset.transaction_depth(), 3);
 		changeset.commit_transaction().unwrap();
 		assert_eq!(changeset.transaction_depth(), 2);
-		assert_changes(&changeset, &all_changes);
+		assert_changes(&mut changeset, &all_changes);
 
 		changeset.commit_transaction().unwrap();
 		assert_eq!(changeset.transaction_depth(), 1);
 
-		assert_changes(&changeset, &all_changes);
+		assert_changes(&mut changeset, &all_changes);
 
 		changeset.rollback_transaction().unwrap();
 		assert_eq!(changeset.transaction_depth(), 0);
 
 		let rolled_back: Changes =
 			vec![(b"key0", (Some(b"val0-1"), vec![1, 10])), (b"key1", (Some(b"val1"), vec![1]))];
-		assert_changes(&changeset, &rolled_back);
+		assert_changes(&mut changeset, &rolled_back);
 
 		assert_drained_changes(changeset, rolled_back);
 	}
 
 	#[test]
-	fn modify_works() {
+	fn append_works() {
+		use codec::Encode;
 		let mut changeset = OverlayedChangeSet::default();
 		assert_eq!(changeset.transaction_depth(), 0);
-		let init = || b"valinit".to_vec();
+		let init = || vec![b"valinit".to_vec()].encode();
 
 		// committed set
-		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), Some(0));
+		let val0 = vec![b"val0".to_vec()].encode();
+		changeset.set(b"key0".to_vec(), Some(val0.clone()), Some(0));
 		changeset.set(b"key1".to_vec(), None, Some(1));
-		let val = changeset.modify(b"key3".to_vec(), init, Some(3));
-		assert_eq!(val, &Some(b"valinit".to_vec()));
-		val.as_mut().unwrap().extend_from_slice(b"-modified");
+		let all_changes: Changes =
+			vec![(b"key0", (Some(val0.as_slice()), vec![0])), (b"key1", (None, vec![1]))];
+
+		assert_changes(&mut changeset, &all_changes);
+		changeset.append_storage(b"key3".to_vec(), b"-modified".to_vec().encode(), init, Some(3));
+		let val3 = vec![b"valinit".to_vec(), b"-modified".to_vec()].encode();
+		let all_changes: Changes = vec![
+			(b"key0", (Some(val0.as_slice()), vec![0])),
+			(b"key1", (None, vec![1])),
+			(b"key3", (Some(val3.as_slice()), vec![3])),
+		];
+		assert_changes(&mut changeset, &all_changes);
 
 		changeset.start_transaction();
 		assert_eq!(changeset.transaction_depth(), 1);
@@ -645,39 +1113,75 @@ mod test {
 		assert_eq!(changeset.transaction_depth(), 2);
 
 		// non existing value -> init value should be returned
-		let val = changeset.modify(b"key2".to_vec(), init, Some(2));
-		assert_eq!(val, &Some(b"valinit".to_vec()));
-		val.as_mut().unwrap().extend_from_slice(b"-modified");
+		changeset.append_storage(b"key3".to_vec(), b"-twice".to_vec().encode(), init, Some(15));
 
-		// existing value should be returned by modify
-		let val = changeset.modify(b"key0".to_vec(), init, Some(10));
-		assert_eq!(val, &Some(b"val0".to_vec()));
-		val.as_mut().unwrap().extend_from_slice(b"-modified");
+		// non existing value -> init value should be returned
+		changeset.append_storage(b"key2".to_vec(), b"-modified".to_vec().encode(), init, Some(2));
+		// existing value should be reuse on append
+		changeset.append_storage(b"key0".to_vec(), b"-modified".to_vec().encode(), init, Some(10));
 
 		// should work for deleted keys
-		let val = changeset.modify(b"key1".to_vec(), init, Some(20));
-		assert_eq!(val, &None);
-		*val = Some(b"deleted-modified".to_vec());
+		changeset.append_storage(
+			b"key1".to_vec(),
+			b"deleted-modified".to_vec().encode(),
+			init,
+			Some(20),
+		);
+		let val0_2 = vec![b"val0".to_vec(), b"-modified".to_vec()].encode();
+		let val3_2 = vec![b"valinit".to_vec(), b"-modified".to_vec(), b"-twice".to_vec()].encode();
+		let val1 = vec![b"deleted-modified".to_vec()].encode();
+		let all_changes: Changes = vec![
+			(b"key0", (Some(val0_2.as_slice()), vec![0, 10])),
+			(b"key1", (Some(val1.as_slice()), vec![1, 20])),
+			(b"key2", (Some(val3.as_slice()), vec![2])),
+			(b"key3", (Some(val3_2.as_slice()), vec![3, 15])),
+		];
+		assert_changes(&mut changeset, &all_changes);
+
+		changeset.start_transaction();
+		let val3_3 =
+			vec![b"valinit".to_vec(), b"-modified".to_vec(), b"-twice".to_vec(), b"-2".to_vec()]
+				.encode();
+		changeset.append_storage(b"key3".to_vec(), b"-2".to_vec().encode(), init, Some(21));
+		let all_changes2: Changes = vec![
+			(b"key0", (Some(val0_2.as_slice()), vec![0, 10])),
+			(b"key1", (Some(val1.as_slice()), vec![1, 20])),
+			(b"key2", (Some(val3.as_slice()), vec![2])),
+			(b"key3", (Some(val3_3.as_slice()), vec![3, 15, 21])),
+		];
+		assert_changes(&mut changeset, &all_changes2);
+		changeset.rollback_transaction().unwrap();
 
+		assert_changes(&mut changeset, &all_changes);
+		changeset.start_transaction();
+		let val3_4 = vec![
+			b"valinit".to_vec(),
+			b"-modified".to_vec(),
+			b"-twice".to_vec(),
+			b"-thrice".to_vec(),
+		]
+		.encode();
+		changeset.append_storage(b"key3".to_vec(), b"-thrice".to_vec().encode(), init, Some(25));
 		let all_changes: Changes = vec![
-			(b"key0", (Some(b"val0-modified"), vec![0, 10])),
-			(b"key1", (Some(b"deleted-modified"), vec![1, 20])),
-			(b"key2", (Some(b"valinit-modified"), vec![2])),
-			(b"key3", (Some(b"valinit-modified"), vec![3])),
+			(b"key0", (Some(val0_2.as_slice()), vec![0, 10])),
+			(b"key1", (Some(val1.as_slice()), vec![1, 20])),
+			(b"key2", (Some(val3.as_slice()), vec![2])),
+			(b"key3", (Some(val3_4.as_slice()), vec![3, 15, 25])),
 		];
-		assert_changes(&changeset, &all_changes);
+		assert_changes(&mut changeset, &all_changes);
+		changeset.commit_transaction().unwrap();
 		changeset.commit_transaction().unwrap();
 		assert_eq!(changeset.transaction_depth(), 1);
-		assert_changes(&changeset, &all_changes);
+		assert_changes(&mut changeset, &all_changes);
 
 		changeset.rollback_transaction().unwrap();
 		assert_eq!(changeset.transaction_depth(), 0);
 		let rolled_back: Changes = vec![
-			(b"key0", (Some(b"val0"), vec![0])),
+			(b"key0", (Some(val0.as_slice()), vec![0])),
 			(b"key1", (None, vec![1])),
-			(b"key3", (Some(b"valinit-modified"), vec![3])),
+			(b"key3", (Some(val3.as_slice()), vec![3])),
 		];
-		assert_changes(&changeset, &rolled_back);
+		assert_changes(&mut changeset, &rolled_back);
 		assert_drained_changes(changeset, rolled_back);
 	}
 
@@ -695,7 +1199,7 @@ mod test {
 		changeset.clear_where(|k, _| k.starts_with(b"del"), Some(5));
 
 		assert_changes(
-			&changeset,
+			&mut changeset,
 			&vec![
 				(b"del1", (None, vec![3, 5])),
 				(b"del2", (None, vec![4, 5])),
@@ -707,7 +1211,7 @@ mod test {
 		changeset.rollback_transaction().unwrap();
 
 		assert_changes(
-			&changeset,
+			&mut changeset,
 			&vec![
 				(b"del1", (Some(b"delval1"), vec![3])),
 				(b"del2", (Some(b"delval2"), vec![4])),
@@ -850,4 +1354,72 @@ mod test {
 		assert_eq!(changeset.exit_runtime(), Ok(()));
 		assert_eq!(changeset.exit_runtime(), Err(NotInRuntime));
 	}
+
+	#[test]
+	fn restore_append_to_parent() {
+		use codec::{Compact, Encode};
+		let mut changeset = OverlayedChangeSet::default();
+		let key: Vec<u8> = b"akey".into();
+
+		let from = 50; // 1 byte len
+		let to = 100; // 2 byte len
+		for i in 0..from {
+			changeset.append_storage(key.clone(), vec![i], Default::default, None);
+		}
+
+		// materialized
+		let encoded = changeset.get(&key).unwrap().value().unwrap();
+		let encoded_from_len = Compact(from as u32).encode();
+		assert_eq!(encoded_from_len.len(), 1);
+		assert!(encoded.starts_with(&encoded_from_len[..]));
+		let encoded_from = encoded.clone();
+
+		changeset.start_transaction();
+
+		for i in from..to {
+			changeset.append_storage(key.clone(), vec![i], Default::default, None);
+		}
+
+		// materialized
+		let encoded = changeset.get(&key).unwrap().value().unwrap();
+		let encoded_to_len = Compact(to as u32).encode();
+		assert_eq!(encoded_to_len.len(), 2);
+		assert!(encoded.starts_with(&encoded_to_len[..]));
+
+		changeset.rollback_transaction().unwrap();
+
+		let encoded = changeset.get(&key).unwrap().value().unwrap();
+		assert_eq!(&encoded_from, encoded);
+	}
+
+	/// First we have some `Set` operation with a valid SCALE list. Then we append data and rollback
+	/// afterwards.
+	#[test]
+	fn restore_initial_set_after_append_to_parent() {
+		use codec::{Compact, Encode};
+		let mut changeset = OverlayedChangeSet::default();
+		let key: Vec<u8> = b"akey".into();
+
+		let initial_data = vec![1u8; 50].encode();
+
+		changeset.set(key.clone(), Some(initial_data.clone()), None);
+
+		changeset.start_transaction();
+
+		// Append until we require 2 bytes for the length prefix.
+		for i in 0..50 {
+			changeset.append_storage(key.clone(), vec![i], Default::default, None);
+		}
+
+		// Materialize the value.
+		let encoded = changeset.get(&key).unwrap().value().unwrap();
+		let encoded_to_len = Compact(100u32).encode();
+		assert_eq!(encoded_to_len.len(), 2);
+		assert!(encoded.starts_with(&encoded_to_len[..]));
+
+		changeset.rollback_transaction().unwrap();
+
+		let encoded = changeset.get(&key).unwrap().value().unwrap();
+		assert_eq!(&initial_data, encoded);
+	}
 }
diff --git a/substrate/primitives/state-machine/src/overlayed_changes/mod.rs b/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
index d6fc404e84fb5256656c5849d8f52894f37bfa02..c2dc637bc71a70dbef3a55abf658dbd1dd889db5 100644
--- a/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
+++ b/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
@@ -289,7 +289,7 @@ impl<H: Hasher> OverlayedChanges<H> {
 	/// Returns a double-Option: None if the key is unknown (i.e. and the query should be referred
 	/// to the backend); Some(None) if the key has been deleted. Some(Some(...)) for a key whose
 	/// value has been set.
-	pub fn storage(&self, key: &[u8]) -> Option<Option<&[u8]>> {
+	pub fn storage(&mut self, key: &[u8]) -> Option<Option<&[u8]>> {
 		self.top.get(key).map(|x| {
 			let value = x.value();
 			let size_read = value.map(|x| x.len() as u64).unwrap_or(0);
@@ -304,30 +304,11 @@ impl<H: Hasher> OverlayedChanges<H> {
 		self.storage_transaction_cache = None;
 	}
 
-	/// Returns mutable reference to current value.
-	/// If there is no value in the overlay, the given callback is used to initiate the value.
-	/// Warning this function registers a change, so the mutable reference MUST be modified.
-	///
-	/// Can be rolled back or committed when called inside a transaction.
-	#[must_use = "A change was registered, so this value MUST be modified."]
-	pub fn value_mut_or_insert_with(
-		&mut self,
-		key: &[u8],
-		init: impl Fn() -> StorageValue,
-	) -> &mut StorageValue {
-		self.mark_dirty();
-
-		let value = self.top.modify(key.to_vec(), init, self.extrinsic_index());
-
-		// if the value was deleted initialise it back with an empty vec
-		value.get_or_insert_with(StorageValue::default)
-	}
-
 	/// Returns a double-Option: None if the key is unknown (i.e. and the query should be referred
 	/// to the backend); Some(None) if the key has been deleted. Some(Some(...)) for a key whose
 	/// value has been set.
-	pub fn child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Option<&[u8]>> {
-		let map = self.children.get(child_info.storage_key())?;
+	pub fn child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Option<&[u8]>> {
+		let map = self.children.get_mut(child_info.storage_key())?;
 		let value = map.0.get(key)?.value();
 		let size_read = value.map(|x| x.len() as u64).unwrap_or(0);
 		self.stats.tally_read_modified(size_read);
@@ -342,7 +323,21 @@ impl<H: Hasher> OverlayedChanges<H> {
 
 		let size_write = val.as_ref().map(|x| x.len() as u64).unwrap_or(0);
 		self.stats.tally_write_overlay(size_write);
-		self.top.set(key, val, self.extrinsic_index());
+		let extrinsic_index = self.extrinsic_index();
+		self.top.set(key, val, extrinsic_index);
+	}
+
+	/// Append a element to storage, init with existing value if first write.
+	pub fn append_storage(
+		&mut self,
+		key: StorageKey,
+		element: StorageValue,
+		init: impl Fn() -> StorageValue,
+	) {
+		let extrinsic_index = self.extrinsic_index();
+		let size_write = element.len() as u64;
+		self.stats.tally_write_overlay(size_write);
+		self.top.append_storage(key, element, init, extrinsic_index);
 	}
 
 	/// Set a new value for the specified key and child.
@@ -396,7 +391,8 @@ impl<H: Hasher> OverlayedChanges<H> {
 	pub fn clear_prefix(&mut self, prefix: &[u8]) -> u32 {
 		self.mark_dirty();
 
-		self.top.clear_where(|key, _| key.starts_with(prefix), self.extrinsic_index())
+		let extrinsic_index = self.extrinsic_index();
+		self.top.clear_where(|key, _| key.starts_with(prefix), extrinsic_index)
 	}
 
 	/// Removes all key-value pairs which keys share the given prefix.
@@ -457,7 +453,7 @@ impl<H: Hasher> OverlayedChanges<H> {
 		});
 		self.offchain
 			.overlay_mut()
-			.rollback_transaction()
+			.rollback_transaction_offchain()
 			.expect("Top and offchain changesets are started in lockstep; qed");
 		Ok(())
 	}
@@ -475,7 +471,7 @@ impl<H: Hasher> OverlayedChanges<H> {
 		}
 		self.offchain
 			.overlay_mut()
-			.commit_transaction()
+			.commit_transaction_offchain()
 			.expect("Top and offchain changesets are started in lockstep; qed");
 		Ok(())
 	}
@@ -511,7 +507,7 @@ impl<H: Hasher> OverlayedChanges<H> {
 		}
 		self.offchain
 			.overlay_mut()
-			.exit_runtime()
+			.exit_runtime_offchain()
 			.expect("Top and offchain changesets are started in lockstep; qed");
 		Ok(())
 	}
@@ -535,11 +531,24 @@ impl<H: Hasher> OverlayedChanges<H> {
 		self.children.values().map(|v| (v.0.changes(), &v.1))
 	}
 
+	/// Get an iterator over all child changes as seen by the current transaction.
+	pub fn children_mut(
+		&mut self,
+	) -> impl Iterator<Item = (impl Iterator<Item = (&StorageKey, &mut OverlayedValue)>, &ChildInfo)>
+	{
+		self.children.values_mut().map(|v| (v.0.changes_mut(), &v.1))
+	}
+
 	/// Get an iterator over all top changes as been by the current transaction.
 	pub fn changes(&self) -> impl Iterator<Item = (&StorageKey, &OverlayedValue)> {
 		self.top.changes()
 	}
 
+	/// Get an iterator over all top changes as been by the current transaction.
+	pub fn changes_mut(&mut self) -> impl Iterator<Item = (&StorageKey, &mut OverlayedValue)> {
+		self.top.changes_mut()
+	}
+
 	/// Get an optional iterator over all child changes stored under the supplied key.
 	pub fn child_changes(
 		&self,
@@ -548,6 +557,16 @@ impl<H: Hasher> OverlayedChanges<H> {
 		self.children.get(key).map(|(overlay, info)| (overlay.changes(), info))
 	}
 
+	/// Get an optional iterator over all child changes stored under the supplied key.
+	pub fn child_changes_mut(
+		&mut self,
+		key: &[u8],
+	) -> Option<(impl Iterator<Item = (&StorageKey, &mut OverlayedValue)>, &ChildInfo)> {
+		self.children
+			.get_mut(key)
+			.map(|(overlay, info)| (overlay.changes_mut(), &*info))
+	}
+
 	/// Get an list of all index operations.
 	pub fn transaction_index_ops(&self) -> &[IndexOperation] {
 		&self.transaction_index_ops
@@ -575,11 +594,12 @@ impl<H: Hasher> OverlayedChanges<H> {
 		};
 
 		use core::mem::take;
-		let main_storage_changes = take(&mut self.top).drain_committed();
-		let child_storage_changes = take(&mut self.children)
-			.into_iter()
-			.map(|(key, (val, info))| (key, (val.drain_committed(), info)));
-
+		let main_storage_changes =
+			take(&mut self.top).drain_committed().map(|(k, v)| (k, v.to_option()));
+		let child_storage_changes =
+			take(&mut self.children).into_iter().map(|(key, (val, info))| {
+				(key, (val.drain_committed().map(|(k, v)| (k, v.to_option())), info))
+			});
 		let offchain_storage_changes = self.offchain_drain_committed().collect();
 
 		#[cfg(feature = "std")]
@@ -610,7 +630,7 @@ impl<H: Hasher> OverlayedChanges<H> {
 	/// set this index before first and unset after last extrinsic is executed.
 	/// Changes that are made outside of extrinsics, are marked with
 	/// `NO_EXTRINSIC_INDEX` index.
-	fn extrinsic_index(&self) -> Option<u32> {
+	fn extrinsic_index(&mut self) -> Option<u32> {
 		self.collect_extrinsics.then(|| {
 			self.storage(EXTRINSIC_INDEX)
 				.and_then(|idx| idx.and_then(|idx| Decode::decode(&mut &*idx).ok()))
@@ -634,10 +654,12 @@ impl<H: Hasher> OverlayedChanges<H> {
 			return (cache.transaction_storage_root, true)
 		}
 
-		let delta = self.changes().map(|(k, v)| (&k[..], v.value().map(|v| &v[..])));
-		let child_delta = self.children().map(|(changes, info)| {
-			(info, changes.map(|(k, v)| (&k[..], v.value().map(|v| &v[..]))))
-		});
+		let delta = self.top.changes_mut().map(|(k, v)| (&k[..], v.value().map(|v| &v[..])));
+
+		let child_delta = self
+			.children
+			.values_mut()
+			.map(|v| (&v.1, v.0.changes_mut().map(|(k, v)| (&k[..], v.value().map(|v| &v[..])))));
 
 		let (root, transaction) = backend.full_storage_root(delta, child_delta, state_version);
 
@@ -677,7 +699,7 @@ impl<H: Hasher> OverlayedChanges<H> {
 			return Ok((root, true))
 		}
 
-		let root = if let Some((changes, info)) = self.child_changes(storage_key) {
+		let root = if let Some((changes, info)) = self.child_changes_mut(storage_key) {
 			let delta = changes.map(|(k, v)| (k.as_ref(), v.value().map(AsRef::as_ref)));
 			Some(backend.child_storage_root(info, delta, state_version))
 		} else {
@@ -711,19 +733,19 @@ impl<H: Hasher> OverlayedChanges<H> {
 
 	/// Returns an iterator over the keys (in lexicographic order) following `key` (excluding `key`)
 	/// alongside its value.
-	pub fn iter_after(&self, key: &[u8]) -> impl Iterator<Item = (&[u8], &OverlayedValue)> {
+	pub fn iter_after(&mut self, key: &[u8]) -> impl Iterator<Item = (&[u8], &mut OverlayedValue)> {
 		self.top.changes_after(key)
 	}
 
 	/// Returns an iterator over the keys (in lexicographic order) following `key` (excluding `key`)
 	/// alongside its value for the given `storage_key` child.
 	pub fn child_iter_after(
-		&self,
+		&mut self,
 		storage_key: &[u8],
 		key: &[u8],
-	) -> impl Iterator<Item = (&[u8], &OverlayedValue)> {
+	) -> impl Iterator<Item = (&[u8], &mut OverlayedValue)> {
 		self.children
-			.get(storage_key)
+			.get_mut(storage_key)
 			.map(|(overlay, _)| overlay.changes_after(key))
 			.into_iter()
 			.flatten()
@@ -858,7 +880,11 @@ mod tests {
 	use sp_core::{traits::Externalities, Blake2Hasher};
 	use std::collections::BTreeMap;
 
-	fn assert_extrinsics(overlay: &OverlayedChangeSet, key: impl AsRef<[u8]>, expected: Vec<u32>) {
+	fn assert_extrinsics(
+		overlay: &mut OverlayedChangeSet,
+		key: impl AsRef<[u8]>,
+		expected: Vec<u32>,
+	) {
 		assert_eq!(
 			overlay.get(key.as_ref()).unwrap().extrinsics().into_iter().collect::<Vec<_>>(),
 			expected
@@ -1049,9 +1075,9 @@ mod tests {
 		overlay.set_extrinsic_index(2);
 		overlay.set_storage(vec![1], Some(vec![6]));
 
-		assert_extrinsics(&overlay.top, vec![1], vec![0, 2]);
-		assert_extrinsics(&overlay.top, vec![3], vec![1]);
-		assert_extrinsics(&overlay.top, vec![100], vec![NO_EXTRINSIC_INDEX]);
+		assert_extrinsics(&mut overlay.top, vec![1], vec![0, 2]);
+		assert_extrinsics(&mut overlay.top, vec![3], vec![1]);
+		assert_extrinsics(&mut overlay.top, vec![100], vec![NO_EXTRINSIC_INDEX]);
 
 		overlay.start_transaction();
 
@@ -1061,15 +1087,15 @@ mod tests {
 		overlay.set_extrinsic_index(4);
 		overlay.set_storage(vec![1], Some(vec![8]));
 
-		assert_extrinsics(&overlay.top, vec![1], vec![0, 2, 4]);
-		assert_extrinsics(&overlay.top, vec![3], vec![1, 3]);
-		assert_extrinsics(&overlay.top, vec![100], vec![NO_EXTRINSIC_INDEX]);
+		assert_extrinsics(&mut overlay.top, vec![1], vec![0, 2, 4]);
+		assert_extrinsics(&mut overlay.top, vec![3], vec![1, 3]);
+		assert_extrinsics(&mut overlay.top, vec![100], vec![NO_EXTRINSIC_INDEX]);
 
 		overlay.rollback_transaction().unwrap();
 
-		assert_extrinsics(&overlay.top, vec![1], vec![0, 2]);
-		assert_extrinsics(&overlay.top, vec![3], vec![1]);
-		assert_extrinsics(&overlay.top, vec![100], vec![NO_EXTRINSIC_INDEX]);
+		assert_extrinsics(&mut overlay.top, vec![1], vec![0, 2]);
+		assert_extrinsics(&mut overlay.top, vec![3], vec![1]);
+		assert_extrinsics(&mut overlay.top, vec![100], vec![NO_EXTRINSIC_INDEX]);
 	}
 
 	#[test]
diff --git a/substrate/primitives/state-machine/src/overlayed_changes/offchain.rs b/substrate/primitives/state-machine/src/overlayed_changes/offchain.rs
index 1e6965e874759e30b415783a560192af8412027d..517a51b02693c0528cf9475972a259ab72fd5f59 100644
--- a/substrate/primitives/state-machine/src/overlayed_changes/offchain.rs
+++ b/substrate/primitives/state-machine/src/overlayed_changes/offchain.rs
@@ -42,7 +42,7 @@ impl OffchainOverlayedChanges {
 	}
 
 	/// Iterate over all key value pairs by reference.
-	pub fn iter(&self) -> impl Iterator<Item = OffchainOverlayedChangesItem> {
+	pub fn iter(&mut self) -> impl Iterator<Item = OffchainOverlayedChangesItem> {
 		self.0.changes().map(|kv| (kv.0, kv.1.value_ref()))
 	}
 
@@ -53,14 +53,16 @@ impl OffchainOverlayedChanges {
 
 	/// Remove a key and its associated value from the offchain database.
 	pub fn remove(&mut self, prefix: &[u8], key: &[u8]) {
-		let _ = self
-			.0
-			.set((prefix.to_vec(), key.to_vec()), OffchainOverlayedChange::Remove, None);
+		let _ = self.0.set_offchain(
+			(prefix.to_vec(), key.to_vec()),
+			OffchainOverlayedChange::Remove,
+			None,
+		);
 	}
 
 	/// Set the value associated with a key under a prefix to the value provided.
 	pub fn set(&mut self, prefix: &[u8], key: &[u8], value: &[u8]) {
-		let _ = self.0.set(
+		let _ = self.0.set_offchain(
 			(prefix.to_vec(), key.to_vec()),
 			OffchainOverlayedChange::SetValue(value.to_vec()),
 			None,
@@ -68,7 +70,7 @@ impl OffchainOverlayedChanges {
 	}
 
 	/// Obtain a associated value to the given key in storage with prefix.
-	pub fn get(&self, prefix: &[u8], key: &[u8]) -> Option<OffchainOverlayedChange> {
+	pub fn get(&mut self, prefix: &[u8], key: &[u8]) -> Option<OffchainOverlayedChange> {
 		let key = (prefix.to_vec(), key.to_vec());
 		self.0.get(&key).map(|entry| entry.value_ref()).cloned()
 	}
diff --git a/substrate/primitives/state-machine/src/read_only.rs b/substrate/primitives/state-machine/src/read_only.rs
index 2056bf9866358d4d5086fbdf67a7385e7532092f..b78d17138b0ff5c968a858ab7515b5d82a9673c3 100644
--- a/substrate/primitives/state-machine/src/read_only.rs
+++ b/substrate/primitives/state-machine/src/read_only.rs
@@ -88,39 +88,39 @@ where
 		panic!("Should not be used in read-only externalities!")
 	}
 
-	fn storage(&self, key: &[u8]) -> Option<StorageValue> {
+	fn storage(&mut self, key: &[u8]) -> Option<StorageValue> {
 		self.backend
 			.storage(key)
 			.expect("Backed failed for storage in ReadOnlyExternalities")
 	}
 
-	fn storage_hash(&self, key: &[u8]) -> Option<Vec<u8>> {
+	fn storage_hash(&mut self, key: &[u8]) -> Option<Vec<u8>> {
 		self.backend
 			.storage_hash(key)
 			.expect("Backed failed for storage_hash in ReadOnlyExternalities")
 			.map(|h| h.encode())
 	}
 
-	fn child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageValue> {
+	fn child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageValue> {
 		self.backend
 			.child_storage(child_info, key)
 			.expect("Backed failed for child_storage in ReadOnlyExternalities")
 	}
 
-	fn child_storage_hash(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage_hash(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
 		self.backend
 			.child_storage_hash(child_info, key)
 			.expect("Backed failed for child_storage_hash in ReadOnlyExternalities")
 			.map(|h| h.encode())
 	}
 
-	fn next_storage_key(&self, key: &[u8]) -> Option<StorageKey> {
+	fn next_storage_key(&mut self, key: &[u8]) -> Option<StorageKey> {
 		self.backend
 			.next_storage_key(key)
 			.expect("Backed failed for next_storage_key in ReadOnlyExternalities")
 	}
 
-	fn next_child_storage_key(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageKey> {
+	fn next_child_storage_key(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageKey> {
 		self.backend
 			.next_child_storage_key(child_info, key)
 			.expect("Backed failed for next_child_storage_key in ReadOnlyExternalities")
diff --git a/substrate/primitives/state-machine/src/testing.rs b/substrate/primitives/state-machine/src/testing.rs
index e19ba95755c1b16f5cc6a2d59a8ede48997707f0..e9d64a891e819094d8a2c4d49265d01d6b7fc965 100644
--- a/substrate/primitives/state-machine/src/testing.rs
+++ b/substrate/primitives/state-machine/src/testing.rs
@@ -209,12 +209,15 @@ where
 	///
 	/// In contrast to [`commit_all`](Self::commit_all) this will not panic if there are open
 	/// transactions.
-	pub fn as_backend(&self) -> InMemoryBackend<H> {
-		let top: Vec<_> =
-			self.overlay.changes().map(|(k, v)| (k.clone(), v.value().cloned())).collect();
+	pub fn as_backend(&mut self) -> InMemoryBackend<H> {
+		let top: Vec<_> = self
+			.overlay
+			.changes_mut()
+			.map(|(k, v)| (k.clone(), v.value().cloned()))
+			.collect();
 		let mut transaction = vec![(None, top)];
 
-		for (child_changes, child_info) in self.overlay.children() {
+		for (child_changes, child_info) in self.overlay.children_mut() {
 			transaction.push((
 				Some(child_info.clone()),
 				child_changes.map(|(k, v)| (k.clone(), v.value().cloned())).collect(),
@@ -293,13 +296,14 @@ where
 	}
 }
 
-impl<H: Hasher> PartialEq for TestExternalities<H>
+impl<H> TestExternalities<H>
 where
+	H: Hasher,
 	H::Out: Ord + 'static + codec::Codec,
 {
 	/// This doesn't test if they are in the same state, only if they contains the
 	/// same data at this state
-	fn eq(&self, other: &TestExternalities<H>) -> bool {
+	pub fn eq(&mut self, other: &mut TestExternalities<H>) -> bool {
 		self.as_backend().eq(&other.as_backend())
 	}
 }
diff --git a/substrate/primitives/statement-store/Cargo.toml b/substrate/primitives/statement-store/Cargo.toml
index bb893b25dc443f617ab5c0dd3d0d22c94646b689..60919b7439ea8fbbaa9bedca14286c92df664094 100644
--- a/substrate/primitives/statement-store/Cargo.toml
+++ b/substrate/primitives/statement-store/Cargo.toml
@@ -30,7 +30,7 @@ thiserror = { optional = true, workspace = true }
 # ECIES dependencies
 ed25519-dalek = { version = "2.1", optional = true }
 x25519-dalek = { version = "2.0", optional = true, features = ["static_secrets"] }
-curve25519-dalek = { version = "4.1.1", optional = true }
+curve25519-dalek = { version = "4.1.3", optional = true }
 aes-gcm = { version = "0.10", optional = true }
 hkdf = { version = "0.12.0", optional = true }
 sha2 = { version = "0.10.7", optional = true }
diff --git a/substrate/primitives/storage/src/lib.rs b/substrate/primitives/storage/src/lib.rs
index 197994f574719ec0b000b8dbd79f333c71291708..3b9afae4ca078d1e69f5e33e9b3cfeee76b4a328 100644
--- a/substrate/primitives/storage/src/lib.rs
+++ b/substrate/primitives/storage/src/lib.rs
@@ -293,7 +293,7 @@ impl ChildInfo {
 		}
 	}
 
-	/// Return a the full location in the direct parent of
+	/// Return the full location in the direct parent of
 	/// this trie.
 	pub fn prefixed_storage_key(&self) -> PrefixedStorageKey {
 		match self {
@@ -302,7 +302,7 @@ impl ChildInfo {
 		}
 	}
 
-	/// Returns a the full location in the direct parent of
+	/// Returns the full location in the direct parent of
 	/// this trie.
 	pub fn into_prefixed_storage_key(self) -> PrefixedStorageKey {
 		match self {
diff --git a/substrate/primitives/trie/src/lib.rs b/substrate/primitives/trie/src/lib.rs
index 54f202eda0c9ac3d3991c094b3f406f8d78d4c4d..0c14e3af196d062e08f86ee8b6a7fa370a2a28bd 100644
--- a/substrate/primitives/trie/src/lib.rs
+++ b/substrate/primitives/trie/src/lib.rs
@@ -195,11 +195,11 @@ pub type MemoryDB<H> = memory_db::MemoryDB<H, memory_db::HashKey<H>, trie_db::DB
 /// Reexport from `hash_db`, with genericity set for `Hasher` trait.
 pub type GenericMemoryDB<H, KF> = memory_db::MemoryDB<H, KF, trie_db::DBValue>;
 
-/// Persistent trie database read-access interface for the a given hasher.
+/// Persistent trie database read-access interface for a given hasher.
 pub type TrieDB<'a, 'cache, L> = trie_db::TrieDB<'a, 'cache, L>;
 /// Builder for creating a [`TrieDB`].
 pub type TrieDBBuilder<'a, 'cache, L> = trie_db::TrieDBBuilder<'a, 'cache, L>;
-/// Persistent trie database write-access interface for the a given hasher.
+/// Persistent trie database write-access interface for a given hasher.
 pub type TrieDBMut<'a, L> = trie_db::TrieDBMut<'a, L>;
 /// Builder for creating a [`TrieDBMut`].
 pub type TrieDBMutBuilder<'a, L> = trie_db::TrieDBMutBuilder<'a, L>;
@@ -212,17 +212,17 @@ pub type TrieHash<L> = <<L as TrieLayout>::Hash as Hasher>::Out;
 pub mod trie_types {
 	use super::*;
 
-	/// Persistent trie database read-access interface for the a given hasher.
+	/// Persistent trie database read-access interface for a given hasher.
 	///
 	/// Read only V1 and V0 are compatible, thus we always use V1.
 	pub type TrieDB<'a, 'cache, H> = super::TrieDB<'a, 'cache, LayoutV1<H>>;
 	/// Builder for creating a [`TrieDB`].
 	pub type TrieDBBuilder<'a, 'cache, H> = super::TrieDBBuilder<'a, 'cache, LayoutV1<H>>;
-	/// Persistent trie database write-access interface for the a given hasher.
+	/// Persistent trie database write-access interface for a given hasher.
 	pub type TrieDBMutV0<'a, H> = super::TrieDBMut<'a, LayoutV0<H>>;
 	/// Builder for creating a [`TrieDBMutV0`].
 	pub type TrieDBMutBuilderV0<'a, H> = super::TrieDBMutBuilder<'a, LayoutV0<H>>;
-	/// Persistent trie database write-access interface for the a given hasher.
+	/// Persistent trie database write-access interface for a given hasher.
 	pub type TrieDBMutV1<'a, H> = super::TrieDBMut<'a, LayoutV1<H>>;
 	/// Builder for creating a [`TrieDBMutV1`].
 	pub type TrieDBMutBuilderV1<'a, H> = super::TrieDBMutBuilder<'a, LayoutV1<H>>;
diff --git a/substrate/scripts/ci/deny.toml b/substrate/scripts/ci/deny.toml
deleted file mode 100644
index 2e1701f3c60da3d2bebbafdbf1290a8e37bac859..0000000000000000000000000000000000000000
--- a/substrate/scripts/ci/deny.toml
+++ /dev/null
@@ -1,118 +0,0 @@
-[licenses]
-# The lint level for crates which do not have a detectable license
-unlicensed = "deny"
-# List of explicitly allowed licenses
-# See https://spdx.org/licenses/ for list of possible licenses
-# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
-allow = [
-	"MPL-2.0",
-]
-# List of explicitly disallowed licenses
-# See https://spdx.org/licenses/ for list of possible licenses
-# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
-deny = [
-]
-# Lint level for licenses considered copyleft
-copyleft = "deny"
-# Blanket approval or denial for OSI-approved or FSF Free/Libre licenses
-# * both - The license will be approved if it is both OSI-approved *AND* FSF
-# * either - The license will be approved if it is either OSI-approved *OR* FSF
-# * osi-only - The license will be approved if is OSI-approved *AND NOT* FSF
-# * fsf-only - The license will be approved if is FSF *AND NOT* OSI-approved
-# * neither - This predicate is ignored and the default lint level is used
-allow-osi-fsf-free = "either"
-# Lint level used when no other predicates are matched
-# 1. License isn't in the allow or deny lists
-# 2. License isn't copyleft
-# 3. License isn't OSI/FSF, or allow-osi-fsf-free = "neither"
-default = "deny"
-# The confidence threshold for detecting a license from license text.
-# The higher the value, the more closely the license text must be to the
-# canonical license text of a valid SPDX license file.
-# [possible values: any between 0.0 and 1.0].
-confidence-threshold = 0.8
-# Allow 1 or more licenses on a per-crate basis, so that particular licenses
-# aren't accepted for every possible crate as with the normal allow list
-exceptions = [
-	# Each entry is the crate and version constraint, and its specific allow list
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "chain-spec-builder" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "mmr-gadget" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "node-bench" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "node-inspect" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "node-template-release" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "node-testing" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-authority-discovery" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-basic-authorship" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-block-builder" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-chain-spec" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-chain-spec-derive" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-cli" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-client-api" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-client-db" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-aura" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-babe" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-babe-rpc" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-beefy" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-beefy-rpc" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-epochs" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-grandpa" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-grandpa-rpc" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-manual-seal" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-pow" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-consensus-slots" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-executor" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-executor-common" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-executor-wasmi" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-executor-wasmtime" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-informant" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-keystore" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-mixnet" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-common" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-gossip" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-light" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-statement" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-sync" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-test" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-transactions" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-offchain" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-peerset" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-proposer-metrics" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-rpc" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-rpc-api" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-rpc-server" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-rpc-spec-v2" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-runtime-test" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-service" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-service-test" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-state-db" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-statement-store" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-storage-monitor" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-sysinfo" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-telemetry" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-tracing" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-transaction-pool" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-transaction-pool-api" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "staging-node-cli" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "subkey" },
-	{ allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "substrate" },
-]
-
-# Some crates don't have (easily) machine readable licensing information,
-# adding a clarification entry for it allows you to manually specify the
-# licensing information
-[[licenses.clarify]]
-# The name of the crate the clarification applies to
-name = "ring"
-# The SPDX expression for the license requirements of the crate
-expression = "MIT AND ISC AND OpenSSL"
-# One or more files in the crate's source used as the "source of truth" for
-# the license expression. If the contents match, the clarification will be used
-# when running the license check, otherwise the clarification will be ignored
-# and the crate will be checked normally, which may produce warnings or errors
-# depending on the rest of your configuration
-license-files = [
-	# Each entry is a crate relative path, and the (opaque) hash of its contents
-	{ path = "LICENSE", hash = 0xbd0eed23 },
-]
diff --git a/substrate/test-utils/client/src/client_ext.rs b/substrate/test-utils/client/src/client_ext.rs
index 73581a4f0efa31c195f3856a8894692a2f71bcfb..9dc4739eb795437cff17fae69e5a0181cf150510 100644
--- a/substrate/test-utils/client/src/client_ext.rs
+++ b/substrate/test-utils/client/src/client_ext.rs
@@ -153,7 +153,7 @@ where
 	Self: BlockImport<Block, Error = ConsensusError>,
 	RA: Send,
 	B: Send + Sync,
-	E: Send,
+	E: Send + Sync,
 {
 	async fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
 		let (header, extrinsics) = block.deconstruct();
diff --git a/substrate/test-utils/runtime/Cargo.toml b/substrate/test-utils/runtime/Cargo.toml
index 038076e10c5acbdaa49330c534a26ddb511ce307..8733ff9fcebb36199c341cd6d90a96623212944c 100644
--- a/substrate/test-utils/runtime/Cargo.toml
+++ b/substrate/test-utils/runtime/Cargo.toml
@@ -37,6 +37,7 @@ sp-runtime = { path = "../../primitives/runtime", default-features = false, feat
 pallet-babe = { path = "../../frame/babe", default-features = false }
 pallet-balances = { path = "../../frame/balances", default-features = false }
 frame-executive = { path = "../../frame/executive", default-features = false }
+frame-metadata-hash-extension = { path = "../../frame/metadata-hash-extension", default-features = false }
 frame-system = { path = "../../frame/system", default-features = false }
 frame-system-rpc-runtime-api = { path = "../../frame/system/rpc/runtime-api", default-features = false }
 pallet-timestamp = { path = "../../frame/timestamp", default-features = false }
@@ -67,7 +68,7 @@ serde = { features = ["alloc", "derive"], workspace = true }
 serde_json = { features = ["alloc"], workspace = true }
 
 [build-dependencies]
-substrate-wasm-builder = { path = "../../utils/wasm-builder", optional = true }
+substrate-wasm-builder = { path = "../../utils/wasm-builder", optional = true, features = ["metadata-hash"] }
 
 [features]
 default = ["std"]
@@ -76,6 +77,7 @@ std = [
 	"array-bytes",
 	"codec/std",
 	"frame-executive/std",
+	"frame-metadata-hash-extension/std",
 	"frame-support/std",
 	"frame-system-rpc-runtime-api/std",
 	"frame-system/std",
@@ -112,5 +114,6 @@ std = [
 	"substrate-wasm-builder",
 	"trie-db/std",
 ]
+
 # Special feature to disable logging
 disable-logging = ["sp-api/disable-logging"]
diff --git a/substrate/test-utils/runtime/build.rs b/substrate/test-utils/runtime/build.rs
index dd79ce2c5ae842ad7fc1c759a14fa8dedd200a1a..d38173fcfcb4eff6debb4b23c1341d334025d7ed 100644
--- a/substrate/test-utils/runtime/build.rs
+++ b/substrate/test-utils/runtime/build.rs
@@ -25,6 +25,7 @@ fn main() {
 			// to this value by default. This is because some of our tests
 			// (`restoration_of_globals`) depend on the stack-size.
 			.append_to_rust_flags("-Clink-arg=-zstack-size=1048576")
+			.enable_metadata_hash("TOKEN", 10)
 			.import_memory()
 			.build();
 	}
diff --git a/substrate/test-utils/runtime/src/extrinsic.rs b/substrate/test-utils/runtime/src/extrinsic.rs
index e355e5d099ad5a01c74512f79d722fdf968af02e..5ae0d8f8f6eca2517b3a2c4db6fc8f4501744511 100644
--- a/substrate/test-utils/runtime/src/extrinsic.rs
+++ b/substrate/test-utils/runtime/src/extrinsic.rs
@@ -22,10 +22,11 @@ use crate::{
 	CheckSubstrateCall, Extrinsic, Nonce, Pair, RuntimeCall, SignedPayload, TransferData,
 };
 use codec::Encode;
+use frame_metadata_hash_extension::CheckMetadataHash;
 use frame_system::{CheckNonce, CheckWeight};
 use sp_core::crypto::Pair as TraitPair;
 use sp_keyring::AccountKeyring;
-use sp_runtime::{transaction_validity::TransactionPriority, Perbill};
+use sp_runtime::{traits::SignedExtension, transaction_validity::TransactionPriority, Perbill};
 
 /// Transfer used in test substrate pallet. Extrinsic is created and signed using this data.
 #[derive(Clone)]
@@ -81,17 +82,23 @@ pub struct ExtrinsicBuilder {
 	function: RuntimeCall,
 	signer: Option<Pair>,
 	nonce: Option<Nonce>,
+	metadata_hash: Option<[u8; 32]>,
 }
 
 impl ExtrinsicBuilder {
 	/// Create builder for given `RuntimeCall`. By default `Extrinsic` will be signed by `Alice`.
 	pub fn new(function: impl Into<RuntimeCall>) -> Self {
-		Self { function: function.into(), signer: Some(AccountKeyring::Alice.pair()), nonce: None }
+		Self {
+			function: function.into(),
+			signer: Some(AccountKeyring::Alice.pair()),
+			nonce: None,
+			metadata_hash: None,
+		}
 	}
 
 	/// Create builder for given `RuntimeCall`. `Extrinsic` will be unsigned.
 	pub fn new_unsigned(function: impl Into<RuntimeCall>) -> Self {
-		Self { function: function.into(), signer: None, nonce: None }
+		Self { function: function.into(), signer: None, nonce: None, metadata_hash: None }
 	}
 
 	/// Create builder for `pallet_call::bench_transfer` from given `TransferData`.
@@ -105,6 +112,7 @@ impl ExtrinsicBuilder {
 		Self {
 			nonce: Some(transfer.nonce),
 			signer: Some(transfer.from.clone()),
+			metadata_hash: None,
 			..Self::new(BalancesCall::transfer_allow_death {
 				dest: transfer.to,
 				value: transfer.amount,
@@ -186,6 +194,12 @@ impl ExtrinsicBuilder {
 		self
 	}
 
+	/// Metadata hash to put into the signed data of the extrinsic.
+	pub fn metadata_hash(mut self, metadata_hash: [u8; 32]) -> Self {
+		self.metadata_hash = Some(metadata_hash);
+		self
+	}
+
 	/// Build `Extrinsic` using embedded parameters
 	pub fn build(self) -> Extrinsic {
 		if let Some(signer) = self.signer {
@@ -193,9 +207,15 @@ impl ExtrinsicBuilder {
 				CheckNonce::from(self.nonce.unwrap_or(0)),
 				CheckWeight::new(),
 				CheckSubstrateCall {},
+				self.metadata_hash
+					.map(CheckMetadataHash::new_with_custom_hash)
+					.unwrap_or_else(|| CheckMetadataHash::new(false)),
+			);
+			let raw_payload = SignedPayload::from_raw(
+				self.function.clone(),
+				extra.clone(),
+				extra.additional_signed().unwrap(),
 			);
-			let raw_payload =
-				SignedPayload::from_raw(self.function.clone(), extra.clone(), ((), (), ()));
 			let signature = raw_payload.using_encoded(|e| signer.sign(e));
 
 			Extrinsic::new_signed(self.function, signer.public(), signature, extra)
diff --git a/substrate/test-utils/runtime/src/lib.rs b/substrate/test-utils/runtime/src/lib.rs
index 370aa0034fcd10db18007050c8b0701810655ada..0aab6d3f01ca075b85f1c43f879168e2a0e5280d 100644
--- a/substrate/test-utils/runtime/src/lib.rs
+++ b/substrate/test-utils/runtime/src/lib.rs
@@ -149,7 +149,12 @@ pub type Signature = sr25519::Signature;
 pub type Pair = sp_core::sr25519::Pair;
 
 /// The SignedExtension to the basic transaction logic.
-pub type SignedExtra = (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall);
+pub type SignedExtra = (
+	CheckNonce<Runtime>,
+	CheckWeight<Runtime>,
+	CheckSubstrateCall,
+	frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
+);
 /// The payload being signed in transactions.
 pub type SignedPayload = sp_runtime::generic::SignedPayload<RuntimeCall, SignedExtra>;
 /// Unchecked extrinsic type as expected by this runtime.
@@ -350,29 +355,12 @@ parameter_types! {
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::pallet::Config for Runtime {
-	type BaseCallFilter = frame_support::traits::Everything;
 	type BlockWeights = RuntimeBlockWeights;
-	type BlockLength = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
 	type Nonce = Nonce;
-	type Hash = H256;
-	type Hashing = Hashing;
 	type AccountId = AccountId;
 	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<2400>;
-	type DbWeight = ();
-	type Version = ();
-	type PalletInfo = PalletInfo;
 	type AccountData = pallet_balances::AccountData<Balance>;
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ();
-	type OnSetCode = ();
-	type MaxConsumers = ConstU32<16>;
 }
 
 pub mod currency {
@@ -494,14 +482,14 @@ impl_runtime_apis! {
 
 	impl sp_api::Metadata<Block> for Runtime {
 		fn metadata() -> OpaqueMetadata {
-			unimplemented!()
+			OpaqueMetadata::new(Runtime::metadata().into())
 		}
 
-		fn metadata_at_version(_version: u32) -> Option<OpaqueMetadata> {
-			unimplemented!()
+		fn metadata_at_version(version: u32) -> Option<OpaqueMetadata> {
+			Runtime::metadata_at_version(version)
 		}
 		fn metadata_versions() -> alloc::vec::Vec<u32> {
-			unimplemented!()
+			Runtime::metadata_versions()
 		}
 	}
 
diff --git a/substrate/utils/frame/benchmarking-cli/src/overhead/README.md b/substrate/utils/frame/benchmarking-cli/src/overhead/README.md
index 648908010ba04cf6b19cf2aa50c0ea68491a1e28..cee095fb8cadd4fab0cc34c53bc8f0f7df6fc830 100644
--- a/substrate/utils/frame/benchmarking-cli/src/overhead/README.md
+++ b/substrate/utils/frame/benchmarking-cli/src/overhead/README.md
@@ -108,7 +108,7 @@ The complete command for Polkadot looks like this:
 cargo run --profile=production -- benchmark overhead --chain=polkadot-dev --wasm-execution=compiled --weight-path=runtime/polkadot/constants/src/weights/
 ```
 
-This will overwrite the the
+This will overwrite the
 [block_weights.rs](https://github.com/paritytech/polkadot/blob/c254e5975711a6497af256f6831e9a6c752d28f5/runtime/polkadot/constants/src/weights/block_weights.rs)
 and
 [extrinsic_weights.rs](https://github.com/paritytech/polkadot/blob/c254e5975711a6497af256f6831e9a6c752d28f5/runtime/polkadot/constants/src/weights/extrinsic_weights.rs)
diff --git a/substrate/utils/frame/omni-bencher/Cargo.toml b/substrate/utils/frame/omni-bencher/Cargo.toml
index 0c2d1a1b32b1f973955795a7d883a3ef72b268aa..41e3882c9d79ddd735cb33eaa5ffa37cc63b0a67 100644
--- a/substrate/utils/frame/omni-bencher/Cargo.toml
+++ b/substrate/utils/frame/omni-bencher/Cargo.toml
@@ -11,7 +11,7 @@ license.workspace = true
 workspace = true
 
 [dependencies]
-clap = { version = "4.5.2", features = ["derive"] }
+clap = { version = "4.5.3", features = ["derive"] }
 cumulus-primitives-proof-size-hostfunction = { path = "../../../../cumulus/primitives/proof-size-hostfunction" }
 frame-benchmarking-cli = { path = "../benchmarking-cli", default-features = false }
 sc-cli = { path = "../../../client/cli" }
diff --git a/substrate/utils/frame/remote-externalities/src/lib.rs b/substrate/utils/frame/remote-externalities/src/lib.rs
index 0ecb98f31343aa050d9daa8f33445e858631813d..44e5f467d895e34eca95d2b6ef86186b03d2f6b2 100644
--- a/substrate/utils/frame/remote-externalities/src/lib.rs
+++ b/substrate/utils/frame/remote-externalities/src/lib.rs
@@ -1383,7 +1383,7 @@ mod remote_tests {
 		init_logger();
 
 		// create an ext with children keys
-		let child_ext = Builder::<Block>::new()
+		let mut child_ext = Builder::<Block>::new()
 			.mode(Mode::Online(OnlineConfig {
 				transport: endpoint().clone().into(),
 				pallets: vec!["Proxy".to_owned()],
@@ -1396,7 +1396,7 @@ mod remote_tests {
 			.unwrap();
 
 		// create an ext without children keys
-		let ext = Builder::<Block>::new()
+		let mut ext = Builder::<Block>::new()
 			.mode(Mode::Online(OnlineConfig {
 				transport: endpoint().clone().into(),
 				pallets: vec!["Proxy".to_owned()],
diff --git a/substrate/utils/frame/rpc/system/Cargo.toml b/substrate/utils/frame/rpc/system/Cargo.toml
index 6829d753ed71327dea8ad4e65d91af67c14285f1..75d24e8e210fcde7822b6c53079a2f958f1d956a 100644
--- a/substrate/utils/frame/rpc/system/Cargo.toml
+++ b/substrate/utils/frame/rpc/system/Cargo.toml
@@ -16,9 +16,14 @@ workspace = true
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12" }
-jsonrpsee = { version = "0.22.5", features = ["client-core", "macros", "server-core"] }
 futures = "0.3.30"
+codec = { package = "parity-scale-codec", version = "3.6.12" }
+docify = "0.2.0"
+jsonrpsee = { version = "0.22.5", features = [
+	"client-core",
+	"macros",
+	"server-core",
+] }
 log = { workspace = true, default-features = true }
 frame-system-rpc-runtime-api = { path = "../../../../frame/system/rpc/runtime-api" }
 sc-rpc-api = { path = "../../../../client/rpc-api" }
diff --git a/substrate/utils/frame/rpc/system/src/lib.rs b/substrate/utils/frame/rpc/system/src/lib.rs
index bb0592599b2ad678acd7475e8ed868b4454f2d53..8cb7b785bc7c0b895182d27938d02e6a78709cb4 100644
--- a/substrate/utils/frame/rpc/system/src/lib.rs
+++ b/substrate/utils/frame/rpc/system/src/lib.rs
@@ -37,6 +37,7 @@ use sp_runtime::{legacy, traits};
 pub use frame_system_rpc_runtime_api::AccountNonceApi;
 
 /// System RPC methods.
+#[docify::export]
 #[rpc(client, server)]
 pub trait SystemApi<BlockHash, AccountId, Nonce> {
 	/// Returns the next valid index (aka nonce) for given account.
diff --git a/substrate/utils/wasm-builder/Cargo.toml b/substrate/utils/wasm-builder/Cargo.toml
index bac323e2e6a0905cf1d956589235c196ef2881a4..090955494f0a7572a08407c2aed26919863b3837 100644
--- a/substrate/utils/wasm-builder/Cargo.toml
+++ b/substrate/utils/wasm-builder/Cargo.toml
@@ -27,3 +27,34 @@ filetime = "0.2.16"
 wasm-opt = "0.116"
 parity-wasm = "0.45"
 polkavm-linker = { workspace = true }
+
+# Dependencies required for the `metadata-hash` feature.
+merkleized-metadata = { version = "0.1.0", optional = true }
+sc-executor = { path = "../../client/executor", optional = true }
+sp-core = { path = "../../primitives/core", optional = true }
+sp-io = { path = "../../primitives/io", optional = true }
+sp-version = { path = "../../primitives/version", optional = true }
+frame-metadata = { version = "16.0.0", features = ["current"], optional = true }
+codec = { package = "parity-scale-codec", version = "3.1.5", optional = true }
+array-bytes = { version = "6.1", optional = true }
+sp-tracing = { path = "../../primitives/tracing", optional = true }
+
+[features]
+# Enable support for generating the metadata hash.
+#
+# To generate the metadata hash the runtime is build once, executed to build the metadata and then
+# build a second time with the `RUNTIME_METADATA_HASH` environment variable set. The environment
+# variable then contains the hash and can be used inside the runtime.
+#
+# This pulls in quite a lot of dependencies and thus, is disabled by default.
+metadata-hash = [
+	"array-bytes",
+	"codec",
+	"frame-metadata",
+	"merkleized-metadata",
+	"sc-executor",
+	"sp-core",
+	"sp-io",
+	"sp-tracing",
+	"sp-version",
+]
diff --git a/substrate/utils/wasm-builder/src/builder.rs b/substrate/utils/wasm-builder/src/builder.rs
index 163703fbec628327c0ba3dc0683972285af71e30..37c6c4aa74319321122dabb6d3da7295d753732e 100644
--- a/substrate/utils/wasm-builder/src/builder.rs
+++ b/substrate/utils/wasm-builder/src/builder.rs
@@ -23,6 +23,13 @@ use std::{
 
 use crate::RuntimeTarget;
 
+/// Extra information when generating the `metadata-hash`.
+#[cfg(feature = "metadata-hash")]
+pub(crate) struct MetadataExtraInfo {
+	pub decimals: u8,
+	pub token_symbol: String,
+}
+
 /// Returns the manifest dir from the `CARGO_MANIFEST_DIR` env.
 fn get_manifest_dir() -> PathBuf {
 	env::var("CARGO_MANIFEST_DIR")
@@ -53,6 +60,8 @@ impl WasmBuilderSelectProject {
 			disable_runtime_version_section_check: false,
 			export_heap_base: false,
 			import_memory: false,
+			#[cfg(feature = "metadata-hash")]
+			enable_metadata_hash: None,
 		}
 	}
 
@@ -71,6 +80,8 @@ impl WasmBuilderSelectProject {
 				disable_runtime_version_section_check: false,
 				export_heap_base: false,
 				import_memory: false,
+				#[cfg(feature = "metadata-hash")]
+				enable_metadata_hash: None,
 			})
 		} else {
 			Err("Project path must point to the `Cargo.toml` of the project")
@@ -108,6 +119,10 @@ pub struct WasmBuilder {
 	export_heap_base: bool,
 	/// Whether `--import-memory` should be added to the link args (WASM-only).
 	import_memory: bool,
+
+	/// Whether to enable the metadata hash generation.
+	#[cfg(feature = "metadata-hash")]
+	enable_metadata_hash: Option<MetadataExtraInfo>,
 }
 
 impl WasmBuilder {
@@ -191,6 +206,22 @@ impl WasmBuilder {
 		self
 	}
 
+	/// Enable generation of the metadata hash.
+	///
+	/// This will compile the runtime once, fetch the metadata, build the metadata hash and
+	/// then compile again with the env `RUNTIME_METADATA_HASH` set. For more information
+	/// about the metadata hash see [RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html).
+	///
+	/// - `token_symbol`: The symbol of the main native token of the chain.
+	/// - `decimals`: The number of decimals of the main native token.
+	#[cfg(feature = "metadata-hash")]
+	pub fn enable_metadata_hash(mut self, token_symbol: impl Into<String>, decimals: u8) -> Self {
+		self.enable_metadata_hash =
+			Some(MetadataExtraInfo { token_symbol: token_symbol.into(), decimals });
+
+		self
+	}
+
 	/// Disable the check for the `runtime_version` wasm section.
 	///
 	/// By default the `wasm-builder` will ensure that the `runtime_version` section will
@@ -237,6 +268,8 @@ impl WasmBuilder {
 			self.features_to_enable,
 			self.file_name,
 			!self.disable_runtime_version_section_check,
+			#[cfg(feature = "metadata-hash")]
+			self.enable_metadata_hash,
 		);
 
 		// As last step we need to generate our `rerun-if-changed` stuff. If a build fails, we don't
@@ -311,6 +344,7 @@ fn build_project(
 	features_to_enable: Vec<String>,
 	wasm_binary_name: Option<String>,
 	check_for_runtime_version_section: bool,
+	#[cfg(feature = "metadata-hash")] enable_metadata_hash: Option<MetadataExtraInfo>,
 ) {
 	let cargo_cmd = match crate::prerequisites::check(target) {
 		Ok(cmd) => cmd,
@@ -328,6 +362,8 @@ fn build_project(
 		features_to_enable,
 		wasm_binary_name,
 		check_for_runtime_version_section,
+		#[cfg(feature = "metadata-hash")]
+		enable_metadata_hash,
 	);
 
 	let (wasm_binary, wasm_binary_bloaty) = if let Some(wasm_binary) = wasm_binary {
diff --git a/substrate/utils/wasm-builder/src/lib.rs b/substrate/utils/wasm-builder/src/lib.rs
index 9ebab38b9cb2f727594e310f1e6d27c221f528dc..07de4c15831b842e6ac559ebf445901744d7d98f 100644
--- a/substrate/utils/wasm-builder/src/lib.rs
+++ b/substrate/utils/wasm-builder/src/lib.rs
@@ -116,6 +116,8 @@ use std::{
 use version::Version;
 
 mod builder;
+#[cfg(feature = "metadata-hash")]
+mod metadata_hash;
 mod prerequisites;
 mod version;
 mod wasm_project;
@@ -238,7 +240,7 @@ fn get_rustup_command(target: RuntimeTarget) -> Option<CargoCommand> {
 }
 
 /// Wraps a specific command which represents a cargo invocation.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct CargoCommand {
 	program: String,
 	args: Vec<String>,
@@ -350,6 +352,7 @@ impl CargoCommand {
 }
 
 /// Wraps a [`CargoCommand`] and the version of `rustc` the cargo command uses.
+#[derive(Clone)]
 struct CargoCommandVersioned {
 	command: CargoCommand,
 	version: String,
diff --git a/substrate/utils/wasm-builder/src/metadata_hash.rs b/substrate/utils/wasm-builder/src/metadata_hash.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1003f2d18eafdab2c619f260c10ba5e30e0d589b
--- /dev/null
+++ b/substrate/utils/wasm-builder/src/metadata_hash.rs
@@ -0,0 +1,132 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::builder::MetadataExtraInfo;
+use codec::{Decode, Encode};
+use frame_metadata::{RuntimeMetadata, RuntimeMetadataPrefixed};
+use merkleized_metadata::{generate_metadata_digest, ExtraInfo};
+use sc_executor::WasmExecutor;
+use sp_core::traits::{CallContext, CodeExecutor, RuntimeCode, WrappedRuntimeCode};
+use std::path::Path;
+
+/// The host functions that we provide when calling into the wasm file.
+///
+/// Any other host function will return an error.
+type HostFunctions = (
+	// The allocator functions.
+	sp_io::allocator::HostFunctions,
+	// Logging is good to have for debugging issues.
+	sp_io::logging::HostFunctions,
+	// Give access to the "state", actually the state will be empty, but some chains put constants
+	// into the state and this would panic at metadata generation. Thus, we give them an empty
+	// state to not panic.
+	sp_io::storage::HostFunctions,
+	// The hashing functions.
+	sp_io::hashing::HostFunctions,
+);
+
+/// Generate the metadata hash.
+///
+/// The metadata hash is generated as specced in
+/// [RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html).
+///
+/// Returns the metadata hash.
+pub fn generate_metadata_hash(wasm: &Path, extra_info: MetadataExtraInfo) -> [u8; 32] {
+	sp_tracing::try_init_simple();
+
+	let wasm = std::fs::read(wasm).expect("Wasm file was just created and should be readable.");
+
+	let executor = WasmExecutor::<HostFunctions>::builder()
+		.with_allow_missing_host_functions(true)
+		.build();
+
+	let runtime_code = RuntimeCode {
+		code_fetcher: &WrappedRuntimeCode(wasm.into()),
+		heap_pages: None,
+		// The hash is only used for caching and thus, not that important for our use case here.
+		hash: vec![1, 2, 3],
+	};
+
+	let metadata = executor
+		.call(
+			&mut sp_io::TestExternalities::default().ext(),
+			&runtime_code,
+			"Metadata_metadata_at_version",
+			&15u32.encode(),
+			CallContext::Offchain,
+		)
+		.0
+		.expect("`Metadata::metadata_at_version` should exist.");
+
+	let metadata = Option::<Vec<u8>>::decode(&mut &metadata[..])
+		.ok()
+		.flatten()
+		.expect("Metadata V15 support is required.");
+
+	let metadata = RuntimeMetadataPrefixed::decode(&mut &metadata[..])
+		.expect("Invalid encoded metadata?")
+		.1;
+
+	let runtime_version = executor
+		.call(
+			&mut sp_io::TestExternalities::default().ext(),
+			&runtime_code,
+			"Core_version",
+			&[],
+			CallContext::Offchain,
+		)
+		.0
+		.expect("`Core_version` should exist.");
+	let runtime_version = sp_version::RuntimeVersion::decode(&mut &runtime_version[..])
+		.expect("Invalid `RuntimeVersion` encoding");
+
+	let base58_prefix = extract_ss58_prefix(&metadata);
+
+	let extra_info = ExtraInfo {
+		spec_version: runtime_version.spec_version,
+		spec_name: runtime_version.spec_name.into(),
+		base58_prefix,
+		decimals: extra_info.decimals,
+		token_symbol: extra_info.token_symbol,
+	};
+
+	generate_metadata_digest(&metadata, extra_info)
+		.expect("Failed to generate the metadata digest")
+		.hash()
+}
+
+/// Extract the `SS58` from the constants in the given `metadata`.
+fn extract_ss58_prefix(metadata: &RuntimeMetadata) -> u16 {
+	let RuntimeMetadata::V15(ref metadata) = metadata else {
+		panic!("Metadata version 15 required")
+	};
+
+	let system = metadata
+		.pallets
+		.iter()
+		.find(|p| p.name == "System")
+		.expect("Each FRAME runtime has the `System` pallet; qed");
+
+	system
+		.constants
+		.iter()
+		.find_map(|c| {
+			(c.name == "SS58Prefix")
+				.then(|| u16::decode(&mut &c.value[..]).expect("SS58 is an `u16`; qed"))
+		})
+		.expect("`SS58PREFIX` exists in the `System` constants; qed")
+}
diff --git a/substrate/utils/wasm-builder/src/wasm_project.rs b/substrate/utils/wasm-builder/src/wasm_project.rs
index b58e6bfa36b478b91995789a148b042d167d9f3f..ff6c8e38a332121d6e4c7fcdfa6fe4128867ac5a 100644
--- a/substrate/utils/wasm-builder/src/wasm_project.rs
+++ b/substrate/utils/wasm-builder/src/wasm_project.rs
@@ -15,6 +15,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#[cfg(feature = "metadata-hash")]
+use crate::builder::MetadataExtraInfo;
 use crate::{write_file_if_changed, CargoCommandVersioned, RuntimeTarget, OFFLINE};
 
 use build_helper::rerun_if_changed;
@@ -113,57 +115,103 @@ fn crate_metadata(cargo_manifest: &Path) -> Metadata {
 /// The path to the compact runtime binary and the bloaty runtime binary.
 pub(crate) fn create_and_compile(
 	target: RuntimeTarget,
-	project_cargo_toml: &Path,
+	orig_project_cargo_toml: &Path,
 	default_rustflags: &str,
 	cargo_cmd: CargoCommandVersioned,
 	features_to_enable: Vec<String>,
-	bloaty_blob_out_name_override: Option<String>,
+	blob_out_name_override: Option<String>,
 	check_for_runtime_version_section: bool,
+	#[cfg(feature = "metadata-hash")] enable_metadata_hash: Option<MetadataExtraInfo>,
 ) -> (Option<WasmBinary>, WasmBinaryBloaty) {
 	let runtime_workspace_root = get_wasm_workspace_root();
 	let runtime_workspace = runtime_workspace_root.join(target.build_subdirectory());
 
-	let crate_metadata = crate_metadata(project_cargo_toml);
+	let crate_metadata = crate_metadata(orig_project_cargo_toml);
 
 	let project = create_project(
 		target,
-		project_cargo_toml,
+		orig_project_cargo_toml,
 		&runtime_workspace,
 		&crate_metadata,
 		crate_metadata.workspace_root.as_ref(),
 		features_to_enable,
 	);
+	let wasm_project_cargo_toml = project.join("Cargo.toml");
 
 	let build_config = BuildConfiguration::detect(target, &project);
 
-	// Build the bloaty runtime blob
-	let raw_blob_path = build_bloaty_blob(
-		target,
-		&build_config.blob_build_profile,
-		&project,
-		default_rustflags,
-		cargo_cmd,
-	);
+	#[cfg(feature = "metadata-hash")]
+	let raw_blob_path = match enable_metadata_hash {
+		Some(extra_info) => {
+			// When the metadata hash is enabled we need to build the runtime twice.
+			let raw_blob_path = build_bloaty_blob(
+				target,
+				&build_config.blob_build_profile,
+				&project,
+				default_rustflags,
+				cargo_cmd.clone(),
+				None,
+			);
 
-	let (final_blob_binary, bloaty_blob_binary) = match target {
-		RuntimeTarget::Wasm => compile_wasm(
-			project_cargo_toml,
+			let hash = crate::metadata_hash::generate_metadata_hash(&raw_blob_path, extra_info);
+
+			build_bloaty_blob(
+				target,
+				&build_config.blob_build_profile,
+				&project,
+				default_rustflags,
+				cargo_cmd,
+				Some(hash),
+			)
+		},
+		None => build_bloaty_blob(
+			target,
+			&build_config.blob_build_profile,
 			&project,
-			bloaty_blob_out_name_override,
-			check_for_runtime_version_section,
-			&build_config,
+			default_rustflags,
+			cargo_cmd,
+			None,
 		),
+	};
+
+	// If the feature is not enabled, we only need to do it once.
+	#[cfg(not(feature = "metadata-hash"))]
+	let raw_blob_path = {
+		build_bloaty_blob(
+			target,
+			&build_config.blob_build_profile,
+			&project,
+			default_rustflags,
+			cargo_cmd,
+		)
+	};
+
+	let blob_name =
+		blob_out_name_override.unwrap_or_else(|| get_blob_name(target, &wasm_project_cargo_toml));
+
+	let (final_blob_binary, bloaty_blob_binary) = match target {
+		RuntimeTarget::Wasm => {
+			let out_path = project.join(format!("{blob_name}.wasm"));
+			fs::copy(raw_blob_path, &out_path).expect("copying the runtime blob should never fail");
+
+			maybe_compact_and_compress_wasm(
+				&wasm_project_cargo_toml,
+				&project,
+				WasmBinaryBloaty(out_path),
+				&blob_name,
+				check_for_runtime_version_section,
+				&build_config,
+			)
+		},
 		RuntimeTarget::Riscv => {
-			let out_name = bloaty_blob_out_name_override
-				.unwrap_or_else(|| get_blob_name(target, project_cargo_toml));
-			let out_path = project.join(format!("{out_name}.polkavm"));
+			let out_path = project.join(format!("{blob_name}.polkavm"));
 			fs::copy(raw_blob_path, &out_path).expect("copying the runtime blob should never fail");
 			(None, WasmBinaryBloaty(out_path))
 		},
 	};
 
 	generate_rerun_if_changed_instructions(
-		project_cargo_toml,
+		orig_project_cargo_toml,
 		&project,
 		&runtime_workspace,
 		final_blob_binary.as_ref(),
@@ -177,25 +225,14 @@ pub(crate) fn create_and_compile(
 	(final_blob_binary, bloaty_blob_binary)
 }
 
-fn compile_wasm(
-	project_cargo_toml: &Path,
+fn maybe_compact_and_compress_wasm(
+	wasm_project_cargo_toml: &Path,
 	project: &Path,
-	bloaty_blob_out_name_override: Option<String>,
+	bloaty_blob_binary: WasmBinaryBloaty,
+	blob_name: &str,
 	check_for_runtime_version_section: bool,
 	build_config: &BuildConfiguration,
 ) -> (Option<WasmBinary>, WasmBinaryBloaty) {
-	// Get the name of the bloaty runtime blob.
-	let bloaty_blob_default_name = get_blob_name(RuntimeTarget::Wasm, project_cargo_toml);
-	let bloaty_blob_out_name =
-		bloaty_blob_out_name_override.unwrap_or_else(|| bloaty_blob_default_name.clone());
-
-	let bloaty_blob_binary = copy_bloaty_blob(
-		&project,
-		&build_config.blob_build_profile,
-		&bloaty_blob_default_name,
-		&bloaty_blob_out_name,
-	);
-
 	// Try to compact and compress the bloaty blob, if the *outer* profile wants it.
 	//
 	// This is because, by default the inner profile will be set to `Release` even when the outer
@@ -203,15 +240,9 @@ fn compile_wasm(
 	// development activities.
 	let (compact_blob_path, compact_compressed_blob_path) =
 		if build_config.outer_build_profile.wants_compact() {
-			let compact_blob_path = compact_wasm(
-				&project,
-				&build_config.blob_build_profile,
-				project_cargo_toml,
-				&bloaty_blob_out_name,
-			);
-			let compact_compressed_blob_path = compact_blob_path
-				.as_ref()
-				.and_then(|p| try_compress_blob(&p.0, &bloaty_blob_out_name));
+			let compact_blob_path = compact_wasm(&project, blob_name, &bloaty_blob_binary);
+			let compact_compressed_blob_path =
+				compact_blob_path.as_ref().and_then(|p| try_compress_blob(&p.0, blob_name));
 			(compact_blob_path, compact_compressed_blob_path)
 		} else {
 			(None, None)
@@ -221,15 +252,12 @@ fn compile_wasm(
 		ensure_runtime_version_wasm_section_exists(bloaty_blob_binary.bloaty_path());
 	}
 
-	compact_blob_path
-		.as_ref()
-		.map(|wasm_binary| copy_blob_to_target_directory(project_cargo_toml, wasm_binary));
+	let final_blob_binary = compact_compressed_blob_path.or(compact_blob_path);
 
-	compact_compressed_blob_path.as_ref().map(|wasm_binary_compressed| {
-		copy_blob_to_target_directory(project_cargo_toml, wasm_binary_compressed)
-	});
+	final_blob_binary
+		.as_ref()
+		.map(|binary| copy_blob_to_target_directory(wasm_project_cargo_toml, binary));
 
-	let final_blob_binary = compact_compressed_blob_path.or(compact_blob_path);
 	(final_blob_binary, bloaty_blob_binary)
 }
 
@@ -347,12 +375,25 @@ fn get_crate_name(cargo_manifest: &Path) -> String {
 		.expect("Package name exists; qed")
 }
 
+/// Extract the `lib.name` from the given `Cargo.toml`.
+fn get_lib_name(cargo_manifest: &Path) -> Option<String> {
+	let cargo_toml: Table = toml::from_str(
+		&fs::read_to_string(cargo_manifest).expect("File exists as checked before; qed"),
+	)
+	.expect("Cargo manifest is a valid toml file; qed");
+
+	let lib = cargo_toml.get("lib").and_then(|t| t.as_table())?;
+
+	lib.get("name").and_then(|p| p.as_str()).map(ToOwned::to_owned)
+}
+
 /// Returns the name for the blob binary.
 fn get_blob_name(target: RuntimeTarget, cargo_manifest: &Path) -> String {
-	let crate_name = get_crate_name(cargo_manifest);
 	match target {
-		RuntimeTarget::Wasm => crate_name.replace('-', "_"),
-		RuntimeTarget::Riscv => crate_name,
+		RuntimeTarget::Wasm => get_lib_name(cargo_manifest)
+			.expect("The wasm project should have a `lib.name`; qed")
+			.replace('-', "_"),
+		RuntimeTarget::Riscv => get_crate_name(cargo_manifest),
 	}
 }
 
@@ -379,7 +420,6 @@ fn create_project_cargo_toml(
 	workspace_root_path: &Path,
 	crate_name: &str,
 	crate_path: &Path,
-	wasm_binary: &str,
 	enabled_features: impl Iterator<Item = String>,
 ) {
 	let mut workspace_toml: Table = toml::from_str(
@@ -443,7 +483,7 @@ fn create_project_cargo_toml(
 
 	if target == RuntimeTarget::Wasm {
 		let mut lib = Table::new();
-		lib.insert("name".into(), wasm_binary.into());
+		lib.insert("name".into(), crate_name.replace("-", "_").into());
 		lib.insert("crate-type".into(), vec!["cdylib".to_string()].into());
 		wasm_workspace_toml.insert("lib".into(), lib.into());
 	}
@@ -588,7 +628,6 @@ fn create_project(
 ) -> PathBuf {
 	let crate_name = get_crate_name(project_cargo_toml);
 	let crate_path = project_cargo_toml.parent().expect("Parent path exists; qed");
-	let wasm_binary = get_blob_name(target, project_cargo_toml);
 	let wasm_project_folder = wasm_workspace.join(&crate_name);
 
 	fs::create_dir_all(wasm_project_folder.join("src"))
@@ -610,7 +649,6 @@ fn create_project(
 		workspace_root_path,
 		&crate_name,
 		crate_path,
-		&wasm_binary,
 		enabled_features.into_iter(),
 	);
 
@@ -775,12 +813,15 @@ fn offline_build() -> bool {
 }
 
 /// Build the project and create the bloaty runtime blob.
+///
+/// Returns the path to the generated bloaty runtime blob.
 fn build_bloaty_blob(
 	target: RuntimeTarget,
 	blob_build_profile: &Profile,
 	project: &Path,
 	default_rustflags: &str,
 	cargo_cmd: CargoCommandVersioned,
+	#[cfg(feature = "metadata-hash")] metadata_hash: Option<[u8; 32]>,
 ) -> PathBuf {
 	let manifest_path = project.join("Cargo.toml");
 	let mut build_cmd = cargo_cmd.command();
@@ -820,6 +861,11 @@ fn build_bloaty_blob(
 		// We don't want to call ourselves recursively
 		.env(crate::SKIP_BUILD_ENV, "");
 
+	#[cfg(feature = "metadata-hash")]
+	if let Some(hash) = metadata_hash {
+		build_cmd.env("RUNTIME_METADATA_HASH", array_bytes::bytes2hex("0x", &hash));
+	}
+
 	if super::color_output_enabled() {
 		build_cmd.arg("--color=always");
 	}
@@ -908,23 +954,16 @@ fn build_bloaty_blob(
 
 fn compact_wasm(
 	project: &Path,
-	inner_profile: &Profile,
-	cargo_manifest: &Path,
-	out_name: &str,
+	blob_name: &str,
+	bloaty_binary: &WasmBinaryBloaty,
 ) -> Option<WasmBinary> {
-	let default_out_name = get_blob_name(RuntimeTarget::Wasm, cargo_manifest);
-	let in_path = project
-		.join("target/wasm32-unknown-unknown")
-		.join(inner_profile.directory())
-		.join(format!("{}.wasm", default_out_name));
-
-	let wasm_compact_path = project.join(format!("{}.compact.wasm", out_name));
+	let wasm_compact_path = project.join(format!("{blob_name}.compact.wasm"));
 	let start = std::time::Instant::now();
 	wasm_opt::OptimizationOptions::new_opt_level_0()
 		.mvp_features_only()
 		.debug_info(true)
 		.add_pass(wasm_opt::Pass::StripDwarf)
-		.run(&in_path, &wasm_compact_path)
+		.run(bloaty_binary.bloaty_path(), &wasm_compact_path)
 		.expect("Failed to compact generated WASM binary.");
 	println!(
 		"{} {}",
@@ -934,22 +973,6 @@ fn compact_wasm(
 	Some(WasmBinary(wasm_compact_path))
 }
 
-fn copy_bloaty_blob(
-	project: &Path,
-	inner_profile: &Profile,
-	in_name: &str,
-	out_name: &str,
-) -> WasmBinaryBloaty {
-	let in_path = project
-		.join("target/wasm32-unknown-unknown")
-		.join(inner_profile.directory())
-		.join(format!("{}.wasm", in_name));
-
-	let bloaty_path = project.join(format!("{}.wasm", out_name));
-	fs::copy(in_path, &bloaty_path).expect("Copying the bloaty file to the project dir.");
-	WasmBinaryBloaty(bloaty_path)
-}
-
 fn try_compress_blob(compact_blob_path: &Path, out_name: &str) -> Option<WasmBinary> {
 	use sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT;
 
diff --git a/templates/minimal/.dockerignore b/templates/minimal/.dockerignore
new file mode 100644
index 0000000000000000000000000000000000000000..da6a8f2620d64f3761669047dfbda397b685493c
--- /dev/null
+++ b/templates/minimal/.dockerignore
@@ -0,0 +1,3 @@
+target/
+Dockerfile
+.dockerignore
diff --git a/templates/minimal/Cargo.toml b/templates/minimal/Cargo.toml
index 6cd28c5a49364a911c9b93fa1269456cf07527d5..ca00cb84284524fc7d43d3b95f9cf4bb795ec506 100644
--- a/templates/minimal/Cargo.toml
+++ b/templates/minimal/Cargo.toml
@@ -2,16 +2,13 @@
 name = "minimal-template"
 description = "A minimal template built with Substrate, part of Polkadot Sdk."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 publish = false
 
-[lints]
-workspace = true
-
 [dependencies]
 minimal-template-node = { path = "./node" }
 minimal-template-runtime = { path = "./runtime" }
diff --git a/templates/minimal/Dockerfile b/templates/minimal/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..0c59192208fe66961613f7adaec16284078b9d9f
--- /dev/null
+++ b/templates/minimal/Dockerfile
@@ -0,0 +1,28 @@
+FROM docker.io/paritytech/ci-unified:latest as builder
+
+WORKDIR /polkadot
+COPY . /polkadot
+
+RUN cargo fetch
+RUN cargo build --locked --release
+
+FROM docker.io/parity/base-bin:latest
+
+COPY --from=builder /polkadot/target/release/minimal-template-node /usr/local/bin
+
+USER root
+RUN useradd -m -u 1001 -U -s /bin/sh -d /polkadot polkadot && \
+	mkdir -p /data /polkadot/.local/share && \
+	chown -R polkadot:polkadot /data && \
+	ln -s /data /polkadot/.local/share/polkadot && \
+# unclutter and minimize the attack surface
+	rm -rf /usr/bin /usr/sbin && \
+# check if executable works in this container
+	/usr/local/bin/minimal-template-node --version
+
+USER polkadot
+
+EXPOSE 30333 9933 9944 9615
+VOLUME ["/data"]
+
+ENTRYPOINT ["/usr/local/bin/minimal-template-node"]
diff --git a/templates/minimal/LICENSE b/templates/minimal/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..cf1ab25da0349f84a3fdd40032f0ce99db813b8b
--- /dev/null
+++ b/templates/minimal/LICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>
diff --git a/templates/minimal/README.md b/templates/minimal/README.md
index 0541e393db93bd9a67ddfaefe208c7ef22627f44..f00bfd4d48772ba7df8a035df757eb59d23626ca 100644
--- a/templates/minimal/README.md
+++ b/templates/minimal/README.md
@@ -1,13 +1,101 @@
-# Minimal Template
+<div align="center">
 
-This is a minimal template for creating a blockchain using the Polkadot SDK.
+# Polkadot SDK's Minimal Template
 
-# Docs
+<img height="70px" alt="Polkadot SDK Logo" src="https://github.com/paritytech/polkadot-sdk/raw/master/docs/images/Polkadot_Logo_Horizontal_Pink_White.png#gh-dark-mode-only"/>
+<img height="70px" alt="Polkadot SDK Logo" src="https://github.com/paritytech/polkadot-sdk/raw/master/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png#gh-light-mode-only"/>
 
-You can generate and view the [Rust
-Docs](https://doc.rust-lang.org/cargo/commands/cargo-doc.html) for this template
-with this command:
+> This is a minimal template for creating a blockchain based on Polkadot SDK.
+>
+> This template is automatically updated after releases in the main [Polkadot SDK monorepo](https://github.com/paritytech/polkadot-sdk).
+
+</div>
+
+* 🤏 This template is a minimal (in terms of complexity and the number of components)
+template for building a blockchain node.
+
+* 🔧 Its runtime is configured of a single custom pallet as a starting point, and a handful of ready-made pallets
+such as a [Balances pallet](https://paritytech.github.io/polkadot-sdk/master/pallet_balances/index.html).
+
+* 👤 The template has no consensus configured - it is best for experimenting with a single node network.
+
+## Template Structure
+
+A Polkadot SDK based project such as this one consists of:
+
+* 💿 a [Node](./node/README.md) - the binary application.
+* 🧮 the [Runtime](./runtime/README.md) - the core logic of the blockchain.
+* 🎨 the [Pallets](./pallets/README.md) - from which the runtime is constructed.
+
+## Getting Started
+
+* 🦀 The template is using the Rust language.
+
+* 👉 Check the
+[Rust installation instructions](https://www.rust-lang.org/tools/install) for your system.
+
+* 🛠️ Depending on your operating system and Rust version, there might be additional
+packages required to compile this template - please take note of the Rust compiler output.
+
+### Build
+
+🔨 Use the following command to build the node without launching it:
 
 ```sh
-cargo doc -p minimal-template --open
+cargo build --release
 ```
+
+🐳 Alternatively, build the docker image:
+
+```sh
+docker build . -t polkadot-sdk-minimal-template
+```
+
+### Single-Node Development Chain
+
+👤 The following command starts a single-node development chain:
+
+```sh
+./target/release/minimal-template-node --dev
+
+# docker version:
+docker run --rm polkadot-sdk-minimal-template --dev
+```
+
+Development chains:
+
+* 🧹 Do not persist the state.
+* 💰 Are preconfigured with a genesis state that includes several prefunded development accounts.
+* 🧑‍⚖️ Development accounts are used as `sudo` accounts.
+
+### Connect with the Polkadot-JS Apps Front-End
+
+* 🌐 You can interact with your local node using the
+hosted version of the [Polkadot/Substrate
+Portal](https://polkadot.js.org/apps/#/explorer?rpc=ws://localhost:9944).
+
+* 🪐 A hosted version is also
+available on [IPFS](https://dotapps.io/).
+
+* 🧑‍🔧 You can also find the source code and instructions for hosting your own instance in the
+[`polkadot-js/apps`](https://github.com/polkadot-js/apps) repository.
+
+## Contributing
+
+* 🔄 This template is automatically updated after releases in the main [Polkadot SDK monorepo](https://github.com/paritytech/polkadot-sdk).
+
+* ➡️ Any pull requests should be directed to this [source](https://github.com/paritytech/polkadot-sdk/tree/master/templates/minimal).
+
+* 😇 Please refer to the monorepo's
+[contribution guidelines](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CONTRIBUTING.md) and
+[Code of Conduct](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CODE_OF_CONDUCT.md).
+
+## Getting Help
+
+* 🧑‍🏫 To learn about Polkadot in general, [Polkadot.network](https://polkadot.network/) website is a good starting point.
+
+* 🧑‍🔧 For technical introduction, [here](https://github.com/paritytech/polkadot-sdk#-documentation) are
+the Polkadot SDK documentation resources.
+
+* 👥 Additionally, there are [GitHub issues](https://github.com/paritytech/polkadot-sdk/issues) and
+[Substrate StackExchange](https://substrate.stackexchange.com/).
diff --git a/templates/minimal/node/Cargo.toml b/templates/minimal/node/Cargo.toml
index 606fd05803562abe7dc85b35c6a4c0b7c15a320c..a10364a2854a9acfa9f7bf69ee885bc155facb79 100644
--- a/templates/minimal/node/Cargo.toml
+++ b/templates/minimal/node/Cargo.toml
@@ -2,7 +2,7 @@
 name = "minimal-template-node"
 description = "A minimal Substrate-based Substrate node, ready for hacking."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
@@ -10,13 +10,11 @@ edition.workspace = true
 publish = false
 build = "build.rs"
 
-[lints]
-workspace = true
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
+docify = "0.2.0"
 clap = { version = "4.5.3", features = ["derive"] }
 futures = { version = "0.3.30", features = ["thread-pool"] }
 futures-timer = "3.0.1"
diff --git a/templates/minimal/node/README.md b/templates/minimal/node/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fd22f081a89ea4c3fd9b02517bd32e8d5bb18eb
--- /dev/null
+++ b/templates/minimal/node/README.md
@@ -0,0 +1,18 @@
+# Node
+
+ℹ️ A node -  in Polkadot - is a binary executable, whose primary purpose is to execute the [runtime](../runtime/README.md).
+
+🔗 It communicates with other nodes in the network, and aims for
+[consensus](https://wiki.polkadot.network/docs/learn-consensus) among them.
+
+⚙️ It acts as a remote procedure call (RPC) server, allowing interaction with the blockchain.
+
+👉 Learn more about the architecture, and a difference between a node and a runtime
+[here](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/reference_docs/wasm_meta_protocol/index.html).
+
+👇 Here are the most important files in this node template:
+
+- [`chain_spec.rs`](./src/chain_spec.rs): A chain specification is a source code file that defines the chain's
+initial (genesis) state.
+- [`service.rs`](./src/service.rs): This file defines the node implementation.
+It's a place to configure consensus-related topics. In favor of minimalism, this template has no consensus configured.
diff --git a/templates/minimal/node/src/chain_spec.rs b/templates/minimal/node/src/chain_spec.rs
index 6b721deb6d1df402d811ba40cd6c848c01a83754..7a3475bb167334e05f570ad4b46e8d471ec5a9a8 100644
--- a/templates/minimal/node/src/chain_spec.rs
+++ b/templates/minimal/node/src/chain_spec.rs
@@ -21,7 +21,7 @@ use serde_json::{json, Value};
 use sp_keyring::AccountKeyring;
 
 /// This is a specialization of the general Substrate ChainSpec type.
-pub type ChainSpec = sc_service::GenericChainSpec<()>;
+pub type ChainSpec = sc_service::GenericChainSpec;
 
 fn props() -> Properties {
 	let mut properties = Properties::new();
diff --git a/templates/minimal/node/src/cli.rs b/templates/minimal/node/src/cli.rs
index e464fa7d6caa36ce41b45ae79a3883713ef50aca..22726b7eb9a36c0254c2f8423086e5206b730570 100644
--- a/templates/minimal/node/src/cli.rs
+++ b/templates/minimal/node/src/cli.rs
@@ -32,7 +32,7 @@ impl std::str::FromStr for Consensus {
 		} else if let Some(block_time) = s.strip_prefix("manual-seal-") {
 			Consensus::ManualSeal(block_time.parse().map_err(|_| "invalid block time")?)
 		} else {
-			return Err("incorrect consensus identifier".into())
+			return Err("incorrect consensus identifier".into());
 		})
 	}
 }
diff --git a/templates/minimal/node/src/rpc.rs b/templates/minimal/node/src/rpc.rs
index d0c417a93d7aa6c8c8a6c6163628aac9845c6eb3..4b283bb2a66f4e18a6dffdbd2d387be93f8ff6a7 100644
--- a/templates/minimal/node/src/rpc.rs
+++ b/templates/minimal/node/src/rpc.rs
@@ -27,7 +27,6 @@ use runtime::interface::{AccountId, Nonce, OpaqueBlock};
 use sc_transaction_pool_api::TransactionPool;
 use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 use std::sync::Arc;
-use substrate_frame_rpc_system::{System, SystemApiServer};
 
 pub use sc_rpc_api::DenyUnsafe;
 
@@ -41,6 +40,7 @@ pub struct FullDeps<C, P> {
 	pub deny_unsafe: DenyUnsafe,
 }
 
+#[docify::export]
 /// Instantiate all full RPC extensions.
 pub fn create_full<C, P>(
 	deps: FullDeps<C, P>,
@@ -57,6 +57,7 @@ where
 	C::Api: substrate_frame_rpc_system::AccountNonceApi<OpaqueBlock, AccountId, Nonce>,
 	P: TransactionPool + 'static,
 {
+	use substrate_frame_rpc_system::{System, SystemApiServer};
 	let mut module = RpcModule::new(());
 	let FullDeps { client, pool, deny_unsafe } = deps;
 
diff --git a/templates/minimal/node/src/service.rs b/templates/minimal/node/src/service.rs
index d84df95dc1924edf8077783aed4f2ce80a803f14..8217a4f5b3de361972c2ffba3ab8dfed5de74f6e 100644
--- a/templates/minimal/node/src/service.rs
+++ b/templates/minimal/node/src/service.rs
@@ -34,8 +34,10 @@ type HostFunctions =
 #[cfg(not(feature = "runtime-benchmarks"))]
 type HostFunctions = sp_io::SubstrateHostFunctions;
 
+#[docify::export]
 pub(crate) type FullClient =
 	sc_service::TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>;
+
 type FullBackend = sc_service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
 
@@ -61,7 +63,7 @@ pub fn new_partial(config: &Configuration) -> Result<Service, ServiceError> {
 		})
 		.transpose()?;
 
-	let executor = sc_service::new_wasm_executor(&config);
+	let executor = sc_service::new_wasm_executor(config);
 
 	let (client, backend, keystore_container, task_manager) =
 		sc_service::new_full_parts::<Block, RuntimeApi, _>(
diff --git a/templates/minimal/pallets/README.md b/templates/minimal/pallets/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fabe64a3e79a495a455b0f87b0957d364df5f30
--- /dev/null
+++ b/templates/minimal/pallets/README.md
@@ -0,0 +1,13 @@
+# Pallets
+
+ℹ️ A pallet is a unit of encapsulated logic, with a clearly defined responsibility. A pallet is analogous to a
+module in the runtime.
+
+💁 In this template, there is a simple custom pallet based on the FRAME framework.
+
+👉 Learn more about FRAME
+[here](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/frame_runtime/index.html).
+
+🧑‍🏫 Please refer to
+[this guide](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html)
+to learn how to write a basic pallet.
diff --git a/templates/minimal/pallets/template/Cargo.toml b/templates/minimal/pallets/template/Cargo.toml
index e6fe43abc0909a257648051f67f6ab489fe047c4..f0abe3c6942de634e603f939aaa5ad8c19bcd20d 100644
--- a/templates/minimal/pallets/template/Cargo.toml
+++ b/templates/minimal/pallets/template/Cargo.toml
@@ -2,16 +2,13 @@
 name = "pallet-minimal-template"
 description = "A minimal pallet built with FRAME, part of Polkadot Sdk."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 publish = false
 
-[lints]
-workspace = true
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
diff --git a/templates/minimal/runtime/Cargo.toml b/templates/minimal/runtime/Cargo.toml
index 99559308e5b8f8f553a8a64ca4afabdcec6f39f9..42ea49ff404628ba1d2768302dc252c652a0ddaa 100644
--- a/templates/minimal/runtime/Cargo.toml
+++ b/templates/minimal/runtime/Cargo.toml
@@ -2,18 +2,15 @@
 name = "minimal-template-runtime"
 description = "A solochain runtime template built with Substrate, part of Polkadot Sdk."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 publish = false
 
-[lints]
-workspace = true
-
 [dependencies]
-parity-scale-codec = { version = "3.6.12", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
 scale-info = { version = "2.6.0", default-features = false }
 
 # this is a frame-based runtime, thus importing `frame` with runtime feature enabled.
@@ -42,7 +39,7 @@ substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder", optio
 [features]
 default = ["std"]
 std = [
-	"parity-scale-codec/std",
+	"codec/std",
 	"scale-info/std",
 
 	"frame/std",
diff --git a/templates/minimal/runtime/README.md b/templates/minimal/runtime/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9aded8740cb0fcea1cbb4e43ed2164a350bc6492
--- /dev/null
+++ b/templates/minimal/runtime/README.md
@@ -0,0 +1,10 @@
+# Runtime
+
+ℹ️ The runtime (in other words, a state transition function), refers to the core logic of the blockchain that is
+responsible for validating blocks and executing the state changes they define.
+
+💁 The runtime in this template is constructed using ready-made FRAME pallets that ship with
+[Polkadot SDK](https://github.com/paritytech/polkadot-sdk), and a [template for a custom pallet](../pallets/README.md).
+
+👉 Learn more about FRAME
+[here](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/frame_runtime/index.html).
diff --git a/templates/parachain/.dockerignore b/templates/parachain/.dockerignore
new file mode 100644
index 0000000000000000000000000000000000000000..da6a8f2620d64f3761669047dfbda397b685493c
--- /dev/null
+++ b/templates/parachain/.dockerignore
@@ -0,0 +1,3 @@
+target/
+Dockerfile
+.dockerignore
diff --git a/templates/parachain/Dockerfile b/templates/parachain/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..72a8f19fe79ae0ff870f19e90206c9aa7a4309fb
--- /dev/null
+++ b/templates/parachain/Dockerfile
@@ -0,0 +1,28 @@
+FROM docker.io/paritytech/ci-unified:latest as builder
+
+WORKDIR /polkadot
+COPY . /polkadot
+
+RUN cargo fetch
+RUN cargo build --locked --release
+
+FROM docker.io/parity/base-bin:latest
+
+COPY --from=builder /polkadot/target/release/parachain-template-node /usr/local/bin
+
+USER root
+RUN useradd -m -u 1001 -U -s /bin/sh -d /polkadot polkadot && \
+	mkdir -p /data /polkadot/.local/share && \
+	chown -R polkadot:polkadot /data && \
+	ln -s /data /polkadot/.local/share/polkadot && \
+# unclutter and minimize the attack surface
+	rm -rf /usr/bin /usr/sbin && \
+# check if executable works in this container
+	/usr/local/bin/parachain-template-node --version
+
+USER polkadot
+
+EXPOSE 30333 9933 9944 9615
+VOLUME ["/data"]
+
+ENTRYPOINT ["/usr/local/bin/parachain-template-node"]
diff --git a/templates/parachain/README.md b/templates/parachain/README.md
index 01e9cc26d9af3e8c437486b6785d6f5eb8d6047c..a6ac91799b77728c4116c3e98554d5dca66e9929 100644
--- a/templates/parachain/README.md
+++ b/templates/parachain/README.md
@@ -1,22 +1,121 @@
-# Substrate Cumulus Parachain Template
+<div align="center">
 
-A new [Cumulus](https://github.com/paritytech/polkadot-sdk/tree/master/cumulus)-based Substrate node, ready for hacking ☁️..
+# Polkadot SDK's Parachain Template
 
-This project is originally a fork of the
-[Substrate Node Template](https://github.com/substrate-developer-hub/substrate-node-template)
-modified to include dependencies required for registering this node as a **parathread** or
-**parachain** to a **relay chain**.
+<img height="70px" alt="Polkadot SDK Logo" src="https://github.com/paritytech/polkadot-sdk/raw/master/docs/images/Polkadot_Logo_Horizontal_Pink_White.png#gh-dark-mode-only"/>
+<img height="70px" alt="Polkadot SDK Logo" src="https://github.com/paritytech/polkadot-sdk/raw/master/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png#gh-light-mode-only"/>
 
-The stand-alone version of this template is hosted on the
-[Substrate Devhub Parachain Template](https://github.com/substrate-developer-hub/substrate-parachain-template/)
-for each release of Polkadot. It is generated directly to the upstream
-[Parachain Template in Cumulus](https://github.com/paritytech/polkadot-sdk/tree/master/cumulus/parachain-template)
-at each release branch using the
-[Substrate Template Generator](https://github.com/paritytech/substrate-template-generator/).
+> This is a template for creating a [parachain](https://wiki.polkadot.network/docs/learn-parachains) based on Polkadot SDK.
+>
+> This template is automatically updated after releases in the main [Polkadot SDK monorepo](https://github.com/paritytech/polkadot-sdk).
 
-👉 Learn more about parachains [here](https://wiki.polkadot.network/docs/learn-parachains), and
-parathreads [here](https://wiki.polkadot.network/docs/learn-parathreads).
+</div>
 
+* ⏫ This template provides a starting point to build a [parachain](https://wiki.polkadot.network/docs/learn-parachains).
 
-🧙 Learn about how to use this template and run your own parachain testnet for it in the
-[Devhub Cumulus Tutorial](https://docs.substrate.io/tutorials/v3/cumulus/start-relay/).
+* ☁️ It is based on the
+[Cumulus](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/cumulus/index.html) framework.
+
+* 🔧 Its runtime is configured of a single custom pallet as a starting point, and a handful of ready-made pallets
+such as a [Balances pallet](https://paritytech.github.io/polkadot-sdk/master/pallet_balances/index.html).
+
+* 👉 Learn more about parachains [here](https://wiki.polkadot.network/docs/learn-parachains)
+
+## Template Structure
+
+A Polkadot SDK based project such as this one consists of:
+
+* 💿 a [Node](./node/README.md) - the binary application.
+* 🧮 the [Runtime](./runtime/README.md) - the core logic of the parachain.
+* 🎨 the [Pallets](./pallets/README.md) - from which the runtime is constructed.
+
+## Getting Started
+
+* 🦀 The template is using the Rust language.
+
+* 👉 Check the
+[Rust installation instructions](https://www.rust-lang.org/tools/install) for your system.
+
+* 🛠️ Depending on your operating system and Rust version, there might be additional
+packages required to compile this template - please take note of the Rust compiler output.
+
+### Build
+
+🔨 Use the following command to build the node without launching it:
+
+```sh
+cargo build --release
+```
+
+🐳 Alternatively, build the docker image:
+
+```sh
+docker build . -t polkadot-sdk-parachain-template
+```
+
+### Local Development Chain
+
+🧟 This project uses [Zombienet](https://github.com/paritytech/zombienet) to orchestrate the relaychain and parachain nodes.
+You can grab a [released binary](https://github.com/paritytech/zombienet/releases/latest) or use an [npm version](https://www.npmjs.com/package/@zombienet/cli).
+
+This template produces a parachain node.
+You still need a relaychain node - you can download the `polkadot`
+(and the accompanying `polkadot-prepare-worker` and `polkadot-execute-worker`)
+binaries from [Polkadot SDK releases](https://github.com/paritytech/polkadot-sdk/releases/latest).
+
+Make sure to bring the parachain node - as well as `polkadot`, `polkadot-prepare-worker`, `polkadot-execute-worker`,
+and `zombienet` - into `PATH` like so:
+
+```sh
+export PATH="./target/release/:$PATH"
+```
+
+This way, we can conveniently use them un the following steps.
+
+👥 The following command starts a local development chain, with a single relay chain node and a single parachain collator:
+
+```sh
+zombienet --provider native spawn ./zombienet.toml
+
+# Alternatively, the npm version:
+npx --yes @zombienet/cli --provider native spawn ./zombienet.toml
+```
+
+Development chains:
+
+* 🧹 Do not persist the state.
+* 💰 Are preconfigured with a genesis state that includes several prefunded development accounts.
+* 🧑‍⚖️ Development accounts are used as validators, collators, and `sudo` accounts.
+
+### Connect with the Polkadot-JS Apps Front-End
+
+* 🌐 You can interact with your local node using the
+hosted version of the Polkadot/Substrate Portal:
+[relay chain](https://polkadot.js.org/apps/#/explorer?rpc=ws://localhost:9944)
+and [parachain](https://polkadot.js.org/apps/#/explorer?rpc=ws://localhost:9988).
+
+* 🪐 A hosted version is also
+available on [IPFS](https://dotapps.io/).
+
+* 🧑‍🔧 You can also find the source code and instructions for hosting your own instance in the
+[`polkadot-js/apps`](https://github.com/polkadot-js/apps) repository.
+
+## Contributing
+
+* 🔄 This template is automatically updated after releases in the main [Polkadot SDK monorepo](https://github.com/paritytech/polkadot-sdk).
+
+* ➡️ Any pull requests should be directed to this [source](https://github.com/paritytech/polkadot-sdk/tree/master/templates/parachain).
+
+* 😇 Please refer to the monorepo's
+[contribution guidelines](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CONTRIBUTING.md) and
+[Code of Conduct](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CODE_OF_CONDUCT.md).
+
+## Getting Help
+
+* 🧑‍🏫 To learn about Polkadot in general, [Polkadot.network](https://polkadot.network/) website is a good starting point.
+
+* 🧑‍🔧 For technical introduction, [here](https://github.com/paritytech/polkadot-sdk#-documentation) are
+the Polkadot SDK documentation resources.
+
+* 👥 Additionally, there are [GitHub issues](https://github.com/paritytech/polkadot-sdk/issues) and
+[Substrate StackExchange](https://substrate.stackexchange.com/).
diff --git a/templates/parachain/node/Cargo.toml b/templates/parachain/node/Cargo.toml
index 6f7150829829ac1f06ca1de91f69f99e61497f8a..1737c6a9df75e41b6d8252d8966c1464bfdc5bfb 100644
--- a/templates/parachain/node/Cargo.toml
+++ b/templates/parachain/node/Cargo.toml
@@ -2,7 +2,7 @@
 name = "parachain-template-node"
 description = "A parachain node template built with Substrate and Cumulus, part of Polkadot Sdk."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
@@ -10,9 +10,6 @@ edition.workspace = true
 publish = false
 build = "build.rs"
 
-[lints]
-workspace = true
-
 # [[bin]]
 # name = "parachain-template-node"
 
@@ -59,7 +56,7 @@ sp-io = { path = "../../../substrate/primitives/io" }
 sp-runtime = { path = "../../../substrate/primitives/runtime" }
 sp-timestamp = { path = "../../../substrate/primitives/timestamp" }
 substrate-frame-rpc-system = { path = "../../../substrate/utils/frame/rpc/system" }
-substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" }
 
 # Polkadot
 polkadot-cli = { path = "../../../polkadot/cli", features = ["rococo-native"] }
diff --git a/templates/parachain/node/README.md b/templates/parachain/node/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..350272c7b6efe1e53b4ed13296a00c89a8cf0639
--- /dev/null
+++ b/templates/parachain/node/README.md
@@ -0,0 +1,18 @@
+# Node
+
+ℹ️ A node -  in Polkadot - is a binary executable, whose primary purpose is to execute the [runtime](../runtime/README.md).
+
+🔗 It communicates with other nodes in the network, and aims for
+[consensus](https://wiki.polkadot.network/docs/learn-consensus) among them.
+
+⚙️ It acts as a remote procedure call (RPC) server, allowing interaction with the blockchain.
+
+👉 Learn more about the architecture, and a difference between a node and a runtime
+[here](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/reference_docs/wasm_meta_protocol/index.html).
+
+👇 Here are the most important files in this node template:
+
+- [`chain_spec.rs`](./src/chain_spec.rs): A chain specification is a source code file that defines the chain's
+initial (genesis) state.
+- [`service.rs`](./src/service.rs): This file defines the node implementation.
+It's a place to configure consensus-related topics.
diff --git a/templates/parachain/node/src/chain_spec.rs b/templates/parachain/node/src/chain_spec.rs
index 51710f1199c35abbf0e2971758803462a8522f03..3fa91c0261622cd71dbf2b473eb70748f3a29b96 100644
--- a/templates/parachain/node/src/chain_spec.rs
+++ b/templates/parachain/node/src/chain_spec.rs
@@ -8,7 +8,7 @@ use sp_core::{sr25519, Pair, Public};
 use sp_runtime::traits::{IdentifyAccount, Verify};
 
 /// Specialized `ChainSpec` for the normal parachain runtime.
-pub type ChainSpec = sc_service::GenericChainSpec<(), Extensions>;
+pub type ChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// The default XCM version to set in genesis config.
 const SAFE_XCM_VERSION: u32 = xcm::prelude::XCM_VERSION;
diff --git a/templates/parachain/node/src/cli.rs b/templates/parachain/node/src/cli.rs
index cffbfbc1db23f8b28d234e78f781977d7face5ab..f008e856d99b8ba4dceac5835681920713d2d3f9 100644
--- a/templates/parachain/node/src/cli.rs
+++ b/templates/parachain/node/src/cli.rs
@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 /// Sub-commands supported by the collator.
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, clap::Subcommand)]
 pub enum Subcommand {
 	/// Build a chain specification.
diff --git a/templates/parachain/node/src/command.rs b/templates/parachain/node/src/command.rs
index 56ae022cad2b22757af87cef08d179433e9db509..eba7fdcdae7185186f2ec12f27efec5b1fca720b 100644
--- a/templates/parachain/node/src/command.rs
+++ b/templates/parachain/node/src/command.rs
@@ -194,13 +194,11 @@ pub fn run() -> Result<()> {
 					cmd.run(partials.client)
 				}),
 				#[cfg(not(feature = "runtime-benchmarks"))]
-				BenchmarkCmd::Storage(_) =>
-					return Err(sc_cli::Error::Input(
-						"Compile with --features=runtime-benchmarks \
+				BenchmarkCmd::Storage(_) => Err(sc_cli::Error::Input(
+					"Compile with --features=runtime-benchmarks \
 						to enable storage benchmarks."
-							.into(),
-					)
-					.into()),
+						.into(),
+				)),
 				#[cfg(feature = "runtime-benchmarks")]
 				BenchmarkCmd::Storage(cmd) => runner.sync_run(|config| {
 					let partials = new_partial(&config)?;
diff --git a/templates/parachain/node/src/service.rs b/templates/parachain/node/src/service.rs
index ad4689c6e55dc7d9bb96e0390182d7e7c8bf1591..587dd19faf3e8af6e8a8296333d61393e6fd52ac 100644
--- a/templates/parachain/node/src/service.rs
+++ b/templates/parachain/node/src/service.rs
@@ -28,6 +28,7 @@ use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};
 
 // Substrate Imports
 use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE;
+use prometheus_endpoint::Registry;
 use sc_client_api::Backend;
 use sc_consensus::ImportQueue;
 use sc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY};
@@ -37,7 +38,6 @@ use sc_service::{Configuration, PartialComponents, TFullBackend, TFullClient, Ta
 use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};
 use sc_transaction_pool_api::OffchainTransactionPoolFactory;
 use sp_keystore::KeystorePtr;
-use substrate_prometheus_endpoint::Registry;
 
 #[docify::export(wasm_executor)]
 type ParachainExecutor = WasmExecutor<ParachainHostFunctions>;
@@ -160,6 +160,7 @@ fn build_import_queue(
 	)
 }
 
+#[allow(clippy::too_many_arguments)]
 fn start_consensus(
 	client: Arc<ParachainClient>,
 	backend: Arc<ParachainBackend>,
diff --git a/templates/parachain/pallets/README.md b/templates/parachain/pallets/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fabe64a3e79a495a455b0f87b0957d364df5f30
--- /dev/null
+++ b/templates/parachain/pallets/README.md
@@ -0,0 +1,13 @@
+# Pallets
+
+ℹ️ A pallet is a unit of encapsulated logic, with a clearly defined responsibility. A pallet is analogous to a
+module in the runtime.
+
+💁 In this template, there is a simple custom pallet based on the FRAME framework.
+
+👉 Learn more about FRAME
+[here](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/frame_runtime/index.html).
+
+🧑‍🏫 Please refer to
+[this guide](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html)
+to learn how to write a basic pallet.
diff --git a/templates/parachain/pallets/template/Cargo.toml b/templates/parachain/pallets/template/Cargo.toml
index c5334e871fa4967bff0ae2259a7fe6a8066d9a33..6c549c2c4a9b64f7bffd07f27bde04bcdb32442d 100644
--- a/templates/parachain/pallets/template/Cargo.toml
+++ b/templates/parachain/pallets/template/Cargo.toml
@@ -2,16 +2,13 @@
 name = "pallet-parachain-template"
 description = "FRAME pallet template for defining custom runtime logic."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 publish = false
 
-[lints]
-workspace = true
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
diff --git a/templates/parachain/pallets/template/README.md b/templates/parachain/pallets/template/README.md
deleted file mode 100644
index 9e4dc55267d69c47fff971cb0427bcb2e0ff871c..0000000000000000000000000000000000000000
--- a/templates/parachain/pallets/template/README.md
+++ /dev/null
@@ -1 +0,0 @@
-License: MIT-0
diff --git a/templates/parachain/pallets/template/src/benchmarking.rs b/templates/parachain/pallets/template/src/benchmarking.rs
index 5a262417629c579c6ecf5ada30ae803217623766..d1a9554aed6dc0533f914e18661942ed56bcd514 100644
--- a/templates/parachain/pallets/template/src/benchmarking.rs
+++ b/templates/parachain/pallets/template/src/benchmarking.rs
@@ -13,7 +13,7 @@ mod benchmarks {
 
 	#[benchmark]
 	fn do_something() {
-		let value = 100u32.into();
+		let value = 100u32;
 		let caller: T::AccountId = whitelisted_caller();
 		#[extrinsic_call]
 		do_something(RawOrigin::Signed(caller), value);
diff --git a/templates/parachain/pallets/template/src/lib.rs b/templates/parachain/pallets/template/src/lib.rs
index 11587d1df426f485139eab9e333b292768c6c571..0420e2b908215120d97c0849a798cc5dbc07ea84 100644
--- a/templates/parachain/pallets/template/src/lib.rs
+++ b/templates/parachain/pallets/template/src/lib.rs
@@ -1,8 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-/// Edit this file to define custom logic or remove it if it is not needed.
-/// Learn more about FRAME and the core library of Substrate FRAME pallets:
-/// <https://docs.substrate.io/v3/runtime/frame>
 pub use pallet::*;
 
 #[cfg(test)]
@@ -16,6 +13,12 @@ pub mod weights;
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
 
+// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/frame_runtime/index.html>
+// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html>
+//
+// To see a full list of `pallet` macros and their use cases, see:
+// <https://paritytech.github.io/polkadot-sdk/master/pallet_example_kitchensink/index.html>
+// <https://paritytech.github.io/polkadot-sdk/master/frame_support/pallet_macros/index.html>
 #[frame_support::pallet]
 pub mod pallet {
 	use frame_support::{dispatch::DispatchResultWithPostInfo, pallet_prelude::*};
@@ -25,7 +28,9 @@ pub mod pallet {
 	#[pallet::config]
 	pub trait Config: frame_system::Config {
 		/// Because this pallet emits events, it depends on the runtime's definition of an event.
+		/// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/reference_docs/frame_runtime_types/index.html>
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
 		/// A type representing the weights required by the dispatchables of this pallet.
 		type WeightInfo: crate::weights::WeightInfo;
 	}
@@ -33,24 +38,23 @@ pub mod pallet {
 	#[pallet::pallet]
 	pub struct Pallet<T>(_);
 
-	// The pallet's runtime storage items.
-	// https://docs.substrate.io/v3/runtime/storage
+	/// The pallet's storage items.
+	/// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html#storage>
+	/// <https://paritytech.github.io/polkadot-sdk/master/frame_support/pallet_macros/attr.storage.html>
 	#[pallet::storage]
-	// Learn more about declaring storage items:
-	// https://docs.substrate.io/v3/runtime/storage#declaring-storage-items
 	pub type Something<T> = StorageValue<_, u32>;
 
-	// Pallets use events to inform users when important changes are made.
-	// https://docs.substrate.io/v3/runtime/events-and-errors
+	/// Pallets use events to inform users when important changes are made.
+	/// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html#event-and-error>
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
-		/// Event documentation should end with an array that provides descriptive names for event
-		/// parameters. [something, who]
-		SomethingStored(u32, T::AccountId),
+		/// We usually use passive tense for events.
+		SomethingStored { something: u32, who: T::AccountId },
 	}
 
-	// Errors inform users that something went wrong.
+	/// Errors inform users that something went wrong.
+	/// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html#event-and-error>
 	#[pallet::error]
 	pub enum Error<T> {
 		/// Error names should be descriptive.
@@ -62,9 +66,10 @@ pub mod pallet {
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
 
-	// Dispatchable functions allows users to interact with the pallet and invoke state changes.
-	// These functions materialize as "extrinsics", which are often compared to transactions.
-	// Dispatchable functions must be annotated with a weight and must return a DispatchResult.
+	/// Dispatchable functions allows users to interact with the pallet and invoke state changes.
+	/// These functions materialize as "extrinsics", which are often compared to transactions.
+	/// Dispatchable functions must be annotated with a weight and must return a DispatchResult.
+	/// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html#dispatchables>
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
 		/// An example dispatchable that takes a singles value as a parameter, writes the value to
@@ -74,14 +79,15 @@ pub mod pallet {
 		pub fn do_something(origin: OriginFor<T>, something: u32) -> DispatchResultWithPostInfo {
 			// Check that the extrinsic was signed and get the signer.
 			// This function will return an error if the extrinsic is not signed.
-			// https://docs.substrate.io/v3/runtime/origins
+			// <https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/reference_docs/frame_origin/index.html>
 			let who = ensure_signed(origin)?;
 
 			// Update storage.
 			<Something<T>>::put(something);
 
 			// Emit an event.
-			Self::deposit_event(Event::SomethingStored(something, who));
+			Self::deposit_event(Event::SomethingStored { something, who });
+
 			// Return a successful DispatchResultWithPostInfo
 			Ok(().into())
 		}
diff --git a/templates/parachain/pallets/template/src/mock.rs b/templates/parachain/pallets/template/src/mock.rs
index 8a88be3e3e9f6d08137ae1bb16767145e2d84aa9..46e3117596f599ca923425dd72be7c01421b4ffa 100644
--- a/templates/parachain/pallets/template/src/mock.rs
+++ b/templates/parachain/pallets/template/src/mock.rs
@@ -1,52 +1,36 @@
-use frame_support::{derive_impl, parameter_types, traits::Everything};
-use frame_system as system;
-use sp_core::H256;
-use sp_runtime::{
-	traits::{BlakeTwo256, IdentityLookup},
-	BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
+use frame_support::{derive_impl, weights::constants::RocksDbWeight};
+use frame_system::{mocking::MockBlock, GenesisConfig};
+use sp_runtime::{traits::ConstU64, BuildStorage};
 
 // Configure a mock runtime to test the pallet.
-frame_support::construct_runtime!(
-	pub enum Test
-	{
-		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
-		TemplateModule: crate::{Pallet, Call, Storage, Event<T>},
-	}
-);
+#[frame_support::runtime]
+mod test_runtime {
+	#[runtime::runtime]
+	#[runtime::derive(
+		RuntimeCall,
+		RuntimeEvent,
+		RuntimeError,
+		RuntimeOrigin,
+		RuntimeFreezeReason,
+		RuntimeHoldReason,
+		RuntimeSlashReason,
+		RuntimeLockId,
+		RuntimeTask
+	)]
+	pub struct Test;
 
-parameter_types! {
-	pub const BlockHashCount: u64 = 250;
-	pub const SS58Prefix: u8 = 42;
+	#[runtime::pallet_index(0)]
+	pub type System = frame_system;
+	#[runtime::pallet_index(1)]
+	pub type TemplateModule = crate;
 }
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl system::Config for Test {
-	type BaseCallFilter = Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
+impl frame_system::Config for Test {
 	type Nonce = u64;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
-	type Lookup = IdentityLookup<Self::AccountId>;
-	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = BlockHashCount;
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = ();
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = SS58Prefix;
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
+	type Block = MockBlock<Test>;
+	type BlockHashCount = ConstU64<250>;
+	type DbWeight = RocksDbWeight;
 }
 
 impl crate::Config for Test {
@@ -56,5 +40,5 @@ impl crate::Config for Test {
 
 // Build genesis storage according to the mock runtime.
 pub fn new_test_ext() -> sp_io::TestExternalities {
-	system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+	GenesisConfig::<Test>::default().build_storage().unwrap().into()
 }
diff --git a/templates/parachain/pallets/template/src/weights.rs b/templates/parachain/pallets/template/src/weights.rs
index 7c42936e09f292de831d28460a3bc39436c3323f..5bfe28e8b71e36d7ee06127b3c1f769617e96494 100644
--- a/templates/parachain/pallets/template/src/weights.rs
+++ b/templates/parachain/pallets/template/src/weights.rs
@@ -4,7 +4,7 @@
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
 //! DATE: 2023-04-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `Alexs-MacBook-Pro-2.local`, CPU: `<UNKNOWN>`
+//! HOSTNAME: `_`, CPU: `<UNKNOWN>`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
 
 // Executed Command:
diff --git a/templates/parachain/polkadot-launch/config.json b/templates/parachain/polkadot-launch/config.json
deleted file mode 100644
index f03f983a4975e3289adcf8922f70cb12d7c9b084..0000000000000000000000000000000000000000
--- a/templates/parachain/polkadot-launch/config.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
-	"relaychain": {
-		"bin": "../../polkadot/target/release/polkadot",
-		"chain": "rococo-local",
-		"nodes": [
-			{
-				"name": "alice",
-				"wsPort": 9944,
-				"port": 30444
-			},
-			{
-				"name": "bob",
-				"wsPort": 9955,
-				"port": 30555
-			}
-		]
-	},
-	"parachains": [
-		{
-			"bin": "../target/release/polkadot-parachain",
-			"id": "200",
-			"balance": "1000000000000000000000",
-			"nodes": [
-				{
-					"wsPort": 9988,
-					"name": "alice",
-					"port": 31200,
-					"flags": [
-						"--force-authoring",
-						"--",
-						"--execution=wasm"
-					]
-				}
-			]
-		}
-	],
-	"types": {
-	}
-}
diff --git a/templates/parachain/runtime/Cargo.toml b/templates/parachain/runtime/Cargo.toml
index 74b82f06e3ac0a2b9c125524ceade259eac1462e..48d9f69128949e228e3a53f53d89cbccc0a45127 100644
--- a/templates/parachain/runtime/Cargo.toml
+++ b/templates/parachain/runtime/Cargo.toml
@@ -2,21 +2,19 @@
 name = "parachain-template-runtime"
 description = "A parachain runtime template built with Substrate and Cumulus, part of Polkadot Sdk."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 publish = false
 
-[lints]
-workspace = true
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
 [build-dependencies]
 substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder", optional = true }
+docify = "0.2.8"
 
 [dependencies]
 codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = [
@@ -36,7 +34,8 @@ pallet-parachain-template = { path = "../pallets/template", default-features = f
 # Substrate / FRAME
 frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true }
 frame-executive = { path = "../../../substrate/frame/executive", default-features = false }
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
+frame-metadata-hash-extension = { path = "../../../substrate/frame/metadata-hash-extension", default-features = false }
+frame-support = { path = "../../../substrate/frame/support", default-features = false, features = ["experimental"] }
 frame-system = { path = "../../../substrate/frame/system", default-features = false }
 frame-system-benchmarking = { path = "../../../substrate/frame/system/benchmarking", default-features = false, optional = true }
 frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api", default-features = false }
@@ -77,9 +76,7 @@ xcm-executor = { package = "staging-xcm-executor", path = "../../../polkadot/xcm
 
 # Cumulus
 cumulus-pallet-aura-ext = { path = "../../../cumulus/pallets/aura-ext", default-features = false }
-cumulus-pallet-parachain-system = { path = "../../../cumulus/pallets/parachain-system", default-features = false, features = [
-	"parameterized-consensus-hook",
-] }
+cumulus-pallet-parachain-system = { path = "../../../cumulus/pallets/parachain-system", default-features = false }
 cumulus-pallet-session-benchmarking = { path = "../../../cumulus/pallets/session-benchmarking", default-features = false }
 cumulus-pallet-xcm = { path = "../../../cumulus/pallets/xcm", default-features = false }
 cumulus-pallet-xcmp-queue = { path = "../../../cumulus/pallets/xcmp-queue", default-features = false }
@@ -106,6 +103,7 @@ std = [
 	"cumulus-primitives-utility/std",
 	"frame-benchmarking?/std",
 	"frame-executive/std",
+	"frame-metadata-hash-extension/std",
 	"frame-support/std",
 	"frame-system-benchmarking?/std",
 	"frame-system-rpc-runtime-api/std",
@@ -197,3 +195,16 @@ try-runtime = [
 	"polkadot-runtime-common/try-runtime",
 	"sp-runtime/try-runtime",
 ]
+
+# Enable the metadata hash generation.
+#
+# This is hidden behind a feature because it increases the compile time.
+# The wasm binary needs to be compiled twice, once to fetch the metadata,
+# generate the metadata hash and then a second time with the
+# `RUNTIME_METADATA_HASH` environment variable set for the `CheckMetadataHash`
+# extension.
+metadata-hash = ["substrate-wasm-builder/metadata-hash"]
+
+# A convenience feature for enabling things when doing a build
+# for an on-chain release.
+on-chain-release-build = ["metadata-hash"]
diff --git a/templates/parachain/runtime/README.md b/templates/parachain/runtime/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..acd5939fc54226774f01ca9d52d1830218dcd18d
--- /dev/null
+++ b/templates/parachain/runtime/README.md
@@ -0,0 +1,10 @@
+# Runtime
+
+ℹ️ The runtime (in other words, a state transition function), refers to the core logic of the parachain that is
+responsible for validating blocks and executing the state changes they define.
+
+💁 The runtime in this template is constructed using ready-made FRAME pallets that ship with
+[Polkadot SDK](https://github.com/paritytech/polkadot-sdk), and a [template for a custom pallet](../pallets/README.md).
+
+👉 Learn more about FRAME
+[here](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/frame_runtime/index.html).
diff --git a/templates/parachain/runtime/build.rs b/templates/parachain/runtime/build.rs
index bb05afe02b1fc526d1c7a2c64514e7f25f33c7be..4f33752ca6b2d47b31270ca885a1c42f10ed8410 100644
--- a/templates/parachain/runtime/build.rs
+++ b/templates/parachain/runtime/build.rs
@@ -1,4 +1,12 @@
-#[cfg(feature = "std")]
+#[cfg(all(feature = "std", feature = "metadata-hash"))]
+#[docify::export(template_enable_metadata_hash)]
+fn main() {
+	substrate_wasm_builder::WasmBuilder::init_with_defaults()
+		.enable_metadata_hash("UNIT", 12)
+		.build();
+}
+
+#[cfg(all(feature = "std", not(feature = "metadata-hash")))]
 fn main() {
 	substrate_wasm_builder::WasmBuilder::build_using_defaults();
 }
diff --git a/templates/parachain/runtime/src/configs/mod.rs b/templates/parachain/runtime/src/configs/mod.rs
index 63e6a67a90638266820bce44e8aee75a544681bc..8a410a27e4a7bd270f661ec0b7cd99c8ef1416f9 100644
--- a/templates/parachain/runtime/src/configs/mod.rs
+++ b/templates/parachain/runtime/src/configs/mod.rs
@@ -32,7 +32,9 @@ use frame_support::{
 	derive_impl,
 	dispatch::DispatchClass,
 	parameter_types,
-	traits::{ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, TransformOrigin},
+	traits::{
+		ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, TransformOrigin, VariantCountOf,
+	},
 	weights::{ConstantMultiplier, Weight},
 	PalletId,
 };
@@ -154,8 +156,8 @@ impl pallet_balances::Config for Runtime {
 	type ReserveIdentifier = [u8; 8];
 	type RuntimeHoldReason = RuntimeHoldReason;
 	type RuntimeFreezeReason = RuntimeFreezeReason;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ConstU32<0>;
+	type FreezeIdentifier = RuntimeFreezeReason;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
 }
 
 parameter_types! {
diff --git a/templates/parachain/runtime/src/lib.rs b/templates/parachain/runtime/src/lib.rs
index 179a425ca04165a53ab3c14caaeeb638adb358b0..6e6491a19adf6b41f4fcfa28aa62f6bf97e12b3e 100644
--- a/templates/parachain/runtime/src/lib.rs
+++ b/templates/parachain/runtime/src/lib.rs
@@ -7,6 +7,8 @@
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
 
 pub mod apis;
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarks;
 mod configs;
 mod weights;
 
@@ -22,12 +24,9 @@ use sp_std::prelude::*;
 use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 
-use frame_support::{
-	construct_runtime,
-	weights::{
-		constants::WEIGHT_REF_TIME_PER_SECOND, Weight, WeightToFeeCoefficient,
-		WeightToFeeCoefficients, WeightToFeePolynomial,
-	},
+use frame_support::weights::{
+	constants::WEIGHT_REF_TIME_PER_SECOND, Weight, WeightToFeeCoefficient, WeightToFeeCoefficients,
+	WeightToFeePolynomial,
 };
 pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 pub use sp_runtime::{MultiAddress, Perbill, Permill};
@@ -86,6 +85,7 @@ pub type SignedExtra = (
 	frame_system::CheckWeight<Runtime>,
 	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
 	cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim<Runtime>,
+	frame_metadata_hash_extension::CheckMetadataHash<Runtime>,
 );
 
 /// Unchecked extrinsic type as expected by this runtime.
@@ -231,43 +231,69 @@ pub fn native_version() -> NativeVersion {
 }
 
 // Create the runtime by composing the FRAME pallets that were previously configured.
-construct_runtime!(
-	pub enum Runtime {
-		// System support stuff.
-		System: frame_system = 0,
-		ParachainSystem: cumulus_pallet_parachain_system = 1,
-		Timestamp: pallet_timestamp = 2,
-		ParachainInfo: parachain_info = 3,
-
-		// Monetary stuff.
-		Balances: pallet_balances = 10,
-		TransactionPayment: pallet_transaction_payment = 11,
-
-		// Governance
-		Sudo: pallet_sudo = 15,
-
-		// Collator support. The order of these 4 are important and shall not change.
-		Authorship: pallet_authorship = 20,
-		CollatorSelection: pallet_collator_selection = 21,
-		Session: pallet_session = 22,
-		Aura: pallet_aura = 23,
-		AuraExt: cumulus_pallet_aura_ext = 24,
-
-		// XCM helpers.
-		XcmpQueue: cumulus_pallet_xcmp_queue = 30,
-		PolkadotXcm: pallet_xcm = 31,
-		CumulusXcm: cumulus_pallet_xcm = 32,
-		MessageQueue: pallet_message_queue = 33,
-
-		// Template
-		TemplatePallet: pallet_parachain_template = 50,
-	}
-);
+#[frame_support::runtime]
+mod runtime {
+	#[runtime::runtime]
+	#[runtime::derive(
+		RuntimeCall,
+		RuntimeEvent,
+		RuntimeError,
+		RuntimeOrigin,
+		RuntimeFreezeReason,
+		RuntimeHoldReason,
+		RuntimeSlashReason,
+		RuntimeLockId,
+		RuntimeTask
+	)]
+	pub struct Runtime;
+
+	#[runtime::pallet_index(0)]
+	pub type System = frame_system;
+	#[runtime::pallet_index(1)]
+	pub type ParachainSystem = cumulus_pallet_parachain_system;
+	#[runtime::pallet_index(2)]
+	pub type Timestamp = pallet_timestamp;
+	#[runtime::pallet_index(3)]
+	pub type ParachainInfo = parachain_info;
+
+	// Monetary stuff.
+	#[runtime::pallet_index(10)]
+	pub type Balances = pallet_balances;
+	#[runtime::pallet_index(11)]
+	pub type TransactionPayment = pallet_transaction_payment;
+
+	// Governance
+	#[runtime::pallet_index(15)]
+	pub type Sudo = pallet_sudo;
+
+	// Collator support. The order of these 4 are important and shall not change.
+	#[runtime::pallet_index(20)]
+	pub type Authorship = pallet_authorship;
+	#[runtime::pallet_index(21)]
+	pub type CollatorSelection = pallet_collator_selection;
+	#[runtime::pallet_index(22)]
+	pub type Session = pallet_session;
+	#[runtime::pallet_index(23)]
+	pub type Aura = pallet_aura;
+	#[runtime::pallet_index(24)]
+	pub type AuraExt = cumulus_pallet_aura_ext;
+
+	// XCM helpers.
+	#[runtime::pallet_index(30)]
+	pub type XcmpQueue = cumulus_pallet_xcmp_queue;
+	#[runtime::pallet_index(31)]
+	pub type PolkadotXcm = pallet_xcm;
+	#[runtime::pallet_index(32)]
+	pub type CumulusXcm = cumulus_pallet_xcm;
+	#[runtime::pallet_index(33)]
+	pub type MessageQueue = pallet_message_queue;
+
+	// Template
+	#[runtime::pallet_index(50)]
+	pub type TemplatePallet = pallet_parachain_template;
+}
 
 cumulus_pallet_parachain_system::register_validate_block! {
 	Runtime = Runtime,
 	BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,
 }
-
-#[cfg(feature = "runtime-benchmarks")]
-mod benchmarks;
diff --git a/templates/parachain/zombienet.toml b/templates/parachain/zombienet.toml
new file mode 100644
index 0000000000000000000000000000000000000000..336ba1af4dde56a78208e555fdad1d732696db27
--- /dev/null
+++ b/templates/parachain/zombienet.toml
@@ -0,0 +1,16 @@
+[relaychain]
+default_command = "polkadot"
+chain = "dev"
+
+[[relaychain.nodes]]
+name = "alice"
+validator = true
+ws_port = 9944
+
+[[parachains]]
+id = 1000
+
+[parachains.collator]
+name = "alice"
+ws_port = 9988
+command = "parachain-template-node"
diff --git a/templates/solochain/.dockerignore b/templates/solochain/.dockerignore
new file mode 100644
index 0000000000000000000000000000000000000000..da6a8f2620d64f3761669047dfbda397b685493c
--- /dev/null
+++ b/templates/solochain/.dockerignore
@@ -0,0 +1,3 @@
+target/
+Dockerfile
+.dockerignore
diff --git a/templates/solochain/Dockerfile b/templates/solochain/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..97e6dd29107ace0fdcc2f83bb8c4b0dbc124523c
--- /dev/null
+++ b/templates/solochain/Dockerfile
@@ -0,0 +1,28 @@
+FROM docker.io/paritytech/ci-unified:latest as builder
+
+WORKDIR /polkadot
+COPY . /polkadot
+
+RUN cargo fetch
+RUN cargo build --locked --release
+
+FROM docker.io/parity/base-bin:latest
+
+COPY --from=builder /polkadot/target/release/solochain-template-node /usr/local/bin
+
+USER root
+RUN useradd -m -u 1001 -U -s /bin/sh -d /polkadot polkadot && \
+	mkdir -p /data /polkadot/.local/share && \
+	chown -R polkadot:polkadot /data && \
+	ln -s /data /polkadot/.local/share/polkadot && \
+# unclutter and minimize the attack surface
+	rm -rf /usr/bin /usr/sbin && \
+# check if executable works in this container
+	/usr/local/bin/solochain-template-node --version
+
+USER polkadot
+
+EXPOSE 30333 9933 9944 9615
+VOLUME ["/data"]
+
+ENTRYPOINT ["/usr/local/bin/solochain-template-node"]
diff --git a/templates/solochain/LICENSE b/templates/solochain/LICENSE
index ffa0b3f2df035abdd789f1f205357f7318bc5498..cf1ab25da0349f84a3fdd40032f0ce99db813b8b 100644
--- a/templates/solochain/LICENSE
+++ b/templates/solochain/LICENSE
@@ -1,16 +1,24 @@
-MIT No Attribution
+This is free and unencumbered software released into the public domain.
 
-Copyright Parity Technologies (UK) Ltd.
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
 
-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.
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
 
-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.
\ No newline at end of file
+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 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.
+
+For more information, please refer to <http://unlicense.org>
diff --git a/templates/solochain/README.md b/templates/solochain/README.md
index 37c65797dcb00a8aed0a4f4566eaaacab37c8359..2e3b1146a8fdebbdb4488af29831662a951733c9 100644
--- a/templates/solochain/README.md
+++ b/templates/solochain/README.md
@@ -103,9 +103,8 @@ After you start the node template locally, you can interact with it using the
 hosted version of the [Polkadot/Substrate
 Portal](https://polkadot.js.org/apps/#/explorer?rpc=ws://localhost:9944)
 front-end by connecting to the local node endpoint. A hosted version is also
-available on [IPFS (redirect) here](https://dotapps.io/) or [IPNS (direct)
-here](ipns://dotapps.io/?rpc=ws%3A%2F%2F127.0.0.1%3A9944#/explorer). You can
-also find the source code and instructions for hosting your own instance on the
+available on [IPFS](https://dotapps.io/). You can
+also find the source code and instructions for hosting your own instance in the
 [`polkadot-js/apps`](https://github.com/polkadot-js/apps) repository.
 
 ### Multi-Node Local Testnet
@@ -131,7 +130,7 @@ capabilities:
   the network. Substrate makes it possible to supply custom consensus engines
   and also ships with several consensus mechanisms that have been built on top
   of [Web3 Foundation
-  research](https://research.web3.foundation/en/latest/polkadot/NPoS/index.html).
+  research](https://research.web3.foundation/Polkadot/protocols/NPoS).
 - RPC Server: A remote procedure call (RPC) server is used to interact with
   Substrate nodes.
 
diff --git a/templates/solochain/node/Cargo.toml b/templates/solochain/node/Cargo.toml
index 9332da3a6549c90fe3eebfcda3fbb51dc49c57d6..4e8b81840900d3365f569ce96ecb642eb560d6d9 100644
--- a/templates/solochain/node/Cargo.toml
+++ b/templates/solochain/node/Cargo.toml
@@ -2,7 +2,7 @@
 name = "solochain-template-node"
 description = "A solochain node template built with Substrate, part of Polkadot Sdk."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
@@ -11,9 +11,6 @@ publish = false
 
 build = "build.rs"
 
-[lints]
-workspace = true
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
diff --git a/templates/solochain/node/src/chain_spec.rs b/templates/solochain/node/src/chain_spec.rs
index be49f2c1fc731ee4e5ece7841151068abf0f0790..651025e68ded916485f03b377bb44482d89ac5ba 100644
--- a/templates/solochain/node/src/chain_spec.rs
+++ b/templates/solochain/node/src/chain_spec.rs
@@ -1,5 +1,5 @@
 use sc_service::ChainType;
-use solochain_template_runtime::{AccountId, RuntimeGenesisConfig, Signature, WASM_BINARY};
+use solochain_template_runtime::{AccountId, Signature, WASM_BINARY};
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 use sp_consensus_grandpa::AuthorityId as GrandpaId;
 use sp_core::{sr25519, Pair, Public};
@@ -9,7 +9,7 @@ use sp_runtime::traits::{IdentifyAccount, Verify};
 // const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/";
 
 /// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.
-pub type ChainSpec = sc_service::GenericChainSpec<RuntimeGenesisConfig>;
+pub type ChainSpec = sc_service::GenericChainSpec;
 
 /// Generate a crypto pair from seed.
 pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
diff --git a/templates/solochain/node/src/command.rs b/templates/solochain/node/src/command.rs
index e46fedc91f0e26fb9e4e36dbbc45a3cc0c0c7310..624ace1bf350a1d5b36d0f409d0ca3868fd127fc 100644
--- a/templates/solochain/node/src/command.rs
+++ b/templates/solochain/node/src/command.rs
@@ -114,7 +114,7 @@ pub fn run() -> sc_cli::Result<()> {
 								"Runtime benchmarking wasn't enabled when building the node. \
 							You can enable it with `--features runtime-benchmarks`."
 									.into(),
-							)
+							);
 						}
 
 						cmd.run_with_spec::<sp_runtime::traits::HashingFor<Block>, ()>(Some(
diff --git a/templates/solochain/pallets/template/Cargo.toml b/templates/solochain/pallets/template/Cargo.toml
index 1a122bd82d40c7f28c468140e842310c2f45f128..5b8349b5d678cdcf72befebf77b8d4598d61b261 100644
--- a/templates/solochain/pallets/template/Cargo.toml
+++ b/templates/solochain/pallets/template/Cargo.toml
@@ -2,16 +2,13 @@
 name = "pallet-template"
 description = "FRAME pallet template for defining custom runtime logic."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 publish = false
 
-[lints]
-workspace = true
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
diff --git a/templates/solochain/pallets/template/src/benchmarking.rs b/templates/solochain/pallets/template/src/benchmarking.rs
index 5a262417629c579c6ecf5ada30ae803217623766..d1a9554aed6dc0533f914e18661942ed56bcd514 100644
--- a/templates/solochain/pallets/template/src/benchmarking.rs
+++ b/templates/solochain/pallets/template/src/benchmarking.rs
@@ -13,7 +13,7 @@ mod benchmarks {
 
 	#[benchmark]
 	fn do_something() {
-		let value = 100u32.into();
+		let value = 100u32;
 		let caller: T::AccountId = whitelisted_caller();
 		#[extrinsic_call]
 		do_something(RawOrigin::Signed(caller), value);
diff --git a/templates/solochain/pallets/template/src/mock.rs b/templates/solochain/pallets/template/src/mock.rs
index 3f1fd2dd6d4441c2177d3f44a0f377b3ab2edc72..0c2a247e802b35fcccd770bec2e5fa723bf49891 100644
--- a/templates/solochain/pallets/template/src/mock.rs
+++ b/templates/solochain/pallets/template/src/mock.rs
@@ -1,13 +1,6 @@
 use crate as pallet_template;
-use frame_support::{
-	derive_impl,
-	traits::{ConstU16, ConstU64},
-};
-use sp_core::H256;
-use sp_runtime::{
-	traits::{BlakeTwo256, IdentityLookup},
-	BuildStorage,
-};
+use frame_support::derive_impl;
+use sp_runtime::BuildStorage;
 
 type Block = frame_system::mocking::MockBlock<Test>;
 
@@ -22,29 +15,7 @@ frame_support::construct_runtime!(
 
 #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
 impl frame_system::Config for Test {
-	type BaseCallFilter = frame_support::traits::Everything;
-	type BlockWeights = ();
-	type BlockLength = ();
-	type DbWeight = ();
-	type RuntimeOrigin = RuntimeOrigin;
-	type RuntimeCall = RuntimeCall;
-	type Nonce = u64;
-	type Hash = H256;
-	type Hashing = BlakeTwo256;
-	type AccountId = u64;
-	type Lookup = IdentityLookup<Self::AccountId>;
 	type Block = Block;
-	type RuntimeEvent = RuntimeEvent;
-	type BlockHashCount = ConstU64<250>;
-	type Version = ();
-	type PalletInfo = PalletInfo;
-	type AccountData = ();
-	type OnNewAccount = ();
-	type OnKilledAccount = ();
-	type SystemWeightInfo = ();
-	type SS58Prefix = ConstU16<42>;
-	type OnSetCode = ();
-	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 
 impl pallet_template::Config for Test {
diff --git a/templates/solochain/runtime/Cargo.toml b/templates/solochain/runtime/Cargo.toml
index b4a543826e793ffe16c0383985b1b8101bab4a01..0af3899a666995120738459be823a70debd23168 100644
--- a/templates/solochain/runtime/Cargo.toml
+++ b/templates/solochain/runtime/Cargo.toml
@@ -2,16 +2,13 @@
 name = "solochain-template-runtime"
 description = "A solochain runtime template built with Substrate, part of Polkadot Sdk."
 version = "0.0.0"
-license = "MIT-0"
+license = "Unlicense"
 authors.workspace = true
 homepage.workspace = true
 repository.workspace = true
 edition.workspace = true
 publish = false
 
-[lints]
-workspace = true
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
diff --git a/templates/solochain/runtime/src/lib.rs b/templates/solochain/runtime/src/lib.rs
index c7f331fb40e0660ac5587baa7cc64aea4a38b862..294f04d64ec05f46c758bea46e7d58c4c7463e66 100644
--- a/templates/solochain/runtime/src/lib.rs
+++ b/templates/solochain/runtime/src/lib.rs
@@ -18,7 +18,6 @@ use sp_std::prelude::*;
 use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 
-use frame_support::genesis_builder_helper::{build_state, get_preset};
 pub use frame_support::{
 	construct_runtime, derive_impl, parameter_types,
 	traits::{
@@ -33,6 +32,10 @@ pub use frame_support::{
 	},
 	StorageValue,
 };
+use frame_support::{
+	genesis_builder_helper::{build_state, get_preset},
+	traits::VariantCountOf,
+};
 pub use frame_system::Call as SystemCall;
 pub use pallet_balances::Call as BalancesCall;
 pub use pallet_timestamp::Call as TimestampCall;
@@ -218,10 +221,10 @@ impl pallet_balances::Config for Runtime {
 	type ExistentialDeposit = ConstU128<EXISTENTIAL_DEPOSIT>;
 	type AccountStore = System;
 	type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
-	type FreezeIdentifier = ();
-	type MaxFreezes = ();
-	type RuntimeHoldReason = ();
-	type RuntimeFreezeReason = ();
+	type FreezeIdentifier = RuntimeFreezeReason;
+	type MaxFreezes = VariantCountOf<RuntimeFreezeReason>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type RuntimeFreezeReason = RuntimeHoldReason;
 }
 
 parameter_types! {
diff --git a/umbrella/Cargo.toml b/umbrella/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..93af28a7ddd9293d37cdaca4578459bcbe7b0837
--- /dev/null
+++ b/umbrella/Cargo.toml
@@ -0,0 +1,2462 @@
+[package]
+name = "polkadot-sdk"
+version = "0.1.0"
+description = "Polkadot SDK umbrella crate."
+license = "Apache-2.0"
+
+[features]
+default = ["std"]
+std = [
+	"asset-test-utils?/std",
+	"assets-common?/std",
+	"binary-merkle-tree?/std",
+	"bp-asset-hub-rococo?/std",
+	"bp-asset-hub-westend?/std",
+	"bp-bridge-hub-cumulus?/std",
+	"bp-bridge-hub-kusama?/std",
+	"bp-bridge-hub-polkadot?/std",
+	"bp-bridge-hub-rococo?/std",
+	"bp-bridge-hub-westend?/std",
+	"bp-header-chain?/std",
+	"bp-kusama?/std",
+	"bp-messages?/std",
+	"bp-parachains?/std",
+	"bp-polkadot-bulletin?/std",
+	"bp-polkadot-core?/std",
+	"bp-polkadot?/std",
+	"bp-relayers?/std",
+	"bp-rococo?/std",
+	"bp-runtime?/std",
+	"bp-test-utils?/std",
+	"bp-westend?/std",
+	"bp-xcm-bridge-hub-router?/std",
+	"bp-xcm-bridge-hub?/std",
+	"bridge-hub-common?/std",
+	"bridge-hub-test-utils?/std",
+	"bridge-runtime-common?/std",
+	"cumulus-pallet-aura-ext?/std",
+	"cumulus-pallet-dmp-queue?/std",
+	"cumulus-pallet-parachain-system-proc-macro?/std",
+	"cumulus-pallet-parachain-system?/std",
+	"cumulus-pallet-session-benchmarking?/std",
+	"cumulus-pallet-solo-to-para?/std",
+	"cumulus-pallet-xcm?/std",
+	"cumulus-pallet-xcmp-queue?/std",
+	"cumulus-ping?/std",
+	"cumulus-primitives-aura?/std",
+	"cumulus-primitives-core?/std",
+	"cumulus-primitives-parachain-inherent?/std",
+	"cumulus-primitives-proof-size-hostfunction?/std",
+	"cumulus-primitives-storage-weight-reclaim?/std",
+	"cumulus-primitives-timestamp?/std",
+	"cumulus-primitives-utility?/std",
+	"cumulus-test-relay-sproof-builder?/std",
+	"frame-benchmarking-pallet-pov?/std",
+	"frame-benchmarking?/std",
+	"frame-election-provider-support?/std",
+	"frame-executive?/std",
+	"frame-metadata-hash-extension?/std",
+	"frame-support-procedural?/std",
+	"frame-support?/std",
+	"frame-system-benchmarking?/std",
+	"frame-system-rpc-runtime-api?/std",
+	"frame-system?/std",
+	"frame-try-runtime?/std",
+	"pallet-alliance?/std",
+	"pallet-asset-conversion-ops?/std",
+	"pallet-asset-conversion-tx-payment?/std",
+	"pallet-asset-conversion?/std",
+	"pallet-asset-rate?/std",
+	"pallet-asset-tx-payment?/std",
+	"pallet-assets-freezer?/std",
+	"pallet-assets?/std",
+	"pallet-atomic-swap?/std",
+	"pallet-aura?/std",
+	"pallet-authority-discovery?/std",
+	"pallet-authorship?/std",
+	"pallet-babe?/std",
+	"pallet-bags-list?/std",
+	"pallet-balances?/std",
+	"pallet-beefy-mmr?/std",
+	"pallet-beefy?/std",
+	"pallet-bounties?/std",
+	"pallet-bridge-grandpa?/std",
+	"pallet-bridge-messages?/std",
+	"pallet-bridge-parachains?/std",
+	"pallet-bridge-relayers?/std",
+	"pallet-broker?/std",
+	"pallet-child-bounties?/std",
+	"pallet-collator-selection?/std",
+	"pallet-collective-content?/std",
+	"pallet-collective?/std",
+	"pallet-contracts-mock-network?/std",
+	"pallet-contracts?/std",
+	"pallet-conviction-voting?/std",
+	"pallet-core-fellowship?/std",
+	"pallet-delegated-staking?/std",
+	"pallet-democracy?/std",
+	"pallet-dev-mode?/std",
+	"pallet-election-provider-multi-phase?/std",
+	"pallet-election-provider-support-benchmarking?/std",
+	"pallet-elections-phragmen?/std",
+	"pallet-fast-unstake?/std",
+	"pallet-glutton?/std",
+	"pallet-grandpa?/std",
+	"pallet-identity?/std",
+	"pallet-im-online?/std",
+	"pallet-indices?/std",
+	"pallet-insecure-randomness-collective-flip?/std",
+	"pallet-lottery?/std",
+	"pallet-membership?/std",
+	"pallet-message-queue?/std",
+	"pallet-migrations?/std",
+	"pallet-mixnet?/std",
+	"pallet-mmr?/std",
+	"pallet-multisig?/std",
+	"pallet-nft-fractionalization?/std",
+	"pallet-nfts-runtime-api?/std",
+	"pallet-nfts?/std",
+	"pallet-nis?/std",
+	"pallet-node-authorization?/std",
+	"pallet-nomination-pools-benchmarking?/std",
+	"pallet-nomination-pools-runtime-api?/std",
+	"pallet-nomination-pools?/std",
+	"pallet-offences-benchmarking?/std",
+	"pallet-offences?/std",
+	"pallet-paged-list?/std",
+	"pallet-parameters?/std",
+	"pallet-preimage?/std",
+	"pallet-proxy?/std",
+	"pallet-ranked-collective?/std",
+	"pallet-recovery?/std",
+	"pallet-referenda?/std",
+	"pallet-remark?/std",
+	"pallet-root-offences?/std",
+	"pallet-root-testing?/std",
+	"pallet-safe-mode?/std",
+	"pallet-salary?/std",
+	"pallet-scheduler?/std",
+	"pallet-scored-pool?/std",
+	"pallet-session-benchmarking?/std",
+	"pallet-session?/std",
+	"pallet-skip-feeless-payment?/std",
+	"pallet-society?/std",
+	"pallet-staking-reward-fn?/std",
+	"pallet-staking-runtime-api?/std",
+	"pallet-staking?/std",
+	"pallet-state-trie-migration?/std",
+	"pallet-statement?/std",
+	"pallet-sudo?/std",
+	"pallet-timestamp?/std",
+	"pallet-tips?/std",
+	"pallet-transaction-payment-rpc-runtime-api?/std",
+	"pallet-transaction-payment?/std",
+	"pallet-transaction-storage?/std",
+	"pallet-treasury?/std",
+	"pallet-tx-pause?/std",
+	"pallet-uniques?/std",
+	"pallet-utility?/std",
+	"pallet-vesting?/std",
+	"pallet-whitelist?/std",
+	"pallet-xcm-benchmarks?/std",
+	"pallet-xcm-bridge-hub-router?/std",
+	"pallet-xcm-bridge-hub?/std",
+	"pallet-xcm?/std",
+	"parachains-common?/std",
+	"parachains-runtimes-test-utils?/std",
+	"polkadot-core-primitives?/std",
+	"polkadot-parachain-primitives?/std",
+	"polkadot-primitives?/std",
+	"polkadot-runtime-common?/std",
+	"polkadot-runtime-metrics?/std",
+	"polkadot-runtime-parachains?/std",
+	"polkadot-sdk-frame?/std",
+	"rococo-runtime-constants?/std",
+	"sc-executor?/std",
+	"slot-range-helper?/std",
+	"snowbridge-beacon-primitives?/std",
+	"snowbridge-core?/std",
+	"snowbridge-ethereum?/std",
+	"snowbridge-outbound-queue-merkle-tree?/std",
+	"snowbridge-outbound-queue-runtime-api?/std",
+	"snowbridge-pallet-ethereum-client-fixtures?/std",
+	"snowbridge-pallet-ethereum-client?/std",
+	"snowbridge-pallet-inbound-queue-fixtures?/std",
+	"snowbridge-pallet-inbound-queue?/std",
+	"snowbridge-pallet-outbound-queue?/std",
+	"snowbridge-pallet-system?/std",
+	"snowbridge-router-primitives?/std",
+	"snowbridge-runtime-common?/std",
+	"snowbridge-runtime-test-common?/std",
+	"snowbridge-system-runtime-api?/std",
+	"sp-api-proc-macro?/std",
+	"sp-api?/std",
+	"sp-application-crypto?/std",
+	"sp-arithmetic?/std",
+	"sp-authority-discovery?/std",
+	"sp-block-builder?/std",
+	"sp-consensus-aura?/std",
+	"sp-consensus-babe?/std",
+	"sp-consensus-beefy?/std",
+	"sp-consensus-grandpa?/std",
+	"sp-consensus-pow?/std",
+	"sp-consensus-slots?/std",
+	"sp-core-hashing?/std",
+	"sp-core?/std",
+	"sp-crypto-ec-utils?/std",
+	"sp-crypto-hashing?/std",
+	"sp-debug-derive?/std",
+	"sp-externalities?/std",
+	"sp-genesis-builder?/std",
+	"sp-inherents?/std",
+	"sp-io?/std",
+	"sp-keyring?/std",
+	"sp-keystore?/std",
+	"sp-metadata-ir?/std",
+	"sp-mixnet?/std",
+	"sp-mmr-primitives?/std",
+	"sp-npos-elections?/std",
+	"sp-offchain?/std",
+	"sp-runtime-interface?/std",
+	"sp-runtime?/std",
+	"sp-session?/std",
+	"sp-staking?/std",
+	"sp-state-machine?/std",
+	"sp-statement-store?/std",
+	"sp-std?/std",
+	"sp-storage?/std",
+	"sp-timestamp?/std",
+	"sp-tracing?/std",
+	"sp-transaction-pool?/std",
+	"sp-transaction-storage-proof?/std",
+	"sp-trie?/std",
+	"sp-version?/std",
+	"sp-wasm-interface?/std",
+	"sp-weights?/std",
+	"staging-parachain-info?/std",
+	"staging-xcm-builder?/std",
+	"staging-xcm-executor?/std",
+	"staging-xcm?/std",
+	"substrate-bip39?/std",
+	"testnet-parachains-constants?/std",
+	"westend-runtime-constants?/std",
+	"xcm-fee-payment-runtime-api?/std",
+]
+runtime-benchmarks = [
+	"assets-common?/runtime-benchmarks",
+	"bridge-hub-common?/runtime-benchmarks",
+	"bridge-runtime-common?/runtime-benchmarks",
+	"cumulus-pallet-dmp-queue?/runtime-benchmarks",
+	"cumulus-pallet-parachain-system?/runtime-benchmarks",
+	"cumulus-pallet-session-benchmarking?/runtime-benchmarks",
+	"cumulus-pallet-xcmp-queue?/runtime-benchmarks",
+	"cumulus-primitives-core?/runtime-benchmarks",
+	"cumulus-primitives-utility?/runtime-benchmarks",
+	"frame-benchmarking-cli?/runtime-benchmarks",
+	"frame-benchmarking-pallet-pov?/runtime-benchmarks",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support?/runtime-benchmarks",
+	"frame-support?/runtime-benchmarks",
+	"frame-system-benchmarking?/runtime-benchmarks",
+	"frame-system?/runtime-benchmarks",
+	"pallet-alliance?/runtime-benchmarks",
+	"pallet-asset-conversion-ops?/runtime-benchmarks",
+	"pallet-asset-conversion?/runtime-benchmarks",
+	"pallet-asset-rate?/runtime-benchmarks",
+	"pallet-asset-tx-payment?/runtime-benchmarks",
+	"pallet-assets-freezer?/runtime-benchmarks",
+	"pallet-assets?/runtime-benchmarks",
+	"pallet-babe?/runtime-benchmarks",
+	"pallet-bags-list?/runtime-benchmarks",
+	"pallet-balances?/runtime-benchmarks",
+	"pallet-bounties?/runtime-benchmarks",
+	"pallet-bridge-grandpa?/runtime-benchmarks",
+	"pallet-bridge-messages?/runtime-benchmarks",
+	"pallet-bridge-parachains?/runtime-benchmarks",
+	"pallet-bridge-relayers?/runtime-benchmarks",
+	"pallet-broker?/runtime-benchmarks",
+	"pallet-child-bounties?/runtime-benchmarks",
+	"pallet-collator-selection?/runtime-benchmarks",
+	"pallet-collective-content?/runtime-benchmarks",
+	"pallet-collective?/runtime-benchmarks",
+	"pallet-contracts-mock-network?/runtime-benchmarks",
+	"pallet-contracts?/runtime-benchmarks",
+	"pallet-conviction-voting?/runtime-benchmarks",
+	"pallet-core-fellowship?/runtime-benchmarks",
+	"pallet-delegated-staking?/runtime-benchmarks",
+	"pallet-democracy?/runtime-benchmarks",
+	"pallet-election-provider-multi-phase?/runtime-benchmarks",
+	"pallet-election-provider-support-benchmarking?/runtime-benchmarks",
+	"pallet-elections-phragmen?/runtime-benchmarks",
+	"pallet-fast-unstake?/runtime-benchmarks",
+	"pallet-glutton?/runtime-benchmarks",
+	"pallet-grandpa?/runtime-benchmarks",
+	"pallet-identity?/runtime-benchmarks",
+	"pallet-im-online?/runtime-benchmarks",
+	"pallet-indices?/runtime-benchmarks",
+	"pallet-lottery?/runtime-benchmarks",
+	"pallet-membership?/runtime-benchmarks",
+	"pallet-message-queue?/runtime-benchmarks",
+	"pallet-migrations?/runtime-benchmarks",
+	"pallet-mixnet?/runtime-benchmarks",
+	"pallet-mmr?/runtime-benchmarks",
+	"pallet-multisig?/runtime-benchmarks",
+	"pallet-nft-fractionalization?/runtime-benchmarks",
+	"pallet-nfts?/runtime-benchmarks",
+	"pallet-nis?/runtime-benchmarks",
+	"pallet-nomination-pools-benchmarking?/runtime-benchmarks",
+	"pallet-nomination-pools?/runtime-benchmarks",
+	"pallet-offences-benchmarking?/runtime-benchmarks",
+	"pallet-offences?/runtime-benchmarks",
+	"pallet-paged-list?/runtime-benchmarks",
+	"pallet-parameters?/runtime-benchmarks",
+	"pallet-preimage?/runtime-benchmarks",
+	"pallet-proxy?/runtime-benchmarks",
+	"pallet-ranked-collective?/runtime-benchmarks",
+	"pallet-recovery?/runtime-benchmarks",
+	"pallet-referenda?/runtime-benchmarks",
+	"pallet-remark?/runtime-benchmarks",
+	"pallet-root-offences?/runtime-benchmarks",
+	"pallet-safe-mode?/runtime-benchmarks",
+	"pallet-salary?/runtime-benchmarks",
+	"pallet-scheduler?/runtime-benchmarks",
+	"pallet-session-benchmarking?/runtime-benchmarks",
+	"pallet-skip-feeless-payment?/runtime-benchmarks",
+	"pallet-society?/runtime-benchmarks",
+	"pallet-staking?/runtime-benchmarks",
+	"pallet-state-trie-migration?/runtime-benchmarks",
+	"pallet-sudo?/runtime-benchmarks",
+	"pallet-timestamp?/runtime-benchmarks",
+	"pallet-tips?/runtime-benchmarks",
+	"pallet-transaction-storage?/runtime-benchmarks",
+	"pallet-treasury?/runtime-benchmarks",
+	"pallet-tx-pause?/runtime-benchmarks",
+	"pallet-uniques?/runtime-benchmarks",
+	"pallet-utility?/runtime-benchmarks",
+	"pallet-vesting?/runtime-benchmarks",
+	"pallet-whitelist?/runtime-benchmarks",
+	"pallet-xcm-benchmarks?/runtime-benchmarks",
+	"pallet-xcm-bridge-hub-router?/runtime-benchmarks",
+	"pallet-xcm-bridge-hub?/runtime-benchmarks",
+	"pallet-xcm?/runtime-benchmarks",
+	"parachains-common?/runtime-benchmarks",
+	"polkadot-cli?/runtime-benchmarks",
+	"polkadot-node-metrics?/runtime-benchmarks",
+	"polkadot-parachain-primitives?/runtime-benchmarks",
+	"polkadot-primitives?/runtime-benchmarks",
+	"polkadot-runtime-common?/runtime-benchmarks",
+	"polkadot-runtime-parachains?/runtime-benchmarks",
+	"polkadot-sdk-frame?/runtime-benchmarks",
+	"polkadot-service?/runtime-benchmarks",
+	"sc-client-db?/runtime-benchmarks",
+	"sc-service?/runtime-benchmarks",
+	"snowbridge-core?/runtime-benchmarks",
+	"snowbridge-pallet-ethereum-client-fixtures?/runtime-benchmarks",
+	"snowbridge-pallet-ethereum-client?/runtime-benchmarks",
+	"snowbridge-pallet-inbound-queue-fixtures?/runtime-benchmarks",
+	"snowbridge-pallet-inbound-queue?/runtime-benchmarks",
+	"snowbridge-pallet-outbound-queue?/runtime-benchmarks",
+	"snowbridge-pallet-system?/runtime-benchmarks",
+	"snowbridge-router-primitives?/runtime-benchmarks",
+	"snowbridge-runtime-common?/runtime-benchmarks",
+	"snowbridge-runtime-test-common?/runtime-benchmarks",
+	"sp-runtime?/runtime-benchmarks",
+	"sp-staking?/runtime-benchmarks",
+	"staging-node-inspect?/runtime-benchmarks",
+	"staging-xcm-builder?/runtime-benchmarks",
+	"staging-xcm-executor?/runtime-benchmarks",
+	"xcm-fee-payment-runtime-api?/runtime-benchmarks",
+]
+try-runtime = [
+	"cumulus-pallet-aura-ext?/try-runtime",
+	"cumulus-pallet-dmp-queue?/try-runtime",
+	"cumulus-pallet-parachain-system?/try-runtime",
+	"cumulus-pallet-solo-to-para?/try-runtime",
+	"cumulus-pallet-xcm?/try-runtime",
+	"cumulus-pallet-xcmp-queue?/try-runtime",
+	"cumulus-ping?/try-runtime",
+	"frame-benchmarking-pallet-pov?/try-runtime",
+	"frame-election-provider-support?/try-runtime",
+	"frame-executive?/try-runtime",
+	"frame-support?/try-runtime",
+	"frame-system?/try-runtime",
+	"frame-try-runtime/try-runtime",
+	"pallet-alliance?/try-runtime",
+	"pallet-asset-conversion-ops?/try-runtime",
+	"pallet-asset-conversion-tx-payment?/try-runtime",
+	"pallet-asset-conversion?/try-runtime",
+	"pallet-asset-rate?/try-runtime",
+	"pallet-asset-tx-payment?/try-runtime",
+	"pallet-assets-freezer?/try-runtime",
+	"pallet-assets?/try-runtime",
+	"pallet-atomic-swap?/try-runtime",
+	"pallet-aura?/try-runtime",
+	"pallet-authority-discovery?/try-runtime",
+	"pallet-authorship?/try-runtime",
+	"pallet-babe?/try-runtime",
+	"pallet-bags-list?/try-runtime",
+	"pallet-balances?/try-runtime",
+	"pallet-beefy-mmr?/try-runtime",
+	"pallet-beefy?/try-runtime",
+	"pallet-bounties?/try-runtime",
+	"pallet-bridge-grandpa?/try-runtime",
+	"pallet-bridge-messages?/try-runtime",
+	"pallet-bridge-parachains?/try-runtime",
+	"pallet-bridge-relayers?/try-runtime",
+	"pallet-broker?/try-runtime",
+	"pallet-child-bounties?/try-runtime",
+	"pallet-collator-selection?/try-runtime",
+	"pallet-collective-content?/try-runtime",
+	"pallet-collective?/try-runtime",
+	"pallet-contracts?/try-runtime",
+	"pallet-conviction-voting?/try-runtime",
+	"pallet-core-fellowship?/try-runtime",
+	"pallet-delegated-staking?/try-runtime",
+	"pallet-democracy?/try-runtime",
+	"pallet-dev-mode?/try-runtime",
+	"pallet-election-provider-multi-phase?/try-runtime",
+	"pallet-elections-phragmen?/try-runtime",
+	"pallet-fast-unstake?/try-runtime",
+	"pallet-glutton?/try-runtime",
+	"pallet-grandpa?/try-runtime",
+	"pallet-identity?/try-runtime",
+	"pallet-im-online?/try-runtime",
+	"pallet-indices?/try-runtime",
+	"pallet-insecure-randomness-collective-flip?/try-runtime",
+	"pallet-lottery?/try-runtime",
+	"pallet-membership?/try-runtime",
+	"pallet-message-queue?/try-runtime",
+	"pallet-migrations?/try-runtime",
+	"pallet-mixnet?/try-runtime",
+	"pallet-mmr?/try-runtime",
+	"pallet-multisig?/try-runtime",
+	"pallet-nft-fractionalization?/try-runtime",
+	"pallet-nfts?/try-runtime",
+	"pallet-nis?/try-runtime",
+	"pallet-node-authorization?/try-runtime",
+	"pallet-nomination-pools?/try-runtime",
+	"pallet-offences?/try-runtime",
+	"pallet-paged-list?/try-runtime",
+	"pallet-parameters?/try-runtime",
+	"pallet-preimage?/try-runtime",
+	"pallet-proxy?/try-runtime",
+	"pallet-ranked-collective?/try-runtime",
+	"pallet-recovery?/try-runtime",
+	"pallet-referenda?/try-runtime",
+	"pallet-remark?/try-runtime",
+	"pallet-root-offences?/try-runtime",
+	"pallet-root-testing?/try-runtime",
+	"pallet-safe-mode?/try-runtime",
+	"pallet-salary?/try-runtime",
+	"pallet-scheduler?/try-runtime",
+	"pallet-scored-pool?/try-runtime",
+	"pallet-session?/try-runtime",
+	"pallet-skip-feeless-payment?/try-runtime",
+	"pallet-society?/try-runtime",
+	"pallet-staking?/try-runtime",
+	"pallet-state-trie-migration?/try-runtime",
+	"pallet-statement?/try-runtime",
+	"pallet-sudo?/try-runtime",
+	"pallet-timestamp?/try-runtime",
+	"pallet-tips?/try-runtime",
+	"pallet-transaction-payment?/try-runtime",
+	"pallet-transaction-storage?/try-runtime",
+	"pallet-treasury?/try-runtime",
+	"pallet-tx-pause?/try-runtime",
+	"pallet-uniques?/try-runtime",
+	"pallet-utility?/try-runtime",
+	"pallet-vesting?/try-runtime",
+	"pallet-whitelist?/try-runtime",
+	"pallet-xcm-bridge-hub-router?/try-runtime",
+	"pallet-xcm-bridge-hub?/try-runtime",
+	"pallet-xcm?/try-runtime",
+	"polkadot-cli?/try-runtime",
+	"polkadot-runtime-common?/try-runtime",
+	"polkadot-runtime-parachains?/try-runtime",
+	"polkadot-sdk-frame?/try-runtime",
+	"polkadot-service?/try-runtime",
+	"snowbridge-pallet-ethereum-client?/try-runtime",
+	"snowbridge-pallet-inbound-queue?/try-runtime",
+	"snowbridge-pallet-outbound-queue?/try-runtime",
+	"snowbridge-pallet-system?/try-runtime",
+	"sp-runtime?/try-runtime",
+	"staging-parachain-info?/try-runtime",
+]
+serde = [
+	"bp-polkadot-core?/serde",
+	"frame-benchmarking?/serde",
+	"pallet-asset-tx-payment?/serde",
+	"pallet-beefy-mmr?/serde",
+	"pallet-beefy?/serde",
+	"pallet-contracts?/serde",
+	"pallet-conviction-voting?/serde",
+	"pallet-democracy?/serde",
+	"pallet-message-queue?/serde",
+	"pallet-offences?/serde",
+	"pallet-parameters?/serde",
+	"pallet-referenda?/serde",
+	"pallet-remark?/serde",
+	"pallet-state-trie-migration?/serde",
+	"pallet-tips?/serde",
+	"pallet-transaction-payment?/serde",
+	"pallet-transaction-storage?/serde",
+	"pallet-treasury?/serde",
+	"pallet-xcm?/serde",
+	"snowbridge-beacon-primitives?/serde",
+	"snowbridge-core?/serde",
+	"snowbridge-ethereum?/serde",
+	"snowbridge-pallet-ethereum-client?/serde",
+	"snowbridge-pallet-inbound-queue?/serde",
+	"sp-application-crypto?/serde",
+	"sp-arithmetic?/serde",
+	"sp-authority-discovery?/serde",
+	"sp-consensus-aura?/serde",
+	"sp-consensus-babe?/serde",
+	"sp-consensus-beefy?/serde",
+	"sp-consensus-grandpa?/serde",
+	"sp-consensus-slots?/serde",
+	"sp-core?/serde",
+	"sp-mmr-primitives?/serde",
+	"sp-npos-elections?/serde",
+	"sp-runtime?/serde",
+	"sp-staking?/serde",
+	"sp-statement-store?/serde",
+	"sp-storage?/serde",
+	"sp-version?/serde",
+	"sp-weights?/serde",
+]
+experimental = [
+	"frame-support-procedural?/experimental",
+	"frame-support?/experimental",
+	"frame-system?/experimental",
+	"polkadot-sdk-frame?/experimental",
+]
+with-tracing = [
+	"frame-executive?/with-tracing",
+	"frame-executive?/with-tracing",
+	"sp-io?/with-tracing",
+	"sp-io?/with-tracing",
+	"sp-tracing?/with-tracing",
+	"sp-tracing?/with-tracing",
+]
+runtime = ["assets-common", "binary-merkle-tree", "bp-asset-hub-rococo", "bp-asset-hub-westend", "bp-bridge-hub-cumulus", "bp-bridge-hub-kusama", "bp-bridge-hub-polkadot", "bp-bridge-hub-rococo", "bp-bridge-hub-westend", "bp-header-chain", "bp-kusama", "bp-messages", "bp-parachains", "bp-polkadot", "bp-polkadot-bulletin", "bp-polkadot-core", "bp-relayers", "bp-rococo", "bp-runtime", "bp-test-utils", "bp-westend", "bp-xcm-bridge-hub", "bp-xcm-bridge-hub-router", "bridge-hub-common", "bridge-runtime-common", "cumulus-pallet-aura-ext", "cumulus-pallet-dmp-queue", "cumulus-pallet-parachain-system", "cumulus-pallet-parachain-system-proc-macro", "cumulus-pallet-session-benchmarking", "cumulus-pallet-solo-to-para", "cumulus-pallet-xcm", "cumulus-pallet-xcmp-queue", "cumulus-ping", "cumulus-primitives-aura", "cumulus-primitives-core", "cumulus-primitives-parachain-inherent", "cumulus-primitives-proof-size-hostfunction", "cumulus-primitives-storage-weight-reclaim", "cumulus-primitives-timestamp", "cumulus-primitives-utility", "frame-benchmarking", "frame-benchmarking-pallet-pov", "frame-election-provider-solution-type", "frame-election-provider-support", "frame-executive", "frame-metadata-hash-extension", "frame-support", "frame-support-procedural", "frame-support-procedural-tools-derive", "frame-system", "frame-system-benchmarking", "frame-system-rpc-runtime-api", "frame-try-runtime", "pallet-alliance", "pallet-asset-conversion", "pallet-asset-conversion-ops", "pallet-asset-conversion-tx-payment", "pallet-asset-rate", "pallet-asset-tx-payment", "pallet-assets", "pallet-assets-freezer", "pallet-atomic-swap", "pallet-aura", "pallet-authority-discovery", "pallet-authorship", "pallet-babe", "pallet-bags-list", "pallet-balances", "pallet-beefy", "pallet-beefy-mmr", "pallet-bounties", "pallet-bridge-grandpa", "pallet-bridge-messages", "pallet-bridge-parachains", "pallet-bridge-relayers", "pallet-broker", "pallet-child-bounties", "pallet-collator-selection", "pallet-collective", "pallet-collective-content", "pallet-contracts", "pallet-contracts-proc-macro", "pallet-contracts-uapi", "pallet-conviction-voting", "pallet-core-fellowship", "pallet-delegated-staking", "pallet-democracy", "pallet-dev-mode", "pallet-election-provider-multi-phase", "pallet-election-provider-support-benchmarking", "pallet-elections-phragmen", "pallet-fast-unstake", "pallet-glutton", "pallet-grandpa", "pallet-identity", "pallet-im-online", "pallet-indices", "pallet-insecure-randomness-collective-flip", "pallet-lottery", "pallet-membership", "pallet-message-queue", "pallet-migrations", "pallet-mixnet", "pallet-mmr", "pallet-multisig", "pallet-nft-fractionalization", "pallet-nfts", "pallet-nfts-runtime-api", "pallet-nis", "pallet-node-authorization", "pallet-nomination-pools", "pallet-nomination-pools-benchmarking", "pallet-nomination-pools-runtime-api", "pallet-offences", "pallet-offences-benchmarking", "pallet-paged-list", "pallet-parameters", "pallet-preimage", "pallet-proxy", "pallet-ranked-collective", "pallet-recovery", "pallet-referenda", "pallet-remark", "pallet-root-offences", "pallet-root-testing", "pallet-safe-mode", "pallet-salary", "pallet-scheduler", "pallet-scored-pool", "pallet-session", "pallet-session-benchmarking", "pallet-skip-feeless-payment", "pallet-society", "pallet-staking", "pallet-staking-reward-curve", "pallet-staking-reward-fn", "pallet-staking-runtime-api", "pallet-state-trie-migration", "pallet-statement", "pallet-sudo", "pallet-timestamp", "pallet-tips", "pallet-transaction-payment", "pallet-transaction-payment-rpc-runtime-api", "pallet-transaction-storage", "pallet-treasury", "pallet-tx-pause", "pallet-uniques", "pallet-utility", "pallet-vesting", "pallet-whitelist", "pallet-xcm", "pallet-xcm-benchmarks", "pallet-xcm-bridge-hub", "pallet-xcm-bridge-hub-router", "parachains-common", "polkadot-core-primitives", "polkadot-parachain-primitives", "polkadot-primitives", "polkadot-runtime-common", "polkadot-runtime-metrics", "polkadot-runtime-parachains", "polkadot-sdk-frame", "rococo-runtime-constants", "sc-chain-spec-derive", "sc-tracing-proc-macro", "slot-range-helper", "snowbridge-beacon-primitives", "snowbridge-core", "snowbridge-ethereum", "snowbridge-outbound-queue-merkle-tree", "snowbridge-outbound-queue-runtime-api", "snowbridge-pallet-ethereum-client", "snowbridge-pallet-ethereum-client-fixtures", "snowbridge-pallet-inbound-queue", "snowbridge-pallet-inbound-queue-fixtures", "snowbridge-pallet-outbound-queue", "snowbridge-pallet-system", "snowbridge-router-primitives", "snowbridge-runtime-common", "snowbridge-system-runtime-api", "sp-api", "sp-api-proc-macro", "sp-application-crypto", "sp-arithmetic", "sp-authority-discovery", "sp-block-builder", "sp-consensus-aura", "sp-consensus-babe", "sp-consensus-beefy", "sp-consensus-grandpa", "sp-consensus-pow", "sp-consensus-slots", "sp-core", "sp-crypto-ec-utils", "sp-crypto-hashing", "sp-crypto-hashing-proc-macro", "sp-debug-derive", "sp-externalities", "sp-genesis-builder", "sp-inherents", "sp-io", "sp-keyring", "sp-keystore", "sp-metadata-ir", "sp-mixnet", "sp-mmr-primitives", "sp-npos-elections", "sp-offchain", "sp-runtime", "sp-runtime-interface", "sp-runtime-interface-proc-macro", "sp-session", "sp-staking", "sp-state-machine", "sp-statement-store", "sp-std", "sp-storage", "sp-timestamp", "sp-tracing", "sp-transaction-pool", "sp-transaction-storage-proof", "sp-trie", "sp-version", "sp-version-proc-macro", "sp-wasm-interface", "sp-weights", "staging-parachain-info", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", "substrate-bip39", "testnet-parachains-constants", "tracing-gum-proc-macro", "westend-runtime-constants", "xcm-fee-payment-runtime-api", "xcm-procedural"]
+node = ["asset-test-utils", "bridge-hub-test-utils", "cumulus-client-cli", "cumulus-client-collator", "cumulus-client-consensus-aura", "cumulus-client-consensus-common", "cumulus-client-consensus-proposer", "cumulus-client-consensus-relay-chain", "cumulus-client-network", "cumulus-client-parachain-inherent", "cumulus-client-pov-recovery", "cumulus-client-service", "cumulus-relay-chain-inprocess-interface", "cumulus-relay-chain-interface", "cumulus-relay-chain-minimal-node", "cumulus-relay-chain-rpc-interface", "cumulus-test-relay-sproof-builder", "emulated-integration-tests-common", "fork-tree", "frame-benchmarking-cli", "frame-remote-externalities", "frame-support-procedural-tools", "generate-bags", "mmr-gadget", "mmr-rpc", "pallet-contracts-mock-network", "pallet-transaction-payment-rpc", "parachains-runtimes-test-utils", "polkadot-approval-distribution", "polkadot-availability-bitfield-distribution", "polkadot-availability-distribution", "polkadot-availability-recovery", "polkadot-cli", "polkadot-collator-protocol", "polkadot-dispute-distribution", "polkadot-erasure-coding", "polkadot-gossip-support", "polkadot-network-bridge", "polkadot-node-collation-generation", "polkadot-node-core-approval-voting", "polkadot-node-core-av-store", "polkadot-node-core-backing", "polkadot-node-core-bitfield-signing", "polkadot-node-core-candidate-validation", "polkadot-node-core-chain-api", "polkadot-node-core-chain-selection", "polkadot-node-core-dispute-coordinator", "polkadot-node-core-parachains-inherent", "polkadot-node-core-prospective-parachains", "polkadot-node-core-provisioner", "polkadot-node-core-pvf", "polkadot-node-core-pvf-checker", "polkadot-node-core-pvf-common", "polkadot-node-core-pvf-execute-worker", "polkadot-node-core-pvf-prepare-worker", "polkadot-node-core-runtime-api", "polkadot-node-jaeger", "polkadot-node-metrics", "polkadot-node-network-protocol", "polkadot-node-primitives", "polkadot-node-subsystem", "polkadot-node-subsystem-types", "polkadot-node-subsystem-util", "polkadot-overseer", "polkadot-rpc", "polkadot-service", "polkadot-statement-distribution", "polkadot-statement-table", "sc-allocator", "sc-authority-discovery", "sc-basic-authorship", "sc-block-builder", "sc-chain-spec", "sc-cli", "sc-client-api", "sc-client-db", "sc-consensus", "sc-consensus-aura", "sc-consensus-babe", "sc-consensus-babe-rpc", "sc-consensus-beefy", "sc-consensus-beefy-rpc", "sc-consensus-epochs", "sc-consensus-grandpa", "sc-consensus-grandpa-rpc", "sc-consensus-manual-seal", "sc-consensus-pow", "sc-consensus-slots", "sc-executor", "sc-executor-common", "sc-executor-polkavm", "sc-executor-wasmtime", "sc-informant", "sc-keystore", "sc-mixnet", "sc-network", "sc-network-common", "sc-network-gossip", "sc-network-light", "sc-network-statement", "sc-network-sync", "sc-network-transactions", "sc-network-types", "sc-offchain", "sc-proposer-metrics", "sc-rpc", "sc-rpc-api", "sc-rpc-server", "sc-rpc-spec-v2", "sc-service", "sc-state-db", "sc-statement-store", "sc-storage-monitor", "sc-sync-state-rpc", "sc-sysinfo", "sc-telemetry", "sc-tracing", "sc-transaction-pool", "sc-transaction-pool-api", "sc-utils", "snowbridge-runtime-test-common", "sp-blockchain", "sp-consensus", "sp-core-hashing", "sp-core-hashing-proc-macro", "sp-database", "sp-maybe-compressed-blob", "sp-panic-handler", "sp-rpc", "staging-chain-spec-builder", "staging-node-inspect", "staging-tracking-allocator", "std", "subkey", "substrate-build-script-utils", "substrate-frame-rpc-support", "substrate-frame-rpc-system", "substrate-prometheus-endpoint", "substrate-rpc-client", "substrate-state-trie-migration-rpc", "substrate-wasm-builder", "tracing-gum", "xcm-emulator", "xcm-simulator"]
+tuples-96 = [
+	"frame-support-procedural?/tuples-96",
+	"frame-support?/tuples-96",
+]
+
+[package.edition]
+workspace = true
+
+[package.authors]
+workspace = true
+
+[dependencies.assets-common]
+path = "../cumulus/parachains/runtimes/assets/common"
+default-features = false
+optional = true
+
+[dependencies.binary-merkle-tree]
+path = "../substrate/utils/binary-merkle-tree"
+default-features = false
+optional = true
+
+[dependencies.bp-asset-hub-rococo]
+path = "../bridges/chains/chain-asset-hub-rococo"
+default-features = false
+optional = true
+
+[dependencies.bp-asset-hub-westend]
+path = "../bridges/chains/chain-asset-hub-westend"
+default-features = false
+optional = true
+
+[dependencies.bp-bridge-hub-cumulus]
+path = "../bridges/chains/chain-bridge-hub-cumulus"
+default-features = false
+optional = true
+
+[dependencies.bp-bridge-hub-kusama]
+path = "../bridges/chains/chain-bridge-hub-kusama"
+default-features = false
+optional = true
+
+[dependencies.bp-bridge-hub-polkadot]
+path = "../bridges/chains/chain-bridge-hub-polkadot"
+default-features = false
+optional = true
+
+[dependencies.bp-bridge-hub-rococo]
+path = "../bridges/chains/chain-bridge-hub-rococo"
+default-features = false
+optional = true
+
+[dependencies.bp-bridge-hub-westend]
+path = "../bridges/chains/chain-bridge-hub-westend"
+default-features = false
+optional = true
+
+[dependencies.bp-header-chain]
+path = "../bridges/primitives/header-chain"
+default-features = false
+optional = true
+
+[dependencies.bp-kusama]
+path = "../bridges/chains/chain-kusama"
+default-features = false
+optional = true
+
+[dependencies.bp-messages]
+path = "../bridges/primitives/messages"
+default-features = false
+optional = true
+
+[dependencies.bp-parachains]
+path = "../bridges/primitives/parachains"
+default-features = false
+optional = true
+
+[dependencies.bp-polkadot]
+path = "../bridges/chains/chain-polkadot"
+default-features = false
+optional = true
+
+[dependencies.bp-polkadot-bulletin]
+path = "../bridges/chains/chain-polkadot-bulletin"
+default-features = false
+optional = true
+
+[dependencies.bp-polkadot-core]
+path = "../bridges/primitives/polkadot-core"
+default-features = false
+optional = true
+
+[dependencies.bp-relayers]
+path = "../bridges/primitives/relayers"
+default-features = false
+optional = true
+
+[dependencies.bp-rococo]
+path = "../bridges/chains/chain-rococo"
+default-features = false
+optional = true
+
+[dependencies.bp-runtime]
+path = "../bridges/primitives/runtime"
+default-features = false
+optional = true
+
+[dependencies.bp-test-utils]
+path = "../bridges/primitives/test-utils"
+default-features = false
+optional = true
+
+[dependencies.bp-westend]
+path = "../bridges/chains/chain-westend"
+default-features = false
+optional = true
+
+[dependencies.bp-xcm-bridge-hub]
+path = "../bridges/primitives/xcm-bridge-hub"
+default-features = false
+optional = true
+
+[dependencies.bp-xcm-bridge-hub-router]
+path = "../bridges/primitives/xcm-bridge-hub-router"
+default-features = false
+optional = true
+
+[dependencies.bridge-hub-common]
+path = "../cumulus/parachains/runtimes/bridge-hubs/common"
+default-features = false
+optional = true
+
+[dependencies.bridge-runtime-common]
+path = "../bridges/bin/runtime-common"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-aura-ext]
+path = "../cumulus/pallets/aura-ext"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-dmp-queue]
+path = "../cumulus/pallets/dmp-queue"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-parachain-system]
+path = "../cumulus/pallets/parachain-system"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-parachain-system-proc-macro]
+path = "../cumulus/pallets/parachain-system/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-session-benchmarking]
+path = "../cumulus/pallets/session-benchmarking"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-solo-to-para]
+path = "../cumulus/pallets/solo-to-para"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-xcm]
+path = "../cumulus/pallets/xcm"
+default-features = false
+optional = true
+
+[dependencies.cumulus-pallet-xcmp-queue]
+path = "../cumulus/pallets/xcmp-queue"
+default-features = false
+optional = true
+
+[dependencies.cumulus-ping]
+path = "../cumulus/parachains/pallets/ping"
+default-features = false
+optional = true
+
+[dependencies.cumulus-primitives-aura]
+path = "../cumulus/primitives/aura"
+default-features = false
+optional = true
+
+[dependencies.cumulus-primitives-core]
+path = "../cumulus/primitives/core"
+default-features = false
+optional = true
+
+[dependencies.cumulus-primitives-parachain-inherent]
+path = "../cumulus/primitives/parachain-inherent"
+default-features = false
+optional = true
+
+[dependencies.cumulus-primitives-proof-size-hostfunction]
+path = "../cumulus/primitives/proof-size-hostfunction"
+default-features = false
+optional = true
+
+[dependencies.cumulus-primitives-storage-weight-reclaim]
+path = "../cumulus/primitives/storage-weight-reclaim"
+default-features = false
+optional = true
+
+[dependencies.cumulus-primitives-timestamp]
+path = "../cumulus/primitives/timestamp"
+default-features = false
+optional = true
+
+[dependencies.cumulus-primitives-utility]
+path = "../cumulus/primitives/utility"
+default-features = false
+optional = true
+
+[dependencies.frame-benchmarking]
+path = "../substrate/frame/benchmarking"
+default-features = false
+optional = true
+
+[dependencies.frame-benchmarking-pallet-pov]
+path = "../substrate/frame/benchmarking/pov"
+default-features = false
+optional = true
+
+[dependencies.frame-election-provider-solution-type]
+path = "../substrate/frame/election-provider-support/solution-type"
+default-features = false
+optional = true
+
+[dependencies.frame-election-provider-support]
+path = "../substrate/frame/election-provider-support"
+default-features = false
+optional = true
+
+[dependencies.frame-executive]
+path = "../substrate/frame/executive"
+default-features = false
+optional = true
+
+[dependencies.frame-metadata-hash-extension]
+path = "../substrate/frame/metadata-hash-extension"
+default-features = false
+optional = true
+
+[dependencies.frame-support]
+path = "../substrate/frame/support"
+default-features = false
+optional = true
+
+[dependencies.frame-support-procedural]
+path = "../substrate/frame/support/procedural"
+default-features = false
+optional = true
+
+[dependencies.frame-support-procedural-tools-derive]
+path = "../substrate/frame/support/procedural/tools/derive"
+default-features = false
+optional = true
+
+[dependencies.frame-system]
+path = "../substrate/frame/system"
+default-features = false
+optional = true
+
+[dependencies.frame-system-benchmarking]
+path = "../substrate/frame/system/benchmarking"
+default-features = false
+optional = true
+
+[dependencies.frame-system-rpc-runtime-api]
+path = "../substrate/frame/system/rpc/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.frame-try-runtime]
+path = "../substrate/frame/try-runtime"
+default-features = false
+optional = true
+
+[dependencies.pallet-alliance]
+path = "../substrate/frame/alliance"
+default-features = false
+optional = true
+
+[dependencies.pallet-asset-conversion]
+path = "../substrate/frame/asset-conversion"
+default-features = false
+optional = true
+
+[dependencies.pallet-asset-conversion-ops]
+path = "../substrate/frame/asset-conversion/ops"
+default-features = false
+optional = true
+
+[dependencies.pallet-asset-conversion-tx-payment]
+path = "../substrate/frame/transaction-payment/asset-conversion-tx-payment"
+default-features = false
+optional = true
+
+[dependencies.pallet-asset-rate]
+path = "../substrate/frame/asset-rate"
+default-features = false
+optional = true
+
+[dependencies.pallet-asset-tx-payment]
+path = "../substrate/frame/transaction-payment/asset-tx-payment"
+default-features = false
+optional = true
+
+[dependencies.pallet-assets]
+path = "../substrate/frame/assets"
+default-features = false
+optional = true
+
+[dependencies.pallet-assets-freezer]
+path = "../substrate/frame/assets-freezer"
+default-features = false
+optional = true
+
+[dependencies.pallet-atomic-swap]
+path = "../substrate/frame/atomic-swap"
+default-features = false
+optional = true
+
+[dependencies.pallet-aura]
+path = "../substrate/frame/aura"
+default-features = false
+optional = true
+
+[dependencies.pallet-authority-discovery]
+path = "../substrate/frame/authority-discovery"
+default-features = false
+optional = true
+
+[dependencies.pallet-authorship]
+path = "../substrate/frame/authorship"
+default-features = false
+optional = true
+
+[dependencies.pallet-babe]
+path = "../substrate/frame/babe"
+default-features = false
+optional = true
+
+[dependencies.pallet-bags-list]
+path = "../substrate/frame/bags-list"
+default-features = false
+optional = true
+
+[dependencies.pallet-balances]
+path = "../substrate/frame/balances"
+default-features = false
+optional = true
+
+[dependencies.pallet-beefy]
+path = "../substrate/frame/beefy"
+default-features = false
+optional = true
+
+[dependencies.pallet-beefy-mmr]
+path = "../substrate/frame/beefy-mmr"
+default-features = false
+optional = true
+
+[dependencies.pallet-bounties]
+path = "../substrate/frame/bounties"
+default-features = false
+optional = true
+
+[dependencies.pallet-bridge-grandpa]
+path = "../bridges/modules/grandpa"
+default-features = false
+optional = true
+
+[dependencies.pallet-bridge-messages]
+path = "../bridges/modules/messages"
+default-features = false
+optional = true
+
+[dependencies.pallet-bridge-parachains]
+path = "../bridges/modules/parachains"
+default-features = false
+optional = true
+
+[dependencies.pallet-bridge-relayers]
+path = "../bridges/modules/relayers"
+default-features = false
+optional = true
+
+[dependencies.pallet-broker]
+path = "../substrate/frame/broker"
+default-features = false
+optional = true
+
+[dependencies.pallet-child-bounties]
+path = "../substrate/frame/child-bounties"
+default-features = false
+optional = true
+
+[dependencies.pallet-collator-selection]
+path = "../cumulus/pallets/collator-selection"
+default-features = false
+optional = true
+
+[dependencies.pallet-collective]
+path = "../substrate/frame/collective"
+default-features = false
+optional = true
+
+[dependencies.pallet-collective-content]
+path = "../cumulus/parachains/pallets/collective-content"
+default-features = false
+optional = true
+
+[dependencies.pallet-contracts]
+path = "../substrate/frame/contracts"
+default-features = false
+optional = true
+
+[dependencies.pallet-contracts-proc-macro]
+path = "../substrate/frame/contracts/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.pallet-contracts-uapi]
+path = "../substrate/frame/contracts/uapi"
+default-features = false
+optional = true
+
+[dependencies.pallet-conviction-voting]
+path = "../substrate/frame/conviction-voting"
+default-features = false
+optional = true
+
+[dependencies.pallet-core-fellowship]
+path = "../substrate/frame/core-fellowship"
+default-features = false
+optional = true
+
+[dependencies.pallet-delegated-staking]
+path = "../substrate/frame/delegated-staking"
+default-features = false
+optional = true
+
+[dependencies.pallet-democracy]
+path = "../substrate/frame/democracy"
+default-features = false
+optional = true
+
+[dependencies.pallet-dev-mode]
+path = "../substrate/frame/examples/dev-mode"
+default-features = false
+optional = true
+
+[dependencies.pallet-election-provider-multi-phase]
+path = "../substrate/frame/election-provider-multi-phase"
+default-features = false
+optional = true
+
+[dependencies.pallet-election-provider-support-benchmarking]
+path = "../substrate/frame/election-provider-support/benchmarking"
+default-features = false
+optional = true
+
+[dependencies.pallet-elections-phragmen]
+path = "../substrate/frame/elections-phragmen"
+default-features = false
+optional = true
+
+[dependencies.pallet-fast-unstake]
+path = "../substrate/frame/fast-unstake"
+default-features = false
+optional = true
+
+[dependencies.pallet-glutton]
+path = "../substrate/frame/glutton"
+default-features = false
+optional = true
+
+[dependencies.pallet-grandpa]
+path = "../substrate/frame/grandpa"
+default-features = false
+optional = true
+
+[dependencies.pallet-identity]
+path = "../substrate/frame/identity"
+default-features = false
+optional = true
+
+[dependencies.pallet-im-online]
+path = "../substrate/frame/im-online"
+default-features = false
+optional = true
+
+[dependencies.pallet-indices]
+path = "../substrate/frame/indices"
+default-features = false
+optional = true
+
+[dependencies.pallet-insecure-randomness-collective-flip]
+path = "../substrate/frame/insecure-randomness-collective-flip"
+default-features = false
+optional = true
+
+[dependencies.pallet-lottery]
+path = "../substrate/frame/lottery"
+default-features = false
+optional = true
+
+[dependencies.pallet-membership]
+path = "../substrate/frame/membership"
+default-features = false
+optional = true
+
+[dependencies.pallet-message-queue]
+path = "../substrate/frame/message-queue"
+default-features = false
+optional = true
+
+[dependencies.pallet-migrations]
+path = "../substrate/frame/migrations"
+default-features = false
+optional = true
+
+[dependencies.pallet-mixnet]
+path = "../substrate/frame/mixnet"
+default-features = false
+optional = true
+
+[dependencies.pallet-mmr]
+path = "../substrate/frame/merkle-mountain-range"
+default-features = false
+optional = true
+
+[dependencies.pallet-multisig]
+path = "../substrate/frame/multisig"
+default-features = false
+optional = true
+
+[dependencies.pallet-nft-fractionalization]
+path = "../substrate/frame/nft-fractionalization"
+default-features = false
+optional = true
+
+[dependencies.pallet-nfts]
+path = "../substrate/frame/nfts"
+default-features = false
+optional = true
+
+[dependencies.pallet-nfts-runtime-api]
+path = "../substrate/frame/nfts/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.pallet-nis]
+path = "../substrate/frame/nis"
+default-features = false
+optional = true
+
+[dependencies.pallet-node-authorization]
+path = "../substrate/frame/node-authorization"
+default-features = false
+optional = true
+
+[dependencies.pallet-nomination-pools]
+path = "../substrate/frame/nomination-pools"
+default-features = false
+optional = true
+
+[dependencies.pallet-nomination-pools-benchmarking]
+path = "../substrate/frame/nomination-pools/benchmarking"
+default-features = false
+optional = true
+
+[dependencies.pallet-nomination-pools-runtime-api]
+path = "../substrate/frame/nomination-pools/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.pallet-offences]
+path = "../substrate/frame/offences"
+default-features = false
+optional = true
+
+[dependencies.pallet-offences-benchmarking]
+path = "../substrate/frame/offences/benchmarking"
+default-features = false
+optional = true
+
+[dependencies.pallet-paged-list]
+path = "../substrate/frame/paged-list"
+default-features = false
+optional = true
+
+[dependencies.pallet-parameters]
+path = "../substrate/frame/parameters"
+default-features = false
+optional = true
+
+[dependencies.pallet-preimage]
+path = "../substrate/frame/preimage"
+default-features = false
+optional = true
+
+[dependencies.pallet-proxy]
+path = "../substrate/frame/proxy"
+default-features = false
+optional = true
+
+[dependencies.pallet-ranked-collective]
+path = "../substrate/frame/ranked-collective"
+default-features = false
+optional = true
+
+[dependencies.pallet-recovery]
+path = "../substrate/frame/recovery"
+default-features = false
+optional = true
+
+[dependencies.pallet-referenda]
+path = "../substrate/frame/referenda"
+default-features = false
+optional = true
+
+[dependencies.pallet-remark]
+path = "../substrate/frame/remark"
+default-features = false
+optional = true
+
+[dependencies.pallet-root-offences]
+path = "../substrate/frame/root-offences"
+default-features = false
+optional = true
+
+[dependencies.pallet-root-testing]
+path = "../substrate/frame/root-testing"
+default-features = false
+optional = true
+
+[dependencies.pallet-safe-mode]
+path = "../substrate/frame/safe-mode"
+default-features = false
+optional = true
+
+[dependencies.pallet-salary]
+path = "../substrate/frame/salary"
+default-features = false
+optional = true
+
+[dependencies.pallet-scheduler]
+path = "../substrate/frame/scheduler"
+default-features = false
+optional = true
+
+[dependencies.pallet-scored-pool]
+path = "../substrate/frame/scored-pool"
+default-features = false
+optional = true
+
+[dependencies.pallet-session]
+path = "../substrate/frame/session"
+default-features = false
+optional = true
+
+[dependencies.pallet-session-benchmarking]
+path = "../substrate/frame/session/benchmarking"
+default-features = false
+optional = true
+
+[dependencies.pallet-skip-feeless-payment]
+path = "../substrate/frame/transaction-payment/skip-feeless-payment"
+default-features = false
+optional = true
+
+[dependencies.pallet-society]
+path = "../substrate/frame/society"
+default-features = false
+optional = true
+
+[dependencies.pallet-staking]
+path = "../substrate/frame/staking"
+default-features = false
+optional = true
+
+[dependencies.pallet-staking-reward-curve]
+path = "../substrate/frame/staking/reward-curve"
+default-features = false
+optional = true
+
+[dependencies.pallet-staking-reward-fn]
+path = "../substrate/frame/staking/reward-fn"
+default-features = false
+optional = true
+
+[dependencies.pallet-staking-runtime-api]
+path = "../substrate/frame/staking/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.pallet-state-trie-migration]
+path = "../substrate/frame/state-trie-migration"
+default-features = false
+optional = true
+
+[dependencies.pallet-statement]
+path = "../substrate/frame/statement"
+default-features = false
+optional = true
+
+[dependencies.pallet-sudo]
+path = "../substrate/frame/sudo"
+default-features = false
+optional = true
+
+[dependencies.pallet-timestamp]
+path = "../substrate/frame/timestamp"
+default-features = false
+optional = true
+
+[dependencies.pallet-tips]
+path = "../substrate/frame/tips"
+default-features = false
+optional = true
+
+[dependencies.pallet-transaction-payment]
+path = "../substrate/frame/transaction-payment"
+default-features = false
+optional = true
+
+[dependencies.pallet-transaction-payment-rpc-runtime-api]
+path = "../substrate/frame/transaction-payment/rpc/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.pallet-transaction-storage]
+path = "../substrate/frame/transaction-storage"
+default-features = false
+optional = true
+
+[dependencies.pallet-treasury]
+path = "../substrate/frame/treasury"
+default-features = false
+optional = true
+
+[dependencies.pallet-tx-pause]
+path = "../substrate/frame/tx-pause"
+default-features = false
+optional = true
+
+[dependencies.pallet-uniques]
+path = "../substrate/frame/uniques"
+default-features = false
+optional = true
+
+[dependencies.pallet-utility]
+path = "../substrate/frame/utility"
+default-features = false
+optional = true
+
+[dependencies.pallet-vesting]
+path = "../substrate/frame/vesting"
+default-features = false
+optional = true
+
+[dependencies.pallet-whitelist]
+path = "../substrate/frame/whitelist"
+default-features = false
+optional = true
+
+[dependencies.pallet-xcm]
+path = "../polkadot/xcm/pallet-xcm"
+default-features = false
+optional = true
+
+[dependencies.pallet-xcm-benchmarks]
+path = "../polkadot/xcm/pallet-xcm-benchmarks"
+default-features = false
+optional = true
+
+[dependencies.pallet-xcm-bridge-hub]
+path = "../bridges/modules/xcm-bridge-hub"
+default-features = false
+optional = true
+
+[dependencies.pallet-xcm-bridge-hub-router]
+path = "../bridges/modules/xcm-bridge-hub-router"
+default-features = false
+optional = true
+
+[dependencies.parachains-common]
+path = "../cumulus/parachains/common"
+default-features = false
+optional = true
+
+[dependencies.polkadot-core-primitives]
+path = "../polkadot/core-primitives"
+default-features = false
+optional = true
+
+[dependencies.polkadot-parachain-primitives]
+path = "../polkadot/parachain"
+default-features = false
+optional = true
+
+[dependencies.polkadot-primitives]
+path = "../polkadot/primitives"
+default-features = false
+optional = true
+
+[dependencies.polkadot-runtime-common]
+path = "../polkadot/runtime/common"
+default-features = false
+optional = true
+
+[dependencies.polkadot-runtime-metrics]
+path = "../polkadot/runtime/metrics"
+default-features = false
+optional = true
+
+[dependencies.polkadot-runtime-parachains]
+path = "../polkadot/runtime/parachains"
+default-features = false
+optional = true
+
+[dependencies.polkadot-sdk-frame]
+path = "../substrate/frame"
+default-features = false
+optional = true
+
+[dependencies.rococo-runtime-constants]
+path = "../polkadot/runtime/rococo/constants"
+default-features = false
+optional = true
+
+[dependencies.sc-chain-spec-derive]
+path = "../substrate/client/chain-spec/derive"
+default-features = false
+optional = true
+
+[dependencies.sc-tracing-proc-macro]
+path = "../substrate/client/tracing/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.slot-range-helper]
+path = "../polkadot/runtime/common/slot_range_helper"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-beacon-primitives]
+path = "../bridges/snowbridge/primitives/beacon"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-core]
+path = "../bridges/snowbridge/primitives/core"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-ethereum]
+path = "../bridges/snowbridge/primitives/ethereum"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-outbound-queue-merkle-tree]
+path = "../bridges/snowbridge/pallets/outbound-queue/merkle-tree"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-outbound-queue-runtime-api]
+path = "../bridges/snowbridge/pallets/outbound-queue/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-pallet-ethereum-client]
+path = "../bridges/snowbridge/pallets/ethereum-client"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-pallet-ethereum-client-fixtures]
+path = "../bridges/snowbridge/pallets/ethereum-client/fixtures"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-pallet-inbound-queue]
+path = "../bridges/snowbridge/pallets/inbound-queue"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-pallet-inbound-queue-fixtures]
+path = "../bridges/snowbridge/pallets/inbound-queue/fixtures"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-pallet-outbound-queue]
+path = "../bridges/snowbridge/pallets/outbound-queue"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-pallet-system]
+path = "../bridges/snowbridge/pallets/system"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-router-primitives]
+path = "../bridges/snowbridge/primitives/router"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-runtime-common]
+path = "../bridges/snowbridge/runtime/runtime-common"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-system-runtime-api]
+path = "../bridges/snowbridge/pallets/system/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.sp-api]
+path = "../substrate/primitives/api"
+default-features = false
+optional = true
+
+[dependencies.sp-api-proc-macro]
+path = "../substrate/primitives/api/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.sp-application-crypto]
+path = "../substrate/primitives/application-crypto"
+default-features = false
+optional = true
+
+[dependencies.sp-arithmetic]
+path = "../substrate/primitives/arithmetic"
+default-features = false
+optional = true
+
+[dependencies.sp-authority-discovery]
+path = "../substrate/primitives/authority-discovery"
+default-features = false
+optional = true
+
+[dependencies.sp-block-builder]
+path = "../substrate/primitives/block-builder"
+default-features = false
+optional = true
+
+[dependencies.sp-consensus-aura]
+path = "../substrate/primitives/consensus/aura"
+default-features = false
+optional = true
+
+[dependencies.sp-consensus-babe]
+path = "../substrate/primitives/consensus/babe"
+default-features = false
+optional = true
+
+[dependencies.sp-consensus-beefy]
+path = "../substrate/primitives/consensus/beefy"
+default-features = false
+optional = true
+
+[dependencies.sp-consensus-grandpa]
+path = "../substrate/primitives/consensus/grandpa"
+default-features = false
+optional = true
+
+[dependencies.sp-consensus-pow]
+path = "../substrate/primitives/consensus/pow"
+default-features = false
+optional = true
+
+[dependencies.sp-consensus-slots]
+path = "../substrate/primitives/consensus/slots"
+default-features = false
+optional = true
+
+[dependencies.sp-core]
+path = "../substrate/primitives/core"
+default-features = false
+optional = true
+
+[dependencies.sp-crypto-ec-utils]
+path = "../substrate/primitives/crypto/ec-utils"
+default-features = false
+optional = true
+
+[dependencies.sp-crypto-hashing]
+path = "../substrate/primitives/crypto/hashing"
+default-features = false
+optional = true
+
+[dependencies.sp-crypto-hashing-proc-macro]
+path = "../substrate/primitives/crypto/hashing/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.sp-debug-derive]
+path = "../substrate/primitives/debug-derive"
+default-features = false
+optional = true
+
+[dependencies.sp-externalities]
+path = "../substrate/primitives/externalities"
+default-features = false
+optional = true
+
+[dependencies.sp-genesis-builder]
+path = "../substrate/primitives/genesis-builder"
+default-features = false
+optional = true
+
+[dependencies.sp-inherents]
+path = "../substrate/primitives/inherents"
+default-features = false
+optional = true
+
+[dependencies.sp-io]
+path = "../substrate/primitives/io"
+default-features = false
+optional = true
+
+[dependencies.sp-keyring]
+path = "../substrate/primitives/keyring"
+default-features = false
+optional = true
+
+[dependencies.sp-keystore]
+path = "../substrate/primitives/keystore"
+default-features = false
+optional = true
+
+[dependencies.sp-metadata-ir]
+path = "../substrate/primitives/metadata-ir"
+default-features = false
+optional = true
+
+[dependencies.sp-mixnet]
+path = "../substrate/primitives/mixnet"
+default-features = false
+optional = true
+
+[dependencies.sp-mmr-primitives]
+path = "../substrate/primitives/merkle-mountain-range"
+default-features = false
+optional = true
+
+[dependencies.sp-npos-elections]
+path = "../substrate/primitives/npos-elections"
+default-features = false
+optional = true
+
+[dependencies.sp-offchain]
+path = "../substrate/primitives/offchain"
+default-features = false
+optional = true
+
+[dependencies.sp-runtime]
+path = "../substrate/primitives/runtime"
+default-features = false
+optional = true
+
+[dependencies.sp-runtime-interface]
+path = "../substrate/primitives/runtime-interface"
+default-features = false
+optional = true
+
+[dependencies.sp-runtime-interface-proc-macro]
+path = "../substrate/primitives/runtime-interface/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.sp-session]
+path = "../substrate/primitives/session"
+default-features = false
+optional = true
+
+[dependencies.sp-staking]
+path = "../substrate/primitives/staking"
+default-features = false
+optional = true
+
+[dependencies.sp-state-machine]
+path = "../substrate/primitives/state-machine"
+default-features = false
+optional = true
+
+[dependencies.sp-statement-store]
+path = "../substrate/primitives/statement-store"
+default-features = false
+optional = true
+
+[dependencies.sp-std]
+path = "../substrate/primitives/std"
+default-features = false
+optional = true
+
+[dependencies.sp-storage]
+path = "../substrate/primitives/storage"
+default-features = false
+optional = true
+
+[dependencies.sp-timestamp]
+path = "../substrate/primitives/timestamp"
+default-features = false
+optional = true
+
+[dependencies.sp-tracing]
+path = "../substrate/primitives/tracing"
+default-features = false
+optional = true
+
+[dependencies.sp-transaction-pool]
+path = "../substrate/primitives/transaction-pool"
+default-features = false
+optional = true
+
+[dependencies.sp-transaction-storage-proof]
+path = "../substrate/primitives/transaction-storage-proof"
+default-features = false
+optional = true
+
+[dependencies.sp-trie]
+path = "../substrate/primitives/trie"
+default-features = false
+optional = true
+
+[dependencies.sp-version]
+path = "../substrate/primitives/version"
+default-features = false
+optional = true
+
+[dependencies.sp-version-proc-macro]
+path = "../substrate/primitives/version/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.sp-wasm-interface]
+path = "../substrate/primitives/wasm-interface"
+default-features = false
+optional = true
+
+[dependencies.sp-weights]
+path = "../substrate/primitives/weights"
+default-features = false
+optional = true
+
+[dependencies.staging-parachain-info]
+path = "../cumulus/parachains/pallets/parachain-info"
+default-features = false
+optional = true
+
+[dependencies.staging-xcm]
+path = "../polkadot/xcm"
+default-features = false
+optional = true
+
+[dependencies.staging-xcm-builder]
+path = "../polkadot/xcm/xcm-builder"
+default-features = false
+optional = true
+
+[dependencies.staging-xcm-executor]
+path = "../polkadot/xcm/xcm-executor"
+default-features = false
+optional = true
+
+[dependencies.substrate-bip39]
+path = "../substrate/utils/substrate-bip39"
+default-features = false
+optional = true
+
+[dependencies.testnet-parachains-constants]
+path = "../cumulus/parachains/runtimes/constants"
+default-features = false
+optional = true
+
+[dependencies.tracing-gum-proc-macro]
+path = "../polkadot/node/gum/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.westend-runtime-constants]
+path = "../polkadot/runtime/westend/constants"
+default-features = false
+optional = true
+
+[dependencies.xcm-fee-payment-runtime-api]
+path = "../polkadot/xcm/xcm-fee-payment-runtime-api"
+default-features = false
+optional = true
+
+[dependencies.xcm-procedural]
+path = "../polkadot/xcm/procedural"
+default-features = false
+optional = true
+
+[dependencies.asset-test-utils]
+path = "../cumulus/parachains/runtimes/assets/test-utils"
+default-features = false
+optional = true
+
+[dependencies.bridge-hub-test-utils]
+path = "../cumulus/parachains/runtimes/bridge-hubs/test-utils"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-cli]
+path = "../cumulus/client/cli"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-collator]
+path = "../cumulus/client/collator"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-consensus-aura]
+path = "../cumulus/client/consensus/aura"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-consensus-common]
+path = "../cumulus/client/consensus/common"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-consensus-proposer]
+path = "../cumulus/client/consensus/proposer"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-consensus-relay-chain]
+path = "../cumulus/client/consensus/relay-chain"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-network]
+path = "../cumulus/client/network"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-parachain-inherent]
+path = "../cumulus/client/parachain-inherent"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-pov-recovery]
+path = "../cumulus/client/pov-recovery"
+default-features = false
+optional = true
+
+[dependencies.cumulus-client-service]
+path = "../cumulus/client/service"
+default-features = false
+optional = true
+
+[dependencies.cumulus-relay-chain-inprocess-interface]
+path = "../cumulus/client/relay-chain-inprocess-interface"
+default-features = false
+optional = true
+
+[dependencies.cumulus-relay-chain-interface]
+path = "../cumulus/client/relay-chain-interface"
+default-features = false
+optional = true
+
+[dependencies.cumulus-relay-chain-minimal-node]
+path = "../cumulus/client/relay-chain-minimal-node"
+default-features = false
+optional = true
+
+[dependencies.cumulus-relay-chain-rpc-interface]
+path = "../cumulus/client/relay-chain-rpc-interface"
+default-features = false
+optional = true
+
+[dependencies.cumulus-test-relay-sproof-builder]
+path = "../cumulus/test/relay-sproof-builder"
+default-features = false
+optional = true
+
+[dependencies.emulated-integration-tests-common]
+path = "../cumulus/parachains/integration-tests/emulated/common"
+default-features = false
+optional = true
+
+[dependencies.fork-tree]
+path = "../substrate/utils/fork-tree"
+default-features = false
+optional = true
+
+[dependencies.frame-benchmarking-cli]
+path = "../substrate/utils/frame/benchmarking-cli"
+default-features = false
+optional = true
+
+[dependencies.frame-remote-externalities]
+path = "../substrate/utils/frame/remote-externalities"
+default-features = false
+optional = true
+
+[dependencies.frame-support-procedural-tools]
+path = "../substrate/frame/support/procedural/tools"
+default-features = false
+optional = true
+
+[dependencies.generate-bags]
+path = "../substrate/utils/frame/generate-bags"
+default-features = false
+optional = true
+
+[dependencies.mmr-gadget]
+path = "../substrate/client/merkle-mountain-range"
+default-features = false
+optional = true
+
+[dependencies.mmr-rpc]
+path = "../substrate/client/merkle-mountain-range/rpc"
+default-features = false
+optional = true
+
+[dependencies.pallet-contracts-mock-network]
+path = "../substrate/frame/contracts/mock-network"
+default-features = false
+optional = true
+
+[dependencies.pallet-transaction-payment-rpc]
+path = "../substrate/frame/transaction-payment/rpc"
+default-features = false
+optional = true
+
+[dependencies.parachains-runtimes-test-utils]
+path = "../cumulus/parachains/runtimes/test-utils"
+default-features = false
+optional = true
+
+[dependencies.polkadot-approval-distribution]
+path = "../polkadot/node/network/approval-distribution"
+default-features = false
+optional = true
+
+[dependencies.polkadot-availability-bitfield-distribution]
+path = "../polkadot/node/network/bitfield-distribution"
+default-features = false
+optional = true
+
+[dependencies.polkadot-availability-distribution]
+path = "../polkadot/node/network/availability-distribution"
+default-features = false
+optional = true
+
+[dependencies.polkadot-availability-recovery]
+path = "../polkadot/node/network/availability-recovery"
+default-features = false
+optional = true
+
+[dependencies.polkadot-cli]
+path = "../polkadot/cli"
+default-features = false
+optional = true
+
+[dependencies.polkadot-collator-protocol]
+path = "../polkadot/node/network/collator-protocol"
+default-features = false
+optional = true
+
+[dependencies.polkadot-dispute-distribution]
+path = "../polkadot/node/network/dispute-distribution"
+default-features = false
+optional = true
+
+[dependencies.polkadot-erasure-coding]
+path = "../polkadot/erasure-coding"
+default-features = false
+optional = true
+
+[dependencies.polkadot-gossip-support]
+path = "../polkadot/node/network/gossip-support"
+default-features = false
+optional = true
+
+[dependencies.polkadot-network-bridge]
+path = "../polkadot/node/network/bridge"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-collation-generation]
+path = "../polkadot/node/collation-generation"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-approval-voting]
+path = "../polkadot/node/core/approval-voting"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-av-store]
+path = "../polkadot/node/core/av-store"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-backing]
+path = "../polkadot/node/core/backing"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-bitfield-signing]
+path = "../polkadot/node/core/bitfield-signing"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-candidate-validation]
+path = "../polkadot/node/core/candidate-validation"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-chain-api]
+path = "../polkadot/node/core/chain-api"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-chain-selection]
+path = "../polkadot/node/core/chain-selection"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-dispute-coordinator]
+path = "../polkadot/node/core/dispute-coordinator"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-parachains-inherent]
+path = "../polkadot/node/core/parachains-inherent"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-prospective-parachains]
+path = "../polkadot/node/core/prospective-parachains"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-provisioner]
+path = "../polkadot/node/core/provisioner"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-pvf]
+path = "../polkadot/node/core/pvf"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-pvf-checker]
+path = "../polkadot/node/core/pvf-checker"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-pvf-common]
+path = "../polkadot/node/core/pvf/common"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-pvf-execute-worker]
+path = "../polkadot/node/core/pvf/execute-worker"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-pvf-prepare-worker]
+path = "../polkadot/node/core/pvf/prepare-worker"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-core-runtime-api]
+path = "../polkadot/node/core/runtime-api"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-jaeger]
+path = "../polkadot/node/jaeger"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-metrics]
+path = "../polkadot/node/metrics"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-network-protocol]
+path = "../polkadot/node/network/protocol"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-primitives]
+path = "../polkadot/node/primitives"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-subsystem]
+path = "../polkadot/node/subsystem"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-subsystem-types]
+path = "../polkadot/node/subsystem-types"
+default-features = false
+optional = true
+
+[dependencies.polkadot-node-subsystem-util]
+path = "../polkadot/node/subsystem-util"
+default-features = false
+optional = true
+
+[dependencies.polkadot-overseer]
+path = "../polkadot/node/overseer"
+default-features = false
+optional = true
+
+[dependencies.polkadot-rpc]
+path = "../polkadot/rpc"
+default-features = false
+optional = true
+
+[dependencies.polkadot-service]
+path = "../polkadot/node/service"
+default-features = false
+optional = true
+
+[dependencies.polkadot-statement-distribution]
+path = "../polkadot/node/network/statement-distribution"
+default-features = false
+optional = true
+
+[dependencies.polkadot-statement-table]
+path = "../polkadot/statement-table"
+default-features = false
+optional = true
+
+[dependencies.sc-allocator]
+path = "../substrate/client/allocator"
+default-features = false
+optional = true
+
+[dependencies.sc-authority-discovery]
+path = "../substrate/client/authority-discovery"
+default-features = false
+optional = true
+
+[dependencies.sc-basic-authorship]
+path = "../substrate/client/basic-authorship"
+default-features = false
+optional = true
+
+[dependencies.sc-block-builder]
+path = "../substrate/client/block-builder"
+default-features = false
+optional = true
+
+[dependencies.sc-chain-spec]
+path = "../substrate/client/chain-spec"
+default-features = false
+optional = true
+
+[dependencies.sc-cli]
+path = "../substrate/client/cli"
+default-features = false
+optional = true
+
+[dependencies.sc-client-api]
+path = "../substrate/client/api"
+default-features = false
+optional = true
+
+[dependencies.sc-client-db]
+path = "../substrate/client/db"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus]
+path = "../substrate/client/consensus/common"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-aura]
+path = "../substrate/client/consensus/aura"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-babe]
+path = "../substrate/client/consensus/babe"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-babe-rpc]
+path = "../substrate/client/consensus/babe/rpc"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-beefy]
+path = "../substrate/client/consensus/beefy"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-beefy-rpc]
+path = "../substrate/client/consensus/beefy/rpc"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-epochs]
+path = "../substrate/client/consensus/epochs"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-grandpa]
+path = "../substrate/client/consensus/grandpa"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-grandpa-rpc]
+path = "../substrate/client/consensus/grandpa/rpc"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-manual-seal]
+path = "../substrate/client/consensus/manual-seal"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-pow]
+path = "../substrate/client/consensus/pow"
+default-features = false
+optional = true
+
+[dependencies.sc-consensus-slots]
+path = "../substrate/client/consensus/slots"
+default-features = false
+optional = true
+
+[dependencies.sc-executor]
+path = "../substrate/client/executor"
+default-features = false
+optional = true
+
+[dependencies.sc-executor-common]
+path = "../substrate/client/executor/common"
+default-features = false
+optional = true
+
+[dependencies.sc-executor-polkavm]
+path = "../substrate/client/executor/polkavm"
+default-features = false
+optional = true
+
+[dependencies.sc-executor-wasmtime]
+path = "../substrate/client/executor/wasmtime"
+default-features = false
+optional = true
+
+[dependencies.sc-informant]
+path = "../substrate/client/informant"
+default-features = false
+optional = true
+
+[dependencies.sc-keystore]
+path = "../substrate/client/keystore"
+default-features = false
+optional = true
+
+[dependencies.sc-mixnet]
+path = "../substrate/client/mixnet"
+default-features = false
+optional = true
+
+[dependencies.sc-network]
+path = "../substrate/client/network"
+default-features = false
+optional = true
+
+[dependencies.sc-network-common]
+path = "../substrate/client/network/common"
+default-features = false
+optional = true
+
+[dependencies.sc-network-gossip]
+path = "../substrate/client/network-gossip"
+default-features = false
+optional = true
+
+[dependencies.sc-network-light]
+path = "../substrate/client/network/light"
+default-features = false
+optional = true
+
+[dependencies.sc-network-statement]
+path = "../substrate/client/network/statement"
+default-features = false
+optional = true
+
+[dependencies.sc-network-sync]
+path = "../substrate/client/network/sync"
+default-features = false
+optional = true
+
+[dependencies.sc-network-transactions]
+path = "../substrate/client/network/transactions"
+default-features = false
+optional = true
+
+[dependencies.sc-network-types]
+path = "../substrate/client/network/types"
+default-features = false
+optional = true
+
+[dependencies.sc-offchain]
+path = "../substrate/client/offchain"
+default-features = false
+optional = true
+
+[dependencies.sc-proposer-metrics]
+path = "../substrate/client/proposer-metrics"
+default-features = false
+optional = true
+
+[dependencies.sc-rpc]
+path = "../substrate/client/rpc"
+default-features = false
+optional = true
+
+[dependencies.sc-rpc-api]
+path = "../substrate/client/rpc-api"
+default-features = false
+optional = true
+
+[dependencies.sc-rpc-server]
+path = "../substrate/client/rpc-servers"
+default-features = false
+optional = true
+
+[dependencies.sc-rpc-spec-v2]
+path = "../substrate/client/rpc-spec-v2"
+default-features = false
+optional = true
+
+[dependencies.sc-service]
+path = "../substrate/client/service"
+default-features = false
+optional = true
+
+[dependencies.sc-state-db]
+path = "../substrate/client/state-db"
+default-features = false
+optional = true
+
+[dependencies.sc-statement-store]
+path = "../substrate/client/statement-store"
+default-features = false
+optional = true
+
+[dependencies.sc-storage-monitor]
+path = "../substrate/client/storage-monitor"
+default-features = false
+optional = true
+
+[dependencies.sc-sync-state-rpc]
+path = "../substrate/client/sync-state-rpc"
+default-features = false
+optional = true
+
+[dependencies.sc-sysinfo]
+path = "../substrate/client/sysinfo"
+default-features = false
+optional = true
+
+[dependencies.sc-telemetry]
+path = "../substrate/client/telemetry"
+default-features = false
+optional = true
+
+[dependencies.sc-tracing]
+path = "../substrate/client/tracing"
+default-features = false
+optional = true
+
+[dependencies.sc-transaction-pool]
+path = "../substrate/client/transaction-pool"
+default-features = false
+optional = true
+
+[dependencies.sc-transaction-pool-api]
+path = "../substrate/client/transaction-pool/api"
+default-features = false
+optional = true
+
+[dependencies.sc-utils]
+path = "../substrate/client/utils"
+default-features = false
+optional = true
+
+[dependencies.snowbridge-runtime-test-common]
+path = "../bridges/snowbridge/runtime/test-common"
+default-features = false
+optional = true
+
+[dependencies.sp-blockchain]
+path = "../substrate/primitives/blockchain"
+default-features = false
+optional = true
+
+[dependencies.sp-consensus]
+path = "../substrate/primitives/consensus/common"
+default-features = false
+optional = true
+
+[dependencies.sp-core-hashing]
+path = "../substrate/deprecated/hashing"
+default-features = false
+optional = true
+
+[dependencies.sp-core-hashing-proc-macro]
+path = "../substrate/deprecated/hashing/proc-macro"
+default-features = false
+optional = true
+
+[dependencies.sp-database]
+path = "../substrate/primitives/database"
+default-features = false
+optional = true
+
+[dependencies.sp-maybe-compressed-blob]
+path = "../substrate/primitives/maybe-compressed-blob"
+default-features = false
+optional = true
+
+[dependencies.sp-panic-handler]
+path = "../substrate/primitives/panic-handler"
+default-features = false
+optional = true
+
+[dependencies.sp-rpc]
+path = "../substrate/primitives/rpc"
+default-features = false
+optional = true
+
+[dependencies.staging-chain-spec-builder]
+path = "../substrate/bin/utils/chain-spec-builder"
+default-features = false
+optional = true
+
+[dependencies.staging-node-inspect]
+path = "../substrate/bin/node/inspect"
+default-features = false
+optional = true
+
+[dependencies.staging-tracking-allocator]
+path = "../polkadot/node/tracking-allocator"
+default-features = false
+optional = true
+
+[dependencies.subkey]
+path = "../substrate/bin/utils/subkey"
+default-features = false
+optional = true
+
+[dependencies.substrate-build-script-utils]
+path = "../substrate/utils/build-script-utils"
+default-features = false
+optional = true
+
+[dependencies.substrate-frame-rpc-support]
+path = "../substrate/utils/frame/rpc/support"
+default-features = false
+optional = true
+
+[dependencies.substrate-frame-rpc-system]
+path = "../substrate/utils/frame/rpc/system"
+default-features = false
+optional = true
+
+[dependencies.substrate-prometheus-endpoint]
+path = "../substrate/utils/prometheus"
+default-features = false
+optional = true
+
+[dependencies.substrate-rpc-client]
+path = "../substrate/utils/frame/rpc/client"
+default-features = false
+optional = true
+
+[dependencies.substrate-state-trie-migration-rpc]
+path = "../substrate/utils/frame/rpc/state-trie-migration-rpc"
+default-features = false
+optional = true
+
+[dependencies.substrate-wasm-builder]
+path = "../substrate/utils/wasm-builder"
+default-features = false
+optional = true
+
+[dependencies.tracing-gum]
+path = "../polkadot/node/gum"
+default-features = false
+optional = true
+
+[dependencies.xcm-emulator]
+path = "../cumulus/xcm/xcm-emulator"
+default-features = false
+optional = true
+
+[dependencies.xcm-simulator]
+path = "../polkadot/xcm/xcm-simulator"
+default-features = false
+optional = true
+
+[package.metadata.docs.rs]
+features = ["node", "runtime"]
+targets = ["x86_64-unknown-linux-gnu"]
diff --git a/umbrella/src/lib.rs b/umbrella/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..87fcd4214dbc0b7a0466814b7047cd26b57685b7
--- /dev/null
+++ b/umbrella/src/lib.rs
@@ -0,0 +1,1573 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+//! Polkadot SDK umbrella crate re-exporting all other published crates.
+//!
+//! This helps to set a single version number for all your dependencies. Docs are in the
+//! `polkadot-sdk-docs` crate.
+
+// This file is auto-generated and checked by the CI.  You can edit it manually, but it must be
+// exactly the way that the CI expects it.
+
+/// Test utils for Asset Hub runtimes.
+#[cfg(feature = "asset-test-utils")]
+pub use asset_test_utils;
+
+/// Assets common utilities.
+#[cfg(feature = "assets-common")]
+pub use assets_common;
+
+/// A no-std/Substrate compatible library to construct binary merkle tree.
+#[cfg(feature = "binary-merkle-tree")]
+pub use binary_merkle_tree;
+
+/// Primitives of AssetHubRococo parachain runtime.
+#[cfg(feature = "bp-asset-hub-rococo")]
+pub use bp_asset_hub_rococo;
+
+/// Primitives of AssetHubWestend parachain runtime.
+#[cfg(feature = "bp-asset-hub-westend")]
+pub use bp_asset_hub_westend;
+
+/// Primitives for BridgeHub parachain runtimes.
+#[cfg(feature = "bp-bridge-hub-cumulus")]
+pub use bp_bridge_hub_cumulus;
+
+/// Primitives of BridgeHubKusama parachain runtime.
+#[cfg(feature = "bp-bridge-hub-kusama")]
+pub use bp_bridge_hub_kusama;
+
+/// Primitives of BridgeHubPolkadot parachain runtime.
+#[cfg(feature = "bp-bridge-hub-polkadot")]
+pub use bp_bridge_hub_polkadot;
+
+/// Primitives of BridgeHubRococo parachain runtime.
+#[cfg(feature = "bp-bridge-hub-rococo")]
+pub use bp_bridge_hub_rococo;
+
+/// Primitives of BridgeHubWestend parachain runtime.
+#[cfg(feature = "bp-bridge-hub-westend")]
+pub use bp_bridge_hub_westend;
+
+/// A common interface for describing what a bridge pallet should be able to do.
+#[cfg(feature = "bp-header-chain")]
+pub use bp_header_chain;
+
+/// Primitives of Kusama runtime.
+#[cfg(feature = "bp-kusama")]
+pub use bp_kusama;
+
+/// Primitives of messages module.
+#[cfg(feature = "bp-messages")]
+pub use bp_messages;
+
+/// Primitives of parachains module.
+#[cfg(feature = "bp-parachains")]
+pub use bp_parachains;
+
+/// Primitives of Polkadot runtime.
+#[cfg(feature = "bp-polkadot")]
+pub use bp_polkadot;
+
+/// Primitives of Polkadot Bulletin chain runtime.
+#[cfg(feature = "bp-polkadot-bulletin")]
+pub use bp_polkadot_bulletin;
+
+/// Primitives of Polkadot-like runtime.
+#[cfg(feature = "bp-polkadot-core")]
+pub use bp_polkadot_core;
+
+/// Primitives of relayers module.
+#[cfg(feature = "bp-relayers")]
+pub use bp_relayers;
+
+/// Primitives of Rococo runtime.
+#[cfg(feature = "bp-rococo")]
+pub use bp_rococo;
+
+/// Primitives that may be used at (bridges) runtime level.
+#[cfg(feature = "bp-runtime")]
+pub use bp_runtime;
+
+/// Utilities for testing substrate-based runtime bridge code.
+#[cfg(feature = "bp-test-utils")]
+pub use bp_test_utils;
+
+/// Primitives of Westend runtime.
+#[cfg(feature = "bp-westend")]
+pub use bp_westend;
+
+/// Primitives of the xcm-bridge-hub pallet.
+#[cfg(feature = "bp-xcm-bridge-hub")]
+pub use bp_xcm_bridge_hub;
+
+/// Primitives of the xcm-bridge-hub fee pallet.
+#[cfg(feature = "bp-xcm-bridge-hub-router")]
+pub use bp_xcm_bridge_hub_router;
+
+/// Bridge hub common utilities.
+#[cfg(feature = "bridge-hub-common")]
+pub use bridge_hub_common;
+
+/// Utils for BridgeHub testing.
+#[cfg(feature = "bridge-hub-test-utils")]
+pub use bridge_hub_test_utils;
+
+/// Common types and functions that may be used by substrate-based runtimes of all bridged
+/// chains.
+#[cfg(feature = "bridge-runtime-common")]
+pub use bridge_runtime_common;
+
+/// Parachain node CLI utilities.
+#[cfg(feature = "cumulus-client-cli")]
+pub use cumulus_client_cli;
+
+/// Common node-side functionality and glue code to collate parachain blocks.
+#[cfg(feature = "cumulus-client-collator")]
+pub use cumulus_client_collator;
+
+/// AURA consensus algorithm for parachains.
+#[cfg(feature = "cumulus-client-consensus-aura")]
+pub use cumulus_client_consensus_aura;
+
+/// Cumulus specific common consensus implementations.
+#[cfg(feature = "cumulus-client-consensus-common")]
+pub use cumulus_client_consensus_common;
+
+/// A Substrate `Proposer` for building parachain blocks.
+#[cfg(feature = "cumulus-client-consensus-proposer")]
+pub use cumulus_client_consensus_proposer;
+
+/// The relay-chain provided consensus algorithm.
+#[cfg(feature = "cumulus-client-consensus-relay-chain")]
+pub use cumulus_client_consensus_relay_chain;
+
+/// Cumulus-specific networking protocol.
+#[cfg(feature = "cumulus-client-network")]
+pub use cumulus_client_network;
+
+/// Inherent that needs to be present in every parachain block. Contains messages and a relay
+/// chain storage-proof.
+#[cfg(feature = "cumulus-client-parachain-inherent")]
+pub use cumulus_client_parachain_inherent;
+
+/// Cumulus-specific networking protocol.
+#[cfg(feature = "cumulus-client-pov-recovery")]
+pub use cumulus_client_pov_recovery;
+
+/// Common functions used to assemble the components of a parachain node.
+#[cfg(feature = "cumulus-client-service")]
+pub use cumulus_client_service;
+
+/// AURA consensus extension pallet for parachains.
+#[cfg(feature = "cumulus-pallet-aura-ext")]
+pub use cumulus_pallet_aura_ext;
+
+/// Migrates messages from the old DMP queue pallet.
+#[cfg(feature = "cumulus-pallet-dmp-queue")]
+pub use cumulus_pallet_dmp_queue;
+
+/// Base pallet for cumulus-based parachains.
+#[cfg(feature = "cumulus-pallet-parachain-system")]
+pub use cumulus_pallet_parachain_system;
+
+/// Proc macros provided by the parachain-system pallet.
+#[cfg(feature = "cumulus-pallet-parachain-system-proc-macro")]
+pub use cumulus_pallet_parachain_system_proc_macro;
+
+/// FRAME sessions pallet benchmarking.
+#[cfg(feature = "cumulus-pallet-session-benchmarking")]
+pub use cumulus_pallet_session_benchmarking;
+
+/// Adds functionality to migrate from a Solo to a Parachain.
+#[cfg(feature = "cumulus-pallet-solo-to-para")]
+pub use cumulus_pallet_solo_to_para;
+
+/// Pallet for stuff specific to parachains' usage of XCM.
+#[cfg(feature = "cumulus-pallet-xcm")]
+pub use cumulus_pallet_xcm;
+
+/// Pallet to queue outbound and inbound XCMP messages.
+#[cfg(feature = "cumulus-pallet-xcmp-queue")]
+pub use cumulus_pallet_xcmp_queue;
+
+/// Ping Pallet for Cumulus XCM/UMP testing.
+#[cfg(feature = "cumulus-ping")]
+pub use cumulus_ping;
+
+/// Core primitives for Aura in Cumulus.
+#[cfg(feature = "cumulus-primitives-aura")]
+pub use cumulus_primitives_aura;
+
+/// Cumulus related core primitive types and traits.
+#[cfg(feature = "cumulus-primitives-core")]
+pub use cumulus_primitives_core;
+
+/// Inherent that needs to be present in every parachain block. Contains messages and a relay
+/// chain storage-proof.
+#[cfg(feature = "cumulus-primitives-parachain-inherent")]
+pub use cumulus_primitives_parachain_inherent;
+
+/// Hostfunction exposing storage proof size to the runtime.
+#[cfg(feature = "cumulus-primitives-proof-size-hostfunction")]
+pub use cumulus_primitives_proof_size_hostfunction;
+
+/// Utilities to reclaim storage weight.
+#[cfg(feature = "cumulus-primitives-storage-weight-reclaim")]
+pub use cumulus_primitives_storage_weight_reclaim;
+
+/// Provides timestamp related functionality for parachains.
+#[cfg(feature = "cumulus-primitives-timestamp")]
+pub use cumulus_primitives_timestamp;
+
+/// Helper datatypes for Cumulus.
+#[cfg(feature = "cumulus-primitives-utility")]
+pub use cumulus_primitives_utility;
+
+/// Implementation of the RelayChainInterface trait for Polkadot full-nodes.
+#[cfg(feature = "cumulus-relay-chain-inprocess-interface")]
+pub use cumulus_relay_chain_inprocess_interface;
+
+/// Common interface for different relay chain datasources.
+#[cfg(feature = "cumulus-relay-chain-interface")]
+pub use cumulus_relay_chain_interface;
+
+/// Minimal node implementation to be used in tandem with RPC or light-client mode.
+#[cfg(feature = "cumulus-relay-chain-minimal-node")]
+pub use cumulus_relay_chain_minimal_node;
+
+/// Implementation of the RelayChainInterface trait that connects to a remote RPC-node.
+#[cfg(feature = "cumulus-relay-chain-rpc-interface")]
+pub use cumulus_relay_chain_rpc_interface;
+
+/// Mocked relay state proof builder for testing Cumulus.
+#[cfg(feature = "cumulus-test-relay-sproof-builder")]
+pub use cumulus_test_relay_sproof_builder;
+
+/// Common resources for integration testing with xcm-emulator.
+#[cfg(feature = "emulated-integration-tests-common")]
+pub use emulated_integration_tests_common;
+
+/// Utility library for managing tree-like ordered data with logic for pruning the tree while
+/// finalizing nodes.
+#[cfg(feature = "fork-tree")]
+pub use fork_tree;
+
+/// Macro for benchmarking a FRAME runtime.
+#[cfg(feature = "frame-benchmarking")]
+pub use frame_benchmarking;
+
+/// CLI for benchmarking FRAME.
+#[cfg(feature = "frame-benchmarking-cli")]
+pub use frame_benchmarking_cli;
+
+/// Pallet for testing FRAME PoV benchmarking.
+#[cfg(feature = "frame-benchmarking-pallet-pov")]
+pub use frame_benchmarking_pallet_pov;
+
+/// NPoS Solution Type.
+#[cfg(feature = "frame-election-provider-solution-type")]
+pub use frame_election_provider_solution_type;
+
+/// election provider supporting traits.
+#[cfg(feature = "frame-election-provider-support")]
+pub use frame_election_provider_support;
+
+/// FRAME executives engine.
+#[cfg(feature = "frame-executive")]
+pub use frame_executive;
+
+/// FRAME signed extension for verifying the metadata hash.
+#[cfg(feature = "frame-metadata-hash-extension")]
+pub use frame_metadata_hash_extension;
+
+/// An externalities provided environment that can load itself from remote nodes or cached
+/// files.
+#[cfg(feature = "frame-remote-externalities")]
+pub use frame_remote_externalities;
+
+/// Support code for the runtime.
+#[cfg(feature = "frame-support")]
+pub use frame_support;
+
+/// Proc macro of Support code for the runtime.
+#[cfg(feature = "frame-support-procedural")]
+pub use frame_support_procedural;
+
+/// Proc macro helpers for procedural macros.
+#[cfg(feature = "frame-support-procedural-tools")]
+pub use frame_support_procedural_tools;
+
+/// Use to derive parsing for parsing struct.
+#[cfg(feature = "frame-support-procedural-tools-derive")]
+pub use frame_support_procedural_tools_derive;
+
+/// FRAME system module.
+#[cfg(feature = "frame-system")]
+pub use frame_system;
+
+/// FRAME System benchmarking.
+#[cfg(feature = "frame-system-benchmarking")]
+pub use frame_system_benchmarking;
+
+/// Runtime API definition required by System RPC extensions.
+#[cfg(feature = "frame-system-rpc-runtime-api")]
+pub use frame_system_rpc_runtime_api;
+
+/// FRAME pallet for democracy.
+#[cfg(feature = "frame-try-runtime")]
+pub use frame_try_runtime;
+
+/// Bag threshold generation script for pallet-bag-list.
+#[cfg(feature = "generate-bags")]
+pub use generate_bags;
+
+/// MMR Client gadget for substrate.
+#[cfg(feature = "mmr-gadget")]
+pub use mmr_gadget;
+
+/// Node-specific RPC methods for interaction with Merkle Mountain Range pallet.
+#[cfg(feature = "mmr-rpc")]
+pub use mmr_rpc;
+
+/// The Alliance pallet provides a collective for standard-setting industry collaboration.
+#[cfg(feature = "pallet-alliance")]
+pub use pallet_alliance;
+
+/// FRAME asset conversion pallet.
+#[cfg(feature = "pallet-asset-conversion")]
+pub use pallet_asset_conversion;
+
+/// FRAME asset conversion pallet's operations suite.
+#[cfg(feature = "pallet-asset-conversion-ops")]
+pub use pallet_asset_conversion_ops;
+
+/// Pallet to manage transaction payments in assets by converting them to native assets.
+#[cfg(feature = "pallet-asset-conversion-tx-payment")]
+pub use pallet_asset_conversion_tx_payment;
+
+/// Whitelist non-native assets for treasury spending and provide conversion to native balance.
+#[cfg(feature = "pallet-asset-rate")]
+pub use pallet_asset_rate;
+
+/// pallet to manage transaction payments in assets.
+#[cfg(feature = "pallet-asset-tx-payment")]
+pub use pallet_asset_tx_payment;
+
+/// FRAME asset management pallet.
+#[cfg(feature = "pallet-assets")]
+pub use pallet_assets;
+
+/// Provides freezing features to `pallet-assets`.
+#[cfg(feature = "pallet-assets-freezer")]
+pub use pallet_assets_freezer;
+
+/// FRAME atomic swap pallet.
+#[cfg(feature = "pallet-atomic-swap")]
+pub use pallet_atomic_swap;
+
+/// FRAME AURA consensus pallet.
+#[cfg(feature = "pallet-aura")]
+pub use pallet_aura;
+
+/// FRAME pallet for authority discovery.
+#[cfg(feature = "pallet-authority-discovery")]
+pub use pallet_authority_discovery;
+
+/// Block and Uncle Author tracking for the FRAME.
+#[cfg(feature = "pallet-authorship")]
+pub use pallet_authorship;
+
+/// Consensus extension module for BABE consensus. Collects on-chain randomness from VRF
+/// outputs and manages epoch transitions.
+#[cfg(feature = "pallet-babe")]
+pub use pallet_babe;
+
+/// FRAME pallet bags list.
+#[cfg(feature = "pallet-bags-list")]
+pub use pallet_bags_list;
+
+/// FRAME pallet to manage balances.
+#[cfg(feature = "pallet-balances")]
+pub use pallet_balances;
+
+/// BEEFY FRAME pallet.
+#[cfg(feature = "pallet-beefy")]
+pub use pallet_beefy;
+
+/// BEEFY + MMR runtime utilities.
+#[cfg(feature = "pallet-beefy-mmr")]
+pub use pallet_beefy_mmr;
+
+/// FRAME pallet to manage bounties.
+#[cfg(feature = "pallet-bounties")]
+pub use pallet_bounties;
+
+/// Module implementing GRANDPA on-chain light client used for bridging consensus of
+/// substrate-based chains.
+#[cfg(feature = "pallet-bridge-grandpa")]
+pub use pallet_bridge_grandpa;
+
+/// Module that allows bridged chains to exchange messages using lane concept.
+#[cfg(feature = "pallet-bridge-messages")]
+pub use pallet_bridge_messages;
+
+/// Module that allows bridged relay chains to exchange information on their parachains' heads.
+#[cfg(feature = "pallet-bridge-parachains")]
+pub use pallet_bridge_parachains;
+
+/// Module used to store relayer rewards and coordinate relayers set.
+#[cfg(feature = "pallet-bridge-relayers")]
+pub use pallet_bridge_relayers;
+
+/// Brokerage tool for managing Polkadot Core scheduling.
+#[cfg(feature = "pallet-broker")]
+pub use pallet_broker;
+
+/// FRAME pallet to manage child bounties.
+#[cfg(feature = "pallet-child-bounties")]
+pub use pallet_child_bounties;
+
+/// Simple pallet to select collators for a parachain.
+#[cfg(feature = "pallet-collator-selection")]
+pub use pallet_collator_selection;
+
+/// Collective system: Members of a set of account IDs can make their collective feelings known
+/// through dispatched calls from one of two specialized origins.
+#[cfg(feature = "pallet-collective")]
+pub use pallet_collective;
+
+/// Managed content.
+#[cfg(feature = "pallet-collective-content")]
+pub use pallet_collective_content;
+
+/// FRAME pallet for WASM contracts.
+#[cfg(feature = "pallet-contracts")]
+pub use pallet_contracts;
+
+/// A mock network for testing pallet-contracts.
+#[cfg(feature = "pallet-contracts-mock-network")]
+pub use pallet_contracts_mock_network;
+
+/// Procedural macros used in pallet_contracts.
+#[cfg(feature = "pallet-contracts-proc-macro")]
+pub use pallet_contracts_proc_macro;
+
+/// Exposes all the host functions that a contract can import.
+#[cfg(feature = "pallet-contracts-uapi")]
+pub use pallet_contracts_uapi;
+
+/// FRAME pallet for conviction voting in referenda.
+#[cfg(feature = "pallet-conviction-voting")]
+pub use pallet_conviction_voting;
+
+/// Logic as per the description of The Fellowship for core Polkadot technology.
+#[cfg(feature = "pallet-core-fellowship")]
+pub use pallet_core_fellowship;
+
+/// FRAME delegated staking pallet.
+#[cfg(feature = "pallet-delegated-staking")]
+pub use pallet_delegated_staking;
+
+/// FRAME pallet for democracy.
+#[cfg(feature = "pallet-democracy")]
+pub use pallet_democracy;
+
+/// FRAME example pallet.
+#[cfg(feature = "pallet-dev-mode")]
+pub use pallet_dev_mode;
+
+/// PALLET two phase election providers.
+#[cfg(feature = "pallet-election-provider-multi-phase")]
+pub use pallet_election_provider_multi_phase;
+
+/// Benchmarking for election provider support onchain config trait.
+#[cfg(feature = "pallet-election-provider-support-benchmarking")]
+pub use pallet_election_provider_support_benchmarking;
+
+/// FRAME pallet based on seq-Phragmén election method.
+#[cfg(feature = "pallet-elections-phragmen")]
+pub use pallet_elections_phragmen;
+
+/// FRAME fast unstake pallet.
+#[cfg(feature = "pallet-fast-unstake")]
+pub use pallet_fast_unstake;
+
+/// FRAME pallet for pushing a chain to its weight limits.
+#[cfg(feature = "pallet-glutton")]
+pub use pallet_glutton;
+
+/// FRAME pallet for GRANDPA finality gadget.
+#[cfg(feature = "pallet-grandpa")]
+pub use pallet_grandpa;
+
+/// FRAME identity management pallet.
+#[cfg(feature = "pallet-identity")]
+pub use pallet_identity;
+
+/// FRAME's I'm online pallet.
+#[cfg(feature = "pallet-im-online")]
+pub use pallet_im_online;
+
+/// FRAME indices management pallet.
+#[cfg(feature = "pallet-indices")]
+pub use pallet_indices;
+
+/// Insecure do not use in production: FRAME randomness collective flip pallet.
+#[cfg(feature = "pallet-insecure-randomness-collective-flip")]
+pub use pallet_insecure_randomness_collective_flip;
+
+/// FRAME Participation Lottery Pallet.
+#[cfg(feature = "pallet-lottery")]
+pub use pallet_lottery;
+
+/// FRAME membership management pallet.
+#[cfg(feature = "pallet-membership")]
+pub use pallet_membership;
+
+/// FRAME pallet to queue and process messages.
+#[cfg(feature = "pallet-message-queue")]
+pub use pallet_message_queue;
+
+/// FRAME pallet to execute multi-block migrations.
+#[cfg(feature = "pallet-migrations")]
+pub use pallet_migrations;
+
+/// FRAME's mixnet pallet.
+#[cfg(feature = "pallet-mixnet")]
+pub use pallet_mixnet;
+
+/// FRAME Merkle Mountain Range pallet.
+#[cfg(feature = "pallet-mmr")]
+pub use pallet_mmr;
+
+/// FRAME multi-signature dispatch pallet.
+#[cfg(feature = "pallet-multisig")]
+pub use pallet_multisig;
+
+/// FRAME pallet to convert non-fungible to fungible tokens.
+#[cfg(feature = "pallet-nft-fractionalization")]
+pub use pallet_nft_fractionalization;
+
+/// FRAME NFTs pallet.
+#[cfg(feature = "pallet-nfts")]
+pub use pallet_nfts;
+
+/// Runtime API for the FRAME NFTs pallet.
+#[cfg(feature = "pallet-nfts-runtime-api")]
+pub use pallet_nfts_runtime_api;
+
+/// FRAME pallet for rewarding account freezing.
+#[cfg(feature = "pallet-nis")]
+pub use pallet_nis;
+
+/// FRAME pallet for node authorization.
+#[cfg(feature = "pallet-node-authorization")]
+pub use pallet_node_authorization;
+
+/// FRAME nomination pools pallet.
+#[cfg(feature = "pallet-nomination-pools")]
+pub use pallet_nomination_pools;
+
+/// FRAME nomination pools pallet benchmarking.
+#[cfg(feature = "pallet-nomination-pools-benchmarking")]
+pub use pallet_nomination_pools_benchmarking;
+
+/// Runtime API for nomination-pools FRAME pallet.
+#[cfg(feature = "pallet-nomination-pools-runtime-api")]
+pub use pallet_nomination_pools_runtime_api;
+
+/// FRAME offences pallet.
+#[cfg(feature = "pallet-offences")]
+pub use pallet_offences;
+
+/// FRAME offences pallet benchmarking.
+#[cfg(feature = "pallet-offences-benchmarking")]
+pub use pallet_offences_benchmarking;
+
+/// FRAME pallet that provides a paged list data structure.
+#[cfg(feature = "pallet-paged-list")]
+pub use pallet_paged_list;
+
+/// Pallet to store and configure parameters.
+#[cfg(feature = "pallet-parameters")]
+pub use pallet_parameters;
+
+/// FRAME pallet for storing preimages of hashes.
+#[cfg(feature = "pallet-preimage")]
+pub use pallet_preimage;
+
+/// FRAME proxying pallet.
+#[cfg(feature = "pallet-proxy")]
+pub use pallet_proxy;
+
+/// Ranked collective system: Members of a set of account IDs can make their collective
+/// feelings known through dispatched calls from one of two specialized origins.
+#[cfg(feature = "pallet-ranked-collective")]
+pub use pallet_ranked_collective;
+
+/// FRAME account recovery pallet.
+#[cfg(feature = "pallet-recovery")]
+pub use pallet_recovery;
+
+/// FRAME pallet for inclusive on-chain decisions.
+#[cfg(feature = "pallet-referenda")]
+pub use pallet_referenda;
+
+/// Remark storage pallet.
+#[cfg(feature = "pallet-remark")]
+pub use pallet_remark;
+
+/// FRAME root offences pallet.
+#[cfg(feature = "pallet-root-offences")]
+pub use pallet_root_offences;
+
+/// FRAME root testing pallet.
+#[cfg(feature = "pallet-root-testing")]
+pub use pallet_root_testing;
+
+/// FRAME safe-mode pallet.
+#[cfg(feature = "pallet-safe-mode")]
+pub use pallet_safe_mode;
+
+/// Paymaster.
+#[cfg(feature = "pallet-salary")]
+pub use pallet_salary;
+
+/// FRAME Scheduler pallet.
+#[cfg(feature = "pallet-scheduler")]
+pub use pallet_scheduler;
+
+/// FRAME pallet for scored pools.
+#[cfg(feature = "pallet-scored-pool")]
+pub use pallet_scored_pool;
+
+/// FRAME sessions pallet.
+#[cfg(feature = "pallet-session")]
+pub use pallet_session;
+
+/// FRAME sessions pallet benchmarking.
+#[cfg(feature = "pallet-session-benchmarking")]
+pub use pallet_session_benchmarking;
+
+/// Pallet to skip payments for calls annotated with `feeless_if` if the respective conditions
+/// are satisfied.
+#[cfg(feature = "pallet-skip-feeless-payment")]
+pub use pallet_skip_feeless_payment;
+
+/// FRAME society pallet.
+#[cfg(feature = "pallet-society")]
+pub use pallet_society;
+
+/// FRAME pallet staking.
+#[cfg(feature = "pallet-staking")]
+pub use pallet_staking;
+
+/// Reward Curve for FRAME staking pallet.
+#[cfg(feature = "pallet-staking-reward-curve")]
+pub use pallet_staking_reward_curve;
+
+/// Reward function for FRAME staking pallet.
+#[cfg(feature = "pallet-staking-reward-fn")]
+pub use pallet_staking_reward_fn;
+
+/// RPC runtime API for transaction payment FRAME pallet.
+#[cfg(feature = "pallet-staking-runtime-api")]
+pub use pallet_staking_runtime_api;
+
+/// FRAME pallet migration of trie.
+#[cfg(feature = "pallet-state-trie-migration")]
+pub use pallet_state_trie_migration;
+
+/// FRAME pallet for statement store.
+#[cfg(feature = "pallet-statement")]
+pub use pallet_statement;
+
+/// FRAME pallet for sudo.
+#[cfg(feature = "pallet-sudo")]
+pub use pallet_sudo;
+
+/// FRAME Timestamp Module.
+#[cfg(feature = "pallet-timestamp")]
+pub use pallet_timestamp;
+
+/// FRAME pallet to manage tips.
+#[cfg(feature = "pallet-tips")]
+pub use pallet_tips;
+
+/// FRAME pallet to manage transaction payments.
+#[cfg(feature = "pallet-transaction-payment")]
+pub use pallet_transaction_payment;
+
+/// RPC interface for the transaction payment pallet.
+#[cfg(feature = "pallet-transaction-payment-rpc")]
+pub use pallet_transaction_payment_rpc;
+
+/// RPC runtime API for transaction payment FRAME pallet.
+#[cfg(feature = "pallet-transaction-payment-rpc-runtime-api")]
+pub use pallet_transaction_payment_rpc_runtime_api;
+
+/// Storage chain pallet.
+#[cfg(feature = "pallet-transaction-storage")]
+pub use pallet_transaction_storage;
+
+/// FRAME pallet to manage treasury.
+#[cfg(feature = "pallet-treasury")]
+pub use pallet_treasury;
+
+/// FRAME transaction pause pallet.
+#[cfg(feature = "pallet-tx-pause")]
+pub use pallet_tx_pause;
+
+/// FRAME NFT asset management pallet.
+#[cfg(feature = "pallet-uniques")]
+pub use pallet_uniques;
+
+/// FRAME utilities pallet.
+#[cfg(feature = "pallet-utility")]
+pub use pallet_utility;
+
+/// FRAME pallet for manage vesting.
+#[cfg(feature = "pallet-vesting")]
+pub use pallet_vesting;
+
+/// FRAME pallet for whitelisting call, and dispatch from specific origin.
+#[cfg(feature = "pallet-whitelist")]
+pub use pallet_whitelist;
+
+/// A pallet for handling XCM programs.
+#[cfg(feature = "pallet-xcm")]
+pub use pallet_xcm;
+
+/// Benchmarks for the XCM pallet.
+#[cfg(feature = "pallet-xcm-benchmarks")]
+pub use pallet_xcm_benchmarks;
+
+/// Module that adds dynamic bridges/lanes support to XCM infrastructure at the bridge hub.
+#[cfg(feature = "pallet-xcm-bridge-hub")]
+pub use pallet_xcm_bridge_hub;
+
+/// Bridge hub interface for sibling/parent chains with dynamic fees support.
+#[cfg(feature = "pallet-xcm-bridge-hub-router")]
+pub use pallet_xcm_bridge_hub_router;
+
+/// Logic which is common to all parachain runtimes.
+#[cfg(feature = "parachains-common")]
+pub use parachains_common;
+
+/// Utils for Runtimes testing.
+#[cfg(feature = "parachains-runtimes-test-utils")]
+pub use parachains_runtimes_test_utils;
+
+/// Polkadot Approval Distribution subsystem for the distribution of assignments and approvals
+/// for approval checks on candidates over the network.
+#[cfg(feature = "polkadot-approval-distribution")]
+pub use polkadot_approval_distribution;
+
+/// Polkadot Bitfiled Distribution subsystem, which gossips signed availability bitfields used
+/// to compactly determine which backed candidates are available or not based on a 2/3+ quorum.
+#[cfg(feature = "polkadot-availability-bitfield-distribution")]
+pub use polkadot_availability_bitfield_distribution;
+
+/// The Availability Distribution subsystem. Requests the required availability data. Also
+/// distributes availability data and chunks to requesters.
+#[cfg(feature = "polkadot-availability-distribution")]
+pub use polkadot_availability_distribution;
+
+/// The Availability Recovery subsystem. Handles requests for recovering the availability data
+/// of included candidates.
+#[cfg(feature = "polkadot-availability-recovery")]
+pub use polkadot_availability_recovery;
+
+/// Polkadot Relay-chain Client Node.
+#[cfg(feature = "polkadot-cli")]
+pub use polkadot_cli;
+
+/// Polkadot Collator Protocol subsystem. Allows collators and validators to talk to each
+/// other.
+#[cfg(feature = "polkadot-collator-protocol")]
+pub use polkadot_collator_protocol;
+
+/// Core Polkadot types used by Relay Chains and parachains.
+#[cfg(feature = "polkadot-core-primitives")]
+pub use polkadot_core_primitives;
+
+/// Polkadot Dispute Distribution subsystem, which ensures all concerned validators are aware
+/// of a dispute and have the relevant votes.
+#[cfg(feature = "polkadot-dispute-distribution")]
+pub use polkadot_dispute_distribution;
+
+/// Erasure coding used for Polkadot's availability system.
+#[cfg(feature = "polkadot-erasure-coding")]
+pub use polkadot_erasure_coding;
+
+/// Polkadot Gossip Support subsystem. Responsible for keeping track of session changes and
+/// issuing a connection request to the relevant validators on every new session.
+#[cfg(feature = "polkadot-gossip-support")]
+pub use polkadot_gossip_support;
+
+/// The Network Bridge Subsystem — protocol multiplexer for Polkadot.
+#[cfg(feature = "polkadot-network-bridge")]
+pub use polkadot_network_bridge;
+
+/// Collator-side subsystem that handles incoming candidate submissions from the parachain.
+#[cfg(feature = "polkadot-node-collation-generation")]
+pub use polkadot_node_collation_generation;
+
+/// Approval Voting Subsystem of the Polkadot node.
+#[cfg(feature = "polkadot-node-core-approval-voting")]
+pub use polkadot_node_core_approval_voting;
+
+/// The Availability Store subsystem. Wrapper over the DB that stores availability data and
+/// chunks.
+#[cfg(feature = "polkadot-node-core-av-store")]
+pub use polkadot_node_core_av_store;
+
+/// The Candidate Backing Subsystem. Tracks parachain candidates that can be backed, as well as
+/// the issuance of statements about candidates.
+#[cfg(feature = "polkadot-node-core-backing")]
+pub use polkadot_node_core_backing;
+
+/// Bitfield signing subsystem for the Polkadot node.
+#[cfg(feature = "polkadot-node-core-bitfield-signing")]
+pub use polkadot_node_core_bitfield_signing;
+
+/// Polkadot crate that implements the Candidate Validation subsystem. Handles requests to
+/// validate candidates according to a PVF.
+#[cfg(feature = "polkadot-node-core-candidate-validation")]
+pub use polkadot_node_core_candidate_validation;
+
+/// The Chain API subsystem provides access to chain related utility functions like block
+/// number to hash conversions.
+#[cfg(feature = "polkadot-node-core-chain-api")]
+pub use polkadot_node_core_chain_api;
+
+/// Chain Selection Subsystem.
+#[cfg(feature = "polkadot-node-core-chain-selection")]
+pub use polkadot_node_core_chain_selection;
+
+/// The node-side components that participate in disputes.
+#[cfg(feature = "polkadot-node-core-dispute-coordinator")]
+pub use polkadot_node_core_dispute_coordinator;
+
+/// Parachains inherent data provider for Polkadot node.
+#[cfg(feature = "polkadot-node-core-parachains-inherent")]
+pub use polkadot_node_core_parachains_inherent;
+
+/// The Prospective Parachains subsystem. Tracks and handles prospective parachain fragments.
+#[cfg(feature = "polkadot-node-core-prospective-parachains")]
+pub use polkadot_node_core_prospective_parachains;
+
+/// Responsible for assembling a relay chain block from a set of available parachain
+/// candidates.
+#[cfg(feature = "polkadot-node-core-provisioner")]
+pub use polkadot_node_core_provisioner;
+
+/// Polkadot crate that implements the PVF validation host. Responsible for coordinating
+/// preparation and execution of PVFs.
+#[cfg(feature = "polkadot-node-core-pvf")]
+pub use polkadot_node_core_pvf;
+
+/// Polkadot crate that implements the PVF pre-checking subsystem. Responsible for checking and
+/// voting for PVFs that are pending approval.
+#[cfg(feature = "polkadot-node-core-pvf-checker")]
+pub use polkadot_node_core_pvf_checker;
+
+/// Polkadot crate that contains functionality related to PVFs that is shared by the PVF host
+/// and the PVF workers.
+#[cfg(feature = "polkadot-node-core-pvf-common")]
+pub use polkadot_node_core_pvf_common;
+
+/// Polkadot crate that contains the logic for executing PVFs. Used by the
+/// polkadot-execute-worker binary.
+#[cfg(feature = "polkadot-node-core-pvf-execute-worker")]
+pub use polkadot_node_core_pvf_execute_worker;
+
+/// Polkadot crate that contains the logic for preparing PVFs. Used by the
+/// polkadot-prepare-worker binary.
+#[cfg(feature = "polkadot-node-core-pvf-prepare-worker")]
+pub use polkadot_node_core_pvf_prepare_worker;
+
+/// Wrapper around the parachain-related runtime APIs.
+#[cfg(feature = "polkadot-node-core-runtime-api")]
+pub use polkadot_node_core_runtime_api;
+
+/// Polkadot Jaeger primitives, but equally useful for Grafana/Tempo.
+#[cfg(feature = "polkadot-node-jaeger")]
+pub use polkadot_node_jaeger;
+
+/// Subsystem metric helpers.
+#[cfg(feature = "polkadot-node-metrics")]
+pub use polkadot_node_metrics;
+
+/// Primitives types for the Node-side.
+#[cfg(feature = "polkadot-node-network-protocol")]
+pub use polkadot_node_network_protocol;
+
+/// Primitives types for the Node-side.
+#[cfg(feature = "polkadot-node-primitives")]
+pub use polkadot_node_primitives;
+
+/// Subsystem traits and message definitions and the generated overseer.
+#[cfg(feature = "polkadot-node-subsystem")]
+pub use polkadot_node_subsystem;
+
+/// Subsystem traits and message definitions.
+#[cfg(feature = "polkadot-node-subsystem-types")]
+pub use polkadot_node_subsystem_types;
+
+/// Subsystem traits and message definitions.
+#[cfg(feature = "polkadot-node-subsystem-util")]
+pub use polkadot_node_subsystem_util;
+
+/// System overseer of the Polkadot node.
+#[cfg(feature = "polkadot-overseer")]
+pub use polkadot_overseer;
+
+/// Types and utilities for creating and working with parachains.
+#[cfg(feature = "polkadot-parachain-primitives")]
+pub use polkadot_parachain_primitives;
+
+/// Shared primitives used by Polkadot runtime.
+#[cfg(feature = "polkadot-primitives")]
+pub use polkadot_primitives;
+
+/// Polkadot specific RPC functionality.
+#[cfg(feature = "polkadot-rpc")]
+pub use polkadot_rpc;
+
+/// Pallets and constants used in Relay Chain networks.
+#[cfg(feature = "polkadot-runtime-common")]
+pub use polkadot_runtime_common;
+
+/// Runtime metric interface for the Polkadot node.
+#[cfg(feature = "polkadot-runtime-metrics")]
+pub use polkadot_runtime_metrics;
+
+/// Relay Chain runtime code responsible for Parachains.
+#[cfg(feature = "polkadot-runtime-parachains")]
+pub use polkadot_runtime_parachains;
+
+/// Experimental: The single package to get you started with building frame pallets and
+/// runtimes.
+#[cfg(feature = "polkadot-sdk-frame")]
+pub use polkadot_sdk_frame;
+
+/// Utils to tie different Polkadot components together and allow instantiation of a node.
+#[cfg(feature = "polkadot-service")]
+pub use polkadot_service;
+
+/// Statement Distribution Subsystem.
+#[cfg(feature = "polkadot-statement-distribution")]
+pub use polkadot_statement_distribution;
+
+/// Stores messages other authorities issue about candidates in Polkadot.
+#[cfg(feature = "polkadot-statement-table")]
+pub use polkadot_statement_table;
+
+/// Constants used throughout the Rococo network.
+#[cfg(feature = "rococo-runtime-constants")]
+pub use rococo_runtime_constants;
+
+/// Collection of allocator implementations.
+#[cfg(feature = "sc-allocator")]
+pub use sc_allocator;
+
+/// Substrate authority discovery.
+#[cfg(feature = "sc-authority-discovery")]
+pub use sc_authority_discovery;
+
+/// Basic implementation of block-authoring logic.
+#[cfg(feature = "sc-basic-authorship")]
+pub use sc_basic_authorship;
+
+/// Substrate block builder.
+#[cfg(feature = "sc-block-builder")]
+pub use sc_block_builder;
+
+/// Substrate chain configurations.
+#[cfg(feature = "sc-chain-spec")]
+pub use sc_chain_spec;
+
+/// Macros to derive chain spec extension traits implementation.
+#[cfg(feature = "sc-chain-spec-derive")]
+pub use sc_chain_spec_derive;
+
+/// Substrate CLI interface.
+#[cfg(feature = "sc-cli")]
+pub use sc_cli;
+
+/// Substrate client interfaces.
+#[cfg(feature = "sc-client-api")]
+pub use sc_client_api;
+
+/// Client backend that uses RocksDB database as storage.
+#[cfg(feature = "sc-client-db")]
+pub use sc_client_db;
+
+/// Collection of common consensus specific implementations for Substrate (client).
+#[cfg(feature = "sc-consensus")]
+pub use sc_consensus;
+
+/// Aura consensus algorithm for substrate.
+#[cfg(feature = "sc-consensus-aura")]
+pub use sc_consensus_aura;
+
+/// BABE consensus algorithm for substrate.
+#[cfg(feature = "sc-consensus-babe")]
+pub use sc_consensus_babe;
+
+/// RPC extensions for the BABE consensus algorithm.
+#[cfg(feature = "sc-consensus-babe-rpc")]
+pub use sc_consensus_babe_rpc;
+
+/// BEEFY Client gadget for substrate.
+#[cfg(feature = "sc-consensus-beefy")]
+pub use sc_consensus_beefy;
+
+/// RPC for the BEEFY Client gadget for substrate.
+#[cfg(feature = "sc-consensus-beefy-rpc")]
+pub use sc_consensus_beefy_rpc;
+
+/// Generic epochs-based utilities for consensus.
+#[cfg(feature = "sc-consensus-epochs")]
+pub use sc_consensus_epochs;
+
+/// Integration of the GRANDPA finality gadget into substrate.
+#[cfg(feature = "sc-consensus-grandpa")]
+pub use sc_consensus_grandpa;
+
+/// RPC extensions for the GRANDPA finality gadget.
+#[cfg(feature = "sc-consensus-grandpa-rpc")]
+pub use sc_consensus_grandpa_rpc;
+
+/// Manual sealing engine for Substrate.
+#[cfg(feature = "sc-consensus-manual-seal")]
+pub use sc_consensus_manual_seal;
+
+/// PoW consensus algorithm for substrate.
+#[cfg(feature = "sc-consensus-pow")]
+pub use sc_consensus_pow;
+
+/// Generic slots-based utilities for consensus.
+#[cfg(feature = "sc-consensus-slots")]
+pub use sc_consensus_slots;
+
+/// A crate that provides means of executing/dispatching calls into the runtime.
+#[cfg(feature = "sc-executor")]
+pub use sc_executor;
+
+/// A set of common definitions that are needed for defining execution engines.
+#[cfg(feature = "sc-executor-common")]
+pub use sc_executor_common;
+
+/// PolkaVM executor for Substrate.
+#[cfg(feature = "sc-executor-polkavm")]
+pub use sc_executor_polkavm;
+
+/// Defines a `WasmRuntime` that uses the Wasmtime JIT to execute.
+#[cfg(feature = "sc-executor-wasmtime")]
+pub use sc_executor_wasmtime;
+
+/// Substrate informant.
+#[cfg(feature = "sc-informant")]
+pub use sc_informant;
+
+/// Keystore (and session key management) for ed25519 based chains like Polkadot.
+#[cfg(feature = "sc-keystore")]
+pub use sc_keystore;
+
+/// Substrate mixnet service.
+#[cfg(feature = "sc-mixnet")]
+pub use sc_mixnet;
+
+/// Substrate network protocol.
+#[cfg(feature = "sc-network")]
+pub use sc_network;
+
+/// Substrate network common.
+#[cfg(feature = "sc-network-common")]
+pub use sc_network_common;
+
+/// Gossiping for the Substrate network protocol.
+#[cfg(feature = "sc-network-gossip")]
+pub use sc_network_gossip;
+
+/// Substrate light network protocol.
+#[cfg(feature = "sc-network-light")]
+pub use sc_network_light;
+
+/// Substrate statement protocol.
+#[cfg(feature = "sc-network-statement")]
+pub use sc_network_statement;
+
+/// Substrate sync network protocol.
+#[cfg(feature = "sc-network-sync")]
+pub use sc_network_sync;
+
+/// Substrate transaction protocol.
+#[cfg(feature = "sc-network-transactions")]
+pub use sc_network_transactions;
+
+/// Substrate network types.
+#[cfg(feature = "sc-network-types")]
+pub use sc_network_types;
+
+/// Substrate offchain workers.
+#[cfg(feature = "sc-offchain")]
+pub use sc_offchain;
+
+/// Basic metrics for block production.
+#[cfg(feature = "sc-proposer-metrics")]
+pub use sc_proposer_metrics;
+
+/// Substrate Client RPC.
+#[cfg(feature = "sc-rpc")]
+pub use sc_rpc;
+
+/// Substrate RPC interfaces.
+#[cfg(feature = "sc-rpc-api")]
+pub use sc_rpc_api;
+
+/// Substrate RPC servers.
+#[cfg(feature = "sc-rpc-server")]
+pub use sc_rpc_server;
+
+/// Substrate RPC interface v2.
+#[cfg(feature = "sc-rpc-spec-v2")]
+pub use sc_rpc_spec_v2;
+
+/// Substrate service. Starts a thread that spins up the network, client, and extrinsic pool.
+/// Manages communication between them.
+#[cfg(feature = "sc-service")]
+pub use sc_service;
+
+/// State database maintenance. Handles canonicalization and pruning in the database.
+#[cfg(feature = "sc-state-db")]
+pub use sc_state_db;
+
+/// Substrate statement store.
+#[cfg(feature = "sc-statement-store")]
+pub use sc_statement_store;
+
+/// Storage monitor service for substrate.
+#[cfg(feature = "sc-storage-monitor")]
+pub use sc_storage_monitor;
+
+/// A RPC handler to create sync states for light clients.
+#[cfg(feature = "sc-sync-state-rpc")]
+pub use sc_sync_state_rpc;
+
+/// A crate that provides basic hardware and software telemetry information.
+#[cfg(feature = "sc-sysinfo")]
+pub use sc_sysinfo;
+
+/// Telemetry utils.
+#[cfg(feature = "sc-telemetry")]
+pub use sc_telemetry;
+
+/// Instrumentation implementation for substrate.
+#[cfg(feature = "sc-tracing")]
+pub use sc_tracing;
+
+/// Helper macros for Substrate's client CLI.
+#[cfg(feature = "sc-tracing-proc-macro")]
+pub use sc_tracing_proc_macro;
+
+/// Substrate transaction pool implementation.
+#[cfg(feature = "sc-transaction-pool")]
+pub use sc_transaction_pool;
+
+/// Transaction pool client facing API.
+#[cfg(feature = "sc-transaction-pool-api")]
+pub use sc_transaction_pool_api;
+
+/// I/O for Substrate runtimes.
+#[cfg(feature = "sc-utils")]
+pub use sc_utils;
+
+/// Helper crate for generating slot ranges for the Polkadot runtime.
+#[cfg(feature = "slot-range-helper")]
+pub use slot_range_helper;
+
+/// Snowbridge Beacon Primitives.
+#[cfg(feature = "snowbridge-beacon-primitives")]
+pub use snowbridge_beacon_primitives;
+
+/// Snowbridge Core.
+#[cfg(feature = "snowbridge-core")]
+pub use snowbridge_core;
+
+/// Snowbridge Ethereum.
+#[cfg(feature = "snowbridge-ethereum")]
+pub use snowbridge_ethereum;
+
+/// Snowbridge Outbound Queue Merkle Tree.
+#[cfg(feature = "snowbridge-outbound-queue-merkle-tree")]
+pub use snowbridge_outbound_queue_merkle_tree;
+
+/// Snowbridge Outbound Queue Runtime API.
+#[cfg(feature = "snowbridge-outbound-queue-runtime-api")]
+pub use snowbridge_outbound_queue_runtime_api;
+
+/// Snowbridge Ethereum Client Pallet.
+#[cfg(feature = "snowbridge-pallet-ethereum-client")]
+pub use snowbridge_pallet_ethereum_client;
+
+/// Snowbridge Ethereum Client Test Fixtures.
+#[cfg(feature = "snowbridge-pallet-ethereum-client-fixtures")]
+pub use snowbridge_pallet_ethereum_client_fixtures;
+
+/// Snowbridge Inbound Queue Pallet.
+#[cfg(feature = "snowbridge-pallet-inbound-queue")]
+pub use snowbridge_pallet_inbound_queue;
+
+/// Snowbridge Inbound Queue Test Fixtures.
+#[cfg(feature = "snowbridge-pallet-inbound-queue-fixtures")]
+pub use snowbridge_pallet_inbound_queue_fixtures;
+
+/// Snowbridge Outbound Queue Pallet.
+#[cfg(feature = "snowbridge-pallet-outbound-queue")]
+pub use snowbridge_pallet_outbound_queue;
+
+/// Snowbridge System Pallet.
+#[cfg(feature = "snowbridge-pallet-system")]
+pub use snowbridge_pallet_system;
+
+/// Snowbridge Router Primitives.
+#[cfg(feature = "snowbridge-router-primitives")]
+pub use snowbridge_router_primitives;
+
+/// Snowbridge Runtime Common.
+#[cfg(feature = "snowbridge-runtime-common")]
+pub use snowbridge_runtime_common;
+
+/// Snowbridge Runtime Tests.
+#[cfg(feature = "snowbridge-runtime-test-common")]
+pub use snowbridge_runtime_test_common;
+
+/// Snowbridge System Runtime API.
+#[cfg(feature = "snowbridge-system-runtime-api")]
+pub use snowbridge_system_runtime_api;
+
+/// Substrate runtime api primitives.
+#[cfg(feature = "sp-api")]
+pub use sp_api;
+
+/// Macros for declaring and implementing runtime apis.
+#[cfg(feature = "sp-api-proc-macro")]
+pub use sp_api_proc_macro;
+
+/// Provides facilities for generating application specific crypto wrapper types.
+#[cfg(feature = "sp-application-crypto")]
+pub use sp_application_crypto;
+
+/// Minimal fixed point arithmetic primitives and types for runtime.
+#[cfg(feature = "sp-arithmetic")]
+pub use sp_arithmetic;
+
+/// Authority discovery primitives.
+#[cfg(feature = "sp-authority-discovery")]
+pub use sp_authority_discovery;
+
+/// The block builder runtime api.
+#[cfg(feature = "sp-block-builder")]
+pub use sp_block_builder;
+
+/// Substrate blockchain traits and primitives.
+#[cfg(feature = "sp-blockchain")]
+pub use sp_blockchain;
+
+/// Common utilities for building and using consensus engines in substrate.
+#[cfg(feature = "sp-consensus")]
+pub use sp_consensus;
+
+/// Primitives for Aura consensus.
+#[cfg(feature = "sp-consensus-aura")]
+pub use sp_consensus_aura;
+
+/// Primitives for BABE consensus.
+#[cfg(feature = "sp-consensus-babe")]
+pub use sp_consensus_babe;
+
+/// Primitives for BEEFY protocol.
+#[cfg(feature = "sp-consensus-beefy")]
+pub use sp_consensus_beefy;
+
+/// Primitives for GRANDPA integration, suitable for WASM compilation.
+#[cfg(feature = "sp-consensus-grandpa")]
+pub use sp_consensus_grandpa;
+
+/// Primitives for Aura consensus.
+#[cfg(feature = "sp-consensus-pow")]
+pub use sp_consensus_pow;
+
+/// Primitives for slots-based consensus.
+#[cfg(feature = "sp-consensus-slots")]
+pub use sp_consensus_slots;
+
+/// Shareable Substrate types.
+#[cfg(feature = "sp-core")]
+pub use sp_core;
+
+/// Hashing primitives (deprecated: use sp-crypto-hashing for new applications).
+#[cfg(feature = "sp-core-hashing")]
+pub use sp_core_hashing;
+
+/// Procedural macros for calculating static hashes (deprecated in favor of
+/// `sp-crypto-hashing-proc-macro`).
+#[cfg(feature = "sp-core-hashing-proc-macro")]
+pub use sp_core_hashing_proc_macro;
+
+/// Host functions for common Arkworks elliptic curve operations.
+#[cfg(feature = "sp-crypto-ec-utils")]
+pub use sp_crypto_ec_utils;
+
+/// Hashing primitives.
+#[cfg(feature = "sp-crypto-hashing")]
+pub use sp_crypto_hashing;
+
+/// Procedural macros for calculating static hashes.
+#[cfg(feature = "sp-crypto-hashing-proc-macro")]
+pub use sp_crypto_hashing_proc_macro;
+
+/// Substrate database trait.
+#[cfg(feature = "sp-database")]
+pub use sp_database;
+
+/// Macros to derive runtime debug implementation.
+#[cfg(feature = "sp-debug-derive")]
+pub use sp_debug_derive;
+
+/// Substrate externalities abstraction.
+#[cfg(feature = "sp-externalities")]
+pub use sp_externalities;
+
+/// Substrate RuntimeGenesisConfig builder API.
+#[cfg(feature = "sp-genesis-builder")]
+pub use sp_genesis_builder;
+
+/// Provides types and traits for creating and checking inherents.
+#[cfg(feature = "sp-inherents")]
+pub use sp_inherents;
+
+/// I/O for Substrate runtimes.
+#[cfg(feature = "sp-io")]
+pub use sp_io;
+
+/// Keyring support code for the runtime. A set of test accounts.
+#[cfg(feature = "sp-keyring")]
+pub use sp_keyring;
+
+/// Keystore primitives.
+#[cfg(feature = "sp-keystore")]
+pub use sp_keystore;
+
+/// Handling of blobs, usually Wasm code, which may be compressed.
+#[cfg(feature = "sp-maybe-compressed-blob")]
+pub use sp_maybe_compressed_blob;
+
+/// Intermediate representation of the runtime metadata.
+#[cfg(feature = "sp-metadata-ir")]
+pub use sp_metadata_ir;
+
+/// Substrate mixnet types and runtime interface.
+#[cfg(feature = "sp-mixnet")]
+pub use sp_mixnet;
+
+/// Merkle Mountain Range primitives.
+#[cfg(feature = "sp-mmr-primitives")]
+pub use sp_mmr_primitives;
+
+/// NPoS election algorithm primitives.
+#[cfg(feature = "sp-npos-elections")]
+pub use sp_npos_elections;
+
+/// Substrate offchain workers primitives.
+#[cfg(feature = "sp-offchain")]
+pub use sp_offchain;
+
+/// Custom panic hook with bug report link.
+#[cfg(feature = "sp-panic-handler")]
+pub use sp_panic_handler;
+
+/// Substrate RPC primitives and utilities.
+#[cfg(feature = "sp-rpc")]
+pub use sp_rpc;
+
+/// Runtime Modules shared primitive types.
+#[cfg(feature = "sp-runtime")]
+pub use sp_runtime;
+
+/// Substrate runtime interface.
+#[cfg(feature = "sp-runtime-interface")]
+pub use sp_runtime_interface;
+
+/// This crate provides procedural macros for usage within the context of the Substrate runtime
+/// interface.
+#[cfg(feature = "sp-runtime-interface-proc-macro")]
+pub use sp_runtime_interface_proc_macro;
+
+/// Primitives for sessions.
+#[cfg(feature = "sp-session")]
+pub use sp_session;
+
+/// A crate which contains primitives that are useful for implementation that uses staking
+/// approaches in general. Definitions related to sessions, slashing, etc go here.
+#[cfg(feature = "sp-staking")]
+pub use sp_staking;
+
+/// Substrate State Machine.
+#[cfg(feature = "sp-state-machine")]
+pub use sp_state_machine;
+
+/// A crate which contains primitives related to the statement store.
+#[cfg(feature = "sp-statement-store")]
+pub use sp_statement_store;
+
+/// Lowest-abstraction level for the Substrate runtime: just exports useful primitives from std
+/// or client/alloc to be used with any code that depends on the runtime.
+#[cfg(feature = "sp-std")]
+pub use sp_std;
+
+/// Storage related primitives.
+#[cfg(feature = "sp-storage")]
+pub use sp_storage;
+
+/// Substrate core types and inherents for timestamps.
+#[cfg(feature = "sp-timestamp")]
+pub use sp_timestamp;
+
+/// Instrumentation primitives and macros for Substrate.
+#[cfg(feature = "sp-tracing")]
+pub use sp_tracing;
+
+/// Transaction pool runtime facing API.
+#[cfg(feature = "sp-transaction-pool")]
+pub use sp_transaction_pool;
+
+/// Transaction storage proof primitives.
+#[cfg(feature = "sp-transaction-storage-proof")]
+pub use sp_transaction_storage_proof;
+
+/// Patricia trie stuff using a parity-scale-codec node format.
+#[cfg(feature = "sp-trie")]
+pub use sp_trie;
+
+/// Version module for the Substrate runtime; Provides a function that returns the runtime
+/// version.
+#[cfg(feature = "sp-version")]
+pub use sp_version;
+
+/// Macro for defining a runtime version.
+#[cfg(feature = "sp-version-proc-macro")]
+pub use sp_version_proc_macro;
+
+/// Types and traits for interfacing between the host and the wasm runtime.
+#[cfg(feature = "sp-wasm-interface")]
+pub use sp_wasm_interface;
+
+/// Types and traits for interfacing between the host and the wasm runtime.
+#[cfg(feature = "sp-weights")]
+pub use sp_weights;
+
+/// Utility for building chain-specification files for Substrate-based runtimes based on
+/// `sp-genesis-builder`.
+#[cfg(feature = "staging-chain-spec-builder")]
+pub use staging_chain_spec_builder;
+
+/// Substrate node block inspection tool.
+#[cfg(feature = "staging-node-inspect")]
+pub use staging_node_inspect;
+
+/// Pallet to store the parachain ID.
+#[cfg(feature = "staging-parachain-info")]
+pub use staging_parachain_info;
+
+/// Tracking allocator to control the amount of memory consumed by the process.
+#[cfg(feature = "staging-tracking-allocator")]
+pub use staging_tracking_allocator;
+
+/// The basic XCM datastructures.
+#[cfg(feature = "staging-xcm")]
+pub use staging_xcm;
+
+/// Tools & types for building with XCM and its executor.
+#[cfg(feature = "staging-xcm-builder")]
+pub use staging_xcm_builder;
+
+/// An abstract and configurable XCM message executor.
+#[cfg(feature = "staging-xcm-executor")]
+pub use staging_xcm_executor;
+
+/// Generate and restore keys for Substrate based chains such as Polkadot, Kusama and a growing
+/// number of parachains and Substrate based projects.
+#[cfg(feature = "subkey")]
+pub use subkey;
+
+/// Converting BIP39 entropy to valid Substrate (sr25519) SecretKeys.
+#[cfg(feature = "substrate-bip39")]
+pub use substrate_bip39;
+
+/// Crate with utility functions for `build.rs` scripts.
+#[cfg(feature = "substrate-build-script-utils")]
+pub use substrate_build_script_utils;
+
+/// Substrate RPC for FRAME's support.
+#[cfg(feature = "substrate-frame-rpc-support")]
+pub use substrate_frame_rpc_support;
+
+/// FRAME's system exposed over Substrate RPC.
+#[cfg(feature = "substrate-frame-rpc-system")]
+pub use substrate_frame_rpc_system;
+
+/// Endpoint to expose Prometheus metrics.
+#[cfg(feature = "substrate-prometheus-endpoint")]
+pub use substrate_prometheus_endpoint;
+
+/// Shared JSON-RPC client.
+#[cfg(feature = "substrate-rpc-client")]
+pub use substrate_rpc_client;
+
+/// Node-specific RPC methods for interaction with state trie migration.
+#[cfg(feature = "substrate-state-trie-migration-rpc")]
+pub use substrate_state_trie_migration_rpc;
+
+/// Utility for building WASM binaries.
+#[cfg(feature = "substrate-wasm-builder")]
+pub use substrate_wasm_builder;
+
+/// Common constants for Testnet Parachains runtimes.
+#[cfg(feature = "testnet-parachains-constants")]
+pub use testnet_parachains_constants;
+
+/// Stick logs together with the TraceID as provided by tempo.
+#[cfg(feature = "tracing-gum")]
+pub use tracing_gum;
+
+/// Generate an overseer including builder pattern and message wrapper from a single annotated
+/// struct definition.
+#[cfg(feature = "tracing-gum-proc-macro")]
+pub use tracing_gum_proc_macro;
+
+/// Constants used throughout the Westend network.
+#[cfg(feature = "westend-runtime-constants")]
+pub use westend_runtime_constants;
+
+/// Test kit to emulate XCM program execution.
+#[cfg(feature = "xcm-emulator")]
+pub use xcm_emulator;
+
+/// XCM fee payment runtime API.
+#[cfg(feature = "xcm-fee-payment-runtime-api")]
+pub use xcm_fee_payment_runtime_api;
+
+/// Procedural macros for XCM.
+#[cfg(feature = "xcm-procedural")]
+pub use xcm_procedural;
+
+/// Test kit to simulate cross-chain message passing and XCM execution.
+#[cfg(feature = "xcm-simulator")]
+pub use xcm_simulator;